diff --git a/dbtesterpb/config_analyze_machine.pb.go b/dbtesterpb/config_analyze_machine.pb.go new file mode 100644 index 00000000..fd6b8d7e --- /dev/null +++ b/dbtesterpb/config_analyze_machine.pb.go @@ -0,0 +1,1863 @@ +// Code generated by protoc-gen-gogo. +// source: dbtesterpb/config_analyze_machine.proto +// DO NOT EDIT! + +/* + Package dbtesterpb is a generated protocol buffer package. + + It is generated from these files: + dbtesterpb/config_analyze_machine.proto + dbtesterpb/config_client_machine.proto + dbtesterpb/database_id.proto + dbtesterpb/flag_cetcd.proto + dbtesterpb/flag_consul.proto + dbtesterpb/flag_etcd.proto + dbtesterpb/flag_zetcd.proto + dbtesterpb/flag_zookeeper.proto + dbtesterpb/message.proto + + It has these top-level messages: + ConfigAnalyzeMachineInitial + ConfigAnalyzeMachineAllAggregatedOutput + ConfigAnalyzeMachinePlot + ConfigAnalyzeMachineImage + ConfigAnalyzeMachineREADME + ConfigClientMachineInitial + ConfigClientMachineBenchmarkOptions + ConfigClientMachineBenchmarkSteps + ConfigClientMachineAgentControl + Flag_Cetcd_Beta + Flag_Consul_V0_7_5 + Flag_Consul_V0_8_0 + Flag_Etcd_V2_3 + Flag_Etcd_V3_1 + Flag_Etcd_V3_2 + Flag_Etcd_Tip + Flag_Zetcd_Beta + Flag_Zookeeper_R3_4_9 + Flag_Zookeeper_R3_5_2Alpha + Request + Response +*/ +package dbtesterpb + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" +import _ "github.com/gogo/protobuf/gogoproto" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package + +// ConfigAnalyzeMachineInitial represents common control options and test data information for analyzer machine. +type ConfigAnalyzeMachineInitial struct { + DatabaseID string `protobuf:"bytes,1,opt,name=DatabaseID,proto3" json:"DatabaseID,omitempty"` + DatabaseTag string `protobuf:"bytes,2,opt,name=DatabaseTag,proto3" json:"DatabaseTag,omitempty"` + DatabaseDescription string `protobuf:"bytes,3,opt,name=DatabaseDescription,proto3" json:"DatabaseDescription,omitempty"` + PathPrefix string `protobuf:"bytes,4,opt,name=PathPrefix,proto3" json:"PathPrefix,omitempty" yaml:"path_prefix"` + ClientSystemMetricsInterpolatedPath string `protobuf:"bytes,5,opt,name=ClientSystemMetricsInterpolatedPath,proto3" json:"ClientSystemMetricsInterpolatedPath,omitempty" yaml:"client_system_metrics_interpolated_path"` + ClientLatencyThroughputTimeseriesPath string `protobuf:"bytes,6,opt,name=ClientLatencyThroughputTimeseriesPath,proto3" json:"ClientLatencyThroughputTimeseriesPath,omitempty" yaml:"client_latency_throughput_timeseries_path"` + ClientLatencyDistributionAllPath string `protobuf:"bytes,7,opt,name=ClientLatencyDistributionAllPath,proto3" json:"ClientLatencyDistributionAllPath,omitempty" yaml:"client_latency_distribution_all_path"` + ClientLatencyDistributionPercentilePath string `protobuf:"bytes,8,opt,name=ClientLatencyDistributionPercentilePath,proto3" json:"ClientLatencyDistributionPercentilePath,omitempty" yaml:"client_latency_distribution_percentile_path"` + ClientLatencyDistributionSummaryPath string `protobuf:"bytes,9,opt,name=ClientLatencyDistributionSummaryPath,proto3" json:"ClientLatencyDistributionSummaryPath,omitempty" yaml:"client_latency_distribution_summary_path"` + ClientLatencyByKeyNumberPath string `protobuf:"bytes,10,opt,name=ClientLatencyByKeyNumberPath,proto3" json:"ClientLatencyByKeyNumberPath,omitempty" yaml:"client_latency_by_key_number_path"` + ServerDiskSpaceUsageSummaryPath string `protobuf:"bytes,11,opt,name=ServerDiskSpaceUsageSummaryPath,proto3" json:"ServerDiskSpaceUsageSummaryPath,omitempty" yaml:"server_disk_space_usage_summary_path"` + ServerMemoryByKeyNumberPath string `protobuf:"bytes,12,opt,name=ServerMemoryByKeyNumberPath,proto3" json:"ServerMemoryByKeyNumberPath,omitempty" yaml:"server_memory_by_key_number_path"` + ServerReadBytesDeltaByKeyNumberPath string `protobuf:"bytes,13,opt,name=ServerReadBytesDeltaByKeyNumberPath,proto3" json:"ServerReadBytesDeltaByKeyNumberPath,omitempty" yaml:"server_read_bytes_delta_by_key_number_path"` + ServerWriteBytesDeltaByKeyNumberPath string `protobuf:"bytes,14,opt,name=ServerWriteBytesDeltaByKeyNumberPath,proto3" json:"ServerWriteBytesDeltaByKeyNumberPath,omitempty" yaml:"server_write_bytes_delta_by_key_number_path"` + ServerSystemMetricsInterpolatedPathList []string `protobuf:"bytes,15,rep,name=ServerSystemMetricsInterpolatedPathList" json:"ServerSystemMetricsInterpolatedPathList,omitempty" yaml:"server_system_metrics_interpolated_path_list"` + AllAggregatedOutputPath string `protobuf:"bytes,16,opt,name=AllAggregatedOutputPath,proto3" json:"AllAggregatedOutputPath,omitempty" yaml:"all_aggregated_output_path"` +} + +func (m *ConfigAnalyzeMachineInitial) Reset() { *m = ConfigAnalyzeMachineInitial{} } +func (m *ConfigAnalyzeMachineInitial) String() string { return proto.CompactTextString(m) } +func (*ConfigAnalyzeMachineInitial) ProtoMessage() {} +func (*ConfigAnalyzeMachineInitial) Descriptor() ([]byte, []int) { + return fileDescriptorConfigAnalyzeMachine, []int{0} +} + +type ConfigAnalyzeMachineAllAggregatedOutput struct { + AllAggregatedOutputPathCSV string `protobuf:"bytes,1,opt,name=AllAggregatedOutputPathCSV,proto3" json:"AllAggregatedOutputPathCSV,omitempty" yaml:"all_aggregated_output_path_csv"` + AllAggregatedOutputPathTXT string `protobuf:"bytes,2,opt,name=AllAggregatedOutputPathTXT,proto3" json:"AllAggregatedOutputPathTXT,omitempty" yaml:"all_aggregated_output_path_txt"` +} + +func (m *ConfigAnalyzeMachineAllAggregatedOutput) Reset() { + *m = ConfigAnalyzeMachineAllAggregatedOutput{} +} +func (m *ConfigAnalyzeMachineAllAggregatedOutput) String() string { return proto.CompactTextString(m) } +func (*ConfigAnalyzeMachineAllAggregatedOutput) ProtoMessage() {} +func (*ConfigAnalyzeMachineAllAggregatedOutput) Descriptor() ([]byte, []int) { + return fileDescriptorConfigAnalyzeMachine, []int{1} +} + +// ConfigAnalyzeMachinePlot defines plot configuration. +type ConfigAnalyzeMachinePlot struct { + Column string `protobuf:"bytes,1,opt,name=Column,proto3" json:"Column,omitempty" yaml:"column"` + XAxis string `protobuf:"bytes,2,opt,name=XAxis,proto3" json:"XAxis,omitempty" yaml:"x_axis"` + YAxis string `protobuf:"bytes,3,opt,name=YAxis,proto3" json:"YAxis,omitempty" yaml:"y_axis"` + OutputPathCSV string `protobuf:"bytes,4,opt,name=OutputPathCSV,proto3" json:"OutputPathCSV,omitempty" yaml:"output_path_csv"` + OutputPathList []string `protobuf:"bytes,5,rep,name=OutputPathList" json:"OutputPathList,omitempty" yaml:"output_path_list"` +} + +func (m *ConfigAnalyzeMachinePlot) Reset() { *m = ConfigAnalyzeMachinePlot{} } +func (m *ConfigAnalyzeMachinePlot) String() string { return proto.CompactTextString(m) } +func (*ConfigAnalyzeMachinePlot) ProtoMessage() {} +func (*ConfigAnalyzeMachinePlot) Descriptor() ([]byte, []int) { + return fileDescriptorConfigAnalyzeMachine, []int{2} +} + +// ConfigAnalyzeMachineImage defines image configuration. +type ConfigAnalyzeMachineImage struct { + Title string `protobuf:"bytes,1,opt,name=Title,proto3" json:"Title,omitempty" yaml:"title"` + Path string `protobuf:"bytes,2,opt,name=Path,proto3" json:"Path,omitempty" yaml:"path"` + Type string `protobuf:"bytes,3,opt,name=Type,proto3" json:"Type,omitempty" yaml:"type"` +} + +func (m *ConfigAnalyzeMachineImage) Reset() { *m = ConfigAnalyzeMachineImage{} } +func (m *ConfigAnalyzeMachineImage) String() string { return proto.CompactTextString(m) } +func (*ConfigAnalyzeMachineImage) ProtoMessage() {} +func (*ConfigAnalyzeMachineImage) Descriptor() ([]byte, []int) { + return fileDescriptorConfigAnalyzeMachine, []int{3} +} + +// ConfigAnalyzeMachineREADME defines read configuration. +type ConfigAnalyzeMachineREADME struct { + OutputPath string `protobuf:"bytes,1,opt,name=OutputPath,proto3" json:"OutputPath,omitempty" yaml:"output_path"` + Images []*ConfigAnalyzeMachineImage `protobuf:"bytes,2,rep,name=Images" json:"Images,omitempty" yaml:"images"` +} + +func (m *ConfigAnalyzeMachineREADME) Reset() { *m = ConfigAnalyzeMachineREADME{} } +func (m *ConfigAnalyzeMachineREADME) String() string { return proto.CompactTextString(m) } +func (*ConfigAnalyzeMachineREADME) ProtoMessage() {} +func (*ConfigAnalyzeMachineREADME) Descriptor() ([]byte, []int) { + return fileDescriptorConfigAnalyzeMachine, []int{4} +} + +func init() { + proto.RegisterType((*ConfigAnalyzeMachineInitial)(nil), "dbtesterpb.ConfigAnalyzeMachineInitial") + proto.RegisterType((*ConfigAnalyzeMachineAllAggregatedOutput)(nil), "dbtesterpb.ConfigAnalyzeMachineAllAggregatedOutput") + proto.RegisterType((*ConfigAnalyzeMachinePlot)(nil), "dbtesterpb.ConfigAnalyzeMachinePlot") + proto.RegisterType((*ConfigAnalyzeMachineImage)(nil), "dbtesterpb.ConfigAnalyzeMachineImage") + proto.RegisterType((*ConfigAnalyzeMachineREADME)(nil), "dbtesterpb.ConfigAnalyzeMachineREADME") +} +func (m *ConfigAnalyzeMachineInitial) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ConfigAnalyzeMachineInitial) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.DatabaseID) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.DatabaseID))) + i += copy(dAtA[i:], m.DatabaseID) + } + if len(m.DatabaseTag) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.DatabaseTag))) + i += copy(dAtA[i:], m.DatabaseTag) + } + if len(m.DatabaseDescription) > 0 { + dAtA[i] = 0x1a + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.DatabaseDescription))) + i += copy(dAtA[i:], m.DatabaseDescription) + } + if len(m.PathPrefix) > 0 { + dAtA[i] = 0x22 + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.PathPrefix))) + i += copy(dAtA[i:], m.PathPrefix) + } + if len(m.ClientSystemMetricsInterpolatedPath) > 0 { + dAtA[i] = 0x2a + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.ClientSystemMetricsInterpolatedPath))) + i += copy(dAtA[i:], m.ClientSystemMetricsInterpolatedPath) + } + if len(m.ClientLatencyThroughputTimeseriesPath) > 0 { + dAtA[i] = 0x32 + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.ClientLatencyThroughputTimeseriesPath))) + i += copy(dAtA[i:], m.ClientLatencyThroughputTimeseriesPath) + } + if len(m.ClientLatencyDistributionAllPath) > 0 { + dAtA[i] = 0x3a + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.ClientLatencyDistributionAllPath))) + i += copy(dAtA[i:], m.ClientLatencyDistributionAllPath) + } + if len(m.ClientLatencyDistributionPercentilePath) > 0 { + dAtA[i] = 0x42 + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.ClientLatencyDistributionPercentilePath))) + i += copy(dAtA[i:], m.ClientLatencyDistributionPercentilePath) + } + if len(m.ClientLatencyDistributionSummaryPath) > 0 { + dAtA[i] = 0x4a + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.ClientLatencyDistributionSummaryPath))) + i += copy(dAtA[i:], m.ClientLatencyDistributionSummaryPath) + } + if len(m.ClientLatencyByKeyNumberPath) > 0 { + dAtA[i] = 0x52 + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.ClientLatencyByKeyNumberPath))) + i += copy(dAtA[i:], m.ClientLatencyByKeyNumberPath) + } + if len(m.ServerDiskSpaceUsageSummaryPath) > 0 { + dAtA[i] = 0x5a + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.ServerDiskSpaceUsageSummaryPath))) + i += copy(dAtA[i:], m.ServerDiskSpaceUsageSummaryPath) + } + if len(m.ServerMemoryByKeyNumberPath) > 0 { + dAtA[i] = 0x62 + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.ServerMemoryByKeyNumberPath))) + i += copy(dAtA[i:], m.ServerMemoryByKeyNumberPath) + } + if len(m.ServerReadBytesDeltaByKeyNumberPath) > 0 { + dAtA[i] = 0x6a + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.ServerReadBytesDeltaByKeyNumberPath))) + i += copy(dAtA[i:], m.ServerReadBytesDeltaByKeyNumberPath) + } + if len(m.ServerWriteBytesDeltaByKeyNumberPath) > 0 { + dAtA[i] = 0x72 + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.ServerWriteBytesDeltaByKeyNumberPath))) + i += copy(dAtA[i:], m.ServerWriteBytesDeltaByKeyNumberPath) + } + if len(m.ServerSystemMetricsInterpolatedPathList) > 0 { + for _, s := range m.ServerSystemMetricsInterpolatedPathList { + dAtA[i] = 0x7a + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if len(m.AllAggregatedOutputPath) > 0 { + dAtA[i] = 0x82 + i++ + dAtA[i] = 0x1 + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.AllAggregatedOutputPath))) + i += copy(dAtA[i:], m.AllAggregatedOutputPath) + } + return i, nil +} + +func (m *ConfigAnalyzeMachineAllAggregatedOutput) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ConfigAnalyzeMachineAllAggregatedOutput) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.AllAggregatedOutputPathCSV) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.AllAggregatedOutputPathCSV))) + i += copy(dAtA[i:], m.AllAggregatedOutputPathCSV) + } + if len(m.AllAggregatedOutputPathTXT) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.AllAggregatedOutputPathTXT))) + i += copy(dAtA[i:], m.AllAggregatedOutputPathTXT) + } + return i, nil +} + +func (m *ConfigAnalyzeMachinePlot) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ConfigAnalyzeMachinePlot) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Column) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.Column))) + i += copy(dAtA[i:], m.Column) + } + if len(m.XAxis) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.XAxis))) + i += copy(dAtA[i:], m.XAxis) + } + if len(m.YAxis) > 0 { + dAtA[i] = 0x1a + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.YAxis))) + i += copy(dAtA[i:], m.YAxis) + } + if len(m.OutputPathCSV) > 0 { + dAtA[i] = 0x22 + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.OutputPathCSV))) + i += copy(dAtA[i:], m.OutputPathCSV) + } + if len(m.OutputPathList) > 0 { + for _, s := range m.OutputPathList { + dAtA[i] = 0x2a + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + return i, nil +} + +func (m *ConfigAnalyzeMachineImage) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ConfigAnalyzeMachineImage) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Title) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.Title))) + i += copy(dAtA[i:], m.Title) + } + if len(m.Path) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.Path))) + i += copy(dAtA[i:], m.Path) + } + if len(m.Type) > 0 { + dAtA[i] = 0x1a + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.Type))) + i += copy(dAtA[i:], m.Type) + } + return i, nil +} + +func (m *ConfigAnalyzeMachineREADME) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ConfigAnalyzeMachineREADME) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.OutputPath) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(len(m.OutputPath))) + i += copy(dAtA[i:], m.OutputPath) + } + if len(m.Images) > 0 { + for _, msg := range m.Images { + dAtA[i] = 0x12 + i++ + i = encodeVarintConfigAnalyzeMachine(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + return i, nil +} + +func encodeFixed64ConfigAnalyzeMachine(dAtA []byte, offset int, v uint64) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) + dAtA[offset+4] = uint8(v >> 32) + dAtA[offset+5] = uint8(v >> 40) + dAtA[offset+6] = uint8(v >> 48) + dAtA[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32ConfigAnalyzeMachine(dAtA []byte, offset int, v uint32) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintConfigAnalyzeMachine(dAtA []byte, offset int, v uint64) int { + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return offset + 1 +} +func (m *ConfigAnalyzeMachineInitial) Size() (n int) { + var l int + _ = l + l = len(m.DatabaseID) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + l = len(m.DatabaseTag) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + l = len(m.DatabaseDescription) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + l = len(m.PathPrefix) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + l = len(m.ClientSystemMetricsInterpolatedPath) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + l = len(m.ClientLatencyThroughputTimeseriesPath) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + l = len(m.ClientLatencyDistributionAllPath) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + l = len(m.ClientLatencyDistributionPercentilePath) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + l = len(m.ClientLatencyDistributionSummaryPath) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + l = len(m.ClientLatencyByKeyNumberPath) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + l = len(m.ServerDiskSpaceUsageSummaryPath) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + l = len(m.ServerMemoryByKeyNumberPath) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + l = len(m.ServerReadBytesDeltaByKeyNumberPath) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + l = len(m.ServerWriteBytesDeltaByKeyNumberPath) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + if len(m.ServerSystemMetricsInterpolatedPathList) > 0 { + for _, s := range m.ServerSystemMetricsInterpolatedPathList { + l = len(s) + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + } + l = len(m.AllAggregatedOutputPath) + if l > 0 { + n += 2 + l + sovConfigAnalyzeMachine(uint64(l)) + } + return n +} + +func (m *ConfigAnalyzeMachineAllAggregatedOutput) Size() (n int) { + var l int + _ = l + l = len(m.AllAggregatedOutputPathCSV) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + l = len(m.AllAggregatedOutputPathTXT) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + return n +} + +func (m *ConfigAnalyzeMachinePlot) Size() (n int) { + var l int + _ = l + l = len(m.Column) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + l = len(m.XAxis) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + l = len(m.YAxis) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + l = len(m.OutputPathCSV) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + if len(m.OutputPathList) > 0 { + for _, s := range m.OutputPathList { + l = len(s) + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + } + return n +} + +func (m *ConfigAnalyzeMachineImage) Size() (n int) { + var l int + _ = l + l = len(m.Title) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + l = len(m.Path) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + l = len(m.Type) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + return n +} + +func (m *ConfigAnalyzeMachineREADME) Size() (n int) { + var l int + _ = l + l = len(m.OutputPath) + if l > 0 { + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + if len(m.Images) > 0 { + for _, e := range m.Images { + l = e.Size() + n += 1 + l + sovConfigAnalyzeMachine(uint64(l)) + } + } + return n +} + +func sovConfigAnalyzeMachine(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozConfigAnalyzeMachine(x uint64) (n int) { + return sovConfigAnalyzeMachine(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *ConfigAnalyzeMachineInitial) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ConfigAnalyzeMachineInitial: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConfigAnalyzeMachineInitial: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DatabaseID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DatabaseID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DatabaseTag", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DatabaseTag = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DatabaseDescription", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DatabaseDescription = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PathPrefix", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PathPrefix = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientSystemMetricsInterpolatedPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientSystemMetricsInterpolatedPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientLatencyThroughputTimeseriesPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientLatencyThroughputTimeseriesPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientLatencyDistributionAllPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientLatencyDistributionAllPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientLatencyDistributionPercentilePath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientLatencyDistributionPercentilePath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientLatencyDistributionSummaryPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientLatencyDistributionSummaryPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientLatencyByKeyNumberPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientLatencyByKeyNumberPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ServerDiskSpaceUsageSummaryPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ServerDiskSpaceUsageSummaryPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ServerMemoryByKeyNumberPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ServerMemoryByKeyNumberPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ServerReadBytesDeltaByKeyNumberPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ServerReadBytesDeltaByKeyNumberPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ServerWriteBytesDeltaByKeyNumberPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ServerWriteBytesDeltaByKeyNumberPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ServerSystemMetricsInterpolatedPathList", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ServerSystemMetricsInterpolatedPathList = append(m.ServerSystemMetricsInterpolatedPathList, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AllAggregatedOutputPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AllAggregatedOutputPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipConfigAnalyzeMachine(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ConfigAnalyzeMachineAllAggregatedOutput) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ConfigAnalyzeMachineAllAggregatedOutput: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConfigAnalyzeMachineAllAggregatedOutput: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AllAggregatedOutputPathCSV", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AllAggregatedOutputPathCSV = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AllAggregatedOutputPathTXT", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AllAggregatedOutputPathTXT = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipConfigAnalyzeMachine(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ConfigAnalyzeMachinePlot) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ConfigAnalyzeMachinePlot: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConfigAnalyzeMachinePlot: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Column", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Column = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field XAxis", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.XAxis = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field YAxis", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.YAxis = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OutputPathCSV", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OutputPathCSV = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OutputPathList", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OutputPathList = append(m.OutputPathList, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipConfigAnalyzeMachine(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ConfigAnalyzeMachineImage) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ConfigAnalyzeMachineImage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConfigAnalyzeMachineImage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Title = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Path = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipConfigAnalyzeMachine(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ConfigAnalyzeMachineREADME) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ConfigAnalyzeMachineREADME: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConfigAnalyzeMachineREADME: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OutputPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OutputPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Images", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Images = append(m.Images, &ConfigAnalyzeMachineImage{}) + if err := m.Images[len(m.Images)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipConfigAnalyzeMachine(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthConfigAnalyzeMachine + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipConfigAnalyzeMachine(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthConfigAnalyzeMachine + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowConfigAnalyzeMachine + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipConfigAnalyzeMachine(dAtA[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthConfigAnalyzeMachine = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowConfigAnalyzeMachine = fmt.Errorf("proto: integer overflow") +) + +func init() { + proto.RegisterFile("dbtesterpb/config_analyze_machine.proto", fileDescriptorConfigAnalyzeMachine) +} + +var fileDescriptorConfigAnalyzeMachine = []byte{ + // 999 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x56, 0xcf, 0x6e, 0xdc, 0x44, + 0x18, 0xaf, 0x9b, 0x26, 0x90, 0x49, 0xd3, 0x96, 0x01, 0xb5, 0x4b, 0x82, 0xd6, 0xc1, 0x69, 0x48, + 0xaa, 0x42, 0x52, 0x12, 0x28, 0x12, 0x27, 0x76, 0xb3, 0x3d, 0x44, 0x34, 0x10, 0x39, 0x0b, 0x84, + 0xd3, 0x68, 0xec, 0x9d, 0x78, 0x47, 0xf1, 0x3f, 0x79, 0xc6, 0x65, 0x0d, 0x57, 0x24, 0x24, 0x24, + 0x24, 0xb8, 0x71, 0xe2, 0xc8, 0xb3, 0xf4, 0xc8, 0x13, 0x18, 0x08, 0x6f, 0xe0, 0x17, 0xa0, 0x9a, + 0x6f, 0x9c, 0xc4, 0xbb, 0xf1, 0xfe, 0xb9, 0xad, 0xe7, 0xfb, 0xfd, 0xfb, 0x3e, 0xcf, 0x8e, 0x07, + 0x6d, 0xf6, 0x1c, 0xc9, 0x84, 0x64, 0x49, 0xec, 0xec, 0xb8, 0x51, 0x78, 0xca, 0x3d, 0x42, 0x43, + 0xea, 0x67, 0xdf, 0x33, 0x12, 0x50, 0xb7, 0xcf, 0x43, 0xb6, 0x1d, 0x27, 0x91, 0x8c, 0x30, 0xba, + 0x02, 0xae, 0x7c, 0xe0, 0x71, 0xd9, 0x4f, 0x9d, 0x6d, 0x37, 0x0a, 0x76, 0xbc, 0xc8, 0x8b, 0x76, + 0x00, 0xe2, 0xa4, 0xa7, 0xf0, 0x04, 0x0f, 0xf0, 0x4b, 0x53, 0xad, 0xbf, 0x97, 0xd1, 0xea, 0x3e, + 0x68, 0xb7, 0xb4, 0xf4, 0xa1, 0x56, 0x3e, 0x08, 0xb9, 0xe4, 0xd4, 0xc7, 0x4d, 0x84, 0x3a, 0x54, + 0x52, 0x87, 0x0a, 0x76, 0xd0, 0x69, 0x18, 0x6b, 0xc6, 0xd6, 0xa2, 0x5d, 0x59, 0xc1, 0x6b, 0x68, + 0xe9, 0xe2, 0xa9, 0x4b, 0xbd, 0xc6, 0x4d, 0x00, 0x54, 0x97, 0xf0, 0x13, 0xf4, 0xe6, 0xc5, 0x63, + 0x87, 0x09, 0x37, 0xe1, 0xb1, 0xe4, 0x51, 0xd8, 0x98, 0x03, 0x64, 0x5d, 0x09, 0x3f, 0x45, 0xe8, + 0x88, 0xca, 0xfe, 0x51, 0xc2, 0x4e, 0xf9, 0xa0, 0x71, 0x4b, 0x01, 0xdb, 0xf7, 0x8b, 0xdc, 0xc4, + 0x19, 0x0d, 0xfc, 0x4f, 0xad, 0x98, 0xca, 0x3e, 0x89, 0xa1, 0x68, 0xd9, 0x15, 0x24, 0xfe, 0xd1, + 0x40, 0xeb, 0xfb, 0x3e, 0x67, 0xa1, 0x3c, 0xce, 0x84, 0x64, 0xc1, 0x21, 0x93, 0x09, 0x77, 0xc5, + 0x41, 0xa8, 0x26, 0x13, 0xf9, 0x54, 0xb2, 0x9e, 0x42, 0x37, 0xe6, 0x41, 0x71, 0xb7, 0xc8, 0xcd, + 0x6d, 0xad, 0xe8, 0x02, 0x89, 0x08, 0x60, 0x91, 0x40, 0xd3, 0x08, 0xaf, 0xf0, 0x88, 0x32, 0xb5, + 0xec, 0x59, 0xe4, 0xf1, 0xcf, 0x06, 0xda, 0xd0, 0xb8, 0xe7, 0x54, 0xb2, 0xd0, 0xcd, 0xba, 0xfd, + 0x24, 0x4a, 0xbd, 0x7e, 0x9c, 0xca, 0x2e, 0x0f, 0x98, 0x60, 0x09, 0x67, 0x02, 0x82, 0x2c, 0x40, + 0x90, 0x8f, 0x8a, 0xdc, 0x7c, 0x32, 0x14, 0xc4, 0xd7, 0x3c, 0x22, 0x2f, 0x89, 0x44, 0x5e, 0x32, + 0xcb, 0x28, 0xb3, 0x59, 0xe0, 0x1f, 0xd0, 0xda, 0x10, 0xb0, 0xc3, 0x85, 0x4c, 0xb8, 0x93, 0xaa, + 0x41, 0xb7, 0x7c, 0x1f, 0x62, 0xbc, 0x06, 0x31, 0x76, 0x8a, 0xdc, 0x7c, 0x5c, 0x1b, 0xa3, 0x57, + 0xe1, 0x10, 0xea, 0xfb, 0x65, 0x82, 0xa9, 0xc2, 0xf8, 0x57, 0x03, 0x6d, 0x8e, 0x05, 0x1d, 0xb1, + 0xc4, 0x65, 0xa1, 0xe4, 0x3e, 0x83, 0x10, 0xaf, 0x43, 0x88, 0xa7, 0x45, 0x6e, 0xee, 0x4e, 0x0f, + 0x11, 0x5f, 0x72, 0xcb, 0x2c, 0xb3, 0xda, 0xe0, 0x9f, 0x0c, 0xf4, 0x70, 0x2c, 0xf6, 0x38, 0x0d, + 0x02, 0x9a, 0x64, 0x90, 0x67, 0x11, 0xf2, 0xec, 0x15, 0xb9, 0xb9, 0x33, 0x3d, 0x8f, 0xd0, 0xc4, + 0x32, 0xcc, 0x4c, 0x06, 0x38, 0x46, 0xef, 0x0c, 0xe1, 0xda, 0xd9, 0xe7, 0x2c, 0xfb, 0x22, 0x0d, + 0x1c, 0x96, 0x40, 0x00, 0x04, 0x01, 0xde, 0x2f, 0x72, 0x73, 0xab, 0x36, 0x80, 0x93, 0x91, 0x33, + 0x96, 0x91, 0x10, 0x18, 0xa5, 0xf3, 0x44, 0x45, 0x9c, 0x21, 0xf3, 0x98, 0x25, 0x2f, 0x58, 0xd2, + 0xe1, 0xe2, 0xec, 0x38, 0xa6, 0x2e, 0xfb, 0x4a, 0x50, 0x8f, 0x55, 0xbb, 0x5e, 0x1a, 0xdd, 0x0a, + 0x02, 0x08, 0xaa, 0xdb, 0x33, 0x22, 0x14, 0x85, 0xa4, 0x8a, 0x33, 0xd2, 0xf1, 0x34, 0x5d, 0x1c, + 0xa0, 0x55, 0x0d, 0x39, 0x64, 0x41, 0x94, 0x5c, 0xeb, 0xf5, 0x36, 0xd8, 0x3e, 0x2e, 0x72, 0x73, + 0x73, 0xc8, 0x36, 0x00, 0x74, 0x6d, 0xab, 0x93, 0xf4, 0xd4, 0x5b, 0x5e, 0xd7, 0x75, 0x9b, 0xd1, + 0x5e, 0x3b, 0x93, 0x4c, 0x74, 0x98, 0x2f, 0xe9, 0xa8, 0xef, 0x32, 0xf8, 0x7e, 0x5c, 0xe4, 0xe6, + 0x87, 0x43, 0xbe, 0x09, 0xa3, 0x3d, 0xe2, 0x28, 0x1a, 0xe9, 0x29, 0x5e, 0x6d, 0x82, 0x59, 0x1c, + 0xd4, 0x61, 0xf0, 0x50, 0xe3, 0xbe, 0x49, 0xb8, 0x64, 0xe3, 0xa3, 0xdc, 0x19, 0xdd, 0xff, 0x65, + 0x94, 0xef, 0x14, 0x6d, 0x6a, 0x96, 0x99, 0x3c, 0xf0, 0x6f, 0x06, 0xda, 0xd4, 0xc0, 0x89, 0x27, + 0xd8, 0x73, 0x2e, 0x64, 0xe3, 0xee, 0xda, 0xdc, 0xd6, 0x62, 0xfb, 0x93, 0x22, 0x37, 0xf7, 0x86, + 0xf2, 0x4c, 0x3b, 0x24, 0x89, 0xcf, 0x85, 0xb4, 0xec, 0x59, 0x7d, 0x30, 0x41, 0x0f, 0x5a, 0xbe, + 0xdf, 0xf2, 0xbc, 0x84, 0x79, 0xaa, 0xf0, 0x65, 0x2a, 0xe3, 0x54, 0xc2, 0x48, 0xee, 0xc1, 0x48, + 0x36, 0x8a, 0xdc, 0x7c, 0x57, 0x47, 0x50, 0x67, 0x0f, 0xbd, 0x44, 0x92, 0x08, 0xa0, 0xe5, 0x04, + 0xc6, 0xa9, 0x58, 0xff, 0xab, 0x43, 0xa8, 0xe6, 0x0b, 0x57, 0x83, 0xc7, 0x1c, 0xad, 0x8c, 0x91, + 0xd9, 0x3f, 0xfe, 0x5a, 0x7f, 0xfd, 0xda, 0x8f, 0x8a, 0xdc, 0xdc, 0x98, 0x96, 0x87, 0xb8, 0xe2, + 0x85, 0x65, 0x4f, 0x10, 0x9b, 0x60, 0xd5, 0x3d, 0xe9, 0xea, 0xef, 0xe8, 0x8c, 0x56, 0x72, 0x20, + 0xc7, 0x5b, 0x75, 0x4f, 0xba, 0xd6, 0x1f, 0x37, 0x51, 0xa3, 0x6e, 0x02, 0x47, 0x7e, 0x24, 0xf1, + 0x23, 0xb4, 0xb0, 0x1f, 0xf9, 0x69, 0x10, 0x96, 0xed, 0xbd, 0x51, 0xe4, 0xe6, 0x72, 0x79, 0xe0, + 0xc0, 0xba, 0x65, 0x97, 0x00, 0xbc, 0x89, 0xe6, 0x4f, 0x5a, 0x03, 0x2e, 0xca, 0x74, 0x15, 0xe4, + 0x80, 0xd0, 0x01, 0x17, 0x96, 0xad, 0xeb, 0x0a, 0xf8, 0x2d, 0x00, 0xe7, 0x46, 0x81, 0xd9, 0x05, + 0x10, 0xea, 0xf8, 0x33, 0xb4, 0x3c, 0x3c, 0x62, 0xfd, 0xb1, 0x5f, 0x29, 0x72, 0xf3, 0xbe, 0x26, + 0x5c, 0x9b, 0xe9, 0x30, 0x01, 0xef, 0xa3, 0x3b, 0x57, 0x0b, 0xb0, 0x71, 0xe7, 0x61, 0xe3, 0xae, + 0x16, 0xb9, 0xf9, 0xe0, 0xba, 0x84, 0xde, 0x9c, 0x23, 0x14, 0xeb, 0x17, 0x03, 0xbd, 0x5d, 0x7b, + 0x09, 0x0a, 0xa8, 0xc7, 0xf0, 0x7b, 0x68, 0xbe, 0xcb, 0xa5, 0xcf, 0xca, 0x01, 0xdd, 0x2b, 0x72, + 0xf3, 0xb6, 0x56, 0x96, 0x6a, 0xd9, 0xb2, 0x75, 0x19, 0xaf, 0xa3, 0x5b, 0xb0, 0x6d, 0xf5, 0x74, + 0xee, 0x16, 0xb9, 0xb9, 0x74, 0x75, 0x61, 0xb1, 0x6c, 0x28, 0x2a, 0x50, 0x37, 0x8b, 0x59, 0x39, + 0x99, 0x0a, 0x48, 0x66, 0x31, 0xb3, 0x6c, 0x28, 0x5a, 0x7f, 0x1a, 0x68, 0xa5, 0x2e, 0x8f, 0xfd, + 0xac, 0xd5, 0x39, 0x7c, 0xa6, 0xee, 0x47, 0x95, 0x7f, 0x89, 0x31, 0x7a, 0x3f, 0x1a, 0xfa, 0x5b, + 0x54, 0x90, 0xf8, 0x08, 0x2d, 0x40, 0x47, 0xea, 0x05, 0xce, 0x6d, 0x2d, 0xed, 0x6e, 0x6c, 0x5f, + 0xdd, 0x1b, 0xb7, 0xc7, 0xf6, 0x5f, 0x7d, 0x7d, 0x1c, 0xe8, 0x96, 0x5d, 0xea, 0xb4, 0xdf, 0x7a, + 0xf9, 0x6f, 0xf3, 0xc6, 0xcb, 0xf3, 0xa6, 0xf1, 0xd7, 0x79, 0xd3, 0xf8, 0xe7, 0xbc, 0x69, 0xfc, + 0xfe, 0x5f, 0xf3, 0x86, 0xb3, 0x00, 0x57, 0xcb, 0xbd, 0x57, 0x01, 0x00, 0x00, 0xff, 0xff, 0x47, + 0x8f, 0xbe, 0x24, 0xc0, 0x0a, 0x00, 0x00, +} diff --git a/dbtesterpb/config_analyze_machine.proto b/dbtesterpb/config_analyze_machine.proto new file mode 100644 index 00000000..22ec3650 --- /dev/null +++ b/dbtesterpb/config_analyze_machine.proto @@ -0,0 +1,57 @@ +syntax = "proto3"; +package dbtesterpb; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.goproto_getters_all) = false; + +// ConfigAnalyzeMachineInitial represents common control options and test data information for analyzer machine. +message ConfigAnalyzeMachineInitial { + string DatabaseID = 1; + string DatabaseTag = 2; + string DatabaseDescription = 3; + + string PathPrefix = 4 [(gogoproto.moretags) = "yaml:\"path_prefix\""]; + string ClientSystemMetricsInterpolatedPath = 5 [(gogoproto.moretags) = "yaml:\"client_system_metrics_interpolated_path\""]; + string ClientLatencyThroughputTimeseriesPath = 6 [(gogoproto.moretags) = "yaml:\"client_latency_throughput_timeseries_path\""]; + string ClientLatencyDistributionAllPath = 7 [(gogoproto.moretags) = "yaml:\"client_latency_distribution_all_path\""]; + string ClientLatencyDistributionPercentilePath = 8 [(gogoproto.moretags) = "yaml:\"client_latency_distribution_percentile_path\""]; + string ClientLatencyDistributionSummaryPath = 9 [(gogoproto.moretags) = "yaml:\"client_latency_distribution_summary_path\""]; + string ClientLatencyByKeyNumberPath = 10 [(gogoproto.moretags) = "yaml:\"client_latency_by_key_number_path\""]; + string ServerDiskSpaceUsageSummaryPath = 11 [(gogoproto.moretags) = "yaml:\"server_disk_space_usage_summary_path\""]; + string ServerMemoryByKeyNumberPath = 12 [(gogoproto.moretags) = "yaml:\"server_memory_by_key_number_path\""]; + string ServerReadBytesDeltaByKeyNumberPath = 13 [(gogoproto.moretags) = "yaml:\"server_read_bytes_delta_by_key_number_path\""]; + string ServerWriteBytesDeltaByKeyNumberPath = 14 [(gogoproto.moretags) = "yaml:\"server_write_bytes_delta_by_key_number_path\""]; + repeated string ServerSystemMetricsInterpolatedPathList = 15 [(gogoproto.moretags) = "yaml:\"server_system_metrics_interpolated_path_list\""]; + string AllAggregatedOutputPath = 16 [(gogoproto.moretags) = "yaml:\"all_aggregated_output_path\""]; +} + +message ConfigAnalyzeMachineAllAggregatedOutput { + string AllAggregatedOutputPathCSV = 1 [(gogoproto.moretags) = "yaml:\"all_aggregated_output_path_csv\""]; + string AllAggregatedOutputPathTXT = 2 [(gogoproto.moretags) = "yaml:\"all_aggregated_output_path_txt\""]; +} + +// ConfigAnalyzeMachinePlot defines plot configuration. +message ConfigAnalyzeMachinePlot { + string Column = 1 [(gogoproto.moretags) = "yaml:\"column\""]; + string XAxis = 2 [(gogoproto.moretags) = "yaml:\"x_axis\""]; + string YAxis = 3 [(gogoproto.moretags) = "yaml:\"y_axis\""]; + string OutputPathCSV = 4 [(gogoproto.moretags) = "yaml:\"output_path_csv\""]; + repeated string OutputPathList = 5 [(gogoproto.moretags) = "yaml:\"output_path_list\""]; +} + +// ConfigAnalyzeMachineImage defines image configuration. +message ConfigAnalyzeMachineImage { + string Title = 1 [(gogoproto.moretags) = "yaml:\"title\""]; + string Path = 2 [(gogoproto.moretags) = "yaml:\"path\""]; + string Type = 3 [(gogoproto.moretags) = "yaml:\"type\""]; +} + +// ConfigAnalyzeMachineREADME defines read configuration. +message ConfigAnalyzeMachineREADME { + string OutputPath = 1 [(gogoproto.moretags) = "yaml:\"output_path\""]; + repeated ConfigAnalyzeMachineImage Images = 2 [(gogoproto.moretags) = "yaml:\"images\""]; +} diff --git a/dbtesterpb/config_client_machine.pb.go b/dbtesterpb/config_client_machine.pb.go new file mode 100644 index 00000000..ea5b25e6 --- /dev/null +++ b/dbtesterpb/config_client_machine.pb.go @@ -0,0 +1,2706 @@ +// Code generated by protoc-gen-gogo. +// source: dbtesterpb/config_client_machine.proto +// DO NOT EDIT! + +package dbtesterpb + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" +import _ "github.com/gogo/protobuf/gogoproto" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// ConfigClientMachineInitial represents common control options on client machine. +type ConfigClientMachineInitial struct { + PathPrefix string `protobuf:"bytes,1,opt,name=PathPrefix,proto3" json:"PathPrefix,omitempty" yaml:"path_prefix"` + LogPath string `protobuf:"bytes,2,opt,name=LogPath,proto3" json:"LogPath,omitempty" yaml:"log_path"` + ClientSystemMetricsPath string `protobuf:"bytes,3,opt,name=ClientSystemMetricsPath,proto3" json:"ClientSystemMetricsPath,omitempty" yaml:"client_system_metrics_path"` + ClientSystemMetricsInterpolatedPath string `protobuf:"bytes,4,opt,name=ClientSystemMetricsInterpolatedPath,proto3" json:"ClientSystemMetricsInterpolatedPath,omitempty" yaml:"client_system_metrics_interpolated_path"` + ClientLatencyThroughputTimeseriesPath string `protobuf:"bytes,5,opt,name=ClientLatencyThroughputTimeseriesPath,proto3" json:"ClientLatencyThroughputTimeseriesPath,omitempty" yaml:"client_latency_throughput_timeseries_path"` + ClientLatencyDistributionAllPath string `protobuf:"bytes,6,opt,name=ClientLatencyDistributionAllPath,proto3" json:"ClientLatencyDistributionAllPath,omitempty" yaml:"client_latency_distribution_all_path"` + ClientLatencyDistributionPercentilePath string `protobuf:"bytes,7,opt,name=ClientLatencyDistributionPercentilePath,proto3" json:"ClientLatencyDistributionPercentilePath,omitempty" yaml:"client_latency_distribution_percentile_path"` + ClientLatencyDistributionSummaryPath string `protobuf:"bytes,8,opt,name=ClientLatencyDistributionSummaryPath,proto3" json:"ClientLatencyDistributionSummaryPath,omitempty" yaml:"client_latency_distribution_summary_path"` + ClientLatencyByKeyNumberPath string `protobuf:"bytes,9,opt,name=ClientLatencyByKeyNumberPath,proto3" json:"ClientLatencyByKeyNumberPath,omitempty" yaml:"client_latency_by_key_number_path"` + ServerDiskSpaceUsageSummaryPath string `protobuf:"bytes,10,opt,name=ServerDiskSpaceUsageSummaryPath,proto3" json:"ServerDiskSpaceUsageSummaryPath,omitempty" yaml:"server_disk_space_usage_summary_path"` + GoogleCloudProjectName string `protobuf:"bytes,100,opt,name=GoogleCloudProjectName,proto3" json:"GoogleCloudProjectName,omitempty" yaml:"google_cloud_project_name"` + GoogleCloudStorageKeyPath string `protobuf:"bytes,101,opt,name=GoogleCloudStorageKeyPath,proto3" json:"GoogleCloudStorageKeyPath,omitempty" yaml:"google_cloud_storage_key_path"` + GoogleCloudStorageKey string `protobuf:"bytes,102,opt,name=GoogleCloudStorageKey,proto3" json:"GoogleCloudStorageKey,omitempty"` + GoogleCloudStorageBucketName string `protobuf:"bytes,103,opt,name=GoogleCloudStorageBucketName,proto3" json:"GoogleCloudStorageBucketName,omitempty" yaml:"google_cloud_storage_bucket_name"` + GoogleCloudStorageSubDirectory string `protobuf:"bytes,104,opt,name=GoogleCloudStorageSubDirectory,proto3" json:"GoogleCloudStorageSubDirectory,omitempty" yaml:"google_cloud_storage_sub_directory"` +} + +func (m *ConfigClientMachineInitial) Reset() { *m = ConfigClientMachineInitial{} } +func (m *ConfigClientMachineInitial) String() string { return proto.CompactTextString(m) } +func (*ConfigClientMachineInitial) ProtoMessage() {} +func (*ConfigClientMachineInitial) Descriptor() ([]byte, []int) { + return fileDescriptorConfigClientMachine, []int{0} +} + +// ConfigClientMachineBenchmarkOptions represents benchmark options. +type ConfigClientMachineBenchmarkOptions struct { + Type string `protobuf:"bytes,1,opt,name=Type,proto3" json:"Type,omitempty" yaml:"type"` + RequestNumber int64 `protobuf:"varint,2,opt,name=RequestNumber,proto3" json:"RequestNumber,omitempty" yaml:"request_number"` + ConnectionNumber int64 `protobuf:"varint,3,opt,name=ConnectionNumber,proto3" json:"ConnectionNumber,omitempty" yaml:"connection_number"` + ClientNumber int64 `protobuf:"varint,4,opt,name=ClientNumber,proto3" json:"ClientNumber,omitempty" yaml:"client_number"` + ConnectionClientNumbers []int64 `protobuf:"varint,5,rep,packed,name=ConnectionClientNumbers" json:"ConnectionClientNumbers,omitempty" yaml:"connection_client_numbers"` + RateLimitRequestsPerSecond int64 `protobuf:"varint,6,opt,name=RateLimitRequestsPerSecond,proto3" json:"RateLimitRequestsPerSecond,omitempty" yaml:"rate_limit_requests_per_second"` + SameKey bool `protobuf:"varint,7,opt,name=SameKey,proto3" json:"SameKey,omitempty" yaml:"same_key"` + KeySizeBytes int64 `protobuf:"varint,8,opt,name=KeySizeBytes,proto3" json:"KeySizeBytes,omitempty" yaml:"key_size_bytes"` + ValueSizeBytes int64 `protobuf:"varint,9,opt,name=ValueSizeBytes,proto3" json:"ValueSizeBytes,omitempty" yaml:"value_size_bytes"` + StaleRead bool `protobuf:"varint,10,opt,name=StaleRead,proto3" json:"StaleRead,omitempty" yaml:"stale_read"` +} + +func (m *ConfigClientMachineBenchmarkOptions) Reset() { *m = ConfigClientMachineBenchmarkOptions{} } +func (m *ConfigClientMachineBenchmarkOptions) String() string { return proto.CompactTextString(m) } +func (*ConfigClientMachineBenchmarkOptions) ProtoMessage() {} +func (*ConfigClientMachineBenchmarkOptions) Descriptor() ([]byte, []int) { + return fileDescriptorConfigClientMachine, []int{1} +} + +// ConfigClientMachineBenchmarkSteps represents benchmark steps. +type ConfigClientMachineBenchmarkSteps struct { + Step1StartDatabase bool `protobuf:"varint,1,opt,name=Step1StartDatabase,proto3" json:"Step1StartDatabase,omitempty" yaml:"step1_start_database"` + Step2StressDatabase bool `protobuf:"varint,2,opt,name=Step2StressDatabase,proto3" json:"Step2StressDatabase,omitempty" yaml:"step2_stress_database"` + Step3StopDatabase bool `protobuf:"varint,3,opt,name=Step3StopDatabase,proto3" json:"Step3StopDatabase,omitempty" yaml:"step3_stop_database"` + Step4UploadLogs bool `protobuf:"varint,4,opt,name=Step4UploadLogs,proto3" json:"Step4UploadLogs,omitempty" yaml:"step4_upload_logs"` +} + +func (m *ConfigClientMachineBenchmarkSteps) Reset() { *m = ConfigClientMachineBenchmarkSteps{} } +func (m *ConfigClientMachineBenchmarkSteps) String() string { return proto.CompactTextString(m) } +func (*ConfigClientMachineBenchmarkSteps) ProtoMessage() {} +func (*ConfigClientMachineBenchmarkSteps) Descriptor() ([]byte, []int) { + return fileDescriptorConfigClientMachine, []int{2} +} + +// ConfigClientMachineAgentControl represents control options on client machine. +type ConfigClientMachineAgentControl struct { + DatabaseID string `protobuf:"bytes,1,opt,name=DatabaseID,proto3" json:"DatabaseID,omitempty" yaml:"database_id"` + DatabaseDescription string `protobuf:"bytes,2,opt,name=DatabaseDescription,proto3" json:"DatabaseDescription,omitempty" yaml:"database_description"` + DatabaseTag string `protobuf:"bytes,3,opt,name=DatabaseTag,proto3" json:"DatabaseTag,omitempty" yaml:"database_tag"` + PeerIPs []string `protobuf:"bytes,4,rep,name=PeerIPs" json:"PeerIPs,omitempty" yaml:"peer_ips"` + PeerIPsString string `protobuf:"bytes,5,opt,name=PeerIPsString,proto3" json:"PeerIPsString,omitempty" yaml:"peer_ips_string"` + AgentPortToConnect int64 `protobuf:"varint,6,opt,name=AgentPortToConnect,proto3" json:"AgentPortToConnect,omitempty" yaml:"agent_port_to_connect"` + AgentEndpoints []string `protobuf:"bytes,7,rep,name=AgentEndpoints" json:"AgentEndpoints,omitempty" yaml:"agent_endpoints"` + DatabasePortToConnect int64 `protobuf:"varint,8,opt,name=DatabasePortToConnect,proto3" json:"DatabasePortToConnect,omitempty" yaml:"database_port_to_connect"` + DatabaseEndpoints []string `protobuf:"bytes,9,rep,name=DatabaseEndpoints" json:"DatabaseEndpoints,omitempty" yaml:"database_endpoints"` + Flag_Etcd_V2_3 *Flag_Etcd_V2_3 `protobuf:"bytes,100,opt,name=flag__etcd__v2_3,json=flagEtcdV23" json:"flag__etcd__v2_3,omitempty" yaml:"etcd__v2_3"` + Flag_Etcd_V3_1 *Flag_Etcd_V3_1 `protobuf:"bytes,101,opt,name=flag__etcd__v3_1,json=flagEtcdV31" json:"flag__etcd__v3_1,omitempty" yaml:"etcd__v3_1"` + Flag_Etcd_V3_2 *Flag_Etcd_V3_2 `protobuf:"bytes,102,opt,name=flag__etcd__v3_2,json=flagEtcdV32" json:"flag__etcd__v3_2,omitempty" yaml:"etcd__v3_2"` + Flag_Etcd_Tip *Flag_Etcd_Tip `protobuf:"bytes,103,opt,name=flag__etcd__tip,json=flagEtcdTip" json:"flag__etcd__tip,omitempty" yaml:"etcd__tip"` + Flag_Zookeeper_R3_4_9 *Flag_Zookeeper_R3_4_9 `protobuf:"bytes,200,opt,name=flag__zookeeper__r3_4_9,json=flagZookeeperR349" json:"flag__zookeeper__r3_4_9,omitempty" yaml:"zookeeper__r3_4_9"` + Flag_Zookeeper_R3_5_2Alpha *Flag_Zookeeper_R3_5_2Alpha `protobuf:"bytes,201,opt,name=flag__zookeeper__r3_5_2_alpha,json=flagZookeeperR352Alpha" json:"flag__zookeeper__r3_5_2_alpha,omitempty" yaml:"zookeeper__r3_5_2_alpha"` + Flag_Consul_V0_7_5 *Flag_Consul_V0_7_5 `protobuf:"bytes,300,opt,name=flag__consul__v0_7_5,json=flagConsulV075" json:"flag__consul__v0_7_5,omitempty" yaml:"consul__v0_7_5"` + Flag_Consul_V0_8_0 *Flag_Consul_V0_8_0 `protobuf:"bytes,301,opt,name=flag__consul__v0_8_0,json=flagConsulV080" json:"flag__consul__v0_8_0,omitempty" yaml:"consul__v0_8_0"` + Flag_Cetcd_Beta *Flag_Cetcd_Beta `protobuf:"bytes,400,opt,name=flag__cetcd__beta,json=flagCetcdBeta" json:"flag__cetcd__beta,omitempty" yaml:"cetcd__beta"` + Flag_Zetcd_Beta *Flag_Zetcd_Beta `protobuf:"bytes,500,opt,name=flag__zetcd__beta,json=flagZetcdBeta" json:"flag__zetcd__beta,omitempty" yaml:"zetcd__beta"` + ConfigClientMachineBenchmarkOptions *ConfigClientMachineBenchmarkOptions `protobuf:"bytes,1000,opt,name=ConfigClientMachineBenchmarkOptions" json:"ConfigClientMachineBenchmarkOptions,omitempty" yaml:"benchmark_options"` + ConfigClientMachineBenchmarkSteps *ConfigClientMachineBenchmarkSteps `protobuf:"bytes,1001,opt,name=ConfigClientMachineBenchmarkSteps" json:"ConfigClientMachineBenchmarkSteps,omitempty" yaml:"benchmark_steps"` +} + +func (m *ConfigClientMachineAgentControl) Reset() { *m = ConfigClientMachineAgentControl{} } +func (m *ConfigClientMachineAgentControl) String() string { return proto.CompactTextString(m) } +func (*ConfigClientMachineAgentControl) ProtoMessage() {} +func (*ConfigClientMachineAgentControl) Descriptor() ([]byte, []int) { + return fileDescriptorConfigClientMachine, []int{3} +} + +func init() { + proto.RegisterType((*ConfigClientMachineInitial)(nil), "dbtesterpb.ConfigClientMachineInitial") + proto.RegisterType((*ConfigClientMachineBenchmarkOptions)(nil), "dbtesterpb.ConfigClientMachineBenchmarkOptions") + proto.RegisterType((*ConfigClientMachineBenchmarkSteps)(nil), "dbtesterpb.ConfigClientMachineBenchmarkSteps") + proto.RegisterType((*ConfigClientMachineAgentControl)(nil), "dbtesterpb.ConfigClientMachineAgentControl") +} +func (m *ConfigClientMachineInitial) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ConfigClientMachineInitial) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.PathPrefix) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(len(m.PathPrefix))) + i += copy(dAtA[i:], m.PathPrefix) + } + if len(m.LogPath) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(len(m.LogPath))) + i += copy(dAtA[i:], m.LogPath) + } + if len(m.ClientSystemMetricsPath) > 0 { + dAtA[i] = 0x1a + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(len(m.ClientSystemMetricsPath))) + i += copy(dAtA[i:], m.ClientSystemMetricsPath) + } + if len(m.ClientSystemMetricsInterpolatedPath) > 0 { + dAtA[i] = 0x22 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(len(m.ClientSystemMetricsInterpolatedPath))) + i += copy(dAtA[i:], m.ClientSystemMetricsInterpolatedPath) + } + if len(m.ClientLatencyThroughputTimeseriesPath) > 0 { + dAtA[i] = 0x2a + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(len(m.ClientLatencyThroughputTimeseriesPath))) + i += copy(dAtA[i:], m.ClientLatencyThroughputTimeseriesPath) + } + if len(m.ClientLatencyDistributionAllPath) > 0 { + dAtA[i] = 0x32 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(len(m.ClientLatencyDistributionAllPath))) + i += copy(dAtA[i:], m.ClientLatencyDistributionAllPath) + } + if len(m.ClientLatencyDistributionPercentilePath) > 0 { + dAtA[i] = 0x3a + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(len(m.ClientLatencyDistributionPercentilePath))) + i += copy(dAtA[i:], m.ClientLatencyDistributionPercentilePath) + } + if len(m.ClientLatencyDistributionSummaryPath) > 0 { + dAtA[i] = 0x42 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(len(m.ClientLatencyDistributionSummaryPath))) + i += copy(dAtA[i:], m.ClientLatencyDistributionSummaryPath) + } + if len(m.ClientLatencyByKeyNumberPath) > 0 { + dAtA[i] = 0x4a + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(len(m.ClientLatencyByKeyNumberPath))) + i += copy(dAtA[i:], m.ClientLatencyByKeyNumberPath) + } + if len(m.ServerDiskSpaceUsageSummaryPath) > 0 { + dAtA[i] = 0x52 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(len(m.ServerDiskSpaceUsageSummaryPath))) + i += copy(dAtA[i:], m.ServerDiskSpaceUsageSummaryPath) + } + if len(m.GoogleCloudProjectName) > 0 { + dAtA[i] = 0xa2 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(len(m.GoogleCloudProjectName))) + i += copy(dAtA[i:], m.GoogleCloudProjectName) + } + if len(m.GoogleCloudStorageKeyPath) > 0 { + dAtA[i] = 0xaa + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(len(m.GoogleCloudStorageKeyPath))) + i += copy(dAtA[i:], m.GoogleCloudStorageKeyPath) + } + if len(m.GoogleCloudStorageKey) > 0 { + dAtA[i] = 0xb2 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(len(m.GoogleCloudStorageKey))) + i += copy(dAtA[i:], m.GoogleCloudStorageKey) + } + if len(m.GoogleCloudStorageBucketName) > 0 { + dAtA[i] = 0xba + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(len(m.GoogleCloudStorageBucketName))) + i += copy(dAtA[i:], m.GoogleCloudStorageBucketName) + } + if len(m.GoogleCloudStorageSubDirectory) > 0 { + dAtA[i] = 0xc2 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(len(m.GoogleCloudStorageSubDirectory))) + i += copy(dAtA[i:], m.GoogleCloudStorageSubDirectory) + } + return i, nil +} + +func (m *ConfigClientMachineBenchmarkOptions) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ConfigClientMachineBenchmarkOptions) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Type) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(len(m.Type))) + i += copy(dAtA[i:], m.Type) + } + if m.RequestNumber != 0 { + dAtA[i] = 0x10 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(m.RequestNumber)) + } + if m.ConnectionNumber != 0 { + dAtA[i] = 0x18 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(m.ConnectionNumber)) + } + if m.ClientNumber != 0 { + dAtA[i] = 0x20 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(m.ClientNumber)) + } + if len(m.ConnectionClientNumbers) > 0 { + dAtA2 := make([]byte, len(m.ConnectionClientNumbers)*10) + var j1 int + for _, num1 := range m.ConnectionClientNumbers { + num := uint64(num1) + for num >= 1<<7 { + dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j1++ + } + dAtA2[j1] = uint8(num) + j1++ + } + dAtA[i] = 0x2a + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(j1)) + i += copy(dAtA[i:], dAtA2[:j1]) + } + if m.RateLimitRequestsPerSecond != 0 { + dAtA[i] = 0x30 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(m.RateLimitRequestsPerSecond)) + } + if m.SameKey { + dAtA[i] = 0x38 + i++ + if m.SameKey { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + } + if m.KeySizeBytes != 0 { + dAtA[i] = 0x40 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(m.KeySizeBytes)) + } + if m.ValueSizeBytes != 0 { + dAtA[i] = 0x48 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(m.ValueSizeBytes)) + } + if m.StaleRead { + dAtA[i] = 0x50 + i++ + if m.StaleRead { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + } + return i, nil +} + +func (m *ConfigClientMachineBenchmarkSteps) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ConfigClientMachineBenchmarkSteps) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Step1StartDatabase { + dAtA[i] = 0x8 + i++ + if m.Step1StartDatabase { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + } + if m.Step2StressDatabase { + dAtA[i] = 0x10 + i++ + if m.Step2StressDatabase { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + } + if m.Step3StopDatabase { + dAtA[i] = 0x18 + i++ + if m.Step3StopDatabase { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + } + if m.Step4UploadLogs { + dAtA[i] = 0x20 + i++ + if m.Step4UploadLogs { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + } + return i, nil +} + +func (m *ConfigClientMachineAgentControl) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ConfigClientMachineAgentControl) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.DatabaseID) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(len(m.DatabaseID))) + i += copy(dAtA[i:], m.DatabaseID) + } + if len(m.DatabaseDescription) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(len(m.DatabaseDescription))) + i += copy(dAtA[i:], m.DatabaseDescription) + } + if len(m.DatabaseTag) > 0 { + dAtA[i] = 0x1a + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(len(m.DatabaseTag))) + i += copy(dAtA[i:], m.DatabaseTag) + } + if len(m.PeerIPs) > 0 { + for _, s := range m.PeerIPs { + dAtA[i] = 0x22 + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if len(m.PeerIPsString) > 0 { + dAtA[i] = 0x2a + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(len(m.PeerIPsString))) + i += copy(dAtA[i:], m.PeerIPsString) + } + if m.AgentPortToConnect != 0 { + dAtA[i] = 0x30 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(m.AgentPortToConnect)) + } + if len(m.AgentEndpoints) > 0 { + for _, s := range m.AgentEndpoints { + dAtA[i] = 0x3a + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if m.DatabasePortToConnect != 0 { + dAtA[i] = 0x40 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(m.DatabasePortToConnect)) + } + if len(m.DatabaseEndpoints) > 0 { + for _, s := range m.DatabaseEndpoints { + dAtA[i] = 0x4a + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if m.Flag_Etcd_V2_3 != nil { + dAtA[i] = 0xa2 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(m.Flag_Etcd_V2_3.Size())) + n3, err := m.Flag_Etcd_V2_3.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n3 + } + if m.Flag_Etcd_V3_1 != nil { + dAtA[i] = 0xaa + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(m.Flag_Etcd_V3_1.Size())) + n4, err := m.Flag_Etcd_V3_1.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n4 + } + if m.Flag_Etcd_V3_2 != nil { + dAtA[i] = 0xb2 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(m.Flag_Etcd_V3_2.Size())) + n5, err := m.Flag_Etcd_V3_2.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n5 + } + if m.Flag_Etcd_Tip != nil { + dAtA[i] = 0xba + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(m.Flag_Etcd_Tip.Size())) + n6, err := m.Flag_Etcd_Tip.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n6 + } + if m.Flag_Zookeeper_R3_4_9 != nil { + dAtA[i] = 0xc2 + i++ + dAtA[i] = 0xc + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(m.Flag_Zookeeper_R3_4_9.Size())) + n7, err := m.Flag_Zookeeper_R3_4_9.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n7 + } + if m.Flag_Zookeeper_R3_5_2Alpha != nil { + dAtA[i] = 0xca + i++ + dAtA[i] = 0xc + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(m.Flag_Zookeeper_R3_5_2Alpha.Size())) + n8, err := m.Flag_Zookeeper_R3_5_2Alpha.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n8 + } + if m.Flag_Consul_V0_7_5 != nil { + dAtA[i] = 0xe2 + i++ + dAtA[i] = 0x12 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(m.Flag_Consul_V0_7_5.Size())) + n9, err := m.Flag_Consul_V0_7_5.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n9 + } + if m.Flag_Consul_V0_8_0 != nil { + dAtA[i] = 0xea + i++ + dAtA[i] = 0x12 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(m.Flag_Consul_V0_8_0.Size())) + n10, err := m.Flag_Consul_V0_8_0.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n10 + } + if m.Flag_Cetcd_Beta != nil { + dAtA[i] = 0x82 + i++ + dAtA[i] = 0x19 + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(m.Flag_Cetcd_Beta.Size())) + n11, err := m.Flag_Cetcd_Beta.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n11 + } + if m.Flag_Zetcd_Beta != nil { + dAtA[i] = 0xa2 + i++ + dAtA[i] = 0x1f + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(m.Flag_Zetcd_Beta.Size())) + n12, err := m.Flag_Zetcd_Beta.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n12 + } + if m.ConfigClientMachineBenchmarkOptions != nil { + dAtA[i] = 0xc2 + i++ + dAtA[i] = 0x3e + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(m.ConfigClientMachineBenchmarkOptions.Size())) + n13, err := m.ConfigClientMachineBenchmarkOptions.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n13 + } + if m.ConfigClientMachineBenchmarkSteps != nil { + dAtA[i] = 0xca + i++ + dAtA[i] = 0x3e + i++ + i = encodeVarintConfigClientMachine(dAtA, i, uint64(m.ConfigClientMachineBenchmarkSteps.Size())) + n14, err := m.ConfigClientMachineBenchmarkSteps.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n14 + } + return i, nil +} + +func encodeFixed64ConfigClientMachine(dAtA []byte, offset int, v uint64) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) + dAtA[offset+4] = uint8(v >> 32) + dAtA[offset+5] = uint8(v >> 40) + dAtA[offset+6] = uint8(v >> 48) + dAtA[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32ConfigClientMachine(dAtA []byte, offset int, v uint32) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintConfigClientMachine(dAtA []byte, offset int, v uint64) int { + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return offset + 1 +} +func (m *ConfigClientMachineInitial) Size() (n int) { + var l int + _ = l + l = len(m.PathPrefix) + if l > 0 { + n += 1 + l + sovConfigClientMachine(uint64(l)) + } + l = len(m.LogPath) + if l > 0 { + n += 1 + l + sovConfigClientMachine(uint64(l)) + } + l = len(m.ClientSystemMetricsPath) + if l > 0 { + n += 1 + l + sovConfigClientMachine(uint64(l)) + } + l = len(m.ClientSystemMetricsInterpolatedPath) + if l > 0 { + n += 1 + l + sovConfigClientMachine(uint64(l)) + } + l = len(m.ClientLatencyThroughputTimeseriesPath) + if l > 0 { + n += 1 + l + sovConfigClientMachine(uint64(l)) + } + l = len(m.ClientLatencyDistributionAllPath) + if l > 0 { + n += 1 + l + sovConfigClientMachine(uint64(l)) + } + l = len(m.ClientLatencyDistributionPercentilePath) + if l > 0 { + n += 1 + l + sovConfigClientMachine(uint64(l)) + } + l = len(m.ClientLatencyDistributionSummaryPath) + if l > 0 { + n += 1 + l + sovConfigClientMachine(uint64(l)) + } + l = len(m.ClientLatencyByKeyNumberPath) + if l > 0 { + n += 1 + l + sovConfigClientMachine(uint64(l)) + } + l = len(m.ServerDiskSpaceUsageSummaryPath) + if l > 0 { + n += 1 + l + sovConfigClientMachine(uint64(l)) + } + l = len(m.GoogleCloudProjectName) + if l > 0 { + n += 2 + l + sovConfigClientMachine(uint64(l)) + } + l = len(m.GoogleCloudStorageKeyPath) + if l > 0 { + n += 2 + l + sovConfigClientMachine(uint64(l)) + } + l = len(m.GoogleCloudStorageKey) + if l > 0 { + n += 2 + l + sovConfigClientMachine(uint64(l)) + } + l = len(m.GoogleCloudStorageBucketName) + if l > 0 { + n += 2 + l + sovConfigClientMachine(uint64(l)) + } + l = len(m.GoogleCloudStorageSubDirectory) + if l > 0 { + n += 2 + l + sovConfigClientMachine(uint64(l)) + } + return n +} + +func (m *ConfigClientMachineBenchmarkOptions) Size() (n int) { + var l int + _ = l + l = len(m.Type) + if l > 0 { + n += 1 + l + sovConfigClientMachine(uint64(l)) + } + if m.RequestNumber != 0 { + n += 1 + sovConfigClientMachine(uint64(m.RequestNumber)) + } + if m.ConnectionNumber != 0 { + n += 1 + sovConfigClientMachine(uint64(m.ConnectionNumber)) + } + if m.ClientNumber != 0 { + n += 1 + sovConfigClientMachine(uint64(m.ClientNumber)) + } + if len(m.ConnectionClientNumbers) > 0 { + l = 0 + for _, e := range m.ConnectionClientNumbers { + l += sovConfigClientMachine(uint64(e)) + } + n += 1 + sovConfigClientMachine(uint64(l)) + l + } + if m.RateLimitRequestsPerSecond != 0 { + n += 1 + sovConfigClientMachine(uint64(m.RateLimitRequestsPerSecond)) + } + if m.SameKey { + n += 2 + } + if m.KeySizeBytes != 0 { + n += 1 + sovConfigClientMachine(uint64(m.KeySizeBytes)) + } + if m.ValueSizeBytes != 0 { + n += 1 + sovConfigClientMachine(uint64(m.ValueSizeBytes)) + } + if m.StaleRead { + n += 2 + } + return n +} + +func (m *ConfigClientMachineBenchmarkSteps) Size() (n int) { + var l int + _ = l + if m.Step1StartDatabase { + n += 2 + } + if m.Step2StressDatabase { + n += 2 + } + if m.Step3StopDatabase { + n += 2 + } + if m.Step4UploadLogs { + n += 2 + } + return n +} + +func (m *ConfigClientMachineAgentControl) Size() (n int) { + var l int + _ = l + l = len(m.DatabaseID) + if l > 0 { + n += 1 + l + sovConfigClientMachine(uint64(l)) + } + l = len(m.DatabaseDescription) + if l > 0 { + n += 1 + l + sovConfigClientMachine(uint64(l)) + } + l = len(m.DatabaseTag) + if l > 0 { + n += 1 + l + sovConfigClientMachine(uint64(l)) + } + if len(m.PeerIPs) > 0 { + for _, s := range m.PeerIPs { + l = len(s) + n += 1 + l + sovConfigClientMachine(uint64(l)) + } + } + l = len(m.PeerIPsString) + if l > 0 { + n += 1 + l + sovConfigClientMachine(uint64(l)) + } + if m.AgentPortToConnect != 0 { + n += 1 + sovConfigClientMachine(uint64(m.AgentPortToConnect)) + } + if len(m.AgentEndpoints) > 0 { + for _, s := range m.AgentEndpoints { + l = len(s) + n += 1 + l + sovConfigClientMachine(uint64(l)) + } + } + if m.DatabasePortToConnect != 0 { + n += 1 + sovConfigClientMachine(uint64(m.DatabasePortToConnect)) + } + if len(m.DatabaseEndpoints) > 0 { + for _, s := range m.DatabaseEndpoints { + l = len(s) + n += 1 + l + sovConfigClientMachine(uint64(l)) + } + } + if m.Flag_Etcd_V2_3 != nil { + l = m.Flag_Etcd_V2_3.Size() + n += 2 + l + sovConfigClientMachine(uint64(l)) + } + if m.Flag_Etcd_V3_1 != nil { + l = m.Flag_Etcd_V3_1.Size() + n += 2 + l + sovConfigClientMachine(uint64(l)) + } + if m.Flag_Etcd_V3_2 != nil { + l = m.Flag_Etcd_V3_2.Size() + n += 2 + l + sovConfigClientMachine(uint64(l)) + } + if m.Flag_Etcd_Tip != nil { + l = m.Flag_Etcd_Tip.Size() + n += 2 + l + sovConfigClientMachine(uint64(l)) + } + if m.Flag_Zookeeper_R3_4_9 != nil { + l = m.Flag_Zookeeper_R3_4_9.Size() + n += 2 + l + sovConfigClientMachine(uint64(l)) + } + if m.Flag_Zookeeper_R3_5_2Alpha != nil { + l = m.Flag_Zookeeper_R3_5_2Alpha.Size() + n += 2 + l + sovConfigClientMachine(uint64(l)) + } + if m.Flag_Consul_V0_7_5 != nil { + l = m.Flag_Consul_V0_7_5.Size() + n += 2 + l + sovConfigClientMachine(uint64(l)) + } + if m.Flag_Consul_V0_8_0 != nil { + l = m.Flag_Consul_V0_8_0.Size() + n += 2 + l + sovConfigClientMachine(uint64(l)) + } + if m.Flag_Cetcd_Beta != nil { + l = m.Flag_Cetcd_Beta.Size() + n += 2 + l + sovConfigClientMachine(uint64(l)) + } + if m.Flag_Zetcd_Beta != nil { + l = m.Flag_Zetcd_Beta.Size() + n += 2 + l + sovConfigClientMachine(uint64(l)) + } + if m.ConfigClientMachineBenchmarkOptions != nil { + l = m.ConfigClientMachineBenchmarkOptions.Size() + n += 2 + l + sovConfigClientMachine(uint64(l)) + } + if m.ConfigClientMachineBenchmarkSteps != nil { + l = m.ConfigClientMachineBenchmarkSteps.Size() + n += 2 + l + sovConfigClientMachine(uint64(l)) + } + return n +} + +func sovConfigClientMachine(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozConfigClientMachine(x uint64) (n int) { + return sovConfigClientMachine(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *ConfigClientMachineInitial) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ConfigClientMachineInitial: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConfigClientMachineInitial: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PathPrefix", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PathPrefix = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LogPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LogPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientSystemMetricsPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientSystemMetricsPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientSystemMetricsInterpolatedPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientSystemMetricsInterpolatedPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientLatencyThroughputTimeseriesPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientLatencyThroughputTimeseriesPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientLatencyDistributionAllPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientLatencyDistributionAllPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientLatencyDistributionPercentilePath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientLatencyDistributionPercentilePath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientLatencyDistributionSummaryPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientLatencyDistributionSummaryPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientLatencyByKeyNumberPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientLatencyByKeyNumberPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ServerDiskSpaceUsageSummaryPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ServerDiskSpaceUsageSummaryPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 100: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GoogleCloudProjectName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GoogleCloudProjectName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 101: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GoogleCloudStorageKeyPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GoogleCloudStorageKeyPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 102: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GoogleCloudStorageKey", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GoogleCloudStorageKey = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 103: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GoogleCloudStorageBucketName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GoogleCloudStorageBucketName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 104: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GoogleCloudStorageSubDirectory", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GoogleCloudStorageSubDirectory = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipConfigClientMachine(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthConfigClientMachine + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ConfigClientMachineBenchmarkOptions) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ConfigClientMachineBenchmarkOptions: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConfigClientMachineBenchmarkOptions: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestNumber", wireType) + } + m.RequestNumber = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RequestNumber |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ConnectionNumber", wireType) + } + m.ConnectionNumber = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ConnectionNumber |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientNumber", wireType) + } + m.ClientNumber = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ClientNumber |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType == 0 { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.ConnectionClientNumbers = append(m.ConnectionClientNumbers, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.ConnectionClientNumbers = append(m.ConnectionClientNumbers, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field ConnectionClientNumbers", wireType) + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RateLimitRequestsPerSecond", wireType) + } + m.RateLimitRequestsPerSecond = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RateLimitRequestsPerSecond |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SameKey", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.SameKey = bool(v != 0) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field KeySizeBytes", wireType) + } + m.KeySizeBytes = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.KeySizeBytes |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ValueSizeBytes", wireType) + } + m.ValueSizeBytes = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ValueSizeBytes |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StaleRead", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.StaleRead = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipConfigClientMachine(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthConfigClientMachine + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ConfigClientMachineBenchmarkSteps) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ConfigClientMachineBenchmarkSteps: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConfigClientMachineBenchmarkSteps: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Step1StartDatabase", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Step1StartDatabase = bool(v != 0) + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Step2StressDatabase", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Step2StressDatabase = bool(v != 0) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Step3StopDatabase", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Step3StopDatabase = bool(v != 0) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Step4UploadLogs", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Step4UploadLogs = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipConfigClientMachine(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthConfigClientMachine + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ConfigClientMachineAgentControl) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ConfigClientMachineAgentControl: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConfigClientMachineAgentControl: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DatabaseID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DatabaseID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DatabaseDescription", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DatabaseDescription = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DatabaseTag", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DatabaseTag = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerIPs", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PeerIPs = append(m.PeerIPs, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerIPsString", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PeerIPsString = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AgentPortToConnect", wireType) + } + m.AgentPortToConnect = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AgentPortToConnect |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AgentEndpoints", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AgentEndpoints = append(m.AgentEndpoints, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DatabasePortToConnect", wireType) + } + m.DatabasePortToConnect = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DatabasePortToConnect |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DatabaseEndpoints", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DatabaseEndpoints = append(m.DatabaseEndpoints, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 100: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Flag_Etcd_V2_3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Flag_Etcd_V2_3 == nil { + m.Flag_Etcd_V2_3 = &Flag_Etcd_V2_3{} + } + if err := m.Flag_Etcd_V2_3.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 101: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Flag_Etcd_V3_1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Flag_Etcd_V3_1 == nil { + m.Flag_Etcd_V3_1 = &Flag_Etcd_V3_1{} + } + if err := m.Flag_Etcd_V3_1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 102: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Flag_Etcd_V3_2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Flag_Etcd_V3_2 == nil { + m.Flag_Etcd_V3_2 = &Flag_Etcd_V3_2{} + } + if err := m.Flag_Etcd_V3_2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 103: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Flag_Etcd_Tip", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Flag_Etcd_Tip == nil { + m.Flag_Etcd_Tip = &Flag_Etcd_Tip{} + } + if err := m.Flag_Etcd_Tip.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 200: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Flag_Zookeeper_R3_4_9", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Flag_Zookeeper_R3_4_9 == nil { + m.Flag_Zookeeper_R3_4_9 = &Flag_Zookeeper_R3_4_9{} + } + if err := m.Flag_Zookeeper_R3_4_9.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 201: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Flag_Zookeeper_R3_5_2Alpha", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Flag_Zookeeper_R3_5_2Alpha == nil { + m.Flag_Zookeeper_R3_5_2Alpha = &Flag_Zookeeper_R3_5_2Alpha{} + } + if err := m.Flag_Zookeeper_R3_5_2Alpha.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 300: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Flag_Consul_V0_7_5", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Flag_Consul_V0_7_5 == nil { + m.Flag_Consul_V0_7_5 = &Flag_Consul_V0_7_5{} + } + if err := m.Flag_Consul_V0_7_5.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 301: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Flag_Consul_V0_8_0", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Flag_Consul_V0_8_0 == nil { + m.Flag_Consul_V0_8_0 = &Flag_Consul_V0_8_0{} + } + if err := m.Flag_Consul_V0_8_0.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 400: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Flag_Cetcd_Beta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Flag_Cetcd_Beta == nil { + m.Flag_Cetcd_Beta = &Flag_Cetcd_Beta{} + } + if err := m.Flag_Cetcd_Beta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 500: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Flag_Zetcd_Beta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Flag_Zetcd_Beta == nil { + m.Flag_Zetcd_Beta = &Flag_Zetcd_Beta{} + } + if err := m.Flag_Zetcd_Beta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 1000: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConfigClientMachineBenchmarkOptions", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ConfigClientMachineBenchmarkOptions == nil { + m.ConfigClientMachineBenchmarkOptions = &ConfigClientMachineBenchmarkOptions{} + } + if err := m.ConfigClientMachineBenchmarkOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 1001: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConfigClientMachineBenchmarkSteps", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthConfigClientMachine + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ConfigClientMachineBenchmarkSteps == nil { + m.ConfigClientMachineBenchmarkSteps = &ConfigClientMachineBenchmarkSteps{} + } + if err := m.ConfigClientMachineBenchmarkSteps.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipConfigClientMachine(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthConfigClientMachine + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipConfigClientMachine(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthConfigClientMachine + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowConfigClientMachine + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipConfigClientMachine(dAtA[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthConfigClientMachine = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowConfigClientMachine = fmt.Errorf("proto: integer overflow") +) + +func init() { + proto.RegisterFile("dbtesterpb/config_client_machine.proto", fileDescriptorConfigClientMachine) +} + +var fileDescriptorConfigClientMachine = []byte{ + // 1761 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x58, 0x6d, 0x6f, 0x1b, 0x49, + 0x1d, 0x3f, 0xd7, 0xed, 0x35, 0x99, 0xb4, 0x4d, 0x33, 0x7d, 0x88, 0x9b, 0xa6, 0x99, 0xdc, 0xa6, + 0xe5, 0x5a, 0x1d, 0xcd, 0x83, 0x9d, 0xde, 0xb5, 0x08, 0x04, 0x75, 0x72, 0x40, 0x95, 0xdc, 0x9d, + 0x59, 0xe7, 0x8a, 0xa8, 0x10, 0xc3, 0x78, 0x3d, 0x59, 0xef, 0x65, 0xbd, 0xb3, 0xec, 0x8c, 0x23, + 0x1c, 0xde, 0x22, 0x21, 0x21, 0x21, 0xdd, 0xcb, 0x7b, 0xc9, 0x07, 0x80, 0xaf, 0x81, 0xca, 0x3b, + 0x3e, 0xc1, 0x0a, 0x7a, 0x42, 0x82, 0xb7, 0x2b, 0x3e, 0x00, 0x9a, 0xff, 0xae, 0xed, 0x59, 0x7b, + 0xe3, 0xf8, 0x9d, 0x77, 0xfe, 0xbf, 0xa7, 0x99, 0x9d, 0xa7, 0x35, 0xfa, 0x4e, 0xbb, 0xa5, 0xb8, + 0x54, 0x3c, 0x0a, 0x5b, 0x5b, 0x8e, 0x08, 0x8e, 0x3d, 0x97, 0x3a, 0xbe, 0xc7, 0x03, 0x45, 0xbb, + 0xcc, 0xe9, 0x78, 0x01, 0xdf, 0x0c, 0x23, 0xa1, 0x04, 0x46, 0x23, 0xdc, 0xca, 0x53, 0xd7, 0x53, + 0x9d, 0x5e, 0x6b, 0xd3, 0x11, 0xdd, 0x2d, 0x57, 0xb8, 0x62, 0x0b, 0x20, 0xad, 0xde, 0x31, 0x3c, + 0xc1, 0x03, 0xfc, 0x4a, 0xa9, 0x2b, 0x2b, 0x86, 0xc5, 0xb1, 0xcf, 0x5c, 0xca, 0x95, 0xd3, 0xce, + 0x6a, 0x64, 0xbc, 0x76, 0x26, 0xc4, 0x09, 0xe7, 0x21, 0x8f, 0x32, 0xc0, 0xea, 0x38, 0xc0, 0x11, + 0x81, 0xec, 0xf9, 0x59, 0xf5, 0xfe, 0x04, 0xdd, 0xd0, 0x9e, 0x28, 0x3a, 0xa3, 0xa2, 0xf5, 0xed, + 0x35, 0xb4, 0xb2, 0x07, 0xfd, 0xdd, 0x83, 0xee, 0x7e, 0x96, 0xf6, 0xf6, 0x55, 0xe0, 0x29, 0x8f, + 0xf9, 0xf8, 0x63, 0x84, 0x1a, 0x4c, 0x75, 0x1a, 0x11, 0x3f, 0xf6, 0x7e, 0x5b, 0x29, 0xad, 0x97, + 0x1e, 0xcf, 0xd7, 0xef, 0x26, 0x31, 0xc1, 0x7d, 0xd6, 0xf5, 0xbf, 0x67, 0x85, 0x4c, 0x75, 0x68, + 0x08, 0x45, 0xcb, 0x36, 0x90, 0xf8, 0x29, 0xba, 0x7a, 0x28, 0x5c, 0xdd, 0x50, 0xb9, 0x04, 0xa4, + 0x5b, 0x49, 0x4c, 0x16, 0x53, 0x92, 0x2f, 0x5c, 0xaa, 0x89, 0x96, 0x3d, 0xc0, 0x60, 0x8a, 0x96, + 0x53, 0xfb, 0x66, 0x5f, 0x2a, 0xde, 0xfd, 0x8c, 0xab, 0xc8, 0x73, 0x24, 0xd0, 0xcb, 0x40, 0x7f, + 0x94, 0xc4, 0xe4, 0x83, 0x94, 0x9e, 0xbd, 0x16, 0x09, 0x48, 0xda, 0x4d, 0xa1, 0x99, 0xe0, 0x79, + 0x2a, 0xf8, 0xf7, 0x25, 0xb4, 0x51, 0x50, 0x7b, 0x15, 0xe8, 0x61, 0x11, 0x3e, 0x53, 0xbc, 0x0d, + 0x6e, 0x97, 0xc1, 0xad, 0x9a, 0xc4, 0x64, 0x73, 0x9a, 0x9b, 0x67, 0xf0, 0x32, 0xeb, 0x59, 0xe4, + 0xf1, 0x1f, 0x4b, 0xe8, 0x51, 0x8a, 0x3b, 0x64, 0x8a, 0x07, 0x4e, 0xff, 0xa8, 0x13, 0x89, 0x9e, + 0xdb, 0x09, 0x7b, 0xea, 0xc8, 0xeb, 0x72, 0xc9, 0x23, 0x8f, 0xa7, 0xdd, 0xbe, 0x02, 0x41, 0x76, + 0x93, 0x98, 0x6c, 0xe7, 0x82, 0xf8, 0x29, 0x8f, 0xaa, 0x21, 0x91, 0xaa, 0x21, 0x33, 0x8b, 0x32, + 0x9b, 0x05, 0xfe, 0x1d, 0x5a, 0xcf, 0x01, 0xf7, 0x3d, 0xa9, 0x22, 0xaf, 0xd5, 0x53, 0x9e, 0x08, + 0x5e, 0xfa, 0x3e, 0xc4, 0x78, 0x1f, 0x62, 0x6c, 0x25, 0x31, 0xf9, 0xa8, 0x30, 0x46, 0xdb, 0xe0, + 0x50, 0xe6, 0xfb, 0x59, 0x82, 0x0b, 0x85, 0xf1, 0xd7, 0x25, 0xf4, 0xe1, 0xb9, 0xa0, 0x06, 0x8f, + 0x1c, 0x1e, 0x28, 0xcf, 0xe7, 0x10, 0xe2, 0x2a, 0x84, 0xf8, 0x38, 0x89, 0x49, 0xf5, 0xe2, 0x10, + 0xe1, 0x90, 0x9b, 0x65, 0x99, 0xd5, 0x06, 0xff, 0xa1, 0x84, 0x1e, 0x9e, 0x8b, 0x6d, 0xf6, 0xba, + 0x5d, 0x16, 0xf5, 0x21, 0xcf, 0x1c, 0xe4, 0xa9, 0x25, 0x31, 0xd9, 0xba, 0x38, 0x8f, 0x4c, 0x89, + 0x59, 0x98, 0x99, 0x0c, 0x70, 0x88, 0x56, 0x73, 0xb8, 0x7a, 0xff, 0x80, 0xf7, 0x3f, 0xef, 0x75, + 0x5b, 0x3c, 0x82, 0x00, 0xf3, 0x10, 0xe0, 0xbb, 0x49, 0x4c, 0x1e, 0x17, 0x06, 0x68, 0xf5, 0xe9, + 0x09, 0xef, 0xd3, 0x00, 0x18, 0x99, 0xf3, 0x54, 0x45, 0xdc, 0x47, 0xa4, 0xc9, 0xa3, 0x53, 0x1e, + 0xed, 0x7b, 0xf2, 0xa4, 0x19, 0x32, 0x87, 0x7f, 0x29, 0x99, 0xcb, 0xcd, 0x5e, 0xa3, 0xf1, 0xa9, + 0x20, 0x81, 0xa0, 0x7b, 0x7b, 0x42, 0xa5, 0xa6, 0xd0, 0x9e, 0xe6, 0x8c, 0xf5, 0xf8, 0x22, 0x5d, + 0xfc, 0x4b, 0x74, 0xf7, 0x27, 0x42, 0xb8, 0x3e, 0xdf, 0xf3, 0x45, 0xaf, 0xdd, 0x88, 0xc4, 0x57, + 0xdc, 0x51, 0x9f, 0xb3, 0x2e, 0xaf, 0xb4, 0xc1, 0xf1, 0x61, 0x12, 0x93, 0xf5, 0xd4, 0xd1, 0x05, + 0x1c, 0x75, 0x34, 0x90, 0x86, 0x29, 0x92, 0x06, 0xac, 0xcb, 0x2d, 0xfb, 0x1c, 0x0d, 0x7c, 0x8c, + 0xee, 0x19, 0x95, 0xa6, 0x12, 0x11, 0x73, 0xf9, 0x01, 0x4f, 0xbb, 0xc4, 0xc1, 0xe0, 0x71, 0x12, + 0x93, 0x87, 0x05, 0x06, 0x32, 0x05, 0xc3, 0x50, 0xa6, 0x7d, 0x39, 0x5f, 0x0a, 0xef, 0xa2, 0x3b, + 0x85, 0xc5, 0xca, 0xb1, 0xf6, 0xb0, 0x8b, 0x8b, 0x58, 0xa0, 0xd5, 0xc9, 0x42, 0xbd, 0xe7, 0x9c, + 0xf0, 0x74, 0x04, 0x5c, 0x08, 0xf8, 0x51, 0x12, 0x93, 0x0f, 0xa7, 0x04, 0x6c, 0x01, 0x21, 0x1b, + 0x88, 0xa9, 0x82, 0xb8, 0x87, 0xd6, 0x26, 0xeb, 0xcd, 0x5e, 0x6b, 0xdf, 0x8b, 0xb8, 0xa3, 0x44, + 0xd4, 0xaf, 0x74, 0xc0, 0xf2, 0x69, 0x12, 0x93, 0x27, 0x53, 0x2c, 0x65, 0xaf, 0x45, 0xdb, 0x03, + 0x8e, 0x65, 0x5f, 0x20, 0x6a, 0xfd, 0xed, 0x0a, 0xda, 0x28, 0x38, 0x65, 0xea, 0x3c, 0x70, 0x3a, + 0x5d, 0x16, 0x9d, 0x7c, 0x11, 0xea, 0x25, 0x20, 0xf1, 0x06, 0xba, 0x7c, 0xd4, 0x0f, 0x79, 0x76, + 0xd0, 0x2c, 0x26, 0x31, 0x59, 0x48, 0x43, 0xa8, 0x7e, 0xc8, 0x2d, 0x1b, 0x8a, 0xf8, 0x87, 0xe8, + 0xba, 0xcd, 0x7f, 0xd3, 0xe3, 0x52, 0xa5, 0x13, 0x18, 0x4e, 0x98, 0x72, 0xfd, 0x5e, 0x12, 0x93, + 0x3b, 0x29, 0x3a, 0x4a, 0xcb, 0xd9, 0x02, 0xb0, 0xec, 0x3c, 0x1e, 0xff, 0x14, 0xdd, 0xdc, 0x13, + 0x41, 0xc0, 0x1d, 0x6d, 0x9a, 0x69, 0x94, 0x41, 0x63, 0x35, 0x89, 0x49, 0x25, 0x5b, 0x52, 0x43, + 0xc4, 0x50, 0x66, 0x82, 0x85, 0xbf, 0x8f, 0xae, 0xa5, 0x1d, 0xca, 0x54, 0x2e, 0x83, 0x4a, 0x25, + 0x89, 0xc9, 0xed, 0xdc, 0xc2, 0x1c, 0x28, 0xe4, 0xd0, 0xf8, 0x57, 0x68, 0x79, 0xa4, 0x68, 0x56, + 0x64, 0xe5, 0xca, 0x7a, 0xf9, 0x71, 0xd9, 0x9c, 0xfa, 0x46, 0x9c, 0x9c, 0xa6, 0xd4, 0x87, 0x5e, + 0xb1, 0x08, 0xf6, 0xd0, 0x8a, 0xcd, 0x14, 0x3f, 0xf4, 0xba, 0x9e, 0xca, 0x46, 0x40, 0x36, 0x78, + 0xd4, 0xe4, 0x8e, 0x08, 0xda, 0xb0, 0xb5, 0x97, 0xeb, 0x4f, 0x92, 0x98, 0x3c, 0xca, 0x46, 0x8d, + 0x29, 0x4e, 0x7d, 0x0d, 0xa6, 0xd9, 0x00, 0x4a, 0xbd, 0x9b, 0x52, 0x09, 0x78, 0xcb, 0x9e, 0x22, + 0xa6, 0xcf, 0xfb, 0x26, 0xeb, 0xc2, 0x84, 0xd7, 0xbb, 0xf5, 0x9c, 0x79, 0xde, 0x4b, 0xd6, 0x85, + 0x45, 0x64, 0xd9, 0x03, 0x0c, 0xfe, 0x01, 0xba, 0x76, 0xc0, 0xfb, 0x4d, 0xef, 0x8c, 0xd7, 0xfb, + 0x8a, 0x4b, 0xd8, 0x51, 0x73, 0x6f, 0x50, 0xaf, 0x39, 0xe9, 0x9d, 0x71, 0xda, 0xd2, 0x75, 0xcb, + 0xce, 0xc1, 0xf1, 0x1e, 0xba, 0xf1, 0x9a, 0xf9, 0x3d, 0x3e, 0x12, 0x98, 0x07, 0x81, 0xfb, 0x49, + 0x4c, 0x96, 0x53, 0x81, 0x53, 0x5d, 0xcf, 0x49, 0x8c, 0x51, 0x70, 0x0d, 0xcd, 0x37, 0x15, 0xf3, + 0xb9, 0xcd, 0x59, 0x1b, 0x36, 0xb7, 0xb9, 0xfa, 0x9d, 0x24, 0x26, 0x4b, 0x59, 0x68, 0x5d, 0xa2, + 0x11, 0x67, 0x6d, 0xcb, 0x1e, 0xe1, 0xac, 0xf8, 0x12, 0xfa, 0x60, 0xda, 0x44, 0x6e, 0x2a, 0x1e, + 0x4a, 0xfc, 0x05, 0xc2, 0xfa, 0xc7, 0x4e, 0x53, 0xb1, 0x48, 0xed, 0x33, 0xc5, 0x5a, 0x4c, 0xa6, + 0x93, 0x7a, 0xae, 0x4e, 0x92, 0x98, 0xdc, 0x1f, 0x78, 0xf0, 0x70, 0x87, 0x4a, 0x0d, 0xa2, 0xed, + 0x0c, 0x65, 0xd9, 0x05, 0x54, 0x6c, 0xa3, 0x5b, 0xba, 0xb5, 0xda, 0x54, 0x11, 0x97, 0x72, 0xa8, + 0x78, 0x09, 0x14, 0xd7, 0x93, 0x98, 0xac, 0x8e, 0x14, 0xab, 0x54, 0x02, 0xca, 0x90, 0x2c, 0x22, + 0xe3, 0x43, 0xb4, 0xa4, 0x9b, 0x6b, 0x4d, 0x25, 0xc2, 0xa1, 0x62, 0x19, 0x14, 0xd7, 0x92, 0x98, + 0xac, 0x8c, 0x14, 0x6b, 0x7a, 0xd9, 0x87, 0x86, 0xde, 0x24, 0x11, 0xff, 0x18, 0x2d, 0xea, 0xc6, + 0xdd, 0x2f, 0x43, 0x5f, 0xb0, 0xf6, 0xa1, 0x70, 0x25, 0x2c, 0x86, 0x39, 0x73, 0x49, 0x69, 0xad, + 0x5d, 0xda, 0x03, 0x04, 0xf5, 0x85, 0x2b, 0x2d, 0x7b, 0x9c, 0x64, 0xfd, 0x7b, 0x11, 0x91, 0x82, + 0x01, 0x7e, 0xe9, 0xf2, 0x40, 0xed, 0x89, 0x40, 0x45, 0x02, 0x2e, 0xa5, 0x03, 0xdf, 0x57, 0xfb, + 0x93, 0x97, 0xd2, 0x41, 0x4e, 0xea, 0xb5, 0x2d, 0xdb, 0x40, 0xe2, 0x9f, 0xa1, 0x5b, 0x83, 0xa7, + 0x7d, 0x2e, 0x9d, 0xc8, 0x83, 0x5d, 0x27, 0xbb, 0xa0, 0x1a, 0xef, 0x65, 0x28, 0xd0, 0x1e, 0xa1, + 0x2c, 0xbb, 0x88, 0x8b, 0x5f, 0xa0, 0x85, 0x41, 0xf3, 0x11, 0x73, 0xb3, 0xcb, 0xea, 0x72, 0x12, + 0x93, 0x5b, 0x63, 0x52, 0x8a, 0xb9, 0x96, 0x6d, 0x62, 0xf5, 0x92, 0x69, 0x70, 0x1e, 0xbd, 0x6a, + 0xe8, 0x91, 0x2a, 0xe7, 0xaf, 0xc8, 0x21, 0xe7, 0x11, 0xf5, 0x42, 0x69, 0xd9, 0x03, 0x0c, 0xfe, + 0x11, 0xba, 0x9e, 0xfd, 0x6c, 0xaa, 0xc8, 0x0b, 0xdc, 0xec, 0x86, 0xb8, 0x92, 0xc4, 0xe4, 0x6e, + 0x9e, 0xa4, 0xdf, 0xbf, 0x17, 0xb8, 0x96, 0x9d, 0x27, 0xe0, 0x06, 0xc2, 0x30, 0x8c, 0x0d, 0x11, + 0xa9, 0x23, 0x91, 0x6d, 0x1a, 0xd9, 0x36, 0x60, 0xcc, 0x21, 0xa6, 0x31, 0x34, 0x14, 0x91, 0xa2, + 0x4a, 0xd0, 0x6c, 0xdf, 0xb1, 0xec, 0x02, 0x2e, 0xae, 0xa3, 0x1b, 0xd0, 0xfa, 0x69, 0xd0, 0x0e, + 0x85, 0x17, 0x28, 0x59, 0xb9, 0x0a, 0x3d, 0x31, 0x42, 0xa5, 0x6a, 0x7c, 0x00, 0xb0, 0xec, 0x31, + 0x06, 0xfe, 0x05, 0xba, 0x33, 0x18, 0x95, 0x7c, 0xb0, 0x74, 0x4f, 0xd8, 0x48, 0x62, 0x42, 0xc6, + 0xc6, 0x72, 0x22, 0x5b, 0xb1, 0x02, 0x3e, 0x40, 0x4b, 0x83, 0xc2, 0x28, 0xe1, 0x3c, 0x24, 0x7c, + 0x90, 0xc4, 0xe4, 0xde, 0x98, 0xac, 0x11, 0x72, 0x92, 0x87, 0xdf, 0xa0, 0x9b, 0xf0, 0xf1, 0x04, + 0x5f, 0x6d, 0x94, 0x9e, 0x56, 0x69, 0x0d, 0x2e, 0x28, 0x0b, 0xd5, 0xd5, 0xcd, 0xd1, 0x07, 0xd6, + 0xe6, 0x38, 0xc6, 0xdc, 0x53, 0x46, 0xad, 0x96, 0xbd, 0xa0, 0x81, 0x9f, 0x2a, 0xa7, 0xfd, 0xba, + 0x5a, 0x9b, 0xd0, 0xae, 0xd1, 0x1d, 0xb8, 0x9b, 0x4c, 0xd3, 0xae, 0xd1, 0x9d, 0x02, 0xed, 0x1a, + 0xdd, 0x31, 0xb5, 0x6b, 0x3b, 0x05, 0xda, 0x55, 0xb8, 0x93, 0x4c, 0xd7, 0xae, 0x16, 0x6a, 0x57, + 0x73, 0xda, 0x55, 0xfc, 0x73, 0xb4, 0x68, 0xf2, 0x94, 0x17, 0xc2, 0x8d, 0x65, 0xa1, 0x7a, 0xff, + 0x3c, 0x69, 0xe5, 0x85, 0xf5, 0xdb, 0x49, 0x4c, 0x6e, 0x9a, 0xca, 0xca, 0x0b, 0x0d, 0xe1, 0x23, + 0x2f, 0xc4, 0xa7, 0x68, 0x39, 0x65, 0x0d, 0x3f, 0x83, 0x29, 0x8d, 0x6a, 0x74, 0x97, 0xbe, 0xa8, + 0xbc, 0x2d, 0x81, 0xc3, 0xc6, 0xa4, 0xc3, 0x04, 0xd6, 0xdc, 0x7b, 0x26, 0x8a, 0x96, 0xbd, 0xa4, + 0x69, 0x6f, 0x06, 0xed, 0x76, 0x6d, 0xf7, 0x05, 0xfe, 0x53, 0x09, 0x3d, 0x28, 0x12, 0x7b, 0x46, + 0xab, 0x94, 0xf9, 0x61, 0x87, 0x55, 0xfe, 0x9e, 0xda, 0x3f, 0xb9, 0xc8, 0x7e, 0xc8, 0xa8, 0x5b, + 0x49, 0x4c, 0xd6, 0x8a, 0x42, 0x0c, 0x21, 0x96, 0x7d, 0x77, 0x2c, 0xca, 0xb3, 0xea, 0x4b, 0x5d, + 0xc0, 0x5f, 0xa1, 0xdb, 0xa9, 0x78, 0xfa, 0xb5, 0x4f, 0xe9, 0xe9, 0x36, 0xfd, 0x84, 0x3e, 0xab, + 0xfc, 0xe5, 0x12, 0xa4, 0x58, 0x9f, 0x4c, 0x91, 0x07, 0x9a, 0x47, 0x6a, 0xbe, 0x62, 0xd9, 0x37, + 0x34, 0x61, 0x0f, 0x1a, 0x5f, 0x6f, 0x7f, 0xf2, 0xac, 0xd0, 0xeb, 0x39, 0xdd, 0xae, 0xfc, 0x75, + 0x16, 0xaf, 0xe7, 0x74, 0xfb, 0x1c, 0xaf, 0xe7, 0x74, 0x7b, 0xcc, 0xeb, 0xf9, 0x36, 0xfe, 0x35, + 0x5a, 0xca, 0x24, 0xd2, 0x19, 0xd0, 0xe2, 0x8a, 0x55, 0xbe, 0x2e, 0x83, 0xd1, 0x83, 0x02, 0xa3, + 0x11, 0xca, 0xdc, 0xe8, 0x8d, 0x66, 0xcb, 0xbe, 0x0e, 0x16, 0xba, 0xa5, 0xce, 0x15, 0x1b, 0x39, + 0x9c, 0x19, 0x0e, 0xff, 0x3b, 0xd7, 0xe1, 0xac, 0xd8, 0xe1, 0x6c, 0xc2, 0xe1, 0xcd, 0xd0, 0xe1, + 0xcf, 0xa5, 0x99, 0xee, 0xb4, 0x95, 0xff, 0x5c, 0x05, 0xd3, 0x2d, 0xd3, 0x74, 0x06, 0x9e, 0x39, + 0x79, 0x5b, 0x83, 0x1a, 0x15, 0x69, 0xd1, 0xb2, 0x67, 0xba, 0x4e, 0x7f, 0x53, 0x9a, 0xe1, 0xb6, + 0x52, 0xf9, 0x6f, 0x1a, 0xf0, 0xe9, 0xac, 0x01, 0x81, 0x65, 0xee, 0xf1, 0xa3, 0x78, 0xfa, 0x84, + 0x97, 0x96, 0x7d, 0xb1, 0x69, 0xfd, 0xf6, 0xdb, 0x7f, 0xad, 0xbd, 0xf7, 0xf6, 0xdd, 0x5a, 0xe9, + 0x1f, 0xef, 0xd6, 0x4a, 0xff, 0x7c, 0xb7, 0x56, 0xfa, 0xe6, 0xdb, 0xb5, 0xf7, 0x5a, 0xef, 0xc3, + 0x9f, 0x52, 0xb5, 0xff, 0x07, 0x00, 0x00, 0xff, 0xff, 0xc1, 0x09, 0x69, 0xa2, 0x8e, 0x13, 0x00, + 0x00, +} diff --git a/dbtesterpb/config_client_machine.proto b/dbtesterpb/config_client_machine.proto new file mode 100644 index 00000000..e38d4854 --- /dev/null +++ b/dbtesterpb/config_client_machine.proto @@ -0,0 +1,92 @@ +syntax = "proto3"; +package dbtesterpb; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +import "dbtesterpb/flag_etcd.proto"; +import "dbtesterpb/flag_zookeeper.proto"; +import "dbtesterpb/flag_consul.proto"; +import "dbtesterpb/flag_zetcd.proto"; +import "dbtesterpb/flag_cetcd.proto"; + +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.goproto_getters_all) = false; + +// ConfigClientMachineInitial represents common control options on client machine. +message ConfigClientMachineInitial { + string PathPrefix = 1 [(gogoproto.moretags) = "yaml:\"path_prefix\""]; + string LogPath = 2 [(gogoproto.moretags) = "yaml:\"log_path\""]; + string ClientSystemMetricsPath = 3 [(gogoproto.moretags) = "yaml:\"client_system_metrics_path\""]; + string ClientSystemMetricsInterpolatedPath = 4 [(gogoproto.moretags) = "yaml:\"client_system_metrics_interpolated_path\""]; + string ClientLatencyThroughputTimeseriesPath = 5 [(gogoproto.moretags) = "yaml:\"client_latency_throughput_timeseries_path\""]; + string ClientLatencyDistributionAllPath = 6 [(gogoproto.moretags) = "yaml:\"client_latency_distribution_all_path\""]; + string ClientLatencyDistributionPercentilePath = 7 [(gogoproto.moretags) = "yaml:\"client_latency_distribution_percentile_path\""]; + string ClientLatencyDistributionSummaryPath = 8 [(gogoproto.moretags) = "yaml:\"client_latency_distribution_summary_path\""]; + string ClientLatencyByKeyNumberPath = 9 [(gogoproto.moretags) = "yaml:\"client_latency_by_key_number_path\""]; + string ServerDiskSpaceUsageSummaryPath = 10 [(gogoproto.moretags) = "yaml:\"server_disk_space_usage_summary_path\""]; + + string GoogleCloudProjectName = 100 [(gogoproto.moretags) = "yaml:\"google_cloud_project_name\""]; + string GoogleCloudStorageKeyPath = 101 [(gogoproto.moretags) = "yaml:\"google_cloud_storage_key_path\""]; + string GoogleCloudStorageKey = 102; + string GoogleCloudStorageBucketName = 103 [(gogoproto.moretags) = "yaml:\"google_cloud_storage_bucket_name\""]; + string GoogleCloudStorageSubDirectory = 104 [(gogoproto.moretags) = "yaml:\"google_cloud_storage_sub_directory\""]; +} + +// ConfigClientMachineBenchmarkOptions represents benchmark options. +message ConfigClientMachineBenchmarkOptions { + string Type = 1 [(gogoproto.moretags) = "yaml:\"type\""]; + int64 RequestNumber = 2 [(gogoproto.moretags) = "yaml:\"request_number\""]; + int64 ConnectionNumber = 3 [(gogoproto.moretags) = "yaml:\"connection_number\""]; + int64 ClientNumber = 4 [(gogoproto.moretags) = "yaml:\"client_number\""]; + repeated int64 ConnectionClientNumbers = 5 [(gogoproto.moretags) = "yaml:\"connection_client_numbers\""]; + int64 RateLimitRequestsPerSecond = 6 [(gogoproto.moretags) = "yaml:\"rate_limit_requests_per_second\""]; + + bool SameKey = 7 [(gogoproto.moretags) = "yaml:\"same_key\""]; + int64 KeySizeBytes = 8 [(gogoproto.moretags) = "yaml:\"key_size_bytes\""]; + int64 ValueSizeBytes = 9 [(gogoproto.moretags) = "yaml:\"value_size_bytes\""]; + + bool StaleRead = 10 [(gogoproto.moretags) = "yaml:\"stale_read\""]; +} + +// ConfigClientMachineBenchmarkSteps represents benchmark steps. +message ConfigClientMachineBenchmarkSteps { + bool Step1StartDatabase = 1 [(gogoproto.moretags) = "yaml:\"step1_start_database\""]; + bool Step2StressDatabase = 2 [(gogoproto.moretags) = "yaml:\"step2_stress_database\""]; + bool Step3StopDatabase = 3 [(gogoproto.moretags) = "yaml:\"step3_stop_database\""]; + bool Step4UploadLogs = 4 [(gogoproto.moretags) = "yaml:\"step4_upload_logs\""]; +} + +// ConfigClientMachineAgentControl represents control options on client machine. +message ConfigClientMachineAgentControl { + string DatabaseID = 1 [(gogoproto.moretags) = "yaml:\"database_id\""]; + string DatabaseDescription = 2 [(gogoproto.moretags) = "yaml:\"database_description\""]; + string DatabaseTag = 3 [(gogoproto.moretags) = "yaml:\"database_tag\""]; + + repeated string PeerIPs = 4 [(gogoproto.moretags) = "yaml:\"peer_ips\""]; + string PeerIPsString = 5 [(gogoproto.moretags) = "yaml:\"peer_ips_string\""]; + + int64 AgentPortToConnect = 6 [(gogoproto.moretags) = "yaml:\"agent_port_to_connect\""]; + repeated string AgentEndpoints = 7 [(gogoproto.moretags) = "yaml:\"agent_endpoints\""]; + + int64 DatabasePortToConnect = 8 [(gogoproto.moretags) = "yaml:\"database_port_to_connect\""]; + repeated string DatabaseEndpoints = 9 [(gogoproto.moretags) = "yaml:\"database_endpoints\""]; + + flag__etcd__v2_3 flag__etcd__v2_3 = 100 [(gogoproto.moretags) = "yaml:\"etcd__v2_3\""]; + flag__etcd__v3_1 flag__etcd__v3_1 = 101 [(gogoproto.moretags) = "yaml:\"etcd__v3_1\""]; + flag__etcd__v3_2 flag__etcd__v3_2 = 102 [(gogoproto.moretags) = "yaml:\"etcd__v3_2\""]; + flag__etcd__tip flag__etcd__tip = 103 [(gogoproto.moretags) = "yaml:\"etcd__tip\""]; + + flag__zookeeper__r3_4_9 flag__zookeeper__r3_4_9 = 200 [(gogoproto.moretags) = "yaml:\"zookeeper__r3_4_9\""]; + flag__zookeeper__r3_5_2_alpha flag__zookeeper__r3_5_2_alpha = 201 [(gogoproto.moretags) = "yaml:\"zookeeper__r3_5_2_alpha\""]; + + flag__consul__v0_7_5 flag__consul__v0_7_5 = 300 [(gogoproto.moretags) = "yaml:\"consul__v0_7_5\""]; + flag__consul__v0_8_0 flag__consul__v0_8_0 = 301 [(gogoproto.moretags) = "yaml:\"consul__v0_8_0\""]; + + flag__cetcd__beta flag__cetcd__beta = 400 [(gogoproto.moretags) = "yaml:\"cetcd__beta\""]; + flag__zetcd__beta flag__zetcd__beta = 500 [(gogoproto.moretags) = "yaml:\"zetcd__beta\""]; + + ConfigClientMachineBenchmarkOptions ConfigClientMachineBenchmarkOptions = 1000 [(gogoproto.moretags) = "yaml:\"benchmark_options\""]; + ConfigClientMachineBenchmarkSteps ConfigClientMachineBenchmarkSteps = 1001 [(gogoproto.moretags) = "yaml:\"benchmark_steps\""]; +} diff --git a/dbtesterpb/database_id.pb.go b/dbtesterpb/database_id.pb.go new file mode 100644 index 00000000..8c706218 --- /dev/null +++ b/dbtesterpb/database_id.pb.go @@ -0,0 +1,88 @@ +// Code generated by protoc-gen-gogo. +// source: dbtesterpb/database_id.proto +// DO NOT EDIT! + +package dbtesterpb + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" +import _ "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// differentiate between major or minor releases +// (possibly different APIs) +type DatabaseID int32 + +const ( + DatabaseID_etcd__v2_3 DatabaseID = 0 + DatabaseID_etcd__v3_1 DatabaseID = 1 + DatabaseID_etcd__v3_2 DatabaseID = 2 + DatabaseID_etcd__tip DatabaseID = 3 + DatabaseID_zookeeper__r3_4_9 DatabaseID = 10 + DatabaseID_zookeeper__r3_5_2_alpha DatabaseID = 11 + DatabaseID_consul__v0_7_5 DatabaseID = 20 + DatabaseID_consul__v0_8_0 DatabaseID = 21 + DatabaseID_zetcd__beta DatabaseID = 30 + DatabaseID_cetcd__beta DatabaseID = 40 +) + +var DatabaseID_name = map[int32]string{ + 0: "etcd__v2_3", + 1: "etcd__v3_1", + 2: "etcd__v3_2", + 3: "etcd__tip", + 10: "zookeeper__r3_4_9", + 11: "zookeeper__r3_5_2_alpha", + 20: "consul__v0_7_5", + 21: "consul__v0_8_0", + 30: "zetcd__beta", + 40: "cetcd__beta", +} +var DatabaseID_value = map[string]int32{ + "etcd__v2_3": 0, + "etcd__v3_1": 1, + "etcd__v3_2": 2, + "etcd__tip": 3, + "zookeeper__r3_4_9": 10, + "zookeeper__r3_5_2_alpha": 11, + "consul__v0_7_5": 20, + "consul__v0_8_0": 21, + "zetcd__beta": 30, + "cetcd__beta": 40, +} + +func (x DatabaseID) String() string { + return proto.EnumName(DatabaseID_name, int32(x)) +} +func (DatabaseID) EnumDescriptor() ([]byte, []int) { return fileDescriptorDatabaseId, []int{0} } + +func init() { + proto.RegisterEnum("dbtesterpb.DatabaseID", DatabaseID_name, DatabaseID_value) +} + +func init() { proto.RegisterFile("dbtesterpb/database_id.proto", fileDescriptorDatabaseId) } + +var fileDescriptorDatabaseId = []byte{ + // 245 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x5c, 0x8f, 0xcf, 0x4a, 0xc3, 0x40, + 0x10, 0x87, 0xb3, 0x0a, 0x82, 0x53, 0xac, 0xe3, 0xd2, 0x22, 0xa8, 0xec, 0x59, 0x04, 0x9b, 0x9a, + 0x58, 0xd4, 0xab, 0xf4, 0xe2, 0x53, 0x0c, 0xbb, 0xc9, 0x9a, 0x06, 0xab, 0xbb, 0x24, 0x93, 0x1e, + 0xfa, 0x24, 0x3e, 0x52, 0xbd, 0xf9, 0x08, 0x1a, 0x5f, 0x44, 0xdc, 0x08, 0x36, 0xde, 0xe6, 0xfb, + 0xe6, 0x1f, 0x3f, 0x38, 0xcb, 0x0d, 0xdb, 0x9a, 0x6d, 0xe5, 0x4d, 0x9c, 0x6b, 0xd6, 0x46, 0xd7, + 0x96, 0xca, 0x7c, 0xe2, 0x2b, 0xc7, 0x4e, 0xc2, 0x5f, 0xf7, 0xe4, 0xb2, 0x28, 0x79, 0xd1, 0x98, + 0x49, 0xe6, 0x9e, 0xe3, 0xc2, 0x15, 0x2e, 0x0e, 0x23, 0xa6, 0x79, 0x0c, 0x14, 0x20, 0x54, 0xdd, + 0xea, 0xc5, 0x9b, 0x00, 0x98, 0xff, 0x1e, 0x7c, 0x98, 0xcb, 0x21, 0x80, 0xe5, 0x2c, 0x27, 0x5a, + 0x25, 0x94, 0x62, 0xb4, 0xc5, 0x29, 0x5d, 0xa1, 0xe8, 0x71, 0x82, 0x3b, 0xf2, 0x00, 0xf6, 0x3b, + 0xe6, 0xd2, 0xe3, 0xae, 0x1c, 0xc3, 0xd1, 0xda, 0xb9, 0x27, 0x6b, 0xbd, 0xad, 0x88, 0xaa, 0x94, + 0xae, 0xe9, 0x0e, 0x41, 0x9e, 0xc2, 0x71, 0x5f, 0xcf, 0x28, 0x21, 0xbd, 0xf4, 0x0b, 0x8d, 0x03, + 0x29, 0x61, 0x98, 0xb9, 0x97, 0xba, 0x59, 0x12, 0xad, 0xa6, 0x74, 0x43, 0x33, 0x1c, 0xfd, 0x73, + 0xb7, 0x34, 0xc5, 0xb1, 0x3c, 0x84, 0xc1, 0xba, 0xfb, 0x65, 0x2c, 0x6b, 0x54, 0x3f, 0x22, 0xdb, + 0x12, 0xe7, 0xf7, 0xa3, 0xcd, 0xa7, 0x8a, 0x36, 0xad, 0x12, 0xef, 0xad, 0x12, 0x1f, 0xad, 0x12, + 0xaf, 0x5f, 0x2a, 0x32, 0x7b, 0x21, 0x68, 0xfa, 0x1d, 0x00, 0x00, 0xff, 0xff, 0x89, 0x6f, 0x4c, + 0x96, 0x43, 0x01, 0x00, 0x00, +} diff --git a/dbtesterpb/database_id.proto b/dbtesterpb/database_id.proto new file mode 100644 index 00000000..7e6cd3f2 --- /dev/null +++ b/dbtesterpb/database_id.proto @@ -0,0 +1,27 @@ +syntax = "proto3"; +package dbtesterpb; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.goproto_getters_all) = false; + +// differentiate between major or minor releases +// (possibly different APIs) +enum DatabaseID { + etcd__v2_3 = 0; + etcd__v3_1 = 1; + etcd__v3_2 = 2; + etcd__tip = 3; + + zookeeper__r3_4_9 = 10; + zookeeper__r3_5_2_alpha = 11; + + consul__v0_7_5 = 20; + consul__v0_8_0 = 21; + + zetcd__beta = 30; + cetcd__beta = 40; +} diff --git a/dbtesterpb/flag_cetcd.pb.go b/dbtesterpb/flag_cetcd.pb.go new file mode 100644 index 00000000..cd1071c1 --- /dev/null +++ b/dbtesterpb/flag_cetcd.pb.go @@ -0,0 +1,264 @@ +// Code generated by protoc-gen-gogo. +// source: dbtesterpb/flag_cetcd.proto +// DO NOT EDIT! + +package dbtesterpb + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" +import _ "github.com/gogo/protobuf/gogoproto" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// Flag_Cetcd_Beta is cetcd-specific flags +// (https://github.com/coreos/cetcd). +type Flag_Cetcd_Beta struct { +} + +func (m *Flag_Cetcd_Beta) Reset() { *m = Flag_Cetcd_Beta{} } +func (m *Flag_Cetcd_Beta) String() string { return proto.CompactTextString(m) } +func (*Flag_Cetcd_Beta) ProtoMessage() {} +func (*Flag_Cetcd_Beta) Descriptor() ([]byte, []int) { return fileDescriptorFlagCetcd, []int{0} } + +func init() { + proto.RegisterType((*Flag_Cetcd_Beta)(nil), "dbtesterpb.flag__cetcd__beta") +} +func (m *Flag_Cetcd_Beta) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Flag_Cetcd_Beta) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func encodeFixed64FlagCetcd(dAtA []byte, offset int, v uint64) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) + dAtA[offset+4] = uint8(v >> 32) + dAtA[offset+5] = uint8(v >> 40) + dAtA[offset+6] = uint8(v >> 48) + dAtA[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32FlagCetcd(dAtA []byte, offset int, v uint32) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintFlagCetcd(dAtA []byte, offset int, v uint64) int { + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return offset + 1 +} +func (m *Flag_Cetcd_Beta) Size() (n int) { + var l int + _ = l + return n +} + +func sovFlagCetcd(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozFlagCetcd(x uint64) (n int) { + return sovFlagCetcd(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Flag_Cetcd_Beta) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagCetcd + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: flag__cetcd__beta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: flag__cetcd__beta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipFlagCetcd(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFlagCetcd + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipFlagCetcd(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFlagCetcd + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFlagCetcd + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFlagCetcd + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthFlagCetcd + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFlagCetcd + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipFlagCetcd(dAtA[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthFlagCetcd = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowFlagCetcd = fmt.Errorf("proto: integer overflow") +) + +func init() { proto.RegisterFile("dbtesterpb/flag_cetcd.proto", fileDescriptorFlagCetcd) } + +var fileDescriptorFlagCetcd = []byte{ + // 130 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4e, 0x49, 0x2a, 0x49, + 0x2d, 0x2e, 0x49, 0x2d, 0x2a, 0x48, 0xd2, 0x4f, 0xcb, 0x49, 0x4c, 0x8f, 0x4f, 0x4e, 0x2d, 0x49, + 0x4e, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x42, 0x48, 0x4a, 0xe9, 0xa6, 0x67, 0x96, + 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0xa7, 0xe7, 0xa7, 0xe7, 0xeb, 0x83, 0x95, 0x24, + 0x95, 0xa6, 0x81, 0x79, 0x60, 0x0e, 0x98, 0x05, 0xd1, 0xaa, 0x24, 0xcc, 0x25, 0x08, 0x36, 0x0e, + 0x62, 0x5e, 0x7c, 0x7c, 0x52, 0x6a, 0x49, 0xa2, 0x93, 0xc8, 0x89, 0x87, 0x72, 0x0c, 0x27, 0x1e, + 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x8c, 0xc7, 0x72, 0x0c, 0x49, + 0x6c, 0x60, 0x1d, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0xcf, 0x7e, 0x95, 0x6e, 0x8b, 0x00, + 0x00, 0x00, +} diff --git a/dbtesterpb/flag_cetcd.proto b/dbtesterpb/flag_cetcd.proto new file mode 100644 index 00000000..d83e3cd3 --- /dev/null +++ b/dbtesterpb/flag_cetcd.proto @@ -0,0 +1,14 @@ +syntax = "proto3"; +package dbtesterpb; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.goproto_getters_all) = false; + +// Flag_Cetcd_Beta is cetcd-specific flags +// (https://github.com/coreos/cetcd). +message flag__cetcd__beta { +} diff --git a/dbtesterpb/flag_consul.pb.go b/dbtesterpb/flag_consul.pb.go new file mode 100644 index 00000000..9cda5ffe --- /dev/null +++ b/dbtesterpb/flag_consul.pb.go @@ -0,0 +1,347 @@ +// Code generated by protoc-gen-gogo. +// source: dbtesterpb/flag_consul.proto +// DO NOT EDIT! + +package dbtesterpb + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" +import _ "github.com/gogo/protobuf/gogoproto" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// See https://github.com/hashicorp/consul for more. +type Flag_Consul_V0_7_5 struct { +} + +func (m *Flag_Consul_V0_7_5) Reset() { *m = Flag_Consul_V0_7_5{} } +func (m *Flag_Consul_V0_7_5) String() string { return proto.CompactTextString(m) } +func (*Flag_Consul_V0_7_5) ProtoMessage() {} +func (*Flag_Consul_V0_7_5) Descriptor() ([]byte, []int) { return fileDescriptorFlagConsul, []int{0} } + +// See https://github.com/hashicorp/consul for more. +type Flag_Consul_V0_8_0 struct { +} + +func (m *Flag_Consul_V0_8_0) Reset() { *m = Flag_Consul_V0_8_0{} } +func (m *Flag_Consul_V0_8_0) String() string { return proto.CompactTextString(m) } +func (*Flag_Consul_V0_8_0) ProtoMessage() {} +func (*Flag_Consul_V0_8_0) Descriptor() ([]byte, []int) { return fileDescriptorFlagConsul, []int{1} } + +func init() { + proto.RegisterType((*Flag_Consul_V0_7_5)(nil), "dbtesterpb.flag__consul__v0_7_5") + proto.RegisterType((*Flag_Consul_V0_8_0)(nil), "dbtesterpb.flag__consul__v0_8_0") +} +func (m *Flag_Consul_V0_7_5) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Flag_Consul_V0_7_5) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func (m *Flag_Consul_V0_8_0) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Flag_Consul_V0_8_0) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func encodeFixed64FlagConsul(dAtA []byte, offset int, v uint64) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) + dAtA[offset+4] = uint8(v >> 32) + dAtA[offset+5] = uint8(v >> 40) + dAtA[offset+6] = uint8(v >> 48) + dAtA[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32FlagConsul(dAtA []byte, offset int, v uint32) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintFlagConsul(dAtA []byte, offset int, v uint64) int { + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return offset + 1 +} +func (m *Flag_Consul_V0_7_5) Size() (n int) { + var l int + _ = l + return n +} + +func (m *Flag_Consul_V0_8_0) Size() (n int) { + var l int + _ = l + return n +} + +func sovFlagConsul(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozFlagConsul(x uint64) (n int) { + return sovFlagConsul(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Flag_Consul_V0_7_5) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagConsul + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: flag__consul__v0_7_5: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: flag__consul__v0_7_5: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipFlagConsul(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFlagConsul + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Flag_Consul_V0_8_0) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagConsul + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: flag__consul__v0_8_0: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: flag__consul__v0_8_0: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipFlagConsul(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFlagConsul + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipFlagConsul(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFlagConsul + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFlagConsul + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFlagConsul + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthFlagConsul + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFlagConsul + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipFlagConsul(dAtA[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthFlagConsul = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowFlagConsul = fmt.Errorf("proto: integer overflow") +) + +func init() { proto.RegisterFile("dbtesterpb/flag_consul.proto", fileDescriptorFlagConsul) } + +var fileDescriptorFlagConsul = []byte{ + // 138 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x49, 0x49, 0x2a, 0x49, + 0x2d, 0x2e, 0x49, 0x2d, 0x2a, 0x48, 0xd2, 0x4f, 0xcb, 0x49, 0x4c, 0x8f, 0x4f, 0xce, 0xcf, 0x2b, + 0x2e, 0xcd, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x42, 0xc8, 0x4a, 0xe9, 0xa6, 0x67, + 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0xa7, 0xe7, 0xa7, 0xe7, 0xeb, 0x83, 0x95, + 0x24, 0x95, 0xa6, 0x81, 0x79, 0x60, 0x0e, 0x98, 0x05, 0xd1, 0xaa, 0x24, 0xc6, 0x25, 0x02, 0x36, + 0x0f, 0x6a, 0x60, 0x7c, 0x7c, 0x99, 0x41, 0xbc, 0x79, 0xbc, 0x29, 0x56, 0x71, 0x8b, 0x78, 0x03, + 0x27, 0x91, 0x13, 0x0f, 0xe5, 0x18, 0x4e, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, + 0x23, 0x39, 0xc6, 0x19, 0x8f, 0xe5, 0x18, 0x92, 0xd8, 0xc0, 0x86, 0x19, 0x03, 0x02, 0x00, 0x00, + 0xff, 0xff, 0x93, 0xd4, 0x88, 0x26, 0xa7, 0x00, 0x00, 0x00, +} diff --git a/dbtesterpb/flag_consul.proto b/dbtesterpb/flag_consul.proto new file mode 100644 index 00000000..2c07e6c1 --- /dev/null +++ b/dbtesterpb/flag_consul.proto @@ -0,0 +1,17 @@ +syntax = "proto3"; +package dbtesterpb; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.goproto_getters_all) = false; + +// See https://github.com/hashicorp/consul for more. +message flag__consul__v0_7_5 { +} + +// See https://github.com/hashicorp/consul for more. +message flag__consul__v0_8_0 { +} diff --git a/dbtesterpb/flag_etcd.pb.go b/dbtesterpb/flag_etcd.pb.go new file mode 100644 index 00000000..10592b35 --- /dev/null +++ b/dbtesterpb/flag_etcd.pb.go @@ -0,0 +1,718 @@ +// Code generated by protoc-gen-gogo. +// source: dbtesterpb/flag_etcd.proto +// DO NOT EDIT! + +package dbtesterpb + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" +import _ "github.com/gogo/protobuf/gogoproto" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// See https://github.com/coreos/etcd/blob/master/etcdmain/help.go for more. +type Flag_Etcd_V2_3 struct { + SnapshotCount int64 `protobuf:"varint,1,opt,name=SnapshotCount,proto3" json:"SnapshotCount,omitempty" yaml:"snapshot_count"` +} + +func (m *Flag_Etcd_V2_3) Reset() { *m = Flag_Etcd_V2_3{} } +func (m *Flag_Etcd_V2_3) String() string { return proto.CompactTextString(m) } +func (*Flag_Etcd_V2_3) ProtoMessage() {} +func (*Flag_Etcd_V2_3) Descriptor() ([]byte, []int) { return fileDescriptorFlagEtcd, []int{0} } + +// See https://github.com/coreos/etcd/blob/master/etcdmain/help.go for more. +type Flag_Etcd_V3_1 struct { + SnapshotCount int64 `protobuf:"varint,1,opt,name=SnapshotCount,proto3" json:"SnapshotCount,omitempty" yaml:"snapshot_count"` + QuotaSizeBytes int64 `protobuf:"varint,2,opt,name=QuotaSizeBytes,proto3" json:"QuotaSizeBytes,omitempty" yaml:"quota_size_bytes"` +} + +func (m *Flag_Etcd_V3_1) Reset() { *m = Flag_Etcd_V3_1{} } +func (m *Flag_Etcd_V3_1) String() string { return proto.CompactTextString(m) } +func (*Flag_Etcd_V3_1) ProtoMessage() {} +func (*Flag_Etcd_V3_1) Descriptor() ([]byte, []int) { return fileDescriptorFlagEtcd, []int{1} } + +// See https://github.com/coreos/etcd/blob/master/etcdmain/help.go for more. +type Flag_Etcd_V3_2 struct { + SnapshotCount int64 `protobuf:"varint,1,opt,name=SnapshotCount,proto3" json:"SnapshotCount,omitempty" yaml:"snapshot_count"` + QuotaSizeBytes int64 `protobuf:"varint,2,opt,name=QuotaSizeBytes,proto3" json:"QuotaSizeBytes,omitempty" yaml:"quota_size_bytes"` +} + +func (m *Flag_Etcd_V3_2) Reset() { *m = Flag_Etcd_V3_2{} } +func (m *Flag_Etcd_V3_2) String() string { return proto.CompactTextString(m) } +func (*Flag_Etcd_V3_2) ProtoMessage() {} +func (*Flag_Etcd_V3_2) Descriptor() ([]byte, []int) { return fileDescriptorFlagEtcd, []int{2} } + +// See https://github.com/coreos/etcd/blob/master/etcdmain/help.go for more. +type Flag_Etcd_Tip struct { + SnapshotCount int64 `protobuf:"varint,1,opt,name=SnapshotCount,proto3" json:"SnapshotCount,omitempty" yaml:"snapshot_count"` + QuotaSizeBytes int64 `protobuf:"varint,2,opt,name=QuotaSizeBytes,proto3" json:"QuotaSizeBytes,omitempty" yaml:"quota_size_bytes"` +} + +func (m *Flag_Etcd_Tip) Reset() { *m = Flag_Etcd_Tip{} } +func (m *Flag_Etcd_Tip) String() string { return proto.CompactTextString(m) } +func (*Flag_Etcd_Tip) ProtoMessage() {} +func (*Flag_Etcd_Tip) Descriptor() ([]byte, []int) { return fileDescriptorFlagEtcd, []int{3} } + +func init() { + proto.RegisterType((*Flag_Etcd_V2_3)(nil), "dbtesterpb.flag__etcd__v2_3") + proto.RegisterType((*Flag_Etcd_V3_1)(nil), "dbtesterpb.flag__etcd__v3_1") + proto.RegisterType((*Flag_Etcd_V3_2)(nil), "dbtesterpb.flag__etcd__v3_2") + proto.RegisterType((*Flag_Etcd_Tip)(nil), "dbtesterpb.flag__etcd__tip") +} +func (m *Flag_Etcd_V2_3) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Flag_Etcd_V2_3) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.SnapshotCount != 0 { + dAtA[i] = 0x8 + i++ + i = encodeVarintFlagEtcd(dAtA, i, uint64(m.SnapshotCount)) + } + return i, nil +} + +func (m *Flag_Etcd_V3_1) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Flag_Etcd_V3_1) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.SnapshotCount != 0 { + dAtA[i] = 0x8 + i++ + i = encodeVarintFlagEtcd(dAtA, i, uint64(m.SnapshotCount)) + } + if m.QuotaSizeBytes != 0 { + dAtA[i] = 0x10 + i++ + i = encodeVarintFlagEtcd(dAtA, i, uint64(m.QuotaSizeBytes)) + } + return i, nil +} + +func (m *Flag_Etcd_V3_2) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Flag_Etcd_V3_2) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.SnapshotCount != 0 { + dAtA[i] = 0x8 + i++ + i = encodeVarintFlagEtcd(dAtA, i, uint64(m.SnapshotCount)) + } + if m.QuotaSizeBytes != 0 { + dAtA[i] = 0x10 + i++ + i = encodeVarintFlagEtcd(dAtA, i, uint64(m.QuotaSizeBytes)) + } + return i, nil +} + +func (m *Flag_Etcd_Tip) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Flag_Etcd_Tip) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.SnapshotCount != 0 { + dAtA[i] = 0x8 + i++ + i = encodeVarintFlagEtcd(dAtA, i, uint64(m.SnapshotCount)) + } + if m.QuotaSizeBytes != 0 { + dAtA[i] = 0x10 + i++ + i = encodeVarintFlagEtcd(dAtA, i, uint64(m.QuotaSizeBytes)) + } + return i, nil +} + +func encodeFixed64FlagEtcd(dAtA []byte, offset int, v uint64) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) + dAtA[offset+4] = uint8(v >> 32) + dAtA[offset+5] = uint8(v >> 40) + dAtA[offset+6] = uint8(v >> 48) + dAtA[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32FlagEtcd(dAtA []byte, offset int, v uint32) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintFlagEtcd(dAtA []byte, offset int, v uint64) int { + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return offset + 1 +} +func (m *Flag_Etcd_V2_3) Size() (n int) { + var l int + _ = l + if m.SnapshotCount != 0 { + n += 1 + sovFlagEtcd(uint64(m.SnapshotCount)) + } + return n +} + +func (m *Flag_Etcd_V3_1) Size() (n int) { + var l int + _ = l + if m.SnapshotCount != 0 { + n += 1 + sovFlagEtcd(uint64(m.SnapshotCount)) + } + if m.QuotaSizeBytes != 0 { + n += 1 + sovFlagEtcd(uint64(m.QuotaSizeBytes)) + } + return n +} + +func (m *Flag_Etcd_V3_2) Size() (n int) { + var l int + _ = l + if m.SnapshotCount != 0 { + n += 1 + sovFlagEtcd(uint64(m.SnapshotCount)) + } + if m.QuotaSizeBytes != 0 { + n += 1 + sovFlagEtcd(uint64(m.QuotaSizeBytes)) + } + return n +} + +func (m *Flag_Etcd_Tip) Size() (n int) { + var l int + _ = l + if m.SnapshotCount != 0 { + n += 1 + sovFlagEtcd(uint64(m.SnapshotCount)) + } + if m.QuotaSizeBytes != 0 { + n += 1 + sovFlagEtcd(uint64(m.QuotaSizeBytes)) + } + return n +} + +func sovFlagEtcd(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozFlagEtcd(x uint64) (n int) { + return sovFlagEtcd(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Flag_Etcd_V2_3) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagEtcd + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: flag__etcd__v2_3: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: flag__etcd__v2_3: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SnapshotCount", wireType) + } + m.SnapshotCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagEtcd + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SnapshotCount |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipFlagEtcd(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFlagEtcd + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Flag_Etcd_V3_1) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagEtcd + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: flag__etcd__v3_1: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: flag__etcd__v3_1: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SnapshotCount", wireType) + } + m.SnapshotCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagEtcd + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SnapshotCount |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field QuotaSizeBytes", wireType) + } + m.QuotaSizeBytes = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagEtcd + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.QuotaSizeBytes |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipFlagEtcd(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFlagEtcd + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Flag_Etcd_V3_2) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagEtcd + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: flag__etcd__v3_2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: flag__etcd__v3_2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SnapshotCount", wireType) + } + m.SnapshotCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagEtcd + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SnapshotCount |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field QuotaSizeBytes", wireType) + } + m.QuotaSizeBytes = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagEtcd + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.QuotaSizeBytes |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipFlagEtcd(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFlagEtcd + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Flag_Etcd_Tip) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagEtcd + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: flag__etcd__tip: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: flag__etcd__tip: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SnapshotCount", wireType) + } + m.SnapshotCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagEtcd + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SnapshotCount |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field QuotaSizeBytes", wireType) + } + m.QuotaSizeBytes = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagEtcd + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.QuotaSizeBytes |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipFlagEtcd(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFlagEtcd + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipFlagEtcd(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFlagEtcd + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFlagEtcd + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFlagEtcd + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthFlagEtcd + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFlagEtcd + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipFlagEtcd(dAtA[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthFlagEtcd = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowFlagEtcd = fmt.Errorf("proto: integer overflow") +) + +func init() { proto.RegisterFile("dbtesterpb/flag_etcd.proto", fileDescriptorFlagEtcd) } + +var fileDescriptorFlagEtcd = []byte{ + // 251 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4a, 0x49, 0x2a, 0x49, + 0x2d, 0x2e, 0x49, 0x2d, 0x2a, 0x48, 0xd2, 0x4f, 0xcb, 0x49, 0x4c, 0x8f, 0x4f, 0x2d, 0x49, 0x4e, + 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x42, 0xc8, 0x49, 0xe9, 0xa6, 0x67, 0x96, 0x64, + 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0xa7, 0xe7, 0xa7, 0xe7, 0xeb, 0x83, 0x95, 0x24, 0x95, + 0xa6, 0x81, 0x79, 0x60, 0x0e, 0x98, 0x05, 0xd1, 0xaa, 0x14, 0xcc, 0x25, 0x00, 0x36, 0x0d, 0x6c, + 0x5c, 0x7c, 0x7c, 0x99, 0x51, 0xbc, 0xb1, 0x90, 0x3d, 0x17, 0x6f, 0x70, 0x5e, 0x62, 0x41, 0x71, + 0x46, 0x7e, 0x89, 0x73, 0x7e, 0x69, 0x5e, 0x89, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0xb3, 0x93, 0xe4, + 0xa7, 0x7b, 0xf2, 0xa2, 0x95, 0x89, 0xb9, 0x39, 0x56, 0x4a, 0xc5, 0x50, 0xe9, 0xf8, 0x64, 0x90, + 0xbc, 0x52, 0x10, 0xaa, 0x7a, 0xa5, 0x19, 0x8c, 0x68, 0xa6, 0x1a, 0xc7, 0x1b, 0x52, 0x6c, 0xaa, + 0x90, 0x33, 0x17, 0x5f, 0x60, 0x69, 0x7e, 0x49, 0x62, 0x70, 0x66, 0x55, 0xaa, 0x53, 0x65, 0x49, + 0x6a, 0xb1, 0x04, 0x13, 0xd8, 0x04, 0xe9, 0x4f, 0xf7, 0xe4, 0xc5, 0x21, 0x26, 0x14, 0x82, 0xe4, + 0xe3, 0x8b, 0x33, 0xab, 0x52, 0xe3, 0x93, 0x40, 0x2a, 0x94, 0x82, 0xd0, 0xb4, 0x60, 0x73, 0x9a, + 0xd1, 0x20, 0x71, 0xda, 0x74, 0x46, 0x2e, 0x7e, 0x64, 0xa7, 0x95, 0x64, 0x16, 0x0c, 0x0e, 0x97, + 0x39, 0x89, 0x9c, 0x78, 0x28, 0xc7, 0x70, 0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c, 0x0f, + 0x1e, 0xc9, 0x31, 0xce, 0x78, 0x2c, 0xc7, 0x90, 0xc4, 0x06, 0x4e, 0x41, 0xc6, 0x80, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x5c, 0xec, 0xd8, 0x68, 0x9a, 0x02, 0x00, 0x00, +} diff --git a/dbtesterpb/flag_etcd.proto b/dbtesterpb/flag_etcd.proto new file mode 100644 index 00000000..653dd8ae --- /dev/null +++ b/dbtesterpb/flag_etcd.proto @@ -0,0 +1,32 @@ +syntax = "proto3"; +package dbtesterpb; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.goproto_getters_all) = false; + +// See https://github.com/coreos/etcd/blob/master/etcdmain/help.go for more. +message flag__etcd__v2_3 { + int64 SnapshotCount = 1 [(gogoproto.moretags) = "yaml:\"snapshot_count\""]; +} + +// See https://github.com/coreos/etcd/blob/master/etcdmain/help.go for more. +message flag__etcd__v3_1 { + int64 SnapshotCount = 1 [(gogoproto.moretags) = "yaml:\"snapshot_count\""]; + int64 QuotaSizeBytes = 2 [(gogoproto.moretags) = "yaml:\"quota_size_bytes\""]; +} + +// See https://github.com/coreos/etcd/blob/master/etcdmain/help.go for more. +message flag__etcd__v3_2 { + int64 SnapshotCount = 1 [(gogoproto.moretags) = "yaml:\"snapshot_count\""]; + int64 QuotaSizeBytes = 2 [(gogoproto.moretags) = "yaml:\"quota_size_bytes\""]; +} + +// See https://github.com/coreos/etcd/blob/master/etcdmain/help.go for more. +message flag__etcd__tip { + int64 SnapshotCount = 1 [(gogoproto.moretags) = "yaml:\"snapshot_count\""]; + int64 QuotaSizeBytes = 2 [(gogoproto.moretags) = "yaml:\"quota_size_bytes\""]; +} diff --git a/dbtesterpb/flag_zetcd.pb.go b/dbtesterpb/flag_zetcd.pb.go new file mode 100644 index 00000000..736482b6 --- /dev/null +++ b/dbtesterpb/flag_zetcd.pb.go @@ -0,0 +1,264 @@ +// Code generated by protoc-gen-gogo. +// source: dbtesterpb/flag_zetcd.proto +// DO NOT EDIT! + +package dbtesterpb + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" +import _ "github.com/gogo/protobuf/gogoproto" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// Flag_Zetcd_Beta is zetcd-specific flags +// (https://github.com/coreos/zetcd). +type Flag_Zetcd_Beta struct { +} + +func (m *Flag_Zetcd_Beta) Reset() { *m = Flag_Zetcd_Beta{} } +func (m *Flag_Zetcd_Beta) String() string { return proto.CompactTextString(m) } +func (*Flag_Zetcd_Beta) ProtoMessage() {} +func (*Flag_Zetcd_Beta) Descriptor() ([]byte, []int) { return fileDescriptorFlagZetcd, []int{0} } + +func init() { + proto.RegisterType((*Flag_Zetcd_Beta)(nil), "dbtesterpb.flag__zetcd__beta") +} +func (m *Flag_Zetcd_Beta) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Flag_Zetcd_Beta) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func encodeFixed64FlagZetcd(dAtA []byte, offset int, v uint64) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) + dAtA[offset+4] = uint8(v >> 32) + dAtA[offset+5] = uint8(v >> 40) + dAtA[offset+6] = uint8(v >> 48) + dAtA[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32FlagZetcd(dAtA []byte, offset int, v uint32) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintFlagZetcd(dAtA []byte, offset int, v uint64) int { + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return offset + 1 +} +func (m *Flag_Zetcd_Beta) Size() (n int) { + var l int + _ = l + return n +} + +func sovFlagZetcd(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozFlagZetcd(x uint64) (n int) { + return sovFlagZetcd(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Flag_Zetcd_Beta) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZetcd + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: flag__zetcd__beta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: flag__zetcd__beta: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipFlagZetcd(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFlagZetcd + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipFlagZetcd(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFlagZetcd + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFlagZetcd + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFlagZetcd + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthFlagZetcd + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFlagZetcd + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipFlagZetcd(dAtA[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthFlagZetcd = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowFlagZetcd = fmt.Errorf("proto: integer overflow") +) + +func init() { proto.RegisterFile("dbtesterpb/flag_zetcd.proto", fileDescriptorFlagZetcd) } + +var fileDescriptorFlagZetcd = []byte{ + // 130 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4e, 0x49, 0x2a, 0x49, + 0x2d, 0x2e, 0x49, 0x2d, 0x2a, 0x48, 0xd2, 0x4f, 0xcb, 0x49, 0x4c, 0x8f, 0xaf, 0x4a, 0x2d, 0x49, + 0x4e, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x42, 0x48, 0x4a, 0xe9, 0xa6, 0x67, 0x96, + 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0xa7, 0xe7, 0xa7, 0xe7, 0xeb, 0x83, 0x95, 0x24, + 0x95, 0xa6, 0x81, 0x79, 0x60, 0x0e, 0x98, 0x05, 0xd1, 0xaa, 0x24, 0xcc, 0x25, 0x08, 0x36, 0x0e, + 0x62, 0x5e, 0x7c, 0x7c, 0x52, 0x6a, 0x49, 0xa2, 0x93, 0xc8, 0x89, 0x87, 0x72, 0x0c, 0x27, 0x1e, + 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x8c, 0xc7, 0x72, 0x0c, 0x49, + 0x6c, 0x60, 0x1d, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7e, 0xb7, 0x0d, 0x03, 0x8b, 0x00, + 0x00, 0x00, +} diff --git a/dbtesterpb/flag_zetcd.proto b/dbtesterpb/flag_zetcd.proto new file mode 100644 index 00000000..5a88e170 --- /dev/null +++ b/dbtesterpb/flag_zetcd.proto @@ -0,0 +1,14 @@ +syntax = "proto3"; +package dbtesterpb; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.goproto_getters_all) = false; + +// Flag_Zetcd_Beta is zetcd-specific flags +// (https://github.com/coreos/zetcd). +message flag__zetcd__beta { +} diff --git a/dbtesterpb/flag_zookeeper.pb.go b/dbtesterpb/flag_zookeeper.pb.go new file mode 100644 index 00000000..f575ec92 --- /dev/null +++ b/dbtesterpb/flag_zookeeper.pb.go @@ -0,0 +1,1012 @@ +// Code generated by protoc-gen-gogo. +// source: dbtesterpb/flag_zookeeper.proto +// DO NOT EDIT! + +package dbtesterpb + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" +import _ "github.com/gogo/protobuf/gogoproto" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Flag_Zookeeper_R3_4_9 struct { + // JavaDJuteMaxBuffer is for '-Djute.maxbuffer' flag. + JavaDJuteMaxBuffer uint64 `protobuf:"varint,1,opt,name=JavaDJuteMaxBuffer,proto3" json:"JavaDJuteMaxBuffer,omitempty" yaml:"java_d_jute_max_buffer"` + // JavaXms is for '-Xms' flag. + JavaXms string `protobuf:"bytes,2,opt,name=JavaXms,proto3" json:"JavaXms,omitempty" yaml:"java_xms"` + // JavaXmx is for '-Xmx' flag. + JavaXmx string `protobuf:"bytes,3,opt,name=JavaXmx,proto3" json:"JavaXmx,omitempty" yaml:"java_xmx"` + MyID uint32 `protobuf:"varint,100,opt,name=myID,proto3" json:"myID,omitempty"` + ClientPort int64 `protobuf:"varint,101,opt,name=ClientPort,proto3" json:"ClientPort,omitempty"` + // See http://zookeeper.apache.org/doc/trunk/zookeeperAdmin.html for more. + TickTime int64 `protobuf:"varint,102,opt,name=TickTime,proto3" json:"TickTime,omitempty" yaml:"tick_time"` + InitLimit int64 `protobuf:"varint,103,opt,name=InitLimit,proto3" json:"InitLimit,omitempty" yaml:"init_limit"` + SyncLimit int64 `protobuf:"varint,104,opt,name=SyncLimit,proto3" json:"SyncLimit,omitempty" yaml:"sync_limit"` + SnapCount int64 `protobuf:"varint,105,opt,name=SnapCount,proto3" json:"SnapCount,omitempty" yaml:"snap_count"` + MaxClientConnections int64 `protobuf:"varint,106,opt,name=MaxClientConnections,proto3" json:"MaxClientConnections,omitempty" yaml:"max_client_connections"` +} + +func (m *Flag_Zookeeper_R3_4_9) Reset() { *m = Flag_Zookeeper_R3_4_9{} } +func (m *Flag_Zookeeper_R3_4_9) String() string { return proto.CompactTextString(m) } +func (*Flag_Zookeeper_R3_4_9) ProtoMessage() {} +func (*Flag_Zookeeper_R3_4_9) Descriptor() ([]byte, []int) { + return fileDescriptorFlagZookeeper, []int{0} +} + +type Flag_Zookeeper_R3_5_2Alpha struct { + // JavaDJuteMaxBuffer is for '-Djute.maxbuffer' flag. + JavaDJuteMaxBuffer uint64 `protobuf:"varint,1,opt,name=JavaDJuteMaxBuffer,proto3" json:"JavaDJuteMaxBuffer,omitempty" yaml:"java_d_jute_max_buffer"` + // JavaXms is for '-Xms' flag. + JavaXms string `protobuf:"bytes,2,opt,name=JavaXms,proto3" json:"JavaXms,omitempty" yaml:"java_xms"` + // JavaXmx is for '-Xmx' flag. + JavaXmx string `protobuf:"bytes,3,opt,name=JavaXmx,proto3" json:"JavaXmx,omitempty" yaml:"java_xmx"` + MyID uint32 `protobuf:"varint,100,opt,name=myID,proto3" json:"myID,omitempty"` + ClientPort int64 `protobuf:"varint,101,opt,name=ClientPort,proto3" json:"ClientPort,omitempty"` + // See http://zookeeper.apache.org/doc/trunk/zookeeperAdmin.html for more. + TickTime int64 `protobuf:"varint,102,opt,name=TickTime,proto3" json:"TickTime,omitempty" yaml:"tick_time"` + InitLimit int64 `protobuf:"varint,103,opt,name=InitLimit,proto3" json:"InitLimit,omitempty" yaml:"init_limit"` + SyncLimit int64 `protobuf:"varint,104,opt,name=SyncLimit,proto3" json:"SyncLimit,omitempty" yaml:"sync_limit"` + SnapCount int64 `protobuf:"varint,105,opt,name=SnapCount,proto3" json:"SnapCount,omitempty" yaml:"snap_count"` + MaxClientConnections int64 `protobuf:"varint,106,opt,name=MaxClientConnections,proto3" json:"MaxClientConnections,omitempty" yaml:"max_client_connections"` +} + +func (m *Flag_Zookeeper_R3_5_2Alpha) Reset() { *m = Flag_Zookeeper_R3_5_2Alpha{} } +func (m *Flag_Zookeeper_R3_5_2Alpha) String() string { return proto.CompactTextString(m) } +func (*Flag_Zookeeper_R3_5_2Alpha) ProtoMessage() {} +func (*Flag_Zookeeper_R3_5_2Alpha) Descriptor() ([]byte, []int) { + return fileDescriptorFlagZookeeper, []int{1} +} + +func init() { + proto.RegisterType((*Flag_Zookeeper_R3_4_9)(nil), "dbtesterpb.flag__zookeeper__r3_4_9") + proto.RegisterType((*Flag_Zookeeper_R3_5_2Alpha)(nil), "dbtesterpb.flag__zookeeper__r3_5_2_alpha") +} +func (m *Flag_Zookeeper_R3_4_9) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Flag_Zookeeper_R3_4_9) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.JavaDJuteMaxBuffer != 0 { + dAtA[i] = 0x8 + i++ + i = encodeVarintFlagZookeeper(dAtA, i, uint64(m.JavaDJuteMaxBuffer)) + } + if len(m.JavaXms) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintFlagZookeeper(dAtA, i, uint64(len(m.JavaXms))) + i += copy(dAtA[i:], m.JavaXms) + } + if len(m.JavaXmx) > 0 { + dAtA[i] = 0x1a + i++ + i = encodeVarintFlagZookeeper(dAtA, i, uint64(len(m.JavaXmx))) + i += copy(dAtA[i:], m.JavaXmx) + } + if m.MyID != 0 { + dAtA[i] = 0xa0 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintFlagZookeeper(dAtA, i, uint64(m.MyID)) + } + if m.ClientPort != 0 { + dAtA[i] = 0xa8 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintFlagZookeeper(dAtA, i, uint64(m.ClientPort)) + } + if m.TickTime != 0 { + dAtA[i] = 0xb0 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintFlagZookeeper(dAtA, i, uint64(m.TickTime)) + } + if m.InitLimit != 0 { + dAtA[i] = 0xb8 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintFlagZookeeper(dAtA, i, uint64(m.InitLimit)) + } + if m.SyncLimit != 0 { + dAtA[i] = 0xc0 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintFlagZookeeper(dAtA, i, uint64(m.SyncLimit)) + } + if m.SnapCount != 0 { + dAtA[i] = 0xc8 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintFlagZookeeper(dAtA, i, uint64(m.SnapCount)) + } + if m.MaxClientConnections != 0 { + dAtA[i] = 0xd0 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintFlagZookeeper(dAtA, i, uint64(m.MaxClientConnections)) + } + return i, nil +} + +func (m *Flag_Zookeeper_R3_5_2Alpha) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Flag_Zookeeper_R3_5_2Alpha) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.JavaDJuteMaxBuffer != 0 { + dAtA[i] = 0x8 + i++ + i = encodeVarintFlagZookeeper(dAtA, i, uint64(m.JavaDJuteMaxBuffer)) + } + if len(m.JavaXms) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintFlagZookeeper(dAtA, i, uint64(len(m.JavaXms))) + i += copy(dAtA[i:], m.JavaXms) + } + if len(m.JavaXmx) > 0 { + dAtA[i] = 0x1a + i++ + i = encodeVarintFlagZookeeper(dAtA, i, uint64(len(m.JavaXmx))) + i += copy(dAtA[i:], m.JavaXmx) + } + if m.MyID != 0 { + dAtA[i] = 0xa0 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintFlagZookeeper(dAtA, i, uint64(m.MyID)) + } + if m.ClientPort != 0 { + dAtA[i] = 0xa8 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintFlagZookeeper(dAtA, i, uint64(m.ClientPort)) + } + if m.TickTime != 0 { + dAtA[i] = 0xb0 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintFlagZookeeper(dAtA, i, uint64(m.TickTime)) + } + if m.InitLimit != 0 { + dAtA[i] = 0xb8 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintFlagZookeeper(dAtA, i, uint64(m.InitLimit)) + } + if m.SyncLimit != 0 { + dAtA[i] = 0xc0 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintFlagZookeeper(dAtA, i, uint64(m.SyncLimit)) + } + if m.SnapCount != 0 { + dAtA[i] = 0xc8 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintFlagZookeeper(dAtA, i, uint64(m.SnapCount)) + } + if m.MaxClientConnections != 0 { + dAtA[i] = 0xd0 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintFlagZookeeper(dAtA, i, uint64(m.MaxClientConnections)) + } + return i, nil +} + +func encodeFixed64FlagZookeeper(dAtA []byte, offset int, v uint64) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) + dAtA[offset+4] = uint8(v >> 32) + dAtA[offset+5] = uint8(v >> 40) + dAtA[offset+6] = uint8(v >> 48) + dAtA[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32FlagZookeeper(dAtA []byte, offset int, v uint32) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintFlagZookeeper(dAtA []byte, offset int, v uint64) int { + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return offset + 1 +} +func (m *Flag_Zookeeper_R3_4_9) Size() (n int) { + var l int + _ = l + if m.JavaDJuteMaxBuffer != 0 { + n += 1 + sovFlagZookeeper(uint64(m.JavaDJuteMaxBuffer)) + } + l = len(m.JavaXms) + if l > 0 { + n += 1 + l + sovFlagZookeeper(uint64(l)) + } + l = len(m.JavaXmx) + if l > 0 { + n += 1 + l + sovFlagZookeeper(uint64(l)) + } + if m.MyID != 0 { + n += 2 + sovFlagZookeeper(uint64(m.MyID)) + } + if m.ClientPort != 0 { + n += 2 + sovFlagZookeeper(uint64(m.ClientPort)) + } + if m.TickTime != 0 { + n += 2 + sovFlagZookeeper(uint64(m.TickTime)) + } + if m.InitLimit != 0 { + n += 2 + sovFlagZookeeper(uint64(m.InitLimit)) + } + if m.SyncLimit != 0 { + n += 2 + sovFlagZookeeper(uint64(m.SyncLimit)) + } + if m.SnapCount != 0 { + n += 2 + sovFlagZookeeper(uint64(m.SnapCount)) + } + if m.MaxClientConnections != 0 { + n += 2 + sovFlagZookeeper(uint64(m.MaxClientConnections)) + } + return n +} + +func (m *Flag_Zookeeper_R3_5_2Alpha) Size() (n int) { + var l int + _ = l + if m.JavaDJuteMaxBuffer != 0 { + n += 1 + sovFlagZookeeper(uint64(m.JavaDJuteMaxBuffer)) + } + l = len(m.JavaXms) + if l > 0 { + n += 1 + l + sovFlagZookeeper(uint64(l)) + } + l = len(m.JavaXmx) + if l > 0 { + n += 1 + l + sovFlagZookeeper(uint64(l)) + } + if m.MyID != 0 { + n += 2 + sovFlagZookeeper(uint64(m.MyID)) + } + if m.ClientPort != 0 { + n += 2 + sovFlagZookeeper(uint64(m.ClientPort)) + } + if m.TickTime != 0 { + n += 2 + sovFlagZookeeper(uint64(m.TickTime)) + } + if m.InitLimit != 0 { + n += 2 + sovFlagZookeeper(uint64(m.InitLimit)) + } + if m.SyncLimit != 0 { + n += 2 + sovFlagZookeeper(uint64(m.SyncLimit)) + } + if m.SnapCount != 0 { + n += 2 + sovFlagZookeeper(uint64(m.SnapCount)) + } + if m.MaxClientConnections != 0 { + n += 2 + sovFlagZookeeper(uint64(m.MaxClientConnections)) + } + return n +} + +func sovFlagZookeeper(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozFlagZookeeper(x uint64) (n int) { + return sovFlagZookeeper(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Flag_Zookeeper_R3_4_9) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: flag__zookeeper__r3_4_9: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: flag__zookeeper__r3_4_9: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field JavaDJuteMaxBuffer", wireType) + } + m.JavaDJuteMaxBuffer = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.JavaDJuteMaxBuffer |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JavaXms", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFlagZookeeper + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.JavaXms = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JavaXmx", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFlagZookeeper + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.JavaXmx = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 100: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MyID", wireType) + } + m.MyID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MyID |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 101: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientPort", wireType) + } + m.ClientPort = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ClientPort |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 102: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TickTime", wireType) + } + m.TickTime = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TickTime |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 103: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field InitLimit", wireType) + } + m.InitLimit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.InitLimit |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 104: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncLimit", wireType) + } + m.SyncLimit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SyncLimit |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 105: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SnapCount", wireType) + } + m.SnapCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SnapCount |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 106: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxClientConnections", wireType) + } + m.MaxClientConnections = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MaxClientConnections |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipFlagZookeeper(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFlagZookeeper + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Flag_Zookeeper_R3_5_2Alpha) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: flag__zookeeper__r3_5_2_alpha: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: flag__zookeeper__r3_5_2_alpha: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field JavaDJuteMaxBuffer", wireType) + } + m.JavaDJuteMaxBuffer = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.JavaDJuteMaxBuffer |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JavaXms", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFlagZookeeper + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.JavaXms = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JavaXmx", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFlagZookeeper + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.JavaXmx = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 100: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MyID", wireType) + } + m.MyID = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MyID |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 101: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientPort", wireType) + } + m.ClientPort = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ClientPort |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 102: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TickTime", wireType) + } + m.TickTime = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TickTime |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 103: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field InitLimit", wireType) + } + m.InitLimit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.InitLimit |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 104: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncLimit", wireType) + } + m.SyncLimit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SyncLimit |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 105: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SnapCount", wireType) + } + m.SnapCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SnapCount |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 106: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxClientConnections", wireType) + } + m.MaxClientConnections = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MaxClientConnections |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipFlagZookeeper(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFlagZookeeper + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipFlagZookeeper(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthFlagZookeeper + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFlagZookeeper + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipFlagZookeeper(dAtA[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthFlagZookeeper = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowFlagZookeeper = fmt.Errorf("proto: integer overflow") +) + +func init() { proto.RegisterFile("dbtesterpb/flag_zookeeper.proto", fileDescriptorFlagZookeeper) } + +var fileDescriptorFlagZookeeper = []byte{ + // 442 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x94, 0xcf, 0x6e, 0xd3, 0x30, + 0x18, 0xc0, 0x67, 0x56, 0x01, 0xb3, 0x84, 0x00, 0x53, 0x84, 0x85, 0xb4, 0xa4, 0xf8, 0xd4, 0xcb, + 0x56, 0x44, 0xe1, 0x00, 0xc7, 0x74, 0x97, 0x4d, 0x4c, 0x82, 0x30, 0x24, 0x6e, 0x96, 0xe3, 0x3a, + 0xa9, 0xdb, 0xd8, 0x8e, 0x12, 0x67, 0x4a, 0x79, 0x12, 0x9e, 0x80, 0x13, 0x0f, 0xb2, 0x23, 0x4f, + 0x50, 0x41, 0x79, 0x83, 0x3e, 0x01, 0x8a, 0xa3, 0x25, 0x15, 0x74, 0x6f, 0xb0, 0xdb, 0xf7, 0xe7, + 0xf7, 0xfb, 0xa2, 0xe8, 0xfb, 0x64, 0xe8, 0x4f, 0x23, 0x2b, 0x0a, 0x2b, 0xf2, 0x2c, 0x1a, 0xc5, + 0x29, 0x4b, 0xe8, 0x57, 0x63, 0x16, 0x42, 0x64, 0x22, 0x3f, 0xce, 0x72, 0x63, 0x0d, 0x82, 0x1d, + 0xf0, 0xfc, 0x28, 0x91, 0x76, 0x56, 0x46, 0xc7, 0xdc, 0xa8, 0x51, 0x62, 0x12, 0x33, 0x72, 0x48, + 0x54, 0xc6, 0x2e, 0x73, 0x89, 0x8b, 0x1a, 0x95, 0x7c, 0xef, 0xc1, 0x67, 0x6e, 0x66, 0x37, 0x94, + 0xd2, 0x7c, 0x4c, 0x5f, 0xd3, 0xb7, 0xe8, 0x23, 0x44, 0x67, 0xec, 0x92, 0x9d, 0x9c, 0x95, 0x56, + 0x9c, 0xb3, 0x2a, 0x28, 0xe3, 0x58, 0xe4, 0x18, 0x0c, 0xc0, 0xb0, 0x17, 0xbc, 0xd8, 0xac, 0xfc, + 0xc3, 0x25, 0x53, 0xe9, 0x3b, 0x32, 0x67, 0x97, 0x8c, 0x4e, 0xe9, 0xbc, 0xb4, 0x82, 0x2a, 0x56, + 0xd1, 0xc8, 0x71, 0x24, 0xdc, 0x21, 0xa3, 0x23, 0x78, 0xaf, 0xae, 0x7e, 0x51, 0x05, 0xbe, 0x33, + 0x00, 0xc3, 0x83, 0xe0, 0xc9, 0x66, 0xe5, 0x3f, 0xdc, 0x9a, 0x53, 0xa9, 0x82, 0x84, 0xd7, 0x4c, + 0x87, 0x57, 0x78, 0xff, 0x06, 0xbc, 0x6a, 0xf1, 0x0a, 0x21, 0xd8, 0x53, 0xcb, 0xd3, 0x13, 0x3c, + 0x1d, 0x80, 0xe1, 0x83, 0xd0, 0xc5, 0xc8, 0x83, 0x70, 0x92, 0x4a, 0xa1, 0xed, 0x07, 0x93, 0x5b, + 0x2c, 0x06, 0x60, 0xb8, 0x1f, 0x6e, 0x55, 0xd0, 0x4b, 0x78, 0xff, 0x42, 0xf2, 0xc5, 0x85, 0x54, + 0x02, 0xc7, 0x75, 0x37, 0xe8, 0x6f, 0x56, 0xfe, 0xa3, 0xe6, 0x1b, 0x56, 0xf2, 0x05, 0xb5, 0x52, + 0x09, 0x12, 0xb6, 0x14, 0x1a, 0xc3, 0x83, 0x53, 0x2d, 0xed, 0x7b, 0xa9, 0xa4, 0xc5, 0x89, 0x53, + 0x9e, 0x6e, 0x56, 0xfe, 0xe3, 0x46, 0x91, 0x5a, 0x5a, 0x9a, 0xd6, 0x3d, 0x12, 0x76, 0x5c, 0x2d, + 0x7d, 0x5a, 0x6a, 0xde, 0x48, 0xb3, 0x7f, 0xa5, 0x62, 0xa9, 0x79, 0x2b, 0xb5, 0x9c, 0x93, 0x34, + 0xcb, 0x26, 0xa6, 0xd4, 0x16, 0xcb, 0xff, 0x24, 0xcd, 0x32, 0xca, 0xeb, 0x5e, 0x2d, 0x5d, 0x73, + 0xe8, 0x33, 0xec, 0x9f, 0xb3, 0xaa, 0xf9, 0xc3, 0x89, 0xd1, 0x5a, 0x70, 0x2b, 0x8d, 0x2e, 0xf0, + 0xdc, 0xf9, 0x5b, 0x7b, 0xab, 0x77, 0xc5, 0x1d, 0x46, 0x79, 0xc7, 0x91, 0x70, 0xa7, 0x4e, 0x7e, + 0xf4, 0xe0, 0xe1, 0xae, 0x43, 0x79, 0x43, 0x5f, 0x51, 0x96, 0x66, 0x33, 0x76, 0x7b, 0x2e, 0xb7, + 0xe7, 0xd2, 0x96, 0x83, 0xfe, 0xd5, 0x6f, 0x6f, 0xef, 0x6a, 0xed, 0x81, 0x9f, 0x6b, 0x0f, 0xfc, + 0x5a, 0x7b, 0xe0, 0xdb, 0x1f, 0x6f, 0x2f, 0xba, 0xeb, 0x1e, 0x9d, 0xf1, 0xdf, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x12, 0x42, 0x8d, 0xc8, 0xd2, 0x04, 0x00, 0x00, +} diff --git a/dbtesterpb/flag_zookeeper.proto b/dbtesterpb/flag_zookeeper.proto new file mode 100644 index 00000000..1c442e61 --- /dev/null +++ b/dbtesterpb/flag_zookeeper.proto @@ -0,0 +1,51 @@ +syntax = "proto3"; +package dbtesterpb; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.goproto_getters_all) = false; + +message flag__zookeeper__r3_4_9 { + // JavaDJuteMaxBuffer is for '-Djute.maxbuffer' flag. + uint64 JavaDJuteMaxBuffer = 1 [(gogoproto.moretags) = "yaml:\"java_d_jute_max_buffer\""]; + + // JavaXms is for '-Xms' flag. + string JavaXms = 2 [(gogoproto.moretags) = "yaml:\"java_xms\""]; + + // JavaXmx is for '-Xmx' flag. + string JavaXmx = 3 [(gogoproto.moretags) = "yaml:\"java_xmx\""]; + + uint32 myID = 100; + int64 ClientPort = 101; + + // See http://zookeeper.apache.org/doc/trunk/zookeeperAdmin.html for more. + int64 TickTime = 102 [(gogoproto.moretags) = "yaml:\"tick_time\""]; + int64 InitLimit = 103 [(gogoproto.moretags) = "yaml:\"init_limit\""]; + int64 SyncLimit = 104 [(gogoproto.moretags) = "yaml:\"sync_limit\""]; + int64 SnapCount = 105 [(gogoproto.moretags) = "yaml:\"snap_count\""]; + int64 MaxClientConnections = 106 [(gogoproto.moretags) = "yaml:\"max_client_connections\""]; +} + +message flag__zookeeper__r3_5_2_alpha { + // JavaDJuteMaxBuffer is for '-Djute.maxbuffer' flag. + uint64 JavaDJuteMaxBuffer = 1 [(gogoproto.moretags) = "yaml:\"java_d_jute_max_buffer\""]; + + // JavaXms is for '-Xms' flag. + string JavaXms = 2 [(gogoproto.moretags) = "yaml:\"java_xms\""]; + + // JavaXmx is for '-Xmx' flag. + string JavaXmx = 3 [(gogoproto.moretags) = "yaml:\"java_xmx\""]; + + uint32 myID = 100; + int64 ClientPort = 101; + + // See http://zookeeper.apache.org/doc/trunk/zookeeperAdmin.html for more. + int64 TickTime = 102 [(gogoproto.moretags) = "yaml:\"tick_time\""]; + int64 InitLimit = 103 [(gogoproto.moretags) = "yaml:\"init_limit\""]; + int64 SyncLimit = 104 [(gogoproto.moretags) = "yaml:\"sync_limit\""]; + int64 SnapCount = 105 [(gogoproto.moretags) = "yaml:\"snap_count\""]; + int64 MaxClientConnections = 106 [(gogoproto.moretags) = "yaml:\"max_client_connections\""]; +} diff --git a/dbtesterpb/message.pb.go b/dbtesterpb/message.pb.go index 432c3092..8340596c 100644 --- a/dbtesterpb/message.pb.go +++ b/dbtesterpb/message.pb.go @@ -2,16 +2,6 @@ // source: dbtesterpb/message.proto // DO NOT EDIT! -/* - Package dbtesterpb is a generated protocol buffer package. - - It is generated from these files: - dbtesterpb/message.proto - - It has these top-level messages: - Request - Response -*/ package dbtesterpb import proto "github.com/golang/protobuf/proto" @@ -31,80 +21,49 @@ var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package - -type Request_Operation int32 +type Operation int32 const ( - Request_Start Request_Operation = 0 - Request_Stop Request_Operation = 1 - Request_Heartbeat Request_Operation = 2 + Operation_Start Operation = 0 + Operation_Stop Operation = 1 + Operation_Heartbeat Operation = 2 ) -var Request_Operation_name = map[int32]string{ +var Operation_name = map[int32]string{ 0: "Start", 1: "Stop", 2: "Heartbeat", } -var Request_Operation_value = map[string]int32{ +var Operation_value = map[string]int32{ "Start": 0, "Stop": 1, "Heartbeat": 2, } -func (x Request_Operation) String() string { - return proto.EnumName(Request_Operation_name, int32(x)) +func (x Operation) String() string { + return proto.EnumName(Operation_name, int32(x)) } -func (Request_Operation) EnumDescriptor() ([]byte, []int) { return fileDescriptorMessage, []int{0, 0} } - -type Request_Database int32 - -const ( - Request_etcdv2 Request_Database = 0 - Request_etcdv3 Request_Database = 1 - Request_zookeeper Request_Database = 2 - Request_consul Request_Database = 3 - Request_zetcd Request_Database = 4 - Request_cetcd Request_Database = 5 -) - -var Request_Database_name = map[int32]string{ - 0: "etcdv2", - 1: "etcdv3", - 2: "zookeeper", - 3: "consul", - 4: "zetcd", - 5: "cetcd", -} -var Request_Database_value = map[string]int32{ - "etcdv2": 0, - "etcdv3": 1, - "zookeeper": 2, - "consul": 3, - "zetcd": 4, - "cetcd": 5, -} - -func (x Request_Database) String() string { - return proto.EnumName(Request_Database_name, int32(x)) -} -func (Request_Database) EnumDescriptor() ([]byte, []int) { return fileDescriptorMessage, []int{0, 1} } +func (Operation) EnumDescriptor() ([]byte, []int) { return fileDescriptorMessage, []int{0} } type Request struct { - Operation Request_Operation `protobuf:"varint,1,opt,name=operation,proto3,enum=dbtesterpb.Request_Operation" json:"operation,omitempty"` - TriggerLogUpload bool `protobuf:"varint,2,opt,name=triggerLogUpload,proto3" json:"triggerLogUpload,omitempty"` - DatabaseID Request_Database `protobuf:"varint,3,opt,name=databaseID,proto3,enum=dbtesterpb.Request_Database" json:"databaseID,omitempty"` - DatabaseTag string `protobuf:"bytes,4,opt,name=databaseTag,proto3" json:"databaseTag,omitempty"` - PeerIPsString string `protobuf:"bytes,5,opt,name=peerIPsString,proto3" json:"peerIPsString,omitempty"` - IpIndex uint32 `protobuf:"varint,6,opt,name=ipIndex,proto3" json:"ipIndex,omitempty"` - CurrentClientNumber int64 `protobuf:"varint,7,opt,name=currentClientNumber,proto3" json:"currentClientNumber,omitempty"` - Control *Request_Control `protobuf:"bytes,8,opt,name=control" json:"control,omitempty"` - Etcdv3Config *Request_Etcdv3 `protobuf:"bytes,9,opt,name=etcdv3Config" json:"etcdv3Config,omitempty"` - ZookeeperConfig *Request_Zookeeper `protobuf:"bytes,10,opt,name=zookeeperConfig" json:"zookeeperConfig,omitempty"` + Operation Operation `protobuf:"varint,1,opt,name=Operation,proto3,enum=dbtesterpb.Operation" json:"Operation,omitempty"` + TriggerLogUpload bool `protobuf:"varint,2,opt,name=TriggerLogUpload,proto3" json:"TriggerLogUpload,omitempty"` + DatabaseID DatabaseID `protobuf:"varint,3,opt,name=DatabaseID,proto3,enum=dbtesterpb.DatabaseID" json:"DatabaseID,omitempty"` + DatabaseTag string `protobuf:"bytes,4,opt,name=DatabaseTag,proto3" json:"DatabaseTag,omitempty"` + PeerIPsString string `protobuf:"bytes,5,opt,name=PeerIPsString,proto3" json:"PeerIPsString,omitempty"` + IPIndex uint32 `protobuf:"varint,6,opt,name=IPIndex,proto3" json:"IPIndex,omitempty"` + CurrentClientNumber int64 `protobuf:"varint,7,opt,name=CurrentClientNumber,proto3" json:"CurrentClientNumber,omitempty"` + ConfigClientMachineInitial *ConfigClientMachineInitial `protobuf:"bytes,8,opt,name=ConfigClientMachineInitial" json:"ConfigClientMachineInitial,omitempty"` + Flag_Etcd_V2_3 *Flag_Etcd_V2_3 `protobuf:"bytes,100,opt,name=flag__etcd__v2_3,json=flagEtcdV23" json:"flag__etcd__v2_3,omitempty"` + Flag_Etcd_V3_1 *Flag_Etcd_V3_1 `protobuf:"bytes,101,opt,name=flag__etcd__v3_1,json=flagEtcdV31" json:"flag__etcd__v3_1,omitempty"` + Flag_Etcd_V3_2 *Flag_Etcd_V3_2 `protobuf:"bytes,102,opt,name=flag__etcd__v3_2,json=flagEtcdV32" json:"flag__etcd__v3_2,omitempty"` + Flag_Etcd_Tip *Flag_Etcd_Tip `protobuf:"bytes,103,opt,name=flag__etcd__tip,json=flagEtcdTip" json:"flag__etcd__tip,omitempty"` + Flag_Zookeeper_R3_4_9 *Flag_Zookeeper_R3_4_9 `protobuf:"bytes,200,opt,name=flag__zookeeper__r3_4_9,json=flagZookeeperR349" json:"flag__zookeeper__r3_4_9,omitempty"` + Flag_Zookeeper_R3_5_2Alpha *Flag_Zookeeper_R3_5_2Alpha `protobuf:"bytes,201,opt,name=flag__zookeeper__r3_5_2_alpha,json=flagZookeeperR352Alpha" json:"flag__zookeeper__r3_5_2_alpha,omitempty"` + Flag_Consul_V0_7_5 *Flag_Consul_V0_7_5 `protobuf:"bytes,300,opt,name=flag__consul__v0_7_5,json=flagConsulV075" json:"flag__consul__v0_7_5,omitempty"` + Flag_Consul_V0_8_0 *Flag_Consul_V0_8_0 `protobuf:"bytes,301,opt,name=flag__consul__v0_8_0,json=flagConsulV080" json:"flag__consul__v0_8_0,omitempty"` + Flag_Cetcd_Beta *Flag_Cetcd_Beta `protobuf:"bytes,400,opt,name=flag__cetcd__beta,json=flagCetcdBeta" json:"flag__cetcd__beta,omitempty"` + Flag_Zetcd_Beta *Flag_Zetcd_Beta `protobuf:"bytes,500,opt,name=flag__zetcd__beta,json=flagZetcdBeta" json:"flag__zetcd__beta,omitempty"` } func (m *Request) Reset() { *m = Request{} } @@ -112,48 +71,11 @@ func (m *Request) String() string { return proto.CompactTextString(m) func (*Request) ProtoMessage() {} func (*Request) Descriptor() ([]byte, []int) { return fileDescriptorMessage, []int{0} } -type Request_Control struct { - GoogleCloudProjectName string `protobuf:"bytes,1,opt,name=googleCloudProjectName,proto3" json:"googleCloudProjectName,omitempty"` - GoogleCloudStorageKey string `protobuf:"bytes,2,opt,name=googleCloudStorageKey,proto3" json:"googleCloudStorageKey,omitempty"` - GoogleCloudStorageBucketName string `protobuf:"bytes,3,opt,name=googleCloudStorageBucketName,proto3" json:"googleCloudStorageBucketName,omitempty"` - GoogleCloudStorageSubDirectory string `protobuf:"bytes,4,opt,name=googleCloudStorageSubDirectory,proto3" json:"googleCloudStorageSubDirectory,omitempty"` -} - -func (m *Request_Control) Reset() { *m = Request_Control{} } -func (m *Request_Control) String() string { return proto.CompactTextString(m) } -func (*Request_Control) ProtoMessage() {} -func (*Request_Control) Descriptor() ([]byte, []int) { return fileDescriptorMessage, []int{0, 0} } - -type Request_Etcdv3 struct { - SnapCount int64 `protobuf:"varint,1,opt,name=snapCount,proto3" json:"snapCount,omitempty"` - QuotaSizeBytes int64 `protobuf:"varint,2,opt,name=quotaSizeBytes,proto3" json:"quotaSizeBytes,omitempty"` -} - -func (m *Request_Etcdv3) Reset() { *m = Request_Etcdv3{} } -func (m *Request_Etcdv3) String() string { return proto.CompactTextString(m) } -func (*Request_Etcdv3) ProtoMessage() {} -func (*Request_Etcdv3) Descriptor() ([]byte, []int) { return fileDescriptorMessage, []int{0, 1} } - -type Request_Zookeeper struct { - MyID uint32 `protobuf:"varint,1,opt,name=myID,proto3" json:"myID,omitempty"` - TickTime int64 `protobuf:"varint,2,opt,name=tickTime,proto3" json:"tickTime,omitempty"` - ClientPort int64 `protobuf:"varint,3,opt,name=clientPort,proto3" json:"clientPort,omitempty"` - InitLimit int64 `protobuf:"varint,4,opt,name=initLimit,proto3" json:"initLimit,omitempty"` - SyncLimit int64 `protobuf:"varint,5,opt,name=syncLimit,proto3" json:"syncLimit,omitempty"` - SnapCount int64 `protobuf:"varint,6,opt,name=snapCount,proto3" json:"snapCount,omitempty"` - MaxClientConnections int64 `protobuf:"varint,7,opt,name=maxClientConnections,proto3" json:"maxClientConnections,omitempty"` -} - -func (m *Request_Zookeeper) Reset() { *m = Request_Zookeeper{} } -func (m *Request_Zookeeper) String() string { return proto.CompactTextString(m) } -func (*Request_Zookeeper) ProtoMessage() {} -func (*Request_Zookeeper) Descriptor() ([]byte, []int) { return fileDescriptorMessage, []int{0, 2} } - type Response struct { - Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"` + Success bool `protobuf:"varint,1,opt,name=Success,proto3" json:"Success,omitempty"` // DiskSpaceUsageBytes is the data size of the database on disk in bytes. // It measures after database is requested to stop. - DiskSpaceUsageBytes int64 `protobuf:"varint,2,opt,name=diskSpaceUsageBytes,proto3" json:"diskSpaceUsageBytes,omitempty"` + DiskSpaceUsageBytes int64 `protobuf:"varint,2,opt,name=DiskSpaceUsageBytes,proto3" json:"DiskSpaceUsageBytes,omitempty"` } func (m *Response) Reset() { *m = Response{} } @@ -163,12 +85,8 @@ func (*Response) Descriptor() ([]byte, []int) { return fileDescriptorMessage, [] func init() { proto.RegisterType((*Request)(nil), "dbtesterpb.Request") - proto.RegisterType((*Request_Control)(nil), "dbtesterpb.Request.Control") - proto.RegisterType((*Request_Etcdv3)(nil), "dbtesterpb.Request.Etcdv3") - proto.RegisterType((*Request_Zookeeper)(nil), "dbtesterpb.Request.Zookeeper") proto.RegisterType((*Response)(nil), "dbtesterpb.Response") - proto.RegisterEnum("dbtesterpb.Request_Operation", Request_Operation_name, Request_Operation_value) - proto.RegisterEnum("dbtesterpb.Request_Database", Request_Database_name, Request_Database_value) + proto.RegisterEnum("dbtesterpb.Operation", Operation_name, Operation_value) } // Reference imports to suppress errors if they are not otherwise used. @@ -290,168 +208,145 @@ func (m *Request) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintMessage(dAtA, i, uint64(len(m.PeerIPsString))) i += copy(dAtA[i:], m.PeerIPsString) } - if m.IpIndex != 0 { + if m.IPIndex != 0 { dAtA[i] = 0x30 i++ - i = encodeVarintMessage(dAtA, i, uint64(m.IpIndex)) + i = encodeVarintMessage(dAtA, i, uint64(m.IPIndex)) } if m.CurrentClientNumber != 0 { dAtA[i] = 0x38 i++ i = encodeVarintMessage(dAtA, i, uint64(m.CurrentClientNumber)) } - if m.Control != nil { + if m.ConfigClientMachineInitial != nil { dAtA[i] = 0x42 i++ - i = encodeVarintMessage(dAtA, i, uint64(m.Control.Size())) - n1, err := m.Control.MarshalTo(dAtA[i:]) + i = encodeVarintMessage(dAtA, i, uint64(m.ConfigClientMachineInitial.Size())) + n1, err := m.ConfigClientMachineInitial.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n1 } - if m.Etcdv3Config != nil { - dAtA[i] = 0x4a + if m.Flag_Etcd_V2_3 != nil { + dAtA[i] = 0xa2 i++ - i = encodeVarintMessage(dAtA, i, uint64(m.Etcdv3Config.Size())) - n2, err := m.Etcdv3Config.MarshalTo(dAtA[i:]) + dAtA[i] = 0x6 + i++ + i = encodeVarintMessage(dAtA, i, uint64(m.Flag_Etcd_V2_3.Size())) + n2, err := m.Flag_Etcd_V2_3.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n2 } - if m.ZookeeperConfig != nil { - dAtA[i] = 0x52 + if m.Flag_Etcd_V3_1 != nil { + dAtA[i] = 0xaa i++ - i = encodeVarintMessage(dAtA, i, uint64(m.ZookeeperConfig.Size())) - n3, err := m.ZookeeperConfig.MarshalTo(dAtA[i:]) + dAtA[i] = 0x6 + i++ + i = encodeVarintMessage(dAtA, i, uint64(m.Flag_Etcd_V3_1.Size())) + n3, err := m.Flag_Etcd_V3_1.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n3 } - return i, nil -} - -func (m *Request_Control) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *Request_Control) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if len(m.GoogleCloudProjectName) > 0 { - dAtA[i] = 0xa + if m.Flag_Etcd_V3_2 != nil { + dAtA[i] = 0xb2 i++ - i = encodeVarintMessage(dAtA, i, uint64(len(m.GoogleCloudProjectName))) - i += copy(dAtA[i:], m.GoogleCloudProjectName) + dAtA[i] = 0x6 + i++ + i = encodeVarintMessage(dAtA, i, uint64(m.Flag_Etcd_V3_2.Size())) + n4, err := m.Flag_Etcd_V3_2.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n4 } - if len(m.GoogleCloudStorageKey) > 0 { + if m.Flag_Etcd_Tip != nil { + dAtA[i] = 0xba + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintMessage(dAtA, i, uint64(m.Flag_Etcd_Tip.Size())) + n5, err := m.Flag_Etcd_Tip.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n5 + } + if m.Flag_Zookeeper_R3_4_9 != nil { + dAtA[i] = 0xc2 + i++ + dAtA[i] = 0xc + i++ + i = encodeVarintMessage(dAtA, i, uint64(m.Flag_Zookeeper_R3_4_9.Size())) + n6, err := m.Flag_Zookeeper_R3_4_9.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n6 + } + if m.Flag_Zookeeper_R3_5_2Alpha != nil { + dAtA[i] = 0xca + i++ + dAtA[i] = 0xc + i++ + i = encodeVarintMessage(dAtA, i, uint64(m.Flag_Zookeeper_R3_5_2Alpha.Size())) + n7, err := m.Flag_Zookeeper_R3_5_2Alpha.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n7 + } + if m.Flag_Consul_V0_7_5 != nil { + dAtA[i] = 0xe2 + i++ dAtA[i] = 0x12 i++ - i = encodeVarintMessage(dAtA, i, uint64(len(m.GoogleCloudStorageKey))) - i += copy(dAtA[i:], m.GoogleCloudStorageKey) + i = encodeVarintMessage(dAtA, i, uint64(m.Flag_Consul_V0_7_5.Size())) + n8, err := m.Flag_Consul_V0_7_5.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n8 } - if len(m.GoogleCloudStorageBucketName) > 0 { - dAtA[i] = 0x1a + if m.Flag_Consul_V0_8_0 != nil { + dAtA[i] = 0xea i++ - i = encodeVarintMessage(dAtA, i, uint64(len(m.GoogleCloudStorageBucketName))) - i += copy(dAtA[i:], m.GoogleCloudStorageBucketName) - } - if len(m.GoogleCloudStorageSubDirectory) > 0 { - dAtA[i] = 0x22 + dAtA[i] = 0x12 i++ - i = encodeVarintMessage(dAtA, i, uint64(len(m.GoogleCloudStorageSubDirectory))) - i += copy(dAtA[i:], m.GoogleCloudStorageSubDirectory) + i = encodeVarintMessage(dAtA, i, uint64(m.Flag_Consul_V0_8_0.Size())) + n9, err := m.Flag_Consul_V0_8_0.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n9 } - return i, nil -} - -func (m *Request_Etcdv3) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *Request_Etcdv3) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if m.SnapCount != 0 { - dAtA[i] = 0x8 + if m.Flag_Cetcd_Beta != nil { + dAtA[i] = 0x82 i++ - i = encodeVarintMessage(dAtA, i, uint64(m.SnapCount)) - } - if m.QuotaSizeBytes != 0 { - dAtA[i] = 0x10 + dAtA[i] = 0x19 i++ - i = encodeVarintMessage(dAtA, i, uint64(m.QuotaSizeBytes)) + i = encodeVarintMessage(dAtA, i, uint64(m.Flag_Cetcd_Beta.Size())) + n10, err := m.Flag_Cetcd_Beta.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n10 } - return i, nil -} - -func (m *Request_Zookeeper) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *Request_Zookeeper) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if m.MyID != 0 { - dAtA[i] = 0x8 + if m.Flag_Zetcd_Beta != nil { + dAtA[i] = 0xa2 i++ - i = encodeVarintMessage(dAtA, i, uint64(m.MyID)) - } - if m.TickTime != 0 { - dAtA[i] = 0x10 + dAtA[i] = 0x1f i++ - i = encodeVarintMessage(dAtA, i, uint64(m.TickTime)) - } - if m.ClientPort != 0 { - dAtA[i] = 0x18 - i++ - i = encodeVarintMessage(dAtA, i, uint64(m.ClientPort)) - } - if m.InitLimit != 0 { - dAtA[i] = 0x20 - i++ - i = encodeVarintMessage(dAtA, i, uint64(m.InitLimit)) - } - if m.SyncLimit != 0 { - dAtA[i] = 0x28 - i++ - i = encodeVarintMessage(dAtA, i, uint64(m.SyncLimit)) - } - if m.SnapCount != 0 { - dAtA[i] = 0x30 - i++ - i = encodeVarintMessage(dAtA, i, uint64(m.SnapCount)) - } - if m.MaxClientConnections != 0 { - dAtA[i] = 0x38 - i++ - i = encodeVarintMessage(dAtA, i, uint64(m.MaxClientConnections)) + i = encodeVarintMessage(dAtA, i, uint64(m.Flag_Zetcd_Beta.Size())) + n11, err := m.Flag_Zetcd_Beta.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n11 } return i, nil } @@ -536,84 +431,55 @@ func (m *Request) Size() (n int) { if l > 0 { n += 1 + l + sovMessage(uint64(l)) } - if m.IpIndex != 0 { - n += 1 + sovMessage(uint64(m.IpIndex)) + if m.IPIndex != 0 { + n += 1 + sovMessage(uint64(m.IPIndex)) } if m.CurrentClientNumber != 0 { n += 1 + sovMessage(uint64(m.CurrentClientNumber)) } - if m.Control != nil { - l = m.Control.Size() + if m.ConfigClientMachineInitial != nil { + l = m.ConfigClientMachineInitial.Size() n += 1 + l + sovMessage(uint64(l)) } - if m.Etcdv3Config != nil { - l = m.Etcdv3Config.Size() - n += 1 + l + sovMessage(uint64(l)) + if m.Flag_Etcd_V2_3 != nil { + l = m.Flag_Etcd_V2_3.Size() + n += 2 + l + sovMessage(uint64(l)) } - if m.ZookeeperConfig != nil { - l = m.ZookeeperConfig.Size() - n += 1 + l + sovMessage(uint64(l)) + if m.Flag_Etcd_V3_1 != nil { + l = m.Flag_Etcd_V3_1.Size() + n += 2 + l + sovMessage(uint64(l)) } - return n -} - -func (m *Request_Control) Size() (n int) { - var l int - _ = l - l = len(m.GoogleCloudProjectName) - if l > 0 { - n += 1 + l + sovMessage(uint64(l)) + if m.Flag_Etcd_V3_2 != nil { + l = m.Flag_Etcd_V3_2.Size() + n += 2 + l + sovMessage(uint64(l)) } - l = len(m.GoogleCloudStorageKey) - if l > 0 { - n += 1 + l + sovMessage(uint64(l)) + if m.Flag_Etcd_Tip != nil { + l = m.Flag_Etcd_Tip.Size() + n += 2 + l + sovMessage(uint64(l)) } - l = len(m.GoogleCloudStorageBucketName) - if l > 0 { - n += 1 + l + sovMessage(uint64(l)) + if m.Flag_Zookeeper_R3_4_9 != nil { + l = m.Flag_Zookeeper_R3_4_9.Size() + n += 2 + l + sovMessage(uint64(l)) } - l = len(m.GoogleCloudStorageSubDirectory) - if l > 0 { - n += 1 + l + sovMessage(uint64(l)) + if m.Flag_Zookeeper_R3_5_2Alpha != nil { + l = m.Flag_Zookeeper_R3_5_2Alpha.Size() + n += 2 + l + sovMessage(uint64(l)) } - return n -} - -func (m *Request_Etcdv3) Size() (n int) { - var l int - _ = l - if m.SnapCount != 0 { - n += 1 + sovMessage(uint64(m.SnapCount)) + if m.Flag_Consul_V0_7_5 != nil { + l = m.Flag_Consul_V0_7_5.Size() + n += 2 + l + sovMessage(uint64(l)) } - if m.QuotaSizeBytes != 0 { - n += 1 + sovMessage(uint64(m.QuotaSizeBytes)) + if m.Flag_Consul_V0_8_0 != nil { + l = m.Flag_Consul_V0_8_0.Size() + n += 2 + l + sovMessage(uint64(l)) } - return n -} - -func (m *Request_Zookeeper) Size() (n int) { - var l int - _ = l - if m.MyID != 0 { - n += 1 + sovMessage(uint64(m.MyID)) + if m.Flag_Cetcd_Beta != nil { + l = m.Flag_Cetcd_Beta.Size() + n += 2 + l + sovMessage(uint64(l)) } - if m.TickTime != 0 { - n += 1 + sovMessage(uint64(m.TickTime)) - } - if m.ClientPort != 0 { - n += 1 + sovMessage(uint64(m.ClientPort)) - } - if m.InitLimit != 0 { - n += 1 + sovMessage(uint64(m.InitLimit)) - } - if m.SyncLimit != 0 { - n += 1 + sovMessage(uint64(m.SyncLimit)) - } - if m.SnapCount != 0 { - n += 1 + sovMessage(uint64(m.SnapCount)) - } - if m.MaxClientConnections != 0 { - n += 1 + sovMessage(uint64(m.MaxClientConnections)) + if m.Flag_Zetcd_Beta != nil { + l = m.Flag_Zetcd_Beta.Size() + n += 2 + l + sovMessage(uint64(l)) } return n } @@ -686,7 +552,7 @@ func (m *Request) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Operation |= (Request_Operation(b) & 0x7F) << shift + m.Operation |= (Operation(b) & 0x7F) << shift if b < 0x80 { break } @@ -725,7 +591,7 @@ func (m *Request) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.DatabaseID |= (Request_Database(b) & 0x7F) << shift + m.DatabaseID |= (DatabaseID(b) & 0x7F) << shift if b < 0x80 { break } @@ -790,9 +656,9 @@ func (m *Request) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 6: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field IpIndex", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field IPIndex", wireType) } - m.IpIndex = 0 + m.IPIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMessage @@ -802,7 +668,7 @@ func (m *Request) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.IpIndex |= (uint32(b) & 0x7F) << shift + m.IPIndex |= (uint32(b) & 0x7F) << shift if b < 0x80 { break } @@ -828,7 +694,7 @@ func (m *Request) Unmarshal(dAtA []byte) error { } case 8: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Control", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ConfigClientMachineInitial", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -852,16 +718,16 @@ func (m *Request) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Control == nil { - m.Control = &Request_Control{} + if m.ConfigClientMachineInitial == nil { + m.ConfigClientMachineInitial = &ConfigClientMachineInitial{} } - if err := m.Control.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ConfigClientMachineInitial.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 9: + case 100: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Etcdv3Config", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Flag_Etcd_V2_3", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -885,16 +751,16 @@ func (m *Request) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Etcdv3Config == nil { - m.Etcdv3Config = &Request_Etcdv3{} + if m.Flag_Etcd_V2_3 == nil { + m.Flag_Etcd_V2_3 = &Flag_Etcd_V2_3{} } - if err := m.Etcdv3Config.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Flag_Etcd_V2_3.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 10: + case 101: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ZookeeperConfig", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Flag_Etcd_V3_1", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -918,68 +784,51 @@ func (m *Request) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.ZookeeperConfig == nil { - m.ZookeeperConfig = &Request_Zookeeper{} + if m.Flag_Etcd_V3_1 == nil { + m.Flag_Etcd_V3_1 = &Flag_Etcd_V3_1{} } - if err := m.ZookeeperConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Flag_Etcd_V3_1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipMessage(dAtA[iNdEx:]) - if err != nil { + case 102: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Flag_Etcd_V3_2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMessage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMessage + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Flag_Etcd_V3_2 == nil { + m.Flag_Etcd_V3_2 = &Flag_Etcd_V3_2{} + } + if err := m.Flag_Etcd_V3_2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - if skippy < 0 { - return ErrInvalidLengthMessage - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Request_Control) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowMessage - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: Control: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Control: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + iNdEx = postIndex + case 103: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GoogleCloudProjectName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Flag_Etcd_Tip", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMessage @@ -989,251 +838,129 @@ func (m *Request_Control) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift + msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthMessage } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } - m.GoogleCloudProjectName = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GoogleCloudStorageKey", wireType) + if m.Flag_Etcd_Tip == nil { + m.Flag_Etcd_Tip = &Flag_Etcd_Tip{} } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowMessage - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthMessage - } - postIndex := iNdEx + intStringLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.GoogleCloudStorageKey = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GoogleCloudStorageBucketName", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowMessage - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthMessage - } - postIndex := iNdEx + intStringLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.GoogleCloudStorageBucketName = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GoogleCloudStorageSubDirectory", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowMessage - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthMessage - } - postIndex := iNdEx + intStringLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.GoogleCloudStorageSubDirectory = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipMessage(dAtA[iNdEx:]) - if err != nil { + if err := m.Flag_Etcd_Tip.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - if skippy < 0 { + iNdEx = postIndex + case 200: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Flag_Zookeeper_R3_4_9", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMessage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { return ErrInvalidLengthMessage } - if (iNdEx + skippy) > l { + postIndex := iNdEx + msglen + if postIndex > l { return io.ErrUnexpectedEOF } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Request_Etcdv3) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowMessage + if m.Flag_Zookeeper_R3_4_9 == nil { + m.Flag_Zookeeper_R3_4_9 = &Flag_Zookeeper_R3_4_9{} } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: Etcdv3: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Etcdv3: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SnapCount", wireType) - } - m.SnapCount = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowMessage - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.SnapCount |= (int64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field QuotaSizeBytes", wireType) - } - m.QuotaSizeBytes = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowMessage - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.QuotaSizeBytes |= (int64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipMessage(dAtA[iNdEx:]) - if err != nil { + if err := m.Flag_Zookeeper_R3_4_9.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - if skippy < 0 { + iNdEx = postIndex + case 201: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Flag_Zookeeper_R3_5_2Alpha", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMessage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { return ErrInvalidLengthMessage } - if (iNdEx + skippy) > l { + postIndex := iNdEx + msglen + if postIndex > l { return io.ErrUnexpectedEOF } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Request_Zookeeper) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowMessage + if m.Flag_Zookeeper_R3_5_2Alpha == nil { + m.Flag_Zookeeper_R3_5_2Alpha = &Flag_Zookeeper_R3_5_2Alpha{} } - if iNdEx >= l { + if err := m.Flag_Zookeeper_R3_5_2Alpha.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 300: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Flag_Consul_V0_7_5", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMessage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMessage + } + postIndex := iNdEx + msglen + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break + if m.Flag_Consul_V0_7_5 == nil { + m.Flag_Consul_V0_7_5 = &Flag_Consul_V0_7_5{} } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: Zookeeper: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Zookeeper: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MyID", wireType) + if err := m.Flag_Consul_V0_7_5.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - m.MyID = 0 + iNdEx = postIndex + case 301: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Flag_Consul_V0_8_0", wireType) + } + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMessage @@ -1243,16 +970,30 @@ func (m *Request_Zookeeper) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.MyID |= (uint32(b) & 0x7F) << shift + msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TickTime", wireType) + if msglen < 0 { + return ErrInvalidLengthMessage } - m.TickTime = 0 + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Flag_Consul_V0_8_0 == nil { + m.Flag_Consul_V0_8_0 = &Flag_Consul_V0_8_0{} + } + if err := m.Flag_Consul_V0_8_0.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 400: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Flag_Cetcd_Beta", wireType) + } + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMessage @@ -1262,16 +1003,30 @@ func (m *Request_Zookeeper) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.TickTime |= (int64(b) & 0x7F) << shift + msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ClientPort", wireType) + if msglen < 0 { + return ErrInvalidLengthMessage } - m.ClientPort = 0 + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Flag_Cetcd_Beta == nil { + m.Flag_Cetcd_Beta = &Flag_Cetcd_Beta{} + } + if err := m.Flag_Cetcd_Beta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 500: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Flag_Zetcd_Beta", wireType) + } + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowMessage @@ -1281,87 +1036,25 @@ func (m *Request_Zookeeper) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ClientPort |= (int64(b) & 0x7F) << shift + msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field InitLimit", wireType) + if msglen < 0 { + return ErrInvalidLengthMessage } - m.InitLimit = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowMessage - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.InitLimit |= (int64(b) & 0x7F) << shift - if b < 0x80 { - break - } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF } - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SyncLimit", wireType) + if m.Flag_Zetcd_Beta == nil { + m.Flag_Zetcd_Beta = &Flag_Zetcd_Beta{} } - m.SyncLimit = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowMessage - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.SyncLimit |= (int64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - case 6: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SnapCount", wireType) - } - m.SnapCount = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowMessage - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.SnapCount |= (int64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - case 7: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MaxClientConnections", wireType) - } - m.MaxClientConnections = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowMessage - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.MaxClientConnections |= (int64(b) & 0x7F) << shift - if b < 0x80 { - break - } + if err := m.Flag_Zetcd_Beta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipMessage(dAtA[iNdEx:]) @@ -1580,52 +1273,52 @@ var ( func init() { proto.RegisterFile("dbtesterpb/message.proto", fileDescriptorMessage) } var fileDescriptorMessage = []byte{ - // 743 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x54, 0x4f, 0x6f, 0xeb, 0x44, - 0x10, 0x8f, 0x9b, 0x36, 0xb1, 0xa7, 0xf4, 0x61, 0xed, 0x2b, 0xc8, 0x0a, 0x25, 0x8a, 0x22, 0x84, - 0x22, 0x24, 0x52, 0x94, 0xf2, 0xe7, 0x00, 0xe2, 0xd0, 0x94, 0x07, 0x15, 0x4f, 0xa5, 0x5a, 0xf7, - 0x71, 0xe0, 0xb6, 0xde, 0x4c, 0xcd, 0xd2, 0x78, 0xd7, 0x6f, 0x77, 0x8d, 0x5e, 0x7a, 0xe5, 0x4b, - 0xf0, 0x91, 0xde, 0x81, 0x03, 0x1f, 0x01, 0xca, 0x89, 0x6f, 0x81, 0xbc, 0xb6, 0x93, 0xb4, 0x35, - 0x70, 0x9b, 0xf9, 0xfd, 0x7e, 0x33, 0xbb, 0x33, 0x3b, 0xb3, 0x10, 0x2d, 0x12, 0x8b, 0xc6, 0xa2, - 0xce, 0x93, 0xe3, 0x0c, 0x8d, 0x61, 0x29, 0x4e, 0x73, 0xad, 0xac, 0x22, 0xb0, 0x61, 0x06, 0x1f, - 0xa6, 0xc2, 0xfe, 0x58, 0x24, 0x53, 0xae, 0xb2, 0xe3, 0x54, 0xa5, 0xea, 0xd8, 0x49, 0x92, 0xe2, - 0xda, 0x79, 0xce, 0x71, 0x56, 0x15, 0x3a, 0xfe, 0x2d, 0x80, 0x3e, 0xc5, 0x97, 0x05, 0x1a, 0x4b, - 0x3e, 0x87, 0x40, 0xe5, 0xa8, 0x99, 0x15, 0x4a, 0x46, 0xde, 0xc8, 0x9b, 0x3c, 0x99, 0xbd, 0x3b, - 0xdd, 0xa4, 0x9e, 0xd6, 0xba, 0xe9, 0x77, 0x8d, 0x88, 0x6e, 0xf4, 0xe4, 0x03, 0x08, 0xad, 0x16, - 0x69, 0x8a, 0xfa, 0xb9, 0x4a, 0x5f, 0xe4, 0x4b, 0xc5, 0x16, 0xd1, 0xce, 0xc8, 0x9b, 0xf8, 0xf4, - 0x11, 0x4e, 0xbe, 0x00, 0x58, 0x30, 0xcb, 0x12, 0x66, 0xf0, 0xfc, 0x2c, 0xea, 0xba, 0x93, 0x8e, - 0xda, 0x4e, 0x3a, 0xab, 0x55, 0x74, 0x4b, 0x4f, 0x46, 0xb0, 0xdf, 0x78, 0x57, 0x2c, 0x8d, 0x76, - 0x47, 0xde, 0x24, 0xa0, 0xdb, 0x10, 0x79, 0x0f, 0x0e, 0x72, 0x44, 0x7d, 0x7e, 0x69, 0x62, 0xab, - 0x85, 0x4c, 0xa3, 0x3d, 0xa7, 0xb9, 0x0f, 0x92, 0x08, 0xfa, 0x22, 0x3f, 0x97, 0x0b, 0x7c, 0x15, - 0xf5, 0x46, 0xde, 0xe4, 0x80, 0x36, 0x2e, 0xf9, 0x08, 0x9e, 0xf2, 0x42, 0x6b, 0x94, 0x76, 0xbe, - 0x14, 0x28, 0xed, 0x45, 0x91, 0x25, 0xa8, 0xa3, 0xfe, 0xc8, 0x9b, 0x74, 0x69, 0x1b, 0x45, 0x3e, - 0x81, 0x3e, 0x57, 0xd2, 0x6a, 0xb5, 0x8c, 0xfc, 0x91, 0x37, 0xd9, 0x9f, 0xbd, 0xd3, 0x56, 0xce, - 0xbc, 0x92, 0xd0, 0x46, 0x4b, 0xbe, 0x84, 0x37, 0xd0, 0xf2, 0xc5, 0xcf, 0x27, 0x73, 0x25, 0xaf, - 0x45, 0x1a, 0x05, 0x2e, 0x76, 0xd0, 0x16, 0xfb, 0x95, 0xd3, 0xd1, 0x7b, 0x7a, 0xf2, 0x35, 0xbc, - 0x79, 0xab, 0xd4, 0x0d, 0x62, 0x8e, 0xba, 0x4e, 0x01, 0x2e, 0x45, 0xeb, 0xbb, 0xfd, 0xd0, 0x48, - 0xe9, 0xc3, 0xa8, 0xc1, 0x2f, 0x3b, 0xd0, 0xaf, 0x6f, 0x47, 0x3e, 0x85, 0xb7, 0x53, 0xa5, 0xd2, - 0x25, 0xce, 0x97, 0xaa, 0x58, 0x5c, 0x6a, 0xf5, 0x13, 0x72, 0x7b, 0xc1, 0x32, 0x74, 0x33, 0x11, - 0xd0, 0x7f, 0x61, 0xc9, 0xc7, 0xf0, 0xd6, 0x16, 0x13, 0x5b, 0xa5, 0x59, 0x8a, 0xdf, 0xe2, 0xca, - 0x8d, 0x41, 0x40, 0xdb, 0x49, 0x72, 0x0a, 0x47, 0x8f, 0x89, 0xd3, 0x82, 0xdf, 0x60, 0x75, 0x66, - 0xd7, 0x05, 0xff, 0xa7, 0x86, 0x3c, 0x83, 0xe1, 0x63, 0x3e, 0x2e, 0x92, 0x33, 0xa1, 0x91, 0x5b, - 0xa5, 0x57, 0xf5, 0x90, 0xfc, 0x8f, 0x6a, 0x70, 0x01, 0xbd, 0xaa, 0xcd, 0xe4, 0x08, 0x02, 0x23, - 0x59, 0x3e, 0x57, 0x85, 0xb4, 0xae, 0xec, 0x2e, 0xdd, 0x00, 0xe4, 0x7d, 0x78, 0xf2, 0xb2, 0x50, - 0x96, 0xc5, 0xe2, 0x16, 0x4f, 0x57, 0x16, 0x8d, 0x2b, 0xb1, 0x4b, 0x1f, 0xa0, 0x83, 0xbf, 0x3d, - 0x08, 0xd6, 0x4d, 0x27, 0x04, 0x76, 0xb3, 0xd5, 0xf9, 0x99, 0x4b, 0x77, 0x40, 0x9d, 0x4d, 0x06, - 0xe0, 0x5b, 0xc1, 0x6f, 0xae, 0x44, 0x86, 0x75, 0x8e, 0xb5, 0x4f, 0x86, 0x00, 0xdc, 0xcd, 0xd8, - 0xa5, 0xd2, 0xd6, 0xf5, 0xa1, 0x4b, 0xb7, 0x90, 0xf2, 0x8e, 0x42, 0x0a, 0xfb, 0x5c, 0x64, 0xc2, - 0xba, 0x02, 0xbb, 0x74, 0x03, 0xb8, 0x0a, 0x56, 0x92, 0x57, 0xec, 0x5e, 0x5d, 0x41, 0x03, 0xdc, - 0xaf, 0xaf, 0xf7, 0xb0, 0xbe, 0x19, 0x1c, 0x66, 0xec, 0x55, 0x35, 0xe0, 0x73, 0x25, 0x25, 0xf2, - 0x72, 0xc5, 0x4d, 0xbd, 0x00, 0xad, 0xdc, 0xf8, 0x18, 0x82, 0xf5, 0xbf, 0x40, 0x02, 0xd8, 0x8b, - 0x2d, 0xd3, 0x36, 0xec, 0x10, 0x1f, 0x76, 0x63, 0xab, 0xf2, 0xd0, 0x23, 0x07, 0x10, 0x7c, 0x83, - 0x4c, 0xdb, 0x04, 0x99, 0x0d, 0x77, 0xc6, 0x31, 0xf8, 0xcd, 0x7a, 0x13, 0x80, 0x9e, 0x9b, 0xeb, - 0x59, 0xd8, 0x59, 0xdb, 0x27, 0x55, 0xc8, 0x7a, 0x52, 0xc3, 0x9d, 0x92, 0xe2, 0x4a, 0x9a, 0x62, - 0x19, 0x76, 0xcb, 0x23, 0x6e, 0x4b, 0x5d, 0xb8, 0x5b, 0x9a, 0xdc, 0x99, 0x7b, 0xe3, 0xef, 0xc1, - 0xa7, 0x68, 0x72, 0x25, 0x0d, 0x96, 0xfb, 0x6d, 0x0a, 0xce, 0xd1, 0x18, 0xd7, 0x72, 0x9f, 0x36, - 0x6e, 0xb9, 0xdf, 0x0b, 0x61, 0x6e, 0xe2, 0x9c, 0x71, 0x7c, 0x51, 0xfe, 0xa3, 0xdb, 0x8f, 0xd8, - 0x46, 0xcd, 0x9e, 0xc1, 0xfe, 0x95, 0x66, 0xd2, 0xe4, 0x4a, 0x5b, 0xd4, 0xe4, 0x33, 0xf0, 0x9d, - 0x7b, 0x8d, 0x9a, 0x3c, 0x6d, 0x59, 0xb5, 0xc1, 0xe1, 0x7d, 0xb0, 0xba, 0xd1, 0xb8, 0x73, 0x7a, - 0xf8, 0xfa, 0xcf, 0x61, 0xe7, 0xf5, 0xdd, 0xd0, 0xfb, 0xfd, 0x6e, 0xe8, 0xfd, 0x71, 0x37, 0xf4, - 0x7e, 0xfd, 0x6b, 0xd8, 0x49, 0x7a, 0xee, 0x2f, 0x3e, 0xf9, 0x27, 0x00, 0x00, 0xff, 0xff, 0x51, - 0x07, 0x89, 0xbd, 0xe2, 0x05, 0x00, 0x00, + // 752 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x95, 0xdf, 0x4e, 0xdb, 0x48, + 0x14, 0xc6, 0x63, 0xc2, 0x9f, 0x64, 0xa2, 0xb0, 0x61, 0x60, 0xd9, 0x51, 0x80, 0xac, 0xc5, 0xae, + 0x50, 0x16, 0x69, 0x93, 0x60, 0x93, 0x05, 0x2e, 0x21, 0xec, 0x8a, 0x48, 0xdb, 0x82, 0x26, 0x01, + 0x55, 0xdc, 0x8c, 0xc6, 0xce, 0xc4, 0x58, 0x24, 0xb6, 0x3b, 0x9e, 0xa0, 0x96, 0xa7, 0xe8, 0x65, + 0xdf, 0xa1, 0xed, 0x7b, 0xd0, 0xbb, 0x3e, 0x42, 0x4b, 0x5f, 0xa1, 0x0f, 0x50, 0x79, 0x9c, 0x90, + 0xc9, 0x1f, 0x4a, 0xef, 0x38, 0xdf, 0xf7, 0xcd, 0xef, 0x68, 0x8e, 0x99, 0x13, 0x80, 0x5a, 0x96, + 0x60, 0xa1, 0x60, 0x3c, 0xb0, 0xca, 0x5d, 0x16, 0x86, 0xd4, 0x61, 0xa5, 0x80, 0xfb, 0xc2, 0x87, + 0x60, 0xe8, 0xe4, 0xff, 0x76, 0x5c, 0x71, 0xd5, 0xb3, 0x4a, 0xb6, 0xdf, 0x2d, 0x3b, 0xbe, 0xe3, + 0x97, 0x65, 0xc4, 0xea, 0xb5, 0x65, 0x25, 0x0b, 0xf9, 0x57, 0x7c, 0x34, 0xbf, 0xae, 0x40, 0x5b, + 0x54, 0x50, 0x8b, 0x86, 0x8c, 0xb8, 0xad, 0xbe, 0x9b, 0x57, 0xdc, 0x76, 0x87, 0x3a, 0x84, 0x09, + 0x7b, 0xe0, 0xfd, 0x3e, 0xee, 0xdd, 0xfa, 0xfe, 0x35, 0x63, 0x01, 0xe3, 0x53, 0xd0, 0x32, 0x60, + 0xfb, 0x5e, 0xd8, 0xeb, 0xf4, 0xdd, 0xb5, 0x89, 0xe3, 0x0a, 0x7b, 0xc2, 0xb4, 0x15, 0x73, 0x4b, + 0x31, 0x6d, 0xdf, 0x6b, 0xbb, 0x0e, 0xb1, 0x3b, 0x2e, 0xf3, 0x04, 0xe9, 0x52, 0xfb, 0xca, 0xf5, + 0xfa, 0x53, 0xd9, 0x7c, 0x97, 0x06, 0x0b, 0x98, 0xbd, 0xec, 0xb1, 0x50, 0x40, 0x13, 0xa4, 0x4f, + 0x03, 0xc6, 0xa9, 0x70, 0x7d, 0x0f, 0x69, 0xba, 0x56, 0x5c, 0x34, 0x7e, 0x2d, 0x0d, 0x39, 0xa5, + 0x07, 0x13, 0x0f, 0x73, 0x70, 0x1b, 0xe4, 0x9a, 0xdc, 0x75, 0x1c, 0xc6, 0xff, 0xf7, 0x9d, 0xf3, + 0xa0, 0xe3, 0xd3, 0x16, 0x9a, 0xd1, 0xb5, 0x62, 0x0a, 0x4f, 0xe8, 0xf0, 0x1f, 0x00, 0x8e, 0xfb, + 0xe3, 0xab, 0x1f, 0xa3, 0xa4, 0xec, 0xb0, 0xaa, 0x76, 0x18, 0xba, 0x58, 0x49, 0x42, 0x1d, 0x64, + 0x06, 0x55, 0x93, 0x3a, 0x68, 0x56, 0xd7, 0x8a, 0x69, 0xac, 0x4a, 0xf0, 0x4f, 0x90, 0x3d, 0x63, + 0x8c, 0xd7, 0xcf, 0xc2, 0x86, 0xe0, 0xae, 0xe7, 0xa0, 0x39, 0x99, 0x19, 0x15, 0x21, 0x02, 0x0b, + 0xf5, 0xb3, 0xba, 0xd7, 0x62, 0xaf, 0xd0, 0xbc, 0xae, 0x15, 0xb3, 0x78, 0x50, 0xc2, 0x0a, 0x58, + 0xae, 0xf5, 0x38, 0x67, 0x9e, 0xa8, 0xc9, 0x29, 0x3d, 0xef, 0x75, 0x2d, 0xc6, 0xd1, 0x82, 0xae, + 0x15, 0x93, 0x78, 0x9a, 0x05, 0xdb, 0x20, 0x5f, 0x93, 0x73, 0x8d, 0xd5, 0x67, 0xf1, 0x54, 0xeb, + 0x9e, 0x2b, 0x5c, 0xda, 0x41, 0x29, 0x5d, 0x2b, 0x66, 0x8c, 0x2d, 0xf5, 0x6e, 0x8f, 0xa7, 0xf1, + 0x0f, 0x48, 0xb0, 0x06, 0x72, 0xf2, 0xe3, 0xca, 0xff, 0x2a, 0x42, 0x6e, 0x0c, 0x62, 0xa2, 0x96, + 0xa4, 0xaf, 0xab, 0xf4, 0xf1, 0x0c, 0xce, 0x44, 0xca, 0xbf, 0xc2, 0x6e, 0x5d, 0x18, 0xe6, 0x04, + 0xc4, 0x24, 0x3b, 0x88, 0x3d, 0x01, 0x31, 0xc9, 0x8e, 0x02, 0x31, 0x77, 0xa6, 0x40, 0x0c, 0xd4, + 0x7e, 0x12, 0x62, 0xa8, 0x10, 0x03, 0x1e, 0x82, 0x5f, 0xd4, 0x80, 0x70, 0x03, 0xe4, 0x48, 0xc6, + 0xda, 0x63, 0x0c, 0xe1, 0x06, 0x43, 0x44, 0xd3, 0x0d, 0xe0, 0x0b, 0xf0, 0x5b, 0xec, 0x3f, 0xbc, + 0x25, 0x42, 0xb8, 0x49, 0x76, 0xc9, 0x01, 0xba, 0xd3, 0x24, 0xeb, 0x8f, 0x49, 0xd6, 0x44, 0x16, + 0x2f, 0x45, 0xc6, 0xe5, 0x40, 0xc6, 0xe6, 0xee, 0x01, 0x74, 0xc1, 0xc6, 0xb4, 0x74, 0x95, 0x18, + 0x84, 0x76, 0x82, 0x2b, 0x8a, 0x3e, 0xc6, 0xfc, 0xbf, 0x9e, 0xe2, 0x3f, 0x9c, 0xc0, 0xab, 0x63, + 0x5d, 0xaa, 0xc6, 0x61, 0xa4, 0xc3, 0x53, 0xb0, 0x12, 0x1f, 0x8c, 0xdf, 0x3b, 0x21, 0x37, 0x15, + 0xb2, 0x47, 0xaa, 0xe8, 0xfd, 0x8c, 0xec, 0xa0, 0x4f, 0x76, 0x18, 0x0d, 0xe2, 0xc5, 0x48, 0xad, + 0x49, 0xed, 0xa2, 0xb2, 0x57, 0x9d, 0x0a, 0xdc, 0x27, 0x15, 0xf4, 0xe1, 0x67, 0x80, 0xfb, 0xa4, + 0x32, 0x0a, 0xdc, 0xaf, 0xc0, 0x13, 0xb0, 0xd4, 0xcf, 0xc5, 0xdf, 0xc1, 0x62, 0x82, 0xa2, 0x37, + 0x49, 0x49, 0xdb, 0x98, 0x42, 0x1b, 0xa6, 0x70, 0x56, 0xa2, 0x22, 0xe1, 0x88, 0x09, 0x3a, 0x24, + 0xdd, 0x2a, 0xa4, 0x6f, 0x8f, 0x92, 0x6e, 0xc7, 0x49, 0x97, 0x03, 0xd2, 0xe6, 0x05, 0x48, 0x61, + 0x16, 0x06, 0xbe, 0x17, 0xb2, 0xe8, 0x31, 0x37, 0x7a, 0xb6, 0xcd, 0xc2, 0x50, 0xee, 0xaa, 0x14, + 0x1e, 0x94, 0xd1, 0x63, 0x3e, 0x76, 0xc3, 0xeb, 0x46, 0x40, 0x6d, 0x76, 0x1e, 0xfd, 0x02, 0x1c, + 0xbd, 0x16, 0x2c, 0x94, 0x5b, 0x29, 0x89, 0xa7, 0x59, 0xdb, 0x65, 0x65, 0xf3, 0xc1, 0x34, 0x98, + 0x6b, 0x08, 0xca, 0x45, 0x2e, 0x01, 0x53, 0x60, 0xb6, 0x21, 0xfc, 0x20, 0xa7, 0xc1, 0x2c, 0x48, + 0x9f, 0x30, 0xca, 0x85, 0xc5, 0xa8, 0xc8, 0xcd, 0x18, 0xff, 0x81, 0x4c, 0x93, 0x53, 0x2f, 0x0c, + 0x7c, 0x2e, 0x18, 0x87, 0x7b, 0x20, 0x25, 0xcb, 0x36, 0xe3, 0x70, 0x59, 0xbd, 0x51, 0x7f, 0xb5, + 0xe6, 0x57, 0x46, 0xc5, 0xf8, 0x0a, 0x9b, 0x89, 0xa3, 0x95, 0xbb, 0x2f, 0x85, 0xc4, 0xdd, 0x7d, + 0x41, 0xfb, 0x74, 0x5f, 0xd0, 0x3e, 0xdf, 0x17, 0xb4, 0xb7, 0x5f, 0x0b, 0x09, 0x6b, 0x5e, 0xee, + 0x66, 0xf3, 0x7b, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd4, 0x82, 0xf6, 0x92, 0xcd, 0x06, 0x00, 0x00, } diff --git a/dbtesterpb/message.proto b/dbtesterpb/message.proto index b9ff478d..af29c568 100644 --- a/dbtesterpb/message.proto +++ b/dbtesterpb/message.proto @@ -3,6 +3,16 @@ package dbtesterpb; import "github.com/gogo/protobuf/gogoproto/gogo.proto"; +import "dbtesterpb/database_id.proto"; + +import "dbtesterpb/flag_etcd.proto"; +import "dbtesterpb/flag_zookeeper.proto"; +import "dbtesterpb/flag_consul.proto"; +import "dbtesterpb/flag_zetcd.proto"; +import "dbtesterpb/flag_cetcd.proto"; + +import "dbtesterpb/config_client_machine.proto"; + option (gogoproto.marshaler_all) = true; option (gogoproto.sizer_all) = true; option (gogoproto.unmarshaler_all) = true; @@ -12,59 +22,45 @@ service Transporter { rpc Transfer(Request) returns (Response) {} } +enum Operation { + Start = 0; + Stop = 1; + Heartbeat = 2; +} + message Request { - enum Operation { - Start = 0; - Stop = 1; - Heartbeat = 2; - } - enum Database { - etcdv2 = 0; - etcdv3 = 1; - zookeeper = 2; - consul = 3; - zetcd = 4; - cetcd = 5; - } - message Control { - string googleCloudProjectName = 1; - string googleCloudStorageKey = 2; - string googleCloudStorageBucketName = 3; - string googleCloudStorageSubDirectory = 4; - } - message Etcdv3 { - int64 snapCount = 1; - int64 quotaSizeBytes = 2; - } - message Zookeeper { - uint32 myID = 1; - int64 tickTime = 2; - int64 clientPort = 3; - int64 initLimit = 4; - int64 syncLimit = 5; - int64 snapCount = 6; - int64 maxClientConnections = 7; - } + Operation Operation = 1; + bool TriggerLogUpload = 2; - Operation operation = 1; - bool triggerLogUpload = 2; - Database databaseID = 3; - string databaseTag = 4; + DatabaseID DatabaseID = 3; + string DatabaseTag = 4; - string peerIPsString = 5; - uint32 ipIndex = 6; + string PeerIPsString = 5; + uint32 IPIndex = 6; - int64 currentClientNumber = 7; + int64 CurrentClientNumber = 7; - Control control = 8; - Etcdv3 etcdv3Config = 9; - Zookeeper zookeeperConfig = 10; + ConfigClientMachineInitial ConfigClientMachineInitial = 8; + + flag__etcd__v2_3 flag__etcd__v2_3 = 100; + flag__etcd__v3_1 flag__etcd__v3_1 = 101; + flag__etcd__v3_2 flag__etcd__v3_2 = 102; + flag__etcd__tip flag__etcd__tip = 103; + + flag__zookeeper__r3_4_9 flag__zookeeper__r3_4_9 = 200; + flag__zookeeper__r3_5_2_alpha flag__zookeeper__r3_5_2_alpha = 201; + + flag__consul__v0_7_5 flag__consul__v0_7_5 = 300; + flag__consul__v0_8_0 flag__consul__v0_8_0 = 301; + + flag__cetcd__beta flag__cetcd__beta = 400; + flag__zetcd__beta flag__zetcd__beta = 500; } message Response { - bool success = 1; - + bool Success = 1; + // DiskSpaceUsageBytes is the data size of the database on disk in bytes. // It measures after database is requested to stop. - int64 diskSpaceUsageBytes = 2; + int64 DiskSpaceUsageBytes = 2; } diff --git a/dbtesterpb/util.go b/dbtesterpb/util.go new file mode 100644 index 00000000..f2ef8d28 --- /dev/null +++ b/dbtesterpb/util.go @@ -0,0 +1,93 @@ +// Copyright 2017 CoreOS, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package dbtesterpb + +import ( + "image/color" + + "github.com/gonum/plot/plotutil" +) + +// IsValidDatabaseID returns false if the database id is not supported. +func IsValidDatabaseID(id string) bool { + _, ok := DatabaseID_value[id] + return ok +} + +func GetRGBI(databaseID string, i int) color.Color { + switch databaseID { + case "etcd__v2_3": + return color.RGBA{218, 97, 229, 255} // purple + case "etcd__v3_1": + return color.RGBA{24, 90, 169, 255} // blue + case "etcd__v3_2": + return color.RGBA{63, 81, 181, 255} // indigo + case "etcd__tip": + return color.RGBA{0, 229, 255, 255} // cyan + case "zookeeper__r3_5_2_alpha": + return color.RGBA{38, 169, 24, 255} // green + case "consul__v0_7_5": + return color.RGBA{198, 53, 53, 255} // red + case "zetcd__beta": + return color.RGBA{251, 206, 0, 255} // yellow + case "cetcd__beta": + return color.RGBA{205, 220, 57, 255} // lime + } + return plotutil.Color(i) +} + +func GetRGBII(databaseID string, i int) color.Color { + switch databaseID { + case "etcd__v2_3": + return color.RGBA{229, 212, 231, 255} // light-purple + case "etcd__v3_1": + return color.RGBA{129, 212, 247, 255} // light-blue + case "etcd__v3_2": + return color.RGBA{159, 168, 218, 255} // light-indigo + case "etcd__tip": + return color.RGBA{132, 255, 255, 255} // light-cyan + case "zookeeper__r3_5_2_alpha": + return color.RGBA{129, 247, 152, 255} // light-green + case "consul__v0_7_5": + return color.RGBA{247, 156, 156, 255} // light-red + case "zetcd__beta": + return color.RGBA{245, 247, 166, 255} // light-yellow + case "cetcd__beta": + return color.RGBA{238, 255, 65, 255} // light-lime + } + return plotutil.Color(i) +} + +func GetRGBIII(databaseID string, i int) color.Color { + switch databaseID { + case "etcd__v2_3": + return color.RGBA{165, 8, 180, 255} // deep-purple + case "etcd__v3_1": + return color.RGBA{37, 29, 191, 255} // deep-blue + case "etcd__v3_2": + return color.RGBA{26, 35, 126, 255} // deep-indigo + case "etcd__tip": + return color.RGBA{0, 96, 100, 255} // deep-cyan + case "zookeeper__r3_5_2_alpha": + return color.RGBA{7, 64, 35, 255} // deep-green + case "consul__v0_7_5": + return color.RGBA{212, 8, 46, 255} // deep-red + case "zetcd__beta": + return color.RGBA{229, 255, 0, 255} // deep-yellow + case "cetcd__beta": + return color.RGBA{205, 220, 57, 255} // deep-lime + } + return plotutil.Color(i) +}