1
2
3
4 package computeagent
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 types "github.com/gogo/protobuf/types"
12 io "io"
13 math "math"
14 math_bits "math/bits"
15 reflect "reflect"
16 strings "strings"
17 )
18
19
20 var _ = proto.Marshal
21 var _ = fmt.Errorf
22 var _ = math.Inf
23
24
25
26
27
28 const _ = proto.GoGoProtoPackageIsVersion3
29
30 type AssignPCIInternalRequest struct {
31 ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
32 DeviceID string `protobuf:"bytes,2,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
33 VirtualFunctionIndex uint32 `protobuf:"varint,3,opt,name=virtual_function_index,json=virtualFunctionIndex,proto3" json:"virtual_function_index,omitempty"`
34 NicID string `protobuf:"bytes,4,opt,name=nic_id,json=nicId,proto3" json:"nic_id,omitempty"`
35 XXX_NoUnkeyedLiteral struct{} `json:"-"`
36 XXX_unrecognized []byte `json:"-"`
37 XXX_sizecache int32 `json:"-"`
38 }
39
40 func (m *AssignPCIInternalRequest) Reset() { *m = AssignPCIInternalRequest{} }
41 func (*AssignPCIInternalRequest) ProtoMessage() {}
42 func (*AssignPCIInternalRequest) Descriptor() ([]byte, []int) {
43 return fileDescriptor_7f2f03dc308add4c, []int{0}
44 }
45 func (m *AssignPCIInternalRequest) XXX_Unmarshal(b []byte) error {
46 return m.Unmarshal(b)
47 }
48 func (m *AssignPCIInternalRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
49 if deterministic {
50 return xxx_messageInfo_AssignPCIInternalRequest.Marshal(b, m, deterministic)
51 } else {
52 b = b[:cap(b)]
53 n, err := m.MarshalToSizedBuffer(b)
54 if err != nil {
55 return nil, err
56 }
57 return b[:n], nil
58 }
59 }
60 func (m *AssignPCIInternalRequest) XXX_Merge(src proto.Message) {
61 xxx_messageInfo_AssignPCIInternalRequest.Merge(m, src)
62 }
63 func (m *AssignPCIInternalRequest) XXX_Size() int {
64 return m.Size()
65 }
66 func (m *AssignPCIInternalRequest) XXX_DiscardUnknown() {
67 xxx_messageInfo_AssignPCIInternalRequest.DiscardUnknown(m)
68 }
69
70 var xxx_messageInfo_AssignPCIInternalRequest proto.InternalMessageInfo
71
72 type AssignPCIInternalResponse struct {
73 ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
74 XXX_NoUnkeyedLiteral struct{} `json:"-"`
75 XXX_unrecognized []byte `json:"-"`
76 XXX_sizecache int32 `json:"-"`
77 }
78
79 func (m *AssignPCIInternalResponse) Reset() { *m = AssignPCIInternalResponse{} }
80 func (*AssignPCIInternalResponse) ProtoMessage() {}
81 func (*AssignPCIInternalResponse) Descriptor() ([]byte, []int) {
82 return fileDescriptor_7f2f03dc308add4c, []int{1}
83 }
84 func (m *AssignPCIInternalResponse) XXX_Unmarshal(b []byte) error {
85 return m.Unmarshal(b)
86 }
87 func (m *AssignPCIInternalResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
88 if deterministic {
89 return xxx_messageInfo_AssignPCIInternalResponse.Marshal(b, m, deterministic)
90 } else {
91 b = b[:cap(b)]
92 n, err := m.MarshalToSizedBuffer(b)
93 if err != nil {
94 return nil, err
95 }
96 return b[:n], nil
97 }
98 }
99 func (m *AssignPCIInternalResponse) XXX_Merge(src proto.Message) {
100 xxx_messageInfo_AssignPCIInternalResponse.Merge(m, src)
101 }
102 func (m *AssignPCIInternalResponse) XXX_Size() int {
103 return m.Size()
104 }
105 func (m *AssignPCIInternalResponse) XXX_DiscardUnknown() {
106 xxx_messageInfo_AssignPCIInternalResponse.DiscardUnknown(m)
107 }
108
109 var xxx_messageInfo_AssignPCIInternalResponse proto.InternalMessageInfo
110
111 type RemovePCIInternalRequest struct {
112 ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
113 DeviceID string `protobuf:"bytes,2,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
114 VirtualFunctionIndex uint32 `protobuf:"varint,3,opt,name=virtual_function_index,json=virtualFunctionIndex,proto3" json:"virtual_function_index,omitempty"`
115 XXX_NoUnkeyedLiteral struct{} `json:"-"`
116 XXX_unrecognized []byte `json:"-"`
117 XXX_sizecache int32 `json:"-"`
118 }
119
120 func (m *RemovePCIInternalRequest) Reset() { *m = RemovePCIInternalRequest{} }
121 func (*RemovePCIInternalRequest) ProtoMessage() {}
122 func (*RemovePCIInternalRequest) Descriptor() ([]byte, []int) {
123 return fileDescriptor_7f2f03dc308add4c, []int{2}
124 }
125 func (m *RemovePCIInternalRequest) XXX_Unmarshal(b []byte) error {
126 return m.Unmarshal(b)
127 }
128 func (m *RemovePCIInternalRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
129 if deterministic {
130 return xxx_messageInfo_RemovePCIInternalRequest.Marshal(b, m, deterministic)
131 } else {
132 b = b[:cap(b)]
133 n, err := m.MarshalToSizedBuffer(b)
134 if err != nil {
135 return nil, err
136 }
137 return b[:n], nil
138 }
139 }
140 func (m *RemovePCIInternalRequest) XXX_Merge(src proto.Message) {
141 xxx_messageInfo_RemovePCIInternalRequest.Merge(m, src)
142 }
143 func (m *RemovePCIInternalRequest) XXX_Size() int {
144 return m.Size()
145 }
146 func (m *RemovePCIInternalRequest) XXX_DiscardUnknown() {
147 xxx_messageInfo_RemovePCIInternalRequest.DiscardUnknown(m)
148 }
149
150 var xxx_messageInfo_RemovePCIInternalRequest proto.InternalMessageInfo
151
152 type RemovePCIInternalResponse struct {
153 XXX_NoUnkeyedLiteral struct{} `json:"-"`
154 XXX_unrecognized []byte `json:"-"`
155 XXX_sizecache int32 `json:"-"`
156 }
157
158 func (m *RemovePCIInternalResponse) Reset() { *m = RemovePCIInternalResponse{} }
159 func (*RemovePCIInternalResponse) ProtoMessage() {}
160 func (*RemovePCIInternalResponse) Descriptor() ([]byte, []int) {
161 return fileDescriptor_7f2f03dc308add4c, []int{3}
162 }
163 func (m *RemovePCIInternalResponse) XXX_Unmarshal(b []byte) error {
164 return m.Unmarshal(b)
165 }
166 func (m *RemovePCIInternalResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
167 if deterministic {
168 return xxx_messageInfo_RemovePCIInternalResponse.Marshal(b, m, deterministic)
169 } else {
170 b = b[:cap(b)]
171 n, err := m.MarshalToSizedBuffer(b)
172 if err != nil {
173 return nil, err
174 }
175 return b[:n], nil
176 }
177 }
178 func (m *RemovePCIInternalResponse) XXX_Merge(src proto.Message) {
179 xxx_messageInfo_RemovePCIInternalResponse.Merge(m, src)
180 }
181 func (m *RemovePCIInternalResponse) XXX_Size() int {
182 return m.Size()
183 }
184 func (m *RemovePCIInternalResponse) XXX_DiscardUnknown() {
185 xxx_messageInfo_RemovePCIInternalResponse.DiscardUnknown(m)
186 }
187
188 var xxx_messageInfo_RemovePCIInternalResponse proto.InternalMessageInfo
189
190 type AddNICInternalRequest struct {
191 ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
192 NicID string `protobuf:"bytes,2,opt,name=nic_id,json=nicId,proto3" json:"nic_id,omitempty"`
193 Endpoint *types.Any `protobuf:"bytes,3,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
194 XXX_NoUnkeyedLiteral struct{} `json:"-"`
195 XXX_unrecognized []byte `json:"-"`
196 XXX_sizecache int32 `json:"-"`
197 }
198
199 func (m *AddNICInternalRequest) Reset() { *m = AddNICInternalRequest{} }
200 func (*AddNICInternalRequest) ProtoMessage() {}
201 func (*AddNICInternalRequest) Descriptor() ([]byte, []int) {
202 return fileDescriptor_7f2f03dc308add4c, []int{4}
203 }
204 func (m *AddNICInternalRequest) XXX_Unmarshal(b []byte) error {
205 return m.Unmarshal(b)
206 }
207 func (m *AddNICInternalRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
208 if deterministic {
209 return xxx_messageInfo_AddNICInternalRequest.Marshal(b, m, deterministic)
210 } else {
211 b = b[:cap(b)]
212 n, err := m.MarshalToSizedBuffer(b)
213 if err != nil {
214 return nil, err
215 }
216 return b[:n], nil
217 }
218 }
219 func (m *AddNICInternalRequest) XXX_Merge(src proto.Message) {
220 xxx_messageInfo_AddNICInternalRequest.Merge(m, src)
221 }
222 func (m *AddNICInternalRequest) XXX_Size() int {
223 return m.Size()
224 }
225 func (m *AddNICInternalRequest) XXX_DiscardUnknown() {
226 xxx_messageInfo_AddNICInternalRequest.DiscardUnknown(m)
227 }
228
229 var xxx_messageInfo_AddNICInternalRequest proto.InternalMessageInfo
230
231 type AddNICInternalResponse struct {
232 XXX_NoUnkeyedLiteral struct{} `json:"-"`
233 XXX_unrecognized []byte `json:"-"`
234 XXX_sizecache int32 `json:"-"`
235 }
236
237 func (m *AddNICInternalResponse) Reset() { *m = AddNICInternalResponse{} }
238 func (*AddNICInternalResponse) ProtoMessage() {}
239 func (*AddNICInternalResponse) Descriptor() ([]byte, []int) {
240 return fileDescriptor_7f2f03dc308add4c, []int{5}
241 }
242 func (m *AddNICInternalResponse) XXX_Unmarshal(b []byte) error {
243 return m.Unmarshal(b)
244 }
245 func (m *AddNICInternalResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
246 if deterministic {
247 return xxx_messageInfo_AddNICInternalResponse.Marshal(b, m, deterministic)
248 } else {
249 b = b[:cap(b)]
250 n, err := m.MarshalToSizedBuffer(b)
251 if err != nil {
252 return nil, err
253 }
254 return b[:n], nil
255 }
256 }
257 func (m *AddNICInternalResponse) XXX_Merge(src proto.Message) {
258 xxx_messageInfo_AddNICInternalResponse.Merge(m, src)
259 }
260 func (m *AddNICInternalResponse) XXX_Size() int {
261 return m.Size()
262 }
263 func (m *AddNICInternalResponse) XXX_DiscardUnknown() {
264 xxx_messageInfo_AddNICInternalResponse.DiscardUnknown(m)
265 }
266
267 var xxx_messageInfo_AddNICInternalResponse proto.InternalMessageInfo
268
269 type ModifyNICInternalRequest struct {
270 NicID string `protobuf:"bytes,1,opt,name=nic_id,json=nicId,proto3" json:"nic_id,omitempty"`
271 Endpoint *types.Any `protobuf:"bytes,2,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
272 IovPolicySettings *IovSettings `protobuf:"bytes,3,opt,name=iov_policy_settings,json=iovPolicySettings,proto3" json:"iov_policy_settings,omitempty"`
273 XXX_NoUnkeyedLiteral struct{} `json:"-"`
274 XXX_unrecognized []byte `json:"-"`
275 XXX_sizecache int32 `json:"-"`
276 }
277
278 func (m *ModifyNICInternalRequest) Reset() { *m = ModifyNICInternalRequest{} }
279 func (*ModifyNICInternalRequest) ProtoMessage() {}
280 func (*ModifyNICInternalRequest) Descriptor() ([]byte, []int) {
281 return fileDescriptor_7f2f03dc308add4c, []int{6}
282 }
283 func (m *ModifyNICInternalRequest) XXX_Unmarshal(b []byte) error {
284 return m.Unmarshal(b)
285 }
286 func (m *ModifyNICInternalRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
287 if deterministic {
288 return xxx_messageInfo_ModifyNICInternalRequest.Marshal(b, m, deterministic)
289 } else {
290 b = b[:cap(b)]
291 n, err := m.MarshalToSizedBuffer(b)
292 if err != nil {
293 return nil, err
294 }
295 return b[:n], nil
296 }
297 }
298 func (m *ModifyNICInternalRequest) XXX_Merge(src proto.Message) {
299 xxx_messageInfo_ModifyNICInternalRequest.Merge(m, src)
300 }
301 func (m *ModifyNICInternalRequest) XXX_Size() int {
302 return m.Size()
303 }
304 func (m *ModifyNICInternalRequest) XXX_DiscardUnknown() {
305 xxx_messageInfo_ModifyNICInternalRequest.DiscardUnknown(m)
306 }
307
308 var xxx_messageInfo_ModifyNICInternalRequest proto.InternalMessageInfo
309
310 type ModifyNICInternalResponse struct {
311 XXX_NoUnkeyedLiteral struct{} `json:"-"`
312 XXX_unrecognized []byte `json:"-"`
313 XXX_sizecache int32 `json:"-"`
314 }
315
316 func (m *ModifyNICInternalResponse) Reset() { *m = ModifyNICInternalResponse{} }
317 func (*ModifyNICInternalResponse) ProtoMessage() {}
318 func (*ModifyNICInternalResponse) Descriptor() ([]byte, []int) {
319 return fileDescriptor_7f2f03dc308add4c, []int{7}
320 }
321 func (m *ModifyNICInternalResponse) XXX_Unmarshal(b []byte) error {
322 return m.Unmarshal(b)
323 }
324 func (m *ModifyNICInternalResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
325 if deterministic {
326 return xxx_messageInfo_ModifyNICInternalResponse.Marshal(b, m, deterministic)
327 } else {
328 b = b[:cap(b)]
329 n, err := m.MarshalToSizedBuffer(b)
330 if err != nil {
331 return nil, err
332 }
333 return b[:n], nil
334 }
335 }
336 func (m *ModifyNICInternalResponse) XXX_Merge(src proto.Message) {
337 xxx_messageInfo_ModifyNICInternalResponse.Merge(m, src)
338 }
339 func (m *ModifyNICInternalResponse) XXX_Size() int {
340 return m.Size()
341 }
342 func (m *ModifyNICInternalResponse) XXX_DiscardUnknown() {
343 xxx_messageInfo_ModifyNICInternalResponse.DiscardUnknown(m)
344 }
345
346 var xxx_messageInfo_ModifyNICInternalResponse proto.InternalMessageInfo
347
348 type DeleteNICInternalRequest struct {
349 ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
350 NicID string `protobuf:"bytes,2,opt,name=nic_id,json=nicId,proto3" json:"nic_id,omitempty"`
351 Endpoint *types.Any `protobuf:"bytes,3,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
352 XXX_NoUnkeyedLiteral struct{} `json:"-"`
353 XXX_unrecognized []byte `json:"-"`
354 XXX_sizecache int32 `json:"-"`
355 }
356
357 func (m *DeleteNICInternalRequest) Reset() { *m = DeleteNICInternalRequest{} }
358 func (*DeleteNICInternalRequest) ProtoMessage() {}
359 func (*DeleteNICInternalRequest) Descriptor() ([]byte, []int) {
360 return fileDescriptor_7f2f03dc308add4c, []int{8}
361 }
362 func (m *DeleteNICInternalRequest) XXX_Unmarshal(b []byte) error {
363 return m.Unmarshal(b)
364 }
365 func (m *DeleteNICInternalRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
366 if deterministic {
367 return xxx_messageInfo_DeleteNICInternalRequest.Marshal(b, m, deterministic)
368 } else {
369 b = b[:cap(b)]
370 n, err := m.MarshalToSizedBuffer(b)
371 if err != nil {
372 return nil, err
373 }
374 return b[:n], nil
375 }
376 }
377 func (m *DeleteNICInternalRequest) XXX_Merge(src proto.Message) {
378 xxx_messageInfo_DeleteNICInternalRequest.Merge(m, src)
379 }
380 func (m *DeleteNICInternalRequest) XXX_Size() int {
381 return m.Size()
382 }
383 func (m *DeleteNICInternalRequest) XXX_DiscardUnknown() {
384 xxx_messageInfo_DeleteNICInternalRequest.DiscardUnknown(m)
385 }
386
387 var xxx_messageInfo_DeleteNICInternalRequest proto.InternalMessageInfo
388
389 type DeleteNICInternalResponse struct {
390 XXX_NoUnkeyedLiteral struct{} `json:"-"`
391 XXX_unrecognized []byte `json:"-"`
392 XXX_sizecache int32 `json:"-"`
393 }
394
395 func (m *DeleteNICInternalResponse) Reset() { *m = DeleteNICInternalResponse{} }
396 func (*DeleteNICInternalResponse) ProtoMessage() {}
397 func (*DeleteNICInternalResponse) Descriptor() ([]byte, []int) {
398 return fileDescriptor_7f2f03dc308add4c, []int{9}
399 }
400 func (m *DeleteNICInternalResponse) XXX_Unmarshal(b []byte) error {
401 return m.Unmarshal(b)
402 }
403 func (m *DeleteNICInternalResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
404 if deterministic {
405 return xxx_messageInfo_DeleteNICInternalResponse.Marshal(b, m, deterministic)
406 } else {
407 b = b[:cap(b)]
408 n, err := m.MarshalToSizedBuffer(b)
409 if err != nil {
410 return nil, err
411 }
412 return b[:n], nil
413 }
414 }
415 func (m *DeleteNICInternalResponse) XXX_Merge(src proto.Message) {
416 xxx_messageInfo_DeleteNICInternalResponse.Merge(m, src)
417 }
418 func (m *DeleteNICInternalResponse) XXX_Size() int {
419 return m.Size()
420 }
421 func (m *DeleteNICInternalResponse) XXX_DiscardUnknown() {
422 xxx_messageInfo_DeleteNICInternalResponse.DiscardUnknown(m)
423 }
424
425 var xxx_messageInfo_DeleteNICInternalResponse proto.InternalMessageInfo
426
427 type IovSettings struct {
428 IovOffloadWeight uint32 `protobuf:"varint,1,opt,name=IovOffloadWeight,proto3" json:"IovOffloadWeight,omitempty"`
429 QueuePairsRequested uint32 `protobuf:"varint,2,opt,name=QueuePairsRequested,proto3" json:"QueuePairsRequested,omitempty"`
430 InterruptModeration uint32 `protobuf:"varint,3,opt,name=InterruptModeration,proto3" json:"InterruptModeration,omitempty"`
431 XXX_NoUnkeyedLiteral struct{} `json:"-"`
432 XXX_unrecognized []byte `json:"-"`
433 XXX_sizecache int32 `json:"-"`
434 }
435
436 func (m *IovSettings) Reset() { *m = IovSettings{} }
437 func (*IovSettings) ProtoMessage() {}
438 func (*IovSettings) Descriptor() ([]byte, []int) {
439 return fileDescriptor_7f2f03dc308add4c, []int{10}
440 }
441 func (m *IovSettings) XXX_Unmarshal(b []byte) error {
442 return m.Unmarshal(b)
443 }
444 func (m *IovSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
445 if deterministic {
446 return xxx_messageInfo_IovSettings.Marshal(b, m, deterministic)
447 } else {
448 b = b[:cap(b)]
449 n, err := m.MarshalToSizedBuffer(b)
450 if err != nil {
451 return nil, err
452 }
453 return b[:n], nil
454 }
455 }
456 func (m *IovSettings) XXX_Merge(src proto.Message) {
457 xxx_messageInfo_IovSettings.Merge(m, src)
458 }
459 func (m *IovSettings) XXX_Size() int {
460 return m.Size()
461 }
462 func (m *IovSettings) XXX_DiscardUnknown() {
463 xxx_messageInfo_IovSettings.DiscardUnknown(m)
464 }
465
466 var xxx_messageInfo_IovSettings proto.InternalMessageInfo
467
468 func init() {
469 proto.RegisterType((*AssignPCIInternalRequest)(nil), "AssignPCIInternalRequest")
470 proto.RegisterType((*AssignPCIInternalResponse)(nil), "AssignPCIInternalResponse")
471 proto.RegisterType((*RemovePCIInternalRequest)(nil), "RemovePCIInternalRequest")
472 proto.RegisterType((*RemovePCIInternalResponse)(nil), "RemovePCIInternalResponse")
473 proto.RegisterType((*AddNICInternalRequest)(nil), "AddNICInternalRequest")
474 proto.RegisterType((*AddNICInternalResponse)(nil), "AddNICInternalResponse")
475 proto.RegisterType((*ModifyNICInternalRequest)(nil), "ModifyNICInternalRequest")
476 proto.RegisterType((*ModifyNICInternalResponse)(nil), "ModifyNICInternalResponse")
477 proto.RegisterType((*DeleteNICInternalRequest)(nil), "DeleteNICInternalRequest")
478 proto.RegisterType((*DeleteNICInternalResponse)(nil), "DeleteNICInternalResponse")
479 proto.RegisterType((*IovSettings)(nil), "IovSettings")
480 }
481
482 func init() {
483 proto.RegisterFile("github.com/Microsoft/hcsshim/internal/computeagent/computeagent.proto", fileDescriptor_7f2f03dc308add4c)
484 }
485
486 var fileDescriptor_7f2f03dc308add4c = []byte{
487
488 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x55, 0xcf, 0x6f, 0xd3, 0x30,
489 0x14, 0xae, 0x0b, 0xab, 0x56, 0xb7, 0x13, 0xe0, 0x8d, 0x92, 0x64, 0x52, 0x3b, 0xf5, 0x34, 0x38,
490 0x38, 0xd3, 0xc6, 0x6d, 0x48, 0xa8, 0x6b, 0x40, 0xf2, 0x61, 0x63, 0x84, 0x03, 0x3f, 0x2e, 0x55,
491 0x16, 0xbb, 0xa9, 0xa5, 0xd6, 0x2e, 0x89, 0x13, 0xd1, 0x1b, 0xff, 0x08, 0x42, 0xe2, 0x8c, 0xc4,
492 0xbf, 0xb1, 0x23, 0xdc, 0x38, 0x55, 0x2c, 0xfc, 0x23, 0x28, 0x3f, 0x96, 0x0d, 0x48, 0xa4, 0x21,
493 0x71, 0x80, 0x9b, 0xfd, 0x9e, 0xfd, 0xf2, 0x7d, 0xef, 0x7d, 0xfe, 0x02, 0x1f, 0x79, 0x5c, 0x4d,
494 0xc2, 0x13, 0xec, 0xca, 0x99, 0x79, 0xc8, 0x5d, 0x5f, 0x06, 0x72, 0xac, 0xcc, 0x89, 0x1b, 0x04,
495 0x13, 0x3e, 0x33, 0xb9, 0x50, 0xcc, 0x17, 0xce, 0xd4, 0x74, 0xe5, 0x6c, 0x1e, 0x2a, 0xe6, 0x78,
496 0x4c, 0xa8, 0x9f, 0x36, 0x78, 0xee, 0x4b, 0x25, 0x8d, 0x0d, 0x4f, 0x7a, 0x32, 0x5d, 0x9a, 0xc9,
497 0x2a, 0x8f, 0xea, 0x9e, 0x94, 0xde, 0x94, 0x99, 0xe9, 0xee, 0x24, 0x1c, 0x9b, 0x8e, 0x58, 0x64,
498 0xa9, 0xfe, 0x17, 0x00, 0xb5, 0x41, 0x10, 0x70, 0x4f, 0x1c, 0x0f, 0x09, 0xc9, 0x3f, 0x63, 0xb3,
499 0xd7, 0x21, 0x0b, 0x14, 0xda, 0x85, 0x6d, 0x57, 0x0a, 0xe5, 0x70, 0xc1, 0xfc, 0x11, 0xa7, 0x1a,
500 0xd8, 0x02, 0xdb, 0xcd, 0x83, 0x1b, 0xf1, 0xb2, 0xd7, 0x1a, 0x9e, 0xc7, 0x89, 0x65, 0xb7, 0x8a,
501 0x43, 0x84, 0xa2, 0xbb, 0xb0, 0x49, 0x59, 0xc4, 0x5d, 0x96, 0x5c, 0xa8, 0xa7, 0x17, 0xda, 0xf1,
502 0xb2, 0xb7, 0x6a, 0xa5, 0x41, 0x62, 0xd9, 0xab, 0x59, 0x9a, 0x50, 0x74, 0x1f, 0x76, 0x22, 0xee,
503 0xab, 0xd0, 0x99, 0x8e, 0xc6, 0xa1, 0x70, 0x15, 0x97, 0x62, 0xc4, 0x05, 0x65, 0x6f, 0xb4, 0x6b,
504 0x5b, 0x60, 0x7b, 0xcd, 0xde, 0xc8, 0xb3, 0x8f, 0xf3, 0x24, 0x49, 0x72, 0x68, 0x0b, 0x36, 0x04,
505 0x77, 0x93, 0xea, 0xd7, 0xd3, 0xea, 0xcd, 0x78, 0xd9, 0x5b, 0x39, 0xe2, 0x2e, 0xb1, 0xec, 0x15,
506 0xc1, 0x5d, 0x42, 0xfb, 0x7b, 0x50, 0x2f, 0xa1, 0x14, 0xcc, 0xa5, 0x08, 0x18, 0xea, 0xc0, 0x7a,
507 0xc1, 0xa4, 0x11, 0x2f, 0x7b, 0x75, 0x62, 0xd9, 0x75, 0x4e, 0xfb, 0x9f, 0x00, 0xd4, 0x6c, 0x36,
508 0x93, 0x11, 0xfb, 0x4f, 0x1a, 0xd1, 0xdf, 0x84, 0x7a, 0x09, 0xe0, 0x8c, 0x66, 0xff, 0x3d, 0x80,
509 0xb7, 0x07, 0x94, 0x1e, 0x91, 0xe1, 0xdf, 0xe0, 0x72, 0xd1, 0xf3, 0x7a, 0x79, 0xcf, 0xd1, 0x0e,
510 0x5c, 0x65, 0x82, 0xce, 0x25, 0x17, 0x2a, 0x05, 0xdd, 0xda, 0xdd, 0xc0, 0x99, 0xea, 0xf0, 0xb9,
511 0xea, 0xf0, 0x40, 0x2c, 0xec, 0xe2, 0x54, 0x5f, 0x83, 0x9d, 0x5f, 0x01, 0xe6, 0xd8, 0x3f, 0x02,
512 0xa8, 0x1d, 0x4a, 0xca, 0xc7, 0x8b, 0x12, 0xf8, 0x17, 0x50, 0xc0, 0x15, 0xa0, 0xd4, 0xaf, 0x02,
513 0x05, 0x3d, 0x80, 0xeb, 0x5c, 0x46, 0xa3, 0xb9, 0x9c, 0x72, 0x77, 0x31, 0x0a, 0x98, 0x52, 0x5c,
514 0x78, 0x41, 0xce, 0xa3, 0x8d, 0x89, 0x8c, 0x9e, 0xe5, 0x31, 0xfb, 0x16, 0x97, 0xd1, 0x71, 0x7a,
515 0xee, 0x3c, 0x94, 0xcc, 0xa1, 0x04, 0x6d, 0xce, 0xe5, 0x03, 0x80, 0x9a, 0xc5, 0xa6, 0x4c, 0xb1,
516 0x7f, 0x78, 0x14, 0x9b, 0x50, 0x2f, 0xc1, 0x98, 0x33, 0x78, 0x07, 0x60, 0xeb, 0x52, 0x07, 0xd0,
517 0x3d, 0x78, 0x93, 0xc8, 0xe8, 0xc9, 0x78, 0x3c, 0x95, 0x0e, 0x7d, 0xce, 0xb8, 0x37, 0x51, 0x29,
518 0xf0, 0x35, 0xfb, 0xb7, 0x38, 0xda, 0x81, 0xeb, 0x4f, 0x43, 0x16, 0xb2, 0x63, 0x87, 0xfb, 0x41,
519 0xce, 0x9a, 0x65, 0xc8, 0xd7, 0xec, 0xb2, 0x54, 0x72, 0x23, 0x45, 0xe0, 0x87, 0x73, 0x75, 0x28,
520 0x29, 0xf3, 0x9d, 0x44, 0xf0, 0xf9, 0x3b, 0x28, 0x4b, 0xed, 0x7e, 0xaf, 0xc3, 0xf6, 0x30, 0x73,
521 0xc2, 0x41, 0xe2, 0x84, 0x68, 0x1f, 0x36, 0x32, 0x61, 0xa1, 0x0e, 0x2e, 0x7d, 0x02, 0xc6, 0x1d,
522 0x5c, 0xa1, 0xbc, 0x1a, 0xb2, 0x60, 0xb3, 0x18, 0x26, 0xd2, 0x71, 0x95, 0x0c, 0x0d, 0x03, 0x57,
523 0xcf, 0x3c, 0xad, 0x52, 0x34, 0x14, 0xe9, 0xb8, 0x4a, 0x00, 0x86, 0x81, 0xab, 0xfb, 0x9e, 0x56,
524 0x29, 0x7c, 0x0c, 0xe9, 0xb8, 0xca, 0xa6, 0x0d, 0x03, 0x57, 0xda, 0x5d, 0x56, 0xa5, 0xb0, 0x09,
525 0xa4, 0xe3, 0x2a, 0x8f, 0x33, 0x0c, 0x5c, 0xed, 0x26, 0xb5, 0x83, 0x97, 0xa7, 0x67, 0xdd, 0xda,
526 0xd7, 0xb3, 0x6e, 0xed, 0x6d, 0xdc, 0x05, 0xa7, 0x71, 0x17, 0x7c, 0x8e, 0xbb, 0xe0, 0x5b, 0xdc,
527 0x05, 0xaf, 0x1e, 0xfe, 0xf9, 0x9f, 0x6b, 0xff, 0xf2, 0xe6, 0x45, 0xed, 0xa4, 0x91, 0xea, 0x72,
528 0xef, 0x47, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe4, 0x25, 0x88, 0x14, 0x05, 0x07, 0x00, 0x00,
529 }
530
531 func (m *AssignPCIInternalRequest) Marshal() (dAtA []byte, err error) {
532 size := m.Size()
533 dAtA = make([]byte, size)
534 n, err := m.MarshalToSizedBuffer(dAtA[:size])
535 if err != nil {
536 return nil, err
537 }
538 return dAtA[:n], nil
539 }
540
541 func (m *AssignPCIInternalRequest) MarshalTo(dAtA []byte) (int, error) {
542 size := m.Size()
543 return m.MarshalToSizedBuffer(dAtA[:size])
544 }
545
546 func (m *AssignPCIInternalRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
547 i := len(dAtA)
548 _ = i
549 var l int
550 _ = l
551 if m.XXX_unrecognized != nil {
552 i -= len(m.XXX_unrecognized)
553 copy(dAtA[i:], m.XXX_unrecognized)
554 }
555 if len(m.NicID) > 0 {
556 i -= len(m.NicID)
557 copy(dAtA[i:], m.NicID)
558 i = encodeVarintComputeagent(dAtA, i, uint64(len(m.NicID)))
559 i--
560 dAtA[i] = 0x22
561 }
562 if m.VirtualFunctionIndex != 0 {
563 i = encodeVarintComputeagent(dAtA, i, uint64(m.VirtualFunctionIndex))
564 i--
565 dAtA[i] = 0x18
566 }
567 if len(m.DeviceID) > 0 {
568 i -= len(m.DeviceID)
569 copy(dAtA[i:], m.DeviceID)
570 i = encodeVarintComputeagent(dAtA, i, uint64(len(m.DeviceID)))
571 i--
572 dAtA[i] = 0x12
573 }
574 if len(m.ContainerID) > 0 {
575 i -= len(m.ContainerID)
576 copy(dAtA[i:], m.ContainerID)
577 i = encodeVarintComputeagent(dAtA, i, uint64(len(m.ContainerID)))
578 i--
579 dAtA[i] = 0xa
580 }
581 return len(dAtA) - i, nil
582 }
583
584 func (m *AssignPCIInternalResponse) Marshal() (dAtA []byte, err error) {
585 size := m.Size()
586 dAtA = make([]byte, size)
587 n, err := m.MarshalToSizedBuffer(dAtA[:size])
588 if err != nil {
589 return nil, err
590 }
591 return dAtA[:n], nil
592 }
593
594 func (m *AssignPCIInternalResponse) MarshalTo(dAtA []byte) (int, error) {
595 size := m.Size()
596 return m.MarshalToSizedBuffer(dAtA[:size])
597 }
598
599 func (m *AssignPCIInternalResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
600 i := len(dAtA)
601 _ = i
602 var l int
603 _ = l
604 if m.XXX_unrecognized != nil {
605 i -= len(m.XXX_unrecognized)
606 copy(dAtA[i:], m.XXX_unrecognized)
607 }
608 if len(m.ID) > 0 {
609 i -= len(m.ID)
610 copy(dAtA[i:], m.ID)
611 i = encodeVarintComputeagent(dAtA, i, uint64(len(m.ID)))
612 i--
613 dAtA[i] = 0xa
614 }
615 return len(dAtA) - i, nil
616 }
617
618 func (m *RemovePCIInternalRequest) Marshal() (dAtA []byte, err error) {
619 size := m.Size()
620 dAtA = make([]byte, size)
621 n, err := m.MarshalToSizedBuffer(dAtA[:size])
622 if err != nil {
623 return nil, err
624 }
625 return dAtA[:n], nil
626 }
627
628 func (m *RemovePCIInternalRequest) MarshalTo(dAtA []byte) (int, error) {
629 size := m.Size()
630 return m.MarshalToSizedBuffer(dAtA[:size])
631 }
632
633 func (m *RemovePCIInternalRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
634 i := len(dAtA)
635 _ = i
636 var l int
637 _ = l
638 if m.XXX_unrecognized != nil {
639 i -= len(m.XXX_unrecognized)
640 copy(dAtA[i:], m.XXX_unrecognized)
641 }
642 if m.VirtualFunctionIndex != 0 {
643 i = encodeVarintComputeagent(dAtA, i, uint64(m.VirtualFunctionIndex))
644 i--
645 dAtA[i] = 0x18
646 }
647 if len(m.DeviceID) > 0 {
648 i -= len(m.DeviceID)
649 copy(dAtA[i:], m.DeviceID)
650 i = encodeVarintComputeagent(dAtA, i, uint64(len(m.DeviceID)))
651 i--
652 dAtA[i] = 0x12
653 }
654 if len(m.ContainerID) > 0 {
655 i -= len(m.ContainerID)
656 copy(dAtA[i:], m.ContainerID)
657 i = encodeVarintComputeagent(dAtA, i, uint64(len(m.ContainerID)))
658 i--
659 dAtA[i] = 0xa
660 }
661 return len(dAtA) - i, nil
662 }
663
664 func (m *RemovePCIInternalResponse) Marshal() (dAtA []byte, err error) {
665 size := m.Size()
666 dAtA = make([]byte, size)
667 n, err := m.MarshalToSizedBuffer(dAtA[:size])
668 if err != nil {
669 return nil, err
670 }
671 return dAtA[:n], nil
672 }
673
674 func (m *RemovePCIInternalResponse) MarshalTo(dAtA []byte) (int, error) {
675 size := m.Size()
676 return m.MarshalToSizedBuffer(dAtA[:size])
677 }
678
679 func (m *RemovePCIInternalResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
680 i := len(dAtA)
681 _ = i
682 var l int
683 _ = l
684 if m.XXX_unrecognized != nil {
685 i -= len(m.XXX_unrecognized)
686 copy(dAtA[i:], m.XXX_unrecognized)
687 }
688 return len(dAtA) - i, nil
689 }
690
691 func (m *AddNICInternalRequest) Marshal() (dAtA []byte, err error) {
692 size := m.Size()
693 dAtA = make([]byte, size)
694 n, err := m.MarshalToSizedBuffer(dAtA[:size])
695 if err != nil {
696 return nil, err
697 }
698 return dAtA[:n], nil
699 }
700
701 func (m *AddNICInternalRequest) MarshalTo(dAtA []byte) (int, error) {
702 size := m.Size()
703 return m.MarshalToSizedBuffer(dAtA[:size])
704 }
705
706 func (m *AddNICInternalRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
707 i := len(dAtA)
708 _ = i
709 var l int
710 _ = l
711 if m.XXX_unrecognized != nil {
712 i -= len(m.XXX_unrecognized)
713 copy(dAtA[i:], m.XXX_unrecognized)
714 }
715 if m.Endpoint != nil {
716 {
717 size, err := m.Endpoint.MarshalToSizedBuffer(dAtA[:i])
718 if err != nil {
719 return 0, err
720 }
721 i -= size
722 i = encodeVarintComputeagent(dAtA, i, uint64(size))
723 }
724 i--
725 dAtA[i] = 0x1a
726 }
727 if len(m.NicID) > 0 {
728 i -= len(m.NicID)
729 copy(dAtA[i:], m.NicID)
730 i = encodeVarintComputeagent(dAtA, i, uint64(len(m.NicID)))
731 i--
732 dAtA[i] = 0x12
733 }
734 if len(m.ContainerID) > 0 {
735 i -= len(m.ContainerID)
736 copy(dAtA[i:], m.ContainerID)
737 i = encodeVarintComputeagent(dAtA, i, uint64(len(m.ContainerID)))
738 i--
739 dAtA[i] = 0xa
740 }
741 return len(dAtA) - i, nil
742 }
743
744 func (m *AddNICInternalResponse) Marshal() (dAtA []byte, err error) {
745 size := m.Size()
746 dAtA = make([]byte, size)
747 n, err := m.MarshalToSizedBuffer(dAtA[:size])
748 if err != nil {
749 return nil, err
750 }
751 return dAtA[:n], nil
752 }
753
754 func (m *AddNICInternalResponse) MarshalTo(dAtA []byte) (int, error) {
755 size := m.Size()
756 return m.MarshalToSizedBuffer(dAtA[:size])
757 }
758
759 func (m *AddNICInternalResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
760 i := len(dAtA)
761 _ = i
762 var l int
763 _ = l
764 if m.XXX_unrecognized != nil {
765 i -= len(m.XXX_unrecognized)
766 copy(dAtA[i:], m.XXX_unrecognized)
767 }
768 return len(dAtA) - i, nil
769 }
770
771 func (m *ModifyNICInternalRequest) Marshal() (dAtA []byte, err error) {
772 size := m.Size()
773 dAtA = make([]byte, size)
774 n, err := m.MarshalToSizedBuffer(dAtA[:size])
775 if err != nil {
776 return nil, err
777 }
778 return dAtA[:n], nil
779 }
780
781 func (m *ModifyNICInternalRequest) MarshalTo(dAtA []byte) (int, error) {
782 size := m.Size()
783 return m.MarshalToSizedBuffer(dAtA[:size])
784 }
785
786 func (m *ModifyNICInternalRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
787 i := len(dAtA)
788 _ = i
789 var l int
790 _ = l
791 if m.XXX_unrecognized != nil {
792 i -= len(m.XXX_unrecognized)
793 copy(dAtA[i:], m.XXX_unrecognized)
794 }
795 if m.IovPolicySettings != nil {
796 {
797 size, err := m.IovPolicySettings.MarshalToSizedBuffer(dAtA[:i])
798 if err != nil {
799 return 0, err
800 }
801 i -= size
802 i = encodeVarintComputeagent(dAtA, i, uint64(size))
803 }
804 i--
805 dAtA[i] = 0x1a
806 }
807 if m.Endpoint != nil {
808 {
809 size, err := m.Endpoint.MarshalToSizedBuffer(dAtA[:i])
810 if err != nil {
811 return 0, err
812 }
813 i -= size
814 i = encodeVarintComputeagent(dAtA, i, uint64(size))
815 }
816 i--
817 dAtA[i] = 0x12
818 }
819 if len(m.NicID) > 0 {
820 i -= len(m.NicID)
821 copy(dAtA[i:], m.NicID)
822 i = encodeVarintComputeagent(dAtA, i, uint64(len(m.NicID)))
823 i--
824 dAtA[i] = 0xa
825 }
826 return len(dAtA) - i, nil
827 }
828
829 func (m *ModifyNICInternalResponse) Marshal() (dAtA []byte, err error) {
830 size := m.Size()
831 dAtA = make([]byte, size)
832 n, err := m.MarshalToSizedBuffer(dAtA[:size])
833 if err != nil {
834 return nil, err
835 }
836 return dAtA[:n], nil
837 }
838
839 func (m *ModifyNICInternalResponse) MarshalTo(dAtA []byte) (int, error) {
840 size := m.Size()
841 return m.MarshalToSizedBuffer(dAtA[:size])
842 }
843
844 func (m *ModifyNICInternalResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
845 i := len(dAtA)
846 _ = i
847 var l int
848 _ = l
849 if m.XXX_unrecognized != nil {
850 i -= len(m.XXX_unrecognized)
851 copy(dAtA[i:], m.XXX_unrecognized)
852 }
853 return len(dAtA) - i, nil
854 }
855
856 func (m *DeleteNICInternalRequest) Marshal() (dAtA []byte, err error) {
857 size := m.Size()
858 dAtA = make([]byte, size)
859 n, err := m.MarshalToSizedBuffer(dAtA[:size])
860 if err != nil {
861 return nil, err
862 }
863 return dAtA[:n], nil
864 }
865
866 func (m *DeleteNICInternalRequest) MarshalTo(dAtA []byte) (int, error) {
867 size := m.Size()
868 return m.MarshalToSizedBuffer(dAtA[:size])
869 }
870
871 func (m *DeleteNICInternalRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
872 i := len(dAtA)
873 _ = i
874 var l int
875 _ = l
876 if m.XXX_unrecognized != nil {
877 i -= len(m.XXX_unrecognized)
878 copy(dAtA[i:], m.XXX_unrecognized)
879 }
880 if m.Endpoint != nil {
881 {
882 size, err := m.Endpoint.MarshalToSizedBuffer(dAtA[:i])
883 if err != nil {
884 return 0, err
885 }
886 i -= size
887 i = encodeVarintComputeagent(dAtA, i, uint64(size))
888 }
889 i--
890 dAtA[i] = 0x1a
891 }
892 if len(m.NicID) > 0 {
893 i -= len(m.NicID)
894 copy(dAtA[i:], m.NicID)
895 i = encodeVarintComputeagent(dAtA, i, uint64(len(m.NicID)))
896 i--
897 dAtA[i] = 0x12
898 }
899 if len(m.ContainerID) > 0 {
900 i -= len(m.ContainerID)
901 copy(dAtA[i:], m.ContainerID)
902 i = encodeVarintComputeagent(dAtA, i, uint64(len(m.ContainerID)))
903 i--
904 dAtA[i] = 0xa
905 }
906 return len(dAtA) - i, nil
907 }
908
909 func (m *DeleteNICInternalResponse) Marshal() (dAtA []byte, err error) {
910 size := m.Size()
911 dAtA = make([]byte, size)
912 n, err := m.MarshalToSizedBuffer(dAtA[:size])
913 if err != nil {
914 return nil, err
915 }
916 return dAtA[:n], nil
917 }
918
919 func (m *DeleteNICInternalResponse) MarshalTo(dAtA []byte) (int, error) {
920 size := m.Size()
921 return m.MarshalToSizedBuffer(dAtA[:size])
922 }
923
924 func (m *DeleteNICInternalResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
925 i := len(dAtA)
926 _ = i
927 var l int
928 _ = l
929 if m.XXX_unrecognized != nil {
930 i -= len(m.XXX_unrecognized)
931 copy(dAtA[i:], m.XXX_unrecognized)
932 }
933 return len(dAtA) - i, nil
934 }
935
936 func (m *IovSettings) Marshal() (dAtA []byte, err error) {
937 size := m.Size()
938 dAtA = make([]byte, size)
939 n, err := m.MarshalToSizedBuffer(dAtA[:size])
940 if err != nil {
941 return nil, err
942 }
943 return dAtA[:n], nil
944 }
945
946 func (m *IovSettings) MarshalTo(dAtA []byte) (int, error) {
947 size := m.Size()
948 return m.MarshalToSizedBuffer(dAtA[:size])
949 }
950
951 func (m *IovSettings) MarshalToSizedBuffer(dAtA []byte) (int, error) {
952 i := len(dAtA)
953 _ = i
954 var l int
955 _ = l
956 if m.XXX_unrecognized != nil {
957 i -= len(m.XXX_unrecognized)
958 copy(dAtA[i:], m.XXX_unrecognized)
959 }
960 if m.InterruptModeration != 0 {
961 i = encodeVarintComputeagent(dAtA, i, uint64(m.InterruptModeration))
962 i--
963 dAtA[i] = 0x18
964 }
965 if m.QueuePairsRequested != 0 {
966 i = encodeVarintComputeagent(dAtA, i, uint64(m.QueuePairsRequested))
967 i--
968 dAtA[i] = 0x10
969 }
970 if m.IovOffloadWeight != 0 {
971 i = encodeVarintComputeagent(dAtA, i, uint64(m.IovOffloadWeight))
972 i--
973 dAtA[i] = 0x8
974 }
975 return len(dAtA) - i, nil
976 }
977
978 func encodeVarintComputeagent(dAtA []byte, offset int, v uint64) int {
979 offset -= sovComputeagent(v)
980 base := offset
981 for v >= 1<<7 {
982 dAtA[offset] = uint8(v&0x7f | 0x80)
983 v >>= 7
984 offset++
985 }
986 dAtA[offset] = uint8(v)
987 return base
988 }
989 func (m *AssignPCIInternalRequest) Size() (n int) {
990 if m == nil {
991 return 0
992 }
993 var l int
994 _ = l
995 l = len(m.ContainerID)
996 if l > 0 {
997 n += 1 + l + sovComputeagent(uint64(l))
998 }
999 l = len(m.DeviceID)
1000 if l > 0 {
1001 n += 1 + l + sovComputeagent(uint64(l))
1002 }
1003 if m.VirtualFunctionIndex != 0 {
1004 n += 1 + sovComputeagent(uint64(m.VirtualFunctionIndex))
1005 }
1006 l = len(m.NicID)
1007 if l > 0 {
1008 n += 1 + l + sovComputeagent(uint64(l))
1009 }
1010 if m.XXX_unrecognized != nil {
1011 n += len(m.XXX_unrecognized)
1012 }
1013 return n
1014 }
1015
1016 func (m *AssignPCIInternalResponse) Size() (n int) {
1017 if m == nil {
1018 return 0
1019 }
1020 var l int
1021 _ = l
1022 l = len(m.ID)
1023 if l > 0 {
1024 n += 1 + l + sovComputeagent(uint64(l))
1025 }
1026 if m.XXX_unrecognized != nil {
1027 n += len(m.XXX_unrecognized)
1028 }
1029 return n
1030 }
1031
1032 func (m *RemovePCIInternalRequest) Size() (n int) {
1033 if m == nil {
1034 return 0
1035 }
1036 var l int
1037 _ = l
1038 l = len(m.ContainerID)
1039 if l > 0 {
1040 n += 1 + l + sovComputeagent(uint64(l))
1041 }
1042 l = len(m.DeviceID)
1043 if l > 0 {
1044 n += 1 + l + sovComputeagent(uint64(l))
1045 }
1046 if m.VirtualFunctionIndex != 0 {
1047 n += 1 + sovComputeagent(uint64(m.VirtualFunctionIndex))
1048 }
1049 if m.XXX_unrecognized != nil {
1050 n += len(m.XXX_unrecognized)
1051 }
1052 return n
1053 }
1054
1055 func (m *RemovePCIInternalResponse) Size() (n int) {
1056 if m == nil {
1057 return 0
1058 }
1059 var l int
1060 _ = l
1061 if m.XXX_unrecognized != nil {
1062 n += len(m.XXX_unrecognized)
1063 }
1064 return n
1065 }
1066
1067 func (m *AddNICInternalRequest) Size() (n int) {
1068 if m == nil {
1069 return 0
1070 }
1071 var l int
1072 _ = l
1073 l = len(m.ContainerID)
1074 if l > 0 {
1075 n += 1 + l + sovComputeagent(uint64(l))
1076 }
1077 l = len(m.NicID)
1078 if l > 0 {
1079 n += 1 + l + sovComputeagent(uint64(l))
1080 }
1081 if m.Endpoint != nil {
1082 l = m.Endpoint.Size()
1083 n += 1 + l + sovComputeagent(uint64(l))
1084 }
1085 if m.XXX_unrecognized != nil {
1086 n += len(m.XXX_unrecognized)
1087 }
1088 return n
1089 }
1090
1091 func (m *AddNICInternalResponse) Size() (n int) {
1092 if m == nil {
1093 return 0
1094 }
1095 var l int
1096 _ = l
1097 if m.XXX_unrecognized != nil {
1098 n += len(m.XXX_unrecognized)
1099 }
1100 return n
1101 }
1102
1103 func (m *ModifyNICInternalRequest) Size() (n int) {
1104 if m == nil {
1105 return 0
1106 }
1107 var l int
1108 _ = l
1109 l = len(m.NicID)
1110 if l > 0 {
1111 n += 1 + l + sovComputeagent(uint64(l))
1112 }
1113 if m.Endpoint != nil {
1114 l = m.Endpoint.Size()
1115 n += 1 + l + sovComputeagent(uint64(l))
1116 }
1117 if m.IovPolicySettings != nil {
1118 l = m.IovPolicySettings.Size()
1119 n += 1 + l + sovComputeagent(uint64(l))
1120 }
1121 if m.XXX_unrecognized != nil {
1122 n += len(m.XXX_unrecognized)
1123 }
1124 return n
1125 }
1126
1127 func (m *ModifyNICInternalResponse) Size() (n int) {
1128 if m == nil {
1129 return 0
1130 }
1131 var l int
1132 _ = l
1133 if m.XXX_unrecognized != nil {
1134 n += len(m.XXX_unrecognized)
1135 }
1136 return n
1137 }
1138
1139 func (m *DeleteNICInternalRequest) Size() (n int) {
1140 if m == nil {
1141 return 0
1142 }
1143 var l int
1144 _ = l
1145 l = len(m.ContainerID)
1146 if l > 0 {
1147 n += 1 + l + sovComputeagent(uint64(l))
1148 }
1149 l = len(m.NicID)
1150 if l > 0 {
1151 n += 1 + l + sovComputeagent(uint64(l))
1152 }
1153 if m.Endpoint != nil {
1154 l = m.Endpoint.Size()
1155 n += 1 + l + sovComputeagent(uint64(l))
1156 }
1157 if m.XXX_unrecognized != nil {
1158 n += len(m.XXX_unrecognized)
1159 }
1160 return n
1161 }
1162
1163 func (m *DeleteNICInternalResponse) Size() (n int) {
1164 if m == nil {
1165 return 0
1166 }
1167 var l int
1168 _ = l
1169 if m.XXX_unrecognized != nil {
1170 n += len(m.XXX_unrecognized)
1171 }
1172 return n
1173 }
1174
1175 func (m *IovSettings) Size() (n int) {
1176 if m == nil {
1177 return 0
1178 }
1179 var l int
1180 _ = l
1181 if m.IovOffloadWeight != 0 {
1182 n += 1 + sovComputeagent(uint64(m.IovOffloadWeight))
1183 }
1184 if m.QueuePairsRequested != 0 {
1185 n += 1 + sovComputeagent(uint64(m.QueuePairsRequested))
1186 }
1187 if m.InterruptModeration != 0 {
1188 n += 1 + sovComputeagent(uint64(m.InterruptModeration))
1189 }
1190 if m.XXX_unrecognized != nil {
1191 n += len(m.XXX_unrecognized)
1192 }
1193 return n
1194 }
1195
1196 func sovComputeagent(x uint64) (n int) {
1197 return (math_bits.Len64(x|1) + 6) / 7
1198 }
1199 func sozComputeagent(x uint64) (n int) {
1200 return sovComputeagent(uint64((x << 1) ^ uint64((int64(x) >> 63))))
1201 }
1202 func (this *AssignPCIInternalRequest) String() string {
1203 if this == nil {
1204 return "nil"
1205 }
1206 s := strings.Join([]string{`&AssignPCIInternalRequest{`,
1207 `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
1208 `DeviceID:` + fmt.Sprintf("%v", this.DeviceID) + `,`,
1209 `VirtualFunctionIndex:` + fmt.Sprintf("%v", this.VirtualFunctionIndex) + `,`,
1210 `NicID:` + fmt.Sprintf("%v", this.NicID) + `,`,
1211 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
1212 `}`,
1213 }, "")
1214 return s
1215 }
1216 func (this *AssignPCIInternalResponse) String() string {
1217 if this == nil {
1218 return "nil"
1219 }
1220 s := strings.Join([]string{`&AssignPCIInternalResponse{`,
1221 `ID:` + fmt.Sprintf("%v", this.ID) + `,`,
1222 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
1223 `}`,
1224 }, "")
1225 return s
1226 }
1227 func (this *RemovePCIInternalRequest) String() string {
1228 if this == nil {
1229 return "nil"
1230 }
1231 s := strings.Join([]string{`&RemovePCIInternalRequest{`,
1232 `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
1233 `DeviceID:` + fmt.Sprintf("%v", this.DeviceID) + `,`,
1234 `VirtualFunctionIndex:` + fmt.Sprintf("%v", this.VirtualFunctionIndex) + `,`,
1235 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
1236 `}`,
1237 }, "")
1238 return s
1239 }
1240 func (this *RemovePCIInternalResponse) String() string {
1241 if this == nil {
1242 return "nil"
1243 }
1244 s := strings.Join([]string{`&RemovePCIInternalResponse{`,
1245 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
1246 `}`,
1247 }, "")
1248 return s
1249 }
1250 func (this *AddNICInternalRequest) String() string {
1251 if this == nil {
1252 return "nil"
1253 }
1254 s := strings.Join([]string{`&AddNICInternalRequest{`,
1255 `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
1256 `NicID:` + fmt.Sprintf("%v", this.NicID) + `,`,
1257 `Endpoint:` + strings.Replace(fmt.Sprintf("%v", this.Endpoint), "Any", "types.Any", 1) + `,`,
1258 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
1259 `}`,
1260 }, "")
1261 return s
1262 }
1263 func (this *AddNICInternalResponse) String() string {
1264 if this == nil {
1265 return "nil"
1266 }
1267 s := strings.Join([]string{`&AddNICInternalResponse{`,
1268 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
1269 `}`,
1270 }, "")
1271 return s
1272 }
1273 func (this *ModifyNICInternalRequest) String() string {
1274 if this == nil {
1275 return "nil"
1276 }
1277 s := strings.Join([]string{`&ModifyNICInternalRequest{`,
1278 `NicID:` + fmt.Sprintf("%v", this.NicID) + `,`,
1279 `Endpoint:` + strings.Replace(fmt.Sprintf("%v", this.Endpoint), "Any", "types.Any", 1) + `,`,
1280 `IovPolicySettings:` + strings.Replace(this.IovPolicySettings.String(), "IovSettings", "IovSettings", 1) + `,`,
1281 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
1282 `}`,
1283 }, "")
1284 return s
1285 }
1286 func (this *ModifyNICInternalResponse) String() string {
1287 if this == nil {
1288 return "nil"
1289 }
1290 s := strings.Join([]string{`&ModifyNICInternalResponse{`,
1291 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
1292 `}`,
1293 }, "")
1294 return s
1295 }
1296 func (this *DeleteNICInternalRequest) String() string {
1297 if this == nil {
1298 return "nil"
1299 }
1300 s := strings.Join([]string{`&DeleteNICInternalRequest{`,
1301 `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
1302 `NicID:` + fmt.Sprintf("%v", this.NicID) + `,`,
1303 `Endpoint:` + strings.Replace(fmt.Sprintf("%v", this.Endpoint), "Any", "types.Any", 1) + `,`,
1304 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
1305 `}`,
1306 }, "")
1307 return s
1308 }
1309 func (this *DeleteNICInternalResponse) String() string {
1310 if this == nil {
1311 return "nil"
1312 }
1313 s := strings.Join([]string{`&DeleteNICInternalResponse{`,
1314 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
1315 `}`,
1316 }, "")
1317 return s
1318 }
1319 func (this *IovSettings) String() string {
1320 if this == nil {
1321 return "nil"
1322 }
1323 s := strings.Join([]string{`&IovSettings{`,
1324 `IovOffloadWeight:` + fmt.Sprintf("%v", this.IovOffloadWeight) + `,`,
1325 `QueuePairsRequested:` + fmt.Sprintf("%v", this.QueuePairsRequested) + `,`,
1326 `InterruptModeration:` + fmt.Sprintf("%v", this.InterruptModeration) + `,`,
1327 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
1328 `}`,
1329 }, "")
1330 return s
1331 }
1332 func valueToStringComputeagent(v interface{}) string {
1333 rv := reflect.ValueOf(v)
1334 if rv.IsNil() {
1335 return "nil"
1336 }
1337 pv := reflect.Indirect(rv).Interface()
1338 return fmt.Sprintf("*%v", pv)
1339 }
1340
1341 type ComputeAgentService interface {
1342 AddNIC(ctx context.Context, req *AddNICInternalRequest) (*AddNICInternalResponse, error)
1343 ModifyNIC(ctx context.Context, req *ModifyNICInternalRequest) (*ModifyNICInternalResponse, error)
1344 DeleteNIC(ctx context.Context, req *DeleteNICInternalRequest) (*DeleteNICInternalResponse, error)
1345 AssignPCI(ctx context.Context, req *AssignPCIInternalRequest) (*AssignPCIInternalResponse, error)
1346 RemovePCI(ctx context.Context, req *RemovePCIInternalRequest) (*RemovePCIInternalResponse, error)
1347 }
1348
1349 func RegisterComputeAgentService(srv *github_com_containerd_ttrpc.Server, svc ComputeAgentService) {
1350 srv.Register("ComputeAgent", map[string]github_com_containerd_ttrpc.Method{
1351 "AddNIC": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
1352 var req AddNICInternalRequest
1353 if err := unmarshal(&req); err != nil {
1354 return nil, err
1355 }
1356 return svc.AddNIC(ctx, &req)
1357 },
1358 "ModifyNIC": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
1359 var req ModifyNICInternalRequest
1360 if err := unmarshal(&req); err != nil {
1361 return nil, err
1362 }
1363 return svc.ModifyNIC(ctx, &req)
1364 },
1365 "DeleteNIC": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
1366 var req DeleteNICInternalRequest
1367 if err := unmarshal(&req); err != nil {
1368 return nil, err
1369 }
1370 return svc.DeleteNIC(ctx, &req)
1371 },
1372 "AssignPCI": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
1373 var req AssignPCIInternalRequest
1374 if err := unmarshal(&req); err != nil {
1375 return nil, err
1376 }
1377 return svc.AssignPCI(ctx, &req)
1378 },
1379 "RemovePCI": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
1380 var req RemovePCIInternalRequest
1381 if err := unmarshal(&req); err != nil {
1382 return nil, err
1383 }
1384 return svc.RemovePCI(ctx, &req)
1385 },
1386 })
1387 }
1388
1389 type computeAgentClient struct {
1390 client *github_com_containerd_ttrpc.Client
1391 }
1392
1393 func NewComputeAgentClient(client *github_com_containerd_ttrpc.Client) ComputeAgentService {
1394 return &computeAgentClient{
1395 client: client,
1396 }
1397 }
1398
1399 func (c *computeAgentClient) AddNIC(ctx context.Context, req *AddNICInternalRequest) (*AddNICInternalResponse, error) {
1400 var resp AddNICInternalResponse
1401 if err := c.client.Call(ctx, "ComputeAgent", "AddNIC", req, &resp); err != nil {
1402 return nil, err
1403 }
1404 return &resp, nil
1405 }
1406
1407 func (c *computeAgentClient) ModifyNIC(ctx context.Context, req *ModifyNICInternalRequest) (*ModifyNICInternalResponse, error) {
1408 var resp ModifyNICInternalResponse
1409 if err := c.client.Call(ctx, "ComputeAgent", "ModifyNIC", req, &resp); err != nil {
1410 return nil, err
1411 }
1412 return &resp, nil
1413 }
1414
1415 func (c *computeAgentClient) DeleteNIC(ctx context.Context, req *DeleteNICInternalRequest) (*DeleteNICInternalResponse, error) {
1416 var resp DeleteNICInternalResponse
1417 if err := c.client.Call(ctx, "ComputeAgent", "DeleteNIC", req, &resp); err != nil {
1418 return nil, err
1419 }
1420 return &resp, nil
1421 }
1422
1423 func (c *computeAgentClient) AssignPCI(ctx context.Context, req *AssignPCIInternalRequest) (*AssignPCIInternalResponse, error) {
1424 var resp AssignPCIInternalResponse
1425 if err := c.client.Call(ctx, "ComputeAgent", "AssignPCI", req, &resp); err != nil {
1426 return nil, err
1427 }
1428 return &resp, nil
1429 }
1430
1431 func (c *computeAgentClient) RemovePCI(ctx context.Context, req *RemovePCIInternalRequest) (*RemovePCIInternalResponse, error) {
1432 var resp RemovePCIInternalResponse
1433 if err := c.client.Call(ctx, "ComputeAgent", "RemovePCI", req, &resp); err != nil {
1434 return nil, err
1435 }
1436 return &resp, nil
1437 }
1438 func (m *AssignPCIInternalRequest) Unmarshal(dAtA []byte) error {
1439 l := len(dAtA)
1440 iNdEx := 0
1441 for iNdEx < l {
1442 preIndex := iNdEx
1443 var wire uint64
1444 for shift := uint(0); ; shift += 7 {
1445 if shift >= 64 {
1446 return ErrIntOverflowComputeagent
1447 }
1448 if iNdEx >= l {
1449 return io.ErrUnexpectedEOF
1450 }
1451 b := dAtA[iNdEx]
1452 iNdEx++
1453 wire |= uint64(b&0x7F) << shift
1454 if b < 0x80 {
1455 break
1456 }
1457 }
1458 fieldNum := int32(wire >> 3)
1459 wireType := int(wire & 0x7)
1460 if wireType == 4 {
1461 return fmt.Errorf("proto: AssignPCIInternalRequest: wiretype end group for non-group")
1462 }
1463 if fieldNum <= 0 {
1464 return fmt.Errorf("proto: AssignPCIInternalRequest: illegal tag %d (wire type %d)", fieldNum, wire)
1465 }
1466 switch fieldNum {
1467 case 1:
1468 if wireType != 2 {
1469 return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
1470 }
1471 var stringLen uint64
1472 for shift := uint(0); ; shift += 7 {
1473 if shift >= 64 {
1474 return ErrIntOverflowComputeagent
1475 }
1476 if iNdEx >= l {
1477 return io.ErrUnexpectedEOF
1478 }
1479 b := dAtA[iNdEx]
1480 iNdEx++
1481 stringLen |= uint64(b&0x7F) << shift
1482 if b < 0x80 {
1483 break
1484 }
1485 }
1486 intStringLen := int(stringLen)
1487 if intStringLen < 0 {
1488 return ErrInvalidLengthComputeagent
1489 }
1490 postIndex := iNdEx + intStringLen
1491 if postIndex < 0 {
1492 return ErrInvalidLengthComputeagent
1493 }
1494 if postIndex > l {
1495 return io.ErrUnexpectedEOF
1496 }
1497 m.ContainerID = string(dAtA[iNdEx:postIndex])
1498 iNdEx = postIndex
1499 case 2:
1500 if wireType != 2 {
1501 return fmt.Errorf("proto: wrong wireType = %d for field DeviceID", wireType)
1502 }
1503 var stringLen uint64
1504 for shift := uint(0); ; shift += 7 {
1505 if shift >= 64 {
1506 return ErrIntOverflowComputeagent
1507 }
1508 if iNdEx >= l {
1509 return io.ErrUnexpectedEOF
1510 }
1511 b := dAtA[iNdEx]
1512 iNdEx++
1513 stringLen |= uint64(b&0x7F) << shift
1514 if b < 0x80 {
1515 break
1516 }
1517 }
1518 intStringLen := int(stringLen)
1519 if intStringLen < 0 {
1520 return ErrInvalidLengthComputeagent
1521 }
1522 postIndex := iNdEx + intStringLen
1523 if postIndex < 0 {
1524 return ErrInvalidLengthComputeagent
1525 }
1526 if postIndex > l {
1527 return io.ErrUnexpectedEOF
1528 }
1529 m.DeviceID = string(dAtA[iNdEx:postIndex])
1530 iNdEx = postIndex
1531 case 3:
1532 if wireType != 0 {
1533 return fmt.Errorf("proto: wrong wireType = %d for field VirtualFunctionIndex", wireType)
1534 }
1535 m.VirtualFunctionIndex = 0
1536 for shift := uint(0); ; shift += 7 {
1537 if shift >= 64 {
1538 return ErrIntOverflowComputeagent
1539 }
1540 if iNdEx >= l {
1541 return io.ErrUnexpectedEOF
1542 }
1543 b := dAtA[iNdEx]
1544 iNdEx++
1545 m.VirtualFunctionIndex |= uint32(b&0x7F) << shift
1546 if b < 0x80 {
1547 break
1548 }
1549 }
1550 case 4:
1551 if wireType != 2 {
1552 return fmt.Errorf("proto: wrong wireType = %d for field NicID", wireType)
1553 }
1554 var stringLen uint64
1555 for shift := uint(0); ; shift += 7 {
1556 if shift >= 64 {
1557 return ErrIntOverflowComputeagent
1558 }
1559 if iNdEx >= l {
1560 return io.ErrUnexpectedEOF
1561 }
1562 b := dAtA[iNdEx]
1563 iNdEx++
1564 stringLen |= uint64(b&0x7F) << shift
1565 if b < 0x80 {
1566 break
1567 }
1568 }
1569 intStringLen := int(stringLen)
1570 if intStringLen < 0 {
1571 return ErrInvalidLengthComputeagent
1572 }
1573 postIndex := iNdEx + intStringLen
1574 if postIndex < 0 {
1575 return ErrInvalidLengthComputeagent
1576 }
1577 if postIndex > l {
1578 return io.ErrUnexpectedEOF
1579 }
1580 m.NicID = string(dAtA[iNdEx:postIndex])
1581 iNdEx = postIndex
1582 default:
1583 iNdEx = preIndex
1584 skippy, err := skipComputeagent(dAtA[iNdEx:])
1585 if err != nil {
1586 return err
1587 }
1588 if (skippy < 0) || (iNdEx+skippy) < 0 {
1589 return ErrInvalidLengthComputeagent
1590 }
1591 if (iNdEx + skippy) > l {
1592 return io.ErrUnexpectedEOF
1593 }
1594 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
1595 iNdEx += skippy
1596 }
1597 }
1598
1599 if iNdEx > l {
1600 return io.ErrUnexpectedEOF
1601 }
1602 return nil
1603 }
1604 func (m *AssignPCIInternalResponse) Unmarshal(dAtA []byte) error {
1605 l := len(dAtA)
1606 iNdEx := 0
1607 for iNdEx < l {
1608 preIndex := iNdEx
1609 var wire uint64
1610 for shift := uint(0); ; shift += 7 {
1611 if shift >= 64 {
1612 return ErrIntOverflowComputeagent
1613 }
1614 if iNdEx >= l {
1615 return io.ErrUnexpectedEOF
1616 }
1617 b := dAtA[iNdEx]
1618 iNdEx++
1619 wire |= uint64(b&0x7F) << shift
1620 if b < 0x80 {
1621 break
1622 }
1623 }
1624 fieldNum := int32(wire >> 3)
1625 wireType := int(wire & 0x7)
1626 if wireType == 4 {
1627 return fmt.Errorf("proto: AssignPCIInternalResponse: wiretype end group for non-group")
1628 }
1629 if fieldNum <= 0 {
1630 return fmt.Errorf("proto: AssignPCIInternalResponse: illegal tag %d (wire type %d)", fieldNum, wire)
1631 }
1632 switch fieldNum {
1633 case 1:
1634 if wireType != 2 {
1635 return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
1636 }
1637 var stringLen uint64
1638 for shift := uint(0); ; shift += 7 {
1639 if shift >= 64 {
1640 return ErrIntOverflowComputeagent
1641 }
1642 if iNdEx >= l {
1643 return io.ErrUnexpectedEOF
1644 }
1645 b := dAtA[iNdEx]
1646 iNdEx++
1647 stringLen |= uint64(b&0x7F) << shift
1648 if b < 0x80 {
1649 break
1650 }
1651 }
1652 intStringLen := int(stringLen)
1653 if intStringLen < 0 {
1654 return ErrInvalidLengthComputeagent
1655 }
1656 postIndex := iNdEx + intStringLen
1657 if postIndex < 0 {
1658 return ErrInvalidLengthComputeagent
1659 }
1660 if postIndex > l {
1661 return io.ErrUnexpectedEOF
1662 }
1663 m.ID = string(dAtA[iNdEx:postIndex])
1664 iNdEx = postIndex
1665 default:
1666 iNdEx = preIndex
1667 skippy, err := skipComputeagent(dAtA[iNdEx:])
1668 if err != nil {
1669 return err
1670 }
1671 if (skippy < 0) || (iNdEx+skippy) < 0 {
1672 return ErrInvalidLengthComputeagent
1673 }
1674 if (iNdEx + skippy) > l {
1675 return io.ErrUnexpectedEOF
1676 }
1677 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
1678 iNdEx += skippy
1679 }
1680 }
1681
1682 if iNdEx > l {
1683 return io.ErrUnexpectedEOF
1684 }
1685 return nil
1686 }
1687 func (m *RemovePCIInternalRequest) Unmarshal(dAtA []byte) error {
1688 l := len(dAtA)
1689 iNdEx := 0
1690 for iNdEx < l {
1691 preIndex := iNdEx
1692 var wire uint64
1693 for shift := uint(0); ; shift += 7 {
1694 if shift >= 64 {
1695 return ErrIntOverflowComputeagent
1696 }
1697 if iNdEx >= l {
1698 return io.ErrUnexpectedEOF
1699 }
1700 b := dAtA[iNdEx]
1701 iNdEx++
1702 wire |= uint64(b&0x7F) << shift
1703 if b < 0x80 {
1704 break
1705 }
1706 }
1707 fieldNum := int32(wire >> 3)
1708 wireType := int(wire & 0x7)
1709 if wireType == 4 {
1710 return fmt.Errorf("proto: RemovePCIInternalRequest: wiretype end group for non-group")
1711 }
1712 if fieldNum <= 0 {
1713 return fmt.Errorf("proto: RemovePCIInternalRequest: illegal tag %d (wire type %d)", fieldNum, wire)
1714 }
1715 switch fieldNum {
1716 case 1:
1717 if wireType != 2 {
1718 return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
1719 }
1720 var stringLen uint64
1721 for shift := uint(0); ; shift += 7 {
1722 if shift >= 64 {
1723 return ErrIntOverflowComputeagent
1724 }
1725 if iNdEx >= l {
1726 return io.ErrUnexpectedEOF
1727 }
1728 b := dAtA[iNdEx]
1729 iNdEx++
1730 stringLen |= uint64(b&0x7F) << shift
1731 if b < 0x80 {
1732 break
1733 }
1734 }
1735 intStringLen := int(stringLen)
1736 if intStringLen < 0 {
1737 return ErrInvalidLengthComputeagent
1738 }
1739 postIndex := iNdEx + intStringLen
1740 if postIndex < 0 {
1741 return ErrInvalidLengthComputeagent
1742 }
1743 if postIndex > l {
1744 return io.ErrUnexpectedEOF
1745 }
1746 m.ContainerID = string(dAtA[iNdEx:postIndex])
1747 iNdEx = postIndex
1748 case 2:
1749 if wireType != 2 {
1750 return fmt.Errorf("proto: wrong wireType = %d for field DeviceID", wireType)
1751 }
1752 var stringLen uint64
1753 for shift := uint(0); ; shift += 7 {
1754 if shift >= 64 {
1755 return ErrIntOverflowComputeagent
1756 }
1757 if iNdEx >= l {
1758 return io.ErrUnexpectedEOF
1759 }
1760 b := dAtA[iNdEx]
1761 iNdEx++
1762 stringLen |= uint64(b&0x7F) << shift
1763 if b < 0x80 {
1764 break
1765 }
1766 }
1767 intStringLen := int(stringLen)
1768 if intStringLen < 0 {
1769 return ErrInvalidLengthComputeagent
1770 }
1771 postIndex := iNdEx + intStringLen
1772 if postIndex < 0 {
1773 return ErrInvalidLengthComputeagent
1774 }
1775 if postIndex > l {
1776 return io.ErrUnexpectedEOF
1777 }
1778 m.DeviceID = string(dAtA[iNdEx:postIndex])
1779 iNdEx = postIndex
1780 case 3:
1781 if wireType != 0 {
1782 return fmt.Errorf("proto: wrong wireType = %d for field VirtualFunctionIndex", wireType)
1783 }
1784 m.VirtualFunctionIndex = 0
1785 for shift := uint(0); ; shift += 7 {
1786 if shift >= 64 {
1787 return ErrIntOverflowComputeagent
1788 }
1789 if iNdEx >= l {
1790 return io.ErrUnexpectedEOF
1791 }
1792 b := dAtA[iNdEx]
1793 iNdEx++
1794 m.VirtualFunctionIndex |= uint32(b&0x7F) << shift
1795 if b < 0x80 {
1796 break
1797 }
1798 }
1799 default:
1800 iNdEx = preIndex
1801 skippy, err := skipComputeagent(dAtA[iNdEx:])
1802 if err != nil {
1803 return err
1804 }
1805 if (skippy < 0) || (iNdEx+skippy) < 0 {
1806 return ErrInvalidLengthComputeagent
1807 }
1808 if (iNdEx + skippy) > l {
1809 return io.ErrUnexpectedEOF
1810 }
1811 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
1812 iNdEx += skippy
1813 }
1814 }
1815
1816 if iNdEx > l {
1817 return io.ErrUnexpectedEOF
1818 }
1819 return nil
1820 }
1821 func (m *RemovePCIInternalResponse) Unmarshal(dAtA []byte) error {
1822 l := len(dAtA)
1823 iNdEx := 0
1824 for iNdEx < l {
1825 preIndex := iNdEx
1826 var wire uint64
1827 for shift := uint(0); ; shift += 7 {
1828 if shift >= 64 {
1829 return ErrIntOverflowComputeagent
1830 }
1831 if iNdEx >= l {
1832 return io.ErrUnexpectedEOF
1833 }
1834 b := dAtA[iNdEx]
1835 iNdEx++
1836 wire |= uint64(b&0x7F) << shift
1837 if b < 0x80 {
1838 break
1839 }
1840 }
1841 fieldNum := int32(wire >> 3)
1842 wireType := int(wire & 0x7)
1843 if wireType == 4 {
1844 return fmt.Errorf("proto: RemovePCIInternalResponse: wiretype end group for non-group")
1845 }
1846 if fieldNum <= 0 {
1847 return fmt.Errorf("proto: RemovePCIInternalResponse: illegal tag %d (wire type %d)", fieldNum, wire)
1848 }
1849 switch fieldNum {
1850 default:
1851 iNdEx = preIndex
1852 skippy, err := skipComputeagent(dAtA[iNdEx:])
1853 if err != nil {
1854 return err
1855 }
1856 if (skippy < 0) || (iNdEx+skippy) < 0 {
1857 return ErrInvalidLengthComputeagent
1858 }
1859 if (iNdEx + skippy) > l {
1860 return io.ErrUnexpectedEOF
1861 }
1862 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
1863 iNdEx += skippy
1864 }
1865 }
1866
1867 if iNdEx > l {
1868 return io.ErrUnexpectedEOF
1869 }
1870 return nil
1871 }
1872 func (m *AddNICInternalRequest) Unmarshal(dAtA []byte) error {
1873 l := len(dAtA)
1874 iNdEx := 0
1875 for iNdEx < l {
1876 preIndex := iNdEx
1877 var wire uint64
1878 for shift := uint(0); ; shift += 7 {
1879 if shift >= 64 {
1880 return ErrIntOverflowComputeagent
1881 }
1882 if iNdEx >= l {
1883 return io.ErrUnexpectedEOF
1884 }
1885 b := dAtA[iNdEx]
1886 iNdEx++
1887 wire |= uint64(b&0x7F) << shift
1888 if b < 0x80 {
1889 break
1890 }
1891 }
1892 fieldNum := int32(wire >> 3)
1893 wireType := int(wire & 0x7)
1894 if wireType == 4 {
1895 return fmt.Errorf("proto: AddNICInternalRequest: wiretype end group for non-group")
1896 }
1897 if fieldNum <= 0 {
1898 return fmt.Errorf("proto: AddNICInternalRequest: illegal tag %d (wire type %d)", fieldNum, wire)
1899 }
1900 switch fieldNum {
1901 case 1:
1902 if wireType != 2 {
1903 return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
1904 }
1905 var stringLen uint64
1906 for shift := uint(0); ; shift += 7 {
1907 if shift >= 64 {
1908 return ErrIntOverflowComputeagent
1909 }
1910 if iNdEx >= l {
1911 return io.ErrUnexpectedEOF
1912 }
1913 b := dAtA[iNdEx]
1914 iNdEx++
1915 stringLen |= uint64(b&0x7F) << shift
1916 if b < 0x80 {
1917 break
1918 }
1919 }
1920 intStringLen := int(stringLen)
1921 if intStringLen < 0 {
1922 return ErrInvalidLengthComputeagent
1923 }
1924 postIndex := iNdEx + intStringLen
1925 if postIndex < 0 {
1926 return ErrInvalidLengthComputeagent
1927 }
1928 if postIndex > l {
1929 return io.ErrUnexpectedEOF
1930 }
1931 m.ContainerID = string(dAtA[iNdEx:postIndex])
1932 iNdEx = postIndex
1933 case 2:
1934 if wireType != 2 {
1935 return fmt.Errorf("proto: wrong wireType = %d for field NicID", wireType)
1936 }
1937 var stringLen uint64
1938 for shift := uint(0); ; shift += 7 {
1939 if shift >= 64 {
1940 return ErrIntOverflowComputeagent
1941 }
1942 if iNdEx >= l {
1943 return io.ErrUnexpectedEOF
1944 }
1945 b := dAtA[iNdEx]
1946 iNdEx++
1947 stringLen |= uint64(b&0x7F) << shift
1948 if b < 0x80 {
1949 break
1950 }
1951 }
1952 intStringLen := int(stringLen)
1953 if intStringLen < 0 {
1954 return ErrInvalidLengthComputeagent
1955 }
1956 postIndex := iNdEx + intStringLen
1957 if postIndex < 0 {
1958 return ErrInvalidLengthComputeagent
1959 }
1960 if postIndex > l {
1961 return io.ErrUnexpectedEOF
1962 }
1963 m.NicID = string(dAtA[iNdEx:postIndex])
1964 iNdEx = postIndex
1965 case 3:
1966 if wireType != 2 {
1967 return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType)
1968 }
1969 var msglen int
1970 for shift := uint(0); ; shift += 7 {
1971 if shift >= 64 {
1972 return ErrIntOverflowComputeagent
1973 }
1974 if iNdEx >= l {
1975 return io.ErrUnexpectedEOF
1976 }
1977 b := dAtA[iNdEx]
1978 iNdEx++
1979 msglen |= int(b&0x7F) << shift
1980 if b < 0x80 {
1981 break
1982 }
1983 }
1984 if msglen < 0 {
1985 return ErrInvalidLengthComputeagent
1986 }
1987 postIndex := iNdEx + msglen
1988 if postIndex < 0 {
1989 return ErrInvalidLengthComputeagent
1990 }
1991 if postIndex > l {
1992 return io.ErrUnexpectedEOF
1993 }
1994 if m.Endpoint == nil {
1995 m.Endpoint = &types.Any{}
1996 }
1997 if err := m.Endpoint.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1998 return err
1999 }
2000 iNdEx = postIndex
2001 default:
2002 iNdEx = preIndex
2003 skippy, err := skipComputeagent(dAtA[iNdEx:])
2004 if err != nil {
2005 return err
2006 }
2007 if (skippy < 0) || (iNdEx+skippy) < 0 {
2008 return ErrInvalidLengthComputeagent
2009 }
2010 if (iNdEx + skippy) > l {
2011 return io.ErrUnexpectedEOF
2012 }
2013 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
2014 iNdEx += skippy
2015 }
2016 }
2017
2018 if iNdEx > l {
2019 return io.ErrUnexpectedEOF
2020 }
2021 return nil
2022 }
2023 func (m *AddNICInternalResponse) Unmarshal(dAtA []byte) error {
2024 l := len(dAtA)
2025 iNdEx := 0
2026 for iNdEx < l {
2027 preIndex := iNdEx
2028 var wire uint64
2029 for shift := uint(0); ; shift += 7 {
2030 if shift >= 64 {
2031 return ErrIntOverflowComputeagent
2032 }
2033 if iNdEx >= l {
2034 return io.ErrUnexpectedEOF
2035 }
2036 b := dAtA[iNdEx]
2037 iNdEx++
2038 wire |= uint64(b&0x7F) << shift
2039 if b < 0x80 {
2040 break
2041 }
2042 }
2043 fieldNum := int32(wire >> 3)
2044 wireType := int(wire & 0x7)
2045 if wireType == 4 {
2046 return fmt.Errorf("proto: AddNICInternalResponse: wiretype end group for non-group")
2047 }
2048 if fieldNum <= 0 {
2049 return fmt.Errorf("proto: AddNICInternalResponse: illegal tag %d (wire type %d)", fieldNum, wire)
2050 }
2051 switch fieldNum {
2052 default:
2053 iNdEx = preIndex
2054 skippy, err := skipComputeagent(dAtA[iNdEx:])
2055 if err != nil {
2056 return err
2057 }
2058 if (skippy < 0) || (iNdEx+skippy) < 0 {
2059 return ErrInvalidLengthComputeagent
2060 }
2061 if (iNdEx + skippy) > l {
2062 return io.ErrUnexpectedEOF
2063 }
2064 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
2065 iNdEx += skippy
2066 }
2067 }
2068
2069 if iNdEx > l {
2070 return io.ErrUnexpectedEOF
2071 }
2072 return nil
2073 }
2074 func (m *ModifyNICInternalRequest) Unmarshal(dAtA []byte) error {
2075 l := len(dAtA)
2076 iNdEx := 0
2077 for iNdEx < l {
2078 preIndex := iNdEx
2079 var wire uint64
2080 for shift := uint(0); ; shift += 7 {
2081 if shift >= 64 {
2082 return ErrIntOverflowComputeagent
2083 }
2084 if iNdEx >= l {
2085 return io.ErrUnexpectedEOF
2086 }
2087 b := dAtA[iNdEx]
2088 iNdEx++
2089 wire |= uint64(b&0x7F) << shift
2090 if b < 0x80 {
2091 break
2092 }
2093 }
2094 fieldNum := int32(wire >> 3)
2095 wireType := int(wire & 0x7)
2096 if wireType == 4 {
2097 return fmt.Errorf("proto: ModifyNICInternalRequest: wiretype end group for non-group")
2098 }
2099 if fieldNum <= 0 {
2100 return fmt.Errorf("proto: ModifyNICInternalRequest: illegal tag %d (wire type %d)", fieldNum, wire)
2101 }
2102 switch fieldNum {
2103 case 1:
2104 if wireType != 2 {
2105 return fmt.Errorf("proto: wrong wireType = %d for field NicID", wireType)
2106 }
2107 var stringLen uint64
2108 for shift := uint(0); ; shift += 7 {
2109 if shift >= 64 {
2110 return ErrIntOverflowComputeagent
2111 }
2112 if iNdEx >= l {
2113 return io.ErrUnexpectedEOF
2114 }
2115 b := dAtA[iNdEx]
2116 iNdEx++
2117 stringLen |= uint64(b&0x7F) << shift
2118 if b < 0x80 {
2119 break
2120 }
2121 }
2122 intStringLen := int(stringLen)
2123 if intStringLen < 0 {
2124 return ErrInvalidLengthComputeagent
2125 }
2126 postIndex := iNdEx + intStringLen
2127 if postIndex < 0 {
2128 return ErrInvalidLengthComputeagent
2129 }
2130 if postIndex > l {
2131 return io.ErrUnexpectedEOF
2132 }
2133 m.NicID = string(dAtA[iNdEx:postIndex])
2134 iNdEx = postIndex
2135 case 2:
2136 if wireType != 2 {
2137 return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType)
2138 }
2139 var msglen int
2140 for shift := uint(0); ; shift += 7 {
2141 if shift >= 64 {
2142 return ErrIntOverflowComputeagent
2143 }
2144 if iNdEx >= l {
2145 return io.ErrUnexpectedEOF
2146 }
2147 b := dAtA[iNdEx]
2148 iNdEx++
2149 msglen |= int(b&0x7F) << shift
2150 if b < 0x80 {
2151 break
2152 }
2153 }
2154 if msglen < 0 {
2155 return ErrInvalidLengthComputeagent
2156 }
2157 postIndex := iNdEx + msglen
2158 if postIndex < 0 {
2159 return ErrInvalidLengthComputeagent
2160 }
2161 if postIndex > l {
2162 return io.ErrUnexpectedEOF
2163 }
2164 if m.Endpoint == nil {
2165 m.Endpoint = &types.Any{}
2166 }
2167 if err := m.Endpoint.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2168 return err
2169 }
2170 iNdEx = postIndex
2171 case 3:
2172 if wireType != 2 {
2173 return fmt.Errorf("proto: wrong wireType = %d for field IovPolicySettings", wireType)
2174 }
2175 var msglen int
2176 for shift := uint(0); ; shift += 7 {
2177 if shift >= 64 {
2178 return ErrIntOverflowComputeagent
2179 }
2180 if iNdEx >= l {
2181 return io.ErrUnexpectedEOF
2182 }
2183 b := dAtA[iNdEx]
2184 iNdEx++
2185 msglen |= int(b&0x7F) << shift
2186 if b < 0x80 {
2187 break
2188 }
2189 }
2190 if msglen < 0 {
2191 return ErrInvalidLengthComputeagent
2192 }
2193 postIndex := iNdEx + msglen
2194 if postIndex < 0 {
2195 return ErrInvalidLengthComputeagent
2196 }
2197 if postIndex > l {
2198 return io.ErrUnexpectedEOF
2199 }
2200 if m.IovPolicySettings == nil {
2201 m.IovPolicySettings = &IovSettings{}
2202 }
2203 if err := m.IovPolicySettings.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2204 return err
2205 }
2206 iNdEx = postIndex
2207 default:
2208 iNdEx = preIndex
2209 skippy, err := skipComputeagent(dAtA[iNdEx:])
2210 if err != nil {
2211 return err
2212 }
2213 if (skippy < 0) || (iNdEx+skippy) < 0 {
2214 return ErrInvalidLengthComputeagent
2215 }
2216 if (iNdEx + skippy) > l {
2217 return io.ErrUnexpectedEOF
2218 }
2219 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
2220 iNdEx += skippy
2221 }
2222 }
2223
2224 if iNdEx > l {
2225 return io.ErrUnexpectedEOF
2226 }
2227 return nil
2228 }
2229 func (m *ModifyNICInternalResponse) Unmarshal(dAtA []byte) error {
2230 l := len(dAtA)
2231 iNdEx := 0
2232 for iNdEx < l {
2233 preIndex := iNdEx
2234 var wire uint64
2235 for shift := uint(0); ; shift += 7 {
2236 if shift >= 64 {
2237 return ErrIntOverflowComputeagent
2238 }
2239 if iNdEx >= l {
2240 return io.ErrUnexpectedEOF
2241 }
2242 b := dAtA[iNdEx]
2243 iNdEx++
2244 wire |= uint64(b&0x7F) << shift
2245 if b < 0x80 {
2246 break
2247 }
2248 }
2249 fieldNum := int32(wire >> 3)
2250 wireType := int(wire & 0x7)
2251 if wireType == 4 {
2252 return fmt.Errorf("proto: ModifyNICInternalResponse: wiretype end group for non-group")
2253 }
2254 if fieldNum <= 0 {
2255 return fmt.Errorf("proto: ModifyNICInternalResponse: illegal tag %d (wire type %d)", fieldNum, wire)
2256 }
2257 switch fieldNum {
2258 default:
2259 iNdEx = preIndex
2260 skippy, err := skipComputeagent(dAtA[iNdEx:])
2261 if err != nil {
2262 return err
2263 }
2264 if (skippy < 0) || (iNdEx+skippy) < 0 {
2265 return ErrInvalidLengthComputeagent
2266 }
2267 if (iNdEx + skippy) > l {
2268 return io.ErrUnexpectedEOF
2269 }
2270 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
2271 iNdEx += skippy
2272 }
2273 }
2274
2275 if iNdEx > l {
2276 return io.ErrUnexpectedEOF
2277 }
2278 return nil
2279 }
2280 func (m *DeleteNICInternalRequest) Unmarshal(dAtA []byte) error {
2281 l := len(dAtA)
2282 iNdEx := 0
2283 for iNdEx < l {
2284 preIndex := iNdEx
2285 var wire uint64
2286 for shift := uint(0); ; shift += 7 {
2287 if shift >= 64 {
2288 return ErrIntOverflowComputeagent
2289 }
2290 if iNdEx >= l {
2291 return io.ErrUnexpectedEOF
2292 }
2293 b := dAtA[iNdEx]
2294 iNdEx++
2295 wire |= uint64(b&0x7F) << shift
2296 if b < 0x80 {
2297 break
2298 }
2299 }
2300 fieldNum := int32(wire >> 3)
2301 wireType := int(wire & 0x7)
2302 if wireType == 4 {
2303 return fmt.Errorf("proto: DeleteNICInternalRequest: wiretype end group for non-group")
2304 }
2305 if fieldNum <= 0 {
2306 return fmt.Errorf("proto: DeleteNICInternalRequest: illegal tag %d (wire type %d)", fieldNum, wire)
2307 }
2308 switch fieldNum {
2309 case 1:
2310 if wireType != 2 {
2311 return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
2312 }
2313 var stringLen uint64
2314 for shift := uint(0); ; shift += 7 {
2315 if shift >= 64 {
2316 return ErrIntOverflowComputeagent
2317 }
2318 if iNdEx >= l {
2319 return io.ErrUnexpectedEOF
2320 }
2321 b := dAtA[iNdEx]
2322 iNdEx++
2323 stringLen |= uint64(b&0x7F) << shift
2324 if b < 0x80 {
2325 break
2326 }
2327 }
2328 intStringLen := int(stringLen)
2329 if intStringLen < 0 {
2330 return ErrInvalidLengthComputeagent
2331 }
2332 postIndex := iNdEx + intStringLen
2333 if postIndex < 0 {
2334 return ErrInvalidLengthComputeagent
2335 }
2336 if postIndex > l {
2337 return io.ErrUnexpectedEOF
2338 }
2339 m.ContainerID = string(dAtA[iNdEx:postIndex])
2340 iNdEx = postIndex
2341 case 2:
2342 if wireType != 2 {
2343 return fmt.Errorf("proto: wrong wireType = %d for field NicID", wireType)
2344 }
2345 var stringLen uint64
2346 for shift := uint(0); ; shift += 7 {
2347 if shift >= 64 {
2348 return ErrIntOverflowComputeagent
2349 }
2350 if iNdEx >= l {
2351 return io.ErrUnexpectedEOF
2352 }
2353 b := dAtA[iNdEx]
2354 iNdEx++
2355 stringLen |= uint64(b&0x7F) << shift
2356 if b < 0x80 {
2357 break
2358 }
2359 }
2360 intStringLen := int(stringLen)
2361 if intStringLen < 0 {
2362 return ErrInvalidLengthComputeagent
2363 }
2364 postIndex := iNdEx + intStringLen
2365 if postIndex < 0 {
2366 return ErrInvalidLengthComputeagent
2367 }
2368 if postIndex > l {
2369 return io.ErrUnexpectedEOF
2370 }
2371 m.NicID = string(dAtA[iNdEx:postIndex])
2372 iNdEx = postIndex
2373 case 3:
2374 if wireType != 2 {
2375 return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType)
2376 }
2377 var msglen int
2378 for shift := uint(0); ; shift += 7 {
2379 if shift >= 64 {
2380 return ErrIntOverflowComputeagent
2381 }
2382 if iNdEx >= l {
2383 return io.ErrUnexpectedEOF
2384 }
2385 b := dAtA[iNdEx]
2386 iNdEx++
2387 msglen |= int(b&0x7F) << shift
2388 if b < 0x80 {
2389 break
2390 }
2391 }
2392 if msglen < 0 {
2393 return ErrInvalidLengthComputeagent
2394 }
2395 postIndex := iNdEx + msglen
2396 if postIndex < 0 {
2397 return ErrInvalidLengthComputeagent
2398 }
2399 if postIndex > l {
2400 return io.ErrUnexpectedEOF
2401 }
2402 if m.Endpoint == nil {
2403 m.Endpoint = &types.Any{}
2404 }
2405 if err := m.Endpoint.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2406 return err
2407 }
2408 iNdEx = postIndex
2409 default:
2410 iNdEx = preIndex
2411 skippy, err := skipComputeagent(dAtA[iNdEx:])
2412 if err != nil {
2413 return err
2414 }
2415 if (skippy < 0) || (iNdEx+skippy) < 0 {
2416 return ErrInvalidLengthComputeagent
2417 }
2418 if (iNdEx + skippy) > l {
2419 return io.ErrUnexpectedEOF
2420 }
2421 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
2422 iNdEx += skippy
2423 }
2424 }
2425
2426 if iNdEx > l {
2427 return io.ErrUnexpectedEOF
2428 }
2429 return nil
2430 }
2431 func (m *DeleteNICInternalResponse) Unmarshal(dAtA []byte) error {
2432 l := len(dAtA)
2433 iNdEx := 0
2434 for iNdEx < l {
2435 preIndex := iNdEx
2436 var wire uint64
2437 for shift := uint(0); ; shift += 7 {
2438 if shift >= 64 {
2439 return ErrIntOverflowComputeagent
2440 }
2441 if iNdEx >= l {
2442 return io.ErrUnexpectedEOF
2443 }
2444 b := dAtA[iNdEx]
2445 iNdEx++
2446 wire |= uint64(b&0x7F) << shift
2447 if b < 0x80 {
2448 break
2449 }
2450 }
2451 fieldNum := int32(wire >> 3)
2452 wireType := int(wire & 0x7)
2453 if wireType == 4 {
2454 return fmt.Errorf("proto: DeleteNICInternalResponse: wiretype end group for non-group")
2455 }
2456 if fieldNum <= 0 {
2457 return fmt.Errorf("proto: DeleteNICInternalResponse: illegal tag %d (wire type %d)", fieldNum, wire)
2458 }
2459 switch fieldNum {
2460 default:
2461 iNdEx = preIndex
2462 skippy, err := skipComputeagent(dAtA[iNdEx:])
2463 if err != nil {
2464 return err
2465 }
2466 if (skippy < 0) || (iNdEx+skippy) < 0 {
2467 return ErrInvalidLengthComputeagent
2468 }
2469 if (iNdEx + skippy) > l {
2470 return io.ErrUnexpectedEOF
2471 }
2472 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
2473 iNdEx += skippy
2474 }
2475 }
2476
2477 if iNdEx > l {
2478 return io.ErrUnexpectedEOF
2479 }
2480 return nil
2481 }
2482 func (m *IovSettings) Unmarshal(dAtA []byte) error {
2483 l := len(dAtA)
2484 iNdEx := 0
2485 for iNdEx < l {
2486 preIndex := iNdEx
2487 var wire uint64
2488 for shift := uint(0); ; shift += 7 {
2489 if shift >= 64 {
2490 return ErrIntOverflowComputeagent
2491 }
2492 if iNdEx >= l {
2493 return io.ErrUnexpectedEOF
2494 }
2495 b := dAtA[iNdEx]
2496 iNdEx++
2497 wire |= uint64(b&0x7F) << shift
2498 if b < 0x80 {
2499 break
2500 }
2501 }
2502 fieldNum := int32(wire >> 3)
2503 wireType := int(wire & 0x7)
2504 if wireType == 4 {
2505 return fmt.Errorf("proto: IovSettings: wiretype end group for non-group")
2506 }
2507 if fieldNum <= 0 {
2508 return fmt.Errorf("proto: IovSettings: illegal tag %d (wire type %d)", fieldNum, wire)
2509 }
2510 switch fieldNum {
2511 case 1:
2512 if wireType != 0 {
2513 return fmt.Errorf("proto: wrong wireType = %d for field IovOffloadWeight", wireType)
2514 }
2515 m.IovOffloadWeight = 0
2516 for shift := uint(0); ; shift += 7 {
2517 if shift >= 64 {
2518 return ErrIntOverflowComputeagent
2519 }
2520 if iNdEx >= l {
2521 return io.ErrUnexpectedEOF
2522 }
2523 b := dAtA[iNdEx]
2524 iNdEx++
2525 m.IovOffloadWeight |= uint32(b&0x7F) << shift
2526 if b < 0x80 {
2527 break
2528 }
2529 }
2530 case 2:
2531 if wireType != 0 {
2532 return fmt.Errorf("proto: wrong wireType = %d for field QueuePairsRequested", wireType)
2533 }
2534 m.QueuePairsRequested = 0
2535 for shift := uint(0); ; shift += 7 {
2536 if shift >= 64 {
2537 return ErrIntOverflowComputeagent
2538 }
2539 if iNdEx >= l {
2540 return io.ErrUnexpectedEOF
2541 }
2542 b := dAtA[iNdEx]
2543 iNdEx++
2544 m.QueuePairsRequested |= uint32(b&0x7F) << shift
2545 if b < 0x80 {
2546 break
2547 }
2548 }
2549 case 3:
2550 if wireType != 0 {
2551 return fmt.Errorf("proto: wrong wireType = %d for field InterruptModeration", wireType)
2552 }
2553 m.InterruptModeration = 0
2554 for shift := uint(0); ; shift += 7 {
2555 if shift >= 64 {
2556 return ErrIntOverflowComputeagent
2557 }
2558 if iNdEx >= l {
2559 return io.ErrUnexpectedEOF
2560 }
2561 b := dAtA[iNdEx]
2562 iNdEx++
2563 m.InterruptModeration |= uint32(b&0x7F) << shift
2564 if b < 0x80 {
2565 break
2566 }
2567 }
2568 default:
2569 iNdEx = preIndex
2570 skippy, err := skipComputeagent(dAtA[iNdEx:])
2571 if err != nil {
2572 return err
2573 }
2574 if (skippy < 0) || (iNdEx+skippy) < 0 {
2575 return ErrInvalidLengthComputeagent
2576 }
2577 if (iNdEx + skippy) > l {
2578 return io.ErrUnexpectedEOF
2579 }
2580 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
2581 iNdEx += skippy
2582 }
2583 }
2584
2585 if iNdEx > l {
2586 return io.ErrUnexpectedEOF
2587 }
2588 return nil
2589 }
2590 func skipComputeagent(dAtA []byte) (n int, err error) {
2591 l := len(dAtA)
2592 iNdEx := 0
2593 depth := 0
2594 for iNdEx < l {
2595 var wire uint64
2596 for shift := uint(0); ; shift += 7 {
2597 if shift >= 64 {
2598 return 0, ErrIntOverflowComputeagent
2599 }
2600 if iNdEx >= l {
2601 return 0, io.ErrUnexpectedEOF
2602 }
2603 b := dAtA[iNdEx]
2604 iNdEx++
2605 wire |= (uint64(b) & 0x7F) << shift
2606 if b < 0x80 {
2607 break
2608 }
2609 }
2610 wireType := int(wire & 0x7)
2611 switch wireType {
2612 case 0:
2613 for shift := uint(0); ; shift += 7 {
2614 if shift >= 64 {
2615 return 0, ErrIntOverflowComputeagent
2616 }
2617 if iNdEx >= l {
2618 return 0, io.ErrUnexpectedEOF
2619 }
2620 iNdEx++
2621 if dAtA[iNdEx-1] < 0x80 {
2622 break
2623 }
2624 }
2625 case 1:
2626 iNdEx += 8
2627 case 2:
2628 var length int
2629 for shift := uint(0); ; shift += 7 {
2630 if shift >= 64 {
2631 return 0, ErrIntOverflowComputeagent
2632 }
2633 if iNdEx >= l {
2634 return 0, io.ErrUnexpectedEOF
2635 }
2636 b := dAtA[iNdEx]
2637 iNdEx++
2638 length |= (int(b) & 0x7F) << shift
2639 if b < 0x80 {
2640 break
2641 }
2642 }
2643 if length < 0 {
2644 return 0, ErrInvalidLengthComputeagent
2645 }
2646 iNdEx += length
2647 case 3:
2648 depth++
2649 case 4:
2650 if depth == 0 {
2651 return 0, ErrUnexpectedEndOfGroupComputeagent
2652 }
2653 depth--
2654 case 5:
2655 iNdEx += 4
2656 default:
2657 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
2658 }
2659 if iNdEx < 0 {
2660 return 0, ErrInvalidLengthComputeagent
2661 }
2662 if depth == 0 {
2663 return iNdEx, nil
2664 }
2665 }
2666 return 0, io.ErrUnexpectedEOF
2667 }
2668
2669 var (
2670 ErrInvalidLengthComputeagent = fmt.Errorf("proto: negative length found during unmarshaling")
2671 ErrIntOverflowComputeagent = fmt.Errorf("proto: integer overflow")
2672 ErrUnexpectedEndOfGroupComputeagent = fmt.Errorf("proto: unexpected end of group")
2673 )
2674
View as plain text