1
2
3
4 package clusterpb
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/gogo/protobuf/proto"
14 )
15
16
17 var _ = proto.Marshal
18 var _ = fmt.Errorf
19 var _ = math.Inf
20
21
22
23
24
25 const _ = proto.GoGoProtoPackageIsVersion3
26
27 type MemberlistMessage_Kind int32
28
29 const (
30 MemberlistMessage_STREAM MemberlistMessage_Kind = 0
31 MemberlistMessage_PACKET MemberlistMessage_Kind = 1
32 )
33
34 var MemberlistMessage_Kind_name = map[int32]string{
35 0: "STREAM",
36 1: "PACKET",
37 }
38
39 var MemberlistMessage_Kind_value = map[string]int32{
40 "STREAM": 0,
41 "PACKET": 1,
42 }
43
44 func (x MemberlistMessage_Kind) String() string {
45 return proto.EnumName(MemberlistMessage_Kind_name, int32(x))
46 }
47
48 func (MemberlistMessage_Kind) EnumDescriptor() ([]byte, []int) {
49 return fileDescriptor_3cfb3b8ec240c376, []int{2, 0}
50 }
51
52 type Part struct {
53 Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
54 Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
55 XXX_NoUnkeyedLiteral struct{} `json:"-"`
56 XXX_unrecognized []byte `json:"-"`
57 XXX_sizecache int32 `json:"-"`
58 }
59
60 func (m *Part) Reset() { *m = Part{} }
61 func (m *Part) String() string { return proto.CompactTextString(m) }
62 func (*Part) ProtoMessage() {}
63 func (*Part) Descriptor() ([]byte, []int) {
64 return fileDescriptor_3cfb3b8ec240c376, []int{0}
65 }
66 func (m *Part) XXX_Unmarshal(b []byte) error {
67 return m.Unmarshal(b)
68 }
69 func (m *Part) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
70 if deterministic {
71 return xxx_messageInfo_Part.Marshal(b, m, deterministic)
72 } else {
73 b = b[:cap(b)]
74 n, err := m.MarshalToSizedBuffer(b)
75 if err != nil {
76 return nil, err
77 }
78 return b[:n], nil
79 }
80 }
81 func (m *Part) XXX_Merge(src proto.Message) {
82 xxx_messageInfo_Part.Merge(m, src)
83 }
84 func (m *Part) XXX_Size() int {
85 return m.Size()
86 }
87 func (m *Part) XXX_DiscardUnknown() {
88 xxx_messageInfo_Part.DiscardUnknown(m)
89 }
90
91 var xxx_messageInfo_Part proto.InternalMessageInfo
92
93 type FullState struct {
94 Parts []Part `protobuf:"bytes,1,rep,name=parts,proto3" json:"parts"`
95 XXX_NoUnkeyedLiteral struct{} `json:"-"`
96 XXX_unrecognized []byte `json:"-"`
97 XXX_sizecache int32 `json:"-"`
98 }
99
100 func (m *FullState) Reset() { *m = FullState{} }
101 func (m *FullState) String() string { return proto.CompactTextString(m) }
102 func (*FullState) ProtoMessage() {}
103 func (*FullState) Descriptor() ([]byte, []int) {
104 return fileDescriptor_3cfb3b8ec240c376, []int{1}
105 }
106 func (m *FullState) XXX_Unmarshal(b []byte) error {
107 return m.Unmarshal(b)
108 }
109 func (m *FullState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
110 if deterministic {
111 return xxx_messageInfo_FullState.Marshal(b, m, deterministic)
112 } else {
113 b = b[:cap(b)]
114 n, err := m.MarshalToSizedBuffer(b)
115 if err != nil {
116 return nil, err
117 }
118 return b[:n], nil
119 }
120 }
121 func (m *FullState) XXX_Merge(src proto.Message) {
122 xxx_messageInfo_FullState.Merge(m, src)
123 }
124 func (m *FullState) XXX_Size() int {
125 return m.Size()
126 }
127 func (m *FullState) XXX_DiscardUnknown() {
128 xxx_messageInfo_FullState.DiscardUnknown(m)
129 }
130
131 var xxx_messageInfo_FullState proto.InternalMessageInfo
132
133 type MemberlistMessage struct {
134 Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
135 Kind MemberlistMessage_Kind `protobuf:"varint,2,opt,name=kind,proto3,enum=clusterpb.MemberlistMessage_Kind" json:"kind,omitempty"`
136 FromAddr string `protobuf:"bytes,3,opt,name=from_addr,json=fromAddr,proto3" json:"from_addr,omitempty"`
137 Msg []byte `protobuf:"bytes,4,opt,name=msg,proto3" json:"msg,omitempty"`
138 XXX_NoUnkeyedLiteral struct{} `json:"-"`
139 XXX_unrecognized []byte `json:"-"`
140 XXX_sizecache int32 `json:"-"`
141 }
142
143 func (m *MemberlistMessage) Reset() { *m = MemberlistMessage{} }
144 func (m *MemberlistMessage) String() string { return proto.CompactTextString(m) }
145 func (*MemberlistMessage) ProtoMessage() {}
146 func (*MemberlistMessage) Descriptor() ([]byte, []int) {
147 return fileDescriptor_3cfb3b8ec240c376, []int{2}
148 }
149 func (m *MemberlistMessage) XXX_Unmarshal(b []byte) error {
150 return m.Unmarshal(b)
151 }
152 func (m *MemberlistMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
153 if deterministic {
154 return xxx_messageInfo_MemberlistMessage.Marshal(b, m, deterministic)
155 } else {
156 b = b[:cap(b)]
157 n, err := m.MarshalToSizedBuffer(b)
158 if err != nil {
159 return nil, err
160 }
161 return b[:n], nil
162 }
163 }
164 func (m *MemberlistMessage) XXX_Merge(src proto.Message) {
165 xxx_messageInfo_MemberlistMessage.Merge(m, src)
166 }
167 func (m *MemberlistMessage) XXX_Size() int {
168 return m.Size()
169 }
170 func (m *MemberlistMessage) XXX_DiscardUnknown() {
171 xxx_messageInfo_MemberlistMessage.DiscardUnknown(m)
172 }
173
174 var xxx_messageInfo_MemberlistMessage proto.InternalMessageInfo
175
176 func init() {
177 proto.RegisterEnum("clusterpb.MemberlistMessage_Kind", MemberlistMessage_Kind_name, MemberlistMessage_Kind_value)
178 proto.RegisterType((*Part)(nil), "clusterpb.Part")
179 proto.RegisterType((*FullState)(nil), "clusterpb.FullState")
180 proto.RegisterType((*MemberlistMessage)(nil), "clusterpb.MemberlistMessage")
181 }
182
183 func init() { proto.RegisterFile("cluster.proto", fileDescriptor_3cfb3b8ec240c376) }
184
185 var fileDescriptor_3cfb3b8ec240c376 = []byte{
186
187 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x90, 0xdf, 0x4a, 0xc3, 0x30,
188 0x14, 0xc6, 0x17, 0x17, 0xa7, 0x3d, 0xfe, 0xab, 0xc1, 0x8b, 0xa0, 0x50, 0x67, 0xaf, 0x06, 0x4a,
189 0x85, 0x89, 0xe0, 0xed, 0x26, 0xf3, 0x66, 0x14, 0x46, 0xb7, 0x7b, 0x49, 0x4d, 0x2c, 0x65, 0x6d,
190 0x53, 0x92, 0x4c, 0xf0, 0xb9, 0x7c, 0x89, 0x5e, 0xfa, 0x04, 0xa2, 0x7d, 0x12, 0x49, 0x36, 0x45,
191 0xf0, 0xee, 0x77, 0x0e, 0x5f, 0x7e, 0x1f, 0x27, 0x70, 0xf0, 0x54, 0xac, 0xb4, 0x11, 0x2a, 0xaa,
192 0x95, 0x34, 0x92, 0x78, 0x9b, 0xb1, 0x4e, 0x4f, 0x4f, 0x32, 0x99, 0x49, 0xb7, 0xbd, 0xb6, 0xb4,
193 0x0e, 0x84, 0x57, 0x80, 0x67, 0x4c, 0x19, 0xe2, 0x43, 0x77, 0x29, 0x5e, 0x29, 0xea, 0xa3, 0x81,
194 0x97, 0x58, 0x24, 0x04, 0x30, 0x67, 0x86, 0xd1, 0xad, 0x3e, 0x1a, 0xec, 0x27, 0x8e, 0xc3, 0x3b,
195 0xf0, 0x1e, 0x56, 0x45, 0x31, 0x37, 0xcc, 0x08, 0x72, 0x09, 0xdb, 0x35, 0x53, 0x46, 0x53, 0xd4,
196 0xef, 0x0e, 0xf6, 0x86, 0x47, 0xd1, 0x6f, 0x57, 0x64, 0x95, 0x63, 0xdc, 0x7c, 0x9c, 0x77, 0x92,
197 0x75, 0x26, 0x7c, 0x43, 0x70, 0x1c, 0x8b, 0x32, 0x15, 0xaa, 0xc8, 0xb5, 0x89, 0x85, 0xd6, 0x2c,
198 0x13, 0x84, 0xc2, 0xce, 0x8b, 0x50, 0x3a, 0x97, 0xd5, 0xa6, 0xf9, 0x67, 0x24, 0xb7, 0x80, 0x97,
199 0x79, 0xc5, 0x5d, 0xfb, 0xe1, 0xf0, 0xe2, 0x8f, 0xfb, 0x9f, 0x25, 0x9a, 0xe6, 0x15, 0x4f, 0x5c,
200 0x9c, 0x9c, 0x81, 0xf7, 0xac, 0x64, 0xf9, 0xc8, 0x38, 0x57, 0xb4, 0xeb, 0x94, 0xbb, 0x76, 0x31,
201 0xe2, 0x5c, 0xd9, 0x1b, 0x4b, 0x9d, 0x51, 0xec, 0x0e, 0xb2, 0x18, 0x06, 0x80, 0xed, 0x63, 0x02,
202 0xd0, 0x9b, 0x2f, 0x92, 0xc9, 0x28, 0xf6, 0x3b, 0x96, 0x67, 0xa3, 0xfb, 0xe9, 0x64, 0xe1, 0xa3,
203 0xb1, 0xdf, 0x7c, 0x05, 0x9d, 0xa6, 0x0d, 0xd0, 0x7b, 0x1b, 0xa0, 0xcf, 0x36, 0x40, 0x69, 0xcf,
204 0x7d, 0xdb, 0xcd, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0xaa, 0x3f, 0xca, 0x45, 0x68, 0x01, 0x00,
205 0x00,
206 }
207
208 func (m *Part) Marshal() (dAtA []byte, err error) {
209 size := m.Size()
210 dAtA = make([]byte, size)
211 n, err := m.MarshalToSizedBuffer(dAtA[:size])
212 if err != nil {
213 return nil, err
214 }
215 return dAtA[:n], nil
216 }
217
218 func (m *Part) MarshalTo(dAtA []byte) (int, error) {
219 size := m.Size()
220 return m.MarshalToSizedBuffer(dAtA[:size])
221 }
222
223 func (m *Part) MarshalToSizedBuffer(dAtA []byte) (int, error) {
224 i := len(dAtA)
225 _ = i
226 var l int
227 _ = l
228 if m.XXX_unrecognized != nil {
229 i -= len(m.XXX_unrecognized)
230 copy(dAtA[i:], m.XXX_unrecognized)
231 }
232 if len(m.Data) > 0 {
233 i -= len(m.Data)
234 copy(dAtA[i:], m.Data)
235 i = encodeVarintCluster(dAtA, i, uint64(len(m.Data)))
236 i--
237 dAtA[i] = 0x12
238 }
239 if len(m.Key) > 0 {
240 i -= len(m.Key)
241 copy(dAtA[i:], m.Key)
242 i = encodeVarintCluster(dAtA, i, uint64(len(m.Key)))
243 i--
244 dAtA[i] = 0xa
245 }
246 return len(dAtA) - i, nil
247 }
248
249 func (m *FullState) Marshal() (dAtA []byte, err error) {
250 size := m.Size()
251 dAtA = make([]byte, size)
252 n, err := m.MarshalToSizedBuffer(dAtA[:size])
253 if err != nil {
254 return nil, err
255 }
256 return dAtA[:n], nil
257 }
258
259 func (m *FullState) MarshalTo(dAtA []byte) (int, error) {
260 size := m.Size()
261 return m.MarshalToSizedBuffer(dAtA[:size])
262 }
263
264 func (m *FullState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
265 i := len(dAtA)
266 _ = i
267 var l int
268 _ = l
269 if m.XXX_unrecognized != nil {
270 i -= len(m.XXX_unrecognized)
271 copy(dAtA[i:], m.XXX_unrecognized)
272 }
273 if len(m.Parts) > 0 {
274 for iNdEx := len(m.Parts) - 1; iNdEx >= 0; iNdEx-- {
275 {
276 size, err := m.Parts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
277 if err != nil {
278 return 0, err
279 }
280 i -= size
281 i = encodeVarintCluster(dAtA, i, uint64(size))
282 }
283 i--
284 dAtA[i] = 0xa
285 }
286 }
287 return len(dAtA) - i, nil
288 }
289
290 func (m *MemberlistMessage) Marshal() (dAtA []byte, err error) {
291 size := m.Size()
292 dAtA = make([]byte, size)
293 n, err := m.MarshalToSizedBuffer(dAtA[:size])
294 if err != nil {
295 return nil, err
296 }
297 return dAtA[:n], nil
298 }
299
300 func (m *MemberlistMessage) MarshalTo(dAtA []byte) (int, error) {
301 size := m.Size()
302 return m.MarshalToSizedBuffer(dAtA[:size])
303 }
304
305 func (m *MemberlistMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
306 i := len(dAtA)
307 _ = i
308 var l int
309 _ = l
310 if m.XXX_unrecognized != nil {
311 i -= len(m.XXX_unrecognized)
312 copy(dAtA[i:], m.XXX_unrecognized)
313 }
314 if len(m.Msg) > 0 {
315 i -= len(m.Msg)
316 copy(dAtA[i:], m.Msg)
317 i = encodeVarintCluster(dAtA, i, uint64(len(m.Msg)))
318 i--
319 dAtA[i] = 0x22
320 }
321 if len(m.FromAddr) > 0 {
322 i -= len(m.FromAddr)
323 copy(dAtA[i:], m.FromAddr)
324 i = encodeVarintCluster(dAtA, i, uint64(len(m.FromAddr)))
325 i--
326 dAtA[i] = 0x1a
327 }
328 if m.Kind != 0 {
329 i = encodeVarintCluster(dAtA, i, uint64(m.Kind))
330 i--
331 dAtA[i] = 0x10
332 }
333 if len(m.Version) > 0 {
334 i -= len(m.Version)
335 copy(dAtA[i:], m.Version)
336 i = encodeVarintCluster(dAtA, i, uint64(len(m.Version)))
337 i--
338 dAtA[i] = 0xa
339 }
340 return len(dAtA) - i, nil
341 }
342
343 func encodeVarintCluster(dAtA []byte, offset int, v uint64) int {
344 offset -= sovCluster(v)
345 base := offset
346 for v >= 1<<7 {
347 dAtA[offset] = uint8(v&0x7f | 0x80)
348 v >>= 7
349 offset++
350 }
351 dAtA[offset] = uint8(v)
352 return base
353 }
354 func (m *Part) Size() (n int) {
355 if m == nil {
356 return 0
357 }
358 var l int
359 _ = l
360 l = len(m.Key)
361 if l > 0 {
362 n += 1 + l + sovCluster(uint64(l))
363 }
364 l = len(m.Data)
365 if l > 0 {
366 n += 1 + l + sovCluster(uint64(l))
367 }
368 if m.XXX_unrecognized != nil {
369 n += len(m.XXX_unrecognized)
370 }
371 return n
372 }
373
374 func (m *FullState) Size() (n int) {
375 if m == nil {
376 return 0
377 }
378 var l int
379 _ = l
380 if len(m.Parts) > 0 {
381 for _, e := range m.Parts {
382 l = e.Size()
383 n += 1 + l + sovCluster(uint64(l))
384 }
385 }
386 if m.XXX_unrecognized != nil {
387 n += len(m.XXX_unrecognized)
388 }
389 return n
390 }
391
392 func (m *MemberlistMessage) Size() (n int) {
393 if m == nil {
394 return 0
395 }
396 var l int
397 _ = l
398 l = len(m.Version)
399 if l > 0 {
400 n += 1 + l + sovCluster(uint64(l))
401 }
402 if m.Kind != 0 {
403 n += 1 + sovCluster(uint64(m.Kind))
404 }
405 l = len(m.FromAddr)
406 if l > 0 {
407 n += 1 + l + sovCluster(uint64(l))
408 }
409 l = len(m.Msg)
410 if l > 0 {
411 n += 1 + l + sovCluster(uint64(l))
412 }
413 if m.XXX_unrecognized != nil {
414 n += len(m.XXX_unrecognized)
415 }
416 return n
417 }
418
419 func sovCluster(x uint64) (n int) {
420 return (math_bits.Len64(x|1) + 6) / 7
421 }
422 func sozCluster(x uint64) (n int) {
423 return sovCluster(uint64((x << 1) ^ uint64((int64(x) >> 63))))
424 }
425 func (m *Part) Unmarshal(dAtA []byte) error {
426 l := len(dAtA)
427 iNdEx := 0
428 for iNdEx < l {
429 preIndex := iNdEx
430 var wire uint64
431 for shift := uint(0); ; shift += 7 {
432 if shift >= 64 {
433 return ErrIntOverflowCluster
434 }
435 if iNdEx >= l {
436 return io.ErrUnexpectedEOF
437 }
438 b := dAtA[iNdEx]
439 iNdEx++
440 wire |= uint64(b&0x7F) << shift
441 if b < 0x80 {
442 break
443 }
444 }
445 fieldNum := int32(wire >> 3)
446 wireType := int(wire & 0x7)
447 if wireType == 4 {
448 return fmt.Errorf("proto: Part: wiretype end group for non-group")
449 }
450 if fieldNum <= 0 {
451 return fmt.Errorf("proto: Part: illegal tag %d (wire type %d)", fieldNum, wire)
452 }
453 switch fieldNum {
454 case 1:
455 if wireType != 2 {
456 return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
457 }
458 var stringLen uint64
459 for shift := uint(0); ; shift += 7 {
460 if shift >= 64 {
461 return ErrIntOverflowCluster
462 }
463 if iNdEx >= l {
464 return io.ErrUnexpectedEOF
465 }
466 b := dAtA[iNdEx]
467 iNdEx++
468 stringLen |= uint64(b&0x7F) << shift
469 if b < 0x80 {
470 break
471 }
472 }
473 intStringLen := int(stringLen)
474 if intStringLen < 0 {
475 return ErrInvalidLengthCluster
476 }
477 postIndex := iNdEx + intStringLen
478 if postIndex < 0 {
479 return ErrInvalidLengthCluster
480 }
481 if postIndex > l {
482 return io.ErrUnexpectedEOF
483 }
484 m.Key = string(dAtA[iNdEx:postIndex])
485 iNdEx = postIndex
486 case 2:
487 if wireType != 2 {
488 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
489 }
490 var byteLen int
491 for shift := uint(0); ; shift += 7 {
492 if shift >= 64 {
493 return ErrIntOverflowCluster
494 }
495 if iNdEx >= l {
496 return io.ErrUnexpectedEOF
497 }
498 b := dAtA[iNdEx]
499 iNdEx++
500 byteLen |= int(b&0x7F) << shift
501 if b < 0x80 {
502 break
503 }
504 }
505 if byteLen < 0 {
506 return ErrInvalidLengthCluster
507 }
508 postIndex := iNdEx + byteLen
509 if postIndex < 0 {
510 return ErrInvalidLengthCluster
511 }
512 if postIndex > l {
513 return io.ErrUnexpectedEOF
514 }
515 m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
516 if m.Data == nil {
517 m.Data = []byte{}
518 }
519 iNdEx = postIndex
520 default:
521 iNdEx = preIndex
522 skippy, err := skipCluster(dAtA[iNdEx:])
523 if err != nil {
524 return err
525 }
526 if (skippy < 0) || (iNdEx+skippy) < 0 {
527 return ErrInvalidLengthCluster
528 }
529 if (iNdEx + skippy) > l {
530 return io.ErrUnexpectedEOF
531 }
532 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
533 iNdEx += skippy
534 }
535 }
536
537 if iNdEx > l {
538 return io.ErrUnexpectedEOF
539 }
540 return nil
541 }
542 func (m *FullState) Unmarshal(dAtA []byte) error {
543 l := len(dAtA)
544 iNdEx := 0
545 for iNdEx < l {
546 preIndex := iNdEx
547 var wire uint64
548 for shift := uint(0); ; shift += 7 {
549 if shift >= 64 {
550 return ErrIntOverflowCluster
551 }
552 if iNdEx >= l {
553 return io.ErrUnexpectedEOF
554 }
555 b := dAtA[iNdEx]
556 iNdEx++
557 wire |= uint64(b&0x7F) << shift
558 if b < 0x80 {
559 break
560 }
561 }
562 fieldNum := int32(wire >> 3)
563 wireType := int(wire & 0x7)
564 if wireType == 4 {
565 return fmt.Errorf("proto: FullState: wiretype end group for non-group")
566 }
567 if fieldNum <= 0 {
568 return fmt.Errorf("proto: FullState: illegal tag %d (wire type %d)", fieldNum, wire)
569 }
570 switch fieldNum {
571 case 1:
572 if wireType != 2 {
573 return fmt.Errorf("proto: wrong wireType = %d for field Parts", wireType)
574 }
575 var msglen int
576 for shift := uint(0); ; shift += 7 {
577 if shift >= 64 {
578 return ErrIntOverflowCluster
579 }
580 if iNdEx >= l {
581 return io.ErrUnexpectedEOF
582 }
583 b := dAtA[iNdEx]
584 iNdEx++
585 msglen |= int(b&0x7F) << shift
586 if b < 0x80 {
587 break
588 }
589 }
590 if msglen < 0 {
591 return ErrInvalidLengthCluster
592 }
593 postIndex := iNdEx + msglen
594 if postIndex < 0 {
595 return ErrInvalidLengthCluster
596 }
597 if postIndex > l {
598 return io.ErrUnexpectedEOF
599 }
600 m.Parts = append(m.Parts, Part{})
601 if err := m.Parts[len(m.Parts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
602 return err
603 }
604 iNdEx = postIndex
605 default:
606 iNdEx = preIndex
607 skippy, err := skipCluster(dAtA[iNdEx:])
608 if err != nil {
609 return err
610 }
611 if (skippy < 0) || (iNdEx+skippy) < 0 {
612 return ErrInvalidLengthCluster
613 }
614 if (iNdEx + skippy) > l {
615 return io.ErrUnexpectedEOF
616 }
617 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
618 iNdEx += skippy
619 }
620 }
621
622 if iNdEx > l {
623 return io.ErrUnexpectedEOF
624 }
625 return nil
626 }
627 func (m *MemberlistMessage) Unmarshal(dAtA []byte) error {
628 l := len(dAtA)
629 iNdEx := 0
630 for iNdEx < l {
631 preIndex := iNdEx
632 var wire uint64
633 for shift := uint(0); ; shift += 7 {
634 if shift >= 64 {
635 return ErrIntOverflowCluster
636 }
637 if iNdEx >= l {
638 return io.ErrUnexpectedEOF
639 }
640 b := dAtA[iNdEx]
641 iNdEx++
642 wire |= uint64(b&0x7F) << shift
643 if b < 0x80 {
644 break
645 }
646 }
647 fieldNum := int32(wire >> 3)
648 wireType := int(wire & 0x7)
649 if wireType == 4 {
650 return fmt.Errorf("proto: MemberlistMessage: wiretype end group for non-group")
651 }
652 if fieldNum <= 0 {
653 return fmt.Errorf("proto: MemberlistMessage: illegal tag %d (wire type %d)", fieldNum, wire)
654 }
655 switch fieldNum {
656 case 1:
657 if wireType != 2 {
658 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
659 }
660 var stringLen uint64
661 for shift := uint(0); ; shift += 7 {
662 if shift >= 64 {
663 return ErrIntOverflowCluster
664 }
665 if iNdEx >= l {
666 return io.ErrUnexpectedEOF
667 }
668 b := dAtA[iNdEx]
669 iNdEx++
670 stringLen |= uint64(b&0x7F) << shift
671 if b < 0x80 {
672 break
673 }
674 }
675 intStringLen := int(stringLen)
676 if intStringLen < 0 {
677 return ErrInvalidLengthCluster
678 }
679 postIndex := iNdEx + intStringLen
680 if postIndex < 0 {
681 return ErrInvalidLengthCluster
682 }
683 if postIndex > l {
684 return io.ErrUnexpectedEOF
685 }
686 m.Version = string(dAtA[iNdEx:postIndex])
687 iNdEx = postIndex
688 case 2:
689 if wireType != 0 {
690 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
691 }
692 m.Kind = 0
693 for shift := uint(0); ; shift += 7 {
694 if shift >= 64 {
695 return ErrIntOverflowCluster
696 }
697 if iNdEx >= l {
698 return io.ErrUnexpectedEOF
699 }
700 b := dAtA[iNdEx]
701 iNdEx++
702 m.Kind |= MemberlistMessage_Kind(b&0x7F) << shift
703 if b < 0x80 {
704 break
705 }
706 }
707 case 3:
708 if wireType != 2 {
709 return fmt.Errorf("proto: wrong wireType = %d for field FromAddr", wireType)
710 }
711 var stringLen uint64
712 for shift := uint(0); ; shift += 7 {
713 if shift >= 64 {
714 return ErrIntOverflowCluster
715 }
716 if iNdEx >= l {
717 return io.ErrUnexpectedEOF
718 }
719 b := dAtA[iNdEx]
720 iNdEx++
721 stringLen |= uint64(b&0x7F) << shift
722 if b < 0x80 {
723 break
724 }
725 }
726 intStringLen := int(stringLen)
727 if intStringLen < 0 {
728 return ErrInvalidLengthCluster
729 }
730 postIndex := iNdEx + intStringLen
731 if postIndex < 0 {
732 return ErrInvalidLengthCluster
733 }
734 if postIndex > l {
735 return io.ErrUnexpectedEOF
736 }
737 m.FromAddr = string(dAtA[iNdEx:postIndex])
738 iNdEx = postIndex
739 case 4:
740 if wireType != 2 {
741 return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
742 }
743 var byteLen int
744 for shift := uint(0); ; shift += 7 {
745 if shift >= 64 {
746 return ErrIntOverflowCluster
747 }
748 if iNdEx >= l {
749 return io.ErrUnexpectedEOF
750 }
751 b := dAtA[iNdEx]
752 iNdEx++
753 byteLen |= int(b&0x7F) << shift
754 if b < 0x80 {
755 break
756 }
757 }
758 if byteLen < 0 {
759 return ErrInvalidLengthCluster
760 }
761 postIndex := iNdEx + byteLen
762 if postIndex < 0 {
763 return ErrInvalidLengthCluster
764 }
765 if postIndex > l {
766 return io.ErrUnexpectedEOF
767 }
768 m.Msg = append(m.Msg[:0], dAtA[iNdEx:postIndex]...)
769 if m.Msg == nil {
770 m.Msg = []byte{}
771 }
772 iNdEx = postIndex
773 default:
774 iNdEx = preIndex
775 skippy, err := skipCluster(dAtA[iNdEx:])
776 if err != nil {
777 return err
778 }
779 if (skippy < 0) || (iNdEx+skippy) < 0 {
780 return ErrInvalidLengthCluster
781 }
782 if (iNdEx + skippy) > l {
783 return io.ErrUnexpectedEOF
784 }
785 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
786 iNdEx += skippy
787 }
788 }
789
790 if iNdEx > l {
791 return io.ErrUnexpectedEOF
792 }
793 return nil
794 }
795 func skipCluster(dAtA []byte) (n int, err error) {
796 l := len(dAtA)
797 iNdEx := 0
798 depth := 0
799 for iNdEx < l {
800 var wire uint64
801 for shift := uint(0); ; shift += 7 {
802 if shift >= 64 {
803 return 0, ErrIntOverflowCluster
804 }
805 if iNdEx >= l {
806 return 0, io.ErrUnexpectedEOF
807 }
808 b := dAtA[iNdEx]
809 iNdEx++
810 wire |= (uint64(b) & 0x7F) << shift
811 if b < 0x80 {
812 break
813 }
814 }
815 wireType := int(wire & 0x7)
816 switch wireType {
817 case 0:
818 for shift := uint(0); ; shift += 7 {
819 if shift >= 64 {
820 return 0, ErrIntOverflowCluster
821 }
822 if iNdEx >= l {
823 return 0, io.ErrUnexpectedEOF
824 }
825 iNdEx++
826 if dAtA[iNdEx-1] < 0x80 {
827 break
828 }
829 }
830 case 1:
831 iNdEx += 8
832 case 2:
833 var length int
834 for shift := uint(0); ; shift += 7 {
835 if shift >= 64 {
836 return 0, ErrIntOverflowCluster
837 }
838 if iNdEx >= l {
839 return 0, io.ErrUnexpectedEOF
840 }
841 b := dAtA[iNdEx]
842 iNdEx++
843 length |= (int(b) & 0x7F) << shift
844 if b < 0x80 {
845 break
846 }
847 }
848 if length < 0 {
849 return 0, ErrInvalidLengthCluster
850 }
851 iNdEx += length
852 case 3:
853 depth++
854 case 4:
855 if depth == 0 {
856 return 0, ErrUnexpectedEndOfGroupCluster
857 }
858 depth--
859 case 5:
860 iNdEx += 4
861 default:
862 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
863 }
864 if iNdEx < 0 {
865 return 0, ErrInvalidLengthCluster
866 }
867 if depth == 0 {
868 return iNdEx, nil
869 }
870 }
871 return 0, io.ErrUnexpectedEOF
872 }
873
874 var (
875 ErrInvalidLengthCluster = fmt.Errorf("proto: negative length found during unmarshaling")
876 ErrIntOverflowCluster = fmt.Errorf("proto: integer overflow")
877 ErrUnexpectedEndOfGroupCluster = fmt.Errorf("proto: unexpected end of group")
878 )
879
View as plain text