Source file src/go.etcd.io/etcd/api/v3/membershippb/membership.pb.go

Documentation: go.etcd.io/etcd/api/v3/membershippb

     1  // Code generated by protoc-gen-gogo. DO NOT EDIT.
     2  // source: membership.proto
     3  
     4  package membershippb
     5  
     6  import (
     7  	fmt "fmt"
     8  	io "io"
     9  	math "math"
    10  	math_bits "math/bits"
    11  
    12  	_ "github.com/gogo/protobuf/gogoproto"
    13  	proto "github.com/golang/protobuf/proto"
    14  )
    15  
    16  // Reference imports to suppress errors if they are not otherwise used.
    17  var _ = proto.Marshal
    18  var _ = fmt.Errorf
    19  var _ = math.Inf
    20  
    21  // This is a compile-time assertion to ensure that this generated file
    22  // is compatible with the proto package it is being compiled against.
    23  // A compilation error at this line likely means your copy of the
    24  // proto package needs to be updated.
    25  const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
    26  
    27  // RaftAttributes represents the raft related attributes of an etcd member.
    28  type RaftAttributes struct {
    29  	// peerURLs is the list of peers in the raft cluster.
    30  	PeerUrls []string `protobuf:"bytes,1,rep,name=peer_urls,json=peerUrls,proto3" json:"peer_urls,omitempty"`
    31  	// isLearner indicates if the member is raft learner.
    32  	IsLearner            bool     `protobuf:"varint,2,opt,name=is_learner,json=isLearner,proto3" json:"is_learner,omitempty"`
    33  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
    34  	XXX_unrecognized     []byte   `json:"-"`
    35  	XXX_sizecache        int32    `json:"-"`
    36  }
    37  
    38  func (m *RaftAttributes) Reset()         { *m = RaftAttributes{} }
    39  func (m *RaftAttributes) String() string { return proto.CompactTextString(m) }
    40  func (*RaftAttributes) ProtoMessage()    {}
    41  func (*RaftAttributes) Descriptor() ([]byte, []int) {
    42  	return fileDescriptor_949fe0d019050ef5, []int{0}
    43  }
    44  func (m *RaftAttributes) XXX_Unmarshal(b []byte) error {
    45  	return m.Unmarshal(b)
    46  }
    47  func (m *RaftAttributes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    48  	if deterministic {
    49  		return xxx_messageInfo_RaftAttributes.Marshal(b, m, deterministic)
    50  	} else {
    51  		b = b[:cap(b)]
    52  		n, err := m.MarshalToSizedBuffer(b)
    53  		if err != nil {
    54  			return nil, err
    55  		}
    56  		return b[:n], nil
    57  	}
    58  }
    59  func (m *RaftAttributes) XXX_Merge(src proto.Message) {
    60  	xxx_messageInfo_RaftAttributes.Merge(m, src)
    61  }
    62  func (m *RaftAttributes) XXX_Size() int {
    63  	return m.Size()
    64  }
    65  func (m *RaftAttributes) XXX_DiscardUnknown() {
    66  	xxx_messageInfo_RaftAttributes.DiscardUnknown(m)
    67  }
    68  
    69  var xxx_messageInfo_RaftAttributes proto.InternalMessageInfo
    70  
    71  // Attributes represents all the non-raft related attributes of an etcd member.
    72  type Attributes struct {
    73  	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
    74  	ClientUrls           []string `protobuf:"bytes,2,rep,name=client_urls,json=clientUrls,proto3" json:"client_urls,omitempty"`
    75  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
    76  	XXX_unrecognized     []byte   `json:"-"`
    77  	XXX_sizecache        int32    `json:"-"`
    78  }
    79  
    80  func (m *Attributes) Reset()         { *m = Attributes{} }
    81  func (m *Attributes) String() string { return proto.CompactTextString(m) }
    82  func (*Attributes) ProtoMessage()    {}
    83  func (*Attributes) Descriptor() ([]byte, []int) {
    84  	return fileDescriptor_949fe0d019050ef5, []int{1}
    85  }
    86  func (m *Attributes) XXX_Unmarshal(b []byte) error {
    87  	return m.Unmarshal(b)
    88  }
    89  func (m *Attributes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    90  	if deterministic {
    91  		return xxx_messageInfo_Attributes.Marshal(b, m, deterministic)
    92  	} else {
    93  		b = b[:cap(b)]
    94  		n, err := m.MarshalToSizedBuffer(b)
    95  		if err != nil {
    96  			return nil, err
    97  		}
    98  		return b[:n], nil
    99  	}
   100  }
   101  func (m *Attributes) XXX_Merge(src proto.Message) {
   102  	xxx_messageInfo_Attributes.Merge(m, src)
   103  }
   104  func (m *Attributes) XXX_Size() int {
   105  	return m.Size()
   106  }
   107  func (m *Attributes) XXX_DiscardUnknown() {
   108  	xxx_messageInfo_Attributes.DiscardUnknown(m)
   109  }
   110  
   111  var xxx_messageInfo_Attributes proto.InternalMessageInfo
   112  
   113  type Member struct {
   114  	ID                   uint64          `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
   115  	RaftAttributes       *RaftAttributes `protobuf:"bytes,2,opt,name=raft_attributes,json=raftAttributes,proto3" json:"raft_attributes,omitempty"`
   116  	MemberAttributes     *Attributes     `protobuf:"bytes,3,opt,name=member_attributes,json=memberAttributes,proto3" json:"member_attributes,omitempty"`
   117  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
   118  	XXX_unrecognized     []byte          `json:"-"`
   119  	XXX_sizecache        int32           `json:"-"`
   120  }
   121  
   122  func (m *Member) Reset()         { *m = Member{} }
   123  func (m *Member) String() string { return proto.CompactTextString(m) }
   124  func (*Member) ProtoMessage()    {}
   125  func (*Member) Descriptor() ([]byte, []int) {
   126  	return fileDescriptor_949fe0d019050ef5, []int{2}
   127  }
   128  func (m *Member) XXX_Unmarshal(b []byte) error {
   129  	return m.Unmarshal(b)
   130  }
   131  func (m *Member) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   132  	if deterministic {
   133  		return xxx_messageInfo_Member.Marshal(b, m, deterministic)
   134  	} else {
   135  		b = b[:cap(b)]
   136  		n, err := m.MarshalToSizedBuffer(b)
   137  		if err != nil {
   138  			return nil, err
   139  		}
   140  		return b[:n], nil
   141  	}
   142  }
   143  func (m *Member) XXX_Merge(src proto.Message) {
   144  	xxx_messageInfo_Member.Merge(m, src)
   145  }
   146  func (m *Member) XXX_Size() int {
   147  	return m.Size()
   148  }
   149  func (m *Member) XXX_DiscardUnknown() {
   150  	xxx_messageInfo_Member.DiscardUnknown(m)
   151  }
   152  
   153  var xxx_messageInfo_Member proto.InternalMessageInfo
   154  
   155  type ClusterVersionSetRequest struct {
   156  	Ver                  string   `protobuf:"bytes,1,opt,name=ver,proto3" json:"ver,omitempty"`
   157  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   158  	XXX_unrecognized     []byte   `json:"-"`
   159  	XXX_sizecache        int32    `json:"-"`
   160  }
   161  
   162  func (m *ClusterVersionSetRequest) Reset()         { *m = ClusterVersionSetRequest{} }
   163  func (m *ClusterVersionSetRequest) String() string { return proto.CompactTextString(m) }
   164  func (*ClusterVersionSetRequest) ProtoMessage()    {}
   165  func (*ClusterVersionSetRequest) Descriptor() ([]byte, []int) {
   166  	return fileDescriptor_949fe0d019050ef5, []int{3}
   167  }
   168  func (m *ClusterVersionSetRequest) XXX_Unmarshal(b []byte) error {
   169  	return m.Unmarshal(b)
   170  }
   171  func (m *ClusterVersionSetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   172  	if deterministic {
   173  		return xxx_messageInfo_ClusterVersionSetRequest.Marshal(b, m, deterministic)
   174  	} else {
   175  		b = b[:cap(b)]
   176  		n, err := m.MarshalToSizedBuffer(b)
   177  		if err != nil {
   178  			return nil, err
   179  		}
   180  		return b[:n], nil
   181  	}
   182  }
   183  func (m *ClusterVersionSetRequest) XXX_Merge(src proto.Message) {
   184  	xxx_messageInfo_ClusterVersionSetRequest.Merge(m, src)
   185  }
   186  func (m *ClusterVersionSetRequest) XXX_Size() int {
   187  	return m.Size()
   188  }
   189  func (m *ClusterVersionSetRequest) XXX_DiscardUnknown() {
   190  	xxx_messageInfo_ClusterVersionSetRequest.DiscardUnknown(m)
   191  }
   192  
   193  var xxx_messageInfo_ClusterVersionSetRequest proto.InternalMessageInfo
   194  
   195  type ClusterMemberAttrSetRequest struct {
   196  	Member_ID            uint64      `protobuf:"varint,1,opt,name=member_ID,json=memberID,proto3" json:"member_ID,omitempty"`
   197  	MemberAttributes     *Attributes `protobuf:"bytes,2,opt,name=member_attributes,json=memberAttributes,proto3" json:"member_attributes,omitempty"`
   198  	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
   199  	XXX_unrecognized     []byte      `json:"-"`
   200  	XXX_sizecache        int32       `json:"-"`
   201  }
   202  
   203  func (m *ClusterMemberAttrSetRequest) Reset()         { *m = ClusterMemberAttrSetRequest{} }
   204  func (m *ClusterMemberAttrSetRequest) String() string { return proto.CompactTextString(m) }
   205  func (*ClusterMemberAttrSetRequest) ProtoMessage()    {}
   206  func (*ClusterMemberAttrSetRequest) Descriptor() ([]byte, []int) {
   207  	return fileDescriptor_949fe0d019050ef5, []int{4}
   208  }
   209  func (m *ClusterMemberAttrSetRequest) XXX_Unmarshal(b []byte) error {
   210  	return m.Unmarshal(b)
   211  }
   212  func (m *ClusterMemberAttrSetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   213  	if deterministic {
   214  		return xxx_messageInfo_ClusterMemberAttrSetRequest.Marshal(b, m, deterministic)
   215  	} else {
   216  		b = b[:cap(b)]
   217  		n, err := m.MarshalToSizedBuffer(b)
   218  		if err != nil {
   219  			return nil, err
   220  		}
   221  		return b[:n], nil
   222  	}
   223  }
   224  func (m *ClusterMemberAttrSetRequest) XXX_Merge(src proto.Message) {
   225  	xxx_messageInfo_ClusterMemberAttrSetRequest.Merge(m, src)
   226  }
   227  func (m *ClusterMemberAttrSetRequest) XXX_Size() int {
   228  	return m.Size()
   229  }
   230  func (m *ClusterMemberAttrSetRequest) XXX_DiscardUnknown() {
   231  	xxx_messageInfo_ClusterMemberAttrSetRequest.DiscardUnknown(m)
   232  }
   233  
   234  var xxx_messageInfo_ClusterMemberAttrSetRequest proto.InternalMessageInfo
   235  
   236  type DowngradeInfoSetRequest struct {
   237  	Enabled              bool     `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
   238  	Ver                  string   `protobuf:"bytes,2,opt,name=ver,proto3" json:"ver,omitempty"`
   239  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   240  	XXX_unrecognized     []byte   `json:"-"`
   241  	XXX_sizecache        int32    `json:"-"`
   242  }
   243  
   244  func (m *DowngradeInfoSetRequest) Reset()         { *m = DowngradeInfoSetRequest{} }
   245  func (m *DowngradeInfoSetRequest) String() string { return proto.CompactTextString(m) }
   246  func (*DowngradeInfoSetRequest) ProtoMessage()    {}
   247  func (*DowngradeInfoSetRequest) Descriptor() ([]byte, []int) {
   248  	return fileDescriptor_949fe0d019050ef5, []int{5}
   249  }
   250  func (m *DowngradeInfoSetRequest) XXX_Unmarshal(b []byte) error {
   251  	return m.Unmarshal(b)
   252  }
   253  func (m *DowngradeInfoSetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   254  	if deterministic {
   255  		return xxx_messageInfo_DowngradeInfoSetRequest.Marshal(b, m, deterministic)
   256  	} else {
   257  		b = b[:cap(b)]
   258  		n, err := m.MarshalToSizedBuffer(b)
   259  		if err != nil {
   260  			return nil, err
   261  		}
   262  		return b[:n], nil
   263  	}
   264  }
   265  func (m *DowngradeInfoSetRequest) XXX_Merge(src proto.Message) {
   266  	xxx_messageInfo_DowngradeInfoSetRequest.Merge(m, src)
   267  }
   268  func (m *DowngradeInfoSetRequest) XXX_Size() int {
   269  	return m.Size()
   270  }
   271  func (m *DowngradeInfoSetRequest) XXX_DiscardUnknown() {
   272  	xxx_messageInfo_DowngradeInfoSetRequest.DiscardUnknown(m)
   273  }
   274  
   275  var xxx_messageInfo_DowngradeInfoSetRequest proto.InternalMessageInfo
   276  
   277  func init() {
   278  	proto.RegisterType((*RaftAttributes)(nil), "membershippb.RaftAttributes")
   279  	proto.RegisterType((*Attributes)(nil), "membershippb.Attributes")
   280  	proto.RegisterType((*Member)(nil), "membershippb.Member")
   281  	proto.RegisterType((*ClusterVersionSetRequest)(nil), "membershippb.ClusterVersionSetRequest")
   282  	proto.RegisterType((*ClusterMemberAttrSetRequest)(nil), "membershippb.ClusterMemberAttrSetRequest")
   283  	proto.RegisterType((*DowngradeInfoSetRequest)(nil), "membershippb.DowngradeInfoSetRequest")
   284  }
   285  
   286  func init() { proto.RegisterFile("membership.proto", fileDescriptor_949fe0d019050ef5) }
   287  
   288  var fileDescriptor_949fe0d019050ef5 = []byte{
   289  	// 367 bytes of a gzipped FileDescriptorProto
   290  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xc1, 0x4e, 0xf2, 0x40,
   291  	0x14, 0x85, 0x99, 0x42, 0xf8, 0xdb, 0xcb, 0x1f, 0xc4, 0x09, 0x89, 0x8d, 0x68, 0x25, 0x5d, 0xb1,
   292  	0x30, 0x98, 0xe8, 0x13, 0xa0, 0xb0, 0x20, 0x81, 0xcd, 0x18, 0xdd, 0x92, 0x56, 0x2e, 0xd8, 0xa4,
   293  	0x74, 0xea, 0xcc, 0x54, 0xd7, 0xbe, 0x85, 0x4f, 0xe0, 0xb3, 0xb0, 0xf4, 0x11, 0x14, 0x5f, 0xc4,
   294  	0x74, 0x5a, 0x4a, 0x49, 0xdc, 0xb8, 0xbb, 0x3d, 0xbd, 0xf7, 0x9c, 0xf3, 0x35, 0x85, 0xd6, 0x0a,
   295  	0x57, 0x3e, 0x0a, 0xf9, 0x18, 0xc4, 0xfd, 0x58, 0x70, 0xc5, 0xe9, 0xff, 0x9d, 0x12, 0xfb, 0xc7,
   296  	0xed, 0x25, 0x5f, 0x72, 0xfd, 0xe2, 0x22, 0x9d, 0xb2, 0x1d, 0x77, 0x02, 0x4d, 0xe6, 0x2d, 0xd4,
   297  	0x40, 0x29, 0x11, 0xf8, 0x89, 0x42, 0x49, 0x3b, 0x60, 0xc5, 0x88, 0x62, 0x96, 0x88, 0x50, 0xda,
   298  	0xa4, 0x5b, 0xed, 0x59, 0xcc, 0x4c, 0x85, 0x3b, 0x11, 0x4a, 0x7a, 0x0a, 0x10, 0xc8, 0x59, 0x88,
   299  	0x9e, 0x88, 0x50, 0xd8, 0x46, 0x97, 0xf4, 0x4c, 0x66, 0x05, 0x72, 0x92, 0x09, 0xee, 0x00, 0xa0,
   300  	0xe4, 0x44, 0xa1, 0x16, 0x79, 0x2b, 0xb4, 0x49, 0x97, 0xf4, 0x2c, 0xa6, 0x67, 0x7a, 0x06, 0x8d,
   301  	0x87, 0x30, 0xc0, 0x48, 0x65, 0xfe, 0x86, 0xf6, 0x87, 0x4c, 0x4a, 0x13, 0xdc, 0x77, 0x02, 0xf5,
   302  	0xa9, 0xee, 0x4d, 0x9b, 0x60, 0x8c, 0x87, 0xfa, 0xba, 0xc6, 0x8c, 0xf1, 0x90, 0x8e, 0xe0, 0x40,
   303  	0x78, 0x0b, 0x35, 0xf3, 0x8a, 0x08, 0xdd, 0xa0, 0x71, 0x79, 0xd2, 0x2f, 0x93, 0xf6, 0xf7, 0x81,
   304  	0x58, 0x53, 0xec, 0x03, 0x8e, 0xe0, 0x30, 0x5b, 0x2f, 0x1b, 0x55, 0xb5, 0x91, 0xbd, 0x6f, 0x54,
   305  	0x32, 0xc9, 0xbf, 0xee, 0x4e, 0x71, 0xcf, 0xc1, 0xbe, 0x09, 0x13, 0xa9, 0x50, 0xdc, 0xa3, 0x90,
   306  	0x01, 0x8f, 0x6e, 0x51, 0x31, 0x7c, 0x4a, 0x50, 0x2a, 0xda, 0x82, 0xea, 0x33, 0x8a, 0x1c, 0x3c,
   307  	0x1d, 0xdd, 0x57, 0x02, 0x9d, 0x7c, 0x7d, 0x5a, 0x38, 0x95, 0x2e, 0x3a, 0x60, 0xe5, 0xa5, 0x0a,
   308  	0x64, 0x33, 0x13, 0x34, 0xf8, 0x2f, 0x8d, 0x8d, 0x3f, 0x37, 0x1e, 0xc1, 0xd1, 0x90, 0xbf, 0x44,
   309  	0x4b, 0xe1, 0xcd, 0x71, 0x1c, 0x2d, 0x78, 0x29, 0xde, 0x86, 0x7f, 0x18, 0x79, 0x7e, 0x88, 0x73,
   310  	0x1d, 0x6e, 0xb2, 0xed, 0xe3, 0x16, 0xc5, 0x28, 0x50, 0xae, 0xdb, 0xeb, 0x2f, 0xa7, 0xb2, 0xde,
   311  	0x38, 0xe4, 0x63, 0xe3, 0x90, 0xcf, 0x8d, 0x43, 0xde, 0xbe, 0x9d, 0x8a, 0x5f, 0xd7, 0xff, 0xd3,
   312  	0xd5, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xdc, 0x93, 0x7d, 0x0b, 0x87, 0x02, 0x00, 0x00,
   313  }
   314  
   315  func (m *RaftAttributes) Marshal() (dAtA []byte, err error) {
   316  	size := m.Size()
   317  	dAtA = make([]byte, size)
   318  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   319  	if err != nil {
   320  		return nil, err
   321  	}
   322  	return dAtA[:n], nil
   323  }
   324  
   325  func (m *RaftAttributes) MarshalTo(dAtA []byte) (int, error) {
   326  	size := m.Size()
   327  	return m.MarshalToSizedBuffer(dAtA[:size])
   328  }
   329  
   330  func (m *RaftAttributes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   331  	i := len(dAtA)
   332  	_ = i
   333  	var l int
   334  	_ = l
   335  	if m.XXX_unrecognized != nil {
   336  		i -= len(m.XXX_unrecognized)
   337  		copy(dAtA[i:], m.XXX_unrecognized)
   338  	}
   339  	if m.IsLearner {
   340  		i--
   341  		if m.IsLearner {
   342  			dAtA[i] = 1
   343  		} else {
   344  			dAtA[i] = 0
   345  		}
   346  		i--
   347  		dAtA[i] = 0x10
   348  	}
   349  	if len(m.PeerUrls) > 0 {
   350  		for iNdEx := len(m.PeerUrls) - 1; iNdEx >= 0; iNdEx-- {
   351  			i -= len(m.PeerUrls[iNdEx])
   352  			copy(dAtA[i:], m.PeerUrls[iNdEx])
   353  			i = encodeVarintMembership(dAtA, i, uint64(len(m.PeerUrls[iNdEx])))
   354  			i--
   355  			dAtA[i] = 0xa
   356  		}
   357  	}
   358  	return len(dAtA) - i, nil
   359  }
   360  
   361  func (m *Attributes) Marshal() (dAtA []byte, err error) {
   362  	size := m.Size()
   363  	dAtA = make([]byte, size)
   364  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   365  	if err != nil {
   366  		return nil, err
   367  	}
   368  	return dAtA[:n], nil
   369  }
   370  
   371  func (m *Attributes) MarshalTo(dAtA []byte) (int, error) {
   372  	size := m.Size()
   373  	return m.MarshalToSizedBuffer(dAtA[:size])
   374  }
   375  
   376  func (m *Attributes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   377  	i := len(dAtA)
   378  	_ = i
   379  	var l int
   380  	_ = l
   381  	if m.XXX_unrecognized != nil {
   382  		i -= len(m.XXX_unrecognized)
   383  		copy(dAtA[i:], m.XXX_unrecognized)
   384  	}
   385  	if len(m.ClientUrls) > 0 {
   386  		for iNdEx := len(m.ClientUrls) - 1; iNdEx >= 0; iNdEx-- {
   387  			i -= len(m.ClientUrls[iNdEx])
   388  			copy(dAtA[i:], m.ClientUrls[iNdEx])
   389  			i = encodeVarintMembership(dAtA, i, uint64(len(m.ClientUrls[iNdEx])))
   390  			i--
   391  			dAtA[i] = 0x12
   392  		}
   393  	}
   394  	if len(m.Name) > 0 {
   395  		i -= len(m.Name)
   396  		copy(dAtA[i:], m.Name)
   397  		i = encodeVarintMembership(dAtA, i, uint64(len(m.Name)))
   398  		i--
   399  		dAtA[i] = 0xa
   400  	}
   401  	return len(dAtA) - i, nil
   402  }
   403  
   404  func (m *Member) Marshal() (dAtA []byte, err error) {
   405  	size := m.Size()
   406  	dAtA = make([]byte, size)
   407  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   408  	if err != nil {
   409  		return nil, err
   410  	}
   411  	return dAtA[:n], nil
   412  }
   413  
   414  func (m *Member) MarshalTo(dAtA []byte) (int, error) {
   415  	size := m.Size()
   416  	return m.MarshalToSizedBuffer(dAtA[:size])
   417  }
   418  
   419  func (m *Member) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   420  	i := len(dAtA)
   421  	_ = i
   422  	var l int
   423  	_ = l
   424  	if m.XXX_unrecognized != nil {
   425  		i -= len(m.XXX_unrecognized)
   426  		copy(dAtA[i:], m.XXX_unrecognized)
   427  	}
   428  	if m.MemberAttributes != nil {
   429  		{
   430  			size, err := m.MemberAttributes.MarshalToSizedBuffer(dAtA[:i])
   431  			if err != nil {
   432  				return 0, err
   433  			}
   434  			i -= size
   435  			i = encodeVarintMembership(dAtA, i, uint64(size))
   436  		}
   437  		i--
   438  		dAtA[i] = 0x1a
   439  	}
   440  	if m.RaftAttributes != nil {
   441  		{
   442  			size, err := m.RaftAttributes.MarshalToSizedBuffer(dAtA[:i])
   443  			if err != nil {
   444  				return 0, err
   445  			}
   446  			i -= size
   447  			i = encodeVarintMembership(dAtA, i, uint64(size))
   448  		}
   449  		i--
   450  		dAtA[i] = 0x12
   451  	}
   452  	if m.ID != 0 {
   453  		i = encodeVarintMembership(dAtA, i, uint64(m.ID))
   454  		i--
   455  		dAtA[i] = 0x8
   456  	}
   457  	return len(dAtA) - i, nil
   458  }
   459  
   460  func (m *ClusterVersionSetRequest) Marshal() (dAtA []byte, err error) {
   461  	size := m.Size()
   462  	dAtA = make([]byte, size)
   463  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   464  	if err != nil {
   465  		return nil, err
   466  	}
   467  	return dAtA[:n], nil
   468  }
   469  
   470  func (m *ClusterVersionSetRequest) MarshalTo(dAtA []byte) (int, error) {
   471  	size := m.Size()
   472  	return m.MarshalToSizedBuffer(dAtA[:size])
   473  }
   474  
   475  func (m *ClusterVersionSetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   476  	i := len(dAtA)
   477  	_ = i
   478  	var l int
   479  	_ = l
   480  	if m.XXX_unrecognized != nil {
   481  		i -= len(m.XXX_unrecognized)
   482  		copy(dAtA[i:], m.XXX_unrecognized)
   483  	}
   484  	if len(m.Ver) > 0 {
   485  		i -= len(m.Ver)
   486  		copy(dAtA[i:], m.Ver)
   487  		i = encodeVarintMembership(dAtA, i, uint64(len(m.Ver)))
   488  		i--
   489  		dAtA[i] = 0xa
   490  	}
   491  	return len(dAtA) - i, nil
   492  }
   493  
   494  func (m *ClusterMemberAttrSetRequest) Marshal() (dAtA []byte, err error) {
   495  	size := m.Size()
   496  	dAtA = make([]byte, size)
   497  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   498  	if err != nil {
   499  		return nil, err
   500  	}
   501  	return dAtA[:n], nil
   502  }
   503  
   504  func (m *ClusterMemberAttrSetRequest) MarshalTo(dAtA []byte) (int, error) {
   505  	size := m.Size()
   506  	return m.MarshalToSizedBuffer(dAtA[:size])
   507  }
   508  
   509  func (m *ClusterMemberAttrSetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   510  	i := len(dAtA)
   511  	_ = i
   512  	var l int
   513  	_ = l
   514  	if m.XXX_unrecognized != nil {
   515  		i -= len(m.XXX_unrecognized)
   516  		copy(dAtA[i:], m.XXX_unrecognized)
   517  	}
   518  	if m.MemberAttributes != nil {
   519  		{
   520  			size, err := m.MemberAttributes.MarshalToSizedBuffer(dAtA[:i])
   521  			if err != nil {
   522  				return 0, err
   523  			}
   524  			i -= size
   525  			i = encodeVarintMembership(dAtA, i, uint64(size))
   526  		}
   527  		i--
   528  		dAtA[i] = 0x12
   529  	}
   530  	if m.Member_ID != 0 {
   531  		i = encodeVarintMembership(dAtA, i, uint64(m.Member_ID))
   532  		i--
   533  		dAtA[i] = 0x8
   534  	}
   535  	return len(dAtA) - i, nil
   536  }
   537  
   538  func (m *DowngradeInfoSetRequest) Marshal() (dAtA []byte, err error) {
   539  	size := m.Size()
   540  	dAtA = make([]byte, size)
   541  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   542  	if err != nil {
   543  		return nil, err
   544  	}
   545  	return dAtA[:n], nil
   546  }
   547  
   548  func (m *DowngradeInfoSetRequest) MarshalTo(dAtA []byte) (int, error) {
   549  	size := m.Size()
   550  	return m.MarshalToSizedBuffer(dAtA[:size])
   551  }
   552  
   553  func (m *DowngradeInfoSetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   554  	i := len(dAtA)
   555  	_ = i
   556  	var l int
   557  	_ = l
   558  	if m.XXX_unrecognized != nil {
   559  		i -= len(m.XXX_unrecognized)
   560  		copy(dAtA[i:], m.XXX_unrecognized)
   561  	}
   562  	if len(m.Ver) > 0 {
   563  		i -= len(m.Ver)
   564  		copy(dAtA[i:], m.Ver)
   565  		i = encodeVarintMembership(dAtA, i, uint64(len(m.Ver)))
   566  		i--
   567  		dAtA[i] = 0x12
   568  	}
   569  	if m.Enabled {
   570  		i--
   571  		if m.Enabled {
   572  			dAtA[i] = 1
   573  		} else {
   574  			dAtA[i] = 0
   575  		}
   576  		i--
   577  		dAtA[i] = 0x8
   578  	}
   579  	return len(dAtA) - i, nil
   580  }
   581  
   582  func encodeVarintMembership(dAtA []byte, offset int, v uint64) int {
   583  	offset -= sovMembership(v)
   584  	base := offset
   585  	for v >= 1<<7 {
   586  		dAtA[offset] = uint8(v&0x7f | 0x80)
   587  		v >>= 7
   588  		offset++
   589  	}
   590  	dAtA[offset] = uint8(v)
   591  	return base
   592  }
   593  func (m *RaftAttributes) Size() (n int) {
   594  	if m == nil {
   595  		return 0
   596  	}
   597  	var l int
   598  	_ = l
   599  	if len(m.PeerUrls) > 0 {
   600  		for _, s := range m.PeerUrls {
   601  			l = len(s)
   602  			n += 1 + l + sovMembership(uint64(l))
   603  		}
   604  	}
   605  	if m.IsLearner {
   606  		n += 2
   607  	}
   608  	if m.XXX_unrecognized != nil {
   609  		n += len(m.XXX_unrecognized)
   610  	}
   611  	return n
   612  }
   613  
   614  func (m *Attributes) Size() (n int) {
   615  	if m == nil {
   616  		return 0
   617  	}
   618  	var l int
   619  	_ = l
   620  	l = len(m.Name)
   621  	if l > 0 {
   622  		n += 1 + l + sovMembership(uint64(l))
   623  	}
   624  	if len(m.ClientUrls) > 0 {
   625  		for _, s := range m.ClientUrls {
   626  			l = len(s)
   627  			n += 1 + l + sovMembership(uint64(l))
   628  		}
   629  	}
   630  	if m.XXX_unrecognized != nil {
   631  		n += len(m.XXX_unrecognized)
   632  	}
   633  	return n
   634  }
   635  
   636  func (m *Member) Size() (n int) {
   637  	if m == nil {
   638  		return 0
   639  	}
   640  	var l int
   641  	_ = l
   642  	if m.ID != 0 {
   643  		n += 1 + sovMembership(uint64(m.ID))
   644  	}
   645  	if m.RaftAttributes != nil {
   646  		l = m.RaftAttributes.Size()
   647  		n += 1 + l + sovMembership(uint64(l))
   648  	}
   649  	if m.MemberAttributes != nil {
   650  		l = m.MemberAttributes.Size()
   651  		n += 1 + l + sovMembership(uint64(l))
   652  	}
   653  	if m.XXX_unrecognized != nil {
   654  		n += len(m.XXX_unrecognized)
   655  	}
   656  	return n
   657  }
   658  
   659  func (m *ClusterVersionSetRequest) Size() (n int) {
   660  	if m == nil {
   661  		return 0
   662  	}
   663  	var l int
   664  	_ = l
   665  	l = len(m.Ver)
   666  	if l > 0 {
   667  		n += 1 + l + sovMembership(uint64(l))
   668  	}
   669  	if m.XXX_unrecognized != nil {
   670  		n += len(m.XXX_unrecognized)
   671  	}
   672  	return n
   673  }
   674  
   675  func (m *ClusterMemberAttrSetRequest) Size() (n int) {
   676  	if m == nil {
   677  		return 0
   678  	}
   679  	var l int
   680  	_ = l
   681  	if m.Member_ID != 0 {
   682  		n += 1 + sovMembership(uint64(m.Member_ID))
   683  	}
   684  	if m.MemberAttributes != nil {
   685  		l = m.MemberAttributes.Size()
   686  		n += 1 + l + sovMembership(uint64(l))
   687  	}
   688  	if m.XXX_unrecognized != nil {
   689  		n += len(m.XXX_unrecognized)
   690  	}
   691  	return n
   692  }
   693  
   694  func (m *DowngradeInfoSetRequest) Size() (n int) {
   695  	if m == nil {
   696  		return 0
   697  	}
   698  	var l int
   699  	_ = l
   700  	if m.Enabled {
   701  		n += 2
   702  	}
   703  	l = len(m.Ver)
   704  	if l > 0 {
   705  		n += 1 + l + sovMembership(uint64(l))
   706  	}
   707  	if m.XXX_unrecognized != nil {
   708  		n += len(m.XXX_unrecognized)
   709  	}
   710  	return n
   711  }
   712  
   713  func sovMembership(x uint64) (n int) {
   714  	return (math_bits.Len64(x|1) + 6) / 7
   715  }
   716  func sozMembership(x uint64) (n int) {
   717  	return sovMembership(uint64((x << 1) ^ uint64((int64(x) >> 63))))
   718  }
   719  func (m *RaftAttributes) Unmarshal(dAtA []byte) error {
   720  	l := len(dAtA)
   721  	iNdEx := 0
   722  	for iNdEx < l {
   723  		preIndex := iNdEx
   724  		var wire uint64
   725  		for shift := uint(0); ; shift += 7 {
   726  			if shift >= 64 {
   727  				return ErrIntOverflowMembership
   728  			}
   729  			if iNdEx >= l {
   730  				return io.ErrUnexpectedEOF
   731  			}
   732  			b := dAtA[iNdEx]
   733  			iNdEx++
   734  			wire |= uint64(b&0x7F) << shift
   735  			if b < 0x80 {
   736  				break
   737  			}
   738  		}
   739  		fieldNum := int32(wire >> 3)
   740  		wireType := int(wire & 0x7)
   741  		if wireType == 4 {
   742  			return fmt.Errorf("proto: RaftAttributes: wiretype end group for non-group")
   743  		}
   744  		if fieldNum <= 0 {
   745  			return fmt.Errorf("proto: RaftAttributes: illegal tag %d (wire type %d)", fieldNum, wire)
   746  		}
   747  		switch fieldNum {
   748  		case 1:
   749  			if wireType != 2 {
   750  				return fmt.Errorf("proto: wrong wireType = %d for field PeerUrls", wireType)
   751  			}
   752  			var stringLen uint64
   753  			for shift := uint(0); ; shift += 7 {
   754  				if shift >= 64 {
   755  					return ErrIntOverflowMembership
   756  				}
   757  				if iNdEx >= l {
   758  					return io.ErrUnexpectedEOF
   759  				}
   760  				b := dAtA[iNdEx]
   761  				iNdEx++
   762  				stringLen |= uint64(b&0x7F) << shift
   763  				if b < 0x80 {
   764  					break
   765  				}
   766  			}
   767  			intStringLen := int(stringLen)
   768  			if intStringLen < 0 {
   769  				return ErrInvalidLengthMembership
   770  			}
   771  			postIndex := iNdEx + intStringLen
   772  			if postIndex < 0 {
   773  				return ErrInvalidLengthMembership
   774  			}
   775  			if postIndex > l {
   776  				return io.ErrUnexpectedEOF
   777  			}
   778  			m.PeerUrls = append(m.PeerUrls, string(dAtA[iNdEx:postIndex]))
   779  			iNdEx = postIndex
   780  		case 2:
   781  			if wireType != 0 {
   782  				return fmt.Errorf("proto: wrong wireType = %d for field IsLearner", wireType)
   783  			}
   784  			var v int
   785  			for shift := uint(0); ; shift += 7 {
   786  				if shift >= 64 {
   787  					return ErrIntOverflowMembership
   788  				}
   789  				if iNdEx >= l {
   790  					return io.ErrUnexpectedEOF
   791  				}
   792  				b := dAtA[iNdEx]
   793  				iNdEx++
   794  				v |= int(b&0x7F) << shift
   795  				if b < 0x80 {
   796  					break
   797  				}
   798  			}
   799  			m.IsLearner = bool(v != 0)
   800  		default:
   801  			iNdEx = preIndex
   802  			skippy, err := skipMembership(dAtA[iNdEx:])
   803  			if err != nil {
   804  				return err
   805  			}
   806  			if (skippy < 0) || (iNdEx+skippy) < 0 {
   807  				return ErrInvalidLengthMembership
   808  			}
   809  			if (iNdEx + skippy) > l {
   810  				return io.ErrUnexpectedEOF
   811  			}
   812  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
   813  			iNdEx += skippy
   814  		}
   815  	}
   816  
   817  	if iNdEx > l {
   818  		return io.ErrUnexpectedEOF
   819  	}
   820  	return nil
   821  }
   822  func (m *Attributes) Unmarshal(dAtA []byte) error {
   823  	l := len(dAtA)
   824  	iNdEx := 0
   825  	for iNdEx < l {
   826  		preIndex := iNdEx
   827  		var wire uint64
   828  		for shift := uint(0); ; shift += 7 {
   829  			if shift >= 64 {
   830  				return ErrIntOverflowMembership
   831  			}
   832  			if iNdEx >= l {
   833  				return io.ErrUnexpectedEOF
   834  			}
   835  			b := dAtA[iNdEx]
   836  			iNdEx++
   837  			wire |= uint64(b&0x7F) << shift
   838  			if b < 0x80 {
   839  				break
   840  			}
   841  		}
   842  		fieldNum := int32(wire >> 3)
   843  		wireType := int(wire & 0x7)
   844  		if wireType == 4 {
   845  			return fmt.Errorf("proto: Attributes: wiretype end group for non-group")
   846  		}
   847  		if fieldNum <= 0 {
   848  			return fmt.Errorf("proto: Attributes: illegal tag %d (wire type %d)", fieldNum, wire)
   849  		}
   850  		switch fieldNum {
   851  		case 1:
   852  			if wireType != 2 {
   853  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
   854  			}
   855  			var stringLen uint64
   856  			for shift := uint(0); ; shift += 7 {
   857  				if shift >= 64 {
   858  					return ErrIntOverflowMembership
   859  				}
   860  				if iNdEx >= l {
   861  					return io.ErrUnexpectedEOF
   862  				}
   863  				b := dAtA[iNdEx]
   864  				iNdEx++
   865  				stringLen |= uint64(b&0x7F) << shift
   866  				if b < 0x80 {
   867  					break
   868  				}
   869  			}
   870  			intStringLen := int(stringLen)
   871  			if intStringLen < 0 {
   872  				return ErrInvalidLengthMembership
   873  			}
   874  			postIndex := iNdEx + intStringLen
   875  			if postIndex < 0 {
   876  				return ErrInvalidLengthMembership
   877  			}
   878  			if postIndex > l {
   879  				return io.ErrUnexpectedEOF
   880  			}
   881  			m.Name = string(dAtA[iNdEx:postIndex])
   882  			iNdEx = postIndex
   883  		case 2:
   884  			if wireType != 2 {
   885  				return fmt.Errorf("proto: wrong wireType = %d for field ClientUrls", wireType)
   886  			}
   887  			var stringLen uint64
   888  			for shift := uint(0); ; shift += 7 {
   889  				if shift >= 64 {
   890  					return ErrIntOverflowMembership
   891  				}
   892  				if iNdEx >= l {
   893  					return io.ErrUnexpectedEOF
   894  				}
   895  				b := dAtA[iNdEx]
   896  				iNdEx++
   897  				stringLen |= uint64(b&0x7F) << shift
   898  				if b < 0x80 {
   899  					break
   900  				}
   901  			}
   902  			intStringLen := int(stringLen)
   903  			if intStringLen < 0 {
   904  				return ErrInvalidLengthMembership
   905  			}
   906  			postIndex := iNdEx + intStringLen
   907  			if postIndex < 0 {
   908  				return ErrInvalidLengthMembership
   909  			}
   910  			if postIndex > l {
   911  				return io.ErrUnexpectedEOF
   912  			}
   913  			m.ClientUrls = append(m.ClientUrls, string(dAtA[iNdEx:postIndex]))
   914  			iNdEx = postIndex
   915  		default:
   916  			iNdEx = preIndex
   917  			skippy, err := skipMembership(dAtA[iNdEx:])
   918  			if err != nil {
   919  				return err
   920  			}
   921  			if (skippy < 0) || (iNdEx+skippy) < 0 {
   922  				return ErrInvalidLengthMembership
   923  			}
   924  			if (iNdEx + skippy) > l {
   925  				return io.ErrUnexpectedEOF
   926  			}
   927  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
   928  			iNdEx += skippy
   929  		}
   930  	}
   931  
   932  	if iNdEx > l {
   933  		return io.ErrUnexpectedEOF
   934  	}
   935  	return nil
   936  }
   937  func (m *Member) Unmarshal(dAtA []byte) error {
   938  	l := len(dAtA)
   939  	iNdEx := 0
   940  	for iNdEx < l {
   941  		preIndex := iNdEx
   942  		var wire uint64
   943  		for shift := uint(0); ; shift += 7 {
   944  			if shift >= 64 {
   945  				return ErrIntOverflowMembership
   946  			}
   947  			if iNdEx >= l {
   948  				return io.ErrUnexpectedEOF
   949  			}
   950  			b := dAtA[iNdEx]
   951  			iNdEx++
   952  			wire |= uint64(b&0x7F) << shift
   953  			if b < 0x80 {
   954  				break
   955  			}
   956  		}
   957  		fieldNum := int32(wire >> 3)
   958  		wireType := int(wire & 0x7)
   959  		if wireType == 4 {
   960  			return fmt.Errorf("proto: Member: wiretype end group for non-group")
   961  		}
   962  		if fieldNum <= 0 {
   963  			return fmt.Errorf("proto: Member: illegal tag %d (wire type %d)", fieldNum, wire)
   964  		}
   965  		switch fieldNum {
   966  		case 1:
   967  			if wireType != 0 {
   968  				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
   969  			}
   970  			m.ID = 0
   971  			for shift := uint(0); ; shift += 7 {
   972  				if shift >= 64 {
   973  					return ErrIntOverflowMembership
   974  				}
   975  				if iNdEx >= l {
   976  					return io.ErrUnexpectedEOF
   977  				}
   978  				b := dAtA[iNdEx]
   979  				iNdEx++
   980  				m.ID |= uint64(b&0x7F) << shift
   981  				if b < 0x80 {
   982  					break
   983  				}
   984  			}
   985  		case 2:
   986  			if wireType != 2 {
   987  				return fmt.Errorf("proto: wrong wireType = %d for field RaftAttributes", wireType)
   988  			}
   989  			var msglen int
   990  			for shift := uint(0); ; shift += 7 {
   991  				if shift >= 64 {
   992  					return ErrIntOverflowMembership
   993  				}
   994  				if iNdEx >= l {
   995  					return io.ErrUnexpectedEOF
   996  				}
   997  				b := dAtA[iNdEx]
   998  				iNdEx++
   999  				msglen |= int(b&0x7F) << shift
  1000  				if b < 0x80 {
  1001  					break
  1002  				}
  1003  			}
  1004  			if msglen < 0 {
  1005  				return ErrInvalidLengthMembership
  1006  			}
  1007  			postIndex := iNdEx + msglen
  1008  			if postIndex < 0 {
  1009  				return ErrInvalidLengthMembership
  1010  			}
  1011  			if postIndex > l {
  1012  				return io.ErrUnexpectedEOF
  1013  			}
  1014  			if m.RaftAttributes == nil {
  1015  				m.RaftAttributes = &RaftAttributes{}
  1016  			}
  1017  			if err := m.RaftAttributes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1018  				return err
  1019  			}
  1020  			iNdEx = postIndex
  1021  		case 3:
  1022  			if wireType != 2 {
  1023  				return fmt.Errorf("proto: wrong wireType = %d for field MemberAttributes", wireType)
  1024  			}
  1025  			var msglen int
  1026  			for shift := uint(0); ; shift += 7 {
  1027  				if shift >= 64 {
  1028  					return ErrIntOverflowMembership
  1029  				}
  1030  				if iNdEx >= l {
  1031  					return io.ErrUnexpectedEOF
  1032  				}
  1033  				b := dAtA[iNdEx]
  1034  				iNdEx++
  1035  				msglen |= int(b&0x7F) << shift
  1036  				if b < 0x80 {
  1037  					break
  1038  				}
  1039  			}
  1040  			if msglen < 0 {
  1041  				return ErrInvalidLengthMembership
  1042  			}
  1043  			postIndex := iNdEx + msglen
  1044  			if postIndex < 0 {
  1045  				return ErrInvalidLengthMembership
  1046  			}
  1047  			if postIndex > l {
  1048  				return io.ErrUnexpectedEOF
  1049  			}
  1050  			if m.MemberAttributes == nil {
  1051  				m.MemberAttributes = &Attributes{}
  1052  			}
  1053  			if err := m.MemberAttributes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1054  				return err
  1055  			}
  1056  			iNdEx = postIndex
  1057  		default:
  1058  			iNdEx = preIndex
  1059  			skippy, err := skipMembership(dAtA[iNdEx:])
  1060  			if err != nil {
  1061  				return err
  1062  			}
  1063  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1064  				return ErrInvalidLengthMembership
  1065  			}
  1066  			if (iNdEx + skippy) > l {
  1067  				return io.ErrUnexpectedEOF
  1068  			}
  1069  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1070  			iNdEx += skippy
  1071  		}
  1072  	}
  1073  
  1074  	if iNdEx > l {
  1075  		return io.ErrUnexpectedEOF
  1076  	}
  1077  	return nil
  1078  }
  1079  func (m *ClusterVersionSetRequest) Unmarshal(dAtA []byte) error {
  1080  	l := len(dAtA)
  1081  	iNdEx := 0
  1082  	for iNdEx < l {
  1083  		preIndex := iNdEx
  1084  		var wire uint64
  1085  		for shift := uint(0); ; shift += 7 {
  1086  			if shift >= 64 {
  1087  				return ErrIntOverflowMembership
  1088  			}
  1089  			if iNdEx >= l {
  1090  				return io.ErrUnexpectedEOF
  1091  			}
  1092  			b := dAtA[iNdEx]
  1093  			iNdEx++
  1094  			wire |= uint64(b&0x7F) << shift
  1095  			if b < 0x80 {
  1096  				break
  1097  			}
  1098  		}
  1099  		fieldNum := int32(wire >> 3)
  1100  		wireType := int(wire & 0x7)
  1101  		if wireType == 4 {
  1102  			return fmt.Errorf("proto: ClusterVersionSetRequest: wiretype end group for non-group")
  1103  		}
  1104  		if fieldNum <= 0 {
  1105  			return fmt.Errorf("proto: ClusterVersionSetRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  1106  		}
  1107  		switch fieldNum {
  1108  		case 1:
  1109  			if wireType != 2 {
  1110  				return fmt.Errorf("proto: wrong wireType = %d for field Ver", wireType)
  1111  			}
  1112  			var stringLen uint64
  1113  			for shift := uint(0); ; shift += 7 {
  1114  				if shift >= 64 {
  1115  					return ErrIntOverflowMembership
  1116  				}
  1117  				if iNdEx >= l {
  1118  					return io.ErrUnexpectedEOF
  1119  				}
  1120  				b := dAtA[iNdEx]
  1121  				iNdEx++
  1122  				stringLen |= uint64(b&0x7F) << shift
  1123  				if b < 0x80 {
  1124  					break
  1125  				}
  1126  			}
  1127  			intStringLen := int(stringLen)
  1128  			if intStringLen < 0 {
  1129  				return ErrInvalidLengthMembership
  1130  			}
  1131  			postIndex := iNdEx + intStringLen
  1132  			if postIndex < 0 {
  1133  				return ErrInvalidLengthMembership
  1134  			}
  1135  			if postIndex > l {
  1136  				return io.ErrUnexpectedEOF
  1137  			}
  1138  			m.Ver = string(dAtA[iNdEx:postIndex])
  1139  			iNdEx = postIndex
  1140  		default:
  1141  			iNdEx = preIndex
  1142  			skippy, err := skipMembership(dAtA[iNdEx:])
  1143  			if err != nil {
  1144  				return err
  1145  			}
  1146  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1147  				return ErrInvalidLengthMembership
  1148  			}
  1149  			if (iNdEx + skippy) > l {
  1150  				return io.ErrUnexpectedEOF
  1151  			}
  1152  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1153  			iNdEx += skippy
  1154  		}
  1155  	}
  1156  
  1157  	if iNdEx > l {
  1158  		return io.ErrUnexpectedEOF
  1159  	}
  1160  	return nil
  1161  }
  1162  func (m *ClusterMemberAttrSetRequest) Unmarshal(dAtA []byte) error {
  1163  	l := len(dAtA)
  1164  	iNdEx := 0
  1165  	for iNdEx < l {
  1166  		preIndex := iNdEx
  1167  		var wire uint64
  1168  		for shift := uint(0); ; shift += 7 {
  1169  			if shift >= 64 {
  1170  				return ErrIntOverflowMembership
  1171  			}
  1172  			if iNdEx >= l {
  1173  				return io.ErrUnexpectedEOF
  1174  			}
  1175  			b := dAtA[iNdEx]
  1176  			iNdEx++
  1177  			wire |= uint64(b&0x7F) << shift
  1178  			if b < 0x80 {
  1179  				break
  1180  			}
  1181  		}
  1182  		fieldNum := int32(wire >> 3)
  1183  		wireType := int(wire & 0x7)
  1184  		if wireType == 4 {
  1185  			return fmt.Errorf("proto: ClusterMemberAttrSetRequest: wiretype end group for non-group")
  1186  		}
  1187  		if fieldNum <= 0 {
  1188  			return fmt.Errorf("proto: ClusterMemberAttrSetRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  1189  		}
  1190  		switch fieldNum {
  1191  		case 1:
  1192  			if wireType != 0 {
  1193  				return fmt.Errorf("proto: wrong wireType = %d for field Member_ID", wireType)
  1194  			}
  1195  			m.Member_ID = 0
  1196  			for shift := uint(0); ; shift += 7 {
  1197  				if shift >= 64 {
  1198  					return ErrIntOverflowMembership
  1199  				}
  1200  				if iNdEx >= l {
  1201  					return io.ErrUnexpectedEOF
  1202  				}
  1203  				b := dAtA[iNdEx]
  1204  				iNdEx++
  1205  				m.Member_ID |= uint64(b&0x7F) << shift
  1206  				if b < 0x80 {
  1207  					break
  1208  				}
  1209  			}
  1210  		case 2:
  1211  			if wireType != 2 {
  1212  				return fmt.Errorf("proto: wrong wireType = %d for field MemberAttributes", wireType)
  1213  			}
  1214  			var msglen int
  1215  			for shift := uint(0); ; shift += 7 {
  1216  				if shift >= 64 {
  1217  					return ErrIntOverflowMembership
  1218  				}
  1219  				if iNdEx >= l {
  1220  					return io.ErrUnexpectedEOF
  1221  				}
  1222  				b := dAtA[iNdEx]
  1223  				iNdEx++
  1224  				msglen |= int(b&0x7F) << shift
  1225  				if b < 0x80 {
  1226  					break
  1227  				}
  1228  			}
  1229  			if msglen < 0 {
  1230  				return ErrInvalidLengthMembership
  1231  			}
  1232  			postIndex := iNdEx + msglen
  1233  			if postIndex < 0 {
  1234  				return ErrInvalidLengthMembership
  1235  			}
  1236  			if postIndex > l {
  1237  				return io.ErrUnexpectedEOF
  1238  			}
  1239  			if m.MemberAttributes == nil {
  1240  				m.MemberAttributes = &Attributes{}
  1241  			}
  1242  			if err := m.MemberAttributes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1243  				return err
  1244  			}
  1245  			iNdEx = postIndex
  1246  		default:
  1247  			iNdEx = preIndex
  1248  			skippy, err := skipMembership(dAtA[iNdEx:])
  1249  			if err != nil {
  1250  				return err
  1251  			}
  1252  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1253  				return ErrInvalidLengthMembership
  1254  			}
  1255  			if (iNdEx + skippy) > l {
  1256  				return io.ErrUnexpectedEOF
  1257  			}
  1258  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1259  			iNdEx += skippy
  1260  		}
  1261  	}
  1262  
  1263  	if iNdEx > l {
  1264  		return io.ErrUnexpectedEOF
  1265  	}
  1266  	return nil
  1267  }
  1268  func (m *DowngradeInfoSetRequest) Unmarshal(dAtA []byte) error {
  1269  	l := len(dAtA)
  1270  	iNdEx := 0
  1271  	for iNdEx < l {
  1272  		preIndex := iNdEx
  1273  		var wire uint64
  1274  		for shift := uint(0); ; shift += 7 {
  1275  			if shift >= 64 {
  1276  				return ErrIntOverflowMembership
  1277  			}
  1278  			if iNdEx >= l {
  1279  				return io.ErrUnexpectedEOF
  1280  			}
  1281  			b := dAtA[iNdEx]
  1282  			iNdEx++
  1283  			wire |= uint64(b&0x7F) << shift
  1284  			if b < 0x80 {
  1285  				break
  1286  			}
  1287  		}
  1288  		fieldNum := int32(wire >> 3)
  1289  		wireType := int(wire & 0x7)
  1290  		if wireType == 4 {
  1291  			return fmt.Errorf("proto: DowngradeInfoSetRequest: wiretype end group for non-group")
  1292  		}
  1293  		if fieldNum <= 0 {
  1294  			return fmt.Errorf("proto: DowngradeInfoSetRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  1295  		}
  1296  		switch fieldNum {
  1297  		case 1:
  1298  			if wireType != 0 {
  1299  				return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType)
  1300  			}
  1301  			var v int
  1302  			for shift := uint(0); ; shift += 7 {
  1303  				if shift >= 64 {
  1304  					return ErrIntOverflowMembership
  1305  				}
  1306  				if iNdEx >= l {
  1307  					return io.ErrUnexpectedEOF
  1308  				}
  1309  				b := dAtA[iNdEx]
  1310  				iNdEx++
  1311  				v |= int(b&0x7F) << shift
  1312  				if b < 0x80 {
  1313  					break
  1314  				}
  1315  			}
  1316  			m.Enabled = bool(v != 0)
  1317  		case 2:
  1318  			if wireType != 2 {
  1319  				return fmt.Errorf("proto: wrong wireType = %d for field Ver", wireType)
  1320  			}
  1321  			var stringLen uint64
  1322  			for shift := uint(0); ; shift += 7 {
  1323  				if shift >= 64 {
  1324  					return ErrIntOverflowMembership
  1325  				}
  1326  				if iNdEx >= l {
  1327  					return io.ErrUnexpectedEOF
  1328  				}
  1329  				b := dAtA[iNdEx]
  1330  				iNdEx++
  1331  				stringLen |= uint64(b&0x7F) << shift
  1332  				if b < 0x80 {
  1333  					break
  1334  				}
  1335  			}
  1336  			intStringLen := int(stringLen)
  1337  			if intStringLen < 0 {
  1338  				return ErrInvalidLengthMembership
  1339  			}
  1340  			postIndex := iNdEx + intStringLen
  1341  			if postIndex < 0 {
  1342  				return ErrInvalidLengthMembership
  1343  			}
  1344  			if postIndex > l {
  1345  				return io.ErrUnexpectedEOF
  1346  			}
  1347  			m.Ver = string(dAtA[iNdEx:postIndex])
  1348  			iNdEx = postIndex
  1349  		default:
  1350  			iNdEx = preIndex
  1351  			skippy, err := skipMembership(dAtA[iNdEx:])
  1352  			if err != nil {
  1353  				return err
  1354  			}
  1355  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1356  				return ErrInvalidLengthMembership
  1357  			}
  1358  			if (iNdEx + skippy) > l {
  1359  				return io.ErrUnexpectedEOF
  1360  			}
  1361  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1362  			iNdEx += skippy
  1363  		}
  1364  	}
  1365  
  1366  	if iNdEx > l {
  1367  		return io.ErrUnexpectedEOF
  1368  	}
  1369  	return nil
  1370  }
  1371  func skipMembership(dAtA []byte) (n int, err error) {
  1372  	l := len(dAtA)
  1373  	iNdEx := 0
  1374  	depth := 0
  1375  	for iNdEx < l {
  1376  		var wire uint64
  1377  		for shift := uint(0); ; shift += 7 {
  1378  			if shift >= 64 {
  1379  				return 0, ErrIntOverflowMembership
  1380  			}
  1381  			if iNdEx >= l {
  1382  				return 0, io.ErrUnexpectedEOF
  1383  			}
  1384  			b := dAtA[iNdEx]
  1385  			iNdEx++
  1386  			wire |= (uint64(b) & 0x7F) << shift
  1387  			if b < 0x80 {
  1388  				break
  1389  			}
  1390  		}
  1391  		wireType := int(wire & 0x7)
  1392  		switch wireType {
  1393  		case 0:
  1394  			for shift := uint(0); ; shift += 7 {
  1395  				if shift >= 64 {
  1396  					return 0, ErrIntOverflowMembership
  1397  				}
  1398  				if iNdEx >= l {
  1399  					return 0, io.ErrUnexpectedEOF
  1400  				}
  1401  				iNdEx++
  1402  				if dAtA[iNdEx-1] < 0x80 {
  1403  					break
  1404  				}
  1405  			}
  1406  		case 1:
  1407  			iNdEx += 8
  1408  		case 2:
  1409  			var length int
  1410  			for shift := uint(0); ; shift += 7 {
  1411  				if shift >= 64 {
  1412  					return 0, ErrIntOverflowMembership
  1413  				}
  1414  				if iNdEx >= l {
  1415  					return 0, io.ErrUnexpectedEOF
  1416  				}
  1417  				b := dAtA[iNdEx]
  1418  				iNdEx++
  1419  				length |= (int(b) & 0x7F) << shift
  1420  				if b < 0x80 {
  1421  					break
  1422  				}
  1423  			}
  1424  			if length < 0 {
  1425  				return 0, ErrInvalidLengthMembership
  1426  			}
  1427  			iNdEx += length
  1428  		case 3:
  1429  			depth++
  1430  		case 4:
  1431  			if depth == 0 {
  1432  				return 0, ErrUnexpectedEndOfGroupMembership
  1433  			}
  1434  			depth--
  1435  		case 5:
  1436  			iNdEx += 4
  1437  		default:
  1438  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  1439  		}
  1440  		if iNdEx < 0 {
  1441  			return 0, ErrInvalidLengthMembership
  1442  		}
  1443  		if depth == 0 {
  1444  			return iNdEx, nil
  1445  		}
  1446  	}
  1447  	return 0, io.ErrUnexpectedEOF
  1448  }
  1449  
  1450  var (
  1451  	ErrInvalidLengthMembership        = fmt.Errorf("proto: negative length found during unmarshaling")
  1452  	ErrIntOverflowMembership          = fmt.Errorf("proto: integer overflow")
  1453  	ErrUnexpectedEndOfGroupMembership = fmt.Errorf("proto: unexpected end of group")
  1454  )
  1455  

View as plain text