1
2
3
4 package ncproxyttrpc
5
6 import (
7 context "context"
8 fmt "fmt"
9 github_com_containerd_ttrpc "github.com/containerd/ttrpc"
10 proto "github.com/gogo/protobuf/proto"
11 io "io"
12 math "math"
13 math_bits "math/bits"
14 reflect "reflect"
15 strings "strings"
16 )
17
18
19 var _ = proto.Marshal
20 var _ = fmt.Errorf
21 var _ = math.Inf
22
23
24
25
26
27 const _ = proto.GoGoProtoPackageIsVersion3
28
29 type RequestTypeInternal int32
30
31 const (
32 RequestTypeInternal_Setup RequestTypeInternal = 0
33 RequestTypeInternal_Teardown RequestTypeInternal = 1
34 )
35
36 var RequestTypeInternal_name = map[int32]string{
37 0: "Setup",
38 1: "Teardown",
39 }
40
41 var RequestTypeInternal_value = map[string]int32{
42 "Setup": 0,
43 "Teardown": 1,
44 }
45
46 func (x RequestTypeInternal) String() string {
47 return proto.EnumName(RequestTypeInternal_name, int32(x))
48 }
49
50 func (RequestTypeInternal) EnumDescriptor() ([]byte, []int) {
51 return fileDescriptor_11f9efc6dfbf9b45, []int{0}
52 }
53
54 type RegisterComputeAgentRequest struct {
55 AgentAddress string `protobuf:"bytes,1,opt,name=agent_address,json=agentAddress,proto3" json:"agent_address,omitempty"`
56 ContainerID string `protobuf:"bytes,2,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
57 XXX_NoUnkeyedLiteral struct{} `json:"-"`
58 XXX_unrecognized []byte `json:"-"`
59 XXX_sizecache int32 `json:"-"`
60 }
61
62 func (m *RegisterComputeAgentRequest) Reset() { *m = RegisterComputeAgentRequest{} }
63 func (*RegisterComputeAgentRequest) ProtoMessage() {}
64 func (*RegisterComputeAgentRequest) Descriptor() ([]byte, []int) {
65 return fileDescriptor_11f9efc6dfbf9b45, []int{0}
66 }
67 func (m *RegisterComputeAgentRequest) XXX_Unmarshal(b []byte) error {
68 return m.Unmarshal(b)
69 }
70 func (m *RegisterComputeAgentRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
71 if deterministic {
72 return xxx_messageInfo_RegisterComputeAgentRequest.Marshal(b, m, deterministic)
73 } else {
74 b = b[:cap(b)]
75 n, err := m.MarshalToSizedBuffer(b)
76 if err != nil {
77 return nil, err
78 }
79 return b[:n], nil
80 }
81 }
82 func (m *RegisterComputeAgentRequest) XXX_Merge(src proto.Message) {
83 xxx_messageInfo_RegisterComputeAgentRequest.Merge(m, src)
84 }
85 func (m *RegisterComputeAgentRequest) XXX_Size() int {
86 return m.Size()
87 }
88 func (m *RegisterComputeAgentRequest) XXX_DiscardUnknown() {
89 xxx_messageInfo_RegisterComputeAgentRequest.DiscardUnknown(m)
90 }
91
92 var xxx_messageInfo_RegisterComputeAgentRequest proto.InternalMessageInfo
93
94 type RegisterComputeAgentResponse struct {
95 XXX_NoUnkeyedLiteral struct{} `json:"-"`
96 XXX_unrecognized []byte `json:"-"`
97 XXX_sizecache int32 `json:"-"`
98 }
99
100 func (m *RegisterComputeAgentResponse) Reset() { *m = RegisterComputeAgentResponse{} }
101 func (*RegisterComputeAgentResponse) ProtoMessage() {}
102 func (*RegisterComputeAgentResponse) Descriptor() ([]byte, []int) {
103 return fileDescriptor_11f9efc6dfbf9b45, []int{1}
104 }
105 func (m *RegisterComputeAgentResponse) XXX_Unmarshal(b []byte) error {
106 return m.Unmarshal(b)
107 }
108 func (m *RegisterComputeAgentResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
109 if deterministic {
110 return xxx_messageInfo_RegisterComputeAgentResponse.Marshal(b, m, deterministic)
111 } else {
112 b = b[:cap(b)]
113 n, err := m.MarshalToSizedBuffer(b)
114 if err != nil {
115 return nil, err
116 }
117 return b[:n], nil
118 }
119 }
120 func (m *RegisterComputeAgentResponse) XXX_Merge(src proto.Message) {
121 xxx_messageInfo_RegisterComputeAgentResponse.Merge(m, src)
122 }
123 func (m *RegisterComputeAgentResponse) XXX_Size() int {
124 return m.Size()
125 }
126 func (m *RegisterComputeAgentResponse) XXX_DiscardUnknown() {
127 xxx_messageInfo_RegisterComputeAgentResponse.DiscardUnknown(m)
128 }
129
130 var xxx_messageInfo_RegisterComputeAgentResponse proto.InternalMessageInfo
131
132 type UnregisterComputeAgentRequest struct {
133 ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
134 XXX_NoUnkeyedLiteral struct{} `json:"-"`
135 XXX_unrecognized []byte `json:"-"`
136 XXX_sizecache int32 `json:"-"`
137 }
138
139 func (m *UnregisterComputeAgentRequest) Reset() { *m = UnregisterComputeAgentRequest{} }
140 func (*UnregisterComputeAgentRequest) ProtoMessage() {}
141 func (*UnregisterComputeAgentRequest) Descriptor() ([]byte, []int) {
142 return fileDescriptor_11f9efc6dfbf9b45, []int{2}
143 }
144 func (m *UnregisterComputeAgentRequest) XXX_Unmarshal(b []byte) error {
145 return m.Unmarshal(b)
146 }
147 func (m *UnregisterComputeAgentRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
148 if deterministic {
149 return xxx_messageInfo_UnregisterComputeAgentRequest.Marshal(b, m, deterministic)
150 } else {
151 b = b[:cap(b)]
152 n, err := m.MarshalToSizedBuffer(b)
153 if err != nil {
154 return nil, err
155 }
156 return b[:n], nil
157 }
158 }
159 func (m *UnregisterComputeAgentRequest) XXX_Merge(src proto.Message) {
160 xxx_messageInfo_UnregisterComputeAgentRequest.Merge(m, src)
161 }
162 func (m *UnregisterComputeAgentRequest) XXX_Size() int {
163 return m.Size()
164 }
165 func (m *UnregisterComputeAgentRequest) XXX_DiscardUnknown() {
166 xxx_messageInfo_UnregisterComputeAgentRequest.DiscardUnknown(m)
167 }
168
169 var xxx_messageInfo_UnregisterComputeAgentRequest proto.InternalMessageInfo
170
171 type UnregisterComputeAgentResponse struct {
172 XXX_NoUnkeyedLiteral struct{} `json:"-"`
173 XXX_unrecognized []byte `json:"-"`
174 XXX_sizecache int32 `json:"-"`
175 }
176
177 func (m *UnregisterComputeAgentResponse) Reset() { *m = UnregisterComputeAgentResponse{} }
178 func (*UnregisterComputeAgentResponse) ProtoMessage() {}
179 func (*UnregisterComputeAgentResponse) Descriptor() ([]byte, []int) {
180 return fileDescriptor_11f9efc6dfbf9b45, []int{3}
181 }
182 func (m *UnregisterComputeAgentResponse) XXX_Unmarshal(b []byte) error {
183 return m.Unmarshal(b)
184 }
185 func (m *UnregisterComputeAgentResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
186 if deterministic {
187 return xxx_messageInfo_UnregisterComputeAgentResponse.Marshal(b, m, deterministic)
188 } else {
189 b = b[:cap(b)]
190 n, err := m.MarshalToSizedBuffer(b)
191 if err != nil {
192 return nil, err
193 }
194 return b[:n], nil
195 }
196 }
197 func (m *UnregisterComputeAgentResponse) XXX_Merge(src proto.Message) {
198 xxx_messageInfo_UnregisterComputeAgentResponse.Merge(m, src)
199 }
200 func (m *UnregisterComputeAgentResponse) XXX_Size() int {
201 return m.Size()
202 }
203 func (m *UnregisterComputeAgentResponse) XXX_DiscardUnknown() {
204 xxx_messageInfo_UnregisterComputeAgentResponse.DiscardUnknown(m)
205 }
206
207 var xxx_messageInfo_UnregisterComputeAgentResponse proto.InternalMessageInfo
208
209 type ConfigureNetworkingInternalRequest struct {
210 ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
211 RequestType RequestTypeInternal `protobuf:"varint,2,opt,name=request_type,json=requestType,proto3,enum=RequestTypeInternal" json:"request_type,omitempty"`
212 XXX_NoUnkeyedLiteral struct{} `json:"-"`
213 XXX_unrecognized []byte `json:"-"`
214 XXX_sizecache int32 `json:"-"`
215 }
216
217 func (m *ConfigureNetworkingInternalRequest) Reset() { *m = ConfigureNetworkingInternalRequest{} }
218 func (*ConfigureNetworkingInternalRequest) ProtoMessage() {}
219 func (*ConfigureNetworkingInternalRequest) Descriptor() ([]byte, []int) {
220 return fileDescriptor_11f9efc6dfbf9b45, []int{4}
221 }
222 func (m *ConfigureNetworkingInternalRequest) XXX_Unmarshal(b []byte) error {
223 return m.Unmarshal(b)
224 }
225 func (m *ConfigureNetworkingInternalRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
226 if deterministic {
227 return xxx_messageInfo_ConfigureNetworkingInternalRequest.Marshal(b, m, deterministic)
228 } else {
229 b = b[:cap(b)]
230 n, err := m.MarshalToSizedBuffer(b)
231 if err != nil {
232 return nil, err
233 }
234 return b[:n], nil
235 }
236 }
237 func (m *ConfigureNetworkingInternalRequest) XXX_Merge(src proto.Message) {
238 xxx_messageInfo_ConfigureNetworkingInternalRequest.Merge(m, src)
239 }
240 func (m *ConfigureNetworkingInternalRequest) XXX_Size() int {
241 return m.Size()
242 }
243 func (m *ConfigureNetworkingInternalRequest) XXX_DiscardUnknown() {
244 xxx_messageInfo_ConfigureNetworkingInternalRequest.DiscardUnknown(m)
245 }
246
247 var xxx_messageInfo_ConfigureNetworkingInternalRequest proto.InternalMessageInfo
248
249 type ConfigureNetworkingInternalResponse struct {
250 XXX_NoUnkeyedLiteral struct{} `json:"-"`
251 XXX_unrecognized []byte `json:"-"`
252 XXX_sizecache int32 `json:"-"`
253 }
254
255 func (m *ConfigureNetworkingInternalResponse) Reset() { *m = ConfigureNetworkingInternalResponse{} }
256 func (*ConfigureNetworkingInternalResponse) ProtoMessage() {}
257 func (*ConfigureNetworkingInternalResponse) Descriptor() ([]byte, []int) {
258 return fileDescriptor_11f9efc6dfbf9b45, []int{5}
259 }
260 func (m *ConfigureNetworkingInternalResponse) XXX_Unmarshal(b []byte) error {
261 return m.Unmarshal(b)
262 }
263 func (m *ConfigureNetworkingInternalResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
264 if deterministic {
265 return xxx_messageInfo_ConfigureNetworkingInternalResponse.Marshal(b, m, deterministic)
266 } else {
267 b = b[:cap(b)]
268 n, err := m.MarshalToSizedBuffer(b)
269 if err != nil {
270 return nil, err
271 }
272 return b[:n], nil
273 }
274 }
275 func (m *ConfigureNetworkingInternalResponse) XXX_Merge(src proto.Message) {
276 xxx_messageInfo_ConfigureNetworkingInternalResponse.Merge(m, src)
277 }
278 func (m *ConfigureNetworkingInternalResponse) XXX_Size() int {
279 return m.Size()
280 }
281 func (m *ConfigureNetworkingInternalResponse) XXX_DiscardUnknown() {
282 xxx_messageInfo_ConfigureNetworkingInternalResponse.DiscardUnknown(m)
283 }
284
285 var xxx_messageInfo_ConfigureNetworkingInternalResponse proto.InternalMessageInfo
286
287 func init() {
288 proto.RegisterEnum("RequestTypeInternal", RequestTypeInternal_name, RequestTypeInternal_value)
289 proto.RegisterType((*RegisterComputeAgentRequest)(nil), "RegisterComputeAgentRequest")
290 proto.RegisterType((*RegisterComputeAgentResponse)(nil), "RegisterComputeAgentResponse")
291 proto.RegisterType((*UnregisterComputeAgentRequest)(nil), "UnregisterComputeAgentRequest")
292 proto.RegisterType((*UnregisterComputeAgentResponse)(nil), "UnregisterComputeAgentResponse")
293 proto.RegisterType((*ConfigureNetworkingInternalRequest)(nil), "ConfigureNetworkingInternalRequest")
294 proto.RegisterType((*ConfigureNetworkingInternalResponse)(nil), "ConfigureNetworkingInternalResponse")
295 }
296
297 func init() {
298 proto.RegisterFile("github.com/Microsoft/hcsshim/internal/ncproxyttrpc/networkconfigproxy.proto", fileDescriptor_11f9efc6dfbf9b45)
299 }
300
301 var fileDescriptor_11f9efc6dfbf9b45 = []byte{
302
303 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x53, 0x4d, 0x6b, 0x14, 0x41,
304 0x10, 0x9d, 0x0e, 0x28, 0xa6, 0x76, 0xd5, 0xd0, 0x59, 0x24, 0x8c, 0x49, 0x27, 0xcc, 0x2a, 0x88,
305 0x87, 0x1e, 0x58, 0x0f, 0x1e, 0xbc, 0x98, 0xac, 0x97, 0x45, 0x14, 0x99, 0x24, 0x20, 0xf1, 0xb0,
306 0xcc, 0xce, 0x54, 0x66, 0x1b, 0xdd, 0xee, 0xb6, 0xbb, 0xc7, 0xb8, 0x37, 0xff, 0x82, 0xff, 0xc3,
307 0x1f, 0x92, 0xa3, 0x47, 0x4f, 0x62, 0xe6, 0x97, 0xc8, 0x7c, 0x18, 0x45, 0xc6, 0x49, 0x30, 0xb7,
308 0xae, 0x47, 0xf5, 0x7b, 0xc5, 0x7b, 0x55, 0xf0, 0x3c, 0x13, 0x6e, 0x9e, 0xcf, 0x78, 0xa2, 0x16,
309 0xe1, 0x0b, 0x91, 0x18, 0x65, 0xd5, 0xb1, 0x0b, 0xe7, 0x89, 0xb5, 0x73, 0xb1, 0x08, 0x85, 0x74,
310 0x68, 0x64, 0xfc, 0x2e, 0x94, 0x89, 0x36, 0xea, 0xe3, 0xd2, 0x39, 0xa3, 0x93, 0x50, 0xa2, 0x3b,
311 0x51, 0xe6, 0x6d, 0xa2, 0xe4, 0xb1, 0xc8, 0x2a, 0x9c, 0x6b, 0xa3, 0x9c, 0xf2, 0x07, 0x99, 0xca,
312 0x54, 0xf5, 0x0c, 0xcb, 0x57, 0x8d, 0x06, 0x1f, 0xe0, 0x6e, 0x84, 0x99, 0xb0, 0x0e, 0xcd, 0x58,
313 0x2d, 0x74, 0xee, 0x70, 0x37, 0x43, 0xe9, 0x22, 0x7c, 0x9f, 0xa3, 0x75, 0x74, 0x08, 0x37, 0xe3,
314 0xb2, 0x9e, 0xc6, 0x69, 0x6a, 0xd0, 0xda, 0x0d, 0xb2, 0x43, 0x1e, 0xac, 0x46, 0xfd, 0x0a, 0xdc,
315 0xad, 0x31, 0x3a, 0x82, 0x7e, 0xa2, 0xa4, 0x8b, 0x85, 0x44, 0x33, 0x15, 0xe9, 0xc6, 0x4a, 0xd9,
316 0xb3, 0x77, 0xbb, 0xf8, 0xbe, 0xdd, 0x1b, 0xff, 0xc2, 0x27, 0xcf, 0xa2, 0xde, 0x79, 0xd3, 0x24,
317 0x0d, 0x18, 0x6c, 0xb6, 0xeb, 0x5a, 0xad, 0xa4, 0xc5, 0x60, 0x1f, 0xb6, 0x0e, 0xa5, 0xe9, 0x98,
318 0xec, 0x6f, 0x51, 0x72, 0x09, 0xd1, 0x1d, 0x60, 0xff, 0x22, 0x6d, 0x64, 0x3f, 0x13, 0x08, 0xc6,
319 0x95, 0x75, 0xb9, 0xc1, 0x97, 0xb5, 0x95, 0x42, 0x66, 0x93, 0xc6, 0xea, 0x2b, 0x88, 0xd3, 0xc7,
320 0xd0, 0x37, 0xf5, 0xf7, 0xa9, 0x5b, 0x6a, 0xac, 0x5c, 0xba, 0x35, 0x1a, 0xf0, 0x86, 0xf3, 0x60,
321 0xa9, 0xf1, 0x5c, 0xa6, 0x67, 0x7e, 0x83, 0xc1, 0x7d, 0x18, 0x76, 0x8e, 0x54, 0x8f, 0xfe, 0x90,
322 0xc3, 0x7a, 0x0b, 0x15, 0x5d, 0x85, 0x6b, 0xfb, 0xe8, 0x72, 0xbd, 0xe6, 0xd1, 0x3e, 0xdc, 0x38,
323 0xc0, 0xd8, 0xa4, 0xea, 0x44, 0xae, 0x91, 0xd1, 0x97, 0x15, 0xa0, 0x0d, 0x5d, 0x4d, 0xff, 0xaa,
324 0x5c, 0x16, 0x7a, 0x08, 0x83, 0xb6, 0x60, 0xe8, 0x26, 0xef, 0xd8, 0x13, 0x7f, 0x8b, 0x77, 0xa6,
325 0xe9, 0xd1, 0x37, 0x70, 0xa7, 0xdd, 0x7a, 0xca, 0x78, 0x67, 0xd0, 0xfe, 0x36, 0xbf, 0x20, 0x33,
326 0x8f, 0xce, 0x60, 0xbd, 0xc5, 0x21, 0x3a, 0xe4, 0x17, 0x47, 0xe9, 0xdf, 0xe3, 0x97, 0x30, 0x37,
327 0xf0, 0xf6, 0x8e, 0x4e, 0xcf, 0x98, 0xf7, 0xed, 0x8c, 0x79, 0x9f, 0x0a, 0x46, 0x4e, 0x0b, 0x46,
328 0xbe, 0x16, 0x8c, 0xfc, 0x28, 0x18, 0x39, 0x7a, 0xfa, 0x1f, 0x57, 0xfa, 0xe4, 0xcf, 0xea, 0xb5,
329 0x37, 0xbb, 0x5e, 0x5d, 0xe3, 0xa3, 0x9f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x95, 0xb3, 0x11, 0xd8,
330 0xf2, 0x03, 0x00, 0x00,
331 }
332
333 func (m *RegisterComputeAgentRequest) Marshal() (dAtA []byte, err error) {
334 size := m.Size()
335 dAtA = make([]byte, size)
336 n, err := m.MarshalToSizedBuffer(dAtA[:size])
337 if err != nil {
338 return nil, err
339 }
340 return dAtA[:n], nil
341 }
342
343 func (m *RegisterComputeAgentRequest) MarshalTo(dAtA []byte) (int, error) {
344 size := m.Size()
345 return m.MarshalToSizedBuffer(dAtA[:size])
346 }
347
348 func (m *RegisterComputeAgentRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
349 i := len(dAtA)
350 _ = i
351 var l int
352 _ = l
353 if m.XXX_unrecognized != nil {
354 i -= len(m.XXX_unrecognized)
355 copy(dAtA[i:], m.XXX_unrecognized)
356 }
357 if len(m.ContainerID) > 0 {
358 i -= len(m.ContainerID)
359 copy(dAtA[i:], m.ContainerID)
360 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ContainerID)))
361 i--
362 dAtA[i] = 0x12
363 }
364 if len(m.AgentAddress) > 0 {
365 i -= len(m.AgentAddress)
366 copy(dAtA[i:], m.AgentAddress)
367 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.AgentAddress)))
368 i--
369 dAtA[i] = 0xa
370 }
371 return len(dAtA) - i, nil
372 }
373
374 func (m *RegisterComputeAgentResponse) Marshal() (dAtA []byte, err error) {
375 size := m.Size()
376 dAtA = make([]byte, size)
377 n, err := m.MarshalToSizedBuffer(dAtA[:size])
378 if err != nil {
379 return nil, err
380 }
381 return dAtA[:n], nil
382 }
383
384 func (m *RegisterComputeAgentResponse) MarshalTo(dAtA []byte) (int, error) {
385 size := m.Size()
386 return m.MarshalToSizedBuffer(dAtA[:size])
387 }
388
389 func (m *RegisterComputeAgentResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
390 i := len(dAtA)
391 _ = i
392 var l int
393 _ = l
394 if m.XXX_unrecognized != nil {
395 i -= len(m.XXX_unrecognized)
396 copy(dAtA[i:], m.XXX_unrecognized)
397 }
398 return len(dAtA) - i, nil
399 }
400
401 func (m *UnregisterComputeAgentRequest) Marshal() (dAtA []byte, err error) {
402 size := m.Size()
403 dAtA = make([]byte, size)
404 n, err := m.MarshalToSizedBuffer(dAtA[:size])
405 if err != nil {
406 return nil, err
407 }
408 return dAtA[:n], nil
409 }
410
411 func (m *UnregisterComputeAgentRequest) MarshalTo(dAtA []byte) (int, error) {
412 size := m.Size()
413 return m.MarshalToSizedBuffer(dAtA[:size])
414 }
415
416 func (m *UnregisterComputeAgentRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
417 i := len(dAtA)
418 _ = i
419 var l int
420 _ = l
421 if m.XXX_unrecognized != nil {
422 i -= len(m.XXX_unrecognized)
423 copy(dAtA[i:], m.XXX_unrecognized)
424 }
425 if len(m.ContainerID) > 0 {
426 i -= len(m.ContainerID)
427 copy(dAtA[i:], m.ContainerID)
428 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ContainerID)))
429 i--
430 dAtA[i] = 0xa
431 }
432 return len(dAtA) - i, nil
433 }
434
435 func (m *UnregisterComputeAgentResponse) Marshal() (dAtA []byte, err error) {
436 size := m.Size()
437 dAtA = make([]byte, size)
438 n, err := m.MarshalToSizedBuffer(dAtA[:size])
439 if err != nil {
440 return nil, err
441 }
442 return dAtA[:n], nil
443 }
444
445 func (m *UnregisterComputeAgentResponse) MarshalTo(dAtA []byte) (int, error) {
446 size := m.Size()
447 return m.MarshalToSizedBuffer(dAtA[:size])
448 }
449
450 func (m *UnregisterComputeAgentResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
451 i := len(dAtA)
452 _ = i
453 var l int
454 _ = l
455 if m.XXX_unrecognized != nil {
456 i -= len(m.XXX_unrecognized)
457 copy(dAtA[i:], m.XXX_unrecognized)
458 }
459 return len(dAtA) - i, nil
460 }
461
462 func (m *ConfigureNetworkingInternalRequest) Marshal() (dAtA []byte, err error) {
463 size := m.Size()
464 dAtA = make([]byte, size)
465 n, err := m.MarshalToSizedBuffer(dAtA[:size])
466 if err != nil {
467 return nil, err
468 }
469 return dAtA[:n], nil
470 }
471
472 func (m *ConfigureNetworkingInternalRequest) MarshalTo(dAtA []byte) (int, error) {
473 size := m.Size()
474 return m.MarshalToSizedBuffer(dAtA[:size])
475 }
476
477 func (m *ConfigureNetworkingInternalRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
478 i := len(dAtA)
479 _ = i
480 var l int
481 _ = l
482 if m.XXX_unrecognized != nil {
483 i -= len(m.XXX_unrecognized)
484 copy(dAtA[i:], m.XXX_unrecognized)
485 }
486 if m.RequestType != 0 {
487 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(m.RequestType))
488 i--
489 dAtA[i] = 0x10
490 }
491 if len(m.ContainerID) > 0 {
492 i -= len(m.ContainerID)
493 copy(dAtA[i:], m.ContainerID)
494 i = encodeVarintNetworkconfigproxy(dAtA, i, uint64(len(m.ContainerID)))
495 i--
496 dAtA[i] = 0xa
497 }
498 return len(dAtA) - i, nil
499 }
500
501 func (m *ConfigureNetworkingInternalResponse) Marshal() (dAtA []byte, err error) {
502 size := m.Size()
503 dAtA = make([]byte, size)
504 n, err := m.MarshalToSizedBuffer(dAtA[:size])
505 if err != nil {
506 return nil, err
507 }
508 return dAtA[:n], nil
509 }
510
511 func (m *ConfigureNetworkingInternalResponse) MarshalTo(dAtA []byte) (int, error) {
512 size := m.Size()
513 return m.MarshalToSizedBuffer(dAtA[:size])
514 }
515
516 func (m *ConfigureNetworkingInternalResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
517 i := len(dAtA)
518 _ = i
519 var l int
520 _ = l
521 if m.XXX_unrecognized != nil {
522 i -= len(m.XXX_unrecognized)
523 copy(dAtA[i:], m.XXX_unrecognized)
524 }
525 return len(dAtA) - i, nil
526 }
527
528 func encodeVarintNetworkconfigproxy(dAtA []byte, offset int, v uint64) int {
529 offset -= sovNetworkconfigproxy(v)
530 base := offset
531 for v >= 1<<7 {
532 dAtA[offset] = uint8(v&0x7f | 0x80)
533 v >>= 7
534 offset++
535 }
536 dAtA[offset] = uint8(v)
537 return base
538 }
539 func (m *RegisterComputeAgentRequest) Size() (n int) {
540 if m == nil {
541 return 0
542 }
543 var l int
544 _ = l
545 l = len(m.AgentAddress)
546 if l > 0 {
547 n += 1 + l + sovNetworkconfigproxy(uint64(l))
548 }
549 l = len(m.ContainerID)
550 if l > 0 {
551 n += 1 + l + sovNetworkconfigproxy(uint64(l))
552 }
553 if m.XXX_unrecognized != nil {
554 n += len(m.XXX_unrecognized)
555 }
556 return n
557 }
558
559 func (m *RegisterComputeAgentResponse) Size() (n int) {
560 if m == nil {
561 return 0
562 }
563 var l int
564 _ = l
565 if m.XXX_unrecognized != nil {
566 n += len(m.XXX_unrecognized)
567 }
568 return n
569 }
570
571 func (m *UnregisterComputeAgentRequest) Size() (n int) {
572 if m == nil {
573 return 0
574 }
575 var l int
576 _ = l
577 l = len(m.ContainerID)
578 if l > 0 {
579 n += 1 + l + sovNetworkconfigproxy(uint64(l))
580 }
581 if m.XXX_unrecognized != nil {
582 n += len(m.XXX_unrecognized)
583 }
584 return n
585 }
586
587 func (m *UnregisterComputeAgentResponse) Size() (n int) {
588 if m == nil {
589 return 0
590 }
591 var l int
592 _ = l
593 if m.XXX_unrecognized != nil {
594 n += len(m.XXX_unrecognized)
595 }
596 return n
597 }
598
599 func (m *ConfigureNetworkingInternalRequest) Size() (n int) {
600 if m == nil {
601 return 0
602 }
603 var l int
604 _ = l
605 l = len(m.ContainerID)
606 if l > 0 {
607 n += 1 + l + sovNetworkconfigproxy(uint64(l))
608 }
609 if m.RequestType != 0 {
610 n += 1 + sovNetworkconfigproxy(uint64(m.RequestType))
611 }
612 if m.XXX_unrecognized != nil {
613 n += len(m.XXX_unrecognized)
614 }
615 return n
616 }
617
618 func (m *ConfigureNetworkingInternalResponse) Size() (n int) {
619 if m == nil {
620 return 0
621 }
622 var l int
623 _ = l
624 if m.XXX_unrecognized != nil {
625 n += len(m.XXX_unrecognized)
626 }
627 return n
628 }
629
630 func sovNetworkconfigproxy(x uint64) (n int) {
631 return (math_bits.Len64(x|1) + 6) / 7
632 }
633 func sozNetworkconfigproxy(x uint64) (n int) {
634 return sovNetworkconfigproxy(uint64((x << 1) ^ uint64((int64(x) >> 63))))
635 }
636 func (this *RegisterComputeAgentRequest) String() string {
637 if this == nil {
638 return "nil"
639 }
640 s := strings.Join([]string{`&RegisterComputeAgentRequest{`,
641 `AgentAddress:` + fmt.Sprintf("%v", this.AgentAddress) + `,`,
642 `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
643 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
644 `}`,
645 }, "")
646 return s
647 }
648 func (this *RegisterComputeAgentResponse) String() string {
649 if this == nil {
650 return "nil"
651 }
652 s := strings.Join([]string{`&RegisterComputeAgentResponse{`,
653 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
654 `}`,
655 }, "")
656 return s
657 }
658 func (this *UnregisterComputeAgentRequest) String() string {
659 if this == nil {
660 return "nil"
661 }
662 s := strings.Join([]string{`&UnregisterComputeAgentRequest{`,
663 `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
664 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
665 `}`,
666 }, "")
667 return s
668 }
669 func (this *UnregisterComputeAgentResponse) String() string {
670 if this == nil {
671 return "nil"
672 }
673 s := strings.Join([]string{`&UnregisterComputeAgentResponse{`,
674 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
675 `}`,
676 }, "")
677 return s
678 }
679 func (this *ConfigureNetworkingInternalRequest) String() string {
680 if this == nil {
681 return "nil"
682 }
683 s := strings.Join([]string{`&ConfigureNetworkingInternalRequest{`,
684 `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
685 `RequestType:` + fmt.Sprintf("%v", this.RequestType) + `,`,
686 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
687 `}`,
688 }, "")
689 return s
690 }
691 func (this *ConfigureNetworkingInternalResponse) String() string {
692 if this == nil {
693 return "nil"
694 }
695 s := strings.Join([]string{`&ConfigureNetworkingInternalResponse{`,
696 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
697 `}`,
698 }, "")
699 return s
700 }
701 func valueToStringNetworkconfigproxy(v interface{}) string {
702 rv := reflect.ValueOf(v)
703 if rv.IsNil() {
704 return "nil"
705 }
706 pv := reflect.Indirect(rv).Interface()
707 return fmt.Sprintf("*%v", pv)
708 }
709
710 type NetworkConfigProxyService interface {
711 RegisterComputeAgent(ctx context.Context, req *RegisterComputeAgentRequest) (*RegisterComputeAgentResponse, error)
712 UnregisterComputeAgent(ctx context.Context, req *UnregisterComputeAgentRequest) (*UnregisterComputeAgentResponse, error)
713 ConfigureNetworking(ctx context.Context, req *ConfigureNetworkingInternalRequest) (*ConfigureNetworkingInternalResponse, error)
714 }
715
716 func RegisterNetworkConfigProxyService(srv *github_com_containerd_ttrpc.Server, svc NetworkConfigProxyService) {
717 srv.Register("NetworkConfigProxy", map[string]github_com_containerd_ttrpc.Method{
718 "RegisterComputeAgent": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
719 var req RegisterComputeAgentRequest
720 if err := unmarshal(&req); err != nil {
721 return nil, err
722 }
723 return svc.RegisterComputeAgent(ctx, &req)
724 },
725 "UnregisterComputeAgent": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
726 var req UnregisterComputeAgentRequest
727 if err := unmarshal(&req); err != nil {
728 return nil, err
729 }
730 return svc.UnregisterComputeAgent(ctx, &req)
731 },
732 "ConfigureNetworking": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
733 var req ConfigureNetworkingInternalRequest
734 if err := unmarshal(&req); err != nil {
735 return nil, err
736 }
737 return svc.ConfigureNetworking(ctx, &req)
738 },
739 })
740 }
741
742 type networkConfigProxyClient struct {
743 client *github_com_containerd_ttrpc.Client
744 }
745
746 func NewNetworkConfigProxyClient(client *github_com_containerd_ttrpc.Client) NetworkConfigProxyService {
747 return &networkConfigProxyClient{
748 client: client,
749 }
750 }
751
752 func (c *networkConfigProxyClient) RegisterComputeAgent(ctx context.Context, req *RegisterComputeAgentRequest) (*RegisterComputeAgentResponse, error) {
753 var resp RegisterComputeAgentResponse
754 if err := c.client.Call(ctx, "NetworkConfigProxy", "RegisterComputeAgent", req, &resp); err != nil {
755 return nil, err
756 }
757 return &resp, nil
758 }
759
760 func (c *networkConfigProxyClient) UnregisterComputeAgent(ctx context.Context, req *UnregisterComputeAgentRequest) (*UnregisterComputeAgentResponse, error) {
761 var resp UnregisterComputeAgentResponse
762 if err := c.client.Call(ctx, "NetworkConfigProxy", "UnregisterComputeAgent", req, &resp); err != nil {
763 return nil, err
764 }
765 return &resp, nil
766 }
767
768 func (c *networkConfigProxyClient) ConfigureNetworking(ctx context.Context, req *ConfigureNetworkingInternalRequest) (*ConfigureNetworkingInternalResponse, error) {
769 var resp ConfigureNetworkingInternalResponse
770 if err := c.client.Call(ctx, "NetworkConfigProxy", "ConfigureNetworking", req, &resp); err != nil {
771 return nil, err
772 }
773 return &resp, nil
774 }
775 func (m *RegisterComputeAgentRequest) Unmarshal(dAtA []byte) error {
776 l := len(dAtA)
777 iNdEx := 0
778 for iNdEx < l {
779 preIndex := iNdEx
780 var wire uint64
781 for shift := uint(0); ; shift += 7 {
782 if shift >= 64 {
783 return ErrIntOverflowNetworkconfigproxy
784 }
785 if iNdEx >= l {
786 return io.ErrUnexpectedEOF
787 }
788 b := dAtA[iNdEx]
789 iNdEx++
790 wire |= uint64(b&0x7F) << shift
791 if b < 0x80 {
792 break
793 }
794 }
795 fieldNum := int32(wire >> 3)
796 wireType := int(wire & 0x7)
797 if wireType == 4 {
798 return fmt.Errorf("proto: RegisterComputeAgentRequest: wiretype end group for non-group")
799 }
800 if fieldNum <= 0 {
801 return fmt.Errorf("proto: RegisterComputeAgentRequest: illegal tag %d (wire type %d)", fieldNum, wire)
802 }
803 switch fieldNum {
804 case 1:
805 if wireType != 2 {
806 return fmt.Errorf("proto: wrong wireType = %d for field AgentAddress", wireType)
807 }
808 var stringLen uint64
809 for shift := uint(0); ; shift += 7 {
810 if shift >= 64 {
811 return ErrIntOverflowNetworkconfigproxy
812 }
813 if iNdEx >= l {
814 return io.ErrUnexpectedEOF
815 }
816 b := dAtA[iNdEx]
817 iNdEx++
818 stringLen |= uint64(b&0x7F) << shift
819 if b < 0x80 {
820 break
821 }
822 }
823 intStringLen := int(stringLen)
824 if intStringLen < 0 {
825 return ErrInvalidLengthNetworkconfigproxy
826 }
827 postIndex := iNdEx + intStringLen
828 if postIndex < 0 {
829 return ErrInvalidLengthNetworkconfigproxy
830 }
831 if postIndex > l {
832 return io.ErrUnexpectedEOF
833 }
834 m.AgentAddress = string(dAtA[iNdEx:postIndex])
835 iNdEx = postIndex
836 case 2:
837 if wireType != 2 {
838 return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
839 }
840 var stringLen uint64
841 for shift := uint(0); ; shift += 7 {
842 if shift >= 64 {
843 return ErrIntOverflowNetworkconfigproxy
844 }
845 if iNdEx >= l {
846 return io.ErrUnexpectedEOF
847 }
848 b := dAtA[iNdEx]
849 iNdEx++
850 stringLen |= uint64(b&0x7F) << shift
851 if b < 0x80 {
852 break
853 }
854 }
855 intStringLen := int(stringLen)
856 if intStringLen < 0 {
857 return ErrInvalidLengthNetworkconfigproxy
858 }
859 postIndex := iNdEx + intStringLen
860 if postIndex < 0 {
861 return ErrInvalidLengthNetworkconfigproxy
862 }
863 if postIndex > l {
864 return io.ErrUnexpectedEOF
865 }
866 m.ContainerID = string(dAtA[iNdEx:postIndex])
867 iNdEx = postIndex
868 default:
869 iNdEx = preIndex
870 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
871 if err != nil {
872 return err
873 }
874 if (skippy < 0) || (iNdEx+skippy) < 0 {
875 return ErrInvalidLengthNetworkconfigproxy
876 }
877 if (iNdEx + skippy) > l {
878 return io.ErrUnexpectedEOF
879 }
880 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
881 iNdEx += skippy
882 }
883 }
884
885 if iNdEx > l {
886 return io.ErrUnexpectedEOF
887 }
888 return nil
889 }
890 func (m *RegisterComputeAgentResponse) Unmarshal(dAtA []byte) error {
891 l := len(dAtA)
892 iNdEx := 0
893 for iNdEx < l {
894 preIndex := iNdEx
895 var wire uint64
896 for shift := uint(0); ; shift += 7 {
897 if shift >= 64 {
898 return ErrIntOverflowNetworkconfigproxy
899 }
900 if iNdEx >= l {
901 return io.ErrUnexpectedEOF
902 }
903 b := dAtA[iNdEx]
904 iNdEx++
905 wire |= uint64(b&0x7F) << shift
906 if b < 0x80 {
907 break
908 }
909 }
910 fieldNum := int32(wire >> 3)
911 wireType := int(wire & 0x7)
912 if wireType == 4 {
913 return fmt.Errorf("proto: RegisterComputeAgentResponse: wiretype end group for non-group")
914 }
915 if fieldNum <= 0 {
916 return fmt.Errorf("proto: RegisterComputeAgentResponse: illegal tag %d (wire type %d)", fieldNum, wire)
917 }
918 switch fieldNum {
919 default:
920 iNdEx = preIndex
921 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
922 if err != nil {
923 return err
924 }
925 if (skippy < 0) || (iNdEx+skippy) < 0 {
926 return ErrInvalidLengthNetworkconfigproxy
927 }
928 if (iNdEx + skippy) > l {
929 return io.ErrUnexpectedEOF
930 }
931 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
932 iNdEx += skippy
933 }
934 }
935
936 if iNdEx > l {
937 return io.ErrUnexpectedEOF
938 }
939 return nil
940 }
941 func (m *UnregisterComputeAgentRequest) Unmarshal(dAtA []byte) error {
942 l := len(dAtA)
943 iNdEx := 0
944 for iNdEx < l {
945 preIndex := iNdEx
946 var wire uint64
947 for shift := uint(0); ; shift += 7 {
948 if shift >= 64 {
949 return ErrIntOverflowNetworkconfigproxy
950 }
951 if iNdEx >= l {
952 return io.ErrUnexpectedEOF
953 }
954 b := dAtA[iNdEx]
955 iNdEx++
956 wire |= uint64(b&0x7F) << shift
957 if b < 0x80 {
958 break
959 }
960 }
961 fieldNum := int32(wire >> 3)
962 wireType := int(wire & 0x7)
963 if wireType == 4 {
964 return fmt.Errorf("proto: UnregisterComputeAgentRequest: wiretype end group for non-group")
965 }
966 if fieldNum <= 0 {
967 return fmt.Errorf("proto: UnregisterComputeAgentRequest: illegal tag %d (wire type %d)", fieldNum, wire)
968 }
969 switch fieldNum {
970 case 1:
971 if wireType != 2 {
972 return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
973 }
974 var stringLen uint64
975 for shift := uint(0); ; shift += 7 {
976 if shift >= 64 {
977 return ErrIntOverflowNetworkconfigproxy
978 }
979 if iNdEx >= l {
980 return io.ErrUnexpectedEOF
981 }
982 b := dAtA[iNdEx]
983 iNdEx++
984 stringLen |= uint64(b&0x7F) << shift
985 if b < 0x80 {
986 break
987 }
988 }
989 intStringLen := int(stringLen)
990 if intStringLen < 0 {
991 return ErrInvalidLengthNetworkconfigproxy
992 }
993 postIndex := iNdEx + intStringLen
994 if postIndex < 0 {
995 return ErrInvalidLengthNetworkconfigproxy
996 }
997 if postIndex > l {
998 return io.ErrUnexpectedEOF
999 }
1000 m.ContainerID = string(dAtA[iNdEx:postIndex])
1001 iNdEx = postIndex
1002 default:
1003 iNdEx = preIndex
1004 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
1005 if err != nil {
1006 return err
1007 }
1008 if (skippy < 0) || (iNdEx+skippy) < 0 {
1009 return ErrInvalidLengthNetworkconfigproxy
1010 }
1011 if (iNdEx + skippy) > l {
1012 return io.ErrUnexpectedEOF
1013 }
1014 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
1015 iNdEx += skippy
1016 }
1017 }
1018
1019 if iNdEx > l {
1020 return io.ErrUnexpectedEOF
1021 }
1022 return nil
1023 }
1024 func (m *UnregisterComputeAgentResponse) Unmarshal(dAtA []byte) error {
1025 l := len(dAtA)
1026 iNdEx := 0
1027 for iNdEx < l {
1028 preIndex := iNdEx
1029 var wire uint64
1030 for shift := uint(0); ; shift += 7 {
1031 if shift >= 64 {
1032 return ErrIntOverflowNetworkconfigproxy
1033 }
1034 if iNdEx >= l {
1035 return io.ErrUnexpectedEOF
1036 }
1037 b := dAtA[iNdEx]
1038 iNdEx++
1039 wire |= uint64(b&0x7F) << shift
1040 if b < 0x80 {
1041 break
1042 }
1043 }
1044 fieldNum := int32(wire >> 3)
1045 wireType := int(wire & 0x7)
1046 if wireType == 4 {
1047 return fmt.Errorf("proto: UnregisterComputeAgentResponse: wiretype end group for non-group")
1048 }
1049 if fieldNum <= 0 {
1050 return fmt.Errorf("proto: UnregisterComputeAgentResponse: illegal tag %d (wire type %d)", fieldNum, wire)
1051 }
1052 switch fieldNum {
1053 default:
1054 iNdEx = preIndex
1055 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
1056 if err != nil {
1057 return err
1058 }
1059 if (skippy < 0) || (iNdEx+skippy) < 0 {
1060 return ErrInvalidLengthNetworkconfigproxy
1061 }
1062 if (iNdEx + skippy) > l {
1063 return io.ErrUnexpectedEOF
1064 }
1065 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
1066 iNdEx += skippy
1067 }
1068 }
1069
1070 if iNdEx > l {
1071 return io.ErrUnexpectedEOF
1072 }
1073 return nil
1074 }
1075 func (m *ConfigureNetworkingInternalRequest) Unmarshal(dAtA []byte) error {
1076 l := len(dAtA)
1077 iNdEx := 0
1078 for iNdEx < l {
1079 preIndex := iNdEx
1080 var wire uint64
1081 for shift := uint(0); ; shift += 7 {
1082 if shift >= 64 {
1083 return ErrIntOverflowNetworkconfigproxy
1084 }
1085 if iNdEx >= l {
1086 return io.ErrUnexpectedEOF
1087 }
1088 b := dAtA[iNdEx]
1089 iNdEx++
1090 wire |= uint64(b&0x7F) << shift
1091 if b < 0x80 {
1092 break
1093 }
1094 }
1095 fieldNum := int32(wire >> 3)
1096 wireType := int(wire & 0x7)
1097 if wireType == 4 {
1098 return fmt.Errorf("proto: ConfigureNetworkingInternalRequest: wiretype end group for non-group")
1099 }
1100 if fieldNum <= 0 {
1101 return fmt.Errorf("proto: ConfigureNetworkingInternalRequest: illegal tag %d (wire type %d)", fieldNum, wire)
1102 }
1103 switch fieldNum {
1104 case 1:
1105 if wireType != 2 {
1106 return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
1107 }
1108 var stringLen uint64
1109 for shift := uint(0); ; shift += 7 {
1110 if shift >= 64 {
1111 return ErrIntOverflowNetworkconfigproxy
1112 }
1113 if iNdEx >= l {
1114 return io.ErrUnexpectedEOF
1115 }
1116 b := dAtA[iNdEx]
1117 iNdEx++
1118 stringLen |= uint64(b&0x7F) << shift
1119 if b < 0x80 {
1120 break
1121 }
1122 }
1123 intStringLen := int(stringLen)
1124 if intStringLen < 0 {
1125 return ErrInvalidLengthNetworkconfigproxy
1126 }
1127 postIndex := iNdEx + intStringLen
1128 if postIndex < 0 {
1129 return ErrInvalidLengthNetworkconfigproxy
1130 }
1131 if postIndex > l {
1132 return io.ErrUnexpectedEOF
1133 }
1134 m.ContainerID = string(dAtA[iNdEx:postIndex])
1135 iNdEx = postIndex
1136 case 2:
1137 if wireType != 0 {
1138 return fmt.Errorf("proto: wrong wireType = %d for field RequestType", wireType)
1139 }
1140 m.RequestType = 0
1141 for shift := uint(0); ; shift += 7 {
1142 if shift >= 64 {
1143 return ErrIntOverflowNetworkconfigproxy
1144 }
1145 if iNdEx >= l {
1146 return io.ErrUnexpectedEOF
1147 }
1148 b := dAtA[iNdEx]
1149 iNdEx++
1150 m.RequestType |= RequestTypeInternal(b&0x7F) << shift
1151 if b < 0x80 {
1152 break
1153 }
1154 }
1155 default:
1156 iNdEx = preIndex
1157 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
1158 if err != nil {
1159 return err
1160 }
1161 if (skippy < 0) || (iNdEx+skippy) < 0 {
1162 return ErrInvalidLengthNetworkconfigproxy
1163 }
1164 if (iNdEx + skippy) > l {
1165 return io.ErrUnexpectedEOF
1166 }
1167 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
1168 iNdEx += skippy
1169 }
1170 }
1171
1172 if iNdEx > l {
1173 return io.ErrUnexpectedEOF
1174 }
1175 return nil
1176 }
1177 func (m *ConfigureNetworkingInternalResponse) Unmarshal(dAtA []byte) error {
1178 l := len(dAtA)
1179 iNdEx := 0
1180 for iNdEx < l {
1181 preIndex := iNdEx
1182 var wire uint64
1183 for shift := uint(0); ; shift += 7 {
1184 if shift >= 64 {
1185 return ErrIntOverflowNetworkconfigproxy
1186 }
1187 if iNdEx >= l {
1188 return io.ErrUnexpectedEOF
1189 }
1190 b := dAtA[iNdEx]
1191 iNdEx++
1192 wire |= uint64(b&0x7F) << shift
1193 if b < 0x80 {
1194 break
1195 }
1196 }
1197 fieldNum := int32(wire >> 3)
1198 wireType := int(wire & 0x7)
1199 if wireType == 4 {
1200 return fmt.Errorf("proto: ConfigureNetworkingInternalResponse: wiretype end group for non-group")
1201 }
1202 if fieldNum <= 0 {
1203 return fmt.Errorf("proto: ConfigureNetworkingInternalResponse: illegal tag %d (wire type %d)", fieldNum, wire)
1204 }
1205 switch fieldNum {
1206 default:
1207 iNdEx = preIndex
1208 skippy, err := skipNetworkconfigproxy(dAtA[iNdEx:])
1209 if err != nil {
1210 return err
1211 }
1212 if (skippy < 0) || (iNdEx+skippy) < 0 {
1213 return ErrInvalidLengthNetworkconfigproxy
1214 }
1215 if (iNdEx + skippy) > l {
1216 return io.ErrUnexpectedEOF
1217 }
1218 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
1219 iNdEx += skippy
1220 }
1221 }
1222
1223 if iNdEx > l {
1224 return io.ErrUnexpectedEOF
1225 }
1226 return nil
1227 }
1228 func skipNetworkconfigproxy(dAtA []byte) (n int, err error) {
1229 l := len(dAtA)
1230 iNdEx := 0
1231 depth := 0
1232 for iNdEx < l {
1233 var wire uint64
1234 for shift := uint(0); ; shift += 7 {
1235 if shift >= 64 {
1236 return 0, ErrIntOverflowNetworkconfigproxy
1237 }
1238 if iNdEx >= l {
1239 return 0, io.ErrUnexpectedEOF
1240 }
1241 b := dAtA[iNdEx]
1242 iNdEx++
1243 wire |= (uint64(b) & 0x7F) << shift
1244 if b < 0x80 {
1245 break
1246 }
1247 }
1248 wireType := int(wire & 0x7)
1249 switch wireType {
1250 case 0:
1251 for shift := uint(0); ; shift += 7 {
1252 if shift >= 64 {
1253 return 0, ErrIntOverflowNetworkconfigproxy
1254 }
1255 if iNdEx >= l {
1256 return 0, io.ErrUnexpectedEOF
1257 }
1258 iNdEx++
1259 if dAtA[iNdEx-1] < 0x80 {
1260 break
1261 }
1262 }
1263 case 1:
1264 iNdEx += 8
1265 case 2:
1266 var length int
1267 for shift := uint(0); ; shift += 7 {
1268 if shift >= 64 {
1269 return 0, ErrIntOverflowNetworkconfigproxy
1270 }
1271 if iNdEx >= l {
1272 return 0, io.ErrUnexpectedEOF
1273 }
1274 b := dAtA[iNdEx]
1275 iNdEx++
1276 length |= (int(b) & 0x7F) << shift
1277 if b < 0x80 {
1278 break
1279 }
1280 }
1281 if length < 0 {
1282 return 0, ErrInvalidLengthNetworkconfigproxy
1283 }
1284 iNdEx += length
1285 case 3:
1286 depth++
1287 case 4:
1288 if depth == 0 {
1289 return 0, ErrUnexpectedEndOfGroupNetworkconfigproxy
1290 }
1291 depth--
1292 case 5:
1293 iNdEx += 4
1294 default:
1295 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
1296 }
1297 if iNdEx < 0 {
1298 return 0, ErrInvalidLengthNetworkconfigproxy
1299 }
1300 if depth == 0 {
1301 return iNdEx, nil
1302 }
1303 }
1304 return 0, io.ErrUnexpectedEOF
1305 }
1306
1307 var (
1308 ErrInvalidLengthNetworkconfigproxy = fmt.Errorf("proto: negative length found during unmarshaling")
1309 ErrIntOverflowNetworkconfigproxy = fmt.Errorf("proto: integer overflow")
1310 ErrUnexpectedEndOfGroupNetworkconfigproxy = fmt.Errorf("proto: unexpected end of group")
1311 )
1312
View as plain text