1// Code generated by protoc-gen-gogo.
2// source: overlay.proto
3// DO NOT EDIT!
4
5/*
6	Package overlay is a generated protocol buffer package.
7
8	It is generated from these files:
9		overlay.proto
10
11	It has these top-level messages:
12		PeerRecord
13*/
14package overlay
15
16import proto "github.com/gogo/protobuf/proto"
17import fmt "fmt"
18import math "math"
19import _ "github.com/gogo/protobuf/gogoproto"
20
21import strings "strings"
22import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
23import sort "sort"
24import strconv "strconv"
25import reflect "reflect"
26
27import io "io"
28
29// Reference imports to suppress errors if they are not otherwise used.
30var _ = proto.Marshal
31var _ = fmt.Errorf
32var _ = math.Inf
33
34// This is a compile-time assertion to ensure that this generated file
35// is compatible with the proto package it is being compiled against.
36const _ = proto.GoGoProtoPackageIsVersion1
37
38// PeerRecord defines the information corresponding to a peer
39// container in the overlay network.
40type PeerRecord struct {
41	// Endpoint IP is the IP of the container attachment on the
42	// given overlay network.
43	EndpointIP string `protobuf:"bytes,1,opt,name=endpoint_ip,json=endpointIp,proto3" json:"endpoint_ip,omitempty"`
44	// Endpoint MAC is the mac address of the container attachment
45	// on the given overlay network.
46	EndpointMAC string `protobuf:"bytes,2,opt,name=endpoint_mac,json=endpointMac,proto3" json:"endpoint_mac,omitempty"`
47	// Tunnel Endpoint IP defines the host IP for the host in
48	// which this container is running and can be reached by
49	// building a tunnel to that host IP.
50	TunnelEndpointIP string `protobuf:"bytes,3,opt,name=tunnel_endpoint_ip,json=tunnelEndpointIp,proto3" json:"tunnel_endpoint_ip,omitempty"`
51}
52
53func (m *PeerRecord) Reset()                    { *m = PeerRecord{} }
54func (*PeerRecord) ProtoMessage()               {}
55func (*PeerRecord) Descriptor() ([]byte, []int) { return fileDescriptorOverlay, []int{0} }
56
57func init() {
58	proto.RegisterType((*PeerRecord)(nil), "overlay.PeerRecord")
59}
60func (this *PeerRecord) GoString() string {
61	if this == nil {
62		return "nil"
63	}
64	s := make([]string, 0, 7)
65	s = append(s, "&overlay.PeerRecord{")
66	s = append(s, "EndpointIP: "+fmt.Sprintf("%#v", this.EndpointIP)+",\n")
67	s = append(s, "EndpointMAC: "+fmt.Sprintf("%#v", this.EndpointMAC)+",\n")
68	s = append(s, "TunnelEndpointIP: "+fmt.Sprintf("%#v", this.TunnelEndpointIP)+",\n")
69	s = append(s, "}")
70	return strings.Join(s, "")
71}
72func valueToGoStringOverlay(v interface{}, typ string) string {
73	rv := reflect.ValueOf(v)
74	if rv.IsNil() {
75		return "nil"
76	}
77	pv := reflect.Indirect(rv).Interface()
78	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
79}
80func extensionToGoStringOverlay(e map[int32]github_com_gogo_protobuf_proto.Extension) string {
81	if e == nil {
82		return "nil"
83	}
84	s := "map[int32]proto.Extension{"
85	keys := make([]int, 0, len(e))
86	for k := range e {
87		keys = append(keys, int(k))
88	}
89	sort.Ints(keys)
90	ss := []string{}
91	for _, k := range keys {
92		ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString())
93	}
94	s += strings.Join(ss, ",") + "}"
95	return s
96}
97func (m *PeerRecord) Marshal() (data []byte, err error) {
98	size := m.Size()
99	data = make([]byte, size)
100	n, err := m.MarshalTo(data)
101	if err != nil {
102		return nil, err
103	}
104	return data[:n], nil
105}
106
107func (m *PeerRecord) MarshalTo(data []byte) (int, error) {
108	var i int
109	_ = i
110	var l int
111	_ = l
112	if len(m.EndpointIP) > 0 {
113		data[i] = 0xa
114		i++
115		i = encodeVarintOverlay(data, i, uint64(len(m.EndpointIP)))
116		i += copy(data[i:], m.EndpointIP)
117	}
118	if len(m.EndpointMAC) > 0 {
119		data[i] = 0x12
120		i++
121		i = encodeVarintOverlay(data, i, uint64(len(m.EndpointMAC)))
122		i += copy(data[i:], m.EndpointMAC)
123	}
124	if len(m.TunnelEndpointIP) > 0 {
125		data[i] = 0x1a
126		i++
127		i = encodeVarintOverlay(data, i, uint64(len(m.TunnelEndpointIP)))
128		i += copy(data[i:], m.TunnelEndpointIP)
129	}
130	return i, nil
131}
132
133func encodeFixed64Overlay(data []byte, offset int, v uint64) int {
134	data[offset] = uint8(v)
135	data[offset+1] = uint8(v >> 8)
136	data[offset+2] = uint8(v >> 16)
137	data[offset+3] = uint8(v >> 24)
138	data[offset+4] = uint8(v >> 32)
139	data[offset+5] = uint8(v >> 40)
140	data[offset+6] = uint8(v >> 48)
141	data[offset+7] = uint8(v >> 56)
142	return offset + 8
143}
144func encodeFixed32Overlay(data []byte, offset int, v uint32) int {
145	data[offset] = uint8(v)
146	data[offset+1] = uint8(v >> 8)
147	data[offset+2] = uint8(v >> 16)
148	data[offset+3] = uint8(v >> 24)
149	return offset + 4
150}
151func encodeVarintOverlay(data []byte, offset int, v uint64) int {
152	for v >= 1<<7 {
153		data[offset] = uint8(v&0x7f | 0x80)
154		v >>= 7
155		offset++
156	}
157	data[offset] = uint8(v)
158	return offset + 1
159}
160func (m *PeerRecord) Size() (n int) {
161	var l int
162	_ = l
163	l = len(m.EndpointIP)
164	if l > 0 {
165		n += 1 + l + sovOverlay(uint64(l))
166	}
167	l = len(m.EndpointMAC)
168	if l > 0 {
169		n += 1 + l + sovOverlay(uint64(l))
170	}
171	l = len(m.TunnelEndpointIP)
172	if l > 0 {
173		n += 1 + l + sovOverlay(uint64(l))
174	}
175	return n
176}
177
178func sovOverlay(x uint64) (n int) {
179	for {
180		n++
181		x >>= 7
182		if x == 0 {
183			break
184		}
185	}
186	return n
187}
188func sozOverlay(x uint64) (n int) {
189	return sovOverlay(uint64((x << 1) ^ uint64((int64(x) >> 63))))
190}
191func (this *PeerRecord) String() string {
192	if this == nil {
193		return "nil"
194	}
195	s := strings.Join([]string{`&PeerRecord{`,
196		`EndpointIP:` + fmt.Sprintf("%v", this.EndpointIP) + `,`,
197		`EndpointMAC:` + fmt.Sprintf("%v", this.EndpointMAC) + `,`,
198		`TunnelEndpointIP:` + fmt.Sprintf("%v", this.TunnelEndpointIP) + `,`,
199		`}`,
200	}, "")
201	return s
202}
203func valueToStringOverlay(v interface{}) string {
204	rv := reflect.ValueOf(v)
205	if rv.IsNil() {
206		return "nil"
207	}
208	pv := reflect.Indirect(rv).Interface()
209	return fmt.Sprintf("*%v", pv)
210}
211func (m *PeerRecord) Unmarshal(data []byte) error {
212	l := len(data)
213	iNdEx := 0
214	for iNdEx < l {
215		preIndex := iNdEx
216		var wire uint64
217		for shift := uint(0); ; shift += 7 {
218			if shift >= 64 {
219				return ErrIntOverflowOverlay
220			}
221			if iNdEx >= l {
222				return io.ErrUnexpectedEOF
223			}
224			b := data[iNdEx]
225			iNdEx++
226			wire |= (uint64(b) & 0x7F) << shift
227			if b < 0x80 {
228				break
229			}
230		}
231		fieldNum := int32(wire >> 3)
232		wireType := int(wire & 0x7)
233		if wireType == 4 {
234			return fmt.Errorf("proto: PeerRecord: wiretype end group for non-group")
235		}
236		if fieldNum <= 0 {
237			return fmt.Errorf("proto: PeerRecord: illegal tag %d (wire type %d)", fieldNum, wire)
238		}
239		switch fieldNum {
240		case 1:
241			if wireType != 2 {
242				return fmt.Errorf("proto: wrong wireType = %d for field EndpointIP", wireType)
243			}
244			var stringLen uint64
245			for shift := uint(0); ; shift += 7 {
246				if shift >= 64 {
247					return ErrIntOverflowOverlay
248				}
249				if iNdEx >= l {
250					return io.ErrUnexpectedEOF
251				}
252				b := data[iNdEx]
253				iNdEx++
254				stringLen |= (uint64(b) & 0x7F) << shift
255				if b < 0x80 {
256					break
257				}
258			}
259			intStringLen := int(stringLen)
260			if intStringLen < 0 {
261				return ErrInvalidLengthOverlay
262			}
263			postIndex := iNdEx + intStringLen
264			if postIndex > l {
265				return io.ErrUnexpectedEOF
266			}
267			m.EndpointIP = string(data[iNdEx:postIndex])
268			iNdEx = postIndex
269		case 2:
270			if wireType != 2 {
271				return fmt.Errorf("proto: wrong wireType = %d for field EndpointMAC", wireType)
272			}
273			var stringLen uint64
274			for shift := uint(0); ; shift += 7 {
275				if shift >= 64 {
276					return ErrIntOverflowOverlay
277				}
278				if iNdEx >= l {
279					return io.ErrUnexpectedEOF
280				}
281				b := data[iNdEx]
282				iNdEx++
283				stringLen |= (uint64(b) & 0x7F) << shift
284				if b < 0x80 {
285					break
286				}
287			}
288			intStringLen := int(stringLen)
289			if intStringLen < 0 {
290				return ErrInvalidLengthOverlay
291			}
292			postIndex := iNdEx + intStringLen
293			if postIndex > l {
294				return io.ErrUnexpectedEOF
295			}
296			m.EndpointMAC = string(data[iNdEx:postIndex])
297			iNdEx = postIndex
298		case 3:
299			if wireType != 2 {
300				return fmt.Errorf("proto: wrong wireType = %d for field TunnelEndpointIP", wireType)
301			}
302			var stringLen uint64
303			for shift := uint(0); ; shift += 7 {
304				if shift >= 64 {
305					return ErrIntOverflowOverlay
306				}
307				if iNdEx >= l {
308					return io.ErrUnexpectedEOF
309				}
310				b := data[iNdEx]
311				iNdEx++
312				stringLen |= (uint64(b) & 0x7F) << shift
313				if b < 0x80 {
314					break
315				}
316			}
317			intStringLen := int(stringLen)
318			if intStringLen < 0 {
319				return ErrInvalidLengthOverlay
320			}
321			postIndex := iNdEx + intStringLen
322			if postIndex > l {
323				return io.ErrUnexpectedEOF
324			}
325			m.TunnelEndpointIP = string(data[iNdEx:postIndex])
326			iNdEx = postIndex
327		default:
328			iNdEx = preIndex
329			skippy, err := skipOverlay(data[iNdEx:])
330			if err != nil {
331				return err
332			}
333			if skippy < 0 {
334				return ErrInvalidLengthOverlay
335			}
336			if (iNdEx + skippy) > l {
337				return io.ErrUnexpectedEOF
338			}
339			iNdEx += skippy
340		}
341	}
342
343	if iNdEx > l {
344		return io.ErrUnexpectedEOF
345	}
346	return nil
347}
348func skipOverlay(data []byte) (n int, err error) {
349	l := len(data)
350	iNdEx := 0
351	for iNdEx < l {
352		var wire uint64
353		for shift := uint(0); ; shift += 7 {
354			if shift >= 64 {
355				return 0, ErrIntOverflowOverlay
356			}
357			if iNdEx >= l {
358				return 0, io.ErrUnexpectedEOF
359			}
360			b := data[iNdEx]
361			iNdEx++
362			wire |= (uint64(b) & 0x7F) << shift
363			if b < 0x80 {
364				break
365			}
366		}
367		wireType := int(wire & 0x7)
368		switch wireType {
369		case 0:
370			for shift := uint(0); ; shift += 7 {
371				if shift >= 64 {
372					return 0, ErrIntOverflowOverlay
373				}
374				if iNdEx >= l {
375					return 0, io.ErrUnexpectedEOF
376				}
377				iNdEx++
378				if data[iNdEx-1] < 0x80 {
379					break
380				}
381			}
382			return iNdEx, nil
383		case 1:
384			iNdEx += 8
385			return iNdEx, nil
386		case 2:
387			var length int
388			for shift := uint(0); ; shift += 7 {
389				if shift >= 64 {
390					return 0, ErrIntOverflowOverlay
391				}
392				if iNdEx >= l {
393					return 0, io.ErrUnexpectedEOF
394				}
395				b := data[iNdEx]
396				iNdEx++
397				length |= (int(b) & 0x7F) << shift
398				if b < 0x80 {
399					break
400				}
401			}
402			iNdEx += length
403			if length < 0 {
404				return 0, ErrInvalidLengthOverlay
405			}
406			return iNdEx, nil
407		case 3:
408			for {
409				var innerWire uint64
410				var start int = iNdEx
411				for shift := uint(0); ; shift += 7 {
412					if shift >= 64 {
413						return 0, ErrIntOverflowOverlay
414					}
415					if iNdEx >= l {
416						return 0, io.ErrUnexpectedEOF
417					}
418					b := data[iNdEx]
419					iNdEx++
420					innerWire |= (uint64(b) & 0x7F) << shift
421					if b < 0x80 {
422						break
423					}
424				}
425				innerWireType := int(innerWire & 0x7)
426				if innerWireType == 4 {
427					break
428				}
429				next, err := skipOverlay(data[start:])
430				if err != nil {
431					return 0, err
432				}
433				iNdEx = start + next
434			}
435			return iNdEx, nil
436		case 4:
437			return iNdEx, nil
438		case 5:
439			iNdEx += 4
440			return iNdEx, nil
441		default:
442			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
443		}
444	}
445	panic("unreachable")
446}
447
448var (
449	ErrInvalidLengthOverlay = fmt.Errorf("proto: negative length found during unmarshaling")
450	ErrIntOverflowOverlay   = fmt.Errorf("proto: integer overflow")
451)
452
453var fileDescriptorOverlay = []byte{
454	// 195 bytes of a gzipped FileDescriptorProto
455	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0xcd, 0x2f, 0x4b, 0x2d,
456	0xca, 0x49, 0xac, 0xd4, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x87, 0x72, 0xa5, 0x44, 0xd2,
457	0xf3, 0xd3, 0xf3, 0xc1, 0x62, 0xfa, 0x20, 0x16, 0x44, 0x5a, 0x69, 0x2b, 0x23, 0x17, 0x57, 0x40,
458	0x6a, 0x6a, 0x51, 0x50, 0x6a, 0x72, 0x7e, 0x51, 0x8a, 0x90, 0x3e, 0x17, 0x77, 0x6a, 0x5e, 0x4a,
459	0x41, 0x7e, 0x66, 0x5e, 0x49, 0x7c, 0x66, 0x81, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0xa7, 0x13, 0xdf,
460	0xa3, 0x7b, 0xf2, 0x5c, 0xae, 0x50, 0x61, 0xcf, 0x80, 0x20, 0x2e, 0x98, 0x12, 0xcf, 0x02, 0x21,
461	0x23, 0x2e, 0x1e, 0xb8, 0x86, 0xdc, 0xc4, 0x64, 0x09, 0x26, 0xb0, 0x0e, 0x7e, 0xa0, 0x0e, 0x6e,
462	0x98, 0x0e, 0x5f, 0x47, 0xe7, 0x20, 0xb8, 0xa9, 0xbe, 0x89, 0xc9, 0x42, 0x4e, 0x5c, 0x42, 0x25,
463	0xa5, 0x79, 0x79, 0xa9, 0x39, 0xf1, 0xc8, 0x76, 0x31, 0x83, 0x75, 0x8a, 0x00, 0x75, 0x0a, 0x84,
464	0x80, 0x65, 0x91, 0x6c, 0x14, 0x28, 0x41, 0x15, 0x29, 0x70, 0x92, 0xb8, 0xf1, 0x50, 0x8e, 0xe1,
465	0xc3, 0x43, 0x39, 0xc6, 0x86, 0x47, 0x72, 0x8c, 0x27, 0x80, 0xf8, 0x02, 0x10, 0x3f, 0x00, 0xe2,
466	0x24, 0x36, 0xb0, 0xc7, 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xbf, 0xd7, 0x7d, 0x7d, 0x08,
467	0x01, 0x00, 0x00,
468}
469