1
2
3
4 package v0
5
6 import (
7 context "context"
8 fmt "fmt"
9 proto "github.com/gogo/protobuf/proto"
10 grpc "google.golang.org/grpc"
11 codes "google.golang.org/grpc/codes"
12 status "google.golang.org/grpc/status"
13 io "io"
14 math "math"
15 math_bits "math/bits"
16 reflect "reflect"
17 strings "strings"
18 )
19
20
21 var _ = proto.Marshal
22 var _ = fmt.Errorf
23 var _ = math.Inf
24
25
26
27
28
29 const _ = proto.GoGoProtoPackageIsVersion3
30
31 type CreateNetworkRequest_NetworkMode int32
32 const (
33 CreateNetworkRequest_Transparent CreateNetworkRequest_NetworkMode = 0
34 CreateNetworkRequest_NAT CreateNetworkRequest_NetworkMode = 1
35 )
36
37 var CreateNetworkRequest_NetworkMode_name = map[int32]string{
38 0: "Transparent",
39 1: "NAT",
40 }
41
42 var CreateNetworkRequest_NetworkMode_value = map[string]int32{
43 "Transparent": 0,
44 "NAT": 1,
45 }
46
47 func (x CreateNetworkRequest_NetworkMode) String() string {
48 return proto.EnumName(CreateNetworkRequest_NetworkMode_name, int32(x))
49 }
50
51 func (CreateNetworkRequest_NetworkMode) EnumDescriptor() ([]byte, []int) {
52 return fileDescriptor_2f3a1f7794389dcf, []int{6, 0}
53 }
54
55 type CreateNetworkRequest_IpamType int32
56 const (
57 CreateNetworkRequest_Static CreateNetworkRequest_IpamType = 0
58 CreateNetworkRequest_DHCP CreateNetworkRequest_IpamType = 1
59 )
60
61 var CreateNetworkRequest_IpamType_name = map[int32]string{
62 0: "Static",
63 1: "DHCP",
64 }
65
66 var CreateNetworkRequest_IpamType_value = map[string]int32{
67 "Static": 0,
68 "DHCP": 1,
69 }
70
71 func (x CreateNetworkRequest_IpamType) String() string {
72 return proto.EnumName(CreateNetworkRequest_IpamType_name, int32(x))
73 }
74
75 func (CreateNetworkRequest_IpamType) EnumDescriptor() ([]byte, []int) {
76 return fileDescriptor_2f3a1f7794389dcf, []int{6, 1}
77 }
78
79
80 type AddNICRequest struct {
81 ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
82 NicID string `protobuf:"bytes,2,opt,name=nic_id,json=nicId,proto3" json:"nic_id,omitempty"`
83 EndpointName string `protobuf:"bytes,3,opt,name=endpoint_name,json=endpointName,proto3" json:"endpoint_name,omitempty"`
84 XXX_NoUnkeyedLiteral struct{} `json:"-"`
85 XXX_unrecognized []byte `json:"-"`
86 XXX_sizecache int32 `json:"-"`
87 }
88
89 func (m *AddNICRequest) Reset() { *m = AddNICRequest{} }
90 func (*AddNICRequest) ProtoMessage() {}
91 func (*AddNICRequest) Descriptor() ([]byte, []int) {
92 return fileDescriptor_2f3a1f7794389dcf, []int{0}
93 }
94 func (m *AddNICRequest) XXX_Unmarshal(b []byte) error {
95 return m.Unmarshal(b)
96 }
97 func (m *AddNICRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
98 if deterministic {
99 return xxx_messageInfo_AddNICRequest.Marshal(b, m, deterministic)
100 } else {
101 b = b[:cap(b)]
102 n, err := m.MarshalToSizedBuffer(b)
103 if err != nil {
104 return nil, err
105 }
106 return b[:n], nil
107 }
108 }
109 func (m *AddNICRequest) XXX_Merge(src proto.Message) {
110 xxx_messageInfo_AddNICRequest.Merge(m, src)
111 }
112 func (m *AddNICRequest) XXX_Size() int {
113 return m.Size()
114 }
115 func (m *AddNICRequest) XXX_DiscardUnknown() {
116 xxx_messageInfo_AddNICRequest.DiscardUnknown(m)
117 }
118
119 var xxx_messageInfo_AddNICRequest proto.InternalMessageInfo
120
121
122 type AddNICResponse struct {
123 XXX_NoUnkeyedLiteral struct{} `json:"-"`
124 XXX_unrecognized []byte `json:"-"`
125 XXX_sizecache int32 `json:"-"`
126 }
127
128 func (m *AddNICResponse) Reset() { *m = AddNICResponse{} }
129 func (*AddNICResponse) ProtoMessage() {}
130 func (*AddNICResponse) Descriptor() ([]byte, []int) {
131 return fileDescriptor_2f3a1f7794389dcf, []int{1}
132 }
133 func (m *AddNICResponse) XXX_Unmarshal(b []byte) error {
134 return m.Unmarshal(b)
135 }
136 func (m *AddNICResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
137 if deterministic {
138 return xxx_messageInfo_AddNICResponse.Marshal(b, m, deterministic)
139 } else {
140 b = b[:cap(b)]
141 n, err := m.MarshalToSizedBuffer(b)
142 if err != nil {
143 return nil, err
144 }
145 return b[:n], nil
146 }
147 }
148 func (m *AddNICResponse) XXX_Merge(src proto.Message) {
149 xxx_messageInfo_AddNICResponse.Merge(m, src)
150 }
151 func (m *AddNICResponse) XXX_Size() int {
152 return m.Size()
153 }
154 func (m *AddNICResponse) XXX_DiscardUnknown() {
155 xxx_messageInfo_AddNICResponse.DiscardUnknown(m)
156 }
157
158 var xxx_messageInfo_AddNICResponse proto.InternalMessageInfo
159
160
161 type ModifyNICRequest struct {
162 ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
163 NicID string `protobuf:"bytes,2,opt,name=nic_id,json=nicId,proto3" json:"nic_id,omitempty"`
164 EndpointName string `protobuf:"bytes,3,opt,name=endpoint_name,json=endpointName,proto3" json:"endpoint_name,omitempty"`
165 IovPolicySettings *IovEndpointPolicySetting `protobuf:"bytes,4,opt,name=iov_policy_settings,json=iovPolicySettings,proto3" json:"iov_policy_settings,omitempty"`
166 XXX_NoUnkeyedLiteral struct{} `json:"-"`
167 XXX_unrecognized []byte `json:"-"`
168 XXX_sizecache int32 `json:"-"`
169 }
170
171 func (m *ModifyNICRequest) Reset() { *m = ModifyNICRequest{} }
172 func (*ModifyNICRequest) ProtoMessage() {}
173 func (*ModifyNICRequest) Descriptor() ([]byte, []int) {
174 return fileDescriptor_2f3a1f7794389dcf, []int{2}
175 }
176 func (m *ModifyNICRequest) XXX_Unmarshal(b []byte) error {
177 return m.Unmarshal(b)
178 }
179 func (m *ModifyNICRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
180 if deterministic {
181 return xxx_messageInfo_ModifyNICRequest.Marshal(b, m, deterministic)
182 } else {
183 b = b[:cap(b)]
184 n, err := m.MarshalToSizedBuffer(b)
185 if err != nil {
186 return nil, err
187 }
188 return b[:n], nil
189 }
190 }
191 func (m *ModifyNICRequest) XXX_Merge(src proto.Message) {
192 xxx_messageInfo_ModifyNICRequest.Merge(m, src)
193 }
194 func (m *ModifyNICRequest) XXX_Size() int {
195 return m.Size()
196 }
197 func (m *ModifyNICRequest) XXX_DiscardUnknown() {
198 xxx_messageInfo_ModifyNICRequest.DiscardUnknown(m)
199 }
200
201 var xxx_messageInfo_ModifyNICRequest proto.InternalMessageInfo
202
203
204 type ModifyNICResponse struct {
205 XXX_NoUnkeyedLiteral struct{} `json:"-"`
206 XXX_unrecognized []byte `json:"-"`
207 XXX_sizecache int32 `json:"-"`
208 }
209
210 func (m *ModifyNICResponse) Reset() { *m = ModifyNICResponse{} }
211 func (*ModifyNICResponse) ProtoMessage() {}
212 func (*ModifyNICResponse) Descriptor() ([]byte, []int) {
213 return fileDescriptor_2f3a1f7794389dcf, []int{3}
214 }
215 func (m *ModifyNICResponse) XXX_Unmarshal(b []byte) error {
216 return m.Unmarshal(b)
217 }
218 func (m *ModifyNICResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
219 if deterministic {
220 return xxx_messageInfo_ModifyNICResponse.Marshal(b, m, deterministic)
221 } else {
222 b = b[:cap(b)]
223 n, err := m.MarshalToSizedBuffer(b)
224 if err != nil {
225 return nil, err
226 }
227 return b[:n], nil
228 }
229 }
230 func (m *ModifyNICResponse) XXX_Merge(src proto.Message) {
231 xxx_messageInfo_ModifyNICResponse.Merge(m, src)
232 }
233 func (m *ModifyNICResponse) XXX_Size() int {
234 return m.Size()
235 }
236 func (m *ModifyNICResponse) XXX_DiscardUnknown() {
237 xxx_messageInfo_ModifyNICResponse.DiscardUnknown(m)
238 }
239
240 var xxx_messageInfo_ModifyNICResponse proto.InternalMessageInfo
241
242
243 type DeleteNICRequest struct {
244 ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
245 NicID string `protobuf:"bytes,2,opt,name=nic_id,json=nicId,proto3" json:"nic_id,omitempty"`
246 EndpointName string `protobuf:"bytes,3,opt,name=endpoint_name,json=endpointName,proto3" json:"endpoint_name,omitempty"`
247 XXX_NoUnkeyedLiteral struct{} `json:"-"`
248 XXX_unrecognized []byte `json:"-"`
249 XXX_sizecache int32 `json:"-"`
250 }
251
252 func (m *DeleteNICRequest) Reset() { *m = DeleteNICRequest{} }
253 func (*DeleteNICRequest) ProtoMessage() {}
254 func (*DeleteNICRequest) Descriptor() ([]byte, []int) {
255 return fileDescriptor_2f3a1f7794389dcf, []int{4}
256 }
257 func (m *DeleteNICRequest) XXX_Unmarshal(b []byte) error {
258 return m.Unmarshal(b)
259 }
260 func (m *DeleteNICRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
261 if deterministic {
262 return xxx_messageInfo_DeleteNICRequest.Marshal(b, m, deterministic)
263 } else {
264 b = b[:cap(b)]
265 n, err := m.MarshalToSizedBuffer(b)
266 if err != nil {
267 return nil, err
268 }
269 return b[:n], nil
270 }
271 }
272 func (m *DeleteNICRequest) XXX_Merge(src proto.Message) {
273 xxx_messageInfo_DeleteNICRequest.Merge(m, src)
274 }
275 func (m *DeleteNICRequest) XXX_Size() int {
276 return m.Size()
277 }
278 func (m *DeleteNICRequest) XXX_DiscardUnknown() {
279 xxx_messageInfo_DeleteNICRequest.DiscardUnknown(m)
280 }
281
282 var xxx_messageInfo_DeleteNICRequest proto.InternalMessageInfo
283
284
285 type DeleteNICResponse struct {
286 XXX_NoUnkeyedLiteral struct{} `json:"-"`
287 XXX_unrecognized []byte `json:"-"`
288 XXX_sizecache int32 `json:"-"`
289 }
290
291 func (m *DeleteNICResponse) Reset() { *m = DeleteNICResponse{} }
292 func (*DeleteNICResponse) ProtoMessage() {}
293 func (*DeleteNICResponse) Descriptor() ([]byte, []int) {
294 return fileDescriptor_2f3a1f7794389dcf, []int{5}
295 }
296 func (m *DeleteNICResponse) XXX_Unmarshal(b []byte) error {
297 return m.Unmarshal(b)
298 }
299 func (m *DeleteNICResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
300 if deterministic {
301 return xxx_messageInfo_DeleteNICResponse.Marshal(b, m, deterministic)
302 } else {
303 b = b[:cap(b)]
304 n, err := m.MarshalToSizedBuffer(b)
305 if err != nil {
306 return nil, err
307 }
308 return b[:n], nil
309 }
310 }
311 func (m *DeleteNICResponse) XXX_Merge(src proto.Message) {
312 xxx_messageInfo_DeleteNICResponse.Merge(m, src)
313 }
314 func (m *DeleteNICResponse) XXX_Size() int {
315 return m.Size()
316 }
317 func (m *DeleteNICResponse) XXX_DiscardUnknown() {
318 xxx_messageInfo_DeleteNICResponse.DiscardUnknown(m)
319 }
320
321 var xxx_messageInfo_DeleteNICResponse proto.InternalMessageInfo
322
323
324 type CreateNetworkRequest struct {
325 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
326 Mode CreateNetworkRequest_NetworkMode `protobuf:"varint,2,opt,name=mode,proto3,enum=ncproxygrpc.CreateNetworkRequest_NetworkMode" json:"mode,omitempty"`
327 SwitchName string `protobuf:"bytes,3,opt,name=switch_name,json=switchName,proto3" json:"switch_name,omitempty"`
328 IpamType CreateNetworkRequest_IpamType `protobuf:"varint,4,opt,name=ipam_type,json=ipamType,proto3,enum=ncproxygrpc.CreateNetworkRequest_IpamType" json:"ipam_type,omitempty"`
329 SubnetIpaddressPrefix []string `protobuf:"bytes,5,rep,name=subnet_ipaddress_prefix,json=subnetIpaddressPrefix,proto3" json:"subnet_ipaddress_prefix,omitempty"`
330 DefaultGateway string `protobuf:"bytes,6,opt,name=default_gateway,json=defaultGateway,proto3" json:"default_gateway,omitempty"`
331 XXX_NoUnkeyedLiteral struct{} `json:"-"`
332 XXX_unrecognized []byte `json:"-"`
333 XXX_sizecache int32 `json:"-"`
334 }
335
336 func (m *CreateNetworkRequest) Reset() { *m = CreateNetworkRequest{} }
337 func (*CreateNetworkRequest) ProtoMessage() {}
338 func (*CreateNetworkRequest) Descriptor() ([]byte, []int) {
339 return fileDescriptor_2f3a1f7794389dcf, []int{6}
340 }
341 func (m *CreateNetworkRequest) XXX_Unmarshal(b []byte) error {
342 return m.Unmarshal(b)
343 }
344 func (m *CreateNetworkRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
345 if deterministic {
346 return xxx_messageInfo_CreateNetworkRequest.Marshal(b, m, deterministic)
347 } else {
348 b = b[:cap(b)]
349 n, err := m.MarshalToSizedBuffer(b)
350 if err != nil {
351 return nil, err
352 }
353 return b[:n], nil
354 }
355 }
356 func (m *CreateNetworkRequest) XXX_Merge(src proto.Message) {
357 xxx_messageInfo_CreateNetworkRequest.Merge(m, src)
358 }
359 func (m *CreateNetworkRequest) XXX_Size() int {
360 return m.Size()
361 }
362 func (m *CreateNetworkRequest) XXX_DiscardUnknown() {
363 xxx_messageInfo_CreateNetworkRequest.DiscardUnknown(m)
364 }
365
366 var xxx_messageInfo_CreateNetworkRequest proto.InternalMessageInfo
367
368
369 type CreateNetworkResponse struct {
370 ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
371 XXX_NoUnkeyedLiteral struct{} `json:"-"`
372 XXX_unrecognized []byte `json:"-"`
373 XXX_sizecache int32 `json:"-"`
374 }
375
376 func (m *CreateNetworkResponse) Reset() { *m = CreateNetworkResponse{} }
377 func (*CreateNetworkResponse) ProtoMessage() {}
378 func (*CreateNetworkResponse) Descriptor() ([]byte, []int) {
379 return fileDescriptor_2f3a1f7794389dcf, []int{7}
380 }
381 func (m *CreateNetworkResponse) XXX_Unmarshal(b []byte) error {
382 return m.Unmarshal(b)
383 }
384 func (m *CreateNetworkResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
385 if deterministic {
386 return xxx_messageInfo_CreateNetworkResponse.Marshal(b, m, deterministic)
387 } else {
388 b = b[:cap(b)]
389 n, err := m.MarshalToSizedBuffer(b)
390 if err != nil {
391 return nil, err
392 }
393 return b[:n], nil
394 }
395 }
396 func (m *CreateNetworkResponse) XXX_Merge(src proto.Message) {
397 xxx_messageInfo_CreateNetworkResponse.Merge(m, src)
398 }
399 func (m *CreateNetworkResponse) XXX_Size() int {
400 return m.Size()
401 }
402 func (m *CreateNetworkResponse) XXX_DiscardUnknown() {
403 xxx_messageInfo_CreateNetworkResponse.DiscardUnknown(m)
404 }
405
406 var xxx_messageInfo_CreateNetworkResponse proto.InternalMessageInfo
407
408
409 type PortNameEndpointPolicySetting struct {
410 PortName string `protobuf:"bytes,1,opt,name=port_name,json=portName,proto3" json:"port_name,omitempty"`
411 XXX_NoUnkeyedLiteral struct{} `json:"-"`
412 XXX_unrecognized []byte `json:"-"`
413 XXX_sizecache int32 `json:"-"`
414 }
415
416 func (m *PortNameEndpointPolicySetting) Reset() { *m = PortNameEndpointPolicySetting{} }
417 func (*PortNameEndpointPolicySetting) ProtoMessage() {}
418 func (*PortNameEndpointPolicySetting) Descriptor() ([]byte, []int) {
419 return fileDescriptor_2f3a1f7794389dcf, []int{8}
420 }
421 func (m *PortNameEndpointPolicySetting) XXX_Unmarshal(b []byte) error {
422 return m.Unmarshal(b)
423 }
424 func (m *PortNameEndpointPolicySetting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
425 if deterministic {
426 return xxx_messageInfo_PortNameEndpointPolicySetting.Marshal(b, m, deterministic)
427 } else {
428 b = b[:cap(b)]
429 n, err := m.MarshalToSizedBuffer(b)
430 if err != nil {
431 return nil, err
432 }
433 return b[:n], nil
434 }
435 }
436 func (m *PortNameEndpointPolicySetting) XXX_Merge(src proto.Message) {
437 xxx_messageInfo_PortNameEndpointPolicySetting.Merge(m, src)
438 }
439 func (m *PortNameEndpointPolicySetting) XXX_Size() int {
440 return m.Size()
441 }
442 func (m *PortNameEndpointPolicySetting) XXX_DiscardUnknown() {
443 xxx_messageInfo_PortNameEndpointPolicySetting.DiscardUnknown(m)
444 }
445
446 var xxx_messageInfo_PortNameEndpointPolicySetting proto.InternalMessageInfo
447
448
449 type IovEndpointPolicySetting struct {
450 IovOffloadWeight uint32 `protobuf:"varint,1,opt,name=iov_offload_weight,json=iovOffloadWeight,proto3" json:"iov_offload_weight,omitempty"`
451 QueuePairsRequested uint32 `protobuf:"varint,2,opt,name=queue_pairs_requested,json=queuePairsRequested,proto3" json:"queue_pairs_requested,omitempty"`
452 InterruptModeration uint32 `protobuf:"varint,3,opt,name=interrupt_moderation,json=interruptModeration,proto3" json:"interrupt_moderation,omitempty"`
453 XXX_NoUnkeyedLiteral struct{} `json:"-"`
454 XXX_unrecognized []byte `json:"-"`
455 XXX_sizecache int32 `json:"-"`
456 }
457
458 func (m *IovEndpointPolicySetting) Reset() { *m = IovEndpointPolicySetting{} }
459 func (*IovEndpointPolicySetting) ProtoMessage() {}
460 func (*IovEndpointPolicySetting) Descriptor() ([]byte, []int) {
461 return fileDescriptor_2f3a1f7794389dcf, []int{9}
462 }
463 func (m *IovEndpointPolicySetting) XXX_Unmarshal(b []byte) error {
464 return m.Unmarshal(b)
465 }
466 func (m *IovEndpointPolicySetting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
467 if deterministic {
468 return xxx_messageInfo_IovEndpointPolicySetting.Marshal(b, m, deterministic)
469 } else {
470 b = b[:cap(b)]
471 n, err := m.MarshalToSizedBuffer(b)
472 if err != nil {
473 return nil, err
474 }
475 return b[:n], nil
476 }
477 }
478 func (m *IovEndpointPolicySetting) XXX_Merge(src proto.Message) {
479 xxx_messageInfo_IovEndpointPolicySetting.Merge(m, src)
480 }
481 func (m *IovEndpointPolicySetting) XXX_Size() int {
482 return m.Size()
483 }
484 func (m *IovEndpointPolicySetting) XXX_DiscardUnknown() {
485 xxx_messageInfo_IovEndpointPolicySetting.DiscardUnknown(m)
486 }
487
488 var xxx_messageInfo_IovEndpointPolicySetting proto.InternalMessageInfo
489
490
491 type DnsSetting struct {
492 ServerIpAddrs []string `protobuf:"bytes,1,rep,name=server_ip_addrs,json=serverIpAddrs,proto3" json:"server_ip_addrs,omitempty"`
493 Domain string `protobuf:"bytes,2,opt,name=domain,proto3" json:"domain,omitempty"`
494 Search []string `protobuf:"bytes,3,rep,name=search,proto3" json:"search,omitempty"`
495 XXX_NoUnkeyedLiteral struct{} `json:"-"`
496 XXX_unrecognized []byte `json:"-"`
497 XXX_sizecache int32 `json:"-"`
498 }
499
500 func (m *DnsSetting) Reset() { *m = DnsSetting{} }
501 func (*DnsSetting) ProtoMessage() {}
502 func (*DnsSetting) Descriptor() ([]byte, []int) {
503 return fileDescriptor_2f3a1f7794389dcf, []int{10}
504 }
505 func (m *DnsSetting) XXX_Unmarshal(b []byte) error {
506 return m.Unmarshal(b)
507 }
508 func (m *DnsSetting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
509 if deterministic {
510 return xxx_messageInfo_DnsSetting.Marshal(b, m, deterministic)
511 } else {
512 b = b[:cap(b)]
513 n, err := m.MarshalToSizedBuffer(b)
514 if err != nil {
515 return nil, err
516 }
517 return b[:n], nil
518 }
519 }
520 func (m *DnsSetting) XXX_Merge(src proto.Message) {
521 xxx_messageInfo_DnsSetting.Merge(m, src)
522 }
523 func (m *DnsSetting) XXX_Size() int {
524 return m.Size()
525 }
526 func (m *DnsSetting) XXX_DiscardUnknown() {
527 xxx_messageInfo_DnsSetting.DiscardUnknown(m)
528 }
529
530 var xxx_messageInfo_DnsSetting proto.InternalMessageInfo
531
532
533 type CreateEndpointRequest struct {
534 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
535 Macaddress string `protobuf:"bytes,2,opt,name=macaddress,proto3" json:"macaddress,omitempty"`
536 Ipaddress string `protobuf:"bytes,3,opt,name=ipaddress,proto3" json:"ipaddress,omitempty"`
537 IpaddressPrefixlength string `protobuf:"bytes,4,opt,name=ipaddress_prefixlength,json=ipaddressPrefixlength,proto3" json:"ipaddress_prefixlength,omitempty"`
538 NetworkName string `protobuf:"bytes,5,opt,name=network_name,json=networkName,proto3" json:"network_name,omitempty"`
539 PortnamePolicySetting *PortNameEndpointPolicySetting `protobuf:"bytes,6,opt,name=portname_policy_setting,json=portnamePolicySetting,proto3" json:"portname_policy_setting,omitempty"`
540 IovPolicySettings *IovEndpointPolicySetting `protobuf:"bytes,7,opt,name=iov_policy_settings,json=iovPolicySettings,proto3" json:"iov_policy_settings,omitempty"`
541 DnsSetting *DnsSetting `protobuf:"bytes,16,opt,name=dns_setting,json=dnsSetting,proto3" json:"dns_setting,omitempty"`
542 XXX_NoUnkeyedLiteral struct{} `json:"-"`
543 XXX_unrecognized []byte `json:"-"`
544 XXX_sizecache int32 `json:"-"`
545 }
546
547 func (m *CreateEndpointRequest) Reset() { *m = CreateEndpointRequest{} }
548 func (*CreateEndpointRequest) ProtoMessage() {}
549 func (*CreateEndpointRequest) Descriptor() ([]byte, []int) {
550 return fileDescriptor_2f3a1f7794389dcf, []int{11}
551 }
552 func (m *CreateEndpointRequest) XXX_Unmarshal(b []byte) error {
553 return m.Unmarshal(b)
554 }
555 func (m *CreateEndpointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
556 if deterministic {
557 return xxx_messageInfo_CreateEndpointRequest.Marshal(b, m, deterministic)
558 } else {
559 b = b[:cap(b)]
560 n, err := m.MarshalToSizedBuffer(b)
561 if err != nil {
562 return nil, err
563 }
564 return b[:n], nil
565 }
566 }
567 func (m *CreateEndpointRequest) XXX_Merge(src proto.Message) {
568 xxx_messageInfo_CreateEndpointRequest.Merge(m, src)
569 }
570 func (m *CreateEndpointRequest) XXX_Size() int {
571 return m.Size()
572 }
573 func (m *CreateEndpointRequest) XXX_DiscardUnknown() {
574 xxx_messageInfo_CreateEndpointRequest.DiscardUnknown(m)
575 }
576
577 var xxx_messageInfo_CreateEndpointRequest proto.InternalMessageInfo
578
579
580 type CreateEndpointResponse struct {
581 ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
582 XXX_NoUnkeyedLiteral struct{} `json:"-"`
583 XXX_unrecognized []byte `json:"-"`
584 XXX_sizecache int32 `json:"-"`
585 }
586
587 func (m *CreateEndpointResponse) Reset() { *m = CreateEndpointResponse{} }
588 func (*CreateEndpointResponse) ProtoMessage() {}
589 func (*CreateEndpointResponse) Descriptor() ([]byte, []int) {
590 return fileDescriptor_2f3a1f7794389dcf, []int{12}
591 }
592 func (m *CreateEndpointResponse) XXX_Unmarshal(b []byte) error {
593 return m.Unmarshal(b)
594 }
595 func (m *CreateEndpointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
596 if deterministic {
597 return xxx_messageInfo_CreateEndpointResponse.Marshal(b, m, deterministic)
598 } else {
599 b = b[:cap(b)]
600 n, err := m.MarshalToSizedBuffer(b)
601 if err != nil {
602 return nil, err
603 }
604 return b[:n], nil
605 }
606 }
607 func (m *CreateEndpointResponse) XXX_Merge(src proto.Message) {
608 xxx_messageInfo_CreateEndpointResponse.Merge(m, src)
609 }
610 func (m *CreateEndpointResponse) XXX_Size() int {
611 return m.Size()
612 }
613 func (m *CreateEndpointResponse) XXX_DiscardUnknown() {
614 xxx_messageInfo_CreateEndpointResponse.DiscardUnknown(m)
615 }
616
617 var xxx_messageInfo_CreateEndpointResponse proto.InternalMessageInfo
618
619
620 type AddEndpointRequest struct {
621 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
622 NamespaceID string `protobuf:"bytes,2,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"`
623 XXX_NoUnkeyedLiteral struct{} `json:"-"`
624 XXX_unrecognized []byte `json:"-"`
625 XXX_sizecache int32 `json:"-"`
626 }
627
628 func (m *AddEndpointRequest) Reset() { *m = AddEndpointRequest{} }
629 func (*AddEndpointRequest) ProtoMessage() {}
630 func (*AddEndpointRequest) Descriptor() ([]byte, []int) {
631 return fileDescriptor_2f3a1f7794389dcf, []int{13}
632 }
633 func (m *AddEndpointRequest) XXX_Unmarshal(b []byte) error {
634 return m.Unmarshal(b)
635 }
636 func (m *AddEndpointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
637 if deterministic {
638 return xxx_messageInfo_AddEndpointRequest.Marshal(b, m, deterministic)
639 } else {
640 b = b[:cap(b)]
641 n, err := m.MarshalToSizedBuffer(b)
642 if err != nil {
643 return nil, err
644 }
645 return b[:n], nil
646 }
647 }
648 func (m *AddEndpointRequest) XXX_Merge(src proto.Message) {
649 xxx_messageInfo_AddEndpointRequest.Merge(m, src)
650 }
651 func (m *AddEndpointRequest) XXX_Size() int {
652 return m.Size()
653 }
654 func (m *AddEndpointRequest) XXX_DiscardUnknown() {
655 xxx_messageInfo_AddEndpointRequest.DiscardUnknown(m)
656 }
657
658 var xxx_messageInfo_AddEndpointRequest proto.InternalMessageInfo
659
660
661 type AddEndpointResponse struct {
662 XXX_NoUnkeyedLiteral struct{} `json:"-"`
663 XXX_unrecognized []byte `json:"-"`
664 XXX_sizecache int32 `json:"-"`
665 }
666
667 func (m *AddEndpointResponse) Reset() { *m = AddEndpointResponse{} }
668 func (*AddEndpointResponse) ProtoMessage() {}
669 func (*AddEndpointResponse) Descriptor() ([]byte, []int) {
670 return fileDescriptor_2f3a1f7794389dcf, []int{14}
671 }
672 func (m *AddEndpointResponse) XXX_Unmarshal(b []byte) error {
673 return m.Unmarshal(b)
674 }
675 func (m *AddEndpointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
676 if deterministic {
677 return xxx_messageInfo_AddEndpointResponse.Marshal(b, m, deterministic)
678 } else {
679 b = b[:cap(b)]
680 n, err := m.MarshalToSizedBuffer(b)
681 if err != nil {
682 return nil, err
683 }
684 return b[:n], nil
685 }
686 }
687 func (m *AddEndpointResponse) XXX_Merge(src proto.Message) {
688 xxx_messageInfo_AddEndpointResponse.Merge(m, src)
689 }
690 func (m *AddEndpointResponse) XXX_Size() int {
691 return m.Size()
692 }
693 func (m *AddEndpointResponse) XXX_DiscardUnknown() {
694 xxx_messageInfo_AddEndpointResponse.DiscardUnknown(m)
695 }
696
697 var xxx_messageInfo_AddEndpointResponse proto.InternalMessageInfo
698
699
700 type DeleteEndpointRequest struct {
701 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
702 XXX_NoUnkeyedLiteral struct{} `json:"-"`
703 XXX_unrecognized []byte `json:"-"`
704 XXX_sizecache int32 `json:"-"`
705 }
706
707 func (m *DeleteEndpointRequest) Reset() { *m = DeleteEndpointRequest{} }
708 func (*DeleteEndpointRequest) ProtoMessage() {}
709 func (*DeleteEndpointRequest) Descriptor() ([]byte, []int) {
710 return fileDescriptor_2f3a1f7794389dcf, []int{15}
711 }
712 func (m *DeleteEndpointRequest) XXX_Unmarshal(b []byte) error {
713 return m.Unmarshal(b)
714 }
715 func (m *DeleteEndpointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
716 if deterministic {
717 return xxx_messageInfo_DeleteEndpointRequest.Marshal(b, m, deterministic)
718 } else {
719 b = b[:cap(b)]
720 n, err := m.MarshalToSizedBuffer(b)
721 if err != nil {
722 return nil, err
723 }
724 return b[:n], nil
725 }
726 }
727 func (m *DeleteEndpointRequest) XXX_Merge(src proto.Message) {
728 xxx_messageInfo_DeleteEndpointRequest.Merge(m, src)
729 }
730 func (m *DeleteEndpointRequest) XXX_Size() int {
731 return m.Size()
732 }
733 func (m *DeleteEndpointRequest) XXX_DiscardUnknown() {
734 xxx_messageInfo_DeleteEndpointRequest.DiscardUnknown(m)
735 }
736
737 var xxx_messageInfo_DeleteEndpointRequest proto.InternalMessageInfo
738
739
740 type DeleteEndpointResponse struct {
741 XXX_NoUnkeyedLiteral struct{} `json:"-"`
742 XXX_unrecognized []byte `json:"-"`
743 XXX_sizecache int32 `json:"-"`
744 }
745
746 func (m *DeleteEndpointResponse) Reset() { *m = DeleteEndpointResponse{} }
747 func (*DeleteEndpointResponse) ProtoMessage() {}
748 func (*DeleteEndpointResponse) Descriptor() ([]byte, []int) {
749 return fileDescriptor_2f3a1f7794389dcf, []int{16}
750 }
751 func (m *DeleteEndpointResponse) XXX_Unmarshal(b []byte) error {
752 return m.Unmarshal(b)
753 }
754 func (m *DeleteEndpointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
755 if deterministic {
756 return xxx_messageInfo_DeleteEndpointResponse.Marshal(b, m, deterministic)
757 } else {
758 b = b[:cap(b)]
759 n, err := m.MarshalToSizedBuffer(b)
760 if err != nil {
761 return nil, err
762 }
763 return b[:n], nil
764 }
765 }
766 func (m *DeleteEndpointResponse) XXX_Merge(src proto.Message) {
767 xxx_messageInfo_DeleteEndpointResponse.Merge(m, src)
768 }
769 func (m *DeleteEndpointResponse) XXX_Size() int {
770 return m.Size()
771 }
772 func (m *DeleteEndpointResponse) XXX_DiscardUnknown() {
773 xxx_messageInfo_DeleteEndpointResponse.DiscardUnknown(m)
774 }
775
776 var xxx_messageInfo_DeleteEndpointResponse proto.InternalMessageInfo
777
778
779 type DeleteNetworkRequest struct {
780 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
781 XXX_NoUnkeyedLiteral struct{} `json:"-"`
782 XXX_unrecognized []byte `json:"-"`
783 XXX_sizecache int32 `json:"-"`
784 }
785
786 func (m *DeleteNetworkRequest) Reset() { *m = DeleteNetworkRequest{} }
787 func (*DeleteNetworkRequest) ProtoMessage() {}
788 func (*DeleteNetworkRequest) Descriptor() ([]byte, []int) {
789 return fileDescriptor_2f3a1f7794389dcf, []int{17}
790 }
791 func (m *DeleteNetworkRequest) XXX_Unmarshal(b []byte) error {
792 return m.Unmarshal(b)
793 }
794 func (m *DeleteNetworkRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
795 if deterministic {
796 return xxx_messageInfo_DeleteNetworkRequest.Marshal(b, m, deterministic)
797 } else {
798 b = b[:cap(b)]
799 n, err := m.MarshalToSizedBuffer(b)
800 if err != nil {
801 return nil, err
802 }
803 return b[:n], nil
804 }
805 }
806 func (m *DeleteNetworkRequest) XXX_Merge(src proto.Message) {
807 xxx_messageInfo_DeleteNetworkRequest.Merge(m, src)
808 }
809 func (m *DeleteNetworkRequest) XXX_Size() int {
810 return m.Size()
811 }
812 func (m *DeleteNetworkRequest) XXX_DiscardUnknown() {
813 xxx_messageInfo_DeleteNetworkRequest.DiscardUnknown(m)
814 }
815
816 var xxx_messageInfo_DeleteNetworkRequest proto.InternalMessageInfo
817
818
819 type DeleteNetworkResponse struct {
820 XXX_NoUnkeyedLiteral struct{} `json:"-"`
821 XXX_unrecognized []byte `json:"-"`
822 XXX_sizecache int32 `json:"-"`
823 }
824
825 func (m *DeleteNetworkResponse) Reset() { *m = DeleteNetworkResponse{} }
826 func (*DeleteNetworkResponse) ProtoMessage() {}
827 func (*DeleteNetworkResponse) Descriptor() ([]byte, []int) {
828 return fileDescriptor_2f3a1f7794389dcf, []int{18}
829 }
830 func (m *DeleteNetworkResponse) XXX_Unmarshal(b []byte) error {
831 return m.Unmarshal(b)
832 }
833 func (m *DeleteNetworkResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
834 if deterministic {
835 return xxx_messageInfo_DeleteNetworkResponse.Marshal(b, m, deterministic)
836 } else {
837 b = b[:cap(b)]
838 n, err := m.MarshalToSizedBuffer(b)
839 if err != nil {
840 return nil, err
841 }
842 return b[:n], nil
843 }
844 }
845 func (m *DeleteNetworkResponse) XXX_Merge(src proto.Message) {
846 xxx_messageInfo_DeleteNetworkResponse.Merge(m, src)
847 }
848 func (m *DeleteNetworkResponse) XXX_Size() int {
849 return m.Size()
850 }
851 func (m *DeleteNetworkResponse) XXX_DiscardUnknown() {
852 xxx_messageInfo_DeleteNetworkResponse.DiscardUnknown(m)
853 }
854
855 var xxx_messageInfo_DeleteNetworkResponse proto.InternalMessageInfo
856
857
858 type GetEndpointRequest struct {
859 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
860 XXX_NoUnkeyedLiteral struct{} `json:"-"`
861 XXX_unrecognized []byte `json:"-"`
862 XXX_sizecache int32 `json:"-"`
863 }
864
865 func (m *GetEndpointRequest) Reset() { *m = GetEndpointRequest{} }
866 func (*GetEndpointRequest) ProtoMessage() {}
867 func (*GetEndpointRequest) Descriptor() ([]byte, []int) {
868 return fileDescriptor_2f3a1f7794389dcf, []int{19}
869 }
870 func (m *GetEndpointRequest) XXX_Unmarshal(b []byte) error {
871 return m.Unmarshal(b)
872 }
873 func (m *GetEndpointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
874 if deterministic {
875 return xxx_messageInfo_GetEndpointRequest.Marshal(b, m, deterministic)
876 } else {
877 b = b[:cap(b)]
878 n, err := m.MarshalToSizedBuffer(b)
879 if err != nil {
880 return nil, err
881 }
882 return b[:n], nil
883 }
884 }
885 func (m *GetEndpointRequest) XXX_Merge(src proto.Message) {
886 xxx_messageInfo_GetEndpointRequest.Merge(m, src)
887 }
888 func (m *GetEndpointRequest) XXX_Size() int {
889 return m.Size()
890 }
891 func (m *GetEndpointRequest) XXX_DiscardUnknown() {
892 xxx_messageInfo_GetEndpointRequest.DiscardUnknown(m)
893 }
894
895 var xxx_messageInfo_GetEndpointRequest proto.InternalMessageInfo
896
897
898 type GetEndpointResponse struct {
899 ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
900 Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
901 Network string `protobuf:"bytes,3,opt,name=network,proto3" json:"network,omitempty"`
902 Namespace string `protobuf:"bytes,4,opt,name=namespace,proto3" json:"namespace,omitempty"`
903 DnsSetting *DnsSetting `protobuf:"bytes,5,opt,name=dns_setting,json=dnsSetting,proto3" json:"dns_setting,omitempty"`
904 XXX_NoUnkeyedLiteral struct{} `json:"-"`
905 XXX_unrecognized []byte `json:"-"`
906 XXX_sizecache int32 `json:"-"`
907 }
908
909 func (m *GetEndpointResponse) Reset() { *m = GetEndpointResponse{} }
910 func (*GetEndpointResponse) ProtoMessage() {}
911 func (*GetEndpointResponse) Descriptor() ([]byte, []int) {
912 return fileDescriptor_2f3a1f7794389dcf, []int{20}
913 }
914 func (m *GetEndpointResponse) XXX_Unmarshal(b []byte) error {
915 return m.Unmarshal(b)
916 }
917 func (m *GetEndpointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
918 if deterministic {
919 return xxx_messageInfo_GetEndpointResponse.Marshal(b, m, deterministic)
920 } else {
921 b = b[:cap(b)]
922 n, err := m.MarshalToSizedBuffer(b)
923 if err != nil {
924 return nil, err
925 }
926 return b[:n], nil
927 }
928 }
929 func (m *GetEndpointResponse) XXX_Merge(src proto.Message) {
930 xxx_messageInfo_GetEndpointResponse.Merge(m, src)
931 }
932 func (m *GetEndpointResponse) XXX_Size() int {
933 return m.Size()
934 }
935 func (m *GetEndpointResponse) XXX_DiscardUnknown() {
936 xxx_messageInfo_GetEndpointResponse.DiscardUnknown(m)
937 }
938
939 var xxx_messageInfo_GetEndpointResponse proto.InternalMessageInfo
940
941
942 type GetNetworkRequest struct {
943 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
944 XXX_NoUnkeyedLiteral struct{} `json:"-"`
945 XXX_unrecognized []byte `json:"-"`
946 XXX_sizecache int32 `json:"-"`
947 }
948
949 func (m *GetNetworkRequest) Reset() { *m = GetNetworkRequest{} }
950 func (*GetNetworkRequest) ProtoMessage() {}
951 func (*GetNetworkRequest) Descriptor() ([]byte, []int) {
952 return fileDescriptor_2f3a1f7794389dcf, []int{21}
953 }
954 func (m *GetNetworkRequest) XXX_Unmarshal(b []byte) error {
955 return m.Unmarshal(b)
956 }
957 func (m *GetNetworkRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
958 if deterministic {
959 return xxx_messageInfo_GetNetworkRequest.Marshal(b, m, deterministic)
960 } else {
961 b = b[:cap(b)]
962 n, err := m.MarshalToSizedBuffer(b)
963 if err != nil {
964 return nil, err
965 }
966 return b[:n], nil
967 }
968 }
969 func (m *GetNetworkRequest) XXX_Merge(src proto.Message) {
970 xxx_messageInfo_GetNetworkRequest.Merge(m, src)
971 }
972 func (m *GetNetworkRequest) XXX_Size() int {
973 return m.Size()
974 }
975 func (m *GetNetworkRequest) XXX_DiscardUnknown() {
976 xxx_messageInfo_GetNetworkRequest.DiscardUnknown(m)
977 }
978
979 var xxx_messageInfo_GetNetworkRequest proto.InternalMessageInfo
980
981
982 type GetNetworkResponse struct {
983 ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
984 Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
985 XXX_NoUnkeyedLiteral struct{} `json:"-"`
986 XXX_unrecognized []byte `json:"-"`
987 XXX_sizecache int32 `json:"-"`
988 }
989
990 func (m *GetNetworkResponse) Reset() { *m = GetNetworkResponse{} }
991 func (*GetNetworkResponse) ProtoMessage() {}
992 func (*GetNetworkResponse) Descriptor() ([]byte, []int) {
993 return fileDescriptor_2f3a1f7794389dcf, []int{22}
994 }
995 func (m *GetNetworkResponse) XXX_Unmarshal(b []byte) error {
996 return m.Unmarshal(b)
997 }
998 func (m *GetNetworkResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
999 if deterministic {
1000 return xxx_messageInfo_GetNetworkResponse.Marshal(b, m, deterministic)
1001 } else {
1002 b = b[:cap(b)]
1003 n, err := m.MarshalToSizedBuffer(b)
1004 if err != nil {
1005 return nil, err
1006 }
1007 return b[:n], nil
1008 }
1009 }
1010 func (m *GetNetworkResponse) XXX_Merge(src proto.Message) {
1011 xxx_messageInfo_GetNetworkResponse.Merge(m, src)
1012 }
1013 func (m *GetNetworkResponse) XXX_Size() int {
1014 return m.Size()
1015 }
1016 func (m *GetNetworkResponse) XXX_DiscardUnknown() {
1017 xxx_messageInfo_GetNetworkResponse.DiscardUnknown(m)
1018 }
1019
1020 var xxx_messageInfo_GetNetworkResponse proto.InternalMessageInfo
1021
1022
1023 type GetEndpointsRequest struct {
1024 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1025 XXX_unrecognized []byte `json:"-"`
1026 XXX_sizecache int32 `json:"-"`
1027 }
1028
1029 func (m *GetEndpointsRequest) Reset() { *m = GetEndpointsRequest{} }
1030 func (*GetEndpointsRequest) ProtoMessage() {}
1031 func (*GetEndpointsRequest) Descriptor() ([]byte, []int) {
1032 return fileDescriptor_2f3a1f7794389dcf, []int{23}
1033 }
1034 func (m *GetEndpointsRequest) XXX_Unmarshal(b []byte) error {
1035 return m.Unmarshal(b)
1036 }
1037 func (m *GetEndpointsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1038 if deterministic {
1039 return xxx_messageInfo_GetEndpointsRequest.Marshal(b, m, deterministic)
1040 } else {
1041 b = b[:cap(b)]
1042 n, err := m.MarshalToSizedBuffer(b)
1043 if err != nil {
1044 return nil, err
1045 }
1046 return b[:n], nil
1047 }
1048 }
1049 func (m *GetEndpointsRequest) XXX_Merge(src proto.Message) {
1050 xxx_messageInfo_GetEndpointsRequest.Merge(m, src)
1051 }
1052 func (m *GetEndpointsRequest) XXX_Size() int {
1053 return m.Size()
1054 }
1055 func (m *GetEndpointsRequest) XXX_DiscardUnknown() {
1056 xxx_messageInfo_GetEndpointsRequest.DiscardUnknown(m)
1057 }
1058
1059 var xxx_messageInfo_GetEndpointsRequest proto.InternalMessageInfo
1060
1061
1062 type GetEndpointsResponse struct {
1063 Endpoints []*GetEndpointResponse `protobuf:"bytes,1,rep,name=endpoints,proto3" json:"endpoints,omitempty"`
1064 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1065 XXX_unrecognized []byte `json:"-"`
1066 XXX_sizecache int32 `json:"-"`
1067 }
1068
1069 func (m *GetEndpointsResponse) Reset() { *m = GetEndpointsResponse{} }
1070 func (*GetEndpointsResponse) ProtoMessage() {}
1071 func (*GetEndpointsResponse) Descriptor() ([]byte, []int) {
1072 return fileDescriptor_2f3a1f7794389dcf, []int{24}
1073 }
1074 func (m *GetEndpointsResponse) XXX_Unmarshal(b []byte) error {
1075 return m.Unmarshal(b)
1076 }
1077 func (m *GetEndpointsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1078 if deterministic {
1079 return xxx_messageInfo_GetEndpointsResponse.Marshal(b, m, deterministic)
1080 } else {
1081 b = b[:cap(b)]
1082 n, err := m.MarshalToSizedBuffer(b)
1083 if err != nil {
1084 return nil, err
1085 }
1086 return b[:n], nil
1087 }
1088 }
1089 func (m *GetEndpointsResponse) XXX_Merge(src proto.Message) {
1090 xxx_messageInfo_GetEndpointsResponse.Merge(m, src)
1091 }
1092 func (m *GetEndpointsResponse) XXX_Size() int {
1093 return m.Size()
1094 }
1095 func (m *GetEndpointsResponse) XXX_DiscardUnknown() {
1096 xxx_messageInfo_GetEndpointsResponse.DiscardUnknown(m)
1097 }
1098
1099 var xxx_messageInfo_GetEndpointsResponse proto.InternalMessageInfo
1100
1101
1102 type GetNetworksRequest struct {
1103 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1104 XXX_unrecognized []byte `json:"-"`
1105 XXX_sizecache int32 `json:"-"`
1106 }
1107
1108 func (m *GetNetworksRequest) Reset() { *m = GetNetworksRequest{} }
1109 func (*GetNetworksRequest) ProtoMessage() {}
1110 func (*GetNetworksRequest) Descriptor() ([]byte, []int) {
1111 return fileDescriptor_2f3a1f7794389dcf, []int{25}
1112 }
1113 func (m *GetNetworksRequest) XXX_Unmarshal(b []byte) error {
1114 return m.Unmarshal(b)
1115 }
1116 func (m *GetNetworksRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1117 if deterministic {
1118 return xxx_messageInfo_GetNetworksRequest.Marshal(b, m, deterministic)
1119 } else {
1120 b = b[:cap(b)]
1121 n, err := m.MarshalToSizedBuffer(b)
1122 if err != nil {
1123 return nil, err
1124 }
1125 return b[:n], nil
1126 }
1127 }
1128 func (m *GetNetworksRequest) XXX_Merge(src proto.Message) {
1129 xxx_messageInfo_GetNetworksRequest.Merge(m, src)
1130 }
1131 func (m *GetNetworksRequest) XXX_Size() int {
1132 return m.Size()
1133 }
1134 func (m *GetNetworksRequest) XXX_DiscardUnknown() {
1135 xxx_messageInfo_GetNetworksRequest.DiscardUnknown(m)
1136 }
1137
1138 var xxx_messageInfo_GetNetworksRequest proto.InternalMessageInfo
1139
1140
1141 type GetNetworksResponse struct {
1142 Networks []*GetNetworkResponse `protobuf:"bytes,1,rep,name=networks,proto3" json:"networks,omitempty"`
1143 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1144 XXX_unrecognized []byte `json:"-"`
1145 XXX_sizecache int32 `json:"-"`
1146 }
1147
1148 func (m *GetNetworksResponse) Reset() { *m = GetNetworksResponse{} }
1149 func (*GetNetworksResponse) ProtoMessage() {}
1150 func (*GetNetworksResponse) Descriptor() ([]byte, []int) {
1151 return fileDescriptor_2f3a1f7794389dcf, []int{26}
1152 }
1153 func (m *GetNetworksResponse) XXX_Unmarshal(b []byte) error {
1154 return m.Unmarshal(b)
1155 }
1156 func (m *GetNetworksResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1157 if deterministic {
1158 return xxx_messageInfo_GetNetworksResponse.Marshal(b, m, deterministic)
1159 } else {
1160 b = b[:cap(b)]
1161 n, err := m.MarshalToSizedBuffer(b)
1162 if err != nil {
1163 return nil, err
1164 }
1165 return b[:n], nil
1166 }
1167 }
1168 func (m *GetNetworksResponse) XXX_Merge(src proto.Message) {
1169 xxx_messageInfo_GetNetworksResponse.Merge(m, src)
1170 }
1171 func (m *GetNetworksResponse) XXX_Size() int {
1172 return m.Size()
1173 }
1174 func (m *GetNetworksResponse) XXX_DiscardUnknown() {
1175 xxx_messageInfo_GetNetworksResponse.DiscardUnknown(m)
1176 }
1177
1178 var xxx_messageInfo_GetNetworksResponse proto.InternalMessageInfo
1179
1180 func init() {
1181 proto.RegisterEnum("ncproxygrpc.CreateNetworkRequest_NetworkMode", CreateNetworkRequest_NetworkMode_name, CreateNetworkRequest_NetworkMode_value)
1182 proto.RegisterEnum("ncproxygrpc.CreateNetworkRequest_IpamType", CreateNetworkRequest_IpamType_name, CreateNetworkRequest_IpamType_value)
1183 proto.RegisterType((*AddNICRequest)(nil), "ncproxygrpc.AddNICRequest")
1184 proto.RegisterType((*AddNICResponse)(nil), "ncproxygrpc.AddNICResponse")
1185 proto.RegisterType((*ModifyNICRequest)(nil), "ncproxygrpc.ModifyNICRequest")
1186 proto.RegisterType((*ModifyNICResponse)(nil), "ncproxygrpc.ModifyNICResponse")
1187 proto.RegisterType((*DeleteNICRequest)(nil), "ncproxygrpc.DeleteNICRequest")
1188 proto.RegisterType((*DeleteNICResponse)(nil), "ncproxygrpc.DeleteNICResponse")
1189 proto.RegisterType((*CreateNetworkRequest)(nil), "ncproxygrpc.CreateNetworkRequest")
1190 proto.RegisterType((*CreateNetworkResponse)(nil), "ncproxygrpc.CreateNetworkResponse")
1191 proto.RegisterType((*PortNameEndpointPolicySetting)(nil), "ncproxygrpc.PortNameEndpointPolicySetting")
1192 proto.RegisterType((*IovEndpointPolicySetting)(nil), "ncproxygrpc.IovEndpointPolicySetting")
1193 proto.RegisterType((*DnsSetting)(nil), "ncproxygrpc.DnsSetting")
1194 proto.RegisterType((*CreateEndpointRequest)(nil), "ncproxygrpc.CreateEndpointRequest")
1195 proto.RegisterType((*CreateEndpointResponse)(nil), "ncproxygrpc.CreateEndpointResponse")
1196 proto.RegisterType((*AddEndpointRequest)(nil), "ncproxygrpc.AddEndpointRequest")
1197 proto.RegisterType((*AddEndpointResponse)(nil), "ncproxygrpc.AddEndpointResponse")
1198 proto.RegisterType((*DeleteEndpointRequest)(nil), "ncproxygrpc.DeleteEndpointRequest")
1199 proto.RegisterType((*DeleteEndpointResponse)(nil), "ncproxygrpc.DeleteEndpointResponse")
1200 proto.RegisterType((*DeleteNetworkRequest)(nil), "ncproxygrpc.DeleteNetworkRequest")
1201 proto.RegisterType((*DeleteNetworkResponse)(nil), "ncproxygrpc.DeleteNetworkResponse")
1202 proto.RegisterType((*GetEndpointRequest)(nil), "ncproxygrpc.GetEndpointRequest")
1203 proto.RegisterType((*GetEndpointResponse)(nil), "ncproxygrpc.GetEndpointResponse")
1204 proto.RegisterType((*GetNetworkRequest)(nil), "ncproxygrpc.GetNetworkRequest")
1205 proto.RegisterType((*GetNetworkResponse)(nil), "ncproxygrpc.GetNetworkResponse")
1206 proto.RegisterType((*GetEndpointsRequest)(nil), "ncproxygrpc.GetEndpointsRequest")
1207 proto.RegisterType((*GetEndpointsResponse)(nil), "ncproxygrpc.GetEndpointsResponse")
1208 proto.RegisterType((*GetNetworksRequest)(nil), "ncproxygrpc.GetNetworksRequest")
1209 proto.RegisterType((*GetNetworksResponse)(nil), "ncproxygrpc.GetNetworksResponse")
1210 }
1211
1212 func init() {
1213 proto.RegisterFile("github.com/Microsoft/hcsshim/pkg/ncproxy/ncproxygrpc/v0/networkconfigproxy.proto", fileDescriptor_2f3a1f7794389dcf)
1214 }
1215
1216 var fileDescriptor_2f3a1f7794389dcf = []byte{
1217
1218 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xdd, 0x8e, 0xdb, 0x44,
1219 0x14, 0x8e, 0x93, 0xdd, 0x34, 0x7b, 0x9c, 0x4d, 0xb3, 0xb3, 0x7f, 0x26, 0x6d, 0x93, 0xd4, 0x55,
1220 0x45, 0x55, 0x60, 0x53, 0xa5, 0x3f, 0x88, 0x0a, 0x09, 0x6d, 0xb3, 0x55, 0x49, 0x61, 0xd3, 0x68,
1221 0xbb, 0x08, 0x28, 0x12, 0x96, 0x6b, 0x4f, 0x92, 0x51, 0x37, 0x1e, 0xd7, 0x9e, 0x64, 0x9b, 0x3b,
1222 0xee, 0x78, 0x03, 0x24, 0x9e, 0x04, 0xee, 0xb8, 0x2d, 0x77, 0x5c, 0x72, 0x55, 0xd1, 0x3c, 0x03,
1223 0x0f, 0x80, 0x3c, 0x63, 0x3b, 0xf6, 0x90, 0xec, 0x0f, 0xdc, 0xf4, 0x2a, 0xf2, 0x39, 0xdf, 0xf9,
1224 0x99, 0x73, 0xbe, 0x73, 0x66, 0x14, 0xe8, 0xf6, 0x09, 0x1b, 0x8c, 0x9e, 0xef, 0x58, 0x74, 0xd8,
1225 0xd8, 0x27, 0x96, 0x47, 0x7d, 0xda, 0x63, 0x8d, 0x81, 0xe5, 0xfb, 0x03, 0x32, 0x6c, 0xb8, 0x2f,
1226 0xfa, 0x0d, 0xc7, 0x72, 0x3d, 0xfa, 0x6a, 0x12, 0xfd, 0xf6, 0x3d, 0xd7, 0x6a, 0x8c, 0x6f, 0x35,
1227 0x1c, 0xcc, 0x8e, 0xa9, 0xf7, 0xc2, 0xa2, 0x4e, 0x8f, 0xf4, 0xb9, 0x66, 0xc7, 0xf5, 0x28, 0xa3,
1228 0x48, 0x4d, 0x00, 0xf5, 0x9f, 0x14, 0x58, 0xdd, 0xb5, 0xed, 0x4e, 0xbb, 0x75, 0x80, 0x5f, 0x8e,
1229 0xb0, 0xcf, 0xd0, 0x1d, 0x28, 0x5a, 0xd4, 0x61, 0x26, 0x71, 0xb0, 0x67, 0x10, 0x5b, 0x53, 0xea,
1230 0xca, 0x8d, 0x95, 0x07, 0x6b, 0xd3, 0x37, 0x35, 0xb5, 0x15, 0xc9, 0xdb, 0x7b, 0x9a, 0x72, 0xa0,
1231 0xc6, 0xb0, 0xb6, 0x8d, 0x74, 0xc8, 0x3b, 0xc4, 0x0a, 0xf0, 0x59, 0x8e, 0x57, 0xa7, 0x6f, 0x6a,
1232 0xcb, 0x1d, 0x62, 0x71, 0xe4, 0xb2, 0x43, 0xac, 0xb6, 0x8d, 0xde, 0x87, 0x55, 0xec, 0xd8, 0x2e,
1233 0x25, 0x0e, 0x33, 0x1c, 0x73, 0x88, 0xb5, 0x1c, 0x87, 0x66, 0x35, 0xe5, 0xa0, 0x18, 0x29, 0x3a,
1234 0xe6, 0x10, 0xdf, 0xcf, 0x6a, 0x8a, 0xbe, 0x01, 0xa5, 0x28, 0x2f, 0xdf, 0xa5, 0x8e, 0x2f, 0xa4,
1235 0x7f, 0x2b, 0x50, 0xde, 0xa7, 0x36, 0xe9, 0x4d, 0xde, 0xa9, 0x8c, 0xd1, 0xb7, 0xb0, 0x4e, 0xe8,
1236 0xd8, 0x70, 0xe9, 0x11, 0xb1, 0x26, 0x86, 0x8f, 0x19, 0x23, 0x4e, 0xdf, 0xd7, 0x96, 0xea, 0xca,
1237 0x0d, 0xb5, 0x79, 0x7d, 0x27, 0x51, 0xf1, 0x9d, 0x36, 0x1d, 0x3f, 0x0c, 0x4d, 0xbb, 0x1c, 0xfe,
1238 0x54, 0xa0, 0xb9, 0xd7, 0x35, 0x42, 0xc7, 0x29, 0xa9, 0xcf, 0x8f, 0xbd, 0x0d, 0x6b, 0x89, 0x53,
1239 0x27, 0xea, 0xf1, 0xb3, 0x02, 0xe5, 0x3d, 0x7c, 0x84, 0x19, 0x7e, 0xf7, 0x3a, 0xb8, 0x0d, 0x6b,
1240 0x89, 0xd4, 0x12, 0x49, 0xff, 0x92, 0x83, 0x8d, 0x96, 0x87, 0x4d, 0x86, 0x3b, 0x82, 0xa3, 0x51,
1241 0xe2, 0x5b, 0xb0, 0xc4, 0xbd, 0x2a, 0xb1, 0x57, 0xfe, 0x8d, 0x1e, 0xc2, 0xd2, 0x90, 0xda, 0x98,
1242 0x27, 0x56, 0x6a, 0x7e, 0x94, 0x2a, 0xe7, 0x3c, 0x47, 0x3b, 0xe1, 0xe7, 0x3e, 0xb5, 0xb1, 0x70,
1243 0x13, 0x98, 0xa3, 0x6b, 0xa0, 0xfa, 0xc7, 0x84, 0x59, 0x03, 0x39, 0x77, 0x10, 0x62, 0xde, 0xc9,
1244 0x2f, 0x60, 0x85, 0xb8, 0xe6, 0xd0, 0x60, 0x13, 0x17, 0xf3, 0xfe, 0x95, 0x9a, 0x37, 0x4f, 0x0f,
1245 0xd8, 0x76, 0xcd, 0xe1, 0xe1, 0xc4, 0x15, 0xd1, 0x0a, 0x24, 0xfc, 0x42, 0xf7, 0x61, 0xdb, 0x1f,
1246 0x3d, 0x77, 0x30, 0x33, 0x88, 0x6b, 0xda, 0xb6, 0x87, 0x7d, 0xdf, 0x70, 0x3d, 0xdc, 0x23, 0xaf,
1247 0xb4, 0xe5, 0x7a, 0x2e, 0x8c, 0xbe, 0x29, 0x20, 0xed, 0x08, 0xd1, 0xe5, 0x00, 0xf4, 0x01, 0x5c,
1248 0xb4, 0x71, 0xcf, 0x1c, 0x1d, 0x31, 0xa3, 0x6f, 0x32, 0x7c, 0x6c, 0x4e, 0xb4, 0x7c, 0x9c, 0x71,
1249 0x29, 0x54, 0x3d, 0x12, 0x1a, 0xfd, 0x36, 0xa8, 0x89, 0x33, 0xa3, 0x75, 0x50, 0x0f, 0x3d, 0xd3,
1250 0xf1, 0x5d, 0xd3, 0xc3, 0x0e, 0x2b, 0x67, 0x2a, 0xd9, 0x82, 0x82, 0x54, 0xc8, 0x75, 0x76, 0x0f,
1251 0xcb, 0x4a, 0xf0, 0x51, 0x09, 0xfa, 0xf0, 0x21, 0x14, 0xa2, 0xbc, 0x51, 0x09, 0xf2, 0x4f, 0x99,
1252 0xc9, 0x88, 0x15, 0x82, 0x8b, 0xb0, 0xb4, 0xf7, 0x79, 0xab, 0x3b, 0x43, 0xf3, 0xce, 0xdd, 0x85,
1253 0x4d, 0xe9, 0xf8, 0xa2, 0xad, 0x48, 0x83, 0x6c, 0x4c, 0xb4, 0xc2, 0xf4, 0x4d, 0x2d, 0xcb, 0x59,
1254 0x93, 0x25, 0x36, 0x37, 0xdb, 0x83, 0x2b, 0x5d, 0xea, 0x71, 0x66, 0xcc, 0xa5, 0x3e, 0xaa, 0xc1,
1255 0x8a, 0x4b, 0xbd, 0x90, 0x53, 0xb3, 0xee, 0x17, 0xdc, 0xd0, 0x8a, 0x7b, 0xf9, 0x4d, 0x01, 0x6d,
1256 0xd1, 0xf0, 0xa0, 0x5b, 0x80, 0x82, 0x01, 0xa4, 0xbd, 0xde, 0x11, 0x35, 0x6d, 0xe3, 0x18, 0x93,
1257 0xfe, 0x80, 0x71, 0x57, 0xab, 0xdc, 0x55, 0x99, 0xd0, 0xf1, 0x13, 0xa1, 0xfc, 0x9a, 0xeb, 0xd0,
1258 0x3d, 0xd8, 0x7c, 0x39, 0xc2, 0x23, 0x6c, 0xb8, 0x26, 0xf1, 0x7c, 0xc3, 0x13, 0x9d, 0xc4, 0x82,
1259 0xfe, 0xc2, 0x68, 0x9d, 0x03, 0xba, 0x81, 0xfe, 0x20, 0x52, 0xa3, 0xbb, 0xb0, 0x41, 0x1c, 0x86,
1260 0x3d, 0x6f, 0xe4, 0x32, 0x23, 0xe0, 0x95, 0x67, 0x32, 0x42, 0x1d, 0x4e, 0xa7, 0xd0, 0x2c, 0xd6,
1261 0xef, 0xc7, 0x6a, 0x7e, 0x02, 0x06, 0xb0, 0xe7, 0xf8, 0x51, 0xca, 0x37, 0xe1, 0xa2, 0x8f, 0xbd,
1262 0x71, 0x30, 0xa3, 0xae, 0x11, 0xf4, 0xde, 0xd7, 0x94, 0x98, 0x14, 0xab, 0x42, 0xd5, 0x76, 0x77,
1263 0x03, 0x05, 0xaa, 0x40, 0xde, 0xa6, 0x43, 0x93, 0x38, 0xe1, 0x70, 0x06, 0x90, 0x50, 0x12, 0xe8,
1264 0x7c, 0x6c, 0x7a, 0xd6, 0x40, 0xcb, 0xc5, 0xe6, 0xa1, 0x84, 0x47, 0x9d, 0xe6, 0xa2, 0xae, 0x45,
1265 0xa5, 0x3b, 0x6d, 0xde, 0x74, 0x80, 0xa1, 0x69, 0x85, 0x74, 0x4c, 0x44, 0x4c, 0x48, 0x51, 0x9d,
1266 0xcf, 0x49, 0x08, 0x99, 0x8d, 0xd2, 0x4c, 0x88, 0x3e, 0x81, 0x2d, 0x99, 0xf5, 0x47, 0xd8, 0xe9,
1267 0xb3, 0x01, 0x1f, 0xab, 0x90, 0xfb, 0x24, 0xcd, 0x7a, 0x01, 0x40, 0xd7, 0xa1, 0x18, 0x5e, 0x5f,
1268 0x82, 0x12, 0xcb, 0xb1, 0x81, 0x1a, 0xca, 0xf9, 0xac, 0xf6, 0x60, 0x3b, 0x60, 0x48, 0x00, 0x91,
1269 0x56, 0x2f, 0x1f, 0x15, 0x55, 0x9a, 0xdc, 0x13, 0x39, 0x28, 0xd2, 0x89, 0xdc, 0xa5, 0xc9, 0xb5,
1270 0x60, 0xbb, 0x5f, 0xf8, 0xff, 0xdb, 0x1d, 0x7d, 0x0a, 0xaa, 0xed, 0xf8, 0x71, 0xda, 0x65, 0xee,
1271 0x72, 0x3b, 0xe5, 0x72, 0x46, 0x19, 0xd1, 0x04, 0x3b, 0xfe, 0x0e, 0xda, 0xfb, 0x78, 0xa9, 0x50,
1272 0x28, 0x97, 0xf5, 0x7b, 0xb0, 0x25, 0xf7, 0xf8, 0x4c, 0xa3, 0xd9, 0x03, 0xb4, 0x6b, 0xdb, 0x67,
1273 0x25, 0xc6, 0x1d, 0x28, 0x06, 0xbf, 0xbe, 0x6b, 0x5a, 0x78, 0x76, 0x53, 0xf0, 0x9b, 0xa5, 0x13,
1274 0xc9, 0xc5, 0xcd, 0x12, 0xc3, 0xda, 0x22, 0xce, 0x7b, 0xb0, 0x9e, 0x8a, 0x93, 0xb8, 0x0e, 0x6e,
1275 0xc3, 0xa6, 0xb8, 0x27, 0xce, 0x98, 0x05, 0x37, 0xba, 0x0c, 0x5b, 0xb2, 0x51, 0xc2, 0x65, 0x13,
1276 0x36, 0xc2, 0xab, 0xe7, 0x4c, 0x17, 0x0c, 0xb7, 0xb9, 0x14, 0xa5, 0x21, 0xed, 0x36, 0xae, 0xbc,
1277 0x05, 0xe8, 0x11, 0x66, 0xe7, 0x49, 0xf0, 0x77, 0x05, 0xd6, 0x53, 0x26, 0xa7, 0xb5, 0x23, 0xf6,
1278 0x96, 0x95, 0x8a, 0x7e, 0x19, 0x2e, 0x84, 0xa4, 0x4f, 0xcc, 0x59, 0x24, 0x0a, 0xe6, 0x30, 0xae,
1279 0x75, 0x62, 0xb0, 0x66, 0x42, 0x99, 0x62, 0xcb, 0xe7, 0xa6, 0x98, 0xde, 0x80, 0xb5, 0x47, 0x98,
1280 0x9d, 0xa3, 0x96, 0x8f, 0x79, 0xb9, 0xce, 0x7c, 0x49, 0x2c, 0x3a, 0x7a, 0xc4, 0x9c, 0x44, 0x1d,
1281 0xa3, 0x45, 0xcc, 0x55, 0xdf, 0xc3, 0x46, 0x5a, 0x15, 0x06, 0x7a, 0x00, 0x2b, 0xd1, 0x6b, 0x44,
1282 0xec, 0x54, 0xb5, 0x59, 0x4f, 0x9d, 0x77, 0x4e, 0x63, 0x44, 0xd5, 0x62, 0x33, 0xee, 0x5f, 0x4b,
1283 0x1e, 0x23, 0x15, 0xf9, 0x19, 0x4f, 0x6a, 0xa6, 0x09, 0x03, 0x7f, 0x06, 0x85, 0xb0, 0x2f, 0x51,
1284 0xdc, 0x9a, 0x1c, 0x57, 0x2a, 0x8a, 0xb8, 0xe7, 0x22, 0xa3, 0xc0, 0x77, 0xf3, 0xc7, 0x02, 0xa0,
1285 0x10, 0xd5, 0xe2, 0x8f, 0xf7, 0x6e, 0x60, 0x8f, 0x5a, 0x90, 0x17, 0x0f, 0x62, 0x54, 0x49, 0xf9,
1286 0x4c, 0xbd, 0xde, 0x2b, 0x97, 0xe6, 0xea, 0x44, 0x2c, 0x3d, 0x83, 0xbe, 0x84, 0x95, 0xf8, 0x21,
1287 0x89, 0xae, 0xa4, 0xb0, 0xf2, 0xb3, 0xba, 0x52, 0x5d, 0xa4, 0x4e, 0x7a, 0x8b, 0x5f, 0x78, 0x92,
1288 0x37, 0xf9, 0x51, 0x2a, 0x79, 0xfb, 0xd7, 0xc3, 0x50, 0xcf, 0xa0, 0x6f, 0x60, 0x35, 0xf5, 0xb8,
1289 0x40, 0x57, 0x4f, 0x7d, 0x77, 0x55, 0xf4, 0x93, 0x20, 0xb1, 0xe7, 0xef, 0xa0, 0x94, 0x5e, 0x8e,
1290 0x68, 0x9e, 0x9d, 0x34, 0xdd, 0x95, 0x6b, 0x27, 0x62, 0x62, 0xe7, 0x07, 0xa0, 0x26, 0x36, 0x1b,
1291 0xaa, 0xc9, 0x0d, 0x90, 0xdd, 0xd6, 0x17, 0x03, 0x92, 0x09, 0xa7, 0xb7, 0x9b, 0x94, 0xf0, 0xdc,
1292 0x7d, 0x29, 0x25, 0x3c, 0x7f, 0x3d, 0x8a, 0x3a, 0xa7, 0x16, 0x9d, 0x54, 0xe7, 0x79, 0x8b, 0xb3,
1293 0xa2, 0x9f, 0x04, 0x49, 0x96, 0x22, 0x31, 0x59, 0xa8, 0xb6, 0x78, 0xe6, 0xe6, 0x95, 0x62, 0xce,
1294 0x50, 0xea, 0x19, 0xf4, 0x04, 0x60, 0x36, 0x35, 0xa8, 0xba, 0x70, 0x9c, 0x84, 0xc7, 0xd3, 0xc6,
1295 0x4d, 0xcf, 0xa0, 0xaf, 0xa0, 0x98, 0x5c, 0x1a, 0x68, 0x61, 0x12, 0xd1, 0xc0, 0x57, 0xae, 0x9e,
1296 0x80, 0x90, 0xce, 0x1e, 0x6d, 0x04, 0xb4, 0x28, 0x11, 0x7f, 0xe1, 0xd9, 0xe5, 0x65, 0xa2, 0x67,
1297 0x1e, 0x1c, 0xbe, 0x7e, 0x5b, 0xcd, 0xfc, 0xf9, 0xb6, 0x9a, 0xf9, 0x61, 0x5a, 0x55, 0x5e, 0x4f,
1298 0xab, 0xca, 0x1f, 0xd3, 0xaa, 0xf2, 0xd7, 0xb4, 0xaa, 0x3c, 0xfb, 0xf8, 0x3f, 0xfe, 0x2b, 0xf0,
1299 0xab, 0xa2, 0x3c, 0xcf, 0xf3, 0xbf, 0x01, 0x6e, 0xff, 0x13, 0x00, 0x00, 0xff, 0xff, 0xf1, 0x94,
1300 0x54, 0x89, 0x5a, 0x10, 0x00, 0x00,
1301 }
1302
1303
1304 var _ context.Context
1305 var _ grpc.ClientConn
1306
1307
1308
1309 const _ = grpc.SupportPackageIsVersion4
1310
1311
1312
1313
1314 type NetworkConfigProxyClient interface {
1315 AddNIC(ctx context.Context, in *AddNICRequest, opts ...grpc.CallOption) (*AddNICResponse, error)
1316 ModifyNIC(ctx context.Context, in *ModifyNICRequest, opts ...grpc.CallOption) (*ModifyNICResponse, error)
1317 DeleteNIC(ctx context.Context, in *DeleteNICRequest, opts ...grpc.CallOption) (*DeleteNICResponse, error)
1318 CreateNetwork(ctx context.Context, in *CreateNetworkRequest, opts ...grpc.CallOption) (*CreateNetworkResponse, error)
1319 CreateEndpoint(ctx context.Context, in *CreateEndpointRequest, opts ...grpc.CallOption) (*CreateEndpointResponse, error)
1320 AddEndpoint(ctx context.Context, in *AddEndpointRequest, opts ...grpc.CallOption) (*AddEndpointResponse, error)
1321 DeleteEndpoint(ctx context.Context, in *DeleteEndpointRequest, opts ...grpc.CallOption) (*DeleteEndpointResponse, error)
1322 DeleteNetwork(ctx context.Context, in *DeleteNetworkRequest, opts ...grpc.CallOption) (*DeleteNetworkResponse, error)
1323 GetEndpoint(ctx context.Context, in *GetEndpointRequest, opts ...grpc.CallOption) (*GetEndpointResponse, error)
1324 GetNetwork(ctx context.Context, in *GetNetworkRequest, opts ...grpc.CallOption) (*GetNetworkResponse, error)
1325 GetEndpoints(ctx context.Context, in *GetEndpointsRequest, opts ...grpc.CallOption) (*GetEndpointsResponse, error)
1326 GetNetworks(ctx context.Context, in *GetNetworksRequest, opts ...grpc.CallOption) (*GetNetworksResponse, error)
1327 }
1328
1329 type networkConfigProxyClient struct {
1330 cc *grpc.ClientConn
1331 }
1332
1333 func NewNetworkConfigProxyClient(cc *grpc.ClientConn) NetworkConfigProxyClient {
1334 return &networkConfigProxyClient{cc}
1335 }
1336
1337 func (c *networkConfigProxyClient) AddNIC(ctx context.Context, in *AddNICRequest, opts ...grpc.CallOption) (*AddNICResponse, error) {
1338 out := new(AddNICResponse)
1339 err := c.cc.Invoke(ctx, "/ncproxygrpc.NetworkConfigProxy/AddNIC", in, out, opts...)
1340 if err != nil {
1341 return nil, err
1342 }
1343 return out, nil
1344 }
1345
1346 func (c *networkConfigProxyClient) ModifyNIC(ctx context.Context, in *ModifyNICRequest, opts ...grpc.CallOption) (*ModifyNICResponse, error) {
1347 out := new(ModifyNICResponse)
1348 err := c.cc.Invoke(ctx, "/ncproxygrpc.NetworkConfigProxy/ModifyNIC", in, out, opts...)
1349 if err != nil {
1350 return nil, err
1351 }
1352 return out, nil
1353 }
1354
1355 func (c *networkConfigProxyClient) DeleteNIC(ctx context.Context, in *DeleteNICRequest, opts ...grpc.CallOption) (*DeleteNICResponse, error) {
1356 out := new(DeleteNICResponse)
1357 err := c.cc.Invoke(ctx, "/ncproxygrpc.NetworkConfigProxy/DeleteNIC", in, out, opts...)
1358 if err != nil {
1359 return nil, err
1360 }
1361 return out, nil
1362 }
1363
1364 func (c *networkConfigProxyClient) CreateNetwork(ctx context.Context, in *CreateNetworkRequest, opts ...grpc.CallOption) (*CreateNetworkResponse, error) {
1365 out := new(CreateNetworkResponse)
1366 err := c.cc.Invoke(ctx, "/ncproxygrpc.NetworkConfigProxy/CreateNetwork", in, out, opts...)
1367 if err != nil {
1368 return nil, err
1369 }
1370 return out, nil
1371 }
1372
1373 func (c *networkConfigProxyClient) CreateEndpoint(ctx context.Context, in *CreateEndpointRequest, opts ...grpc.CallOption) (*CreateEndpointResponse, error) {
1374 out := new(CreateEndpointResponse)
1375 err := c.cc.Invoke(ctx, "/ncproxygrpc.NetworkConfigProxy/CreateEndpoint", in, out, opts...)
1376 if err != nil {
1377 return nil, err
1378 }
1379 return out, nil
1380 }
1381
1382 func (c *networkConfigProxyClient) AddEndpoint(ctx context.Context, in *AddEndpointRequest, opts ...grpc.CallOption) (*AddEndpointResponse, error) {
1383 out := new(AddEndpointResponse)
1384 err := c.cc.Invoke(ctx, "/ncproxygrpc.NetworkConfigProxy/AddEndpoint", in, out, opts...)
1385 if err != nil {
1386 return nil, err
1387 }
1388 return out, nil
1389 }
1390
1391 func (c *networkConfigProxyClient) DeleteEndpoint(ctx context.Context, in *DeleteEndpointRequest, opts ...grpc.CallOption) (*DeleteEndpointResponse, error) {
1392 out := new(DeleteEndpointResponse)
1393 err := c.cc.Invoke(ctx, "/ncproxygrpc.NetworkConfigProxy/DeleteEndpoint", in, out, opts...)
1394 if err != nil {
1395 return nil, err
1396 }
1397 return out, nil
1398 }
1399
1400 func (c *networkConfigProxyClient) DeleteNetwork(ctx context.Context, in *DeleteNetworkRequest, opts ...grpc.CallOption) (*DeleteNetworkResponse, error) {
1401 out := new(DeleteNetworkResponse)
1402 err := c.cc.Invoke(ctx, "/ncproxygrpc.NetworkConfigProxy/DeleteNetwork", in, out, opts...)
1403 if err != nil {
1404 return nil, err
1405 }
1406 return out, nil
1407 }
1408
1409 func (c *networkConfigProxyClient) GetEndpoint(ctx context.Context, in *GetEndpointRequest, opts ...grpc.CallOption) (*GetEndpointResponse, error) {
1410 out := new(GetEndpointResponse)
1411 err := c.cc.Invoke(ctx, "/ncproxygrpc.NetworkConfigProxy/GetEndpoint", in, out, opts...)
1412 if err != nil {
1413 return nil, err
1414 }
1415 return out, nil
1416 }
1417
1418 func (c *networkConfigProxyClient) GetNetwork(ctx context.Context, in *GetNetworkRequest, opts ...grpc.CallOption) (*GetNetworkResponse, error) {
1419 out := new(GetNetworkResponse)
1420 err := c.cc.Invoke(ctx, "/ncproxygrpc.NetworkConfigProxy/GetNetwork", in, out, opts...)
1421 if err != nil {
1422 return nil, err
1423 }
1424 return out, nil
1425 }
1426
1427 func (c *networkConfigProxyClient) GetEndpoints(ctx context.Context, in *GetEndpointsRequest, opts ...grpc.CallOption) (*GetEndpointsResponse, error) {
1428 out := new(GetEndpointsResponse)
1429 err := c.cc.Invoke(ctx, "/ncproxygrpc.NetworkConfigProxy/GetEndpoints", in, out, opts...)
1430 if err != nil {
1431 return nil, err
1432 }
1433 return out, nil
1434 }
1435
1436 func (c *networkConfigProxyClient) GetNetworks(ctx context.Context, in *GetNetworksRequest, opts ...grpc.CallOption) (*GetNetworksResponse, error) {
1437 out := new(GetNetworksResponse)
1438 err := c.cc.Invoke(ctx, "/ncproxygrpc.NetworkConfigProxy/GetNetworks", in, out, opts...)
1439 if err != nil {
1440 return nil, err
1441 }
1442 return out, nil
1443 }
1444
1445
1446 type NetworkConfigProxyServer interface {
1447 AddNIC(context.Context, *AddNICRequest) (*AddNICResponse, error)
1448 ModifyNIC(context.Context, *ModifyNICRequest) (*ModifyNICResponse, error)
1449 DeleteNIC(context.Context, *DeleteNICRequest) (*DeleteNICResponse, error)
1450 CreateNetwork(context.Context, *CreateNetworkRequest) (*CreateNetworkResponse, error)
1451 CreateEndpoint(context.Context, *CreateEndpointRequest) (*CreateEndpointResponse, error)
1452 AddEndpoint(context.Context, *AddEndpointRequest) (*AddEndpointResponse, error)
1453 DeleteEndpoint(context.Context, *DeleteEndpointRequest) (*DeleteEndpointResponse, error)
1454 DeleteNetwork(context.Context, *DeleteNetworkRequest) (*DeleteNetworkResponse, error)
1455 GetEndpoint(context.Context, *GetEndpointRequest) (*GetEndpointResponse, error)
1456 GetNetwork(context.Context, *GetNetworkRequest) (*GetNetworkResponse, error)
1457 GetEndpoints(context.Context, *GetEndpointsRequest) (*GetEndpointsResponse, error)
1458 GetNetworks(context.Context, *GetNetworksRequest) (*GetNetworksResponse, error)
1459 }
1460
1461
1462 type UnimplementedNetworkConfigProxyServer struct {
1463 }
1464
1465 func (*UnimplementedNetworkConfigProxyServer) AddNIC(ctx context.Context, req *AddNICRequest) (*AddNICResponse, error) {
1466 return nil, status.Errorf(codes.Unimplemented, "method AddNIC not implemented")
1467 }
1468 func (*UnimplementedNetworkConfigProxyServer) ModifyNIC(ctx context.Context, req *ModifyNICRequest) (*ModifyNICResponse, error) {
1469 return nil, status.Errorf(codes.Unimplemented, "method ModifyNIC not implemented")
1470 }
1471 func (*UnimplementedNetworkConfigProxyServer) DeleteNIC(ctx context.Context, req *DeleteNICRequest) (*DeleteNICResponse, error) {
1472 return nil, status.Errorf(codes.Unimplemented, "method DeleteNIC not implemented")
1473 }
1474 func (*UnimplementedNetworkConfigProxyServer) CreateNetwork(ctx context.Context, req *CreateNetworkRequest) (*CreateNetworkResponse, error) {
1475 return nil, status.Errorf(codes.Unimplemented, "method CreateNetwork not implemented")
1476 }
1477 func (*UnimplementedNetworkConfigProxyServer) CreateEndpoint(ctx context.Context, req *CreateEndpointRequest) (*CreateEndpointResponse, error) {
1478 return nil, status.Errorf(codes.Unimplemented, "method CreateEndpoint not implemented")
1479 }
1480 func (*UnimplementedNetworkConfigProxyServer) AddEndpoint(ctx context.Context, req *AddEndpointRequest) (*AddEndpointResponse, error) {
1481 return nil, status.Errorf(codes.Unimplemented, "method AddEndpoint not implemented")
1482 }
1483 func (*UnimplementedNetworkConfigProxyServer) DeleteEndpoint(ctx context.Context, req *DeleteEndpointRequest) (*DeleteEndpointResponse, error) {
1484 return nil, status.Errorf(codes.Unimplemented, "method DeleteEndpoint not implemented")
1485 }
1486 func (*UnimplementedNetworkConfigProxyServer) DeleteNetwork(ctx context.Context, req *DeleteNetworkRequest) (*DeleteNetworkResponse, error) {
1487 return nil, status.Errorf(codes.Unimplemented, "method DeleteNetwork not implemented")
1488 }
1489 func (*UnimplementedNetworkConfigProxyServer) GetEndpoint(ctx context.Context, req *GetEndpointRequest) (*GetEndpointResponse, error) {
1490 return nil, status.Errorf(codes.Unimplemented, "method GetEndpoint not implemented")
1491 }
1492 func (*UnimplementedNetworkConfigProxyServer) GetNetwork(ctx context.Context, req *GetNetworkRequest) (*GetNetworkResponse, error) {
1493 return nil, status.Errorf(codes.Unimplemented, "method GetNetwork not implemented")
1494 }
1495 func (*UnimplementedNetworkConfigProxyServer) GetEndpoints(ctx context.Context, req *GetEndpointsRequest) (*GetEndpointsResponse, error) {
1496 return nil, status.Errorf(codes.Unimplemented, "method GetEndpoints not implemented")
1497 }
1498 func (*UnimplementedNetworkConfigProxyServer) GetNetworks(ctx context.Context, req *GetNetworksRequest) (*GetNetworksResponse, error) {
1499 return nil, status.Errorf(codes.Unimplemented, "method GetNetworks not implemented")
1500 }
1501
1502 func RegisterNetworkConfigProxyServer(s *grpc.Server, srv NetworkConfigProxyServer) {
1503 s.RegisterService(&_NetworkConfigProxy_serviceDesc, srv)
1504 }
1505
1506 func _NetworkConfigProxy_AddNIC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1507 in := new(AddNICRequest)
1508 if err := dec(in); err != nil {
1509 return nil, err
1510 }
1511 if interceptor == nil {
1512 return srv.(NetworkConfigProxyServer).AddNIC(ctx, in)
1513 }
1514 info := &grpc.UnaryServerInfo{
1515 Server: srv,
1516 FullMethod: "/ncproxygrpc.NetworkConfigProxy/AddNIC",
1517 }
1518 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1519 return srv.(NetworkConfigProxyServer).AddNIC(ctx, req.(*AddNICRequest))
1520 }
1521 return interceptor(ctx, in, info, handler)
1522 }
1523
1524 func _NetworkConfigProxy_ModifyNIC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1525 in := new(ModifyNICRequest)
1526 if err := dec(in); err != nil {
1527 return nil, err
1528 }
1529 if interceptor == nil {
1530 return srv.(NetworkConfigProxyServer).ModifyNIC(ctx, in)
1531 }
1532 info := &grpc.UnaryServerInfo{
1533 Server: srv,
1534 FullMethod: "/ncproxygrpc.NetworkConfigProxy/ModifyNIC",
1535 }
1536 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1537 return srv.(NetworkConfigProxyServer).ModifyNIC(ctx, req.(*ModifyNICRequest))
1538 }
1539 return interceptor(ctx, in, info, handler)
1540 }
1541
1542 func _NetworkConfigProxy_DeleteNIC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1543 in := new(DeleteNICRequest)
1544 if err := dec(in); err != nil {
1545 return nil, err
1546 }
1547 if interceptor == nil {
1548 return srv.(NetworkConfigProxyServer).DeleteNIC(ctx, in)
1549 }
1550 info := &grpc.UnaryServerInfo{
1551 Server: srv,
1552 FullMethod: "/ncproxygrpc.NetworkConfigProxy/DeleteNIC",
1553 }
1554 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1555 return srv.(NetworkConfigProxyServer).DeleteNIC(ctx, req.(*DeleteNICRequest))
1556 }
1557 return interceptor(ctx, in, info, handler)
1558 }
1559
1560 func _NetworkConfigProxy_CreateNetwork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1561 in := new(CreateNetworkRequest)
1562 if err := dec(in); err != nil {
1563 return nil, err
1564 }
1565 if interceptor == nil {
1566 return srv.(NetworkConfigProxyServer).CreateNetwork(ctx, in)
1567 }
1568 info := &grpc.UnaryServerInfo{
1569 Server: srv,
1570 FullMethod: "/ncproxygrpc.NetworkConfigProxy/CreateNetwork",
1571 }
1572 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1573 return srv.(NetworkConfigProxyServer).CreateNetwork(ctx, req.(*CreateNetworkRequest))
1574 }
1575 return interceptor(ctx, in, info, handler)
1576 }
1577
1578 func _NetworkConfigProxy_CreateEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1579 in := new(CreateEndpointRequest)
1580 if err := dec(in); err != nil {
1581 return nil, err
1582 }
1583 if interceptor == nil {
1584 return srv.(NetworkConfigProxyServer).CreateEndpoint(ctx, in)
1585 }
1586 info := &grpc.UnaryServerInfo{
1587 Server: srv,
1588 FullMethod: "/ncproxygrpc.NetworkConfigProxy/CreateEndpoint",
1589 }
1590 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1591 return srv.(NetworkConfigProxyServer).CreateEndpoint(ctx, req.(*CreateEndpointRequest))
1592 }
1593 return interceptor(ctx, in, info, handler)
1594 }
1595
1596 func _NetworkConfigProxy_AddEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1597 in := new(AddEndpointRequest)
1598 if err := dec(in); err != nil {
1599 return nil, err
1600 }
1601 if interceptor == nil {
1602 return srv.(NetworkConfigProxyServer).AddEndpoint(ctx, in)
1603 }
1604 info := &grpc.UnaryServerInfo{
1605 Server: srv,
1606 FullMethod: "/ncproxygrpc.NetworkConfigProxy/AddEndpoint",
1607 }
1608 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1609 return srv.(NetworkConfigProxyServer).AddEndpoint(ctx, req.(*AddEndpointRequest))
1610 }
1611 return interceptor(ctx, in, info, handler)
1612 }
1613
1614 func _NetworkConfigProxy_DeleteEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1615 in := new(DeleteEndpointRequest)
1616 if err := dec(in); err != nil {
1617 return nil, err
1618 }
1619 if interceptor == nil {
1620 return srv.(NetworkConfigProxyServer).DeleteEndpoint(ctx, in)
1621 }
1622 info := &grpc.UnaryServerInfo{
1623 Server: srv,
1624 FullMethod: "/ncproxygrpc.NetworkConfigProxy/DeleteEndpoint",
1625 }
1626 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1627 return srv.(NetworkConfigProxyServer).DeleteEndpoint(ctx, req.(*DeleteEndpointRequest))
1628 }
1629 return interceptor(ctx, in, info, handler)
1630 }
1631
1632 func _NetworkConfigProxy_DeleteNetwork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1633 in := new(DeleteNetworkRequest)
1634 if err := dec(in); err != nil {
1635 return nil, err
1636 }
1637 if interceptor == nil {
1638 return srv.(NetworkConfigProxyServer).DeleteNetwork(ctx, in)
1639 }
1640 info := &grpc.UnaryServerInfo{
1641 Server: srv,
1642 FullMethod: "/ncproxygrpc.NetworkConfigProxy/DeleteNetwork",
1643 }
1644 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1645 return srv.(NetworkConfigProxyServer).DeleteNetwork(ctx, req.(*DeleteNetworkRequest))
1646 }
1647 return interceptor(ctx, in, info, handler)
1648 }
1649
1650 func _NetworkConfigProxy_GetEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1651 in := new(GetEndpointRequest)
1652 if err := dec(in); err != nil {
1653 return nil, err
1654 }
1655 if interceptor == nil {
1656 return srv.(NetworkConfigProxyServer).GetEndpoint(ctx, in)
1657 }
1658 info := &grpc.UnaryServerInfo{
1659 Server: srv,
1660 FullMethod: "/ncproxygrpc.NetworkConfigProxy/GetEndpoint",
1661 }
1662 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1663 return srv.(NetworkConfigProxyServer).GetEndpoint(ctx, req.(*GetEndpointRequest))
1664 }
1665 return interceptor(ctx, in, info, handler)
1666 }
1667
1668 func _NetworkConfigProxy_GetNetwork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1669 in := new(GetNetworkRequest)
1670 if err := dec(in); err != nil {
1671 return nil, err
1672 }
1673 if interceptor == nil {
1674 return srv.(NetworkConfigProxyServer).GetNetwork(ctx, in)
1675 }
1676 info := &grpc.UnaryServerInfo{
1677 Server: srv,
1678 FullMethod: "/ncproxygrpc.NetworkConfigProxy/GetNetwork",
1679 }
1680 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1681 return srv.(NetworkConfigProxyServer).GetNetwork(ctx, req.(*GetNetworkRequest))
1682 }
1683 return interceptor(ctx, in, info, handler)
1684 }
1685
1686 func _NetworkConfigProxy_GetEndpoints_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1687 in := new(GetEndpointsRequest)
1688 if err := dec(in); err != nil {
1689 return nil, err
1690 }
1691 if interceptor == nil {
1692 return srv.(NetworkConfigProxyServer).GetEndpoints(ctx, in)
1693 }
1694 info := &grpc.UnaryServerInfo{
1695 Server: srv,
1696 FullMethod: "/ncproxygrpc.NetworkConfigProxy/GetEndpoints",
1697 }
1698 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1699 return srv.(NetworkConfigProxyServer).GetEndpoints(ctx, req.(*GetEndpointsRequest))
1700 }
1701 return interceptor(ctx, in, info, handler)
1702 }
1703
1704 func _NetworkConfigProxy_GetNetworks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1705 in := new(GetNetworksRequest)
1706 if err := dec(in); err != nil {
1707 return nil, err
1708 }
1709 if interceptor == nil {
1710 return srv.(NetworkConfigProxyServer).GetNetworks(ctx, in)
1711 }
1712 info := &grpc.UnaryServerInfo{
1713 Server: srv,
1714 FullMethod: "/ncproxygrpc.NetworkConfigProxy/GetNetworks",
1715 }
1716 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1717 return srv.(NetworkConfigProxyServer).GetNetworks(ctx, req.(*GetNetworksRequest))
1718 }
1719 return interceptor(ctx, in, info, handler)
1720 }
1721
1722 var _NetworkConfigProxy_serviceDesc = grpc.ServiceDesc{
1723 ServiceName: "ncproxygrpc.NetworkConfigProxy",
1724 HandlerType: (*NetworkConfigProxyServer)(nil),
1725 Methods: []grpc.MethodDesc{
1726 {
1727 MethodName: "AddNIC",
1728 Handler: _NetworkConfigProxy_AddNIC_Handler,
1729 },
1730 {
1731 MethodName: "ModifyNIC",
1732 Handler: _NetworkConfigProxy_ModifyNIC_Handler,
1733 },
1734 {
1735 MethodName: "DeleteNIC",
1736 Handler: _NetworkConfigProxy_DeleteNIC_Handler,
1737 },
1738 {
1739 MethodName: "CreateNetwork",
1740 Handler: _NetworkConfigProxy_CreateNetwork_Handler,
1741 },
1742 {
1743 MethodName: "CreateEndpoint",
1744 Handler: _NetworkConfigProxy_CreateEndpoint_Handler,
1745 },
1746 {
1747 MethodName: "AddEndpoint",
1748 Handler: _NetworkConfigProxy_AddEndpoint_Handler,
1749 },
1750 {
1751 MethodName: "DeleteEndpoint",
1752 Handler: _NetworkConfigProxy_DeleteEndpoint_Handler,
1753 },
1754 {
1755 MethodName: "DeleteNetwork",
1756 Handler: _NetworkConfigProxy_DeleteNetwork_Handler,
1757 },
1758 {
1759 MethodName: "GetEndpoint",
1760 Handler: _NetworkConfigProxy_GetEndpoint_Handler,
1761 },
1762 {
1763 MethodName: "GetNetwork",
1764 Handler: _NetworkConfigProxy_GetNetwork_Handler,
1765 },
1766 {
1767 MethodName: "GetEndpoints",
1768 Handler: _NetworkConfigProxy_GetEndpoints_Handler,
1769 },
1770 {
1771 MethodName: "GetNetworks",
1772 Handler: _NetworkConfigProxy_GetNetworks_Handler,
1773 },
1774 },
1775 Streams: []grpc.StreamDesc{},
1776 Metadata: "github.com/Microsoft/hcsshim/pkg/ncproxy/ncproxygrpc/v0/networkconfigproxy.proto",
1777 }
1778
1779 func (m *AddNICRequest) Marshal() (dAtA []byte, err error) {
1780 size := m.Size()
1781 dAtA = make([]byte, size)
1782 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1783 if err != nil {
1784 return nil, err
1785 }
1786 return dAtA[:n], nil
1787 }
1788
1789 func (m *AddNICRequest) MarshalTo(dAtA []byte) (int, error) {
1790 size := m.Size()
1791 return m.MarshalToSizedBuffer(dAtA[:size])
1792 }
1793
1794 func (m *AddNICRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1795 i := len(dAtA)
1796 _ = i
1797 var l int
1798 _ = l
1799 if m.XXX_unrecognized != nil {
1800 i -= len(m.XXX_unrecognized)
1801 copy(dAtA[i:], m.XXX_unrecognized)
1802 }
1803 if len(m.EndpointName) > 0 {
1804 i -= len(m.EndpointName)
1805 copy(dAtA[i:], m.EndpointName)
1806 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.EndpointName)))
1807 i--
1808 dAtA[i] = 0x1a
1809 }
1810 if len(m.NicID) > 0 {
1811 i -= len(m.NicID)
1812 copy(dAtA[i:], m.NicID)
1813 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.NicID)))
1814 i--
1815 dAtA[i] = 0x12
1816 }
1817 if len(m.ContainerID) > 0 {
1818 i -= len(m.ContainerID)
1819 copy(dAtA[i:], m.ContainerID)
1820 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ContainerID)))
1821 i--
1822 dAtA[i] = 0xa
1823 }
1824 return len(dAtA) - i, nil
1825 }
1826
1827 func (m *AddNICResponse) Marshal() (dAtA []byte, err error) {
1828 size := m.Size()
1829 dAtA = make([]byte, size)
1830 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1831 if err != nil {
1832 return nil, err
1833 }
1834 return dAtA[:n], nil
1835 }
1836
1837 func (m *AddNICResponse) MarshalTo(dAtA []byte) (int, error) {
1838 size := m.Size()
1839 return m.MarshalToSizedBuffer(dAtA[:size])
1840 }
1841
1842 func (m *AddNICResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1843 i := len(dAtA)
1844 _ = i
1845 var l int
1846 _ = l
1847 if m.XXX_unrecognized != nil {
1848 i -= len(m.XXX_unrecognized)
1849 copy(dAtA[i:], m.XXX_unrecognized)
1850 }
1851 return len(dAtA) - i, nil
1852 }
1853
1854 func (m *ModifyNICRequest) Marshal() (dAtA []byte, err error) {
1855 size := m.Size()
1856 dAtA = make([]byte, size)
1857 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1858 if err != nil {
1859 return nil, err
1860 }
1861 return dAtA[:n], nil
1862 }
1863
1864 func (m *ModifyNICRequest) MarshalTo(dAtA []byte) (int, error) {
1865 size := m.Size()
1866 return m.MarshalToSizedBuffer(dAtA[:size])
1867 }
1868
1869 func (m *ModifyNICRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1870 i := len(dAtA)
1871 _ = i
1872 var l int
1873 _ = l
1874 if m.XXX_unrecognized != nil {
1875 i -= len(m.XXX_unrecognized)
1876 copy(dAtA[i:], m.XXX_unrecognized)
1877 }
1878 if m.IovPolicySettings != nil {
1879 {
1880 size, err := m.IovPolicySettings.MarshalToSizedBuffer(dAtA[:i])
1881 if err != nil {
1882 return 0, err
1883 }
1884 i -= size
1885 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
1886 }
1887 i--
1888 dAtA[i] = 0x22
1889 }
1890 if len(m.EndpointName) > 0 {
1891 i -= len(m.EndpointName)
1892 copy(dAtA[i:], m.EndpointName)
1893 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.EndpointName)))
1894 i--
1895 dAtA[i] = 0x1a
1896 }
1897 if len(m.NicID) > 0 {
1898 i -= len(m.NicID)
1899 copy(dAtA[i:], m.NicID)
1900 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.NicID)))
1901 i--
1902 dAtA[i] = 0x12
1903 }
1904 if len(m.ContainerID) > 0 {
1905 i -= len(m.ContainerID)
1906 copy(dAtA[i:], m.ContainerID)
1907 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ContainerID)))
1908 i--
1909 dAtA[i] = 0xa
1910 }
1911 return len(dAtA) - i, nil
1912 }
1913
1914 func (m *ModifyNICResponse) Marshal() (dAtA []byte, err error) {
1915 size := m.Size()
1916 dAtA = make([]byte, size)
1917 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1918 if err != nil {
1919 return nil, err
1920 }
1921 return dAtA[:n], nil
1922 }
1923
1924 func (m *ModifyNICResponse) MarshalTo(dAtA []byte) (int, error) {
1925 size := m.Size()
1926 return m.MarshalToSizedBuffer(dAtA[:size])
1927 }
1928
1929 func (m *ModifyNICResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1930 i := len(dAtA)
1931 _ = i
1932 var l int
1933 _ = l
1934 if m.XXX_unrecognized != nil {
1935 i -= len(m.XXX_unrecognized)
1936 copy(dAtA[i:], m.XXX_unrecognized)
1937 }
1938 return len(dAtA) - i, nil
1939 }
1940
1941 func (m *DeleteNICRequest) Marshal() (dAtA []byte, err error) {
1942 size := m.Size()
1943 dAtA = make([]byte, size)
1944 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1945 if err != nil {
1946 return nil, err
1947 }
1948 return dAtA[:n], nil
1949 }
1950
1951 func (m *DeleteNICRequest) MarshalTo(dAtA []byte) (int, error) {
1952 size := m.Size()
1953 return m.MarshalToSizedBuffer(dAtA[:size])
1954 }
1955
1956 func (m *DeleteNICRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1957 i := len(dAtA)
1958 _ = i
1959 var l int
1960 _ = l
1961 if m.XXX_unrecognized != nil {
1962 i -= len(m.XXX_unrecognized)
1963 copy(dAtA[i:], m.XXX_unrecognized)
1964 }
1965 if len(m.EndpointName) > 0 {
1966 i -= len(m.EndpointName)
1967 copy(dAtA[i:], m.EndpointName)
1968 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.EndpointName)))
1969 i--
1970 dAtA[i] = 0x1a
1971 }
1972 if len(m.NicID) > 0 {
1973 i -= len(m.NicID)
1974 copy(dAtA[i:], m.NicID)
1975 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.NicID)))
1976 i--
1977 dAtA[i] = 0x12
1978 }
1979 if len(m.ContainerID) > 0 {
1980 i -= len(m.ContainerID)
1981 copy(dAtA[i:], m.ContainerID)
1982 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ContainerID)))
1983 i--
1984 dAtA[i] = 0xa
1985 }
1986 return len(dAtA) - i, nil
1987 }
1988
1989 func (m *DeleteNICResponse) Marshal() (dAtA []byte, err error) {
1990 size := m.Size()
1991 dAtA = make([]byte, size)
1992 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1993 if err != nil {
1994 return nil, err
1995 }
1996 return dAtA[:n], nil
1997 }
1998
1999 func (m *DeleteNICResponse) MarshalTo(dAtA []byte) (int, error) {
2000 size := m.Size()
2001 return m.MarshalToSizedBuffer(dAtA[:size])
2002 }
2003
2004 func (m *DeleteNICResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2005 i := len(dAtA)
2006 _ = i
2007 var l int
2008 _ = l
2009 if m.XXX_unrecognized != nil {
2010 i -= len(m.XXX_unrecognized)
2011 copy(dAtA[i:], m.XXX_unrecognized)
2012 }
2013 return len(dAtA) - i, nil
2014 }
2015
2016 func (m *CreateNetworkRequest) Marshal() (dAtA []byte, err error) {
2017 size := m.Size()
2018 dAtA = make([]byte, size)
2019 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2020 if err != nil {
2021 return nil, err
2022 }
2023 return dAtA[:n], nil
2024 }
2025
2026 func (m *CreateNetworkRequest) MarshalTo(dAtA []byte) (int, error) {
2027 size := m.Size()
2028 return m.MarshalToSizedBuffer(dAtA[:size])
2029 }
2030
2031 func (m *CreateNetworkRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2032 i := len(dAtA)
2033 _ = i
2034 var l int
2035 _ = l
2036 if m.XXX_unrecognized != nil {
2037 i -= len(m.XXX_unrecognized)
2038 copy(dAtA[i:], m.XXX_unrecognized)
2039 }
2040 if len(m.DefaultGateway) > 0 {
2041 i -= len(m.DefaultGateway)
2042 copy(dAtA[i:], m.DefaultGateway)
2043 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.DefaultGateway)))
2044 i--
2045 dAtA[i] = 0x32
2046 }
2047 if len(m.SubnetIpaddressPrefix) > 0 {
2048 for iNdEx := len(m.SubnetIpaddressPrefix) - 1; iNdEx >= 0; iNdEx-- {
2049 i -= len(m.SubnetIpaddressPrefix[iNdEx])
2050 copy(dAtA[i:], m.SubnetIpaddressPrefix[iNdEx])
2051 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.SubnetIpaddressPrefix[iNdEx])))
2052 i--
2053 dAtA[i] = 0x2a
2054 }
2055 }
2056 if m.IpamType != 0 {
2057 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.IpamType))
2058 i--
2059 dAtA[i] = 0x20
2060 }
2061 if len(m.SwitchName) > 0 {
2062 i -= len(m.SwitchName)
2063 copy(dAtA[i:], m.SwitchName)
2064 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.SwitchName)))
2065 i--
2066 dAtA[i] = 0x1a
2067 }
2068 if m.Mode != 0 {
2069 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.Mode))
2070 i--
2071 dAtA[i] = 0x10
2072 }
2073 if len(m.Name) > 0 {
2074 i -= len(m.Name)
2075 copy(dAtA[i:], m.Name)
2076 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
2077 i--
2078 dAtA[i] = 0xa
2079 }
2080 return len(dAtA) - i, nil
2081 }
2082
2083 func (m *CreateNetworkResponse) Marshal() (dAtA []byte, err error) {
2084 size := m.Size()
2085 dAtA = make([]byte, size)
2086 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2087 if err != nil {
2088 return nil, err
2089 }
2090 return dAtA[:n], nil
2091 }
2092
2093 func (m *CreateNetworkResponse) MarshalTo(dAtA []byte) (int, error) {
2094 size := m.Size()
2095 return m.MarshalToSizedBuffer(dAtA[:size])
2096 }
2097
2098 func (m *CreateNetworkResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2099 i := len(dAtA)
2100 _ = i
2101 var l int
2102 _ = l
2103 if m.XXX_unrecognized != nil {
2104 i -= len(m.XXX_unrecognized)
2105 copy(dAtA[i:], m.XXX_unrecognized)
2106 }
2107 if len(m.ID) > 0 {
2108 i -= len(m.ID)
2109 copy(dAtA[i:], m.ID)
2110 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ID)))
2111 i--
2112 dAtA[i] = 0xa
2113 }
2114 return len(dAtA) - i, nil
2115 }
2116
2117 func (m *PortNameEndpointPolicySetting) Marshal() (dAtA []byte, err error) {
2118 size := m.Size()
2119 dAtA = make([]byte, size)
2120 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2121 if err != nil {
2122 return nil, err
2123 }
2124 return dAtA[:n], nil
2125 }
2126
2127 func (m *PortNameEndpointPolicySetting) MarshalTo(dAtA []byte) (int, error) {
2128 size := m.Size()
2129 return m.MarshalToSizedBuffer(dAtA[:size])
2130 }
2131
2132 func (m *PortNameEndpointPolicySetting) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2133 i := len(dAtA)
2134 _ = i
2135 var l int
2136 _ = l
2137 if m.XXX_unrecognized != nil {
2138 i -= len(m.XXX_unrecognized)
2139 copy(dAtA[i:], m.XXX_unrecognized)
2140 }
2141 if len(m.PortName) > 0 {
2142 i -= len(m.PortName)
2143 copy(dAtA[i:], m.PortName)
2144 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.PortName)))
2145 i--
2146 dAtA[i] = 0xa
2147 }
2148 return len(dAtA) - i, nil
2149 }
2150
2151 func (m *IovEndpointPolicySetting) Marshal() (dAtA []byte, err error) {
2152 size := m.Size()
2153 dAtA = make([]byte, size)
2154 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2155 if err != nil {
2156 return nil, err
2157 }
2158 return dAtA[:n], nil
2159 }
2160
2161 func (m *IovEndpointPolicySetting) MarshalTo(dAtA []byte) (int, error) {
2162 size := m.Size()
2163 return m.MarshalToSizedBuffer(dAtA[:size])
2164 }
2165
2166 func (m *IovEndpointPolicySetting) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2167 i := len(dAtA)
2168 _ = i
2169 var l int
2170 _ = l
2171 if m.XXX_unrecognized != nil {
2172 i -= len(m.XXX_unrecognized)
2173 copy(dAtA[i:], m.XXX_unrecognized)
2174 }
2175 if m.InterruptModeration != 0 {
2176 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.InterruptModeration))
2177 i--
2178 dAtA[i] = 0x18
2179 }
2180 if m.QueuePairsRequested != 0 {
2181 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.QueuePairsRequested))
2182 i--
2183 dAtA[i] = 0x10
2184 }
2185 if m.IovOffloadWeight != 0 {
2186 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.IovOffloadWeight))
2187 i--
2188 dAtA[i] = 0x8
2189 }
2190 return len(dAtA) - i, nil
2191 }
2192
2193 func (m *DnsSetting) Marshal() (dAtA []byte, err error) {
2194 size := m.Size()
2195 dAtA = make([]byte, size)
2196 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2197 if err != nil {
2198 return nil, err
2199 }
2200 return dAtA[:n], nil
2201 }
2202
2203 func (m *DnsSetting) MarshalTo(dAtA []byte) (int, error) {
2204 size := m.Size()
2205 return m.MarshalToSizedBuffer(dAtA[:size])
2206 }
2207
2208 func (m *DnsSetting) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2209 i := len(dAtA)
2210 _ = i
2211 var l int
2212 _ = l
2213 if m.XXX_unrecognized != nil {
2214 i -= len(m.XXX_unrecognized)
2215 copy(dAtA[i:], m.XXX_unrecognized)
2216 }
2217 if len(m.Search) > 0 {
2218 for iNdEx := len(m.Search) - 1; iNdEx >= 0; iNdEx-- {
2219 i -= len(m.Search[iNdEx])
2220 copy(dAtA[i:], m.Search[iNdEx])
2221 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Search[iNdEx])))
2222 i--
2223 dAtA[i] = 0x1a
2224 }
2225 }
2226 if len(m.Domain) > 0 {
2227 i -= len(m.Domain)
2228 copy(dAtA[i:], m.Domain)
2229 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Domain)))
2230 i--
2231 dAtA[i] = 0x12
2232 }
2233 if len(m.ServerIpAddrs) > 0 {
2234 for iNdEx := len(m.ServerIpAddrs) - 1; iNdEx >= 0; iNdEx-- {
2235 i -= len(m.ServerIpAddrs[iNdEx])
2236 copy(dAtA[i:], m.ServerIpAddrs[iNdEx])
2237 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ServerIpAddrs[iNdEx])))
2238 i--
2239 dAtA[i] = 0xa
2240 }
2241 }
2242 return len(dAtA) - i, nil
2243 }
2244
2245 func (m *CreateEndpointRequest) Marshal() (dAtA []byte, err error) {
2246 size := m.Size()
2247 dAtA = make([]byte, size)
2248 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2249 if err != nil {
2250 return nil, err
2251 }
2252 return dAtA[:n], nil
2253 }
2254
2255 func (m *CreateEndpointRequest) MarshalTo(dAtA []byte) (int, error) {
2256 size := m.Size()
2257 return m.MarshalToSizedBuffer(dAtA[:size])
2258 }
2259
2260 func (m *CreateEndpointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2261 i := len(dAtA)
2262 _ = i
2263 var l int
2264 _ = l
2265 if m.XXX_unrecognized != nil {
2266 i -= len(m.XXX_unrecognized)
2267 copy(dAtA[i:], m.XXX_unrecognized)
2268 }
2269 if m.DnsSetting != nil {
2270 {
2271 size, err := m.DnsSetting.MarshalToSizedBuffer(dAtA[:i])
2272 if err != nil {
2273 return 0, err
2274 }
2275 i -= size
2276 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
2277 }
2278 i--
2279 dAtA[i] = 0x1
2280 i--
2281 dAtA[i] = 0x82
2282 }
2283 if m.IovPolicySettings != nil {
2284 {
2285 size, err := m.IovPolicySettings.MarshalToSizedBuffer(dAtA[:i])
2286 if err != nil {
2287 return 0, err
2288 }
2289 i -= size
2290 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
2291 }
2292 i--
2293 dAtA[i] = 0x3a
2294 }
2295 if m.PortnamePolicySetting != nil {
2296 {
2297 size, err := m.PortnamePolicySetting.MarshalToSizedBuffer(dAtA[:i])
2298 if err != nil {
2299 return 0, err
2300 }
2301 i -= size
2302 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
2303 }
2304 i--
2305 dAtA[i] = 0x32
2306 }
2307 if len(m.NetworkName) > 0 {
2308 i -= len(m.NetworkName)
2309 copy(dAtA[i:], m.NetworkName)
2310 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.NetworkName)))
2311 i--
2312 dAtA[i] = 0x2a
2313 }
2314 if len(m.IpaddressPrefixlength) > 0 {
2315 i -= len(m.IpaddressPrefixlength)
2316 copy(dAtA[i:], m.IpaddressPrefixlength)
2317 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.IpaddressPrefixlength)))
2318 i--
2319 dAtA[i] = 0x22
2320 }
2321 if len(m.Ipaddress) > 0 {
2322 i -= len(m.Ipaddress)
2323 copy(dAtA[i:], m.Ipaddress)
2324 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Ipaddress)))
2325 i--
2326 dAtA[i] = 0x1a
2327 }
2328 if len(m.Macaddress) > 0 {
2329 i -= len(m.Macaddress)
2330 copy(dAtA[i:], m.Macaddress)
2331 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Macaddress)))
2332 i--
2333 dAtA[i] = 0x12
2334 }
2335 if len(m.Name) > 0 {
2336 i -= len(m.Name)
2337 copy(dAtA[i:], m.Name)
2338 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
2339 i--
2340 dAtA[i] = 0xa
2341 }
2342 return len(dAtA) - i, nil
2343 }
2344
2345 func (m *CreateEndpointResponse) Marshal() (dAtA []byte, err error) {
2346 size := m.Size()
2347 dAtA = make([]byte, size)
2348 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2349 if err != nil {
2350 return nil, err
2351 }
2352 return dAtA[:n], nil
2353 }
2354
2355 func (m *CreateEndpointResponse) MarshalTo(dAtA []byte) (int, error) {
2356 size := m.Size()
2357 return m.MarshalToSizedBuffer(dAtA[:size])
2358 }
2359
2360 func (m *CreateEndpointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2361 i := len(dAtA)
2362 _ = i
2363 var l int
2364 _ = l
2365 if m.XXX_unrecognized != nil {
2366 i -= len(m.XXX_unrecognized)
2367 copy(dAtA[i:], m.XXX_unrecognized)
2368 }
2369 if len(m.ID) > 0 {
2370 i -= len(m.ID)
2371 copy(dAtA[i:], m.ID)
2372 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ID)))
2373 i--
2374 dAtA[i] = 0xa
2375 }
2376 return len(dAtA) - i, nil
2377 }
2378
2379 func (m *AddEndpointRequest) Marshal() (dAtA []byte, err error) {
2380 size := m.Size()
2381 dAtA = make([]byte, size)
2382 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2383 if err != nil {
2384 return nil, err
2385 }
2386 return dAtA[:n], nil
2387 }
2388
2389 func (m *AddEndpointRequest) MarshalTo(dAtA []byte) (int, error) {
2390 size := m.Size()
2391 return m.MarshalToSizedBuffer(dAtA[:size])
2392 }
2393
2394 func (m *AddEndpointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2395 i := len(dAtA)
2396 _ = i
2397 var l int
2398 _ = l
2399 if m.XXX_unrecognized != nil {
2400 i -= len(m.XXX_unrecognized)
2401 copy(dAtA[i:], m.XXX_unrecognized)
2402 }
2403 if len(m.NamespaceID) > 0 {
2404 i -= len(m.NamespaceID)
2405 copy(dAtA[i:], m.NamespaceID)
2406 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.NamespaceID)))
2407 i--
2408 dAtA[i] = 0x12
2409 }
2410 if len(m.Name) > 0 {
2411 i -= len(m.Name)
2412 copy(dAtA[i:], m.Name)
2413 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
2414 i--
2415 dAtA[i] = 0xa
2416 }
2417 return len(dAtA) - i, nil
2418 }
2419
2420 func (m *AddEndpointResponse) Marshal() (dAtA []byte, err error) {
2421 size := m.Size()
2422 dAtA = make([]byte, size)
2423 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2424 if err != nil {
2425 return nil, err
2426 }
2427 return dAtA[:n], nil
2428 }
2429
2430 func (m *AddEndpointResponse) MarshalTo(dAtA []byte) (int, error) {
2431 size := m.Size()
2432 return m.MarshalToSizedBuffer(dAtA[:size])
2433 }
2434
2435 func (m *AddEndpointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2436 i := len(dAtA)
2437 _ = i
2438 var l int
2439 _ = l
2440 if m.XXX_unrecognized != nil {
2441 i -= len(m.XXX_unrecognized)
2442 copy(dAtA[i:], m.XXX_unrecognized)
2443 }
2444 return len(dAtA) - i, nil
2445 }
2446
2447 func (m *DeleteEndpointRequest) Marshal() (dAtA []byte, err error) {
2448 size := m.Size()
2449 dAtA = make([]byte, size)
2450 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2451 if err != nil {
2452 return nil, err
2453 }
2454 return dAtA[:n], nil
2455 }
2456
2457 func (m *DeleteEndpointRequest) MarshalTo(dAtA []byte) (int, error) {
2458 size := m.Size()
2459 return m.MarshalToSizedBuffer(dAtA[:size])
2460 }
2461
2462 func (m *DeleteEndpointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2463 i := len(dAtA)
2464 _ = i
2465 var l int
2466 _ = l
2467 if m.XXX_unrecognized != nil {
2468 i -= len(m.XXX_unrecognized)
2469 copy(dAtA[i:], m.XXX_unrecognized)
2470 }
2471 if len(m.Name) > 0 {
2472 i -= len(m.Name)
2473 copy(dAtA[i:], m.Name)
2474 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
2475 i--
2476 dAtA[i] = 0xa
2477 }
2478 return len(dAtA) - i, nil
2479 }
2480
2481 func (m *DeleteEndpointResponse) Marshal() (dAtA []byte, err error) {
2482 size := m.Size()
2483 dAtA = make([]byte, size)
2484 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2485 if err != nil {
2486 return nil, err
2487 }
2488 return dAtA[:n], nil
2489 }
2490
2491 func (m *DeleteEndpointResponse) MarshalTo(dAtA []byte) (int, error) {
2492 size := m.Size()
2493 return m.MarshalToSizedBuffer(dAtA[:size])
2494 }
2495
2496 func (m *DeleteEndpointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2497 i := len(dAtA)
2498 _ = i
2499 var l int
2500 _ = l
2501 if m.XXX_unrecognized != nil {
2502 i -= len(m.XXX_unrecognized)
2503 copy(dAtA[i:], m.XXX_unrecognized)
2504 }
2505 return len(dAtA) - i, nil
2506 }
2507
2508 func (m *DeleteNetworkRequest) Marshal() (dAtA []byte, err error) {
2509 size := m.Size()
2510 dAtA = make([]byte, size)
2511 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2512 if err != nil {
2513 return nil, err
2514 }
2515 return dAtA[:n], nil
2516 }
2517
2518 func (m *DeleteNetworkRequest) MarshalTo(dAtA []byte) (int, error) {
2519 size := m.Size()
2520 return m.MarshalToSizedBuffer(dAtA[:size])
2521 }
2522
2523 func (m *DeleteNetworkRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2524 i := len(dAtA)
2525 _ = i
2526 var l int
2527 _ = l
2528 if m.XXX_unrecognized != nil {
2529 i -= len(m.XXX_unrecognized)
2530 copy(dAtA[i:], m.XXX_unrecognized)
2531 }
2532 if len(m.Name) > 0 {
2533 i -= len(m.Name)
2534 copy(dAtA[i:], m.Name)
2535 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
2536 i--
2537 dAtA[i] = 0xa
2538 }
2539 return len(dAtA) - i, nil
2540 }
2541
2542 func (m *DeleteNetworkResponse) Marshal() (dAtA []byte, err error) {
2543 size := m.Size()
2544 dAtA = make([]byte, size)
2545 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2546 if err != nil {
2547 return nil, err
2548 }
2549 return dAtA[:n], nil
2550 }
2551
2552 func (m *DeleteNetworkResponse) MarshalTo(dAtA []byte) (int, error) {
2553 size := m.Size()
2554 return m.MarshalToSizedBuffer(dAtA[:size])
2555 }
2556
2557 func (m *DeleteNetworkResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2558 i := len(dAtA)
2559 _ = i
2560 var l int
2561 _ = l
2562 if m.XXX_unrecognized != nil {
2563 i -= len(m.XXX_unrecognized)
2564 copy(dAtA[i:], m.XXX_unrecognized)
2565 }
2566 return len(dAtA) - i, nil
2567 }
2568
2569 func (m *GetEndpointRequest) Marshal() (dAtA []byte, err error) {
2570 size := m.Size()
2571 dAtA = make([]byte, size)
2572 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2573 if err != nil {
2574 return nil, err
2575 }
2576 return dAtA[:n], nil
2577 }
2578
2579 func (m *GetEndpointRequest) MarshalTo(dAtA []byte) (int, error) {
2580 size := m.Size()
2581 return m.MarshalToSizedBuffer(dAtA[:size])
2582 }
2583
2584 func (m *GetEndpointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2585 i := len(dAtA)
2586 _ = i
2587 var l int
2588 _ = l
2589 if m.XXX_unrecognized != nil {
2590 i -= len(m.XXX_unrecognized)
2591 copy(dAtA[i:], m.XXX_unrecognized)
2592 }
2593 if len(m.Name) > 0 {
2594 i -= len(m.Name)
2595 copy(dAtA[i:], m.Name)
2596 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
2597 i--
2598 dAtA[i] = 0xa
2599 }
2600 return len(dAtA) - i, nil
2601 }
2602
2603 func (m *GetEndpointResponse) Marshal() (dAtA []byte, err error) {
2604 size := m.Size()
2605 dAtA = make([]byte, size)
2606 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2607 if err != nil {
2608 return nil, err
2609 }
2610 return dAtA[:n], nil
2611 }
2612
2613 func (m *GetEndpointResponse) MarshalTo(dAtA []byte) (int, error) {
2614 size := m.Size()
2615 return m.MarshalToSizedBuffer(dAtA[:size])
2616 }
2617
2618 func (m *GetEndpointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2619 i := len(dAtA)
2620 _ = i
2621 var l int
2622 _ = l
2623 if m.XXX_unrecognized != nil {
2624 i -= len(m.XXX_unrecognized)
2625 copy(dAtA[i:], m.XXX_unrecognized)
2626 }
2627 if m.DnsSetting != nil {
2628 {
2629 size, err := m.DnsSetting.MarshalToSizedBuffer(dAtA[:i])
2630 if err != nil {
2631 return 0, err
2632 }
2633 i -= size
2634 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
2635 }
2636 i--
2637 dAtA[i] = 0x2a
2638 }
2639 if len(m.Namespace) > 0 {
2640 i -= len(m.Namespace)
2641 copy(dAtA[i:], m.Namespace)
2642 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Namespace)))
2643 i--
2644 dAtA[i] = 0x22
2645 }
2646 if len(m.Network) > 0 {
2647 i -= len(m.Network)
2648 copy(dAtA[i:], m.Network)
2649 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Network)))
2650 i--
2651 dAtA[i] = 0x1a
2652 }
2653 if len(m.Name) > 0 {
2654 i -= len(m.Name)
2655 copy(dAtA[i:], m.Name)
2656 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
2657 i--
2658 dAtA[i] = 0x12
2659 }
2660 if len(m.ID) > 0 {
2661 i -= len(m.ID)
2662 copy(dAtA[i:], m.ID)
2663 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ID)))
2664 i--
2665 dAtA[i] = 0xa
2666 }
2667 return len(dAtA) - i, nil
2668 }
2669
2670 func (m *GetNetworkRequest) Marshal() (dAtA []byte, err error) {
2671 size := m.Size()
2672 dAtA = make([]byte, size)
2673 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2674 if err != nil {
2675 return nil, err
2676 }
2677 return dAtA[:n], nil
2678 }
2679
2680 func (m *GetNetworkRequest) MarshalTo(dAtA []byte) (int, error) {
2681 size := m.Size()
2682 return m.MarshalToSizedBuffer(dAtA[:size])
2683 }
2684
2685 func (m *GetNetworkRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2686 i := len(dAtA)
2687 _ = i
2688 var l int
2689 _ = l
2690 if m.XXX_unrecognized != nil {
2691 i -= len(m.XXX_unrecognized)
2692 copy(dAtA[i:], m.XXX_unrecognized)
2693 }
2694 if len(m.Name) > 0 {
2695 i -= len(m.Name)
2696 copy(dAtA[i:], m.Name)
2697 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
2698 i--
2699 dAtA[i] = 0xa
2700 }
2701 return len(dAtA) - i, nil
2702 }
2703
2704 func (m *GetNetworkResponse) Marshal() (dAtA []byte, err error) {
2705 size := m.Size()
2706 dAtA = make([]byte, size)
2707 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2708 if err != nil {
2709 return nil, err
2710 }
2711 return dAtA[:n], nil
2712 }
2713
2714 func (m *GetNetworkResponse) MarshalTo(dAtA []byte) (int, error) {
2715 size := m.Size()
2716 return m.MarshalToSizedBuffer(dAtA[:size])
2717 }
2718
2719 func (m *GetNetworkResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2720 i := len(dAtA)
2721 _ = i
2722 var l int
2723 _ = l
2724 if m.XXX_unrecognized != nil {
2725 i -= len(m.XXX_unrecognized)
2726 copy(dAtA[i:], m.XXX_unrecognized)
2727 }
2728 if len(m.Name) > 0 {
2729 i -= len(m.Name)
2730 copy(dAtA[i:], m.Name)
2731 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.Name)))
2732 i--
2733 dAtA[i] = 0x12
2734 }
2735 if len(m.ID) > 0 {
2736 i -= len(m.ID)
2737 copy(dAtA[i:], m.ID)
2738 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ID)))
2739 i--
2740 dAtA[i] = 0xa
2741 }
2742 return len(dAtA) - i, nil
2743 }
2744
2745 func (m *GetEndpointsRequest) Marshal() (dAtA []byte, err error) {
2746 size := m.Size()
2747 dAtA = make([]byte, size)
2748 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2749 if err != nil {
2750 return nil, err
2751 }
2752 return dAtA[:n], nil
2753 }
2754
2755 func (m *GetEndpointsRequest) MarshalTo(dAtA []byte) (int, error) {
2756 size := m.Size()
2757 return m.MarshalToSizedBuffer(dAtA[:size])
2758 }
2759
2760 func (m *GetEndpointsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2761 i := len(dAtA)
2762 _ = i
2763 var l int
2764 _ = l
2765 if m.XXX_unrecognized != nil {
2766 i -= len(m.XXX_unrecognized)
2767 copy(dAtA[i:], m.XXX_unrecognized)
2768 }
2769 return len(dAtA) - i, nil
2770 }
2771
2772 func (m *GetEndpointsResponse) Marshal() (dAtA []byte, err error) {
2773 size := m.Size()
2774 dAtA = make([]byte, size)
2775 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2776 if err != nil {
2777 return nil, err
2778 }
2779 return dAtA[:n], nil
2780 }
2781
2782 func (m *GetEndpointsResponse) MarshalTo(dAtA []byte) (int, error) {
2783 size := m.Size()
2784 return m.MarshalToSizedBuffer(dAtA[:size])
2785 }
2786
2787 func (m *GetEndpointsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2788 i := len(dAtA)
2789 _ = i
2790 var l int
2791 _ = l
2792 if m.XXX_unrecognized != nil {
2793 i -= len(m.XXX_unrecognized)
2794 copy(dAtA[i:], m.XXX_unrecognized)
2795 }
2796 if len(m.Endpoints) > 0 {
2797 for iNdEx := len(m.Endpoints) - 1; iNdEx >= 0; iNdEx-- {
2798 {
2799 size, err := m.Endpoints[iNdEx].MarshalToSizedBuffer(dAtA[:i])
2800 if err != nil {
2801 return 0, err
2802 }
2803 i -= size
2804 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
2805 }
2806 i--
2807 dAtA[i] = 0xa
2808 }
2809 }
2810 return len(dAtA) - i, nil
2811 }
2812
2813 func (m *GetNetworksRequest) Marshal() (dAtA []byte, err error) {
2814 size := m.Size()
2815 dAtA = make([]byte, size)
2816 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2817 if err != nil {
2818 return nil, err
2819 }
2820 return dAtA[:n], nil
2821 }
2822
2823 func (m *GetNetworksRequest) MarshalTo(dAtA []byte) (int, error) {
2824 size := m.Size()
2825 return m.MarshalToSizedBuffer(dAtA[:size])
2826 }
2827
2828 func (m *GetNetworksRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2829 i := len(dAtA)
2830 _ = i
2831 var l int
2832 _ = l
2833 if m.XXX_unrecognized != nil {
2834 i -= len(m.XXX_unrecognized)
2835 copy(dAtA[i:], m.XXX_unrecognized)
2836 }
2837 return len(dAtA) - i, nil
2838 }
2839
2840 func (m *GetNetworksResponse) Marshal() (dAtA []byte, err error) {
2841 size := m.Size()
2842 dAtA = make([]byte, size)
2843 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2844 if err != nil {
2845 return nil, err
2846 }
2847 return dAtA[:n], nil
2848 }
2849
2850 func (m *GetNetworksResponse) MarshalTo(dAtA []byte) (int, error) {
2851 size := m.Size()
2852 return m.MarshalToSizedBuffer(dAtA[:size])
2853 }
2854
2855 func (m *GetNetworksResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2856 i := len(dAtA)
2857 _ = i
2858 var l int
2859 _ = l
2860 if m.XXX_unrecognized != nil {
2861 i -= len(m.XXX_unrecognized)
2862 copy(dAtA[i:], m.XXX_unrecognized)
2863 }
2864 if len(m.Networks) > 0 {
2865 for iNdEx := len(m.Networks) - 1; iNdEx >= 0; iNdEx-- {
2866 {
2867 size, err := m.Networks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
2868 if err != nil {
2869 return 0, err
2870 }
2871 i -= size
2872 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(size))
2873 }
2874 i--
2875 dAtA[i] = 0xa
2876 }
2877 }
2878 return len(dAtA) - i, nil
2879 }
2880
2881 func encodeVarintNetworkconfigproxy(dAtA []byte, offset int, v uint64) int {
2882 offset -= sovNetworkconfigproxy(v)
2883 base := offset
2884 for v >= 1<<7 {
2885 dAtA[offset] = uint8(v&0x7f | 0x80)
2886 v >>= 7
2887 offset++
2888 }
2889 dAtA[offset] = uint8(v)
2890 return base
2891 }
2892 func (m *AddNICRequest) Size() (n int) {
2893 if m == nil {
2894 return 0
2895 }
2896 var l int
2897 _ = l
2898 l = len(m.ContainerID)
2899 if l > 0 {
2900 n += 1 + l + sovNetworkconfigproxy(uint64(l))
2901 }
2902 l = len(m.NicID)
2903 if l > 0 {
2904 n += 1 + l + sovNetworkconfigproxy(uint64(l))
2905 }
2906 l = len(m.EndpointName)
2907 if l > 0 {
2908 n += 1 + l + sovNetworkconfigproxy(uint64(l))
2909 }
2910 if m.XXX_unrecognized != nil {
2911 n += len(m.XXX_unrecognized)
2912 }
2913 return n
2914 }
2915
2916 func (m *AddNICResponse) Size() (n int) {
2917 if m == nil {
2918 return 0
2919 }
2920 var l int
2921 _ = l
2922 if m.XXX_unrecognized != nil {
2923 n += len(m.XXX_unrecognized)
2924 }
2925 return n
2926 }
2927
2928 func (m *ModifyNICRequest) Size() (n int) {
2929 if m == nil {
2930 return 0
2931 }
2932 var l int
2933 _ = l
2934 l = len(m.ContainerID)
2935 if l > 0 {
2936 n += 1 + l + sovNetworkconfigproxy(uint64(l))
2937 }
2938 l = len(m.NicID)
2939 if l > 0 {
2940 n += 1 + l + sovNetworkconfigproxy(uint64(l))
2941 }
2942 l = len(m.EndpointName)
2943 if l > 0 {
2944 n += 1 + l + sovNetworkconfigproxy(uint64(l))
2945 }
2946 if m.IovPolicySettings != nil {
2947 l = m.IovPolicySettings.Size()
2948 n += 1 + l + sovNetworkconfigproxy(uint64(l))
2949 }
2950 if m.XXX_unrecognized != nil {
2951 n += len(m.XXX_unrecognized)
2952 }
2953 return n
2954 }
2955
2956 func (m *ModifyNICResponse) Size() (n int) {
2957 if m == nil {
2958 return 0
2959 }
2960 var l int
2961 _ = l
2962 if m.XXX_unrecognized != nil {
2963 n += len(m.XXX_unrecognized)
2964 }
2965 return n
2966 }
2967
2968 func (m *DeleteNICRequest) Size() (n int) {
2969 if m == nil {
2970 return 0
2971 }
2972 var l int
2973 _ = l
2974 l = len(m.ContainerID)
2975 if l > 0 {
2976 n += 1 + l + sovNetworkconfigproxy(uint64(l))
2977 }
2978 l = len(m.NicID)
2979 if l > 0 {
2980 n += 1 + l + sovNetworkconfigproxy(uint64(l))
2981 }
2982 l = len(m.EndpointName)
2983 if l > 0 {
2984 n += 1 + l + sovNetworkconfigproxy(uint64(l))
2985 }
2986 if m.XXX_unrecognized != nil {
2987 n += len(m.XXX_unrecognized)
2988 }
2989 return n
2990 }
2991
2992 func (m *DeleteNICResponse) Size() (n int) {
2993 if m == nil {
2994 return 0
2995 }
2996 var l int
2997 _ = l
2998 if m.XXX_unrecognized != nil {
2999 n += len(m.XXX_unrecognized)
3000 }
3001 return n
3002 }
3003
3004 func (m *CreateNetworkRequest) Size() (n int) {
3005 if m == nil {
3006 return 0
3007 }
3008 var l int
3009 _ = l
3010 l = len(m.Name)
3011 if l > 0 {
3012 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3013 }
3014 if m.Mode != 0 {
3015 n += 1 + sovNetworkconfigproxy(uint64(m.Mode))
3016 }
3017 l = len(m.SwitchName)
3018 if l > 0 {
3019 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3020 }
3021 if m.IpamType != 0 {
3022 n += 1 + sovNetworkconfigproxy(uint64(m.IpamType))
3023 }
3024 if len(m.SubnetIpaddressPrefix) > 0 {
3025 for _, s := range m.SubnetIpaddressPrefix {
3026 l = len(s)
3027 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3028 }
3029 }
3030 l = len(m.DefaultGateway)
3031 if l > 0 {
3032 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3033 }
3034 if m.XXX_unrecognized != nil {
3035 n += len(m.XXX_unrecognized)
3036 }
3037 return n
3038 }
3039
3040 func (m *CreateNetworkResponse) Size() (n int) {
3041 if m == nil {
3042 return 0
3043 }
3044 var l int
3045 _ = l
3046 l = len(m.ID)
3047 if l > 0 {
3048 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3049 }
3050 if m.XXX_unrecognized != nil {
3051 n += len(m.XXX_unrecognized)
3052 }
3053 return n
3054 }
3055
3056 func (m *PortNameEndpointPolicySetting) Size() (n int) {
3057 if m == nil {
3058 return 0
3059 }
3060 var l int
3061 _ = l
3062 l = len(m.PortName)
3063 if l > 0 {
3064 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3065 }
3066 if m.XXX_unrecognized != nil {
3067 n += len(m.XXX_unrecognized)
3068 }
3069 return n
3070 }
3071
3072 func (m *IovEndpointPolicySetting) Size() (n int) {
3073 if m == nil {
3074 return 0
3075 }
3076 var l int
3077 _ = l
3078 if m.IovOffloadWeight != 0 {
3079 n += 1 + sovNetworkconfigproxy(uint64(m.IovOffloadWeight))
3080 }
3081 if m.QueuePairsRequested != 0 {
3082 n += 1 + sovNetworkconfigproxy(uint64(m.QueuePairsRequested))
3083 }
3084 if m.InterruptModeration != 0 {
3085 n += 1 + sovNetworkconfigproxy(uint64(m.InterruptModeration))
3086 }
3087 if m.XXX_unrecognized != nil {
3088 n += len(m.XXX_unrecognized)
3089 }
3090 return n
3091 }
3092
3093 func (m *DnsSetting) Size() (n int) {
3094 if m == nil {
3095 return 0
3096 }
3097 var l int
3098 _ = l
3099 if len(m.ServerIpAddrs) > 0 {
3100 for _, s := range m.ServerIpAddrs {
3101 l = len(s)
3102 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3103 }
3104 }
3105 l = len(m.Domain)
3106 if l > 0 {
3107 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3108 }
3109 if len(m.Search) > 0 {
3110 for _, s := range m.Search {
3111 l = len(s)
3112 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3113 }
3114 }
3115 if m.XXX_unrecognized != nil {
3116 n += len(m.XXX_unrecognized)
3117 }
3118 return n
3119 }
3120
3121 func (m *CreateEndpointRequest) Size() (n int) {
3122 if m == nil {
3123 return 0
3124 }
3125 var l int
3126 _ = l
3127 l = len(m.Name)
3128 if l > 0 {
3129 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3130 }
3131 l = len(m.Macaddress)
3132 if l > 0 {
3133 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3134 }
3135 l = len(m.Ipaddress)
3136 if l > 0 {
3137 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3138 }
3139 l = len(m.IpaddressPrefixlength)
3140 if l > 0 {
3141 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3142 }
3143 l = len(m.NetworkName)
3144 if l > 0 {
3145 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3146 }
3147 if m.PortnamePolicySetting != nil {
3148 l = m.PortnamePolicySetting.Size()
3149 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3150 }
3151 if m.IovPolicySettings != nil {
3152 l = m.IovPolicySettings.Size()
3153 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3154 }
3155 if m.DnsSetting != nil {
3156 l = m.DnsSetting.Size()
3157 n += 2 + l + sovNetworkconfigproxy(uint64(l))
3158 }
3159 if m.XXX_unrecognized != nil {
3160 n += len(m.XXX_unrecognized)
3161 }
3162 return n
3163 }
3164
3165 func (m *CreateEndpointResponse) Size() (n int) {
3166 if m == nil {
3167 return 0
3168 }
3169 var l int
3170 _ = l
3171 l = len(m.ID)
3172 if l > 0 {
3173 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3174 }
3175 if m.XXX_unrecognized != nil {
3176 n += len(m.XXX_unrecognized)
3177 }
3178 return n
3179 }
3180
3181 func (m *AddEndpointRequest) Size() (n int) {
3182 if m == nil {
3183 return 0
3184 }
3185 var l int
3186 _ = l
3187 l = len(m.Name)
3188 if l > 0 {
3189 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3190 }
3191 l = len(m.NamespaceID)
3192 if l > 0 {
3193 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3194 }
3195 if m.XXX_unrecognized != nil {
3196 n += len(m.XXX_unrecognized)
3197 }
3198 return n
3199 }
3200
3201 func (m *AddEndpointResponse) Size() (n int) {
3202 if m == nil {
3203 return 0
3204 }
3205 var l int
3206 _ = l
3207 if m.XXX_unrecognized != nil {
3208 n += len(m.XXX_unrecognized)
3209 }
3210 return n
3211 }
3212
3213 func (m *DeleteEndpointRequest) Size() (n int) {
3214 if m == nil {
3215 return 0
3216 }
3217 var l int
3218 _ = l
3219 l = len(m.Name)
3220 if l > 0 {
3221 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3222 }
3223 if m.XXX_unrecognized != nil {
3224 n += len(m.XXX_unrecognized)
3225 }
3226 return n
3227 }
3228
3229 func (m *DeleteEndpointResponse) Size() (n int) {
3230 if m == nil {
3231 return 0
3232 }
3233 var l int
3234 _ = l
3235 if m.XXX_unrecognized != nil {
3236 n += len(m.XXX_unrecognized)
3237 }
3238 return n
3239 }
3240
3241 func (m *DeleteNetworkRequest) Size() (n int) {
3242 if m == nil {
3243 return 0
3244 }
3245 var l int
3246 _ = l
3247 l = len(m.Name)
3248 if l > 0 {
3249 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3250 }
3251 if m.XXX_unrecognized != nil {
3252 n += len(m.XXX_unrecognized)
3253 }
3254 return n
3255 }
3256
3257 func (m *DeleteNetworkResponse) Size() (n int) {
3258 if m == nil {
3259 return 0
3260 }
3261 var l int
3262 _ = l
3263 if m.XXX_unrecognized != nil {
3264 n += len(m.XXX_unrecognized)
3265 }
3266 return n
3267 }
3268
3269 func (m *GetEndpointRequest) Size() (n int) {
3270 if m == nil {
3271 return 0
3272 }
3273 var l int
3274 _ = l
3275 l = len(m.Name)
3276 if l > 0 {
3277 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3278 }
3279 if m.XXX_unrecognized != nil {
3280 n += len(m.XXX_unrecognized)
3281 }
3282 return n
3283 }
3284
3285 func (m *GetEndpointResponse) Size() (n int) {
3286 if m == nil {
3287 return 0
3288 }
3289 var l int
3290 _ = l
3291 l = len(m.ID)
3292 if l > 0 {
3293 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3294 }
3295 l = len(m.Name)
3296 if l > 0 {
3297 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3298 }
3299 l = len(m.Network)
3300 if l > 0 {
3301 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3302 }
3303 l = len(m.Namespace)
3304 if l > 0 {
3305 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3306 }
3307 if m.DnsSetting != nil {
3308 l = m.DnsSetting.Size()
3309 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3310 }
3311 if m.XXX_unrecognized != nil {
3312 n += len(m.XXX_unrecognized)
3313 }
3314 return n
3315 }
3316
3317 func (m *GetNetworkRequest) Size() (n int) {
3318 if m == nil {
3319 return 0
3320 }
3321 var l int
3322 _ = l
3323 l = len(m.Name)
3324 if l > 0 {
3325 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3326 }
3327 if m.XXX_unrecognized != nil {
3328 n += len(m.XXX_unrecognized)
3329 }
3330 return n
3331 }
3332
3333 func (m *GetNetworkResponse) Size() (n int) {
3334 if m == nil {
3335 return 0
3336 }
3337 var l int
3338 _ = l
3339 l = len(m.ID)
3340 if l > 0 {
3341 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3342 }
3343 l = len(m.Name)
3344 if l > 0 {
3345 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3346 }
3347 if m.XXX_unrecognized != nil {
3348 n += len(m.XXX_unrecognized)
3349 }
3350 return n
3351 }
3352
3353 func (m *GetEndpointsRequest) Size() (n int) {
3354 if m == nil {
3355 return 0
3356 }
3357 var l int
3358 _ = l
3359 if m.XXX_unrecognized != nil {
3360 n += len(m.XXX_unrecognized)
3361 }
3362 return n
3363 }
3364
3365 func (m *GetEndpointsResponse) Size() (n int) {
3366 if m == nil {
3367 return 0
3368 }
3369 var l int
3370 _ = l
3371 if len(m.Endpoints) > 0 {
3372 for _, e := range m.Endpoints {
3373 l = e.Size()
3374 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3375 }
3376 }
3377 if m.XXX_unrecognized != nil {
3378 n += len(m.XXX_unrecognized)
3379 }
3380 return n
3381 }
3382
3383 func (m *GetNetworksRequest) Size() (n int) {
3384 if m == nil {
3385 return 0
3386 }
3387 var l int
3388 _ = l
3389 if m.XXX_unrecognized != nil {
3390 n += len(m.XXX_unrecognized)
3391 }
3392 return n
3393 }
3394
3395 func (m *GetNetworksResponse) Size() (n int) {
3396 if m == nil {
3397 return 0
3398 }
3399 var l int
3400 _ = l
3401 if len(m.Networks) > 0 {
3402 for _, e := range m.Networks {
3403 l = e.Size()
3404 n += 1 + l + sovNetworkconfigproxy(uint64(l))
3405 }
3406 }
3407 if m.XXX_unrecognized != nil {
3408 n += len(m.XXX_unrecognized)
3409 }
3410 return n
3411 }
3412
3413 func sovNetworkconfigproxy(x uint64) (n int) {
3414 return (math_bits.Len64(x|1) + 6) / 7
3415 }
3416 func sozNetworkconfigproxy(x uint64) (n int) {
3417 return sovNetworkconfigproxy(uint64((x << 1) ^ uint64((int64(x) >> 63))))
3418 }
3419 func (this *AddNICRequest) String() string {
3420 if this == nil {
3421 return "nil"
3422 }
3423 s := strings.Join([]string{`&AddNICRequest{`,
3424 `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
3425 `NicID:` + fmt.Sprintf("%v", this.NicID) + `,`,
3426 `EndpointName:` + fmt.Sprintf("%v", this.EndpointName) + `,`,
3427 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3428 `}`,
3429 }, "")
3430 return s
3431 }
3432 func (this *AddNICResponse) String() string {
3433 if this == nil {
3434 return "nil"
3435 }
3436 s := strings.Join([]string{`&AddNICResponse{`,
3437 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3438 `}`,
3439 }, "")
3440 return s
3441 }
3442 func (this *ModifyNICRequest) String() string {
3443 if this == nil {
3444 return "nil"
3445 }
3446 s := strings.Join([]string{`&ModifyNICRequest{`,
3447 `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
3448 `NicID:` + fmt.Sprintf("%v", this.NicID) + `,`,
3449 `EndpointName:` + fmt.Sprintf("%v", this.EndpointName) + `,`,
3450 `IovPolicySettings:` + strings.Replace(this.IovPolicySettings.String(), "IovEndpointPolicySetting", "IovEndpointPolicySetting", 1) + `,`,
3451 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3452 `}`,
3453 }, "")
3454 return s
3455 }
3456 func (this *ModifyNICResponse) String() string {
3457 if this == nil {
3458 return "nil"
3459 }
3460 s := strings.Join([]string{`&ModifyNICResponse{`,
3461 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3462 `}`,
3463 }, "")
3464 return s
3465 }
3466 func (this *DeleteNICRequest) String() string {
3467 if this == nil {
3468 return "nil"
3469 }
3470 s := strings.Join([]string{`&DeleteNICRequest{`,
3471 `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
3472 `NicID:` + fmt.Sprintf("%v", this.NicID) + `,`,
3473 `EndpointName:` + fmt.Sprintf("%v", this.EndpointName) + `,`,
3474 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3475 `}`,
3476 }, "")
3477 return s
3478 }
3479 func (this *DeleteNICResponse) String() string {
3480 if this == nil {
3481 return "nil"
3482 }
3483 s := strings.Join([]string{`&DeleteNICResponse{`,
3484 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3485 `}`,
3486 }, "")
3487 return s
3488 }
3489 func (this *CreateNetworkRequest) String() string {
3490 if this == nil {
3491 return "nil"
3492 }
3493 s := strings.Join([]string{`&CreateNetworkRequest{`,
3494 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
3495 `Mode:` + fmt.Sprintf("%v", this.Mode) + `,`,
3496 `SwitchName:` + fmt.Sprintf("%v", this.SwitchName) + `,`,
3497 `IpamType:` + fmt.Sprintf("%v", this.IpamType) + `,`,
3498 `SubnetIpaddressPrefix:` + fmt.Sprintf("%v", this.SubnetIpaddressPrefix) + `,`,
3499 `DefaultGateway:` + fmt.Sprintf("%v", this.DefaultGateway) + `,`,
3500 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3501 `}`,
3502 }, "")
3503 return s
3504 }
3505 func (this *CreateNetworkResponse) String() string {
3506 if this == nil {
3507 return "nil"
3508 }
3509 s := strings.Join([]string{`&CreateNetworkResponse{`,
3510 `ID:` + fmt.Sprintf("%v", this.ID) + `,`,
3511 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3512 `}`,
3513 }, "")
3514 return s
3515 }
3516 func (this *PortNameEndpointPolicySetting) String() string {
3517 if this == nil {
3518 return "nil"
3519 }
3520 s := strings.Join([]string{`&PortNameEndpointPolicySetting{`,
3521 `PortName:` + fmt.Sprintf("%v", this.PortName) + `,`,
3522 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3523 `}`,
3524 }, "")
3525 return s
3526 }
3527 func (this *IovEndpointPolicySetting) String() string {
3528 if this == nil {
3529 return "nil"
3530 }
3531 s := strings.Join([]string{`&IovEndpointPolicySetting{`,
3532 `IovOffloadWeight:` + fmt.Sprintf("%v", this.IovOffloadWeight) + `,`,
3533 `QueuePairsRequested:` + fmt.Sprintf("%v", this.QueuePairsRequested) + `,`,
3534 `InterruptModeration:` + fmt.Sprintf("%v", this.InterruptModeration) + `,`,
3535 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3536 `}`,
3537 }, "")
3538 return s
3539 }
3540 func (this *DnsSetting) String() string {
3541 if this == nil {
3542 return "nil"
3543 }
3544 s := strings.Join([]string{`&DnsSetting{`,
3545 `ServerIpAddrs:` + fmt.Sprintf("%v", this.ServerIpAddrs) + `,`,
3546 `Domain:` + fmt.Sprintf("%v", this.Domain) + `,`,
3547 `Search:` + fmt.Sprintf("%v", this.Search) + `,`,
3548 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3549 `}`,
3550 }, "")
3551 return s
3552 }
3553 func (this *CreateEndpointRequest) String() string {
3554 if this == nil {
3555 return "nil"
3556 }
3557 s := strings.Join([]string{`&CreateEndpointRequest{`,
3558 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
3559 `Macaddress:` + fmt.Sprintf("%v", this.Macaddress) + `,`,
3560 `Ipaddress:` + fmt.Sprintf("%v", this.Ipaddress) + `,`,
3561 `IpaddressPrefixlength:` + fmt.Sprintf("%v", this.IpaddressPrefixlength) + `,`,
3562 `NetworkName:` + fmt.Sprintf("%v", this.NetworkName) + `,`,
3563 `PortnamePolicySetting:` + strings.Replace(this.PortnamePolicySetting.String(), "PortNameEndpointPolicySetting", "PortNameEndpointPolicySetting", 1) + `,`,
3564 `IovPolicySettings:` + strings.Replace(this.IovPolicySettings.String(), "IovEndpointPolicySetting", "IovEndpointPolicySetting", 1) + `,`,
3565 `DnsSetting:` + strings.Replace(this.DnsSetting.String(), "DnsSetting", "DnsSetting", 1) + `,`,
3566 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3567 `}`,
3568 }, "")
3569 return s
3570 }
3571 func (this *CreateEndpointResponse) String() string {
3572 if this == nil {
3573 return "nil"
3574 }
3575 s := strings.Join([]string{`&CreateEndpointResponse{`,
3576 `ID:` + fmt.Sprintf("%v", this.ID) + `,`,
3577 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3578 `}`,
3579 }, "")
3580 return s
3581 }
3582 func (this *AddEndpointRequest) String() string {
3583 if this == nil {
3584 return "nil"
3585 }
3586 s := strings.Join([]string{`&AddEndpointRequest{`,
3587 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
3588 `NamespaceID:` + fmt.Sprintf("%v", this.NamespaceID) + `,`,
3589 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3590 `}`,
3591 }, "")
3592 return s
3593 }
3594 func (this *AddEndpointResponse) String() string {
3595 if this == nil {
3596 return "nil"
3597 }
3598 s := strings.Join([]string{`&AddEndpointResponse{`,
3599 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3600 `}`,
3601 }, "")
3602 return s
3603 }
3604 func (this *DeleteEndpointRequest) String() string {
3605 if this == nil {
3606 return "nil"
3607 }
3608 s := strings.Join([]string{`&DeleteEndpointRequest{`,
3609 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
3610 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3611 `}`,
3612 }, "")
3613 return s
3614 }
3615 func (this *DeleteEndpointResponse) String() string {
3616 if this == nil {
3617 return "nil"
3618 }
3619 s := strings.Join([]string{`&DeleteEndpointResponse{`,
3620 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3621 `}`,
3622 }, "")
3623 return s
3624 }
3625 func (this *DeleteNetworkRequest) String() string {
3626 if this == nil {
3627 return "nil"
3628 }
3629 s := strings.Join([]string{`&DeleteNetworkRequest{`,
3630 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
3631 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3632 `}`,
3633 }, "")
3634 return s
3635 }
3636 func (this *DeleteNetworkResponse) String() string {
3637 if this == nil {
3638 return "nil"
3639 }
3640 s := strings.Join([]string{`&DeleteNetworkResponse{`,
3641 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3642 `}`,
3643 }, "")
3644 return s
3645 }
3646 func (this *GetEndpointRequest) String() string {
3647 if this == nil {
3648 return "nil"
3649 }
3650 s := strings.Join([]string{`&GetEndpointRequest{`,
3651 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
3652 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3653 `}`,
3654 }, "")
3655 return s
3656 }
3657 func (this *GetEndpointResponse) String() string {
3658 if this == nil {
3659 return "nil"
3660 }
3661 s := strings.Join([]string{`&GetEndpointResponse{`,
3662 `ID:` + fmt.Sprintf("%v", this.ID) + `,`,
3663 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
3664 `Network:` + fmt.Sprintf("%v", this.Network) + `,`,
3665 `Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
3666 `DnsSetting:` + strings.Replace(this.DnsSetting.String(), "DnsSetting", "DnsSetting", 1) + `,`,
3667 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3668 `}`,
3669 }, "")
3670 return s
3671 }
3672 func (this *GetNetworkRequest) String() string {
3673 if this == nil {
3674 return "nil"
3675 }
3676 s := strings.Join([]string{`&GetNetworkRequest{`,
3677 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
3678 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3679 `}`,
3680 }, "")
3681 return s
3682 }
3683 func (this *GetNetworkResponse) String() string {
3684 if this == nil {
3685 return "nil"
3686 }
3687 s := strings.Join([]string{`&GetNetworkResponse{`,
3688 `ID:` + fmt.Sprintf("%v", this.ID) + `,`,
3689 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
3690 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3691 `}`,
3692 }, "")
3693 return s
3694 }
3695 func (this *GetEndpointsRequest) String() string {
3696 if this == nil {
3697 return "nil"
3698 }
3699 s := strings.Join([]string{`&GetEndpointsRequest{`,
3700 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3701 `}`,
3702 }, "")
3703 return s
3704 }
3705 func (this *GetEndpointsResponse) String() string {
3706 if this == nil {
3707 return "nil"
3708 }
3709 repeatedStringForEndpoints := "[]*GetEndpointResponse{"
3710 for _, f := range this.Endpoints {
3711 repeatedStringForEndpoints += strings.Replace(f.String(), "GetEndpointResponse", "GetEndpointResponse", 1) + ","
3712 }
3713 repeatedStringForEndpoints += "}"
3714 s := strings.Join([]string{`&GetEndpointsResponse{`,
3715 `Endpoints:` + repeatedStringForEndpoints + `,`,
3716 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3717 `}`,
3718 }, "")
3719 return s
3720 }
3721 func (this *GetNetworksRequest) String() string {
3722 if this == nil {
3723 return "nil"
3724 }
3725 s := strings.Join([]string{`&GetNetworksRequest{`,
3726 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3727 `}`,
3728 }, "")
3729 return s
3730 }
3731 func (this *GetNetworksResponse) String() string {
3732 if this == nil {
3733 return "nil"
3734 }
3735 repeatedStringForNetworks := "[]*GetNetworkResponse{"
3736 for _, f := range this.Networks {
3737 repeatedStringForNetworks += strings.Replace(f.String(), "GetNetworkResponse", "GetNetworkResponse", 1) + ","
3738 }
3739 repeatedStringForNetworks += "}"
3740 s := strings.Join([]string{`&GetNetworksResponse{`,
3741 `Networks:` + repeatedStringForNetworks + `,`,
3742 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3743 `}`,
3744 }, "")
3745 return s
3746 }
3747 func valueToStringNetworkconfigproxy(v interface{}) string {
3748 rv := reflect.ValueOf(v)
3749 if rv.IsNil() {
3750 return "nil"
3751 }
3752 pv := reflect.Indirect(rv).Interface()
3753 return fmt.Sprintf("*%v", pv)
3754 }
3755 func (m *AddNICRequest) Unmarshal(dAtA []byte) error {
3756 l := len(dAtA)
3757 iNdEx := 0
3758 for iNdEx < l {
3759 preIndex := iNdEx
3760 var wire uint64
3761 for shift := uint(0); ; shift += 7 {
3762 if shift >= 64 {
3763 return ErrIntOverflowNetworkconfigproxy
3764 }
3765 if iNdEx >= l {
3766 return io.ErrUnexpectedEOF
3767 }
3768 b := dAtA[iNdEx]
3769 iNdEx++
3770 wire |= uint64(b&0x7F) << shift
3771 if b < 0x80 {
3772 break
3773 }
3774 }
3775 fieldNum := int32(wire >> 3)
3776 wireType := int(wire & 0x7)
3777 if wireType == 4 {
3778 return fmt.Errorf("proto: AddNICRequest: wiretype end group for non-group")
3779 }
3780 if fieldNum <= 0 {
3781 return fmt.Errorf("proto: AddNICRequest: illegal tag %d (wire type %d)", fieldNum, wire)
3782 }
3783 switch fieldNum {
3784 case 1:
3785 if wireType != 2 {
3786 return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
3787 }
3788 var stringLen uint64
3789 for shift := uint(0); ; shift += 7 {
3790 if shift >= 64 {
3791 return ErrIntOverflowNetworkconfigproxy
3792 }
3793 if iNdEx >= l {
3794 return io.ErrUnexpectedEOF
3795 }
3796 b := dAtA[iNdEx]
3797 iNdEx++
3798 stringLen |= uint64(b&0x7F) << shift
3799 if b < 0x80 {
3800 break
3801 }
3802 }
3803 intStringLen := int(stringLen)
3804 if intStringLen < 0 {
3805 return ErrInvalidLengthNetworkconfigproxy
3806 }
3807 postIndex := iNdEx + intStringLen
3808 if postIndex < 0 {
3809 return ErrInvalidLengthNetworkconfigproxy
3810 }
3811 if postIndex > l {
3812 return io.ErrUnexpectedEOF
3813 }
3814 m.ContainerID = string(dAtA[iNdEx:postIndex])
3815 iNdEx = postIndex
3816 case 2:
3817 if wireType != 2 {
3818 return fmt.Errorf("proto: wrong wireType = %d for field NicID", wireType)
3819 }
3820 var stringLen uint64
3821 for shift := uint(0); ; shift += 7 {
3822 if shift >= 64 {
3823 return ErrIntOverflowNetworkconfigproxy
3824 }
3825 if iNdEx >= l {
3826 return io.ErrUnexpectedEOF
3827 }
3828 b := dAtA[iNdEx]
3829 iNdEx++
3830 stringLen |= uint64(b&0x7F) << shift
3831 if b < 0x80 {
3832 break
3833 }
3834 }
3835 intStringLen := int(stringLen)
3836 if intStringLen < 0 {
3837 return ErrInvalidLengthNetworkconfigproxy
3838 }
3839 postIndex := iNdEx + intStringLen
3840 if postIndex < 0 {
3841 return ErrInvalidLengthNetworkconfigproxy
3842 }
3843 if postIndex > l {
3844 return io.ErrUnexpectedEOF
3845 }
3846 m.NicID = string(dAtA[iNdEx:postIndex])
3847 iNdEx = postIndex
3848 case 3:
3849 if wireType != 2 {
3850 return fmt.Errorf("proto: wrong wireType = %d for field EndpointName", wireType)
3851 }
3852 var stringLen uint64
3853 for shift := uint(0); ; shift += 7 {
3854 if shift >= 64 {
3855 return ErrIntOverflowNetworkconfigproxy
3856 }
3857 if iNdEx >= l {
3858 return io.ErrUnexpectedEOF
3859 }
3860 b := dAtA[iNdEx]
3861 iNdEx++
3862 stringLen |= uint64(b&0x7F) << shift
3863 if b < 0x80 {
3864 break
3865 }
3866 }
3867 intStringLen := int(stringLen)
3868 if intStringLen < 0 {
3869 return ErrInvalidLengthNetworkconfigproxy
3870 }
3871 postIndex := iNdEx + intStringLen
3872 if postIndex < 0 {
3873 return ErrInvalidLengthNetworkconfigproxy
3874 }
3875 if postIndex > l {
3876 return io.ErrUnexpectedEOF
3877 }
3878 m.EndpointName = string(dAtA[iNdEx:postIndex])
3879 iNdEx = postIndex
3880 default:
3881 iNdEx = preIndex
3882 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
3883 if err != nil {
3884 return err
3885 }
3886 if (skippy < 0) || (iNdEx+skippy) < 0 {
3887 return ErrInvalidLengthNetworkconfigproxy
3888 }
3889 if (iNdEx + skippy) > l {
3890 return io.ErrUnexpectedEOF
3891 }
3892 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
3893 iNdEx += skippy
3894 }
3895 }
3896
3897 if iNdEx > l {
3898 return io.ErrUnexpectedEOF
3899 }
3900 return nil
3901 }
3902 func (m *AddNICResponse) Unmarshal(dAtA []byte) error {
3903 l := len(dAtA)
3904 iNdEx := 0
3905 for iNdEx < l {
3906 preIndex := iNdEx
3907 var wire uint64
3908 for shift := uint(0); ; shift += 7 {
3909 if shift >= 64 {
3910 return ErrIntOverflowNetworkconfigproxy
3911 }
3912 if iNdEx >= l {
3913 return io.ErrUnexpectedEOF
3914 }
3915 b := dAtA[iNdEx]
3916 iNdEx++
3917 wire |= uint64(b&0x7F) << shift
3918 if b < 0x80 {
3919 break
3920 }
3921 }
3922 fieldNum := int32(wire >> 3)
3923 wireType := int(wire & 0x7)
3924 if wireType == 4 {
3925 return fmt.Errorf("proto: AddNICResponse: wiretype end group for non-group")
3926 }
3927 if fieldNum <= 0 {
3928 return fmt.Errorf("proto: AddNICResponse: illegal tag %d (wire type %d)", fieldNum, wire)
3929 }
3930 switch fieldNum {
3931 default:
3932 iNdEx = preIndex
3933 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
3934 if err != nil {
3935 return err
3936 }
3937 if (skippy < 0) || (iNdEx+skippy) < 0 {
3938 return ErrInvalidLengthNetworkconfigproxy
3939 }
3940 if (iNdEx + skippy) > l {
3941 return io.ErrUnexpectedEOF
3942 }
3943 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
3944 iNdEx += skippy
3945 }
3946 }
3947
3948 if iNdEx > l {
3949 return io.ErrUnexpectedEOF
3950 }
3951 return nil
3952 }
3953 func (m *ModifyNICRequest) Unmarshal(dAtA []byte) error {
3954 l := len(dAtA)
3955 iNdEx := 0
3956 for iNdEx < l {
3957 preIndex := iNdEx
3958 var wire uint64
3959 for shift := uint(0); ; shift += 7 {
3960 if shift >= 64 {
3961 return ErrIntOverflowNetworkconfigproxy
3962 }
3963 if iNdEx >= l {
3964 return io.ErrUnexpectedEOF
3965 }
3966 b := dAtA[iNdEx]
3967 iNdEx++
3968 wire |= uint64(b&0x7F) << shift
3969 if b < 0x80 {
3970 break
3971 }
3972 }
3973 fieldNum := int32(wire >> 3)
3974 wireType := int(wire & 0x7)
3975 if wireType == 4 {
3976 return fmt.Errorf("proto: ModifyNICRequest: wiretype end group for non-group")
3977 }
3978 if fieldNum <= 0 {
3979 return fmt.Errorf("proto: ModifyNICRequest: illegal tag %d (wire type %d)", fieldNum, wire)
3980 }
3981 switch fieldNum {
3982 case 1:
3983 if wireType != 2 {
3984 return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
3985 }
3986 var stringLen uint64
3987 for shift := uint(0); ; shift += 7 {
3988 if shift >= 64 {
3989 return ErrIntOverflowNetworkconfigproxy
3990 }
3991 if iNdEx >= l {
3992 return io.ErrUnexpectedEOF
3993 }
3994 b := dAtA[iNdEx]
3995 iNdEx++
3996 stringLen |= uint64(b&0x7F) << shift
3997 if b < 0x80 {
3998 break
3999 }
4000 }
4001 intStringLen := int(stringLen)
4002 if intStringLen < 0 {
4003 return ErrInvalidLengthNetworkconfigproxy
4004 }
4005 postIndex := iNdEx + intStringLen
4006 if postIndex < 0 {
4007 return ErrInvalidLengthNetworkconfigproxy
4008 }
4009 if postIndex > l {
4010 return io.ErrUnexpectedEOF
4011 }
4012 m.ContainerID = string(dAtA[iNdEx:postIndex])
4013 iNdEx = postIndex
4014 case 2:
4015 if wireType != 2 {
4016 return fmt.Errorf("proto: wrong wireType = %d for field NicID", wireType)
4017 }
4018 var stringLen uint64
4019 for shift := uint(0); ; shift += 7 {
4020 if shift >= 64 {
4021 return ErrIntOverflowNetworkconfigproxy
4022 }
4023 if iNdEx >= l {
4024 return io.ErrUnexpectedEOF
4025 }
4026 b := dAtA[iNdEx]
4027 iNdEx++
4028 stringLen |= uint64(b&0x7F) << shift
4029 if b < 0x80 {
4030 break
4031 }
4032 }
4033 intStringLen := int(stringLen)
4034 if intStringLen < 0 {
4035 return ErrInvalidLengthNetworkconfigproxy
4036 }
4037 postIndex := iNdEx + intStringLen
4038 if postIndex < 0 {
4039 return ErrInvalidLengthNetworkconfigproxy
4040 }
4041 if postIndex > l {
4042 return io.ErrUnexpectedEOF
4043 }
4044 m.NicID = string(dAtA[iNdEx:postIndex])
4045 iNdEx = postIndex
4046 case 3:
4047 if wireType != 2 {
4048 return fmt.Errorf("proto: wrong wireType = %d for field EndpointName", wireType)
4049 }
4050 var stringLen uint64
4051 for shift := uint(0); ; shift += 7 {
4052 if shift >= 64 {
4053 return ErrIntOverflowNetworkconfigproxy
4054 }
4055 if iNdEx >= l {
4056 return io.ErrUnexpectedEOF
4057 }
4058 b := dAtA[iNdEx]
4059 iNdEx++
4060 stringLen |= uint64(b&0x7F) << shift
4061 if b < 0x80 {
4062 break
4063 }
4064 }
4065 intStringLen := int(stringLen)
4066 if intStringLen < 0 {
4067 return ErrInvalidLengthNetworkconfigproxy
4068 }
4069 postIndex := iNdEx + intStringLen
4070 if postIndex < 0 {
4071 return ErrInvalidLengthNetworkconfigproxy
4072 }
4073 if postIndex > l {
4074 return io.ErrUnexpectedEOF
4075 }
4076 m.EndpointName = string(dAtA[iNdEx:postIndex])
4077 iNdEx = postIndex
4078 case 4:
4079 if wireType != 2 {
4080 return fmt.Errorf("proto: wrong wireType = %d for field IovPolicySettings", wireType)
4081 }
4082 var msglen int
4083 for shift := uint(0); ; shift += 7 {
4084 if shift >= 64 {
4085 return ErrIntOverflowNetworkconfigproxy
4086 }
4087 if iNdEx >= l {
4088 return io.ErrUnexpectedEOF
4089 }
4090 b := dAtA[iNdEx]
4091 iNdEx++
4092 msglen |= int(b&0x7F) << shift
4093 if b < 0x80 {
4094 break
4095 }
4096 }
4097 if msglen < 0 {
4098 return ErrInvalidLengthNetworkconfigproxy
4099 }
4100 postIndex := iNdEx + msglen
4101 if postIndex < 0 {
4102 return ErrInvalidLengthNetworkconfigproxy
4103 }
4104 if postIndex > l {
4105 return io.ErrUnexpectedEOF
4106 }
4107 if m.IovPolicySettings == nil {
4108 m.IovPolicySettings = &IovEndpointPolicySetting{}
4109 }
4110 if err := m.IovPolicySettings.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4111 return err
4112 }
4113 iNdEx = postIndex
4114 default:
4115 iNdEx = preIndex
4116 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
4117 if err != nil {
4118 return err
4119 }
4120 if (skippy < 0) || (iNdEx+skippy) < 0 {
4121 return ErrInvalidLengthNetworkconfigproxy
4122 }
4123 if (iNdEx + skippy) > l {
4124 return io.ErrUnexpectedEOF
4125 }
4126 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4127 iNdEx += skippy
4128 }
4129 }
4130
4131 if iNdEx > l {
4132 return io.ErrUnexpectedEOF
4133 }
4134 return nil
4135 }
4136 func (m *ModifyNICResponse) Unmarshal(dAtA []byte) error {
4137 l := len(dAtA)
4138 iNdEx := 0
4139 for iNdEx < l {
4140 preIndex := iNdEx
4141 var wire uint64
4142 for shift := uint(0); ; shift += 7 {
4143 if shift >= 64 {
4144 return ErrIntOverflowNetworkconfigproxy
4145 }
4146 if iNdEx >= l {
4147 return io.ErrUnexpectedEOF
4148 }
4149 b := dAtA[iNdEx]
4150 iNdEx++
4151 wire |= uint64(b&0x7F) << shift
4152 if b < 0x80 {
4153 break
4154 }
4155 }
4156 fieldNum := int32(wire >> 3)
4157 wireType := int(wire & 0x7)
4158 if wireType == 4 {
4159 return fmt.Errorf("proto: ModifyNICResponse: wiretype end group for non-group")
4160 }
4161 if fieldNum <= 0 {
4162 return fmt.Errorf("proto: ModifyNICResponse: illegal tag %d (wire type %d)", fieldNum, wire)
4163 }
4164 switch fieldNum {
4165 default:
4166 iNdEx = preIndex
4167 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
4168 if err != nil {
4169 return err
4170 }
4171 if (skippy < 0) || (iNdEx+skippy) < 0 {
4172 return ErrInvalidLengthNetworkconfigproxy
4173 }
4174 if (iNdEx + skippy) > l {
4175 return io.ErrUnexpectedEOF
4176 }
4177 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4178 iNdEx += skippy
4179 }
4180 }
4181
4182 if iNdEx > l {
4183 return io.ErrUnexpectedEOF
4184 }
4185 return nil
4186 }
4187 func (m *DeleteNICRequest) Unmarshal(dAtA []byte) error {
4188 l := len(dAtA)
4189 iNdEx := 0
4190 for iNdEx < l {
4191 preIndex := iNdEx
4192 var wire uint64
4193 for shift := uint(0); ; shift += 7 {
4194 if shift >= 64 {
4195 return ErrIntOverflowNetworkconfigproxy
4196 }
4197 if iNdEx >= l {
4198 return io.ErrUnexpectedEOF
4199 }
4200 b := dAtA[iNdEx]
4201 iNdEx++
4202 wire |= uint64(b&0x7F) << shift
4203 if b < 0x80 {
4204 break
4205 }
4206 }
4207 fieldNum := int32(wire >> 3)
4208 wireType := int(wire & 0x7)
4209 if wireType == 4 {
4210 return fmt.Errorf("proto: DeleteNICRequest: wiretype end group for non-group")
4211 }
4212 if fieldNum <= 0 {
4213 return fmt.Errorf("proto: DeleteNICRequest: illegal tag %d (wire type %d)", fieldNum, wire)
4214 }
4215 switch fieldNum {
4216 case 1:
4217 if wireType != 2 {
4218 return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
4219 }
4220 var stringLen uint64
4221 for shift := uint(0); ; shift += 7 {
4222 if shift >= 64 {
4223 return ErrIntOverflowNetworkconfigproxy
4224 }
4225 if iNdEx >= l {
4226 return io.ErrUnexpectedEOF
4227 }
4228 b := dAtA[iNdEx]
4229 iNdEx++
4230 stringLen |= uint64(b&0x7F) << shift
4231 if b < 0x80 {
4232 break
4233 }
4234 }
4235 intStringLen := int(stringLen)
4236 if intStringLen < 0 {
4237 return ErrInvalidLengthNetworkconfigproxy
4238 }
4239 postIndex := iNdEx + intStringLen
4240 if postIndex < 0 {
4241 return ErrInvalidLengthNetworkconfigproxy
4242 }
4243 if postIndex > l {
4244 return io.ErrUnexpectedEOF
4245 }
4246 m.ContainerID = string(dAtA[iNdEx:postIndex])
4247 iNdEx = postIndex
4248 case 2:
4249 if wireType != 2 {
4250 return fmt.Errorf("proto: wrong wireType = %d for field NicID", wireType)
4251 }
4252 var stringLen uint64
4253 for shift := uint(0); ; shift += 7 {
4254 if shift >= 64 {
4255 return ErrIntOverflowNetworkconfigproxy
4256 }
4257 if iNdEx >= l {
4258 return io.ErrUnexpectedEOF
4259 }
4260 b := dAtA[iNdEx]
4261 iNdEx++
4262 stringLen |= uint64(b&0x7F) << shift
4263 if b < 0x80 {
4264 break
4265 }
4266 }
4267 intStringLen := int(stringLen)
4268 if intStringLen < 0 {
4269 return ErrInvalidLengthNetworkconfigproxy
4270 }
4271 postIndex := iNdEx + intStringLen
4272 if postIndex < 0 {
4273 return ErrInvalidLengthNetworkconfigproxy
4274 }
4275 if postIndex > l {
4276 return io.ErrUnexpectedEOF
4277 }
4278 m.NicID = string(dAtA[iNdEx:postIndex])
4279 iNdEx = postIndex
4280 case 3:
4281 if wireType != 2 {
4282 return fmt.Errorf("proto: wrong wireType = %d for field EndpointName", wireType)
4283 }
4284 var stringLen uint64
4285 for shift := uint(0); ; shift += 7 {
4286 if shift >= 64 {
4287 return ErrIntOverflowNetworkconfigproxy
4288 }
4289 if iNdEx >= l {
4290 return io.ErrUnexpectedEOF
4291 }
4292 b := dAtA[iNdEx]
4293 iNdEx++
4294 stringLen |= uint64(b&0x7F) << shift
4295 if b < 0x80 {
4296 break
4297 }
4298 }
4299 intStringLen := int(stringLen)
4300 if intStringLen < 0 {
4301 return ErrInvalidLengthNetworkconfigproxy
4302 }
4303 postIndex := iNdEx + intStringLen
4304 if postIndex < 0 {
4305 return ErrInvalidLengthNetworkconfigproxy
4306 }
4307 if postIndex > l {
4308 return io.ErrUnexpectedEOF
4309 }
4310 m.EndpointName = string(dAtA[iNdEx:postIndex])
4311 iNdEx = postIndex
4312 default:
4313 iNdEx = preIndex
4314 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
4315 if err != nil {
4316 return err
4317 }
4318 if (skippy < 0) || (iNdEx+skippy) < 0 {
4319 return ErrInvalidLengthNetworkconfigproxy
4320 }
4321 if (iNdEx + skippy) > l {
4322 return io.ErrUnexpectedEOF
4323 }
4324 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4325 iNdEx += skippy
4326 }
4327 }
4328
4329 if iNdEx > l {
4330 return io.ErrUnexpectedEOF
4331 }
4332 return nil
4333 }
4334 func (m *DeleteNICResponse) Unmarshal(dAtA []byte) error {
4335 l := len(dAtA)
4336 iNdEx := 0
4337 for iNdEx < l {
4338 preIndex := iNdEx
4339 var wire uint64
4340 for shift := uint(0); ; shift += 7 {
4341 if shift >= 64 {
4342 return ErrIntOverflowNetworkconfigproxy
4343 }
4344 if iNdEx >= l {
4345 return io.ErrUnexpectedEOF
4346 }
4347 b := dAtA[iNdEx]
4348 iNdEx++
4349 wire |= uint64(b&0x7F) << shift
4350 if b < 0x80 {
4351 break
4352 }
4353 }
4354 fieldNum := int32(wire >> 3)
4355 wireType := int(wire & 0x7)
4356 if wireType == 4 {
4357 return fmt.Errorf("proto: DeleteNICResponse: wiretype end group for non-group")
4358 }
4359 if fieldNum <= 0 {
4360 return fmt.Errorf("proto: DeleteNICResponse: illegal tag %d (wire type %d)", fieldNum, wire)
4361 }
4362 switch fieldNum {
4363 default:
4364 iNdEx = preIndex
4365 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
4366 if err != nil {
4367 return err
4368 }
4369 if (skippy < 0) || (iNdEx+skippy) < 0 {
4370 return ErrInvalidLengthNetworkconfigproxy
4371 }
4372 if (iNdEx + skippy) > l {
4373 return io.ErrUnexpectedEOF
4374 }
4375 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4376 iNdEx += skippy
4377 }
4378 }
4379
4380 if iNdEx > l {
4381 return io.ErrUnexpectedEOF
4382 }
4383 return nil
4384 }
4385 func (m *CreateNetworkRequest) Unmarshal(dAtA []byte) error {
4386 l := len(dAtA)
4387 iNdEx := 0
4388 for iNdEx < l {
4389 preIndex := iNdEx
4390 var wire uint64
4391 for shift := uint(0); ; shift += 7 {
4392 if shift >= 64 {
4393 return ErrIntOverflowNetworkconfigproxy
4394 }
4395 if iNdEx >= l {
4396 return io.ErrUnexpectedEOF
4397 }
4398 b := dAtA[iNdEx]
4399 iNdEx++
4400 wire |= uint64(b&0x7F) << shift
4401 if b < 0x80 {
4402 break
4403 }
4404 }
4405 fieldNum := int32(wire >> 3)
4406 wireType := int(wire & 0x7)
4407 if wireType == 4 {
4408 return fmt.Errorf("proto: CreateNetworkRequest: wiretype end group for non-group")
4409 }
4410 if fieldNum <= 0 {
4411 return fmt.Errorf("proto: CreateNetworkRequest: illegal tag %d (wire type %d)", fieldNum, wire)
4412 }
4413 switch fieldNum {
4414 case 1:
4415 if wireType != 2 {
4416 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
4417 }
4418 var stringLen uint64
4419 for shift := uint(0); ; shift += 7 {
4420 if shift >= 64 {
4421 return ErrIntOverflowNetworkconfigproxy
4422 }
4423 if iNdEx >= l {
4424 return io.ErrUnexpectedEOF
4425 }
4426 b := dAtA[iNdEx]
4427 iNdEx++
4428 stringLen |= uint64(b&0x7F) << shift
4429 if b < 0x80 {
4430 break
4431 }
4432 }
4433 intStringLen := int(stringLen)
4434 if intStringLen < 0 {
4435 return ErrInvalidLengthNetworkconfigproxy
4436 }
4437 postIndex := iNdEx + intStringLen
4438 if postIndex < 0 {
4439 return ErrInvalidLengthNetworkconfigproxy
4440 }
4441 if postIndex > l {
4442 return io.ErrUnexpectedEOF
4443 }
4444 m.Name = string(dAtA[iNdEx:postIndex])
4445 iNdEx = postIndex
4446 case 2:
4447 if wireType != 0 {
4448 return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
4449 }
4450 m.Mode = 0
4451 for shift := uint(0); ; shift += 7 {
4452 if shift >= 64 {
4453 return ErrIntOverflowNetworkconfigproxy
4454 }
4455 if iNdEx >= l {
4456 return io.ErrUnexpectedEOF
4457 }
4458 b := dAtA[iNdEx]
4459 iNdEx++
4460 m.Mode |= CreateNetworkRequest_NetworkMode(b&0x7F) << shift
4461 if b < 0x80 {
4462 break
4463 }
4464 }
4465 case 3:
4466 if wireType != 2 {
4467 return fmt.Errorf("proto: wrong wireType = %d for field SwitchName", wireType)
4468 }
4469 var stringLen uint64
4470 for shift := uint(0); ; shift += 7 {
4471 if shift >= 64 {
4472 return ErrIntOverflowNetworkconfigproxy
4473 }
4474 if iNdEx >= l {
4475 return io.ErrUnexpectedEOF
4476 }
4477 b := dAtA[iNdEx]
4478 iNdEx++
4479 stringLen |= uint64(b&0x7F) << shift
4480 if b < 0x80 {
4481 break
4482 }
4483 }
4484 intStringLen := int(stringLen)
4485 if intStringLen < 0 {
4486 return ErrInvalidLengthNetworkconfigproxy
4487 }
4488 postIndex := iNdEx + intStringLen
4489 if postIndex < 0 {
4490 return ErrInvalidLengthNetworkconfigproxy
4491 }
4492 if postIndex > l {
4493 return io.ErrUnexpectedEOF
4494 }
4495 m.SwitchName = string(dAtA[iNdEx:postIndex])
4496 iNdEx = postIndex
4497 case 4:
4498 if wireType != 0 {
4499 return fmt.Errorf("proto: wrong wireType = %d for field IpamType", wireType)
4500 }
4501 m.IpamType = 0
4502 for shift := uint(0); ; shift += 7 {
4503 if shift >= 64 {
4504 return ErrIntOverflowNetworkconfigproxy
4505 }
4506 if iNdEx >= l {
4507 return io.ErrUnexpectedEOF
4508 }
4509 b := dAtA[iNdEx]
4510 iNdEx++
4511 m.IpamType |= CreateNetworkRequest_IpamType(b&0x7F) << shift
4512 if b < 0x80 {
4513 break
4514 }
4515 }
4516 case 5:
4517 if wireType != 2 {
4518 return fmt.Errorf("proto: wrong wireType = %d for field SubnetIpaddressPrefix", wireType)
4519 }
4520 var stringLen uint64
4521 for shift := uint(0); ; shift += 7 {
4522 if shift >= 64 {
4523 return ErrIntOverflowNetworkconfigproxy
4524 }
4525 if iNdEx >= l {
4526 return io.ErrUnexpectedEOF
4527 }
4528 b := dAtA[iNdEx]
4529 iNdEx++
4530 stringLen |= uint64(b&0x7F) << shift
4531 if b < 0x80 {
4532 break
4533 }
4534 }
4535 intStringLen := int(stringLen)
4536 if intStringLen < 0 {
4537 return ErrInvalidLengthNetworkconfigproxy
4538 }
4539 postIndex := iNdEx + intStringLen
4540 if postIndex < 0 {
4541 return ErrInvalidLengthNetworkconfigproxy
4542 }
4543 if postIndex > l {
4544 return io.ErrUnexpectedEOF
4545 }
4546 m.SubnetIpaddressPrefix = append(m.SubnetIpaddressPrefix, string(dAtA[iNdEx:postIndex]))
4547 iNdEx = postIndex
4548 case 6:
4549 if wireType != 2 {
4550 return fmt.Errorf("proto: wrong wireType = %d for field DefaultGateway", wireType)
4551 }
4552 var stringLen uint64
4553 for shift := uint(0); ; shift += 7 {
4554 if shift >= 64 {
4555 return ErrIntOverflowNetworkconfigproxy
4556 }
4557 if iNdEx >= l {
4558 return io.ErrUnexpectedEOF
4559 }
4560 b := dAtA[iNdEx]
4561 iNdEx++
4562 stringLen |= uint64(b&0x7F) << shift
4563 if b < 0x80 {
4564 break
4565 }
4566 }
4567 intStringLen := int(stringLen)
4568 if intStringLen < 0 {
4569 return ErrInvalidLengthNetworkconfigproxy
4570 }
4571 postIndex := iNdEx + intStringLen
4572 if postIndex < 0 {
4573 return ErrInvalidLengthNetworkconfigproxy
4574 }
4575 if postIndex > l {
4576 return io.ErrUnexpectedEOF
4577 }
4578 m.DefaultGateway = string(dAtA[iNdEx:postIndex])
4579 iNdEx = postIndex
4580 default:
4581 iNdEx = preIndex
4582 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
4583 if err != nil {
4584 return err
4585 }
4586 if (skippy < 0) || (iNdEx+skippy) < 0 {
4587 return ErrInvalidLengthNetworkconfigproxy
4588 }
4589 if (iNdEx + skippy) > l {
4590 return io.ErrUnexpectedEOF
4591 }
4592 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4593 iNdEx += skippy
4594 }
4595 }
4596
4597 if iNdEx > l {
4598 return io.ErrUnexpectedEOF
4599 }
4600 return nil
4601 }
4602 func (m *CreateNetworkResponse) Unmarshal(dAtA []byte) error {
4603 l := len(dAtA)
4604 iNdEx := 0
4605 for iNdEx < l {
4606 preIndex := iNdEx
4607 var wire uint64
4608 for shift := uint(0); ; shift += 7 {
4609 if shift >= 64 {
4610 return ErrIntOverflowNetworkconfigproxy
4611 }
4612 if iNdEx >= l {
4613 return io.ErrUnexpectedEOF
4614 }
4615 b := dAtA[iNdEx]
4616 iNdEx++
4617 wire |= uint64(b&0x7F) << shift
4618 if b < 0x80 {
4619 break
4620 }
4621 }
4622 fieldNum := int32(wire >> 3)
4623 wireType := int(wire & 0x7)
4624 if wireType == 4 {
4625 return fmt.Errorf("proto: CreateNetworkResponse: wiretype end group for non-group")
4626 }
4627 if fieldNum <= 0 {
4628 return fmt.Errorf("proto: CreateNetworkResponse: illegal tag %d (wire type %d)", fieldNum, wire)
4629 }
4630 switch fieldNum {
4631 case 1:
4632 if wireType != 2 {
4633 return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
4634 }
4635 var stringLen uint64
4636 for shift := uint(0); ; shift += 7 {
4637 if shift >= 64 {
4638 return ErrIntOverflowNetworkconfigproxy
4639 }
4640 if iNdEx >= l {
4641 return io.ErrUnexpectedEOF
4642 }
4643 b := dAtA[iNdEx]
4644 iNdEx++
4645 stringLen |= uint64(b&0x7F) << shift
4646 if b < 0x80 {
4647 break
4648 }
4649 }
4650 intStringLen := int(stringLen)
4651 if intStringLen < 0 {
4652 return ErrInvalidLengthNetworkconfigproxy
4653 }
4654 postIndex := iNdEx + intStringLen
4655 if postIndex < 0 {
4656 return ErrInvalidLengthNetworkconfigproxy
4657 }
4658 if postIndex > l {
4659 return io.ErrUnexpectedEOF
4660 }
4661 m.ID = string(dAtA[iNdEx:postIndex])
4662 iNdEx = postIndex
4663 default:
4664 iNdEx = preIndex
4665 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
4666 if err != nil {
4667 return err
4668 }
4669 if (skippy < 0) || (iNdEx+skippy) < 0 {
4670 return ErrInvalidLengthNetworkconfigproxy
4671 }
4672 if (iNdEx + skippy) > l {
4673 return io.ErrUnexpectedEOF
4674 }
4675 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4676 iNdEx += skippy
4677 }
4678 }
4679
4680 if iNdEx > l {
4681 return io.ErrUnexpectedEOF
4682 }
4683 return nil
4684 }
4685 func (m *PortNameEndpointPolicySetting) Unmarshal(dAtA []byte) error {
4686 l := len(dAtA)
4687 iNdEx := 0
4688 for iNdEx < l {
4689 preIndex := iNdEx
4690 var wire uint64
4691 for shift := uint(0); ; shift += 7 {
4692 if shift >= 64 {
4693 return ErrIntOverflowNetworkconfigproxy
4694 }
4695 if iNdEx >= l {
4696 return io.ErrUnexpectedEOF
4697 }
4698 b := dAtA[iNdEx]
4699 iNdEx++
4700 wire |= uint64(b&0x7F) << shift
4701 if b < 0x80 {
4702 break
4703 }
4704 }
4705 fieldNum := int32(wire >> 3)
4706 wireType := int(wire & 0x7)
4707 if wireType == 4 {
4708 return fmt.Errorf("proto: PortNameEndpointPolicySetting: wiretype end group for non-group")
4709 }
4710 if fieldNum <= 0 {
4711 return fmt.Errorf("proto: PortNameEndpointPolicySetting: illegal tag %d (wire type %d)", fieldNum, wire)
4712 }
4713 switch fieldNum {
4714 case 1:
4715 if wireType != 2 {
4716 return fmt.Errorf("proto: wrong wireType = %d for field PortName", wireType)
4717 }
4718 var stringLen uint64
4719 for shift := uint(0); ; shift += 7 {
4720 if shift >= 64 {
4721 return ErrIntOverflowNetworkconfigproxy
4722 }
4723 if iNdEx >= l {
4724 return io.ErrUnexpectedEOF
4725 }
4726 b := dAtA[iNdEx]
4727 iNdEx++
4728 stringLen |= uint64(b&0x7F) << shift
4729 if b < 0x80 {
4730 break
4731 }
4732 }
4733 intStringLen := int(stringLen)
4734 if intStringLen < 0 {
4735 return ErrInvalidLengthNetworkconfigproxy
4736 }
4737 postIndex := iNdEx + intStringLen
4738 if postIndex < 0 {
4739 return ErrInvalidLengthNetworkconfigproxy
4740 }
4741 if postIndex > l {
4742 return io.ErrUnexpectedEOF
4743 }
4744 m.PortName = string(dAtA[iNdEx:postIndex])
4745 iNdEx = postIndex
4746 default:
4747 iNdEx = preIndex
4748 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
4749 if err != nil {
4750 return err
4751 }
4752 if (skippy < 0) || (iNdEx+skippy) < 0 {
4753 return ErrInvalidLengthNetworkconfigproxy
4754 }
4755 if (iNdEx + skippy) > l {
4756 return io.ErrUnexpectedEOF
4757 }
4758 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4759 iNdEx += skippy
4760 }
4761 }
4762
4763 if iNdEx > l {
4764 return io.ErrUnexpectedEOF
4765 }
4766 return nil
4767 }
4768 func (m *IovEndpointPolicySetting) Unmarshal(dAtA []byte) error {
4769 l := len(dAtA)
4770 iNdEx := 0
4771 for iNdEx < l {
4772 preIndex := iNdEx
4773 var wire uint64
4774 for shift := uint(0); ; shift += 7 {
4775 if shift >= 64 {
4776 return ErrIntOverflowNetworkconfigproxy
4777 }
4778 if iNdEx >= l {
4779 return io.ErrUnexpectedEOF
4780 }
4781 b := dAtA[iNdEx]
4782 iNdEx++
4783 wire |= uint64(b&0x7F) << shift
4784 if b < 0x80 {
4785 break
4786 }
4787 }
4788 fieldNum := int32(wire >> 3)
4789 wireType := int(wire & 0x7)
4790 if wireType == 4 {
4791 return fmt.Errorf("proto: IovEndpointPolicySetting: wiretype end group for non-group")
4792 }
4793 if fieldNum <= 0 {
4794 return fmt.Errorf("proto: IovEndpointPolicySetting: illegal tag %d (wire type %d)", fieldNum, wire)
4795 }
4796 switch fieldNum {
4797 case 1:
4798 if wireType != 0 {
4799 return fmt.Errorf("proto: wrong wireType = %d for field IovOffloadWeight", wireType)
4800 }
4801 m.IovOffloadWeight = 0
4802 for shift := uint(0); ; shift += 7 {
4803 if shift >= 64 {
4804 return ErrIntOverflowNetworkconfigproxy
4805 }
4806 if iNdEx >= l {
4807 return io.ErrUnexpectedEOF
4808 }
4809 b := dAtA[iNdEx]
4810 iNdEx++
4811 m.IovOffloadWeight |= uint32(b&0x7F) << shift
4812 if b < 0x80 {
4813 break
4814 }
4815 }
4816 case 2:
4817 if wireType != 0 {
4818 return fmt.Errorf("proto: wrong wireType = %d for field QueuePairsRequested", wireType)
4819 }
4820 m.QueuePairsRequested = 0
4821 for shift := uint(0); ; shift += 7 {
4822 if shift >= 64 {
4823 return ErrIntOverflowNetworkconfigproxy
4824 }
4825 if iNdEx >= l {
4826 return io.ErrUnexpectedEOF
4827 }
4828 b := dAtA[iNdEx]
4829 iNdEx++
4830 m.QueuePairsRequested |= uint32(b&0x7F) << shift
4831 if b < 0x80 {
4832 break
4833 }
4834 }
4835 case 3:
4836 if wireType != 0 {
4837 return fmt.Errorf("proto: wrong wireType = %d for field InterruptModeration", wireType)
4838 }
4839 m.InterruptModeration = 0
4840 for shift := uint(0); ; shift += 7 {
4841 if shift >= 64 {
4842 return ErrIntOverflowNetworkconfigproxy
4843 }
4844 if iNdEx >= l {
4845 return io.ErrUnexpectedEOF
4846 }
4847 b := dAtA[iNdEx]
4848 iNdEx++
4849 m.InterruptModeration |= uint32(b&0x7F) << shift
4850 if b < 0x80 {
4851 break
4852 }
4853 }
4854 default:
4855 iNdEx = preIndex
4856 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
4857 if err != nil {
4858 return err
4859 }
4860 if (skippy < 0) || (iNdEx+skippy) < 0 {
4861 return ErrInvalidLengthNetworkconfigproxy
4862 }
4863 if (iNdEx + skippy) > l {
4864 return io.ErrUnexpectedEOF
4865 }
4866 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4867 iNdEx += skippy
4868 }
4869 }
4870
4871 if iNdEx > l {
4872 return io.ErrUnexpectedEOF
4873 }
4874 return nil
4875 }
4876 func (m *DnsSetting) Unmarshal(dAtA []byte) error {
4877 l := len(dAtA)
4878 iNdEx := 0
4879 for iNdEx < l {
4880 preIndex := iNdEx
4881 var wire uint64
4882 for shift := uint(0); ; shift += 7 {
4883 if shift >= 64 {
4884 return ErrIntOverflowNetworkconfigproxy
4885 }
4886 if iNdEx >= l {
4887 return io.ErrUnexpectedEOF
4888 }
4889 b := dAtA[iNdEx]
4890 iNdEx++
4891 wire |= uint64(b&0x7F) << shift
4892 if b < 0x80 {
4893 break
4894 }
4895 }
4896 fieldNum := int32(wire >> 3)
4897 wireType := int(wire & 0x7)
4898 if wireType == 4 {
4899 return fmt.Errorf("proto: DnsSetting: wiretype end group for non-group")
4900 }
4901 if fieldNum <= 0 {
4902 return fmt.Errorf("proto: DnsSetting: illegal tag %d (wire type %d)", fieldNum, wire)
4903 }
4904 switch fieldNum {
4905 case 1:
4906 if wireType != 2 {
4907 return fmt.Errorf("proto: wrong wireType = %d for field ServerIpAddrs", wireType)
4908 }
4909 var stringLen uint64
4910 for shift := uint(0); ; shift += 7 {
4911 if shift >= 64 {
4912 return ErrIntOverflowNetworkconfigproxy
4913 }
4914 if iNdEx >= l {
4915 return io.ErrUnexpectedEOF
4916 }
4917 b := dAtA[iNdEx]
4918 iNdEx++
4919 stringLen |= uint64(b&0x7F) << shift
4920 if b < 0x80 {
4921 break
4922 }
4923 }
4924 intStringLen := int(stringLen)
4925 if intStringLen < 0 {
4926 return ErrInvalidLengthNetworkconfigproxy
4927 }
4928 postIndex := iNdEx + intStringLen
4929 if postIndex < 0 {
4930 return ErrInvalidLengthNetworkconfigproxy
4931 }
4932 if postIndex > l {
4933 return io.ErrUnexpectedEOF
4934 }
4935 m.ServerIpAddrs = append(m.ServerIpAddrs, string(dAtA[iNdEx:postIndex]))
4936 iNdEx = postIndex
4937 case 2:
4938 if wireType != 2 {
4939 return fmt.Errorf("proto: wrong wireType = %d for field Domain", wireType)
4940 }
4941 var stringLen uint64
4942 for shift := uint(0); ; shift += 7 {
4943 if shift >= 64 {
4944 return ErrIntOverflowNetworkconfigproxy
4945 }
4946 if iNdEx >= l {
4947 return io.ErrUnexpectedEOF
4948 }
4949 b := dAtA[iNdEx]
4950 iNdEx++
4951 stringLen |= uint64(b&0x7F) << shift
4952 if b < 0x80 {
4953 break
4954 }
4955 }
4956 intStringLen := int(stringLen)
4957 if intStringLen < 0 {
4958 return ErrInvalidLengthNetworkconfigproxy
4959 }
4960 postIndex := iNdEx + intStringLen
4961 if postIndex < 0 {
4962 return ErrInvalidLengthNetworkconfigproxy
4963 }
4964 if postIndex > l {
4965 return io.ErrUnexpectedEOF
4966 }
4967 m.Domain = string(dAtA[iNdEx:postIndex])
4968 iNdEx = postIndex
4969 case 3:
4970 if wireType != 2 {
4971 return fmt.Errorf("proto: wrong wireType = %d for field Search", wireType)
4972 }
4973 var stringLen uint64
4974 for shift := uint(0); ; shift += 7 {
4975 if shift >= 64 {
4976 return ErrIntOverflowNetworkconfigproxy
4977 }
4978 if iNdEx >= l {
4979 return io.ErrUnexpectedEOF
4980 }
4981 b := dAtA[iNdEx]
4982 iNdEx++
4983 stringLen |= uint64(b&0x7F) << shift
4984 if b < 0x80 {
4985 break
4986 }
4987 }
4988 intStringLen := int(stringLen)
4989 if intStringLen < 0 {
4990 return ErrInvalidLengthNetworkconfigproxy
4991 }
4992 postIndex := iNdEx + intStringLen
4993 if postIndex < 0 {
4994 return ErrInvalidLengthNetworkconfigproxy
4995 }
4996 if postIndex > l {
4997 return io.ErrUnexpectedEOF
4998 }
4999 m.Search = append(m.Search, string(dAtA[iNdEx:postIndex]))
5000 iNdEx = postIndex
5001 default:
5002 iNdEx = preIndex
5003 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
5004 if err != nil {
5005 return err
5006 }
5007 if (skippy < 0) || (iNdEx+skippy) < 0 {
5008 return ErrInvalidLengthNetworkconfigproxy
5009 }
5010 if (iNdEx + skippy) > l {
5011 return io.ErrUnexpectedEOF
5012 }
5013 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5014 iNdEx += skippy
5015 }
5016 }
5017
5018 if iNdEx > l {
5019 return io.ErrUnexpectedEOF
5020 }
5021 return nil
5022 }
5023 func (m *CreateEndpointRequest) Unmarshal(dAtA []byte) error {
5024 l := len(dAtA)
5025 iNdEx := 0
5026 for iNdEx < l {
5027 preIndex := iNdEx
5028 var wire uint64
5029 for shift := uint(0); ; shift += 7 {
5030 if shift >= 64 {
5031 return ErrIntOverflowNetworkconfigproxy
5032 }
5033 if iNdEx >= l {
5034 return io.ErrUnexpectedEOF
5035 }
5036 b := dAtA[iNdEx]
5037 iNdEx++
5038 wire |= uint64(b&0x7F) << shift
5039 if b < 0x80 {
5040 break
5041 }
5042 }
5043 fieldNum := int32(wire >> 3)
5044 wireType := int(wire & 0x7)
5045 if wireType == 4 {
5046 return fmt.Errorf("proto: CreateEndpointRequest: wiretype end group for non-group")
5047 }
5048 if fieldNum <= 0 {
5049 return fmt.Errorf("proto: CreateEndpointRequest: illegal tag %d (wire type %d)", fieldNum, wire)
5050 }
5051 switch fieldNum {
5052 case 1:
5053 if wireType != 2 {
5054 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
5055 }
5056 var stringLen uint64
5057 for shift := uint(0); ; shift += 7 {
5058 if shift >= 64 {
5059 return ErrIntOverflowNetworkconfigproxy
5060 }
5061 if iNdEx >= l {
5062 return io.ErrUnexpectedEOF
5063 }
5064 b := dAtA[iNdEx]
5065 iNdEx++
5066 stringLen |= uint64(b&0x7F) << shift
5067 if b < 0x80 {
5068 break
5069 }
5070 }
5071 intStringLen := int(stringLen)
5072 if intStringLen < 0 {
5073 return ErrInvalidLengthNetworkconfigproxy
5074 }
5075 postIndex := iNdEx + intStringLen
5076 if postIndex < 0 {
5077 return ErrInvalidLengthNetworkconfigproxy
5078 }
5079 if postIndex > l {
5080 return io.ErrUnexpectedEOF
5081 }
5082 m.Name = string(dAtA[iNdEx:postIndex])
5083 iNdEx = postIndex
5084 case 2:
5085 if wireType != 2 {
5086 return fmt.Errorf("proto: wrong wireType = %d for field Macaddress", wireType)
5087 }
5088 var stringLen uint64
5089 for shift := uint(0); ; shift += 7 {
5090 if shift >= 64 {
5091 return ErrIntOverflowNetworkconfigproxy
5092 }
5093 if iNdEx >= l {
5094 return io.ErrUnexpectedEOF
5095 }
5096 b := dAtA[iNdEx]
5097 iNdEx++
5098 stringLen |= uint64(b&0x7F) << shift
5099 if b < 0x80 {
5100 break
5101 }
5102 }
5103 intStringLen := int(stringLen)
5104 if intStringLen < 0 {
5105 return ErrInvalidLengthNetworkconfigproxy
5106 }
5107 postIndex := iNdEx + intStringLen
5108 if postIndex < 0 {
5109 return ErrInvalidLengthNetworkconfigproxy
5110 }
5111 if postIndex > l {
5112 return io.ErrUnexpectedEOF
5113 }
5114 m.Macaddress = string(dAtA[iNdEx:postIndex])
5115 iNdEx = postIndex
5116 case 3:
5117 if wireType != 2 {
5118 return fmt.Errorf("proto: wrong wireType = %d for field Ipaddress", wireType)
5119 }
5120 var stringLen uint64
5121 for shift := uint(0); ; shift += 7 {
5122 if shift >= 64 {
5123 return ErrIntOverflowNetworkconfigproxy
5124 }
5125 if iNdEx >= l {
5126 return io.ErrUnexpectedEOF
5127 }
5128 b := dAtA[iNdEx]
5129 iNdEx++
5130 stringLen |= uint64(b&0x7F) << shift
5131 if b < 0x80 {
5132 break
5133 }
5134 }
5135 intStringLen := int(stringLen)
5136 if intStringLen < 0 {
5137 return ErrInvalidLengthNetworkconfigproxy
5138 }
5139 postIndex := iNdEx + intStringLen
5140 if postIndex < 0 {
5141 return ErrInvalidLengthNetworkconfigproxy
5142 }
5143 if postIndex > l {
5144 return io.ErrUnexpectedEOF
5145 }
5146 m.Ipaddress = string(dAtA[iNdEx:postIndex])
5147 iNdEx = postIndex
5148 case 4:
5149 if wireType != 2 {
5150 return fmt.Errorf("proto: wrong wireType = %d for field IpaddressPrefixlength", wireType)
5151 }
5152 var stringLen uint64
5153 for shift := uint(0); ; shift += 7 {
5154 if shift >= 64 {
5155 return ErrIntOverflowNetworkconfigproxy
5156 }
5157 if iNdEx >= l {
5158 return io.ErrUnexpectedEOF
5159 }
5160 b := dAtA[iNdEx]
5161 iNdEx++
5162 stringLen |= uint64(b&0x7F) << shift
5163 if b < 0x80 {
5164 break
5165 }
5166 }
5167 intStringLen := int(stringLen)
5168 if intStringLen < 0 {
5169 return ErrInvalidLengthNetworkconfigproxy
5170 }
5171 postIndex := iNdEx + intStringLen
5172 if postIndex < 0 {
5173 return ErrInvalidLengthNetworkconfigproxy
5174 }
5175 if postIndex > l {
5176 return io.ErrUnexpectedEOF
5177 }
5178 m.IpaddressPrefixlength = string(dAtA[iNdEx:postIndex])
5179 iNdEx = postIndex
5180 case 5:
5181 if wireType != 2 {
5182 return fmt.Errorf("proto: wrong wireType = %d for field NetworkName", wireType)
5183 }
5184 var stringLen uint64
5185 for shift := uint(0); ; shift += 7 {
5186 if shift >= 64 {
5187 return ErrIntOverflowNetworkconfigproxy
5188 }
5189 if iNdEx >= l {
5190 return io.ErrUnexpectedEOF
5191 }
5192 b := dAtA[iNdEx]
5193 iNdEx++
5194 stringLen |= uint64(b&0x7F) << shift
5195 if b < 0x80 {
5196 break
5197 }
5198 }
5199 intStringLen := int(stringLen)
5200 if intStringLen < 0 {
5201 return ErrInvalidLengthNetworkconfigproxy
5202 }
5203 postIndex := iNdEx + intStringLen
5204 if postIndex < 0 {
5205 return ErrInvalidLengthNetworkconfigproxy
5206 }
5207 if postIndex > l {
5208 return io.ErrUnexpectedEOF
5209 }
5210 m.NetworkName = string(dAtA[iNdEx:postIndex])
5211 iNdEx = postIndex
5212 case 6:
5213 if wireType != 2 {
5214 return fmt.Errorf("proto: wrong wireType = %d for field PortnamePolicySetting", wireType)
5215 }
5216 var msglen int
5217 for shift := uint(0); ; shift += 7 {
5218 if shift >= 64 {
5219 return ErrIntOverflowNetworkconfigproxy
5220 }
5221 if iNdEx >= l {
5222 return io.ErrUnexpectedEOF
5223 }
5224 b := dAtA[iNdEx]
5225 iNdEx++
5226 msglen |= int(b&0x7F) << shift
5227 if b < 0x80 {
5228 break
5229 }
5230 }
5231 if msglen < 0 {
5232 return ErrInvalidLengthNetworkconfigproxy
5233 }
5234 postIndex := iNdEx + msglen
5235 if postIndex < 0 {
5236 return ErrInvalidLengthNetworkconfigproxy
5237 }
5238 if postIndex > l {
5239 return io.ErrUnexpectedEOF
5240 }
5241 if m.PortnamePolicySetting == nil {
5242 m.PortnamePolicySetting = &PortNameEndpointPolicySetting{}
5243 }
5244 if err := m.PortnamePolicySetting.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5245 return err
5246 }
5247 iNdEx = postIndex
5248 case 7:
5249 if wireType != 2 {
5250 return fmt.Errorf("proto: wrong wireType = %d for field IovPolicySettings", wireType)
5251 }
5252 var msglen int
5253 for shift := uint(0); ; shift += 7 {
5254 if shift >= 64 {
5255 return ErrIntOverflowNetworkconfigproxy
5256 }
5257 if iNdEx >= l {
5258 return io.ErrUnexpectedEOF
5259 }
5260 b := dAtA[iNdEx]
5261 iNdEx++
5262 msglen |= int(b&0x7F) << shift
5263 if b < 0x80 {
5264 break
5265 }
5266 }
5267 if msglen < 0 {
5268 return ErrInvalidLengthNetworkconfigproxy
5269 }
5270 postIndex := iNdEx + msglen
5271 if postIndex < 0 {
5272 return ErrInvalidLengthNetworkconfigproxy
5273 }
5274 if postIndex > l {
5275 return io.ErrUnexpectedEOF
5276 }
5277 if m.IovPolicySettings == nil {
5278 m.IovPolicySettings = &IovEndpointPolicySetting{}
5279 }
5280 if err := m.IovPolicySettings.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5281 return err
5282 }
5283 iNdEx = postIndex
5284 case 16:
5285 if wireType != 2 {
5286 return fmt.Errorf("proto: wrong wireType = %d for field DnsSetting", wireType)
5287 }
5288 var msglen int
5289 for shift := uint(0); ; shift += 7 {
5290 if shift >= 64 {
5291 return ErrIntOverflowNetworkconfigproxy
5292 }
5293 if iNdEx >= l {
5294 return io.ErrUnexpectedEOF
5295 }
5296 b := dAtA[iNdEx]
5297 iNdEx++
5298 msglen |= int(b&0x7F) << shift
5299 if b < 0x80 {
5300 break
5301 }
5302 }
5303 if msglen < 0 {
5304 return ErrInvalidLengthNetworkconfigproxy
5305 }
5306 postIndex := iNdEx + msglen
5307 if postIndex < 0 {
5308 return ErrInvalidLengthNetworkconfigproxy
5309 }
5310 if postIndex > l {
5311 return io.ErrUnexpectedEOF
5312 }
5313 if m.DnsSetting == nil {
5314 m.DnsSetting = &DnsSetting{}
5315 }
5316 if err := m.DnsSetting.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5317 return err
5318 }
5319 iNdEx = postIndex
5320 default:
5321 iNdEx = preIndex
5322 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
5323 if err != nil {
5324 return err
5325 }
5326 if (skippy < 0) || (iNdEx+skippy) < 0 {
5327 return ErrInvalidLengthNetworkconfigproxy
5328 }
5329 if (iNdEx + skippy) > l {
5330 return io.ErrUnexpectedEOF
5331 }
5332 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5333 iNdEx += skippy
5334 }
5335 }
5336
5337 if iNdEx > l {
5338 return io.ErrUnexpectedEOF
5339 }
5340 return nil
5341 }
5342 func (m *CreateEndpointResponse) Unmarshal(dAtA []byte) error {
5343 l := len(dAtA)
5344 iNdEx := 0
5345 for iNdEx < l {
5346 preIndex := iNdEx
5347 var wire uint64
5348 for shift := uint(0); ; shift += 7 {
5349 if shift >= 64 {
5350 return ErrIntOverflowNetworkconfigproxy
5351 }
5352 if iNdEx >= l {
5353 return io.ErrUnexpectedEOF
5354 }
5355 b := dAtA[iNdEx]
5356 iNdEx++
5357 wire |= uint64(b&0x7F) << shift
5358 if b < 0x80 {
5359 break
5360 }
5361 }
5362 fieldNum := int32(wire >> 3)
5363 wireType := int(wire & 0x7)
5364 if wireType == 4 {
5365 return fmt.Errorf("proto: CreateEndpointResponse: wiretype end group for non-group")
5366 }
5367 if fieldNum <= 0 {
5368 return fmt.Errorf("proto: CreateEndpointResponse: illegal tag %d (wire type %d)", fieldNum, wire)
5369 }
5370 switch fieldNum {
5371 case 1:
5372 if wireType != 2 {
5373 return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
5374 }
5375 var stringLen uint64
5376 for shift := uint(0); ; shift += 7 {
5377 if shift >= 64 {
5378 return ErrIntOverflowNetworkconfigproxy
5379 }
5380 if iNdEx >= l {
5381 return io.ErrUnexpectedEOF
5382 }
5383 b := dAtA[iNdEx]
5384 iNdEx++
5385 stringLen |= uint64(b&0x7F) << shift
5386 if b < 0x80 {
5387 break
5388 }
5389 }
5390 intStringLen := int(stringLen)
5391 if intStringLen < 0 {
5392 return ErrInvalidLengthNetworkconfigproxy
5393 }
5394 postIndex := iNdEx + intStringLen
5395 if postIndex < 0 {
5396 return ErrInvalidLengthNetworkconfigproxy
5397 }
5398 if postIndex > l {
5399 return io.ErrUnexpectedEOF
5400 }
5401 m.ID = string(dAtA[iNdEx:postIndex])
5402 iNdEx = postIndex
5403 default:
5404 iNdEx = preIndex
5405 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
5406 if err != nil {
5407 return err
5408 }
5409 if (skippy < 0) || (iNdEx+skippy) < 0 {
5410 return ErrInvalidLengthNetworkconfigproxy
5411 }
5412 if (iNdEx + skippy) > l {
5413 return io.ErrUnexpectedEOF
5414 }
5415 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5416 iNdEx += skippy
5417 }
5418 }
5419
5420 if iNdEx > l {
5421 return io.ErrUnexpectedEOF
5422 }
5423 return nil
5424 }
5425 func (m *AddEndpointRequest) Unmarshal(dAtA []byte) error {
5426 l := len(dAtA)
5427 iNdEx := 0
5428 for iNdEx < l {
5429 preIndex := iNdEx
5430 var wire uint64
5431 for shift := uint(0); ; shift += 7 {
5432 if shift >= 64 {
5433 return ErrIntOverflowNetworkconfigproxy
5434 }
5435 if iNdEx >= l {
5436 return io.ErrUnexpectedEOF
5437 }
5438 b := dAtA[iNdEx]
5439 iNdEx++
5440 wire |= uint64(b&0x7F) << shift
5441 if b < 0x80 {
5442 break
5443 }
5444 }
5445 fieldNum := int32(wire >> 3)
5446 wireType := int(wire & 0x7)
5447 if wireType == 4 {
5448 return fmt.Errorf("proto: AddEndpointRequest: wiretype end group for non-group")
5449 }
5450 if fieldNum <= 0 {
5451 return fmt.Errorf("proto: AddEndpointRequest: illegal tag %d (wire type %d)", fieldNum, wire)
5452 }
5453 switch fieldNum {
5454 case 1:
5455 if wireType != 2 {
5456 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
5457 }
5458 var stringLen uint64
5459 for shift := uint(0); ; shift += 7 {
5460 if shift >= 64 {
5461 return ErrIntOverflowNetworkconfigproxy
5462 }
5463 if iNdEx >= l {
5464 return io.ErrUnexpectedEOF
5465 }
5466 b := dAtA[iNdEx]
5467 iNdEx++
5468 stringLen |= uint64(b&0x7F) << shift
5469 if b < 0x80 {
5470 break
5471 }
5472 }
5473 intStringLen := int(stringLen)
5474 if intStringLen < 0 {
5475 return ErrInvalidLengthNetworkconfigproxy
5476 }
5477 postIndex := iNdEx + intStringLen
5478 if postIndex < 0 {
5479 return ErrInvalidLengthNetworkconfigproxy
5480 }
5481 if postIndex > l {
5482 return io.ErrUnexpectedEOF
5483 }
5484 m.Name = string(dAtA[iNdEx:postIndex])
5485 iNdEx = postIndex
5486 case 2:
5487 if wireType != 2 {
5488 return fmt.Errorf("proto: wrong wireType = %d for field NamespaceID", wireType)
5489 }
5490 var stringLen uint64
5491 for shift := uint(0); ; shift += 7 {
5492 if shift >= 64 {
5493 return ErrIntOverflowNetworkconfigproxy
5494 }
5495 if iNdEx >= l {
5496 return io.ErrUnexpectedEOF
5497 }
5498 b := dAtA[iNdEx]
5499 iNdEx++
5500 stringLen |= uint64(b&0x7F) << shift
5501 if b < 0x80 {
5502 break
5503 }
5504 }
5505 intStringLen := int(stringLen)
5506 if intStringLen < 0 {
5507 return ErrInvalidLengthNetworkconfigproxy
5508 }
5509 postIndex := iNdEx + intStringLen
5510 if postIndex < 0 {
5511 return ErrInvalidLengthNetworkconfigproxy
5512 }
5513 if postIndex > l {
5514 return io.ErrUnexpectedEOF
5515 }
5516 m.NamespaceID = string(dAtA[iNdEx:postIndex])
5517 iNdEx = postIndex
5518 default:
5519 iNdEx = preIndex
5520 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
5521 if err != nil {
5522 return err
5523 }
5524 if (skippy < 0) || (iNdEx+skippy) < 0 {
5525 return ErrInvalidLengthNetworkconfigproxy
5526 }
5527 if (iNdEx + skippy) > l {
5528 return io.ErrUnexpectedEOF
5529 }
5530 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5531 iNdEx += skippy
5532 }
5533 }
5534
5535 if iNdEx > l {
5536 return io.ErrUnexpectedEOF
5537 }
5538 return nil
5539 }
5540 func (m *AddEndpointResponse) Unmarshal(dAtA []byte) error {
5541 l := len(dAtA)
5542 iNdEx := 0
5543 for iNdEx < l {
5544 preIndex := iNdEx
5545 var wire uint64
5546 for shift := uint(0); ; shift += 7 {
5547 if shift >= 64 {
5548 return ErrIntOverflowNetworkconfigproxy
5549 }
5550 if iNdEx >= l {
5551 return io.ErrUnexpectedEOF
5552 }
5553 b := dAtA[iNdEx]
5554 iNdEx++
5555 wire |= uint64(b&0x7F) << shift
5556 if b < 0x80 {
5557 break
5558 }
5559 }
5560 fieldNum := int32(wire >> 3)
5561 wireType := int(wire & 0x7)
5562 if wireType == 4 {
5563 return fmt.Errorf("proto: AddEndpointResponse: wiretype end group for non-group")
5564 }
5565 if fieldNum <= 0 {
5566 return fmt.Errorf("proto: AddEndpointResponse: illegal tag %d (wire type %d)", fieldNum, wire)
5567 }
5568 switch fieldNum {
5569 default:
5570 iNdEx = preIndex
5571 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
5572 if err != nil {
5573 return err
5574 }
5575 if (skippy < 0) || (iNdEx+skippy) < 0 {
5576 return ErrInvalidLengthNetworkconfigproxy
5577 }
5578 if (iNdEx + skippy) > l {
5579 return io.ErrUnexpectedEOF
5580 }
5581 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5582 iNdEx += skippy
5583 }
5584 }
5585
5586 if iNdEx > l {
5587 return io.ErrUnexpectedEOF
5588 }
5589 return nil
5590 }
5591 func (m *DeleteEndpointRequest) Unmarshal(dAtA []byte) error {
5592 l := len(dAtA)
5593 iNdEx := 0
5594 for iNdEx < l {
5595 preIndex := iNdEx
5596 var wire uint64
5597 for shift := uint(0); ; shift += 7 {
5598 if shift >= 64 {
5599 return ErrIntOverflowNetworkconfigproxy
5600 }
5601 if iNdEx >= l {
5602 return io.ErrUnexpectedEOF
5603 }
5604 b := dAtA[iNdEx]
5605 iNdEx++
5606 wire |= uint64(b&0x7F) << shift
5607 if b < 0x80 {
5608 break
5609 }
5610 }
5611 fieldNum := int32(wire >> 3)
5612 wireType := int(wire & 0x7)
5613 if wireType == 4 {
5614 return fmt.Errorf("proto: DeleteEndpointRequest: wiretype end group for non-group")
5615 }
5616 if fieldNum <= 0 {
5617 return fmt.Errorf("proto: DeleteEndpointRequest: illegal tag %d (wire type %d)", fieldNum, wire)
5618 }
5619 switch fieldNum {
5620 case 1:
5621 if wireType != 2 {
5622 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
5623 }
5624 var stringLen uint64
5625 for shift := uint(0); ; shift += 7 {
5626 if shift >= 64 {
5627 return ErrIntOverflowNetworkconfigproxy
5628 }
5629 if iNdEx >= l {
5630 return io.ErrUnexpectedEOF
5631 }
5632 b := dAtA[iNdEx]
5633 iNdEx++
5634 stringLen |= uint64(b&0x7F) << shift
5635 if b < 0x80 {
5636 break
5637 }
5638 }
5639 intStringLen := int(stringLen)
5640 if intStringLen < 0 {
5641 return ErrInvalidLengthNetworkconfigproxy
5642 }
5643 postIndex := iNdEx + intStringLen
5644 if postIndex < 0 {
5645 return ErrInvalidLengthNetworkconfigproxy
5646 }
5647 if postIndex > l {
5648 return io.ErrUnexpectedEOF
5649 }
5650 m.Name = string(dAtA[iNdEx:postIndex])
5651 iNdEx = postIndex
5652 default:
5653 iNdEx = preIndex
5654 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
5655 if err != nil {
5656 return err
5657 }
5658 if (skippy < 0) || (iNdEx+skippy) < 0 {
5659 return ErrInvalidLengthNetworkconfigproxy
5660 }
5661 if (iNdEx + skippy) > l {
5662 return io.ErrUnexpectedEOF
5663 }
5664 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5665 iNdEx += skippy
5666 }
5667 }
5668
5669 if iNdEx > l {
5670 return io.ErrUnexpectedEOF
5671 }
5672 return nil
5673 }
5674 func (m *DeleteEndpointResponse) Unmarshal(dAtA []byte) error {
5675 l := len(dAtA)
5676 iNdEx := 0
5677 for iNdEx < l {
5678 preIndex := iNdEx
5679 var wire uint64
5680 for shift := uint(0); ; shift += 7 {
5681 if shift >= 64 {
5682 return ErrIntOverflowNetworkconfigproxy
5683 }
5684 if iNdEx >= l {
5685 return io.ErrUnexpectedEOF
5686 }
5687 b := dAtA[iNdEx]
5688 iNdEx++
5689 wire |= uint64(b&0x7F) << shift
5690 if b < 0x80 {
5691 break
5692 }
5693 }
5694 fieldNum := int32(wire >> 3)
5695 wireType := int(wire & 0x7)
5696 if wireType == 4 {
5697 return fmt.Errorf("proto: DeleteEndpointResponse: wiretype end group for non-group")
5698 }
5699 if fieldNum <= 0 {
5700 return fmt.Errorf("proto: DeleteEndpointResponse: illegal tag %d (wire type %d)", fieldNum, wire)
5701 }
5702 switch fieldNum {
5703 default:
5704 iNdEx = preIndex
5705 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
5706 if err != nil {
5707 return err
5708 }
5709 if (skippy < 0) || (iNdEx+skippy) < 0 {
5710 return ErrInvalidLengthNetworkconfigproxy
5711 }
5712 if (iNdEx + skippy) > l {
5713 return io.ErrUnexpectedEOF
5714 }
5715 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5716 iNdEx += skippy
5717 }
5718 }
5719
5720 if iNdEx > l {
5721 return io.ErrUnexpectedEOF
5722 }
5723 return nil
5724 }
5725 func (m *DeleteNetworkRequest) Unmarshal(dAtA []byte) error {
5726 l := len(dAtA)
5727 iNdEx := 0
5728 for iNdEx < l {
5729 preIndex := iNdEx
5730 var wire uint64
5731 for shift := uint(0); ; shift += 7 {
5732 if shift >= 64 {
5733 return ErrIntOverflowNetworkconfigproxy
5734 }
5735 if iNdEx >= l {
5736 return io.ErrUnexpectedEOF
5737 }
5738 b := dAtA[iNdEx]
5739 iNdEx++
5740 wire |= uint64(b&0x7F) << shift
5741 if b < 0x80 {
5742 break
5743 }
5744 }
5745 fieldNum := int32(wire >> 3)
5746 wireType := int(wire & 0x7)
5747 if wireType == 4 {
5748 return fmt.Errorf("proto: DeleteNetworkRequest: wiretype end group for non-group")
5749 }
5750 if fieldNum <= 0 {
5751 return fmt.Errorf("proto: DeleteNetworkRequest: illegal tag %d (wire type %d)", fieldNum, wire)
5752 }
5753 switch fieldNum {
5754 case 1:
5755 if wireType != 2 {
5756 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
5757 }
5758 var stringLen uint64
5759 for shift := uint(0); ; shift += 7 {
5760 if shift >= 64 {
5761 return ErrIntOverflowNetworkconfigproxy
5762 }
5763 if iNdEx >= l {
5764 return io.ErrUnexpectedEOF
5765 }
5766 b := dAtA[iNdEx]
5767 iNdEx++
5768 stringLen |= uint64(b&0x7F) << shift
5769 if b < 0x80 {
5770 break
5771 }
5772 }
5773 intStringLen := int(stringLen)
5774 if intStringLen < 0 {
5775 return ErrInvalidLengthNetworkconfigproxy
5776 }
5777 postIndex := iNdEx + intStringLen
5778 if postIndex < 0 {
5779 return ErrInvalidLengthNetworkconfigproxy
5780 }
5781 if postIndex > l {
5782 return io.ErrUnexpectedEOF
5783 }
5784 m.Name = string(dAtA[iNdEx:postIndex])
5785 iNdEx = postIndex
5786 default:
5787 iNdEx = preIndex
5788 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
5789 if err != nil {
5790 return err
5791 }
5792 if (skippy < 0) || (iNdEx+skippy) < 0 {
5793 return ErrInvalidLengthNetworkconfigproxy
5794 }
5795 if (iNdEx + skippy) > l {
5796 return io.ErrUnexpectedEOF
5797 }
5798 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5799 iNdEx += skippy
5800 }
5801 }
5802
5803 if iNdEx > l {
5804 return io.ErrUnexpectedEOF
5805 }
5806 return nil
5807 }
5808 func (m *DeleteNetworkResponse) Unmarshal(dAtA []byte) error {
5809 l := len(dAtA)
5810 iNdEx := 0
5811 for iNdEx < l {
5812 preIndex := iNdEx
5813 var wire uint64
5814 for shift := uint(0); ; shift += 7 {
5815 if shift >= 64 {
5816 return ErrIntOverflowNetworkconfigproxy
5817 }
5818 if iNdEx >= l {
5819 return io.ErrUnexpectedEOF
5820 }
5821 b := dAtA[iNdEx]
5822 iNdEx++
5823 wire |= uint64(b&0x7F) << shift
5824 if b < 0x80 {
5825 break
5826 }
5827 }
5828 fieldNum := int32(wire >> 3)
5829 wireType := int(wire & 0x7)
5830 if wireType == 4 {
5831 return fmt.Errorf("proto: DeleteNetworkResponse: wiretype end group for non-group")
5832 }
5833 if fieldNum <= 0 {
5834 return fmt.Errorf("proto: DeleteNetworkResponse: illegal tag %d (wire type %d)", fieldNum, wire)
5835 }
5836 switch fieldNum {
5837 default:
5838 iNdEx = preIndex
5839 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
5840 if err != nil {
5841 return err
5842 }
5843 if (skippy < 0) || (iNdEx+skippy) < 0 {
5844 return ErrInvalidLengthNetworkconfigproxy
5845 }
5846 if (iNdEx + skippy) > l {
5847 return io.ErrUnexpectedEOF
5848 }
5849 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5850 iNdEx += skippy
5851 }
5852 }
5853
5854 if iNdEx > l {
5855 return io.ErrUnexpectedEOF
5856 }
5857 return nil
5858 }
5859 func (m *GetEndpointRequest) Unmarshal(dAtA []byte) error {
5860 l := len(dAtA)
5861 iNdEx := 0
5862 for iNdEx < l {
5863 preIndex := iNdEx
5864 var wire uint64
5865 for shift := uint(0); ; shift += 7 {
5866 if shift >= 64 {
5867 return ErrIntOverflowNetworkconfigproxy
5868 }
5869 if iNdEx >= l {
5870 return io.ErrUnexpectedEOF
5871 }
5872 b := dAtA[iNdEx]
5873 iNdEx++
5874 wire |= uint64(b&0x7F) << shift
5875 if b < 0x80 {
5876 break
5877 }
5878 }
5879 fieldNum := int32(wire >> 3)
5880 wireType := int(wire & 0x7)
5881 if wireType == 4 {
5882 return fmt.Errorf("proto: GetEndpointRequest: wiretype end group for non-group")
5883 }
5884 if fieldNum <= 0 {
5885 return fmt.Errorf("proto: GetEndpointRequest: illegal tag %d (wire type %d)", fieldNum, wire)
5886 }
5887 switch fieldNum {
5888 case 1:
5889 if wireType != 2 {
5890 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
5891 }
5892 var stringLen uint64
5893 for shift := uint(0); ; shift += 7 {
5894 if shift >= 64 {
5895 return ErrIntOverflowNetworkconfigproxy
5896 }
5897 if iNdEx >= l {
5898 return io.ErrUnexpectedEOF
5899 }
5900 b := dAtA[iNdEx]
5901 iNdEx++
5902 stringLen |= uint64(b&0x7F) << shift
5903 if b < 0x80 {
5904 break
5905 }
5906 }
5907 intStringLen := int(stringLen)
5908 if intStringLen < 0 {
5909 return ErrInvalidLengthNetworkconfigproxy
5910 }
5911 postIndex := iNdEx + intStringLen
5912 if postIndex < 0 {
5913 return ErrInvalidLengthNetworkconfigproxy
5914 }
5915 if postIndex > l {
5916 return io.ErrUnexpectedEOF
5917 }
5918 m.Name = string(dAtA[iNdEx:postIndex])
5919 iNdEx = postIndex
5920 default:
5921 iNdEx = preIndex
5922 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
5923 if err != nil {
5924 return err
5925 }
5926 if (skippy < 0) || (iNdEx+skippy) < 0 {
5927 return ErrInvalidLengthNetworkconfigproxy
5928 }
5929 if (iNdEx + skippy) > l {
5930 return io.ErrUnexpectedEOF
5931 }
5932 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5933 iNdEx += skippy
5934 }
5935 }
5936
5937 if iNdEx > l {
5938 return io.ErrUnexpectedEOF
5939 }
5940 return nil
5941 }
5942 func (m *GetEndpointResponse) Unmarshal(dAtA []byte) error {
5943 l := len(dAtA)
5944 iNdEx := 0
5945 for iNdEx < l {
5946 preIndex := iNdEx
5947 var wire uint64
5948 for shift := uint(0); ; shift += 7 {
5949 if shift >= 64 {
5950 return ErrIntOverflowNetworkconfigproxy
5951 }
5952 if iNdEx >= l {
5953 return io.ErrUnexpectedEOF
5954 }
5955 b := dAtA[iNdEx]
5956 iNdEx++
5957 wire |= uint64(b&0x7F) << shift
5958 if b < 0x80 {
5959 break
5960 }
5961 }
5962 fieldNum := int32(wire >> 3)
5963 wireType := int(wire & 0x7)
5964 if wireType == 4 {
5965 return fmt.Errorf("proto: GetEndpointResponse: wiretype end group for non-group")
5966 }
5967 if fieldNum <= 0 {
5968 return fmt.Errorf("proto: GetEndpointResponse: illegal tag %d (wire type %d)", fieldNum, wire)
5969 }
5970 switch fieldNum {
5971 case 1:
5972 if wireType != 2 {
5973 return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
5974 }
5975 var stringLen uint64
5976 for shift := uint(0); ; shift += 7 {
5977 if shift >= 64 {
5978 return ErrIntOverflowNetworkconfigproxy
5979 }
5980 if iNdEx >= l {
5981 return io.ErrUnexpectedEOF
5982 }
5983 b := dAtA[iNdEx]
5984 iNdEx++
5985 stringLen |= uint64(b&0x7F) << shift
5986 if b < 0x80 {
5987 break
5988 }
5989 }
5990 intStringLen := int(stringLen)
5991 if intStringLen < 0 {
5992 return ErrInvalidLengthNetworkconfigproxy
5993 }
5994 postIndex := iNdEx + intStringLen
5995 if postIndex < 0 {
5996 return ErrInvalidLengthNetworkconfigproxy
5997 }
5998 if postIndex > l {
5999 return io.ErrUnexpectedEOF
6000 }
6001 m.ID = string(dAtA[iNdEx:postIndex])
6002 iNdEx = postIndex
6003 case 2:
6004 if wireType != 2 {
6005 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
6006 }
6007 var stringLen uint64
6008 for shift := uint(0); ; shift += 7 {
6009 if shift >= 64 {
6010 return ErrIntOverflowNetworkconfigproxy
6011 }
6012 if iNdEx >= l {
6013 return io.ErrUnexpectedEOF
6014 }
6015 b := dAtA[iNdEx]
6016 iNdEx++
6017 stringLen |= uint64(b&0x7F) << shift
6018 if b < 0x80 {
6019 break
6020 }
6021 }
6022 intStringLen := int(stringLen)
6023 if intStringLen < 0 {
6024 return ErrInvalidLengthNetworkconfigproxy
6025 }
6026 postIndex := iNdEx + intStringLen
6027 if postIndex < 0 {
6028 return ErrInvalidLengthNetworkconfigproxy
6029 }
6030 if postIndex > l {
6031 return io.ErrUnexpectedEOF
6032 }
6033 m.Name = string(dAtA[iNdEx:postIndex])
6034 iNdEx = postIndex
6035 case 3:
6036 if wireType != 2 {
6037 return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType)
6038 }
6039 var stringLen uint64
6040 for shift := uint(0); ; shift += 7 {
6041 if shift >= 64 {
6042 return ErrIntOverflowNetworkconfigproxy
6043 }
6044 if iNdEx >= l {
6045 return io.ErrUnexpectedEOF
6046 }
6047 b := dAtA[iNdEx]
6048 iNdEx++
6049 stringLen |= uint64(b&0x7F) << shift
6050 if b < 0x80 {
6051 break
6052 }
6053 }
6054 intStringLen := int(stringLen)
6055 if intStringLen < 0 {
6056 return ErrInvalidLengthNetworkconfigproxy
6057 }
6058 postIndex := iNdEx + intStringLen
6059 if postIndex < 0 {
6060 return ErrInvalidLengthNetworkconfigproxy
6061 }
6062 if postIndex > l {
6063 return io.ErrUnexpectedEOF
6064 }
6065 m.Network = string(dAtA[iNdEx:postIndex])
6066 iNdEx = postIndex
6067 case 4:
6068 if wireType != 2 {
6069 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
6070 }
6071 var stringLen uint64
6072 for shift := uint(0); ; shift += 7 {
6073 if shift >= 64 {
6074 return ErrIntOverflowNetworkconfigproxy
6075 }
6076 if iNdEx >= l {
6077 return io.ErrUnexpectedEOF
6078 }
6079 b := dAtA[iNdEx]
6080 iNdEx++
6081 stringLen |= uint64(b&0x7F) << shift
6082 if b < 0x80 {
6083 break
6084 }
6085 }
6086 intStringLen := int(stringLen)
6087 if intStringLen < 0 {
6088 return ErrInvalidLengthNetworkconfigproxy
6089 }
6090 postIndex := iNdEx + intStringLen
6091 if postIndex < 0 {
6092 return ErrInvalidLengthNetworkconfigproxy
6093 }
6094 if postIndex > l {
6095 return io.ErrUnexpectedEOF
6096 }
6097 m.Namespace = string(dAtA[iNdEx:postIndex])
6098 iNdEx = postIndex
6099 case 5:
6100 if wireType != 2 {
6101 return fmt.Errorf("proto: wrong wireType = %d for field DnsSetting", wireType)
6102 }
6103 var msglen int
6104 for shift := uint(0); ; shift += 7 {
6105 if shift >= 64 {
6106 return ErrIntOverflowNetworkconfigproxy
6107 }
6108 if iNdEx >= l {
6109 return io.ErrUnexpectedEOF
6110 }
6111 b := dAtA[iNdEx]
6112 iNdEx++
6113 msglen |= int(b&0x7F) << shift
6114 if b < 0x80 {
6115 break
6116 }
6117 }
6118 if msglen < 0 {
6119 return ErrInvalidLengthNetworkconfigproxy
6120 }
6121 postIndex := iNdEx + msglen
6122 if postIndex < 0 {
6123 return ErrInvalidLengthNetworkconfigproxy
6124 }
6125 if postIndex > l {
6126 return io.ErrUnexpectedEOF
6127 }
6128 if m.DnsSetting == nil {
6129 m.DnsSetting = &DnsSetting{}
6130 }
6131 if err := m.DnsSetting.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6132 return err
6133 }
6134 iNdEx = postIndex
6135 default:
6136 iNdEx = preIndex
6137 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
6138 if err != nil {
6139 return err
6140 }
6141 if (skippy < 0) || (iNdEx+skippy) < 0 {
6142 return ErrInvalidLengthNetworkconfigproxy
6143 }
6144 if (iNdEx + skippy) > l {
6145 return io.ErrUnexpectedEOF
6146 }
6147 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6148 iNdEx += skippy
6149 }
6150 }
6151
6152 if iNdEx > l {
6153 return io.ErrUnexpectedEOF
6154 }
6155 return nil
6156 }
6157 func (m *GetNetworkRequest) Unmarshal(dAtA []byte) error {
6158 l := len(dAtA)
6159 iNdEx := 0
6160 for iNdEx < l {
6161 preIndex := iNdEx
6162 var wire uint64
6163 for shift := uint(0); ; shift += 7 {
6164 if shift >= 64 {
6165 return ErrIntOverflowNetworkconfigproxy
6166 }
6167 if iNdEx >= l {
6168 return io.ErrUnexpectedEOF
6169 }
6170 b := dAtA[iNdEx]
6171 iNdEx++
6172 wire |= uint64(b&0x7F) << shift
6173 if b < 0x80 {
6174 break
6175 }
6176 }
6177 fieldNum := int32(wire >> 3)
6178 wireType := int(wire & 0x7)
6179 if wireType == 4 {
6180 return fmt.Errorf("proto: GetNetworkRequest: wiretype end group for non-group")
6181 }
6182 if fieldNum <= 0 {
6183 return fmt.Errorf("proto: GetNetworkRequest: illegal tag %d (wire type %d)", fieldNum, wire)
6184 }
6185 switch fieldNum {
6186 case 1:
6187 if wireType != 2 {
6188 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
6189 }
6190 var stringLen uint64
6191 for shift := uint(0); ; shift += 7 {
6192 if shift >= 64 {
6193 return ErrIntOverflowNetworkconfigproxy
6194 }
6195 if iNdEx >= l {
6196 return io.ErrUnexpectedEOF
6197 }
6198 b := dAtA[iNdEx]
6199 iNdEx++
6200 stringLen |= uint64(b&0x7F) << shift
6201 if b < 0x80 {
6202 break
6203 }
6204 }
6205 intStringLen := int(stringLen)
6206 if intStringLen < 0 {
6207 return ErrInvalidLengthNetworkconfigproxy
6208 }
6209 postIndex := iNdEx + intStringLen
6210 if postIndex < 0 {
6211 return ErrInvalidLengthNetworkconfigproxy
6212 }
6213 if postIndex > l {
6214 return io.ErrUnexpectedEOF
6215 }
6216 m.Name = string(dAtA[iNdEx:postIndex])
6217 iNdEx = postIndex
6218 default:
6219 iNdEx = preIndex
6220 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
6221 if err != nil {
6222 return err
6223 }
6224 if (skippy < 0) || (iNdEx+skippy) < 0 {
6225 return ErrInvalidLengthNetworkconfigproxy
6226 }
6227 if (iNdEx + skippy) > l {
6228 return io.ErrUnexpectedEOF
6229 }
6230 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6231 iNdEx += skippy
6232 }
6233 }
6234
6235 if iNdEx > l {
6236 return io.ErrUnexpectedEOF
6237 }
6238 return nil
6239 }
6240 func (m *GetNetworkResponse) Unmarshal(dAtA []byte) error {
6241 l := len(dAtA)
6242 iNdEx := 0
6243 for iNdEx < l {
6244 preIndex := iNdEx
6245 var wire uint64
6246 for shift := uint(0); ; shift += 7 {
6247 if shift >= 64 {
6248 return ErrIntOverflowNetworkconfigproxy
6249 }
6250 if iNdEx >= l {
6251 return io.ErrUnexpectedEOF
6252 }
6253 b := dAtA[iNdEx]
6254 iNdEx++
6255 wire |= uint64(b&0x7F) << shift
6256 if b < 0x80 {
6257 break
6258 }
6259 }
6260 fieldNum := int32(wire >> 3)
6261 wireType := int(wire & 0x7)
6262 if wireType == 4 {
6263 return fmt.Errorf("proto: GetNetworkResponse: wiretype end group for non-group")
6264 }
6265 if fieldNum <= 0 {
6266 return fmt.Errorf("proto: GetNetworkResponse: illegal tag %d (wire type %d)", fieldNum, wire)
6267 }
6268 switch fieldNum {
6269 case 1:
6270 if wireType != 2 {
6271 return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
6272 }
6273 var stringLen uint64
6274 for shift := uint(0); ; shift += 7 {
6275 if shift >= 64 {
6276 return ErrIntOverflowNetworkconfigproxy
6277 }
6278 if iNdEx >= l {
6279 return io.ErrUnexpectedEOF
6280 }
6281 b := dAtA[iNdEx]
6282 iNdEx++
6283 stringLen |= uint64(b&0x7F) << shift
6284 if b < 0x80 {
6285 break
6286 }
6287 }
6288 intStringLen := int(stringLen)
6289 if intStringLen < 0 {
6290 return ErrInvalidLengthNetworkconfigproxy
6291 }
6292 postIndex := iNdEx + intStringLen
6293 if postIndex < 0 {
6294 return ErrInvalidLengthNetworkconfigproxy
6295 }
6296 if postIndex > l {
6297 return io.ErrUnexpectedEOF
6298 }
6299 m.ID = string(dAtA[iNdEx:postIndex])
6300 iNdEx = postIndex
6301 case 2:
6302 if wireType != 2 {
6303 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
6304 }
6305 var stringLen uint64
6306 for shift := uint(0); ; shift += 7 {
6307 if shift >= 64 {
6308 return ErrIntOverflowNetworkconfigproxy
6309 }
6310 if iNdEx >= l {
6311 return io.ErrUnexpectedEOF
6312 }
6313 b := dAtA[iNdEx]
6314 iNdEx++
6315 stringLen |= uint64(b&0x7F) << shift
6316 if b < 0x80 {
6317 break
6318 }
6319 }
6320 intStringLen := int(stringLen)
6321 if intStringLen < 0 {
6322 return ErrInvalidLengthNetworkconfigproxy
6323 }
6324 postIndex := iNdEx + intStringLen
6325 if postIndex < 0 {
6326 return ErrInvalidLengthNetworkconfigproxy
6327 }
6328 if postIndex > l {
6329 return io.ErrUnexpectedEOF
6330 }
6331 m.Name = string(dAtA[iNdEx:postIndex])
6332 iNdEx = postIndex
6333 default:
6334 iNdEx = preIndex
6335 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
6336 if err != nil {
6337 return err
6338 }
6339 if (skippy < 0) || (iNdEx+skippy) < 0 {
6340 return ErrInvalidLengthNetworkconfigproxy
6341 }
6342 if (iNdEx + skippy) > l {
6343 return io.ErrUnexpectedEOF
6344 }
6345 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6346 iNdEx += skippy
6347 }
6348 }
6349
6350 if iNdEx > l {
6351 return io.ErrUnexpectedEOF
6352 }
6353 return nil
6354 }
6355 func (m *GetEndpointsRequest) Unmarshal(dAtA []byte) error {
6356 l := len(dAtA)
6357 iNdEx := 0
6358 for iNdEx < l {
6359 preIndex := iNdEx
6360 var wire uint64
6361 for shift := uint(0); ; shift += 7 {
6362 if shift >= 64 {
6363 return ErrIntOverflowNetworkconfigproxy
6364 }
6365 if iNdEx >= l {
6366 return io.ErrUnexpectedEOF
6367 }
6368 b := dAtA[iNdEx]
6369 iNdEx++
6370 wire |= uint64(b&0x7F) << shift
6371 if b < 0x80 {
6372 break
6373 }
6374 }
6375 fieldNum := int32(wire >> 3)
6376 wireType := int(wire & 0x7)
6377 if wireType == 4 {
6378 return fmt.Errorf("proto: GetEndpointsRequest: wiretype end group for non-group")
6379 }
6380 if fieldNum <= 0 {
6381 return fmt.Errorf("proto: GetEndpointsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
6382 }
6383 switch fieldNum {
6384 default:
6385 iNdEx = preIndex
6386 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
6387 if err != nil {
6388 return err
6389 }
6390 if (skippy < 0) || (iNdEx+skippy) < 0 {
6391 return ErrInvalidLengthNetworkconfigproxy
6392 }
6393 if (iNdEx + skippy) > l {
6394 return io.ErrUnexpectedEOF
6395 }
6396 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6397 iNdEx += skippy
6398 }
6399 }
6400
6401 if iNdEx > l {
6402 return io.ErrUnexpectedEOF
6403 }
6404 return nil
6405 }
6406 func (m *GetEndpointsResponse) Unmarshal(dAtA []byte) error {
6407 l := len(dAtA)
6408 iNdEx := 0
6409 for iNdEx < l {
6410 preIndex := iNdEx
6411 var wire uint64
6412 for shift := uint(0); ; shift += 7 {
6413 if shift >= 64 {
6414 return ErrIntOverflowNetworkconfigproxy
6415 }
6416 if iNdEx >= l {
6417 return io.ErrUnexpectedEOF
6418 }
6419 b := dAtA[iNdEx]
6420 iNdEx++
6421 wire |= uint64(b&0x7F) << shift
6422 if b < 0x80 {
6423 break
6424 }
6425 }
6426 fieldNum := int32(wire >> 3)
6427 wireType := int(wire & 0x7)
6428 if wireType == 4 {
6429 return fmt.Errorf("proto: GetEndpointsResponse: wiretype end group for non-group")
6430 }
6431 if fieldNum <= 0 {
6432 return fmt.Errorf("proto: GetEndpointsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
6433 }
6434 switch fieldNum {
6435 case 1:
6436 if wireType != 2 {
6437 return fmt.Errorf("proto: wrong wireType = %d for field Endpoints", wireType)
6438 }
6439 var msglen int
6440 for shift := uint(0); ; shift += 7 {
6441 if shift >= 64 {
6442 return ErrIntOverflowNetworkconfigproxy
6443 }
6444 if iNdEx >= l {
6445 return io.ErrUnexpectedEOF
6446 }
6447 b := dAtA[iNdEx]
6448 iNdEx++
6449 msglen |= int(b&0x7F) << shift
6450 if b < 0x80 {
6451 break
6452 }
6453 }
6454 if msglen < 0 {
6455 return ErrInvalidLengthNetworkconfigproxy
6456 }
6457 postIndex := iNdEx + msglen
6458 if postIndex < 0 {
6459 return ErrInvalidLengthNetworkconfigproxy
6460 }
6461 if postIndex > l {
6462 return io.ErrUnexpectedEOF
6463 }
6464 m.Endpoints = append(m.Endpoints, &GetEndpointResponse{})
6465 if err := m.Endpoints[len(m.Endpoints)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6466 return err
6467 }
6468 iNdEx = postIndex
6469 default:
6470 iNdEx = preIndex
6471 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
6472 if err != nil {
6473 return err
6474 }
6475 if (skippy < 0) || (iNdEx+skippy) < 0 {
6476 return ErrInvalidLengthNetworkconfigproxy
6477 }
6478 if (iNdEx + skippy) > l {
6479 return io.ErrUnexpectedEOF
6480 }
6481 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6482 iNdEx += skippy
6483 }
6484 }
6485
6486 if iNdEx > l {
6487 return io.ErrUnexpectedEOF
6488 }
6489 return nil
6490 }
6491 func (m *GetNetworksRequest) Unmarshal(dAtA []byte) error {
6492 l := len(dAtA)
6493 iNdEx := 0
6494 for iNdEx < l {
6495 preIndex := iNdEx
6496 var wire uint64
6497 for shift := uint(0); ; shift += 7 {
6498 if shift >= 64 {
6499 return ErrIntOverflowNetworkconfigproxy
6500 }
6501 if iNdEx >= l {
6502 return io.ErrUnexpectedEOF
6503 }
6504 b := dAtA[iNdEx]
6505 iNdEx++
6506 wire |= uint64(b&0x7F) << shift
6507 if b < 0x80 {
6508 break
6509 }
6510 }
6511 fieldNum := int32(wire >> 3)
6512 wireType := int(wire & 0x7)
6513 if wireType == 4 {
6514 return fmt.Errorf("proto: GetNetworksRequest: wiretype end group for non-group")
6515 }
6516 if fieldNum <= 0 {
6517 return fmt.Errorf("proto: GetNetworksRequest: illegal tag %d (wire type %d)", fieldNum, wire)
6518 }
6519 switch fieldNum {
6520 default:
6521 iNdEx = preIndex
6522 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
6523 if err != nil {
6524 return err
6525 }
6526 if (skippy < 0) || (iNdEx+skippy) < 0 {
6527 return ErrInvalidLengthNetworkconfigproxy
6528 }
6529 if (iNdEx + skippy) > l {
6530 return io.ErrUnexpectedEOF
6531 }
6532 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6533 iNdEx += skippy
6534 }
6535 }
6536
6537 if iNdEx > l {
6538 return io.ErrUnexpectedEOF
6539 }
6540 return nil
6541 }
6542 func (m *GetNetworksResponse) Unmarshal(dAtA []byte) error {
6543 l := len(dAtA)
6544 iNdEx := 0
6545 for iNdEx < l {
6546 preIndex := iNdEx
6547 var wire uint64
6548 for shift := uint(0); ; shift += 7 {
6549 if shift >= 64 {
6550 return ErrIntOverflowNetworkconfigproxy
6551 }
6552 if iNdEx >= l {
6553 return io.ErrUnexpectedEOF
6554 }
6555 b := dAtA[iNdEx]
6556 iNdEx++
6557 wire |= uint64(b&0x7F) << shift
6558 if b < 0x80 {
6559 break
6560 }
6561 }
6562 fieldNum := int32(wire >> 3)
6563 wireType := int(wire & 0x7)
6564 if wireType == 4 {
6565 return fmt.Errorf("proto: GetNetworksResponse: wiretype end group for non-group")
6566 }
6567 if fieldNum <= 0 {
6568 return fmt.Errorf("proto: GetNetworksResponse: illegal tag %d (wire type %d)", fieldNum, wire)
6569 }
6570 switch fieldNum {
6571 case 1:
6572 if wireType != 2 {
6573 return fmt.Errorf("proto: wrong wireType = %d for field Networks", wireType)
6574 }
6575 var msglen int
6576 for shift := uint(0); ; shift += 7 {
6577 if shift >= 64 {
6578 return ErrIntOverflowNetworkconfigproxy
6579 }
6580 if iNdEx >= l {
6581 return io.ErrUnexpectedEOF
6582 }
6583 b := dAtA[iNdEx]
6584 iNdEx++
6585 msglen |= int(b&0x7F) << shift
6586 if b < 0x80 {
6587 break
6588 }
6589 }
6590 if msglen < 0 {
6591 return ErrInvalidLengthNetworkconfigproxy
6592 }
6593 postIndex := iNdEx + msglen
6594 if postIndex < 0 {
6595 return ErrInvalidLengthNetworkconfigproxy
6596 }
6597 if postIndex > l {
6598 return io.ErrUnexpectedEOF
6599 }
6600 m.Networks = append(m.Networks, &GetNetworkResponse{})
6601 if err := m.Networks[len(m.Networks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6602 return err
6603 }
6604 iNdEx = postIndex
6605 default:
6606 iNdEx = preIndex
6607 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
6608 if err != nil {
6609 return err
6610 }
6611 if (skippy < 0) || (iNdEx+skippy) < 0 {
6612 return ErrInvalidLengthNetworkconfigproxy
6613 }
6614 if (iNdEx + skippy) > l {
6615 return io.ErrUnexpectedEOF
6616 }
6617 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6618 iNdEx += skippy
6619 }
6620 }
6621
6622 if iNdEx > l {
6623 return io.ErrUnexpectedEOF
6624 }
6625 return nil
6626 }
6627 func skipNetworkconfigproxy(dAtA []byte) (n int, err error) {
6628 l := len(dAtA)
6629 iNdEx := 0
6630 depth := 0
6631 for iNdEx < l {
6632 var wire uint64
6633 for shift := uint(0); ; shift += 7 {
6634 if shift >= 64 {
6635 return 0, ErrIntOverflowNetworkconfigproxy
6636 }
6637 if iNdEx >= l {
6638 return 0, io.ErrUnexpectedEOF
6639 }
6640 b := dAtA[iNdEx]
6641 iNdEx++
6642 wire |= (uint64(b) & 0x7F) << shift
6643 if b < 0x80 {
6644 break
6645 }
6646 }
6647 wireType := int(wire & 0x7)
6648 switch wireType {
6649 case 0:
6650 for shift := uint(0); ; shift += 7 {
6651 if shift >= 64 {
6652 return 0, ErrIntOverflowNetworkconfigproxy
6653 }
6654 if iNdEx >= l {
6655 return 0, io.ErrUnexpectedEOF
6656 }
6657 iNdEx++
6658 if dAtA[iNdEx-1] < 0x80 {
6659 break
6660 }
6661 }
6662 case 1:
6663 iNdEx += 8
6664 case 2:
6665 var length int
6666 for shift := uint(0); ; shift += 7 {
6667 if shift >= 64 {
6668 return 0, ErrIntOverflowNetworkconfigproxy
6669 }
6670 if iNdEx >= l {
6671 return 0, io.ErrUnexpectedEOF
6672 }
6673 b := dAtA[iNdEx]
6674 iNdEx++
6675 length |= (int(b) & 0x7F) << shift
6676 if b < 0x80 {
6677 break
6678 }
6679 }
6680 if length < 0 {
6681 return 0, ErrInvalidLengthNetworkconfigproxy
6682 }
6683 iNdEx += length
6684 case 3:
6685 depth++
6686 case 4:
6687 if depth == 0 {
6688 return 0, ErrUnexpectedEndOfGroupNetworkconfigproxy
6689 }
6690 depth--
6691 case 5:
6692 iNdEx += 4
6693 default:
6694 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
6695 }
6696 if iNdEx < 0 {
6697 return 0, ErrInvalidLengthNetworkconfigproxy
6698 }
6699 if depth == 0 {
6700 return iNdEx, nil
6701 }
6702 }
6703 return 0, io.ErrUnexpectedEOF
6704 }
6705
6706 var (
6707 ErrInvalidLengthNetworkconfigproxy = fmt.Errorf("proto: negative length found during unmarshaling")
6708 ErrIntOverflowNetworkconfigproxy = fmt.Errorf("proto: integer overflow")
6709 ErrUnexpectedEndOfGroupNetworkconfigproxy = fmt.Errorf("proto: unexpected end of group")
6710 )
6711
View as plain text