1
2
3
4 package vmservice
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 github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
12 types "github.com/gogo/protobuf/types"
13 io "io"
14 math "math"
15 math_bits "math/bits"
16 reflect "reflect"
17 strings "strings"
18 )
19
20
21 var _ = proto.Marshal
22 var _ = fmt.Errorf
23 var _ = math.Inf
24
25
26
27
28
29 const _ = proto.GoGoProtoPackageIsVersion3
30
31 type ModifyType int32
32
33 const (
34 ModifyType_ADD ModifyType = 0
35 ModifyType_REMOVE ModifyType = 1
36 ModifyType_UPDATE ModifyType = 2
37 )
38
39 var ModifyType_name = map[int32]string{
40 0: "ADD",
41 1: "REMOVE",
42 2: "UPDATE",
43 }
44
45 var ModifyType_value = map[string]int32{
46 "ADD": 0,
47 "REMOVE": 1,
48 "UPDATE": 2,
49 }
50
51 func (x ModifyType) String() string {
52 return proto.EnumName(ModifyType_name, int32(x))
53 }
54
55 func (ModifyType) EnumDescriptor() ([]byte, []int) {
56 return fileDescriptor_272f12cfdaa6c7c8, []int{0}
57 }
58
59 type DiskType int32
60
61 const (
62 DiskType_SCSI_DISK_TYPE_VHD1 DiskType = 0
63 DiskType_SCSI_DISK_TYPE_VHDX DiskType = 1
64 DiskType_SCSI_DISK_TYPE_PHYSICAL DiskType = 2
65 )
66
67 var DiskType_name = map[int32]string{
68 0: "SCSI_DISK_TYPE_VHD1",
69 1: "SCSI_DISK_TYPE_VHDX",
70 2: "SCSI_DISK_TYPE_PHYSICAL",
71 }
72
73 var DiskType_value = map[string]int32{
74 "SCSI_DISK_TYPE_VHD1": 0,
75 "SCSI_DISK_TYPE_VHDX": 1,
76 "SCSI_DISK_TYPE_PHYSICAL": 2,
77 }
78
79 func (x DiskType) String() string {
80 return proto.EnumName(DiskType_name, int32(x))
81 }
82
83 func (DiskType) EnumDescriptor() ([]byte, []int) {
84 return fileDescriptor_272f12cfdaa6c7c8, []int{1}
85 }
86
87 type PropertiesVMRequest_PropertiesType int32
88
89 const (
90 PropertiesVMRequest_Memory PropertiesVMRequest_PropertiesType = 0
91 PropertiesVMRequest_Processor PropertiesVMRequest_PropertiesType = 1
92 )
93
94 var PropertiesVMRequest_PropertiesType_name = map[int32]string{
95 0: "Memory",
96 1: "Processor",
97 }
98
99 var PropertiesVMRequest_PropertiesType_value = map[string]int32{
100 "Memory": 0,
101 "Processor": 1,
102 }
103
104 func (x PropertiesVMRequest_PropertiesType) String() string {
105 return proto.EnumName(PropertiesVMRequest_PropertiesType_name, int32(x))
106 }
107
108 func (PropertiesVMRequest_PropertiesType) EnumDescriptor() ([]byte, []int) {
109 return fileDescriptor_272f12cfdaa6c7c8, []int{13, 0}
110 }
111
112 type CapabilitiesVMResponse_Resource int32
113
114 const (
115 CapabilitiesVMResponse_Vpmem CapabilitiesVMResponse_Resource = 0
116 CapabilitiesVMResponse_Scsi CapabilitiesVMResponse_Resource = 1
117 CapabilitiesVMResponse_Vpci CapabilitiesVMResponse_Resource = 2
118 CapabilitiesVMResponse_Plan9 CapabilitiesVMResponse_Resource = 3
119 CapabilitiesVMResponse_VMNic CapabilitiesVMResponse_Resource = 4
120 CapabilitiesVMResponse_Memory CapabilitiesVMResponse_Resource = 5
121 CapabilitiesVMResponse_Processor CapabilitiesVMResponse_Resource = 6
122 )
123
124 var CapabilitiesVMResponse_Resource_name = map[int32]string{
125 0: "Vpmem",
126 1: "Scsi",
127 2: "Vpci",
128 3: "Plan9",
129 4: "VMNic",
130 5: "Memory",
131 6: "Processor",
132 }
133
134 var CapabilitiesVMResponse_Resource_value = map[string]int32{
135 "Vpmem": 0,
136 "Scsi": 1,
137 "Vpci": 2,
138 "Plan9": 3,
139 "VMNic": 4,
140 "Memory": 5,
141 "Processor": 6,
142 }
143
144 func (x CapabilitiesVMResponse_Resource) String() string {
145 return proto.EnumName(CapabilitiesVMResponse_Resource_name, int32(x))
146 }
147
148 func (CapabilitiesVMResponse_Resource) EnumDescriptor() ([]byte, []int) {
149 return fileDescriptor_272f12cfdaa6c7c8, []int{15, 0}
150 }
151
152 type CapabilitiesVMResponse_SupportedGuestOS int32
153
154 const (
155 CapabilitiesVMResponse_Windows CapabilitiesVMResponse_SupportedGuestOS = 0
156 CapabilitiesVMResponse_Linux CapabilitiesVMResponse_SupportedGuestOS = 1
157 )
158
159 var CapabilitiesVMResponse_SupportedGuestOS_name = map[int32]string{
160 0: "Windows",
161 1: "Linux",
162 }
163
164 var CapabilitiesVMResponse_SupportedGuestOS_value = map[string]int32{
165 "Windows": 0,
166 "Linux": 1,
167 }
168
169 func (x CapabilitiesVMResponse_SupportedGuestOS) String() string {
170 return proto.EnumName(CapabilitiesVMResponse_SupportedGuestOS_name, int32(x))
171 }
172
173 func (CapabilitiesVMResponse_SupportedGuestOS) EnumDescriptor() ([]byte, []int) {
174 return fileDescriptor_272f12cfdaa6c7c8, []int{15, 1}
175 }
176
177 type DirectBoot struct {
178 KernelPath string `protobuf:"bytes,1,opt,name=kernel_path,json=kernelPath,proto3" json:"kernel_path,omitempty"`
179 InitrdPath string `protobuf:"bytes,2,opt,name=initrd_path,json=initrdPath,proto3" json:"initrd_path,omitempty"`
180 KernelCmdline string `protobuf:"bytes,3,opt,name=kernel_cmdline,json=kernelCmdline,proto3" json:"kernel_cmdline,omitempty"`
181 XXX_NoUnkeyedLiteral struct{} `json:"-"`
182 XXX_unrecognized []byte `json:"-"`
183 XXX_sizecache int32 `json:"-"`
184 }
185
186 func (m *DirectBoot) Reset() { *m = DirectBoot{} }
187 func (*DirectBoot) ProtoMessage() {}
188 func (*DirectBoot) Descriptor() ([]byte, []int) {
189 return fileDescriptor_272f12cfdaa6c7c8, []int{0}
190 }
191 func (m *DirectBoot) XXX_Unmarshal(b []byte) error {
192 return m.Unmarshal(b)
193 }
194 func (m *DirectBoot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
195 if deterministic {
196 return xxx_messageInfo_DirectBoot.Marshal(b, m, deterministic)
197 } else {
198 b = b[:cap(b)]
199 n, err := m.MarshalToSizedBuffer(b)
200 if err != nil {
201 return nil, err
202 }
203 return b[:n], nil
204 }
205 }
206 func (m *DirectBoot) XXX_Merge(src proto.Message) {
207 xxx_messageInfo_DirectBoot.Merge(m, src)
208 }
209 func (m *DirectBoot) XXX_Size() int {
210 return m.Size()
211 }
212 func (m *DirectBoot) XXX_DiscardUnknown() {
213 xxx_messageInfo_DirectBoot.DiscardUnknown(m)
214 }
215
216 var xxx_messageInfo_DirectBoot proto.InternalMessageInfo
217
218 type UEFI struct {
219 FirmwarePath string `protobuf:"bytes,1,opt,name=firmware_path,json=firmwarePath,proto3" json:"firmware_path,omitempty"`
220 DevicePath string `protobuf:"bytes,2,opt,name=device_path,json=devicePath,proto3" json:"device_path,omitempty"`
221
222
223 OptionalData string `protobuf:"bytes,3,opt,name=optional_data,json=optionalData,proto3" json:"optional_data,omitempty"`
224 XXX_NoUnkeyedLiteral struct{} `json:"-"`
225 XXX_unrecognized []byte `json:"-"`
226 XXX_sizecache int32 `json:"-"`
227 }
228
229 func (m *UEFI) Reset() { *m = UEFI{} }
230 func (*UEFI) ProtoMessage() {}
231 func (*UEFI) Descriptor() ([]byte, []int) {
232 return fileDescriptor_272f12cfdaa6c7c8, []int{1}
233 }
234 func (m *UEFI) XXX_Unmarshal(b []byte) error {
235 return m.Unmarshal(b)
236 }
237 func (m *UEFI) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
238 if deterministic {
239 return xxx_messageInfo_UEFI.Marshal(b, m, deterministic)
240 } else {
241 b = b[:cap(b)]
242 n, err := m.MarshalToSizedBuffer(b)
243 if err != nil {
244 return nil, err
245 }
246 return b[:n], nil
247 }
248 }
249 func (m *UEFI) XXX_Merge(src proto.Message) {
250 xxx_messageInfo_UEFI.Merge(m, src)
251 }
252 func (m *UEFI) XXX_Size() int {
253 return m.Size()
254 }
255 func (m *UEFI) XXX_DiscardUnknown() {
256 xxx_messageInfo_UEFI.DiscardUnknown(m)
257 }
258
259 var xxx_messageInfo_UEFI proto.InternalMessageInfo
260
261 type MemoryConfig struct {
262 MemoryMb uint64 `protobuf:"varint,1,opt,name=memory_mb,json=memoryMb,proto3" json:"memory_mb,omitempty"`
263 AllowOvercommit bool `protobuf:"varint,2,opt,name=allow_overcommit,json=allowOvercommit,proto3" json:"allow_overcommit,omitempty"`
264 DeferredCommit bool `protobuf:"varint,3,opt,name=deferred_commit,json=deferredCommit,proto3" json:"deferred_commit,omitempty"`
265 HotHint bool `protobuf:"varint,4,opt,name=hot_hint,json=hotHint,proto3" json:"hot_hint,omitempty"`
266 ColdHint bool `protobuf:"varint,5,opt,name=cold_hint,json=coldHint,proto3" json:"cold_hint,omitempty"`
267 ColdDiscardHint bool `protobuf:"varint,6,opt,name=cold_discard_hint,json=coldDiscardHint,proto3" json:"cold_discard_hint,omitempty"`
268 LowMmioGapInMb uint64 `protobuf:"varint,7,opt,name=low_mmio_gap_in_mb,json=lowMmioGapInMb,proto3" json:"low_mmio_gap_in_mb,omitempty"`
269 HighMmioBaseInMb uint64 `protobuf:"varint,8,opt,name=high_mmio_base_in_mb,json=highMmioBaseInMb,proto3" json:"high_mmio_base_in_mb,omitempty"`
270 HighMmioGapInMb uint64 `protobuf:"varint,9,opt,name=high_mmio_gap_in_mb,json=highMmioGapInMb,proto3" json:"high_mmio_gap_in_mb,omitempty"`
271 XXX_NoUnkeyedLiteral struct{} `json:"-"`
272 XXX_unrecognized []byte `json:"-"`
273 XXX_sizecache int32 `json:"-"`
274 }
275
276 func (m *MemoryConfig) Reset() { *m = MemoryConfig{} }
277 func (*MemoryConfig) ProtoMessage() {}
278 func (*MemoryConfig) Descriptor() ([]byte, []int) {
279 return fileDescriptor_272f12cfdaa6c7c8, []int{2}
280 }
281 func (m *MemoryConfig) XXX_Unmarshal(b []byte) error {
282 return m.Unmarshal(b)
283 }
284 func (m *MemoryConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
285 if deterministic {
286 return xxx_messageInfo_MemoryConfig.Marshal(b, m, deterministic)
287 } else {
288 b = b[:cap(b)]
289 n, err := m.MarshalToSizedBuffer(b)
290 if err != nil {
291 return nil, err
292 }
293 return b[:n], nil
294 }
295 }
296 func (m *MemoryConfig) XXX_Merge(src proto.Message) {
297 xxx_messageInfo_MemoryConfig.Merge(m, src)
298 }
299 func (m *MemoryConfig) XXX_Size() int {
300 return m.Size()
301 }
302 func (m *MemoryConfig) XXX_DiscardUnknown() {
303 xxx_messageInfo_MemoryConfig.DiscardUnknown(m)
304 }
305
306 var xxx_messageInfo_MemoryConfig proto.InternalMessageInfo
307
308 type ProcessorConfig struct {
309 ProcessorCount uint32 `protobuf:"varint,1,opt,name=processor_count,json=processorCount,proto3" json:"processor_count,omitempty"`
310 ProcessorWeight uint32 `protobuf:"varint,2,opt,name=processor_weight,json=processorWeight,proto3" json:"processor_weight,omitempty"`
311 ProcessorLimit uint32 `protobuf:"varint,3,opt,name=processor_limit,json=processorLimit,proto3" json:"processor_limit,omitempty"`
312 XXX_NoUnkeyedLiteral struct{} `json:"-"`
313 XXX_unrecognized []byte `json:"-"`
314 XXX_sizecache int32 `json:"-"`
315 }
316
317 func (m *ProcessorConfig) Reset() { *m = ProcessorConfig{} }
318 func (*ProcessorConfig) ProtoMessage() {}
319 func (*ProcessorConfig) Descriptor() ([]byte, []int) {
320 return fileDescriptor_272f12cfdaa6c7c8, []int{3}
321 }
322 func (m *ProcessorConfig) XXX_Unmarshal(b []byte) error {
323 return m.Unmarshal(b)
324 }
325 func (m *ProcessorConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
326 if deterministic {
327 return xxx_messageInfo_ProcessorConfig.Marshal(b, m, deterministic)
328 } else {
329 b = b[:cap(b)]
330 n, err := m.MarshalToSizedBuffer(b)
331 if err != nil {
332 return nil, err
333 }
334 return b[:n], nil
335 }
336 }
337 func (m *ProcessorConfig) XXX_Merge(src proto.Message) {
338 xxx_messageInfo_ProcessorConfig.Merge(m, src)
339 }
340 func (m *ProcessorConfig) XXX_Size() int {
341 return m.Size()
342 }
343 func (m *ProcessorConfig) XXX_DiscardUnknown() {
344 xxx_messageInfo_ProcessorConfig.DiscardUnknown(m)
345 }
346
347 var xxx_messageInfo_ProcessorConfig proto.InternalMessageInfo
348
349 type DevicesConfig struct {
350 ScsiDisks []*SCSIDisk `protobuf:"bytes,1,rep,name=scsi_disks,json=scsiDisks,proto3" json:"scsi_disks,omitempty"`
351 VpmemDisks []*VPMEMDisk `protobuf:"bytes,2,rep,name=vpmem_disks,json=vpmemDisks,proto3" json:"vpmem_disks,omitempty"`
352 NicConfig []*NICConfig `protobuf:"bytes,3,rep,name=nic_config,json=nicConfig,proto3" json:"nic_config,omitempty"`
353 WindowsDevice []*WindowsPCIDevice `protobuf:"bytes,4,rep,name=windows_device,json=windowsDevice,proto3" json:"windows_device,omitempty"`
354 XXX_NoUnkeyedLiteral struct{} `json:"-"`
355 XXX_unrecognized []byte `json:"-"`
356 XXX_sizecache int32 `json:"-"`
357 }
358
359 func (m *DevicesConfig) Reset() { *m = DevicesConfig{} }
360 func (*DevicesConfig) ProtoMessage() {}
361 func (*DevicesConfig) Descriptor() ([]byte, []int) {
362 return fileDescriptor_272f12cfdaa6c7c8, []int{4}
363 }
364 func (m *DevicesConfig) XXX_Unmarshal(b []byte) error {
365 return m.Unmarshal(b)
366 }
367 func (m *DevicesConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
368 if deterministic {
369 return xxx_messageInfo_DevicesConfig.Marshal(b, m, deterministic)
370 } else {
371 b = b[:cap(b)]
372 n, err := m.MarshalToSizedBuffer(b)
373 if err != nil {
374 return nil, err
375 }
376 return b[:n], nil
377 }
378 }
379 func (m *DevicesConfig) XXX_Merge(src proto.Message) {
380 xxx_messageInfo_DevicesConfig.Merge(m, src)
381 }
382 func (m *DevicesConfig) XXX_Size() int {
383 return m.Size()
384 }
385 func (m *DevicesConfig) XXX_DiscardUnknown() {
386 xxx_messageInfo_DevicesConfig.DiscardUnknown(m)
387 }
388
389 var xxx_messageInfo_DevicesConfig proto.InternalMessageInfo
390
391 type VMConfig struct {
392 MemoryConfig *MemoryConfig `protobuf:"bytes,1,opt,name=memory_config,json=memoryConfig,proto3" json:"memory_config,omitempty"`
393 ProcessorConfig *ProcessorConfig `protobuf:"bytes,2,opt,name=processor_config,json=processorConfig,proto3" json:"processor_config,omitempty"`
394 DevicesConfig *DevicesConfig `protobuf:"bytes,3,opt,name=devices_config,json=devicesConfig,proto3" json:"devices_config,omitempty"`
395 SerialConfig *SerialConfig `protobuf:"bytes,4,opt,name=serial_config,json=serialConfig,proto3" json:"serial_config,omitempty"`
396
397
398
399 BootConfig isVMConfig_BootConfig `protobuf_oneof:"BootConfig"`
400 WindowsOptions *WindowsOptions `protobuf:"bytes,7,opt,name=windows_options,json=windowsOptions,proto3" json:"windows_options,omitempty"`
401
402 ExtraData map[string]string `protobuf:"bytes,8,rep,name=extra_data,json=extraData,proto3" json:"extra_data,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
403 XXX_NoUnkeyedLiteral struct{} `json:"-"`
404 XXX_unrecognized []byte `json:"-"`
405 XXX_sizecache int32 `json:"-"`
406 }
407
408 func (m *VMConfig) Reset() { *m = VMConfig{} }
409 func (*VMConfig) ProtoMessage() {}
410 func (*VMConfig) Descriptor() ([]byte, []int) {
411 return fileDescriptor_272f12cfdaa6c7c8, []int{5}
412 }
413 func (m *VMConfig) XXX_Unmarshal(b []byte) error {
414 return m.Unmarshal(b)
415 }
416 func (m *VMConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
417 if deterministic {
418 return xxx_messageInfo_VMConfig.Marshal(b, m, deterministic)
419 } else {
420 b = b[:cap(b)]
421 n, err := m.MarshalToSizedBuffer(b)
422 if err != nil {
423 return nil, err
424 }
425 return b[:n], nil
426 }
427 }
428 func (m *VMConfig) XXX_Merge(src proto.Message) {
429 xxx_messageInfo_VMConfig.Merge(m, src)
430 }
431 func (m *VMConfig) XXX_Size() int {
432 return m.Size()
433 }
434 func (m *VMConfig) XXX_DiscardUnknown() {
435 xxx_messageInfo_VMConfig.DiscardUnknown(m)
436 }
437
438 var xxx_messageInfo_VMConfig proto.InternalMessageInfo
439
440 type isVMConfig_BootConfig interface {
441 isVMConfig_BootConfig()
442 MarshalTo([]byte) (int, error)
443 Size() int
444 }
445
446 type VMConfig_DirectBoot struct {
447 DirectBoot *DirectBoot `protobuf:"bytes,5,opt,name=direct_boot,json=directBoot,proto3,oneof" json:"direct_boot,omitempty"`
448 }
449 type VMConfig_Uefi struct {
450 Uefi *UEFI `protobuf:"bytes,6,opt,name=uefi,proto3,oneof" json:"uefi,omitempty"`
451 }
452
453 func (*VMConfig_DirectBoot) isVMConfig_BootConfig() {}
454 func (*VMConfig_Uefi) isVMConfig_BootConfig() {}
455
456 func (m *VMConfig) GetBootConfig() isVMConfig_BootConfig {
457 if m != nil {
458 return m.BootConfig
459 }
460 return nil
461 }
462
463 func (m *VMConfig) GetDirectBoot() *DirectBoot {
464 if x, ok := m.GetBootConfig().(*VMConfig_DirectBoot); ok {
465 return x.DirectBoot
466 }
467 return nil
468 }
469
470 func (m *VMConfig) GetUefi() *UEFI {
471 if x, ok := m.GetBootConfig().(*VMConfig_Uefi); ok {
472 return x.Uefi
473 }
474 return nil
475 }
476
477
478 func (*VMConfig) XXX_OneofWrappers() []interface{} {
479 return []interface{}{
480 (*VMConfig_DirectBoot)(nil),
481 (*VMConfig_Uefi)(nil),
482 }
483 }
484
485
486 type WindowsOptions struct {
487 CpuGroupID uint64 `protobuf:"varint,1,opt,name=cpu_group_id,json=cpuGroupId,proto3" json:"cpu_group_id,omitempty"`
488 XXX_NoUnkeyedLiteral struct{} `json:"-"`
489 XXX_unrecognized []byte `json:"-"`
490 XXX_sizecache int32 `json:"-"`
491 }
492
493 func (m *WindowsOptions) Reset() { *m = WindowsOptions{} }
494 func (*WindowsOptions) ProtoMessage() {}
495 func (*WindowsOptions) Descriptor() ([]byte, []int) {
496 return fileDescriptor_272f12cfdaa6c7c8, []int{6}
497 }
498 func (m *WindowsOptions) XXX_Unmarshal(b []byte) error {
499 return m.Unmarshal(b)
500 }
501 func (m *WindowsOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
502 if deterministic {
503 return xxx_messageInfo_WindowsOptions.Marshal(b, m, deterministic)
504 } else {
505 b = b[:cap(b)]
506 n, err := m.MarshalToSizedBuffer(b)
507 if err != nil {
508 return nil, err
509 }
510 return b[:n], nil
511 }
512 }
513 func (m *WindowsOptions) XXX_Merge(src proto.Message) {
514 xxx_messageInfo_WindowsOptions.Merge(m, src)
515 }
516 func (m *WindowsOptions) XXX_Size() int {
517 return m.Size()
518 }
519 func (m *WindowsOptions) XXX_DiscardUnknown() {
520 xxx_messageInfo_WindowsOptions.DiscardUnknown(m)
521 }
522
523 var xxx_messageInfo_WindowsOptions proto.InternalMessageInfo
524
525 type SerialConfig struct {
526 Ports []*SerialConfig_Config `protobuf:"bytes,3,rep,name=ports,proto3" json:"ports,omitempty"`
527 XXX_NoUnkeyedLiteral struct{} `json:"-"`
528 XXX_unrecognized []byte `json:"-"`
529 XXX_sizecache int32 `json:"-"`
530 }
531
532 func (m *SerialConfig) Reset() { *m = SerialConfig{} }
533 func (*SerialConfig) ProtoMessage() {}
534 func (*SerialConfig) Descriptor() ([]byte, []int) {
535 return fileDescriptor_272f12cfdaa6c7c8, []int{7}
536 }
537 func (m *SerialConfig) XXX_Unmarshal(b []byte) error {
538 return m.Unmarshal(b)
539 }
540 func (m *SerialConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
541 if deterministic {
542 return xxx_messageInfo_SerialConfig.Marshal(b, m, deterministic)
543 } else {
544 b = b[:cap(b)]
545 n, err := m.MarshalToSizedBuffer(b)
546 if err != nil {
547 return nil, err
548 }
549 return b[:n], nil
550 }
551 }
552 func (m *SerialConfig) XXX_Merge(src proto.Message) {
553 xxx_messageInfo_SerialConfig.Merge(m, src)
554 }
555 func (m *SerialConfig) XXX_Size() int {
556 return m.Size()
557 }
558 func (m *SerialConfig) XXX_DiscardUnknown() {
559 xxx_messageInfo_SerialConfig.DiscardUnknown(m)
560 }
561
562 var xxx_messageInfo_SerialConfig proto.InternalMessageInfo
563
564 type SerialConfig_Config struct {
565 Port uint32 `protobuf:"varint,1,opt,name=port,proto3" json:"port,omitempty"`
566
567 SocketPath string `protobuf:"bytes,2,opt,name=socket_path,json=socketPath,proto3" json:"socket_path,omitempty"`
568 XXX_NoUnkeyedLiteral struct{} `json:"-"`
569 XXX_unrecognized []byte `json:"-"`
570 XXX_sizecache int32 `json:"-"`
571 }
572
573 func (m *SerialConfig_Config) Reset() { *m = SerialConfig_Config{} }
574 func (*SerialConfig_Config) ProtoMessage() {}
575 func (*SerialConfig_Config) Descriptor() ([]byte, []int) {
576 return fileDescriptor_272f12cfdaa6c7c8, []int{7, 0}
577 }
578 func (m *SerialConfig_Config) XXX_Unmarshal(b []byte) error {
579 return m.Unmarshal(b)
580 }
581 func (m *SerialConfig_Config) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
582 if deterministic {
583 return xxx_messageInfo_SerialConfig_Config.Marshal(b, m, deterministic)
584 } else {
585 b = b[:cap(b)]
586 n, err := m.MarshalToSizedBuffer(b)
587 if err != nil {
588 return nil, err
589 }
590 return b[:n], nil
591 }
592 }
593 func (m *SerialConfig_Config) XXX_Merge(src proto.Message) {
594 xxx_messageInfo_SerialConfig_Config.Merge(m, src)
595 }
596 func (m *SerialConfig_Config) XXX_Size() int {
597 return m.Size()
598 }
599 func (m *SerialConfig_Config) XXX_DiscardUnknown() {
600 xxx_messageInfo_SerialConfig_Config.DiscardUnknown(m)
601 }
602
603 var xxx_messageInfo_SerialConfig_Config proto.InternalMessageInfo
604
605 type CreateVMRequest struct {
606 Config *VMConfig `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
607
608
609
610 LogID string `protobuf:"bytes,2,opt,name=log_id,json=logId,proto3" json:"log_id,omitempty"`
611 XXX_NoUnkeyedLiteral struct{} `json:"-"`
612 XXX_unrecognized []byte `json:"-"`
613 XXX_sizecache int32 `json:"-"`
614 }
615
616 func (m *CreateVMRequest) Reset() { *m = CreateVMRequest{} }
617 func (*CreateVMRequest) ProtoMessage() {}
618 func (*CreateVMRequest) Descriptor() ([]byte, []int) {
619 return fileDescriptor_272f12cfdaa6c7c8, []int{8}
620 }
621 func (m *CreateVMRequest) XXX_Unmarshal(b []byte) error {
622 return m.Unmarshal(b)
623 }
624 func (m *CreateVMRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
625 if deterministic {
626 return xxx_messageInfo_CreateVMRequest.Marshal(b, m, deterministic)
627 } else {
628 b = b[:cap(b)]
629 n, err := m.MarshalToSizedBuffer(b)
630 if err != nil {
631 return nil, err
632 }
633 return b[:n], nil
634 }
635 }
636 func (m *CreateVMRequest) XXX_Merge(src proto.Message) {
637 xxx_messageInfo_CreateVMRequest.Merge(m, src)
638 }
639 func (m *CreateVMRequest) XXX_Size() int {
640 return m.Size()
641 }
642 func (m *CreateVMRequest) XXX_DiscardUnknown() {
643 xxx_messageInfo_CreateVMRequest.DiscardUnknown(m)
644 }
645
646 var xxx_messageInfo_CreateVMRequest proto.InternalMessageInfo
647
648 type InspectVMRequest struct {
649 Query string `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"`
650 RecursionLimit uint32 `protobuf:"varint,2,opt,name=recursion_limit,json=recursionLimit,proto3" json:"recursion_limit,omitempty"`
651 XXX_NoUnkeyedLiteral struct{} `json:"-"`
652 XXX_unrecognized []byte `json:"-"`
653 XXX_sizecache int32 `json:"-"`
654 }
655
656 func (m *InspectVMRequest) Reset() { *m = InspectVMRequest{} }
657 func (*InspectVMRequest) ProtoMessage() {}
658 func (*InspectVMRequest) Descriptor() ([]byte, []int) {
659 return fileDescriptor_272f12cfdaa6c7c8, []int{9}
660 }
661 func (m *InspectVMRequest) XXX_Unmarshal(b []byte) error {
662 return m.Unmarshal(b)
663 }
664 func (m *InspectVMRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
665 if deterministic {
666 return xxx_messageInfo_InspectVMRequest.Marshal(b, m, deterministic)
667 } else {
668 b = b[:cap(b)]
669 n, err := m.MarshalToSizedBuffer(b)
670 if err != nil {
671 return nil, err
672 }
673 return b[:n], nil
674 }
675 }
676 func (m *InspectVMRequest) XXX_Merge(src proto.Message) {
677 xxx_messageInfo_InspectVMRequest.Merge(m, src)
678 }
679 func (m *InspectVMRequest) XXX_Size() int {
680 return m.Size()
681 }
682 func (m *InspectVMRequest) XXX_DiscardUnknown() {
683 xxx_messageInfo_InspectVMRequest.DiscardUnknown(m)
684 }
685
686 var xxx_messageInfo_InspectVMRequest proto.InternalMessageInfo
687
688 type InspectVMResponse struct {
689 Result *types.Value `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty"`
690 XXX_NoUnkeyedLiteral struct{} `json:"-"`
691 XXX_unrecognized []byte `json:"-"`
692 XXX_sizecache int32 `json:"-"`
693 }
694
695 func (m *InspectVMResponse) Reset() { *m = InspectVMResponse{} }
696 func (*InspectVMResponse) ProtoMessage() {}
697 func (*InspectVMResponse) Descriptor() ([]byte, []int) {
698 return fileDescriptor_272f12cfdaa6c7c8, []int{10}
699 }
700 func (m *InspectVMResponse) XXX_Unmarshal(b []byte) error {
701 return m.Unmarshal(b)
702 }
703 func (m *InspectVMResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
704 if deterministic {
705 return xxx_messageInfo_InspectVMResponse.Marshal(b, m, deterministic)
706 } else {
707 b = b[:cap(b)]
708 n, err := m.MarshalToSizedBuffer(b)
709 if err != nil {
710 return nil, err
711 }
712 return b[:n], nil
713 }
714 }
715 func (m *InspectVMResponse) XXX_Merge(src proto.Message) {
716 xxx_messageInfo_InspectVMResponse.Merge(m, src)
717 }
718 func (m *InspectVMResponse) XXX_Size() int {
719 return m.Size()
720 }
721 func (m *InspectVMResponse) XXX_DiscardUnknown() {
722 xxx_messageInfo_InspectVMResponse.DiscardUnknown(m)
723 }
724
725 var xxx_messageInfo_InspectVMResponse proto.InternalMessageInfo
726
727 type MemoryStats struct {
728 WorkingSetBytes uint64 `protobuf:"varint,1,opt,name=working_set_bytes,json=workingSetBytes,proto3" json:"working_set_bytes,omitempty"`
729 AvailableMemory uint64 `protobuf:"varint,2,opt,name=available_memory,json=availableMemory,proto3" json:"available_memory,omitempty"`
730 ReservedMemory uint64 `protobuf:"varint,3,opt,name=reserved_memory,json=reservedMemory,proto3" json:"reserved_memory,omitempty"`
731 AssignedMemory uint64 `protobuf:"varint,4,opt,name=assigned_memory,json=assignedMemory,proto3" json:"assigned_memory,omitempty"`
732 XXX_NoUnkeyedLiteral struct{} `json:"-"`
733 XXX_unrecognized []byte `json:"-"`
734 XXX_sizecache int32 `json:"-"`
735 }
736
737 func (m *MemoryStats) Reset() { *m = MemoryStats{} }
738 func (*MemoryStats) ProtoMessage() {}
739 func (*MemoryStats) Descriptor() ([]byte, []int) {
740 return fileDescriptor_272f12cfdaa6c7c8, []int{11}
741 }
742 func (m *MemoryStats) XXX_Unmarshal(b []byte) error {
743 return m.Unmarshal(b)
744 }
745 func (m *MemoryStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
746 if deterministic {
747 return xxx_messageInfo_MemoryStats.Marshal(b, m, deterministic)
748 } else {
749 b = b[:cap(b)]
750 n, err := m.MarshalToSizedBuffer(b)
751 if err != nil {
752 return nil, err
753 }
754 return b[:n], nil
755 }
756 }
757 func (m *MemoryStats) XXX_Merge(src proto.Message) {
758 xxx_messageInfo_MemoryStats.Merge(m, src)
759 }
760 func (m *MemoryStats) XXX_Size() int {
761 return m.Size()
762 }
763 func (m *MemoryStats) XXX_DiscardUnknown() {
764 xxx_messageInfo_MemoryStats.DiscardUnknown(m)
765 }
766
767 var xxx_messageInfo_MemoryStats proto.InternalMessageInfo
768
769 type ProcessorStats struct {
770 TotalRuntimeNs uint64 `protobuf:"varint,1,opt,name=total_runtime_ns,json=totalRuntimeNs,proto3" json:"total_runtime_ns,omitempty"`
771 XXX_NoUnkeyedLiteral struct{} `json:"-"`
772 XXX_unrecognized []byte `json:"-"`
773 XXX_sizecache int32 `json:"-"`
774 }
775
776 func (m *ProcessorStats) Reset() { *m = ProcessorStats{} }
777 func (*ProcessorStats) ProtoMessage() {}
778 func (*ProcessorStats) Descriptor() ([]byte, []int) {
779 return fileDescriptor_272f12cfdaa6c7c8, []int{12}
780 }
781 func (m *ProcessorStats) XXX_Unmarshal(b []byte) error {
782 return m.Unmarshal(b)
783 }
784 func (m *ProcessorStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
785 if deterministic {
786 return xxx_messageInfo_ProcessorStats.Marshal(b, m, deterministic)
787 } else {
788 b = b[:cap(b)]
789 n, err := m.MarshalToSizedBuffer(b)
790 if err != nil {
791 return nil, err
792 }
793 return b[:n], nil
794 }
795 }
796 func (m *ProcessorStats) XXX_Merge(src proto.Message) {
797 xxx_messageInfo_ProcessorStats.Merge(m, src)
798 }
799 func (m *ProcessorStats) XXX_Size() int {
800 return m.Size()
801 }
802 func (m *ProcessorStats) XXX_DiscardUnknown() {
803 xxx_messageInfo_ProcessorStats.DiscardUnknown(m)
804 }
805
806 var xxx_messageInfo_ProcessorStats proto.InternalMessageInfo
807
808 type PropertiesVMRequest struct {
809 Types []PropertiesVMRequest_PropertiesType `protobuf:"varint,1,rep,packed,name=types,proto3,enum=vmservice.PropertiesVMRequest_PropertiesType" json:"types,omitempty"`
810 XXX_NoUnkeyedLiteral struct{} `json:"-"`
811 XXX_unrecognized []byte `json:"-"`
812 XXX_sizecache int32 `json:"-"`
813 }
814
815 func (m *PropertiesVMRequest) Reset() { *m = PropertiesVMRequest{} }
816 func (*PropertiesVMRequest) ProtoMessage() {}
817 func (*PropertiesVMRequest) Descriptor() ([]byte, []int) {
818 return fileDescriptor_272f12cfdaa6c7c8, []int{13}
819 }
820 func (m *PropertiesVMRequest) XXX_Unmarshal(b []byte) error {
821 return m.Unmarshal(b)
822 }
823 func (m *PropertiesVMRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
824 if deterministic {
825 return xxx_messageInfo_PropertiesVMRequest.Marshal(b, m, deterministic)
826 } else {
827 b = b[:cap(b)]
828 n, err := m.MarshalToSizedBuffer(b)
829 if err != nil {
830 return nil, err
831 }
832 return b[:n], nil
833 }
834 }
835 func (m *PropertiesVMRequest) XXX_Merge(src proto.Message) {
836 xxx_messageInfo_PropertiesVMRequest.Merge(m, src)
837 }
838 func (m *PropertiesVMRequest) XXX_Size() int {
839 return m.Size()
840 }
841 func (m *PropertiesVMRequest) XXX_DiscardUnknown() {
842 xxx_messageInfo_PropertiesVMRequest.DiscardUnknown(m)
843 }
844
845 var xxx_messageInfo_PropertiesVMRequest proto.InternalMessageInfo
846
847 type PropertiesVMResponse struct {
848 MemoryStats *MemoryStats `protobuf:"bytes,1,opt,name=memory_stats,json=memoryStats,proto3" json:"memory_stats,omitempty"`
849 ProcessorStats *ProcessorStats `protobuf:"bytes,2,opt,name=processor_stats,json=processorStats,proto3" json:"processor_stats,omitempty"`
850 XXX_NoUnkeyedLiteral struct{} `json:"-"`
851 XXX_unrecognized []byte `json:"-"`
852 XXX_sizecache int32 `json:"-"`
853 }
854
855 func (m *PropertiesVMResponse) Reset() { *m = PropertiesVMResponse{} }
856 func (*PropertiesVMResponse) ProtoMessage() {}
857 func (*PropertiesVMResponse) Descriptor() ([]byte, []int) {
858 return fileDescriptor_272f12cfdaa6c7c8, []int{14}
859 }
860 func (m *PropertiesVMResponse) XXX_Unmarshal(b []byte) error {
861 return m.Unmarshal(b)
862 }
863 func (m *PropertiesVMResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
864 if deterministic {
865 return xxx_messageInfo_PropertiesVMResponse.Marshal(b, m, deterministic)
866 } else {
867 b = b[:cap(b)]
868 n, err := m.MarshalToSizedBuffer(b)
869 if err != nil {
870 return nil, err
871 }
872 return b[:n], nil
873 }
874 }
875 func (m *PropertiesVMResponse) XXX_Merge(src proto.Message) {
876 xxx_messageInfo_PropertiesVMResponse.Merge(m, src)
877 }
878 func (m *PropertiesVMResponse) XXX_Size() int {
879 return m.Size()
880 }
881 func (m *PropertiesVMResponse) XXX_DiscardUnknown() {
882 xxx_messageInfo_PropertiesVMResponse.DiscardUnknown(m)
883 }
884
885 var xxx_messageInfo_PropertiesVMResponse proto.InternalMessageInfo
886
887 type CapabilitiesVMResponse struct {
888 SupportedResources []*CapabilitiesVMResponse_SupportedResource `protobuf:"bytes,1,rep,name=supported_resources,json=supportedResources,proto3" json:"supported_resources,omitempty"`
889 SupportedGuestOs []CapabilitiesVMResponse_SupportedGuestOS `protobuf:"varint,2,rep,packed,name=supported_guest_os,json=supportedGuestOs,proto3,enum=vmservice.CapabilitiesVMResponse_SupportedGuestOS" json:"supported_guest_os,omitempty"`
890 XXX_NoUnkeyedLiteral struct{} `json:"-"`
891 XXX_unrecognized []byte `json:"-"`
892 XXX_sizecache int32 `json:"-"`
893 }
894
895 func (m *CapabilitiesVMResponse) Reset() { *m = CapabilitiesVMResponse{} }
896 func (*CapabilitiesVMResponse) ProtoMessage() {}
897 func (*CapabilitiesVMResponse) Descriptor() ([]byte, []int) {
898 return fileDescriptor_272f12cfdaa6c7c8, []int{15}
899 }
900 func (m *CapabilitiesVMResponse) XXX_Unmarshal(b []byte) error {
901 return m.Unmarshal(b)
902 }
903 func (m *CapabilitiesVMResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
904 if deterministic {
905 return xxx_messageInfo_CapabilitiesVMResponse.Marshal(b, m, deterministic)
906 } else {
907 b = b[:cap(b)]
908 n, err := m.MarshalToSizedBuffer(b)
909 if err != nil {
910 return nil, err
911 }
912 return b[:n], nil
913 }
914 }
915 func (m *CapabilitiesVMResponse) XXX_Merge(src proto.Message) {
916 xxx_messageInfo_CapabilitiesVMResponse.Merge(m, src)
917 }
918 func (m *CapabilitiesVMResponse) XXX_Size() int {
919 return m.Size()
920 }
921 func (m *CapabilitiesVMResponse) XXX_DiscardUnknown() {
922 xxx_messageInfo_CapabilitiesVMResponse.DiscardUnknown(m)
923 }
924
925 var xxx_messageInfo_CapabilitiesVMResponse proto.InternalMessageInfo
926
927 type CapabilitiesVMResponse_SupportedResource struct {
928 Add bool `protobuf:"varint,1,opt,name=Add,proto3" json:"Add,omitempty"`
929 Remove bool `protobuf:"varint,2,opt,name=Remove,proto3" json:"Remove,omitempty"`
930 Update bool `protobuf:"varint,3,opt,name=Update,proto3" json:"Update,omitempty"`
931 Resource CapabilitiesVMResponse_Resource `protobuf:"varint,4,opt,name=resource,proto3,enum=vmservice.CapabilitiesVMResponse_Resource" json:"resource,omitempty"`
932 XXX_NoUnkeyedLiteral struct{} `json:"-"`
933 XXX_unrecognized []byte `json:"-"`
934 XXX_sizecache int32 `json:"-"`
935 }
936
937 func (m *CapabilitiesVMResponse_SupportedResource) Reset() {
938 *m = CapabilitiesVMResponse_SupportedResource{}
939 }
940 func (*CapabilitiesVMResponse_SupportedResource) ProtoMessage() {}
941 func (*CapabilitiesVMResponse_SupportedResource) Descriptor() ([]byte, []int) {
942 return fileDescriptor_272f12cfdaa6c7c8, []int{15, 0}
943 }
944 func (m *CapabilitiesVMResponse_SupportedResource) XXX_Unmarshal(b []byte) error {
945 return m.Unmarshal(b)
946 }
947 func (m *CapabilitiesVMResponse_SupportedResource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
948 if deterministic {
949 return xxx_messageInfo_CapabilitiesVMResponse_SupportedResource.Marshal(b, m, deterministic)
950 } else {
951 b = b[:cap(b)]
952 n, err := m.MarshalToSizedBuffer(b)
953 if err != nil {
954 return nil, err
955 }
956 return b[:n], nil
957 }
958 }
959 func (m *CapabilitiesVMResponse_SupportedResource) XXX_Merge(src proto.Message) {
960 xxx_messageInfo_CapabilitiesVMResponse_SupportedResource.Merge(m, src)
961 }
962 func (m *CapabilitiesVMResponse_SupportedResource) XXX_Size() int {
963 return m.Size()
964 }
965 func (m *CapabilitiesVMResponse_SupportedResource) XXX_DiscardUnknown() {
966 xxx_messageInfo_CapabilitiesVMResponse_SupportedResource.DiscardUnknown(m)
967 }
968
969 var xxx_messageInfo_CapabilitiesVMResponse_SupportedResource proto.InternalMessageInfo
970
971 type HVSocketListen struct {
972 ServiceID string `protobuf:"bytes,1,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"`
973
974
975 ListenerPath string `protobuf:"bytes,2,opt,name=listener_path,json=listenerPath,proto3" json:"listener_path,omitempty"`
976 XXX_NoUnkeyedLiteral struct{} `json:"-"`
977 XXX_unrecognized []byte `json:"-"`
978 XXX_sizecache int32 `json:"-"`
979 }
980
981 func (m *HVSocketListen) Reset() { *m = HVSocketListen{} }
982 func (*HVSocketListen) ProtoMessage() {}
983 func (*HVSocketListen) Descriptor() ([]byte, []int) {
984 return fileDescriptor_272f12cfdaa6c7c8, []int{16}
985 }
986 func (m *HVSocketListen) XXX_Unmarshal(b []byte) error {
987 return m.Unmarshal(b)
988 }
989 func (m *HVSocketListen) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
990 if deterministic {
991 return xxx_messageInfo_HVSocketListen.Marshal(b, m, deterministic)
992 } else {
993 b = b[:cap(b)]
994 n, err := m.MarshalToSizedBuffer(b)
995 if err != nil {
996 return nil, err
997 }
998 return b[:n], nil
999 }
1000 }
1001 func (m *HVSocketListen) XXX_Merge(src proto.Message) {
1002 xxx_messageInfo_HVSocketListen.Merge(m, src)
1003 }
1004 func (m *HVSocketListen) XXX_Size() int {
1005 return m.Size()
1006 }
1007 func (m *HVSocketListen) XXX_DiscardUnknown() {
1008 xxx_messageInfo_HVSocketListen.DiscardUnknown(m)
1009 }
1010
1011 var xxx_messageInfo_HVSocketListen proto.InternalMessageInfo
1012
1013 type VSockListen struct {
1014 Port uint32 `protobuf:"varint,1,opt,name=port,proto3" json:"port,omitempty"`
1015 ListenerPath string `protobuf:"bytes,2,opt,name=listener_path,json=listenerPath,proto3" json:"listener_path,omitempty"`
1016 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1017 XXX_unrecognized []byte `json:"-"`
1018 XXX_sizecache int32 `json:"-"`
1019 }
1020
1021 func (m *VSockListen) Reset() { *m = VSockListen{} }
1022 func (*VSockListen) ProtoMessage() {}
1023 func (*VSockListen) Descriptor() ([]byte, []int) {
1024 return fileDescriptor_272f12cfdaa6c7c8, []int{17}
1025 }
1026 func (m *VSockListen) XXX_Unmarshal(b []byte) error {
1027 return m.Unmarshal(b)
1028 }
1029 func (m *VSockListen) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1030 if deterministic {
1031 return xxx_messageInfo_VSockListen.Marshal(b, m, deterministic)
1032 } else {
1033 b = b[:cap(b)]
1034 n, err := m.MarshalToSizedBuffer(b)
1035 if err != nil {
1036 return nil, err
1037 }
1038 return b[:n], nil
1039 }
1040 }
1041 func (m *VSockListen) XXX_Merge(src proto.Message) {
1042 xxx_messageInfo_VSockListen.Merge(m, src)
1043 }
1044 func (m *VSockListen) XXX_Size() int {
1045 return m.Size()
1046 }
1047 func (m *VSockListen) XXX_DiscardUnknown() {
1048 xxx_messageInfo_VSockListen.DiscardUnknown(m)
1049 }
1050
1051 var xxx_messageInfo_VSockListen proto.InternalMessageInfo
1052
1053 type VMSocketRequest struct {
1054 Type ModifyType `protobuf:"varint,1,opt,name=type,proto3,enum=vmservice.ModifyType" json:"type,omitempty"`
1055
1056
1057
1058 Config isVMSocketRequest_Config `protobuf_oneof:"Config"`
1059 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1060 XXX_unrecognized []byte `json:"-"`
1061 XXX_sizecache int32 `json:"-"`
1062 }
1063
1064 func (m *VMSocketRequest) Reset() { *m = VMSocketRequest{} }
1065 func (*VMSocketRequest) ProtoMessage() {}
1066 func (*VMSocketRequest) Descriptor() ([]byte, []int) {
1067 return fileDescriptor_272f12cfdaa6c7c8, []int{18}
1068 }
1069 func (m *VMSocketRequest) XXX_Unmarshal(b []byte) error {
1070 return m.Unmarshal(b)
1071 }
1072 func (m *VMSocketRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1073 if deterministic {
1074 return xxx_messageInfo_VMSocketRequest.Marshal(b, m, deterministic)
1075 } else {
1076 b = b[:cap(b)]
1077 n, err := m.MarshalToSizedBuffer(b)
1078 if err != nil {
1079 return nil, err
1080 }
1081 return b[:n], nil
1082 }
1083 }
1084 func (m *VMSocketRequest) XXX_Merge(src proto.Message) {
1085 xxx_messageInfo_VMSocketRequest.Merge(m, src)
1086 }
1087 func (m *VMSocketRequest) XXX_Size() int {
1088 return m.Size()
1089 }
1090 func (m *VMSocketRequest) XXX_DiscardUnknown() {
1091 xxx_messageInfo_VMSocketRequest.DiscardUnknown(m)
1092 }
1093
1094 var xxx_messageInfo_VMSocketRequest proto.InternalMessageInfo
1095
1096 type isVMSocketRequest_Config interface {
1097 isVMSocketRequest_Config()
1098 MarshalTo([]byte) (int, error)
1099 Size() int
1100 }
1101
1102 type VMSocketRequest_HvsocketList struct {
1103 HvsocketList *HVSocketListen `protobuf:"bytes,2,opt,name=hvsocket_list,json=hvsocketList,proto3,oneof" json:"hvsocket_list,omitempty"`
1104 }
1105 type VMSocketRequest_VsockListen struct {
1106 VsockListen *VSockListen `protobuf:"bytes,3,opt,name=vsock_listen,json=vsockListen,proto3,oneof" json:"vsock_listen,omitempty"`
1107 }
1108
1109 func (*VMSocketRequest_HvsocketList) isVMSocketRequest_Config() {}
1110 func (*VMSocketRequest_VsockListen) isVMSocketRequest_Config() {}
1111
1112 func (m *VMSocketRequest) GetConfig() isVMSocketRequest_Config {
1113 if m != nil {
1114 return m.Config
1115 }
1116 return nil
1117 }
1118
1119 func (m *VMSocketRequest) GetHvsocketList() *HVSocketListen {
1120 if x, ok := m.GetConfig().(*VMSocketRequest_HvsocketList); ok {
1121 return x.HvsocketList
1122 }
1123 return nil
1124 }
1125
1126 func (m *VMSocketRequest) GetVsockListen() *VSockListen {
1127 if x, ok := m.GetConfig().(*VMSocketRequest_VsockListen); ok {
1128 return x.VsockListen
1129 }
1130 return nil
1131 }
1132
1133
1134 func (*VMSocketRequest) XXX_OneofWrappers() []interface{} {
1135 return []interface{}{
1136 (*VMSocketRequest_HvsocketList)(nil),
1137 (*VMSocketRequest_VsockListen)(nil),
1138 }
1139 }
1140
1141 type SCSIDisk struct {
1142 Controller uint32 `protobuf:"varint,1,opt,name=controller,proto3" json:"controller,omitempty"`
1143 Lun uint32 `protobuf:"varint,2,opt,name=lun,proto3" json:"lun,omitempty"`
1144 HostPath string `protobuf:"bytes,3,opt,name=host_path,json=hostPath,proto3" json:"host_path,omitempty"`
1145 Type DiskType `protobuf:"varint,4,opt,name=type,proto3,enum=vmservice.DiskType" json:"type,omitempty"`
1146 ReadOnly bool `protobuf:"varint,5,opt,name=read_only,json=readOnly,proto3" json:"read_only,omitempty"`
1147 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1148 XXX_unrecognized []byte `json:"-"`
1149 XXX_sizecache int32 `json:"-"`
1150 }
1151
1152 func (m *SCSIDisk) Reset() { *m = SCSIDisk{} }
1153 func (*SCSIDisk) ProtoMessage() {}
1154 func (*SCSIDisk) Descriptor() ([]byte, []int) {
1155 return fileDescriptor_272f12cfdaa6c7c8, []int{19}
1156 }
1157 func (m *SCSIDisk) XXX_Unmarshal(b []byte) error {
1158 return m.Unmarshal(b)
1159 }
1160 func (m *SCSIDisk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1161 if deterministic {
1162 return xxx_messageInfo_SCSIDisk.Marshal(b, m, deterministic)
1163 } else {
1164 b = b[:cap(b)]
1165 n, err := m.MarshalToSizedBuffer(b)
1166 if err != nil {
1167 return nil, err
1168 }
1169 return b[:n], nil
1170 }
1171 }
1172 func (m *SCSIDisk) XXX_Merge(src proto.Message) {
1173 xxx_messageInfo_SCSIDisk.Merge(m, src)
1174 }
1175 func (m *SCSIDisk) XXX_Size() int {
1176 return m.Size()
1177 }
1178 func (m *SCSIDisk) XXX_DiscardUnknown() {
1179 xxx_messageInfo_SCSIDisk.DiscardUnknown(m)
1180 }
1181
1182 var xxx_messageInfo_SCSIDisk proto.InternalMessageInfo
1183
1184 type VPMEMDisk struct {
1185 HostPath string `protobuf:"bytes,1,opt,name=host_path,json=hostPath,proto3" json:"host_path,omitempty"`
1186 Type DiskType `protobuf:"varint,2,opt,name=type,proto3,enum=vmservice.DiskType" json:"type,omitempty"`
1187 ReadOnly bool `protobuf:"varint,3,opt,name=read_only,json=readOnly,proto3" json:"read_only,omitempty"`
1188 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1189 XXX_unrecognized []byte `json:"-"`
1190 XXX_sizecache int32 `json:"-"`
1191 }
1192
1193 func (m *VPMEMDisk) Reset() { *m = VPMEMDisk{} }
1194 func (*VPMEMDisk) ProtoMessage() {}
1195 func (*VPMEMDisk) Descriptor() ([]byte, []int) {
1196 return fileDescriptor_272f12cfdaa6c7c8, []int{20}
1197 }
1198 func (m *VPMEMDisk) XXX_Unmarshal(b []byte) error {
1199 return m.Unmarshal(b)
1200 }
1201 func (m *VPMEMDisk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1202 if deterministic {
1203 return xxx_messageInfo_VPMEMDisk.Marshal(b, m, deterministic)
1204 } else {
1205 b = b[:cap(b)]
1206 n, err := m.MarshalToSizedBuffer(b)
1207 if err != nil {
1208 return nil, err
1209 }
1210 return b[:n], nil
1211 }
1212 }
1213 func (m *VPMEMDisk) XXX_Merge(src proto.Message) {
1214 xxx_messageInfo_VPMEMDisk.Merge(m, src)
1215 }
1216 func (m *VPMEMDisk) XXX_Size() int {
1217 return m.Size()
1218 }
1219 func (m *VPMEMDisk) XXX_DiscardUnknown() {
1220 xxx_messageInfo_VPMEMDisk.DiscardUnknown(m)
1221 }
1222
1223 var xxx_messageInfo_VPMEMDisk proto.InternalMessageInfo
1224
1225 type NICConfig struct {
1226 NicID string `protobuf:"bytes,1,opt,name=nic_id,json=nicId,proto3" json:"nic_id,omitempty"`
1227 PortID string `protobuf:"bytes,2,opt,name=port_id,json=portId,proto3" json:"port_id,omitempty"`
1228 MacAddress string `protobuf:"bytes,3,opt,name=mac_address,json=macAddress,proto3" json:"mac_address,omitempty"`
1229 SwitchID string `protobuf:"bytes,4,opt,name=switch_id,json=switchId,proto3" json:"switch_id,omitempty"`
1230
1231 NicName string `protobuf:"bytes,5,opt,name=nic_name,json=nicName,proto3" json:"nic_name,omitempty"`
1232 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1233 XXX_unrecognized []byte `json:"-"`
1234 XXX_sizecache int32 `json:"-"`
1235 }
1236
1237 func (m *NICConfig) Reset() { *m = NICConfig{} }
1238 func (*NICConfig) ProtoMessage() {}
1239 func (*NICConfig) Descriptor() ([]byte, []int) {
1240 return fileDescriptor_272f12cfdaa6c7c8, []int{21}
1241 }
1242 func (m *NICConfig) XXX_Unmarshal(b []byte) error {
1243 return m.Unmarshal(b)
1244 }
1245 func (m *NICConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1246 if deterministic {
1247 return xxx_messageInfo_NICConfig.Marshal(b, m, deterministic)
1248 } else {
1249 b = b[:cap(b)]
1250 n, err := m.MarshalToSizedBuffer(b)
1251 if err != nil {
1252 return nil, err
1253 }
1254 return b[:n], nil
1255 }
1256 }
1257 func (m *NICConfig) XXX_Merge(src proto.Message) {
1258 xxx_messageInfo_NICConfig.Merge(m, src)
1259 }
1260 func (m *NICConfig) XXX_Size() int {
1261 return m.Size()
1262 }
1263 func (m *NICConfig) XXX_DiscardUnknown() {
1264 xxx_messageInfo_NICConfig.DiscardUnknown(m)
1265 }
1266
1267 var xxx_messageInfo_NICConfig proto.InternalMessageInfo
1268
1269 type WindowsPCIDevice struct {
1270
1271 InstanceID string `protobuf:"bytes,1,opt,name=instance_id,json=instanceId,proto3" json:"instance_id,omitempty"`
1272 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1273 XXX_unrecognized []byte `json:"-"`
1274 XXX_sizecache int32 `json:"-"`
1275 }
1276
1277 func (m *WindowsPCIDevice) Reset() { *m = WindowsPCIDevice{} }
1278 func (*WindowsPCIDevice) ProtoMessage() {}
1279 func (*WindowsPCIDevice) Descriptor() ([]byte, []int) {
1280 return fileDescriptor_272f12cfdaa6c7c8, []int{22}
1281 }
1282 func (m *WindowsPCIDevice) XXX_Unmarshal(b []byte) error {
1283 return m.Unmarshal(b)
1284 }
1285 func (m *WindowsPCIDevice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1286 if deterministic {
1287 return xxx_messageInfo_WindowsPCIDevice.Marshal(b, m, deterministic)
1288 } else {
1289 b = b[:cap(b)]
1290 n, err := m.MarshalToSizedBuffer(b)
1291 if err != nil {
1292 return nil, err
1293 }
1294 return b[:n], nil
1295 }
1296 }
1297 func (m *WindowsPCIDevice) XXX_Merge(src proto.Message) {
1298 xxx_messageInfo_WindowsPCIDevice.Merge(m, src)
1299 }
1300 func (m *WindowsPCIDevice) XXX_Size() int {
1301 return m.Size()
1302 }
1303 func (m *WindowsPCIDevice) XXX_DiscardUnknown() {
1304 xxx_messageInfo_WindowsPCIDevice.DiscardUnknown(m)
1305 }
1306
1307 var xxx_messageInfo_WindowsPCIDevice proto.InternalMessageInfo
1308
1309 type ModifyMemoryRequest struct {
1310 MemoryMb uint64 `protobuf:"varint,1,opt,name=memory_mb,json=memoryMb,proto3" json:"memory_mb,omitempty"`
1311 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1312 XXX_unrecognized []byte `json:"-"`
1313 XXX_sizecache int32 `json:"-"`
1314 }
1315
1316 func (m *ModifyMemoryRequest) Reset() { *m = ModifyMemoryRequest{} }
1317 func (*ModifyMemoryRequest) ProtoMessage() {}
1318 func (*ModifyMemoryRequest) Descriptor() ([]byte, []int) {
1319 return fileDescriptor_272f12cfdaa6c7c8, []int{23}
1320 }
1321 func (m *ModifyMemoryRequest) XXX_Unmarshal(b []byte) error {
1322 return m.Unmarshal(b)
1323 }
1324 func (m *ModifyMemoryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1325 if deterministic {
1326 return xxx_messageInfo_ModifyMemoryRequest.Marshal(b, m, deterministic)
1327 } else {
1328 b = b[:cap(b)]
1329 n, err := m.MarshalToSizedBuffer(b)
1330 if err != nil {
1331 return nil, err
1332 }
1333 return b[:n], nil
1334 }
1335 }
1336 func (m *ModifyMemoryRequest) XXX_Merge(src proto.Message) {
1337 xxx_messageInfo_ModifyMemoryRequest.Merge(m, src)
1338 }
1339 func (m *ModifyMemoryRequest) XXX_Size() int {
1340 return m.Size()
1341 }
1342 func (m *ModifyMemoryRequest) XXX_DiscardUnknown() {
1343 xxx_messageInfo_ModifyMemoryRequest.DiscardUnknown(m)
1344 }
1345
1346 var xxx_messageInfo_ModifyMemoryRequest proto.InternalMessageInfo
1347
1348 type ModifyProcessorRequest struct {
1349
1350 ProcessorIndex uint32 `protobuf:"varint,1,opt,name=processor_index,json=processorIndex,proto3" json:"processor_index,omitempty"`
1351 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1352 XXX_unrecognized []byte `json:"-"`
1353 XXX_sizecache int32 `json:"-"`
1354 }
1355
1356 func (m *ModifyProcessorRequest) Reset() { *m = ModifyProcessorRequest{} }
1357 func (*ModifyProcessorRequest) ProtoMessage() {}
1358 func (*ModifyProcessorRequest) Descriptor() ([]byte, []int) {
1359 return fileDescriptor_272f12cfdaa6c7c8, []int{24}
1360 }
1361 func (m *ModifyProcessorRequest) XXX_Unmarshal(b []byte) error {
1362 return m.Unmarshal(b)
1363 }
1364 func (m *ModifyProcessorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1365 if deterministic {
1366 return xxx_messageInfo_ModifyProcessorRequest.Marshal(b, m, deterministic)
1367 } else {
1368 b = b[:cap(b)]
1369 n, err := m.MarshalToSizedBuffer(b)
1370 if err != nil {
1371 return nil, err
1372 }
1373 return b[:n], nil
1374 }
1375 }
1376 func (m *ModifyProcessorRequest) XXX_Merge(src proto.Message) {
1377 xxx_messageInfo_ModifyProcessorRequest.Merge(m, src)
1378 }
1379 func (m *ModifyProcessorRequest) XXX_Size() int {
1380 return m.Size()
1381 }
1382 func (m *ModifyProcessorRequest) XXX_DiscardUnknown() {
1383 xxx_messageInfo_ModifyProcessorRequest.DiscardUnknown(m)
1384 }
1385
1386 var xxx_messageInfo_ModifyProcessorRequest proto.InternalMessageInfo
1387
1388 type ModifyProcessorConfigRequest struct {
1389 ProcessorWeight uint32 `protobuf:"varint,1,opt,name=processor_weight,json=processorWeight,proto3" json:"processor_weight,omitempty"`
1390 ProcessorLimit uint32 `protobuf:"varint,2,opt,name=processor_limit,json=processorLimit,proto3" json:"processor_limit,omitempty"`
1391 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1392 XXX_unrecognized []byte `json:"-"`
1393 XXX_sizecache int32 `json:"-"`
1394 }
1395
1396 func (m *ModifyProcessorConfigRequest) Reset() { *m = ModifyProcessorConfigRequest{} }
1397 func (*ModifyProcessorConfigRequest) ProtoMessage() {}
1398 func (*ModifyProcessorConfigRequest) Descriptor() ([]byte, []int) {
1399 return fileDescriptor_272f12cfdaa6c7c8, []int{25}
1400 }
1401 func (m *ModifyProcessorConfigRequest) XXX_Unmarshal(b []byte) error {
1402 return m.Unmarshal(b)
1403 }
1404 func (m *ModifyProcessorConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1405 if deterministic {
1406 return xxx_messageInfo_ModifyProcessorConfigRequest.Marshal(b, m, deterministic)
1407 } else {
1408 b = b[:cap(b)]
1409 n, err := m.MarshalToSizedBuffer(b)
1410 if err != nil {
1411 return nil, err
1412 }
1413 return b[:n], nil
1414 }
1415 }
1416 func (m *ModifyProcessorConfigRequest) XXX_Merge(src proto.Message) {
1417 xxx_messageInfo_ModifyProcessorConfigRequest.Merge(m, src)
1418 }
1419 func (m *ModifyProcessorConfigRequest) XXX_Size() int {
1420 return m.Size()
1421 }
1422 func (m *ModifyProcessorConfigRequest) XXX_DiscardUnknown() {
1423 xxx_messageInfo_ModifyProcessorConfigRequest.DiscardUnknown(m)
1424 }
1425
1426 var xxx_messageInfo_ModifyProcessorConfigRequest proto.InternalMessageInfo
1427
1428 type ModifyResourceRequest struct {
1429 Type ModifyType `protobuf:"varint,1,opt,name=type,proto3,enum=vmservice.ModifyType" json:"type,omitempty"`
1430
1431
1432
1433
1434
1435
1436
1437
1438 Resource isModifyResourceRequest_Resource `protobuf_oneof:"resource"`
1439 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1440 XXX_unrecognized []byte `json:"-"`
1441 XXX_sizecache int32 `json:"-"`
1442 }
1443
1444 func (m *ModifyResourceRequest) Reset() { *m = ModifyResourceRequest{} }
1445 func (*ModifyResourceRequest) ProtoMessage() {}
1446 func (*ModifyResourceRequest) Descriptor() ([]byte, []int) {
1447 return fileDescriptor_272f12cfdaa6c7c8, []int{26}
1448 }
1449 func (m *ModifyResourceRequest) XXX_Unmarshal(b []byte) error {
1450 return m.Unmarshal(b)
1451 }
1452 func (m *ModifyResourceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1453 if deterministic {
1454 return xxx_messageInfo_ModifyResourceRequest.Marshal(b, m, deterministic)
1455 } else {
1456 b = b[:cap(b)]
1457 n, err := m.MarshalToSizedBuffer(b)
1458 if err != nil {
1459 return nil, err
1460 }
1461 return b[:n], nil
1462 }
1463 }
1464 func (m *ModifyResourceRequest) XXX_Merge(src proto.Message) {
1465 xxx_messageInfo_ModifyResourceRequest.Merge(m, src)
1466 }
1467 func (m *ModifyResourceRequest) XXX_Size() int {
1468 return m.Size()
1469 }
1470 func (m *ModifyResourceRequest) XXX_DiscardUnknown() {
1471 xxx_messageInfo_ModifyResourceRequest.DiscardUnknown(m)
1472 }
1473
1474 var xxx_messageInfo_ModifyResourceRequest proto.InternalMessageInfo
1475
1476 type isModifyResourceRequest_Resource interface {
1477 isModifyResourceRequest_Resource()
1478 MarshalTo([]byte) (int, error)
1479 Size() int
1480 }
1481
1482 type ModifyResourceRequest_Processor struct {
1483 Processor *ModifyProcessorRequest `protobuf:"bytes,2,opt,name=processor,proto3,oneof" json:"processor,omitempty"`
1484 }
1485 type ModifyResourceRequest_ProcessorConfig struct {
1486 ProcessorConfig *ModifyProcessorConfigRequest `protobuf:"bytes,3,opt,name=processor_config,json=processorConfig,proto3,oneof" json:"processor_config,omitempty"`
1487 }
1488 type ModifyResourceRequest_Memory struct {
1489 Memory *ModifyMemoryRequest `protobuf:"bytes,4,opt,name=memory,proto3,oneof" json:"memory,omitempty"`
1490 }
1491 type ModifyResourceRequest_ScsiDisk struct {
1492 ScsiDisk *SCSIDisk `protobuf:"bytes,5,opt,name=scsi_disk,json=scsiDisk,proto3,oneof" json:"scsi_disk,omitempty"`
1493 }
1494 type ModifyResourceRequest_VpmemDisk struct {
1495 VpmemDisk *VPMEMDisk `protobuf:"bytes,6,opt,name=vpmem_disk,json=vpmemDisk,proto3,oneof" json:"vpmem_disk,omitempty"`
1496 }
1497 type ModifyResourceRequest_NicConfig struct {
1498 NicConfig *NICConfig `protobuf:"bytes,7,opt,name=nic_config,json=nicConfig,proto3,oneof" json:"nic_config,omitempty"`
1499 }
1500 type ModifyResourceRequest_WindowsDevice struct {
1501 WindowsDevice *WindowsPCIDevice `protobuf:"bytes,8,opt,name=windows_device,json=windowsDevice,proto3,oneof" json:"windows_device,omitempty"`
1502 }
1503
1504 func (*ModifyResourceRequest_Processor) isModifyResourceRequest_Resource() {}
1505 func (*ModifyResourceRequest_ProcessorConfig) isModifyResourceRequest_Resource() {}
1506 func (*ModifyResourceRequest_Memory) isModifyResourceRequest_Resource() {}
1507 func (*ModifyResourceRequest_ScsiDisk) isModifyResourceRequest_Resource() {}
1508 func (*ModifyResourceRequest_VpmemDisk) isModifyResourceRequest_Resource() {}
1509 func (*ModifyResourceRequest_NicConfig) isModifyResourceRequest_Resource() {}
1510 func (*ModifyResourceRequest_WindowsDevice) isModifyResourceRequest_Resource() {}
1511
1512 func (m *ModifyResourceRequest) GetResource() isModifyResourceRequest_Resource {
1513 if m != nil {
1514 return m.Resource
1515 }
1516 return nil
1517 }
1518
1519 func (m *ModifyResourceRequest) GetProcessor() *ModifyProcessorRequest {
1520 if x, ok := m.GetResource().(*ModifyResourceRequest_Processor); ok {
1521 return x.Processor
1522 }
1523 return nil
1524 }
1525
1526 func (m *ModifyResourceRequest) GetProcessorConfig() *ModifyProcessorConfigRequest {
1527 if x, ok := m.GetResource().(*ModifyResourceRequest_ProcessorConfig); ok {
1528 return x.ProcessorConfig
1529 }
1530 return nil
1531 }
1532
1533 func (m *ModifyResourceRequest) GetMemory() *ModifyMemoryRequest {
1534 if x, ok := m.GetResource().(*ModifyResourceRequest_Memory); ok {
1535 return x.Memory
1536 }
1537 return nil
1538 }
1539
1540 func (m *ModifyResourceRequest) GetScsiDisk() *SCSIDisk {
1541 if x, ok := m.GetResource().(*ModifyResourceRequest_ScsiDisk); ok {
1542 return x.ScsiDisk
1543 }
1544 return nil
1545 }
1546
1547 func (m *ModifyResourceRequest) GetVpmemDisk() *VPMEMDisk {
1548 if x, ok := m.GetResource().(*ModifyResourceRequest_VpmemDisk); ok {
1549 return x.VpmemDisk
1550 }
1551 return nil
1552 }
1553
1554 func (m *ModifyResourceRequest) GetNicConfig() *NICConfig {
1555 if x, ok := m.GetResource().(*ModifyResourceRequest_NicConfig); ok {
1556 return x.NicConfig
1557 }
1558 return nil
1559 }
1560
1561 func (m *ModifyResourceRequest) GetWindowsDevice() *WindowsPCIDevice {
1562 if x, ok := m.GetResource().(*ModifyResourceRequest_WindowsDevice); ok {
1563 return x.WindowsDevice
1564 }
1565 return nil
1566 }
1567
1568
1569 func (*ModifyResourceRequest) XXX_OneofWrappers() []interface{} {
1570 return []interface{}{
1571 (*ModifyResourceRequest_Processor)(nil),
1572 (*ModifyResourceRequest_ProcessorConfig)(nil),
1573 (*ModifyResourceRequest_Memory)(nil),
1574 (*ModifyResourceRequest_ScsiDisk)(nil),
1575 (*ModifyResourceRequest_VpmemDisk)(nil),
1576 (*ModifyResourceRequest_NicConfig)(nil),
1577 (*ModifyResourceRequest_WindowsDevice)(nil),
1578 }
1579 }
1580
1581 func init() {
1582 proto.RegisterEnum("vmservice.ModifyType", ModifyType_name, ModifyType_value)
1583 proto.RegisterEnum("vmservice.DiskType", DiskType_name, DiskType_value)
1584 proto.RegisterEnum("vmservice.PropertiesVMRequest_PropertiesType", PropertiesVMRequest_PropertiesType_name, PropertiesVMRequest_PropertiesType_value)
1585 proto.RegisterEnum("vmservice.CapabilitiesVMResponse_Resource", CapabilitiesVMResponse_Resource_name, CapabilitiesVMResponse_Resource_value)
1586 proto.RegisterEnum("vmservice.CapabilitiesVMResponse_SupportedGuestOS", CapabilitiesVMResponse_SupportedGuestOS_name, CapabilitiesVMResponse_SupportedGuestOS_value)
1587 proto.RegisterType((*DirectBoot)(nil), "vmservice.DirectBoot")
1588 proto.RegisterType((*UEFI)(nil), "vmservice.UEFI")
1589 proto.RegisterType((*MemoryConfig)(nil), "vmservice.MemoryConfig")
1590 proto.RegisterType((*ProcessorConfig)(nil), "vmservice.ProcessorConfig")
1591 proto.RegisterType((*DevicesConfig)(nil), "vmservice.DevicesConfig")
1592 proto.RegisterType((*VMConfig)(nil), "vmservice.VMConfig")
1593 proto.RegisterMapType((map[string]string)(nil), "vmservice.VMConfig.ExtraDataEntry")
1594 proto.RegisterType((*WindowsOptions)(nil), "vmservice.WindowsOptions")
1595 proto.RegisterType((*SerialConfig)(nil), "vmservice.SerialConfig")
1596 proto.RegisterType((*SerialConfig_Config)(nil), "vmservice.SerialConfig.Config")
1597 proto.RegisterType((*CreateVMRequest)(nil), "vmservice.CreateVMRequest")
1598 proto.RegisterType((*InspectVMRequest)(nil), "vmservice.InspectVMRequest")
1599 proto.RegisterType((*InspectVMResponse)(nil), "vmservice.InspectVMResponse")
1600 proto.RegisterType((*MemoryStats)(nil), "vmservice.MemoryStats")
1601 proto.RegisterType((*ProcessorStats)(nil), "vmservice.ProcessorStats")
1602 proto.RegisterType((*PropertiesVMRequest)(nil), "vmservice.PropertiesVMRequest")
1603 proto.RegisterType((*PropertiesVMResponse)(nil), "vmservice.PropertiesVMResponse")
1604 proto.RegisterType((*CapabilitiesVMResponse)(nil), "vmservice.CapabilitiesVMResponse")
1605 proto.RegisterType((*CapabilitiesVMResponse_SupportedResource)(nil), "vmservice.CapabilitiesVMResponse.SupportedResource")
1606 proto.RegisterType((*HVSocketListen)(nil), "vmservice.HVSocketListen")
1607 proto.RegisterType((*VSockListen)(nil), "vmservice.VSockListen")
1608 proto.RegisterType((*VMSocketRequest)(nil), "vmservice.VMSocketRequest")
1609 proto.RegisterType((*SCSIDisk)(nil), "vmservice.SCSIDisk")
1610 proto.RegisterType((*VPMEMDisk)(nil), "vmservice.VPMEMDisk")
1611 proto.RegisterType((*NICConfig)(nil), "vmservice.NICConfig")
1612 proto.RegisterType((*WindowsPCIDevice)(nil), "vmservice.WindowsPCIDevice")
1613 proto.RegisterType((*ModifyMemoryRequest)(nil), "vmservice.ModifyMemoryRequest")
1614 proto.RegisterType((*ModifyProcessorRequest)(nil), "vmservice.ModifyProcessorRequest")
1615 proto.RegisterType((*ModifyProcessorConfigRequest)(nil), "vmservice.ModifyProcessorConfigRequest")
1616 proto.RegisterType((*ModifyResourceRequest)(nil), "vmservice.ModifyResourceRequest")
1617 }
1618
1619 func init() {
1620 proto.RegisterFile("github.com/Microsoft/hcsshim/internal/vmservice/vmservice.proto", fileDescriptor_272f12cfdaa6c7c8)
1621 }
1622
1623 var fileDescriptor_272f12cfdaa6c7c8 = []byte{
1624
1625 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x58, 0xcf, 0x73, 0xdb, 0xc6,
1626 0xf5, 0x27, 0x28, 0x8a, 0x22, 0x1f, 0x7f, 0x88, 0x59, 0x39, 0x8e, 0x22, 0x67, 0x24, 0x07, 0x99,
1627 0x8c, 0x13, 0x27, 0x91, 0xbe, 0x5f, 0xba, 0xe9, 0xd8, 0xae, 0x9b, 0x54, 0x24, 0x65, 0x93, 0x8d,
1628 0x69, 0x29, 0xa0, 0x4d, 0xd7, 0xb9, 0x20, 0x10, 0xb0, 0x22, 0x77, 0x04, 0x60, 0x69, 0xec, 0x42,
1629 0xb2, 0x6e, 0x9d, 0xe9, 0xa1, 0xed, 0xa5, 0xb7, 0x1e, 0x3b, 0xfd, 0x2f, 0x3a, 0xd3, 0x6b, 0x67,
1630 0x3a, 0x93, 0x63, 0x8f, 0xbd, 0xd4, 0xd3, 0xe8, 0xde, 0x53, 0xff, 0x81, 0xce, 0xfe, 0x00, 0x09,
1631 0x90, 0x92, 0x13, 0xfb, 0x86, 0x7d, 0xfb, 0x79, 0x6f, 0xdf, 0xbe, 0xb7, 0xef, 0x17, 0xe0, 0xcb,
1632 0x11, 0xe1, 0xe3, 0xf8, 0x70, 0xdb, 0xa5, 0xc1, 0x4e, 0x9f, 0xb8, 0x11, 0x65, 0xf4, 0x88, 0xef,
1633 0x8c, 0x5d, 0xc6, 0xc6, 0x24, 0xd8, 0x21, 0x21, 0xc7, 0x51, 0xe8, 0xf8, 0x3b, 0x27, 0x01, 0xc3,
1634 0xd1, 0x09, 0x71, 0xf1, 0xec, 0x6b, 0x7b, 0x12, 0x51, 0x4e, 0x51, 0x79, 0x4a, 0xd8, 0xb8, 0x36,
1635 0xa2, 0x74, 0xe4, 0xe3, 0x1d, 0xb9, 0x71, 0x18, 0x1f, 0xed, 0xe0, 0x60, 0xc2, 0xcf, 0x14, 0x6e,
1636 0xe3, 0xbd, 0xf9, 0x4d, 0xc6, 0xa3, 0xd8, 0xe5, 0x6a, 0xd7, 0x8c, 0x01, 0x3a, 0x24, 0xc2, 0x2e,
1637 0x6f, 0x51, 0xca, 0xd1, 0x16, 0x54, 0x8e, 0x71, 0x14, 0x62, 0xdf, 0x9e, 0x38, 0x7c, 0xbc, 0x6e,
1638 0x5c, 0x37, 0x3e, 0x2a, 0x5b, 0xa0, 0x48, 0x07, 0x0e, 0x1f, 0x0b, 0x00, 0x09, 0x09, 0x8f, 0x3c,
1639 0x05, 0xc8, 0x2b, 0x80, 0x22, 0x49, 0xc0, 0x87, 0x50, 0xd7, 0x12, 0xdc, 0xc0, 0xf3, 0x49, 0x88,
1640 0xd7, 0x97, 0x24, 0xa6, 0xa6, 0xa8, 0x6d, 0x45, 0x34, 0x9f, 0x43, 0xe1, 0xc9, 0xde, 0xfd, 0x1e,
1641 0xfa, 0x00, 0x6a, 0x47, 0x24, 0x0a, 0x4e, 0x9d, 0x08, 0xa7, 0x8f, 0xac, 0x26, 0xc4, 0xe4, 0x50,
1642 0x0f, 0x8b, 0x8b, 0x66, 0x0e, 0x55, 0x24, 0x09, 0xf8, 0x00, 0x6a, 0x74, 0xc2, 0x09, 0x0d, 0x1d,
1643 0xdf, 0xf6, 0x1c, 0xee, 0xe8, 0x33, 0xab, 0x09, 0xb1, 0xe3, 0x70, 0xc7, 0xfc, 0x4f, 0x1e, 0xaa,
1644 0x7d, 0x1c, 0xd0, 0xe8, 0xac, 0x4d, 0xc3, 0x23, 0x32, 0x42, 0xd7, 0xa0, 0x1c, 0xc8, 0xb5, 0x1d,
1645 0x1c, 0xca, 0x73, 0x0b, 0x56, 0x49, 0x11, 0xfa, 0x87, 0xe8, 0x63, 0x68, 0x38, 0xbe, 0x4f, 0x4f,
1646 0x6d, 0x7a, 0x82, 0x23, 0x97, 0x06, 0x01, 0xe1, 0xf2, 0xe0, 0x92, 0xb5, 0x2a, 0xe9, 0xfb, 0x53,
1647 0x32, 0xba, 0x01, 0xab, 0x1e, 0x3e, 0xc2, 0x51, 0x84, 0x3d, 0x5b, 0x23, 0x97, 0x24, 0xb2, 0x9e,
1648 0x90, 0xdb, 0x0a, 0xf8, 0x2e, 0x94, 0xc6, 0x94, 0xdb, 0x63, 0x12, 0xf2, 0xf5, 0x82, 0x44, 0xac,
1649 0x8c, 0x29, 0xef, 0x92, 0x90, 0x0b, 0x5d, 0x5c, 0xea, 0x7b, 0x6a, 0x6f, 0x59, 0xee, 0x95, 0x04,
1650 0x41, 0x6e, 0xde, 0x84, 0xb7, 0xe4, 0xa6, 0x47, 0x98, 0xeb, 0x44, 0x1a, 0x54, 0x54, 0xca, 0x88,
1651 0x8d, 0x8e, 0xa2, 0x6b, 0x2c, 0x12, 0x5a, 0x07, 0x01, 0xa1, 0xf6, 0xc8, 0x99, 0xd8, 0x24, 0x14,
1652 0xb7, 0x5b, 0x91, 0xb7, 0xab, 0xfb, 0xf4, 0xb4, 0x1f, 0x10, 0xfa, 0xc0, 0x99, 0xf4, 0xc2, 0xfe,
1653 0x21, 0xda, 0x86, 0x2b, 0x63, 0x32, 0x1a, 0x2b, 0xf0, 0xa1, 0xc3, 0xb0, 0x46, 0x97, 0x24, 0xba,
1654 0x21, 0xf6, 0x04, 0xbc, 0xe5, 0x30, 0x2c, 0xf1, 0x9f, 0xc2, 0xda, 0x0c, 0x3f, 0x13, 0x5e, 0x96,
1655 0xf0, 0xd5, 0x04, 0xae, 0xa5, 0x9b, 0x7f, 0x30, 0x60, 0xf5, 0x20, 0xa2, 0x2e, 0x66, 0x8c, 0x46,
1656 0xda, 0xe4, 0x37, 0x60, 0x75, 0x92, 0x90, 0x6c, 0x97, 0xc6, 0x21, 0x97, 0x86, 0xaf, 0x59, 0xf5,
1657 0xc9, 0x0c, 0x19, 0x87, 0x5c, 0x98, 0x7f, 0x06, 0x3c, 0xc5, 0x64, 0x34, 0x56, 0xe6, 0xaf, 0x59,
1658 0x33, 0x01, 0x4f, 0x25, 0x39, 0x2b, 0xd3, 0x27, 0x89, 0xf9, 0xd3, 0x32, 0x1f, 0x0a, 0xaa, 0xf9,
1659 0x5f, 0x03, 0x6a, 0x1d, 0xf9, 0x68, 0x98, 0x56, 0xa7, 0x09, 0xc0, 0x5c, 0x46, 0x84, 0x61, 0x8f,
1660 0xd9, 0xba, 0x71, 0x7d, 0xe9, 0xa3, 0x4a, 0x73, 0x6d, 0x7b, 0x16, 0x68, 0x83, 0xf6, 0xa0, 0xd7,
1661 0x21, 0xec, 0xd8, 0x2a, 0x0b, 0x98, 0xf8, 0x62, 0xe8, 0x73, 0xa8, 0x9c, 0x4c, 0x02, 0x1c, 0x68,
1662 0xa6, 0xbc, 0x64, 0xba, 0x92, 0x62, 0x1a, 0x1e, 0xf4, 0xf7, 0xfa, 0x92, 0x0b, 0x24, 0x50, 0xb1,
1663 0xdd, 0x02, 0x08, 0x89, 0x6b, 0xbb, 0xf2, 0xe0, 0xf5, 0xa5, 0x05, 0xae, 0x47, 0xbd, 0xb6, 0x52,
1664 0xca, 0x2a, 0x87, 0xc4, 0xd5, 0xfa, 0xb5, 0xa0, 0x7e, 0x4a, 0x42, 0x8f, 0x9e, 0x32, 0x5b, 0xbd,
1665 0xf6, 0xf5, 0x82, 0x64, 0xbc, 0x96, 0x62, 0x7c, 0xaa, 0x00, 0x07, 0xed, 0x9e, 0xba, 0x9b, 0x55,
1666 0xd3, 0x2c, 0x6a, 0x69, 0xfe, 0xad, 0x00, 0xa5, 0x61, 0x5f, 0x0b, 0xbc, 0x07, 0x35, 0xfd, 0xe4,
1667 0xb5, 0x22, 0xc2, 0xfa, 0x95, 0xe6, 0x3b, 0x29, 0x79, 0xe9, 0x10, 0xb1, 0xaa, 0x41, 0x3a, 0x60,
1668 0xf6, 0xd2, 0x4e, 0xd1, 0x02, 0xf2, 0x52, 0xc0, 0x46, 0x4a, 0xc0, 0x9c, 0xcf, 0x53, 0x0e, 0xd3,
1669 0x62, 0xbe, 0x84, 0xba, 0xba, 0x0d, 0x9b, 0x99, 0x43, 0x08, 0x59, 0x4f, 0x09, 0xc9, 0xf8, 0xc9,
1670 0xaa, 0x79, 0x19, 0xb7, 0xdd, 0x83, 0x1a, 0xc3, 0x11, 0x71, 0xfc, 0x84, 0xbf, 0xb0, 0x70, 0x8b,
1671 0x81, 0xdc, 0x4f, 0x6e, 0xc1, 0x52, 0x2b, 0x74, 0x1b, 0x2a, 0x9e, 0xcc, 0x78, 0xf6, 0x21, 0xa5,
1672 0x2a, 0xd8, 0x2a, 0xcd, 0xb7, 0xd3, 0x67, 0x4f, 0xf3, 0x61, 0x37, 0x67, 0x81, 0x37, 0xcb, 0x8e,
1673 0x1f, 0x42, 0x21, 0xc6, 0x47, 0x44, 0x86, 0x5e, 0xa5, 0xb9, 0x9a, 0x62, 0x11, 0xb9, 0xac, 0x9b,
1674 0xb3, 0xe4, 0x36, 0x6a, 0xc1, 0x6a, 0xe2, 0x35, 0x95, 0x80, 0x98, 0x8c, 0xbf, 0x4a, 0xf3, 0xdd,
1675 0x45, 0xb7, 0xed, 0x2b, 0x80, 0x95, 0xf8, 0x59, 0xaf, 0xd1, 0x2e, 0x00, 0x7e, 0xc1, 0x23, 0x47,
1676 0xa5, 0xb3, 0x92, 0xf4, 0xba, 0x99, 0x7e, 0x64, 0xda, 0xa3, 0xdb, 0x7b, 0x02, 0x25, 0xf2, 0xdb,
1677 0x5e, 0xc8, 0xa3, 0x33, 0xab, 0x8c, 0x93, 0xf5, 0xc6, 0x3d, 0xa8, 0x67, 0x37, 0x51, 0x03, 0x96,
1678 0x8e, 0xf1, 0x99, 0x4e, 0xb1, 0xe2, 0x13, 0x5d, 0x81, 0xe5, 0x13, 0xc7, 0x8f, 0xb1, 0xce, 0xa9,
1679 0x6a, 0x71, 0x37, 0x7f, 0xdb, 0x68, 0x55, 0x01, 0xc4, 0x9d, 0xd5, 0x29, 0x66, 0x0b, 0xea, 0x59,
1680 0x85, 0xd1, 0xff, 0x41, 0xd5, 0x9d, 0xc4, 0xf6, 0x28, 0xa2, 0xf1, 0xc4, 0x26, 0x9e, 0xca, 0x9f,
1681 0xad, 0xfa, 0xf9, 0xcb, 0x2d, 0x68, 0x4f, 0xe2, 0x07, 0x82, 0xdc, 0xeb, 0x58, 0xe0, 0x26, 0xdf,
1682 0x9e, 0xf9, 0x1b, 0x03, 0xaa, 0x69, 0xb7, 0xa0, 0x9f, 0xc0, 0xf2, 0x84, 0x46, 0x9c, 0xe9, 0x68,
1683 0xd8, 0xbc, 0xc4, 0x7d, 0xdb, 0xda, 0x8b, 0x0a, 0xbc, 0xf1, 0x73, 0x28, 0x6a, 0x7e, 0x04, 0x05,
1684 0x41, 0xd2, 0x19, 0x44, 0x7e, 0x8b, 0x52, 0xc1, 0xa8, 0x7b, 0x8c, 0x79, 0xa6, 0x54, 0x28, 0x92,
1685 0x28, 0x15, 0xe6, 0xb7, 0xb0, 0xda, 0x8e, 0xb0, 0xc3, 0xf1, 0xb0, 0x6f, 0xe1, 0xe7, 0x31, 0x66,
1686 0x1c, 0x7d, 0x02, 0xc5, 0x4c, 0x34, 0xac, 0x5d, 0x60, 0x67, 0x4b, 0x43, 0xd0, 0x75, 0x28, 0xfa,
1687 0x74, 0x24, 0x6e, 0x2c, 0x65, 0xb7, 0xca, 0xe7, 0x2f, 0xb7, 0x96, 0x1f, 0xd2, 0x51, 0xaf, 0x63,
1688 0x2d, 0xfb, 0x74, 0xd4, 0xf3, 0xcc, 0xaf, 0xa1, 0xd1, 0x0b, 0xd9, 0x04, 0xbb, 0x7c, 0x76, 0xc4,
1689 0x15, 0x58, 0x7e, 0x1e, 0xe3, 0x28, 0xb1, 0xbd, 0x5a, 0x88, 0xcc, 0x15, 0x61, 0x37, 0x8e, 0x18,
1690 0xa1, 0xa1, 0xce, 0x5c, 0x2a, 0xc7, 0xd5, 0xa7, 0x64, 0x95, 0xb9, 0xda, 0xf0, 0x56, 0x4a, 0x24,
1691 0x9b, 0xd0, 0x90, 0x61, 0xb4, 0x0d, 0xc5, 0x08, 0xb3, 0xd8, 0xe7, 0x5a, 0xed, 0xab, 0xdb, 0xaa,
1692 0xd0, 0x6f, 0x27, 0x85, 0x7e, 0x7b, 0x28, 0xbc, 0x69, 0x69, 0x94, 0xf9, 0x17, 0x03, 0x2a, 0x2a,
1693 0xb8, 0x07, 0xdc, 0xe1, 0x4c, 0x54, 0x95, 0x53, 0x1a, 0x1d, 0x93, 0x70, 0x64, 0x33, 0xcc, 0xed,
1694 0xc3, 0x33, 0x8e, 0x99, 0x2e, 0x83, 0xab, 0x7a, 0x63, 0x80, 0x79, 0x4b, 0x90, 0x65, 0x35, 0x3c,
1695 0x71, 0x88, 0xef, 0x1c, 0xfa, 0xd8, 0x56, 0x39, 0x41, 0xaa, 0x5a, 0xb0, 0x56, 0xa7, 0x74, 0x25,
1696 0x5b, 0x5d, 0x4a, 0x98, 0x0f, 0x7b, 0x09, 0x72, 0x49, 0x55, 0x9f, 0x84, 0x3c, 0x03, 0x3a, 0x8c,
1697 0x91, 0x51, 0x38, 0x03, 0x16, 0x14, 0x30, 0x21, 0x2b, 0xa0, 0x79, 0x17, 0xea, 0xd3, 0x9c, 0xa2,
1698 0x54, 0xff, 0x08, 0x1a, 0x9c, 0x72, 0xc7, 0xb7, 0xa3, 0x38, 0xe4, 0x24, 0xc0, 0x76, 0x98, 0x68,
1699 0x5e, 0x97, 0x74, 0x4b, 0x91, 0x1f, 0x31, 0xf3, 0xb7, 0x06, 0xac, 0x1d, 0x44, 0x74, 0x82, 0x23,
1700 0x4e, 0x30, 0x9b, 0x39, 0xa4, 0x0d, 0xcb, 0xfc, 0x6c, 0x82, 0x55, 0xd2, 0xaf, 0x37, 0x3f, 0xcb,
1701 0xe6, 0xaf, 0x79, 0x78, 0x8a, 0xf6, 0xf8, 0x6c, 0x82, 0x2d, 0xc5, 0x6b, 0x7e, 0x22, 0x15, 0x4b,
1702 0x6d, 0x20, 0x80, 0xa2, 0x52, 0xba, 0x91, 0x43, 0x35, 0x28, 0x4f, 0xd5, 0x6e, 0x18, 0xe6, 0x1f,
1703 0x0d, 0xb8, 0x92, 0x15, 0xad, 0xfd, 0x78, 0x07, 0x74, 0x96, 0xb5, 0x99, 0xb8, 0xdc, 0xd4, 0x9b,
1704 0xf3, 0x29, 0x59, 0x5e, 0xdd, 0xaa, 0x04, 0x29, 0x17, 0xb6, 0xd2, 0xa5, 0x4f, 0x71, 0xe7, 0x17,
1705 0x32, 0x4d, 0xd6, 0x76, 0xa9, 0xaa, 0x28, 0xd7, 0xe6, 0xef, 0x0a, 0x70, 0xb5, 0xed, 0x4c, 0x9c,
1706 0x43, 0xe2, 0x93, 0x39, 0xcd, 0x3c, 0x58, 0x63, 0xf1, 0x44, 0xc4, 0x15, 0xf6, 0xec, 0x08, 0x33,
1707 0x1a, 0x47, 0x2e, 0x4e, 0xea, 0xe4, 0xad, 0xd4, 0x11, 0x17, 0xf3, 0x6f, 0x0f, 0x12, 0x66, 0x4b,
1708 0xf3, 0x5a, 0x88, 0xcd, 0x93, 0x18, 0xfa, 0x16, 0x66, 0x54, 0x7b, 0x24, 0xcc, 0x6d, 0x53, 0x55,
1709 0x57, 0xeb, 0xcd, 0xe6, 0x6b, 0x1c, 0xf2, 0x40, 0xb0, 0xee, 0x0f, 0xac, 0x06, 0xcb, 0x52, 0xd8,
1710 0xc6, 0x9f, 0x0c, 0x78, 0x6b, 0x41, 0x17, 0x91, 0x0d, 0x77, 0x3d, 0x95, 0xb8, 0x4a, 0x96, 0xf8,
1711 0x44, 0x57, 0xa1, 0x68, 0xe1, 0x80, 0x9e, 0x60, 0xdd, 0xe9, 0xe9, 0x95, 0xa0, 0x3f, 0x99, 0x78,
1712 0x0e, 0xc7, 0xba, 0xaf, 0xd3, 0x2b, 0x74, 0x1f, 0x4a, 0x89, 0x55, 0xe4, 0xd3, 0xad, 0x37, 0x6f,
1713 0xfe, 0xb0, 0xbe, 0x53, 0x5b, 0x4c, 0x79, 0xcd, 0x6f, 0xa0, 0x34, 0xd5, 0xaa, 0x0c, 0xcb, 0x43,
1714 0xd1, 0x35, 0x34, 0x72, 0xa8, 0x04, 0x85, 0x81, 0xcb, 0x48, 0xc3, 0x10, 0x5f, 0xc3, 0x89, 0x4b,
1715 0x1a, 0x79, 0xb1, 0x7d, 0xe0, 0x3b, 0xe1, 0x9d, 0xc6, 0x92, 0x44, 0xf6, 0x1f, 0x11, 0xb7, 0x51,
1716 0x48, 0x3d, 0xbb, 0xe5, 0xec, 0xb3, 0x2b, 0x9a, 0x37, 0xa1, 0x31, 0x6f, 0x21, 0x54, 0x81, 0x15,
1717 0x9d, 0xcd, 0x1b, 0x39, 0x21, 0xe6, 0x21, 0x09, 0xe3, 0x17, 0x0d, 0xc3, 0x74, 0xa1, 0xde, 0x1d,
1718 0x0e, 0x64, 0xae, 0x7c, 0x48, 0x18, 0xc7, 0x21, 0xfa, 0x14, 0x40, 0x5f, 0x27, 0xc9, 0xf1, 0xe5,
1719 0x56, 0xed, 0xfc, 0xe5, 0x56, 0x79, 0xa0, 0xa8, 0xbd, 0x8e, 0x55, 0xd6, 0x80, 0x9e, 0x27, 0xda,
1720 0x70, 0x5f, 0xf2, 0xe1, 0x28, 0x9d, 0x7e, 0xab, 0x09, 0x51, 0x26, 0xe0, 0xfb, 0x50, 0x91, 0x67,
1721 0xe8, 0x13, 0x2e, 0x4a, 0xe2, 0x3f, 0x4a, 0xce, 0xdf, 0x0d, 0x58, 0x1d, 0xf6, 0x95, 0xb6, 0x49,
1722 0x54, 0x7f, 0x0c, 0x05, 0x11, 0x99, 0x52, 0x58, 0x3d, 0x53, 0xd3, 0xfb, 0xd4, 0x23, 0x47, 0x67,
1723 0x32, 0x78, 0x25, 0x04, 0xfd, 0x02, 0x6a, 0xe3, 0x13, 0x5d, 0x2a, 0x84, 0xdc, 0x0b, 0x02, 0x27,
1724 0x6b, 0x8b, 0x6e, 0xce, 0xaa, 0x26, 0x1c, 0x82, 0x82, 0x7e, 0x06, 0x55, 0xb9, 0xb4, 0x95, 0x5a,
1725 0xba, 0x89, 0x49, 0xc7, 0x6d, 0xea, 0x9e, 0xdd, 0x9c, 0x55, 0x91, 0x68, 0xb5, 0x6c, 0x95, 0x92,
1726 0x2a, 0x66, 0xfe, 0xd9, 0x80, 0x52, 0xd2, 0x67, 0xa2, 0x4d, 0x00, 0x97, 0x86, 0x3c, 0xa2, 0xbe,
1727 0x8f, 0x23, 0x6d, 0x93, 0x14, 0x45, 0xbc, 0x59, 0x3f, 0x0e, 0x75, 0x95, 0x10, 0x9f, 0x62, 0x70,
1728 0x18, 0x53, 0xa6, 0xcb, 0x9d, 0x1a, 0x7b, 0x4a, 0x82, 0x20, 0xe7, 0xa2, 0x1b, 0xda, 0x1e, 0xea,
1729 0x71, 0xae, 0x65, 0x7a, 0x1c, 0x76, 0x9c, 0xb2, 0xc6, 0x35, 0x28, 0x47, 0xd8, 0xf1, 0x6c, 0x1a,
1730 0xfa, 0x67, 0xc9, 0xf8, 0x21, 0x08, 0xfb, 0xa1, 0x7f, 0x66, 0x86, 0x50, 0x9e, 0xf6, 0xb4, 0xd9,
1731 0xf3, 0x8c, 0x4b, 0xce, 0xcb, 0xbf, 0xd6, 0x79, 0x4b, 0x73, 0xe7, 0xfd, 0xd5, 0x80, 0xf2, 0xb4,
1732 0x1d, 0x16, 0x05, 0x57, 0x34, 0xce, 0xd3, 0xe7, 0x27, 0x0b, 0xee, 0x23, 0xe2, 0x8a, 0x82, 0x1b,
1733 0x12, 0x57, 0x3e, 0xbb, 0x15, 0xf1, 0x6c, 0x66, 0x35, 0x19, 0xce, 0x5f, 0x6e, 0x15, 0x0f, 0x68,
1734 0xc4, 0x7b, 0x1d, 0xab, 0x28, 0xb6, 0x7a, 0x9e, 0x68, 0x0c, 0x02, 0xc7, 0xb5, 0x1d, 0xcf, 0x8b,
1735 0x30, 0x63, 0xda, 0x52, 0x10, 0x38, 0xee, 0xae, 0xa2, 0xa0, 0x8f, 0xa1, 0xcc, 0x4e, 0x09, 0x77,
1736 0xc7, 0x42, 0x4e, 0x41, 0xca, 0xa9, 0x9e, 0xbf, 0xdc, 0x2a, 0x0d, 0x24, 0xb1, 0xd7, 0xb1, 0x4a,
1737 0x6a, 0xbb, 0xe7, 0x89, 0x39, 0x4e, 0xa8, 0x14, 0x3a, 0x01, 0x96, 0xc6, 0x2a, 0x5b, 0x2b, 0x21,
1738 0x71, 0x1f, 0x39, 0x01, 0x36, 0xdb, 0xd0, 0x98, 0x6f, 0xc8, 0xd1, 0x8e, 0x98, 0x99, 0x19, 0x77,
1739 0xc2, 0x74, 0x14, 0xc9, 0x4e, 0xa9, 0xa7, 0xc9, 0xa2, 0x53, 0x4a, 0x20, 0x3d, 0xcf, 0x6c, 0xc2,
1740 0x9a, 0x7a, 0xaf, 0x2a, 0xa8, 0x93, 0xd7, 0xfd, 0xaa, 0x79, 0xd5, 0xdc, 0x85, 0xab, 0x8a, 0x67,
1741 0x1a, 0xfc, 0x09, 0x5b, 0x66, 0x3e, 0x22, 0xa1, 0x87, 0x5f, 0x2c, 0xcc, 0x5c, 0x3d, 0x41, 0x35,
1742 0x23, 0x78, 0x6f, 0x4e, 0x84, 0xee, 0x7d, 0xa6, 0xd1, 0xb5, 0x38, 0x93, 0x19, 0x3f, 0x7a, 0x26,
1743 0xcb, 0x5f, 0x38, 0x93, 0xfd, 0xbe, 0x00, 0x6f, 0xab, 0x43, 0xa7, 0x79, 0xf1, 0xf5, 0x63, 0x79,
1744 0x17, 0xca, 0x53, 0xb1, 0x3a, 0x8e, 0xdf, 0x5f, 0xc0, 0xcf, 0xdb, 0xa5, 0x9b, 0xb3, 0x66, 0x5c,
1745 0xe8, 0xf1, 0x05, 0xa3, 0x8d, 0x0a, 0xe8, 0x1b, 0x97, 0x4b, 0xca, 0x98, 0xa7, 0x9b, 0x5b, 0x9c,
1746 0x74, 0x6e, 0x43, 0x31, 0xd5, 0xd9, 0x64, 0x5b, 0xdc, 0x0b, 0x3c, 0xdc, 0xcd, 0x59, 0x1a, 0x8f,
1747 0x9a, 0x50, 0x9e, 0x4e, 0xa6, 0x7a, 0x44, 0xb9, 0x68, 0x30, 0xed, 0xe6, 0xac, 0x52, 0x32, 0x9a,
1748 0xa2, 0xcf, 0x01, 0x66, 0x93, 0xa9, 0x1e, 0x52, 0x2e, 0x1c, 0x4c, 0xc5, 0xd5, 0xa7, 0xa3, 0xa9,
1749 0x60, 0x4b, 0x4d, 0xa6, 0x2b, 0x0b, 0x6c, 0xd3, 0x50, 0x14, 0x6c, 0xb3, 0xd9, 0xb4, 0xb3, 0x30,
1750 0x9b, 0x96, 0x24, 0xeb, 0xab, 0x66, 0xd3, 0x6e, 0x6e, 0x6e, 0x3a, 0x6d, 0xc1, 0xac, 0x84, 0xde,
1751 0xfc, 0x0c, 0x60, 0xe6, 0x5a, 0xb4, 0x02, 0x4b, 0xbb, 0x9d, 0x4e, 0x23, 0x27, 0x8a, 0x9b, 0xb5,
1752 0xd7, 0xdf, 0x1f, 0xee, 0x35, 0x0c, 0xf1, 0xfd, 0xe4, 0xa0, 0xb3, 0xfb, 0x78, 0xaf, 0x91, 0xbf,
1753 0xf9, 0x0c, 0x4a, 0x49, 0x56, 0x41, 0xef, 0xc0, 0x9a, 0x30, 0x89, 0xdd, 0xe9, 0x0d, 0xbe, 0xb2,
1754 0x1f, 0x3f, 0x3b, 0xd8, 0xb3, 0x87, 0xdd, 0xce, 0xff, 0x37, 0x72, 0x17, 0x6f, 0xfc, 0xaa, 0x61,
1755 0xa0, 0x6b, 0xf0, 0xce, 0xdc, 0xc6, 0x41, 0xf7, 0xd9, 0xa0, 0xd7, 0xde, 0x7d, 0xd8, 0xc8, 0x37,
1756 0xff, 0xb5, 0x0c, 0xf9, 0x61, 0x1f, 0x7d, 0x01, 0xa5, 0x64, 0x56, 0x40, 0xe9, 0x09, 0x77, 0x6e,
1757 0x80, 0xd8, 0x58, 0xec, 0xbc, 0xf7, 0x82, 0x09, 0x3f, 0x43, 0xf7, 0x00, 0x1e, 0x63, 0x27, 0xf2,
1758 0xe8, 0x69, 0x38, 0xec, 0xa3, 0x4b, 0x50, 0x97, 0x72, 0xdf, 0x81, 0x95, 0x03, 0x27, 0x66, 0xf8,
1759 0x0d, 0x58, 0xef, 0xca, 0x86, 0x22, 0x0e, 0xde, 0x84, 0xf7, 0x36, 0x14, 0x9f, 0x3a, 0x84, 0xbf,
1760 0x01, 0xe7, 0x7d, 0x28, 0x4f, 0xa7, 0x14, 0x94, 0x7e, 0x06, 0xf3, 0xe3, 0xd0, 0xc6, 0x7b, 0x17,
1761 0x6f, 0xea, 0xb6, 0xf3, 0x2b, 0xa8, 0x67, 0x7b, 0xa7, 0x4b, 0x35, 0x79, 0xff, 0x07, 0xdb, 0x2d,
1762 0xb4, 0x0f, 0xd5, 0x74, 0xd7, 0x8d, 0x36, 0x5f, 0xdd, 0xe9, 0x6f, 0x6c, 0x5d, 0xba, 0xaf, 0x05,
1763 0xfe, 0x12, 0xea, 0xd9, 0x84, 0x85, 0xae, 0x2f, 0x44, 0xf5, 0x5c, 0x2e, 0xbb, 0xd4, 0x62, 0x5f,
1764 0x40, 0x29, 0x69, 0x61, 0x32, 0x0f, 0x6c, 0xae, 0xaf, 0xb9, 0x94, 0xff, 0xa7, 0x50, 0xf8, 0x3a,
1765 0x26, 0xfc, 0x75, 0x3d, 0xd5, 0xea, 0x7d, 0xf7, 0xfd, 0x66, 0xee, 0x9f, 0xdf, 0x6f, 0xe6, 0x7e,
1766 0x7d, 0xbe, 0x69, 0x7c, 0x77, 0xbe, 0x69, 0xfc, 0xe3, 0x7c, 0xd3, 0xf8, 0xf7, 0xf9, 0xa6, 0xf1,
1767 0xcd, 0xce, 0x6b, 0xfe, 0x95, 0x3e, 0x2c, 0x4a, 0xd1, 0xb7, 0xfe, 0x17, 0x00, 0x00, 0xff, 0xff,
1768 0x29, 0x1c, 0xce, 0x56, 0xcf, 0x16, 0x00, 0x00,
1769 }
1770
1771 func (m *DirectBoot) Marshal() (dAtA []byte, err error) {
1772 size := m.Size()
1773 dAtA = make([]byte, size)
1774 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1775 if err != nil {
1776 return nil, err
1777 }
1778 return dAtA[:n], nil
1779 }
1780
1781 func (m *DirectBoot) MarshalTo(dAtA []byte) (int, error) {
1782 size := m.Size()
1783 return m.MarshalToSizedBuffer(dAtA[:size])
1784 }
1785
1786 func (m *DirectBoot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1787 i := len(dAtA)
1788 _ = i
1789 var l int
1790 _ = l
1791 if m.XXX_unrecognized != nil {
1792 i -= len(m.XXX_unrecognized)
1793 copy(dAtA[i:], m.XXX_unrecognized)
1794 }
1795 if len(m.KernelCmdline) > 0 {
1796 i -= len(m.KernelCmdline)
1797 copy(dAtA[i:], m.KernelCmdline)
1798 i = encodeVarintVmservice(dAtA, i, uint64(len(m.KernelCmdline)))
1799 i--
1800 dAtA[i] = 0x1a
1801 }
1802 if len(m.InitrdPath) > 0 {
1803 i -= len(m.InitrdPath)
1804 copy(dAtA[i:], m.InitrdPath)
1805 i = encodeVarintVmservice(dAtA, i, uint64(len(m.InitrdPath)))
1806 i--
1807 dAtA[i] = 0x12
1808 }
1809 if len(m.KernelPath) > 0 {
1810 i -= len(m.KernelPath)
1811 copy(dAtA[i:], m.KernelPath)
1812 i = encodeVarintVmservice(dAtA, i, uint64(len(m.KernelPath)))
1813 i--
1814 dAtA[i] = 0xa
1815 }
1816 return len(dAtA) - i, nil
1817 }
1818
1819 func (m *UEFI) Marshal() (dAtA []byte, err error) {
1820 size := m.Size()
1821 dAtA = make([]byte, size)
1822 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1823 if err != nil {
1824 return nil, err
1825 }
1826 return dAtA[:n], nil
1827 }
1828
1829 func (m *UEFI) MarshalTo(dAtA []byte) (int, error) {
1830 size := m.Size()
1831 return m.MarshalToSizedBuffer(dAtA[:size])
1832 }
1833
1834 func (m *UEFI) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1835 i := len(dAtA)
1836 _ = i
1837 var l int
1838 _ = l
1839 if m.XXX_unrecognized != nil {
1840 i -= len(m.XXX_unrecognized)
1841 copy(dAtA[i:], m.XXX_unrecognized)
1842 }
1843 if len(m.OptionalData) > 0 {
1844 i -= len(m.OptionalData)
1845 copy(dAtA[i:], m.OptionalData)
1846 i = encodeVarintVmservice(dAtA, i, uint64(len(m.OptionalData)))
1847 i--
1848 dAtA[i] = 0x1a
1849 }
1850 if len(m.DevicePath) > 0 {
1851 i -= len(m.DevicePath)
1852 copy(dAtA[i:], m.DevicePath)
1853 i = encodeVarintVmservice(dAtA, i, uint64(len(m.DevicePath)))
1854 i--
1855 dAtA[i] = 0x12
1856 }
1857 if len(m.FirmwarePath) > 0 {
1858 i -= len(m.FirmwarePath)
1859 copy(dAtA[i:], m.FirmwarePath)
1860 i = encodeVarintVmservice(dAtA, i, uint64(len(m.FirmwarePath)))
1861 i--
1862 dAtA[i] = 0xa
1863 }
1864 return len(dAtA) - i, nil
1865 }
1866
1867 func (m *MemoryConfig) Marshal() (dAtA []byte, err error) {
1868 size := m.Size()
1869 dAtA = make([]byte, size)
1870 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1871 if err != nil {
1872 return nil, err
1873 }
1874 return dAtA[:n], nil
1875 }
1876
1877 func (m *MemoryConfig) MarshalTo(dAtA []byte) (int, error) {
1878 size := m.Size()
1879 return m.MarshalToSizedBuffer(dAtA[:size])
1880 }
1881
1882 func (m *MemoryConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1883 i := len(dAtA)
1884 _ = i
1885 var l int
1886 _ = l
1887 if m.XXX_unrecognized != nil {
1888 i -= len(m.XXX_unrecognized)
1889 copy(dAtA[i:], m.XXX_unrecognized)
1890 }
1891 if m.HighMmioGapInMb != 0 {
1892 i = encodeVarintVmservice(dAtA, i, uint64(m.HighMmioGapInMb))
1893 i--
1894 dAtA[i] = 0x48
1895 }
1896 if m.HighMmioBaseInMb != 0 {
1897 i = encodeVarintVmservice(dAtA, i, uint64(m.HighMmioBaseInMb))
1898 i--
1899 dAtA[i] = 0x40
1900 }
1901 if m.LowMmioGapInMb != 0 {
1902 i = encodeVarintVmservice(dAtA, i, uint64(m.LowMmioGapInMb))
1903 i--
1904 dAtA[i] = 0x38
1905 }
1906 if m.ColdDiscardHint {
1907 i--
1908 if m.ColdDiscardHint {
1909 dAtA[i] = 1
1910 } else {
1911 dAtA[i] = 0
1912 }
1913 i--
1914 dAtA[i] = 0x30
1915 }
1916 if m.ColdHint {
1917 i--
1918 if m.ColdHint {
1919 dAtA[i] = 1
1920 } else {
1921 dAtA[i] = 0
1922 }
1923 i--
1924 dAtA[i] = 0x28
1925 }
1926 if m.HotHint {
1927 i--
1928 if m.HotHint {
1929 dAtA[i] = 1
1930 } else {
1931 dAtA[i] = 0
1932 }
1933 i--
1934 dAtA[i] = 0x20
1935 }
1936 if m.DeferredCommit {
1937 i--
1938 if m.DeferredCommit {
1939 dAtA[i] = 1
1940 } else {
1941 dAtA[i] = 0
1942 }
1943 i--
1944 dAtA[i] = 0x18
1945 }
1946 if m.AllowOvercommit {
1947 i--
1948 if m.AllowOvercommit {
1949 dAtA[i] = 1
1950 } else {
1951 dAtA[i] = 0
1952 }
1953 i--
1954 dAtA[i] = 0x10
1955 }
1956 if m.MemoryMb != 0 {
1957 i = encodeVarintVmservice(dAtA, i, uint64(m.MemoryMb))
1958 i--
1959 dAtA[i] = 0x8
1960 }
1961 return len(dAtA) - i, nil
1962 }
1963
1964 func (m *ProcessorConfig) Marshal() (dAtA []byte, err error) {
1965 size := m.Size()
1966 dAtA = make([]byte, size)
1967 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1968 if err != nil {
1969 return nil, err
1970 }
1971 return dAtA[:n], nil
1972 }
1973
1974 func (m *ProcessorConfig) MarshalTo(dAtA []byte) (int, error) {
1975 size := m.Size()
1976 return m.MarshalToSizedBuffer(dAtA[:size])
1977 }
1978
1979 func (m *ProcessorConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1980 i := len(dAtA)
1981 _ = i
1982 var l int
1983 _ = l
1984 if m.XXX_unrecognized != nil {
1985 i -= len(m.XXX_unrecognized)
1986 copy(dAtA[i:], m.XXX_unrecognized)
1987 }
1988 if m.ProcessorLimit != 0 {
1989 i = encodeVarintVmservice(dAtA, i, uint64(m.ProcessorLimit))
1990 i--
1991 dAtA[i] = 0x18
1992 }
1993 if m.ProcessorWeight != 0 {
1994 i = encodeVarintVmservice(dAtA, i, uint64(m.ProcessorWeight))
1995 i--
1996 dAtA[i] = 0x10
1997 }
1998 if m.ProcessorCount != 0 {
1999 i = encodeVarintVmservice(dAtA, i, uint64(m.ProcessorCount))
2000 i--
2001 dAtA[i] = 0x8
2002 }
2003 return len(dAtA) - i, nil
2004 }
2005
2006 func (m *DevicesConfig) Marshal() (dAtA []byte, err error) {
2007 size := m.Size()
2008 dAtA = make([]byte, size)
2009 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2010 if err != nil {
2011 return nil, err
2012 }
2013 return dAtA[:n], nil
2014 }
2015
2016 func (m *DevicesConfig) MarshalTo(dAtA []byte) (int, error) {
2017 size := m.Size()
2018 return m.MarshalToSizedBuffer(dAtA[:size])
2019 }
2020
2021 func (m *DevicesConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2022 i := len(dAtA)
2023 _ = i
2024 var l int
2025 _ = l
2026 if m.XXX_unrecognized != nil {
2027 i -= len(m.XXX_unrecognized)
2028 copy(dAtA[i:], m.XXX_unrecognized)
2029 }
2030 if len(m.WindowsDevice) > 0 {
2031 for iNdEx := len(m.WindowsDevice) - 1; iNdEx >= 0; iNdEx-- {
2032 {
2033 size, err := m.WindowsDevice[iNdEx].MarshalToSizedBuffer(dAtA[:i])
2034 if err != nil {
2035 return 0, err
2036 }
2037 i -= size
2038 i = encodeVarintVmservice(dAtA, i, uint64(size))
2039 }
2040 i--
2041 dAtA[i] = 0x22
2042 }
2043 }
2044 if len(m.NicConfig) > 0 {
2045 for iNdEx := len(m.NicConfig) - 1; iNdEx >= 0; iNdEx-- {
2046 {
2047 size, err := m.NicConfig[iNdEx].MarshalToSizedBuffer(dAtA[:i])
2048 if err != nil {
2049 return 0, err
2050 }
2051 i -= size
2052 i = encodeVarintVmservice(dAtA, i, uint64(size))
2053 }
2054 i--
2055 dAtA[i] = 0x1a
2056 }
2057 }
2058 if len(m.VpmemDisks) > 0 {
2059 for iNdEx := len(m.VpmemDisks) - 1; iNdEx >= 0; iNdEx-- {
2060 {
2061 size, err := m.VpmemDisks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
2062 if err != nil {
2063 return 0, err
2064 }
2065 i -= size
2066 i = encodeVarintVmservice(dAtA, i, uint64(size))
2067 }
2068 i--
2069 dAtA[i] = 0x12
2070 }
2071 }
2072 if len(m.ScsiDisks) > 0 {
2073 for iNdEx := len(m.ScsiDisks) - 1; iNdEx >= 0; iNdEx-- {
2074 {
2075 size, err := m.ScsiDisks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
2076 if err != nil {
2077 return 0, err
2078 }
2079 i -= size
2080 i = encodeVarintVmservice(dAtA, i, uint64(size))
2081 }
2082 i--
2083 dAtA[i] = 0xa
2084 }
2085 }
2086 return len(dAtA) - i, nil
2087 }
2088
2089 func (m *VMConfig) Marshal() (dAtA []byte, err error) {
2090 size := m.Size()
2091 dAtA = make([]byte, size)
2092 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2093 if err != nil {
2094 return nil, err
2095 }
2096 return dAtA[:n], nil
2097 }
2098
2099 func (m *VMConfig) MarshalTo(dAtA []byte) (int, error) {
2100 size := m.Size()
2101 return m.MarshalToSizedBuffer(dAtA[:size])
2102 }
2103
2104 func (m *VMConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2105 i := len(dAtA)
2106 _ = i
2107 var l int
2108 _ = l
2109 if m.XXX_unrecognized != nil {
2110 i -= len(m.XXX_unrecognized)
2111 copy(dAtA[i:], m.XXX_unrecognized)
2112 }
2113 if len(m.ExtraData) > 0 {
2114 for k := range m.ExtraData {
2115 v := m.ExtraData[k]
2116 baseI := i
2117 i -= len(v)
2118 copy(dAtA[i:], v)
2119 i = encodeVarintVmservice(dAtA, i, uint64(len(v)))
2120 i--
2121 dAtA[i] = 0x12
2122 i -= len(k)
2123 copy(dAtA[i:], k)
2124 i = encodeVarintVmservice(dAtA, i, uint64(len(k)))
2125 i--
2126 dAtA[i] = 0xa
2127 i = encodeVarintVmservice(dAtA, i, uint64(baseI-i))
2128 i--
2129 dAtA[i] = 0x42
2130 }
2131 }
2132 if m.WindowsOptions != nil {
2133 {
2134 size, err := m.WindowsOptions.MarshalToSizedBuffer(dAtA[:i])
2135 if err != nil {
2136 return 0, err
2137 }
2138 i -= size
2139 i = encodeVarintVmservice(dAtA, i, uint64(size))
2140 }
2141 i--
2142 dAtA[i] = 0x3a
2143 }
2144 if m.BootConfig != nil {
2145 {
2146 size := m.BootConfig.Size()
2147 i -= size
2148 if _, err := m.BootConfig.MarshalTo(dAtA[i:]); err != nil {
2149 return 0, err
2150 }
2151 }
2152 }
2153 if m.SerialConfig != nil {
2154 {
2155 size, err := m.SerialConfig.MarshalToSizedBuffer(dAtA[:i])
2156 if err != nil {
2157 return 0, err
2158 }
2159 i -= size
2160 i = encodeVarintVmservice(dAtA, i, uint64(size))
2161 }
2162 i--
2163 dAtA[i] = 0x22
2164 }
2165 if m.DevicesConfig != nil {
2166 {
2167 size, err := m.DevicesConfig.MarshalToSizedBuffer(dAtA[:i])
2168 if err != nil {
2169 return 0, err
2170 }
2171 i -= size
2172 i = encodeVarintVmservice(dAtA, i, uint64(size))
2173 }
2174 i--
2175 dAtA[i] = 0x1a
2176 }
2177 if m.ProcessorConfig != nil {
2178 {
2179 size, err := m.ProcessorConfig.MarshalToSizedBuffer(dAtA[:i])
2180 if err != nil {
2181 return 0, err
2182 }
2183 i -= size
2184 i = encodeVarintVmservice(dAtA, i, uint64(size))
2185 }
2186 i--
2187 dAtA[i] = 0x12
2188 }
2189 if m.MemoryConfig != nil {
2190 {
2191 size, err := m.MemoryConfig.MarshalToSizedBuffer(dAtA[:i])
2192 if err != nil {
2193 return 0, err
2194 }
2195 i -= size
2196 i = encodeVarintVmservice(dAtA, i, uint64(size))
2197 }
2198 i--
2199 dAtA[i] = 0xa
2200 }
2201 return len(dAtA) - i, nil
2202 }
2203
2204 func (m *VMConfig_DirectBoot) MarshalTo(dAtA []byte) (int, error) {
2205 size := m.Size()
2206 return m.MarshalToSizedBuffer(dAtA[:size])
2207 }
2208
2209 func (m *VMConfig_DirectBoot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2210 i := len(dAtA)
2211 if m.DirectBoot != nil {
2212 {
2213 size, err := m.DirectBoot.MarshalToSizedBuffer(dAtA[:i])
2214 if err != nil {
2215 return 0, err
2216 }
2217 i -= size
2218 i = encodeVarintVmservice(dAtA, i, uint64(size))
2219 }
2220 i--
2221 dAtA[i] = 0x2a
2222 }
2223 return len(dAtA) - i, nil
2224 }
2225 func (m *VMConfig_Uefi) MarshalTo(dAtA []byte) (int, error) {
2226 size := m.Size()
2227 return m.MarshalToSizedBuffer(dAtA[:size])
2228 }
2229
2230 func (m *VMConfig_Uefi) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2231 i := len(dAtA)
2232 if m.Uefi != nil {
2233 {
2234 size, err := m.Uefi.MarshalToSizedBuffer(dAtA[:i])
2235 if err != nil {
2236 return 0, err
2237 }
2238 i -= size
2239 i = encodeVarintVmservice(dAtA, i, uint64(size))
2240 }
2241 i--
2242 dAtA[i] = 0x32
2243 }
2244 return len(dAtA) - i, nil
2245 }
2246 func (m *WindowsOptions) Marshal() (dAtA []byte, err error) {
2247 size := m.Size()
2248 dAtA = make([]byte, size)
2249 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2250 if err != nil {
2251 return nil, err
2252 }
2253 return dAtA[:n], nil
2254 }
2255
2256 func (m *WindowsOptions) MarshalTo(dAtA []byte) (int, error) {
2257 size := m.Size()
2258 return m.MarshalToSizedBuffer(dAtA[:size])
2259 }
2260
2261 func (m *WindowsOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2262 i := len(dAtA)
2263 _ = i
2264 var l int
2265 _ = l
2266 if m.XXX_unrecognized != nil {
2267 i -= len(m.XXX_unrecognized)
2268 copy(dAtA[i:], m.XXX_unrecognized)
2269 }
2270 if m.CpuGroupID != 0 {
2271 i = encodeVarintVmservice(dAtA, i, uint64(m.CpuGroupID))
2272 i--
2273 dAtA[i] = 0x8
2274 }
2275 return len(dAtA) - i, nil
2276 }
2277
2278 func (m *SerialConfig) Marshal() (dAtA []byte, err error) {
2279 size := m.Size()
2280 dAtA = make([]byte, size)
2281 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2282 if err != nil {
2283 return nil, err
2284 }
2285 return dAtA[:n], nil
2286 }
2287
2288 func (m *SerialConfig) MarshalTo(dAtA []byte) (int, error) {
2289 size := m.Size()
2290 return m.MarshalToSizedBuffer(dAtA[:size])
2291 }
2292
2293 func (m *SerialConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2294 i := len(dAtA)
2295 _ = i
2296 var l int
2297 _ = l
2298 if m.XXX_unrecognized != nil {
2299 i -= len(m.XXX_unrecognized)
2300 copy(dAtA[i:], m.XXX_unrecognized)
2301 }
2302 if len(m.Ports) > 0 {
2303 for iNdEx := len(m.Ports) - 1; iNdEx >= 0; iNdEx-- {
2304 {
2305 size, err := m.Ports[iNdEx].MarshalToSizedBuffer(dAtA[:i])
2306 if err != nil {
2307 return 0, err
2308 }
2309 i -= size
2310 i = encodeVarintVmservice(dAtA, i, uint64(size))
2311 }
2312 i--
2313 dAtA[i] = 0x1a
2314 }
2315 }
2316 return len(dAtA) - i, nil
2317 }
2318
2319 func (m *SerialConfig_Config) Marshal() (dAtA []byte, err error) {
2320 size := m.Size()
2321 dAtA = make([]byte, size)
2322 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2323 if err != nil {
2324 return nil, err
2325 }
2326 return dAtA[:n], nil
2327 }
2328
2329 func (m *SerialConfig_Config) MarshalTo(dAtA []byte) (int, error) {
2330 size := m.Size()
2331 return m.MarshalToSizedBuffer(dAtA[:size])
2332 }
2333
2334 func (m *SerialConfig_Config) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2335 i := len(dAtA)
2336 _ = i
2337 var l int
2338 _ = l
2339 if m.XXX_unrecognized != nil {
2340 i -= len(m.XXX_unrecognized)
2341 copy(dAtA[i:], m.XXX_unrecognized)
2342 }
2343 if len(m.SocketPath) > 0 {
2344 i -= len(m.SocketPath)
2345 copy(dAtA[i:], m.SocketPath)
2346 i = encodeVarintVmservice(dAtA, i, uint64(len(m.SocketPath)))
2347 i--
2348 dAtA[i] = 0x12
2349 }
2350 if m.Port != 0 {
2351 i = encodeVarintVmservice(dAtA, i, uint64(m.Port))
2352 i--
2353 dAtA[i] = 0x8
2354 }
2355 return len(dAtA) - i, nil
2356 }
2357
2358 func (m *CreateVMRequest) Marshal() (dAtA []byte, err error) {
2359 size := m.Size()
2360 dAtA = make([]byte, size)
2361 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2362 if err != nil {
2363 return nil, err
2364 }
2365 return dAtA[:n], nil
2366 }
2367
2368 func (m *CreateVMRequest) MarshalTo(dAtA []byte) (int, error) {
2369 size := m.Size()
2370 return m.MarshalToSizedBuffer(dAtA[:size])
2371 }
2372
2373 func (m *CreateVMRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2374 i := len(dAtA)
2375 _ = i
2376 var l int
2377 _ = l
2378 if m.XXX_unrecognized != nil {
2379 i -= len(m.XXX_unrecognized)
2380 copy(dAtA[i:], m.XXX_unrecognized)
2381 }
2382 if len(m.LogID) > 0 {
2383 i -= len(m.LogID)
2384 copy(dAtA[i:], m.LogID)
2385 i = encodeVarintVmservice(dAtA, i, uint64(len(m.LogID)))
2386 i--
2387 dAtA[i] = 0x12
2388 }
2389 if m.Config != nil {
2390 {
2391 size, err := m.Config.MarshalToSizedBuffer(dAtA[:i])
2392 if err != nil {
2393 return 0, err
2394 }
2395 i -= size
2396 i = encodeVarintVmservice(dAtA, i, uint64(size))
2397 }
2398 i--
2399 dAtA[i] = 0xa
2400 }
2401 return len(dAtA) - i, nil
2402 }
2403
2404 func (m *InspectVMRequest) Marshal() (dAtA []byte, err error) {
2405 size := m.Size()
2406 dAtA = make([]byte, size)
2407 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2408 if err != nil {
2409 return nil, err
2410 }
2411 return dAtA[:n], nil
2412 }
2413
2414 func (m *InspectVMRequest) MarshalTo(dAtA []byte) (int, error) {
2415 size := m.Size()
2416 return m.MarshalToSizedBuffer(dAtA[:size])
2417 }
2418
2419 func (m *InspectVMRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2420 i := len(dAtA)
2421 _ = i
2422 var l int
2423 _ = l
2424 if m.XXX_unrecognized != nil {
2425 i -= len(m.XXX_unrecognized)
2426 copy(dAtA[i:], m.XXX_unrecognized)
2427 }
2428 if m.RecursionLimit != 0 {
2429 i = encodeVarintVmservice(dAtA, i, uint64(m.RecursionLimit))
2430 i--
2431 dAtA[i] = 0x10
2432 }
2433 if len(m.Query) > 0 {
2434 i -= len(m.Query)
2435 copy(dAtA[i:], m.Query)
2436 i = encodeVarintVmservice(dAtA, i, uint64(len(m.Query)))
2437 i--
2438 dAtA[i] = 0xa
2439 }
2440 return len(dAtA) - i, nil
2441 }
2442
2443 func (m *InspectVMResponse) Marshal() (dAtA []byte, err error) {
2444 size := m.Size()
2445 dAtA = make([]byte, size)
2446 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2447 if err != nil {
2448 return nil, err
2449 }
2450 return dAtA[:n], nil
2451 }
2452
2453 func (m *InspectVMResponse) MarshalTo(dAtA []byte) (int, error) {
2454 size := m.Size()
2455 return m.MarshalToSizedBuffer(dAtA[:size])
2456 }
2457
2458 func (m *InspectVMResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2459 i := len(dAtA)
2460 _ = i
2461 var l int
2462 _ = l
2463 if m.XXX_unrecognized != nil {
2464 i -= len(m.XXX_unrecognized)
2465 copy(dAtA[i:], m.XXX_unrecognized)
2466 }
2467 if m.Result != nil {
2468 {
2469 size, err := m.Result.MarshalToSizedBuffer(dAtA[:i])
2470 if err != nil {
2471 return 0, err
2472 }
2473 i -= size
2474 i = encodeVarintVmservice(dAtA, i, uint64(size))
2475 }
2476 i--
2477 dAtA[i] = 0xa
2478 }
2479 return len(dAtA) - i, nil
2480 }
2481
2482 func (m *MemoryStats) Marshal() (dAtA []byte, err error) {
2483 size := m.Size()
2484 dAtA = make([]byte, size)
2485 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2486 if err != nil {
2487 return nil, err
2488 }
2489 return dAtA[:n], nil
2490 }
2491
2492 func (m *MemoryStats) MarshalTo(dAtA []byte) (int, error) {
2493 size := m.Size()
2494 return m.MarshalToSizedBuffer(dAtA[:size])
2495 }
2496
2497 func (m *MemoryStats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2498 i := len(dAtA)
2499 _ = i
2500 var l int
2501 _ = l
2502 if m.XXX_unrecognized != nil {
2503 i -= len(m.XXX_unrecognized)
2504 copy(dAtA[i:], m.XXX_unrecognized)
2505 }
2506 if m.AssignedMemory != 0 {
2507 i = encodeVarintVmservice(dAtA, i, uint64(m.AssignedMemory))
2508 i--
2509 dAtA[i] = 0x20
2510 }
2511 if m.ReservedMemory != 0 {
2512 i = encodeVarintVmservice(dAtA, i, uint64(m.ReservedMemory))
2513 i--
2514 dAtA[i] = 0x18
2515 }
2516 if m.AvailableMemory != 0 {
2517 i = encodeVarintVmservice(dAtA, i, uint64(m.AvailableMemory))
2518 i--
2519 dAtA[i] = 0x10
2520 }
2521 if m.WorkingSetBytes != 0 {
2522 i = encodeVarintVmservice(dAtA, i, uint64(m.WorkingSetBytes))
2523 i--
2524 dAtA[i] = 0x8
2525 }
2526 return len(dAtA) - i, nil
2527 }
2528
2529 func (m *ProcessorStats) Marshal() (dAtA []byte, err error) {
2530 size := m.Size()
2531 dAtA = make([]byte, size)
2532 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2533 if err != nil {
2534 return nil, err
2535 }
2536 return dAtA[:n], nil
2537 }
2538
2539 func (m *ProcessorStats) MarshalTo(dAtA []byte) (int, error) {
2540 size := m.Size()
2541 return m.MarshalToSizedBuffer(dAtA[:size])
2542 }
2543
2544 func (m *ProcessorStats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2545 i := len(dAtA)
2546 _ = i
2547 var l int
2548 _ = l
2549 if m.XXX_unrecognized != nil {
2550 i -= len(m.XXX_unrecognized)
2551 copy(dAtA[i:], m.XXX_unrecognized)
2552 }
2553 if m.TotalRuntimeNs != 0 {
2554 i = encodeVarintVmservice(dAtA, i, uint64(m.TotalRuntimeNs))
2555 i--
2556 dAtA[i] = 0x8
2557 }
2558 return len(dAtA) - i, nil
2559 }
2560
2561 func (m *PropertiesVMRequest) Marshal() (dAtA []byte, err error) {
2562 size := m.Size()
2563 dAtA = make([]byte, size)
2564 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2565 if err != nil {
2566 return nil, err
2567 }
2568 return dAtA[:n], nil
2569 }
2570
2571 func (m *PropertiesVMRequest) MarshalTo(dAtA []byte) (int, error) {
2572 size := m.Size()
2573 return m.MarshalToSizedBuffer(dAtA[:size])
2574 }
2575
2576 func (m *PropertiesVMRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2577 i := len(dAtA)
2578 _ = i
2579 var l int
2580 _ = l
2581 if m.XXX_unrecognized != nil {
2582 i -= len(m.XXX_unrecognized)
2583 copy(dAtA[i:], m.XXX_unrecognized)
2584 }
2585 if len(m.Types) > 0 {
2586 dAtA11 := make([]byte, len(m.Types)*10)
2587 var j10 int
2588 for _, num := range m.Types {
2589 for num >= 1<<7 {
2590 dAtA11[j10] = uint8(uint64(num)&0x7f | 0x80)
2591 num >>= 7
2592 j10++
2593 }
2594 dAtA11[j10] = uint8(num)
2595 j10++
2596 }
2597 i -= j10
2598 copy(dAtA[i:], dAtA11[:j10])
2599 i = encodeVarintVmservice(dAtA, i, uint64(j10))
2600 i--
2601 dAtA[i] = 0xa
2602 }
2603 return len(dAtA) - i, nil
2604 }
2605
2606 func (m *PropertiesVMResponse) Marshal() (dAtA []byte, err error) {
2607 size := m.Size()
2608 dAtA = make([]byte, size)
2609 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2610 if err != nil {
2611 return nil, err
2612 }
2613 return dAtA[:n], nil
2614 }
2615
2616 func (m *PropertiesVMResponse) MarshalTo(dAtA []byte) (int, error) {
2617 size := m.Size()
2618 return m.MarshalToSizedBuffer(dAtA[:size])
2619 }
2620
2621 func (m *PropertiesVMResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2622 i := len(dAtA)
2623 _ = i
2624 var l int
2625 _ = l
2626 if m.XXX_unrecognized != nil {
2627 i -= len(m.XXX_unrecognized)
2628 copy(dAtA[i:], m.XXX_unrecognized)
2629 }
2630 if m.ProcessorStats != nil {
2631 {
2632 size, err := m.ProcessorStats.MarshalToSizedBuffer(dAtA[:i])
2633 if err != nil {
2634 return 0, err
2635 }
2636 i -= size
2637 i = encodeVarintVmservice(dAtA, i, uint64(size))
2638 }
2639 i--
2640 dAtA[i] = 0x12
2641 }
2642 if m.MemoryStats != nil {
2643 {
2644 size, err := m.MemoryStats.MarshalToSizedBuffer(dAtA[:i])
2645 if err != nil {
2646 return 0, err
2647 }
2648 i -= size
2649 i = encodeVarintVmservice(dAtA, i, uint64(size))
2650 }
2651 i--
2652 dAtA[i] = 0xa
2653 }
2654 return len(dAtA) - i, nil
2655 }
2656
2657 func (m *CapabilitiesVMResponse) Marshal() (dAtA []byte, err error) {
2658 size := m.Size()
2659 dAtA = make([]byte, size)
2660 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2661 if err != nil {
2662 return nil, err
2663 }
2664 return dAtA[:n], nil
2665 }
2666
2667 func (m *CapabilitiesVMResponse) MarshalTo(dAtA []byte) (int, error) {
2668 size := m.Size()
2669 return m.MarshalToSizedBuffer(dAtA[:size])
2670 }
2671
2672 func (m *CapabilitiesVMResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2673 i := len(dAtA)
2674 _ = i
2675 var l int
2676 _ = l
2677 if m.XXX_unrecognized != nil {
2678 i -= len(m.XXX_unrecognized)
2679 copy(dAtA[i:], m.XXX_unrecognized)
2680 }
2681 if len(m.SupportedGuestOs) > 0 {
2682 dAtA15 := make([]byte, len(m.SupportedGuestOs)*10)
2683 var j14 int
2684 for _, num := range m.SupportedGuestOs {
2685 for num >= 1<<7 {
2686 dAtA15[j14] = uint8(uint64(num)&0x7f | 0x80)
2687 num >>= 7
2688 j14++
2689 }
2690 dAtA15[j14] = uint8(num)
2691 j14++
2692 }
2693 i -= j14
2694 copy(dAtA[i:], dAtA15[:j14])
2695 i = encodeVarintVmservice(dAtA, i, uint64(j14))
2696 i--
2697 dAtA[i] = 0x12
2698 }
2699 if len(m.SupportedResources) > 0 {
2700 for iNdEx := len(m.SupportedResources) - 1; iNdEx >= 0; iNdEx-- {
2701 {
2702 size, err := m.SupportedResources[iNdEx].MarshalToSizedBuffer(dAtA[:i])
2703 if err != nil {
2704 return 0, err
2705 }
2706 i -= size
2707 i = encodeVarintVmservice(dAtA, i, uint64(size))
2708 }
2709 i--
2710 dAtA[i] = 0xa
2711 }
2712 }
2713 return len(dAtA) - i, nil
2714 }
2715
2716 func (m *CapabilitiesVMResponse_SupportedResource) Marshal() (dAtA []byte, err error) {
2717 size := m.Size()
2718 dAtA = make([]byte, size)
2719 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2720 if err != nil {
2721 return nil, err
2722 }
2723 return dAtA[:n], nil
2724 }
2725
2726 func (m *CapabilitiesVMResponse_SupportedResource) MarshalTo(dAtA []byte) (int, error) {
2727 size := m.Size()
2728 return m.MarshalToSizedBuffer(dAtA[:size])
2729 }
2730
2731 func (m *CapabilitiesVMResponse_SupportedResource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2732 i := len(dAtA)
2733 _ = i
2734 var l int
2735 _ = l
2736 if m.XXX_unrecognized != nil {
2737 i -= len(m.XXX_unrecognized)
2738 copy(dAtA[i:], m.XXX_unrecognized)
2739 }
2740 if m.Resource != 0 {
2741 i = encodeVarintVmservice(dAtA, i, uint64(m.Resource))
2742 i--
2743 dAtA[i] = 0x20
2744 }
2745 if m.Update {
2746 i--
2747 if m.Update {
2748 dAtA[i] = 1
2749 } else {
2750 dAtA[i] = 0
2751 }
2752 i--
2753 dAtA[i] = 0x18
2754 }
2755 if m.Remove {
2756 i--
2757 if m.Remove {
2758 dAtA[i] = 1
2759 } else {
2760 dAtA[i] = 0
2761 }
2762 i--
2763 dAtA[i] = 0x10
2764 }
2765 if m.Add {
2766 i--
2767 if m.Add {
2768 dAtA[i] = 1
2769 } else {
2770 dAtA[i] = 0
2771 }
2772 i--
2773 dAtA[i] = 0x8
2774 }
2775 return len(dAtA) - i, nil
2776 }
2777
2778 func (m *HVSocketListen) Marshal() (dAtA []byte, err error) {
2779 size := m.Size()
2780 dAtA = make([]byte, size)
2781 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2782 if err != nil {
2783 return nil, err
2784 }
2785 return dAtA[:n], nil
2786 }
2787
2788 func (m *HVSocketListen) MarshalTo(dAtA []byte) (int, error) {
2789 size := m.Size()
2790 return m.MarshalToSizedBuffer(dAtA[:size])
2791 }
2792
2793 func (m *HVSocketListen) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2794 i := len(dAtA)
2795 _ = i
2796 var l int
2797 _ = l
2798 if m.XXX_unrecognized != nil {
2799 i -= len(m.XXX_unrecognized)
2800 copy(dAtA[i:], m.XXX_unrecognized)
2801 }
2802 if len(m.ListenerPath) > 0 {
2803 i -= len(m.ListenerPath)
2804 copy(dAtA[i:], m.ListenerPath)
2805 i = encodeVarintVmservice(dAtA, i, uint64(len(m.ListenerPath)))
2806 i--
2807 dAtA[i] = 0x12
2808 }
2809 if len(m.ServiceID) > 0 {
2810 i -= len(m.ServiceID)
2811 copy(dAtA[i:], m.ServiceID)
2812 i = encodeVarintVmservice(dAtA, i, uint64(len(m.ServiceID)))
2813 i--
2814 dAtA[i] = 0xa
2815 }
2816 return len(dAtA) - i, nil
2817 }
2818
2819 func (m *VSockListen) Marshal() (dAtA []byte, err error) {
2820 size := m.Size()
2821 dAtA = make([]byte, size)
2822 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2823 if err != nil {
2824 return nil, err
2825 }
2826 return dAtA[:n], nil
2827 }
2828
2829 func (m *VSockListen) MarshalTo(dAtA []byte) (int, error) {
2830 size := m.Size()
2831 return m.MarshalToSizedBuffer(dAtA[:size])
2832 }
2833
2834 func (m *VSockListen) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2835 i := len(dAtA)
2836 _ = i
2837 var l int
2838 _ = l
2839 if m.XXX_unrecognized != nil {
2840 i -= len(m.XXX_unrecognized)
2841 copy(dAtA[i:], m.XXX_unrecognized)
2842 }
2843 if len(m.ListenerPath) > 0 {
2844 i -= len(m.ListenerPath)
2845 copy(dAtA[i:], m.ListenerPath)
2846 i = encodeVarintVmservice(dAtA, i, uint64(len(m.ListenerPath)))
2847 i--
2848 dAtA[i] = 0x12
2849 }
2850 if m.Port != 0 {
2851 i = encodeVarintVmservice(dAtA, i, uint64(m.Port))
2852 i--
2853 dAtA[i] = 0x8
2854 }
2855 return len(dAtA) - i, nil
2856 }
2857
2858 func (m *VMSocketRequest) Marshal() (dAtA []byte, err error) {
2859 size := m.Size()
2860 dAtA = make([]byte, size)
2861 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2862 if err != nil {
2863 return nil, err
2864 }
2865 return dAtA[:n], nil
2866 }
2867
2868 func (m *VMSocketRequest) MarshalTo(dAtA []byte) (int, error) {
2869 size := m.Size()
2870 return m.MarshalToSizedBuffer(dAtA[:size])
2871 }
2872
2873 func (m *VMSocketRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2874 i := len(dAtA)
2875 _ = i
2876 var l int
2877 _ = l
2878 if m.XXX_unrecognized != nil {
2879 i -= len(m.XXX_unrecognized)
2880 copy(dAtA[i:], m.XXX_unrecognized)
2881 }
2882 if m.Config != nil {
2883 {
2884 size := m.Config.Size()
2885 i -= size
2886 if _, err := m.Config.MarshalTo(dAtA[i:]); err != nil {
2887 return 0, err
2888 }
2889 }
2890 }
2891 if m.Type != 0 {
2892 i = encodeVarintVmservice(dAtA, i, uint64(m.Type))
2893 i--
2894 dAtA[i] = 0x8
2895 }
2896 return len(dAtA) - i, nil
2897 }
2898
2899 func (m *VMSocketRequest_HvsocketList) MarshalTo(dAtA []byte) (int, error) {
2900 size := m.Size()
2901 return m.MarshalToSizedBuffer(dAtA[:size])
2902 }
2903
2904 func (m *VMSocketRequest_HvsocketList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2905 i := len(dAtA)
2906 if m.HvsocketList != nil {
2907 {
2908 size, err := m.HvsocketList.MarshalToSizedBuffer(dAtA[:i])
2909 if err != nil {
2910 return 0, err
2911 }
2912 i -= size
2913 i = encodeVarintVmservice(dAtA, i, uint64(size))
2914 }
2915 i--
2916 dAtA[i] = 0x12
2917 }
2918 return len(dAtA) - i, nil
2919 }
2920 func (m *VMSocketRequest_VsockListen) MarshalTo(dAtA []byte) (int, error) {
2921 size := m.Size()
2922 return m.MarshalToSizedBuffer(dAtA[:size])
2923 }
2924
2925 func (m *VMSocketRequest_VsockListen) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2926 i := len(dAtA)
2927 if m.VsockListen != nil {
2928 {
2929 size, err := m.VsockListen.MarshalToSizedBuffer(dAtA[:i])
2930 if err != nil {
2931 return 0, err
2932 }
2933 i -= size
2934 i = encodeVarintVmservice(dAtA, i, uint64(size))
2935 }
2936 i--
2937 dAtA[i] = 0x1a
2938 }
2939 return len(dAtA) - i, nil
2940 }
2941 func (m *SCSIDisk) Marshal() (dAtA []byte, err error) {
2942 size := m.Size()
2943 dAtA = make([]byte, size)
2944 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2945 if err != nil {
2946 return nil, err
2947 }
2948 return dAtA[:n], nil
2949 }
2950
2951 func (m *SCSIDisk) MarshalTo(dAtA []byte) (int, error) {
2952 size := m.Size()
2953 return m.MarshalToSizedBuffer(dAtA[:size])
2954 }
2955
2956 func (m *SCSIDisk) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2957 i := len(dAtA)
2958 _ = i
2959 var l int
2960 _ = l
2961 if m.XXX_unrecognized != nil {
2962 i -= len(m.XXX_unrecognized)
2963 copy(dAtA[i:], m.XXX_unrecognized)
2964 }
2965 if m.ReadOnly {
2966 i--
2967 if m.ReadOnly {
2968 dAtA[i] = 1
2969 } else {
2970 dAtA[i] = 0
2971 }
2972 i--
2973 dAtA[i] = 0x28
2974 }
2975 if m.Type != 0 {
2976 i = encodeVarintVmservice(dAtA, i, uint64(m.Type))
2977 i--
2978 dAtA[i] = 0x20
2979 }
2980 if len(m.HostPath) > 0 {
2981 i -= len(m.HostPath)
2982 copy(dAtA[i:], m.HostPath)
2983 i = encodeVarintVmservice(dAtA, i, uint64(len(m.HostPath)))
2984 i--
2985 dAtA[i] = 0x1a
2986 }
2987 if m.Lun != 0 {
2988 i = encodeVarintVmservice(dAtA, i, uint64(m.Lun))
2989 i--
2990 dAtA[i] = 0x10
2991 }
2992 if m.Controller != 0 {
2993 i = encodeVarintVmservice(dAtA, i, uint64(m.Controller))
2994 i--
2995 dAtA[i] = 0x8
2996 }
2997 return len(dAtA) - i, nil
2998 }
2999
3000 func (m *VPMEMDisk) Marshal() (dAtA []byte, err error) {
3001 size := m.Size()
3002 dAtA = make([]byte, size)
3003 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3004 if err != nil {
3005 return nil, err
3006 }
3007 return dAtA[:n], nil
3008 }
3009
3010 func (m *VPMEMDisk) MarshalTo(dAtA []byte) (int, error) {
3011 size := m.Size()
3012 return m.MarshalToSizedBuffer(dAtA[:size])
3013 }
3014
3015 func (m *VPMEMDisk) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3016 i := len(dAtA)
3017 _ = i
3018 var l int
3019 _ = l
3020 if m.XXX_unrecognized != nil {
3021 i -= len(m.XXX_unrecognized)
3022 copy(dAtA[i:], m.XXX_unrecognized)
3023 }
3024 if m.ReadOnly {
3025 i--
3026 if m.ReadOnly {
3027 dAtA[i] = 1
3028 } else {
3029 dAtA[i] = 0
3030 }
3031 i--
3032 dAtA[i] = 0x18
3033 }
3034 if m.Type != 0 {
3035 i = encodeVarintVmservice(dAtA, i, uint64(m.Type))
3036 i--
3037 dAtA[i] = 0x10
3038 }
3039 if len(m.HostPath) > 0 {
3040 i -= len(m.HostPath)
3041 copy(dAtA[i:], m.HostPath)
3042 i = encodeVarintVmservice(dAtA, i, uint64(len(m.HostPath)))
3043 i--
3044 dAtA[i] = 0xa
3045 }
3046 return len(dAtA) - i, nil
3047 }
3048
3049 func (m *NICConfig) Marshal() (dAtA []byte, err error) {
3050 size := m.Size()
3051 dAtA = make([]byte, size)
3052 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3053 if err != nil {
3054 return nil, err
3055 }
3056 return dAtA[:n], nil
3057 }
3058
3059 func (m *NICConfig) MarshalTo(dAtA []byte) (int, error) {
3060 size := m.Size()
3061 return m.MarshalToSizedBuffer(dAtA[:size])
3062 }
3063
3064 func (m *NICConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3065 i := len(dAtA)
3066 _ = i
3067 var l int
3068 _ = l
3069 if m.XXX_unrecognized != nil {
3070 i -= len(m.XXX_unrecognized)
3071 copy(dAtA[i:], m.XXX_unrecognized)
3072 }
3073 if len(m.NicName) > 0 {
3074 i -= len(m.NicName)
3075 copy(dAtA[i:], m.NicName)
3076 i = encodeVarintVmservice(dAtA, i, uint64(len(m.NicName)))
3077 i--
3078 dAtA[i] = 0x2a
3079 }
3080 if len(m.SwitchID) > 0 {
3081 i -= len(m.SwitchID)
3082 copy(dAtA[i:], m.SwitchID)
3083 i = encodeVarintVmservice(dAtA, i, uint64(len(m.SwitchID)))
3084 i--
3085 dAtA[i] = 0x22
3086 }
3087 if len(m.MacAddress) > 0 {
3088 i -= len(m.MacAddress)
3089 copy(dAtA[i:], m.MacAddress)
3090 i = encodeVarintVmservice(dAtA, i, uint64(len(m.MacAddress)))
3091 i--
3092 dAtA[i] = 0x1a
3093 }
3094 if len(m.PortID) > 0 {
3095 i -= len(m.PortID)
3096 copy(dAtA[i:], m.PortID)
3097 i = encodeVarintVmservice(dAtA, i, uint64(len(m.PortID)))
3098 i--
3099 dAtA[i] = 0x12
3100 }
3101 if len(m.NicID) > 0 {
3102 i -= len(m.NicID)
3103 copy(dAtA[i:], m.NicID)
3104 i = encodeVarintVmservice(dAtA, i, uint64(len(m.NicID)))
3105 i--
3106 dAtA[i] = 0xa
3107 }
3108 return len(dAtA) - i, nil
3109 }
3110
3111 func (m *WindowsPCIDevice) Marshal() (dAtA []byte, err error) {
3112 size := m.Size()
3113 dAtA = make([]byte, size)
3114 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3115 if err != nil {
3116 return nil, err
3117 }
3118 return dAtA[:n], nil
3119 }
3120
3121 func (m *WindowsPCIDevice) MarshalTo(dAtA []byte) (int, error) {
3122 size := m.Size()
3123 return m.MarshalToSizedBuffer(dAtA[:size])
3124 }
3125
3126 func (m *WindowsPCIDevice) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3127 i := len(dAtA)
3128 _ = i
3129 var l int
3130 _ = l
3131 if m.XXX_unrecognized != nil {
3132 i -= len(m.XXX_unrecognized)
3133 copy(dAtA[i:], m.XXX_unrecognized)
3134 }
3135 if len(m.InstanceID) > 0 {
3136 i -= len(m.InstanceID)
3137 copy(dAtA[i:], m.InstanceID)
3138 i = encodeVarintVmservice(dAtA, i, uint64(len(m.InstanceID)))
3139 i--
3140 dAtA[i] = 0xa
3141 }
3142 return len(dAtA) - i, nil
3143 }
3144
3145 func (m *ModifyMemoryRequest) Marshal() (dAtA []byte, err error) {
3146 size := m.Size()
3147 dAtA = make([]byte, size)
3148 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3149 if err != nil {
3150 return nil, err
3151 }
3152 return dAtA[:n], nil
3153 }
3154
3155 func (m *ModifyMemoryRequest) MarshalTo(dAtA []byte) (int, error) {
3156 size := m.Size()
3157 return m.MarshalToSizedBuffer(dAtA[:size])
3158 }
3159
3160 func (m *ModifyMemoryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3161 i := len(dAtA)
3162 _ = i
3163 var l int
3164 _ = l
3165 if m.XXX_unrecognized != nil {
3166 i -= len(m.XXX_unrecognized)
3167 copy(dAtA[i:], m.XXX_unrecognized)
3168 }
3169 if m.MemoryMb != 0 {
3170 i = encodeVarintVmservice(dAtA, i, uint64(m.MemoryMb))
3171 i--
3172 dAtA[i] = 0x8
3173 }
3174 return len(dAtA) - i, nil
3175 }
3176
3177 func (m *ModifyProcessorRequest) Marshal() (dAtA []byte, err error) {
3178 size := m.Size()
3179 dAtA = make([]byte, size)
3180 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3181 if err != nil {
3182 return nil, err
3183 }
3184 return dAtA[:n], nil
3185 }
3186
3187 func (m *ModifyProcessorRequest) MarshalTo(dAtA []byte) (int, error) {
3188 size := m.Size()
3189 return m.MarshalToSizedBuffer(dAtA[:size])
3190 }
3191
3192 func (m *ModifyProcessorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3193 i := len(dAtA)
3194 _ = i
3195 var l int
3196 _ = l
3197 if m.XXX_unrecognized != nil {
3198 i -= len(m.XXX_unrecognized)
3199 copy(dAtA[i:], m.XXX_unrecognized)
3200 }
3201 if m.ProcessorIndex != 0 {
3202 i = encodeVarintVmservice(dAtA, i, uint64(m.ProcessorIndex))
3203 i--
3204 dAtA[i] = 0x8
3205 }
3206 return len(dAtA) - i, nil
3207 }
3208
3209 func (m *ModifyProcessorConfigRequest) Marshal() (dAtA []byte, err error) {
3210 size := m.Size()
3211 dAtA = make([]byte, size)
3212 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3213 if err != nil {
3214 return nil, err
3215 }
3216 return dAtA[:n], nil
3217 }
3218
3219 func (m *ModifyProcessorConfigRequest) MarshalTo(dAtA []byte) (int, error) {
3220 size := m.Size()
3221 return m.MarshalToSizedBuffer(dAtA[:size])
3222 }
3223
3224 func (m *ModifyProcessorConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3225 i := len(dAtA)
3226 _ = i
3227 var l int
3228 _ = l
3229 if m.XXX_unrecognized != nil {
3230 i -= len(m.XXX_unrecognized)
3231 copy(dAtA[i:], m.XXX_unrecognized)
3232 }
3233 if m.ProcessorLimit != 0 {
3234 i = encodeVarintVmservice(dAtA, i, uint64(m.ProcessorLimit))
3235 i--
3236 dAtA[i] = 0x10
3237 }
3238 if m.ProcessorWeight != 0 {
3239 i = encodeVarintVmservice(dAtA, i, uint64(m.ProcessorWeight))
3240 i--
3241 dAtA[i] = 0x8
3242 }
3243 return len(dAtA) - i, nil
3244 }
3245
3246 func (m *ModifyResourceRequest) Marshal() (dAtA []byte, err error) {
3247 size := m.Size()
3248 dAtA = make([]byte, size)
3249 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3250 if err != nil {
3251 return nil, err
3252 }
3253 return dAtA[:n], nil
3254 }
3255
3256 func (m *ModifyResourceRequest) MarshalTo(dAtA []byte) (int, error) {
3257 size := m.Size()
3258 return m.MarshalToSizedBuffer(dAtA[:size])
3259 }
3260
3261 func (m *ModifyResourceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3262 i := len(dAtA)
3263 _ = i
3264 var l int
3265 _ = l
3266 if m.XXX_unrecognized != nil {
3267 i -= len(m.XXX_unrecognized)
3268 copy(dAtA[i:], m.XXX_unrecognized)
3269 }
3270 if m.Resource != nil {
3271 {
3272 size := m.Resource.Size()
3273 i -= size
3274 if _, err := m.Resource.MarshalTo(dAtA[i:]); err != nil {
3275 return 0, err
3276 }
3277 }
3278 }
3279 if m.Type != 0 {
3280 i = encodeVarintVmservice(dAtA, i, uint64(m.Type))
3281 i--
3282 dAtA[i] = 0x8
3283 }
3284 return len(dAtA) - i, nil
3285 }
3286
3287 func (m *ModifyResourceRequest_Processor) MarshalTo(dAtA []byte) (int, error) {
3288 size := m.Size()
3289 return m.MarshalToSizedBuffer(dAtA[:size])
3290 }
3291
3292 func (m *ModifyResourceRequest_Processor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3293 i := len(dAtA)
3294 if m.Processor != nil {
3295 {
3296 size, err := m.Processor.MarshalToSizedBuffer(dAtA[:i])
3297 if err != nil {
3298 return 0, err
3299 }
3300 i -= size
3301 i = encodeVarintVmservice(dAtA, i, uint64(size))
3302 }
3303 i--
3304 dAtA[i] = 0x12
3305 }
3306 return len(dAtA) - i, nil
3307 }
3308 func (m *ModifyResourceRequest_ProcessorConfig) MarshalTo(dAtA []byte) (int, error) {
3309 size := m.Size()
3310 return m.MarshalToSizedBuffer(dAtA[:size])
3311 }
3312
3313 func (m *ModifyResourceRequest_ProcessorConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3314 i := len(dAtA)
3315 if m.ProcessorConfig != nil {
3316 {
3317 size, err := m.ProcessorConfig.MarshalToSizedBuffer(dAtA[:i])
3318 if err != nil {
3319 return 0, err
3320 }
3321 i -= size
3322 i = encodeVarintVmservice(dAtA, i, uint64(size))
3323 }
3324 i--
3325 dAtA[i] = 0x1a
3326 }
3327 return len(dAtA) - i, nil
3328 }
3329 func (m *ModifyResourceRequest_Memory) MarshalTo(dAtA []byte) (int, error) {
3330 size := m.Size()
3331 return m.MarshalToSizedBuffer(dAtA[:size])
3332 }
3333
3334 func (m *ModifyResourceRequest_Memory) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3335 i := len(dAtA)
3336 if m.Memory != nil {
3337 {
3338 size, err := m.Memory.MarshalToSizedBuffer(dAtA[:i])
3339 if err != nil {
3340 return 0, err
3341 }
3342 i -= size
3343 i = encodeVarintVmservice(dAtA, i, uint64(size))
3344 }
3345 i--
3346 dAtA[i] = 0x22
3347 }
3348 return len(dAtA) - i, nil
3349 }
3350 func (m *ModifyResourceRequest_ScsiDisk) MarshalTo(dAtA []byte) (int, error) {
3351 size := m.Size()
3352 return m.MarshalToSizedBuffer(dAtA[:size])
3353 }
3354
3355 func (m *ModifyResourceRequest_ScsiDisk) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3356 i := len(dAtA)
3357 if m.ScsiDisk != nil {
3358 {
3359 size, err := m.ScsiDisk.MarshalToSizedBuffer(dAtA[:i])
3360 if err != nil {
3361 return 0, err
3362 }
3363 i -= size
3364 i = encodeVarintVmservice(dAtA, i, uint64(size))
3365 }
3366 i--
3367 dAtA[i] = 0x2a
3368 }
3369 return len(dAtA) - i, nil
3370 }
3371 func (m *ModifyResourceRequest_VpmemDisk) MarshalTo(dAtA []byte) (int, error) {
3372 size := m.Size()
3373 return m.MarshalToSizedBuffer(dAtA[:size])
3374 }
3375
3376 func (m *ModifyResourceRequest_VpmemDisk) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3377 i := len(dAtA)
3378 if m.VpmemDisk != nil {
3379 {
3380 size, err := m.VpmemDisk.MarshalToSizedBuffer(dAtA[:i])
3381 if err != nil {
3382 return 0, err
3383 }
3384 i -= size
3385 i = encodeVarintVmservice(dAtA, i, uint64(size))
3386 }
3387 i--
3388 dAtA[i] = 0x32
3389 }
3390 return len(dAtA) - i, nil
3391 }
3392 func (m *ModifyResourceRequest_NicConfig) MarshalTo(dAtA []byte) (int, error) {
3393 size := m.Size()
3394 return m.MarshalToSizedBuffer(dAtA[:size])
3395 }
3396
3397 func (m *ModifyResourceRequest_NicConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3398 i := len(dAtA)
3399 if m.NicConfig != nil {
3400 {
3401 size, err := m.NicConfig.MarshalToSizedBuffer(dAtA[:i])
3402 if err != nil {
3403 return 0, err
3404 }
3405 i -= size
3406 i = encodeVarintVmservice(dAtA, i, uint64(size))
3407 }
3408 i--
3409 dAtA[i] = 0x3a
3410 }
3411 return len(dAtA) - i, nil
3412 }
3413 func (m *ModifyResourceRequest_WindowsDevice) MarshalTo(dAtA []byte) (int, error) {
3414 size := m.Size()
3415 return m.MarshalToSizedBuffer(dAtA[:size])
3416 }
3417
3418 func (m *ModifyResourceRequest_WindowsDevice) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3419 i := len(dAtA)
3420 if m.WindowsDevice != nil {
3421 {
3422 size, err := m.WindowsDevice.MarshalToSizedBuffer(dAtA[:i])
3423 if err != nil {
3424 return 0, err
3425 }
3426 i -= size
3427 i = encodeVarintVmservice(dAtA, i, uint64(size))
3428 }
3429 i--
3430 dAtA[i] = 0x42
3431 }
3432 return len(dAtA) - i, nil
3433 }
3434 func encodeVarintVmservice(dAtA []byte, offset int, v uint64) int {
3435 offset -= sovVmservice(v)
3436 base := offset
3437 for v >= 1<<7 {
3438 dAtA[offset] = uint8(v&0x7f | 0x80)
3439 v >>= 7
3440 offset++
3441 }
3442 dAtA[offset] = uint8(v)
3443 return base
3444 }
3445 func (m *DirectBoot) Size() (n int) {
3446 if m == nil {
3447 return 0
3448 }
3449 var l int
3450 _ = l
3451 l = len(m.KernelPath)
3452 if l > 0 {
3453 n += 1 + l + sovVmservice(uint64(l))
3454 }
3455 l = len(m.InitrdPath)
3456 if l > 0 {
3457 n += 1 + l + sovVmservice(uint64(l))
3458 }
3459 l = len(m.KernelCmdline)
3460 if l > 0 {
3461 n += 1 + l + sovVmservice(uint64(l))
3462 }
3463 if m.XXX_unrecognized != nil {
3464 n += len(m.XXX_unrecognized)
3465 }
3466 return n
3467 }
3468
3469 func (m *UEFI) Size() (n int) {
3470 if m == nil {
3471 return 0
3472 }
3473 var l int
3474 _ = l
3475 l = len(m.FirmwarePath)
3476 if l > 0 {
3477 n += 1 + l + sovVmservice(uint64(l))
3478 }
3479 l = len(m.DevicePath)
3480 if l > 0 {
3481 n += 1 + l + sovVmservice(uint64(l))
3482 }
3483 l = len(m.OptionalData)
3484 if l > 0 {
3485 n += 1 + l + sovVmservice(uint64(l))
3486 }
3487 if m.XXX_unrecognized != nil {
3488 n += len(m.XXX_unrecognized)
3489 }
3490 return n
3491 }
3492
3493 func (m *MemoryConfig) Size() (n int) {
3494 if m == nil {
3495 return 0
3496 }
3497 var l int
3498 _ = l
3499 if m.MemoryMb != 0 {
3500 n += 1 + sovVmservice(uint64(m.MemoryMb))
3501 }
3502 if m.AllowOvercommit {
3503 n += 2
3504 }
3505 if m.DeferredCommit {
3506 n += 2
3507 }
3508 if m.HotHint {
3509 n += 2
3510 }
3511 if m.ColdHint {
3512 n += 2
3513 }
3514 if m.ColdDiscardHint {
3515 n += 2
3516 }
3517 if m.LowMmioGapInMb != 0 {
3518 n += 1 + sovVmservice(uint64(m.LowMmioGapInMb))
3519 }
3520 if m.HighMmioBaseInMb != 0 {
3521 n += 1 + sovVmservice(uint64(m.HighMmioBaseInMb))
3522 }
3523 if m.HighMmioGapInMb != 0 {
3524 n += 1 + sovVmservice(uint64(m.HighMmioGapInMb))
3525 }
3526 if m.XXX_unrecognized != nil {
3527 n += len(m.XXX_unrecognized)
3528 }
3529 return n
3530 }
3531
3532 func (m *ProcessorConfig) Size() (n int) {
3533 if m == nil {
3534 return 0
3535 }
3536 var l int
3537 _ = l
3538 if m.ProcessorCount != 0 {
3539 n += 1 + sovVmservice(uint64(m.ProcessorCount))
3540 }
3541 if m.ProcessorWeight != 0 {
3542 n += 1 + sovVmservice(uint64(m.ProcessorWeight))
3543 }
3544 if m.ProcessorLimit != 0 {
3545 n += 1 + sovVmservice(uint64(m.ProcessorLimit))
3546 }
3547 if m.XXX_unrecognized != nil {
3548 n += len(m.XXX_unrecognized)
3549 }
3550 return n
3551 }
3552
3553 func (m *DevicesConfig) Size() (n int) {
3554 if m == nil {
3555 return 0
3556 }
3557 var l int
3558 _ = l
3559 if len(m.ScsiDisks) > 0 {
3560 for _, e := range m.ScsiDisks {
3561 l = e.Size()
3562 n += 1 + l + sovVmservice(uint64(l))
3563 }
3564 }
3565 if len(m.VpmemDisks) > 0 {
3566 for _, e := range m.VpmemDisks {
3567 l = e.Size()
3568 n += 1 + l + sovVmservice(uint64(l))
3569 }
3570 }
3571 if len(m.NicConfig) > 0 {
3572 for _, e := range m.NicConfig {
3573 l = e.Size()
3574 n += 1 + l + sovVmservice(uint64(l))
3575 }
3576 }
3577 if len(m.WindowsDevice) > 0 {
3578 for _, e := range m.WindowsDevice {
3579 l = e.Size()
3580 n += 1 + l + sovVmservice(uint64(l))
3581 }
3582 }
3583 if m.XXX_unrecognized != nil {
3584 n += len(m.XXX_unrecognized)
3585 }
3586 return n
3587 }
3588
3589 func (m *VMConfig) Size() (n int) {
3590 if m == nil {
3591 return 0
3592 }
3593 var l int
3594 _ = l
3595 if m.MemoryConfig != nil {
3596 l = m.MemoryConfig.Size()
3597 n += 1 + l + sovVmservice(uint64(l))
3598 }
3599 if m.ProcessorConfig != nil {
3600 l = m.ProcessorConfig.Size()
3601 n += 1 + l + sovVmservice(uint64(l))
3602 }
3603 if m.DevicesConfig != nil {
3604 l = m.DevicesConfig.Size()
3605 n += 1 + l + sovVmservice(uint64(l))
3606 }
3607 if m.SerialConfig != nil {
3608 l = m.SerialConfig.Size()
3609 n += 1 + l + sovVmservice(uint64(l))
3610 }
3611 if m.BootConfig != nil {
3612 n += m.BootConfig.Size()
3613 }
3614 if m.WindowsOptions != nil {
3615 l = m.WindowsOptions.Size()
3616 n += 1 + l + sovVmservice(uint64(l))
3617 }
3618 if len(m.ExtraData) > 0 {
3619 for k, v := range m.ExtraData {
3620 _ = k
3621 _ = v
3622 mapEntrySize := 1 + len(k) + sovVmservice(uint64(len(k))) + 1 + len(v) + sovVmservice(uint64(len(v)))
3623 n += mapEntrySize + 1 + sovVmservice(uint64(mapEntrySize))
3624 }
3625 }
3626 if m.XXX_unrecognized != nil {
3627 n += len(m.XXX_unrecognized)
3628 }
3629 return n
3630 }
3631
3632 func (m *VMConfig_DirectBoot) Size() (n int) {
3633 if m == nil {
3634 return 0
3635 }
3636 var l int
3637 _ = l
3638 if m.DirectBoot != nil {
3639 l = m.DirectBoot.Size()
3640 n += 1 + l + sovVmservice(uint64(l))
3641 }
3642 return n
3643 }
3644 func (m *VMConfig_Uefi) Size() (n int) {
3645 if m == nil {
3646 return 0
3647 }
3648 var l int
3649 _ = l
3650 if m.Uefi != nil {
3651 l = m.Uefi.Size()
3652 n += 1 + l + sovVmservice(uint64(l))
3653 }
3654 return n
3655 }
3656 func (m *WindowsOptions) Size() (n int) {
3657 if m == nil {
3658 return 0
3659 }
3660 var l int
3661 _ = l
3662 if m.CpuGroupID != 0 {
3663 n += 1 + sovVmservice(uint64(m.CpuGroupID))
3664 }
3665 if m.XXX_unrecognized != nil {
3666 n += len(m.XXX_unrecognized)
3667 }
3668 return n
3669 }
3670
3671 func (m *SerialConfig) Size() (n int) {
3672 if m == nil {
3673 return 0
3674 }
3675 var l int
3676 _ = l
3677 if len(m.Ports) > 0 {
3678 for _, e := range m.Ports {
3679 l = e.Size()
3680 n += 1 + l + sovVmservice(uint64(l))
3681 }
3682 }
3683 if m.XXX_unrecognized != nil {
3684 n += len(m.XXX_unrecognized)
3685 }
3686 return n
3687 }
3688
3689 func (m *SerialConfig_Config) Size() (n int) {
3690 if m == nil {
3691 return 0
3692 }
3693 var l int
3694 _ = l
3695 if m.Port != 0 {
3696 n += 1 + sovVmservice(uint64(m.Port))
3697 }
3698 l = len(m.SocketPath)
3699 if l > 0 {
3700 n += 1 + l + sovVmservice(uint64(l))
3701 }
3702 if m.XXX_unrecognized != nil {
3703 n += len(m.XXX_unrecognized)
3704 }
3705 return n
3706 }
3707
3708 func (m *CreateVMRequest) Size() (n int) {
3709 if m == nil {
3710 return 0
3711 }
3712 var l int
3713 _ = l
3714 if m.Config != nil {
3715 l = m.Config.Size()
3716 n += 1 + l + sovVmservice(uint64(l))
3717 }
3718 l = len(m.LogID)
3719 if l > 0 {
3720 n += 1 + l + sovVmservice(uint64(l))
3721 }
3722 if m.XXX_unrecognized != nil {
3723 n += len(m.XXX_unrecognized)
3724 }
3725 return n
3726 }
3727
3728 func (m *InspectVMRequest) Size() (n int) {
3729 if m == nil {
3730 return 0
3731 }
3732 var l int
3733 _ = l
3734 l = len(m.Query)
3735 if l > 0 {
3736 n += 1 + l + sovVmservice(uint64(l))
3737 }
3738 if m.RecursionLimit != 0 {
3739 n += 1 + sovVmservice(uint64(m.RecursionLimit))
3740 }
3741 if m.XXX_unrecognized != nil {
3742 n += len(m.XXX_unrecognized)
3743 }
3744 return n
3745 }
3746
3747 func (m *InspectVMResponse) Size() (n int) {
3748 if m == nil {
3749 return 0
3750 }
3751 var l int
3752 _ = l
3753 if m.Result != nil {
3754 l = m.Result.Size()
3755 n += 1 + l + sovVmservice(uint64(l))
3756 }
3757 if m.XXX_unrecognized != nil {
3758 n += len(m.XXX_unrecognized)
3759 }
3760 return n
3761 }
3762
3763 func (m *MemoryStats) Size() (n int) {
3764 if m == nil {
3765 return 0
3766 }
3767 var l int
3768 _ = l
3769 if m.WorkingSetBytes != 0 {
3770 n += 1 + sovVmservice(uint64(m.WorkingSetBytes))
3771 }
3772 if m.AvailableMemory != 0 {
3773 n += 1 + sovVmservice(uint64(m.AvailableMemory))
3774 }
3775 if m.ReservedMemory != 0 {
3776 n += 1 + sovVmservice(uint64(m.ReservedMemory))
3777 }
3778 if m.AssignedMemory != 0 {
3779 n += 1 + sovVmservice(uint64(m.AssignedMemory))
3780 }
3781 if m.XXX_unrecognized != nil {
3782 n += len(m.XXX_unrecognized)
3783 }
3784 return n
3785 }
3786
3787 func (m *ProcessorStats) Size() (n int) {
3788 if m == nil {
3789 return 0
3790 }
3791 var l int
3792 _ = l
3793 if m.TotalRuntimeNs != 0 {
3794 n += 1 + sovVmservice(uint64(m.TotalRuntimeNs))
3795 }
3796 if m.XXX_unrecognized != nil {
3797 n += len(m.XXX_unrecognized)
3798 }
3799 return n
3800 }
3801
3802 func (m *PropertiesVMRequest) Size() (n int) {
3803 if m == nil {
3804 return 0
3805 }
3806 var l int
3807 _ = l
3808 if len(m.Types) > 0 {
3809 l = 0
3810 for _, e := range m.Types {
3811 l += sovVmservice(uint64(e))
3812 }
3813 n += 1 + sovVmservice(uint64(l)) + l
3814 }
3815 if m.XXX_unrecognized != nil {
3816 n += len(m.XXX_unrecognized)
3817 }
3818 return n
3819 }
3820
3821 func (m *PropertiesVMResponse) Size() (n int) {
3822 if m == nil {
3823 return 0
3824 }
3825 var l int
3826 _ = l
3827 if m.MemoryStats != nil {
3828 l = m.MemoryStats.Size()
3829 n += 1 + l + sovVmservice(uint64(l))
3830 }
3831 if m.ProcessorStats != nil {
3832 l = m.ProcessorStats.Size()
3833 n += 1 + l + sovVmservice(uint64(l))
3834 }
3835 if m.XXX_unrecognized != nil {
3836 n += len(m.XXX_unrecognized)
3837 }
3838 return n
3839 }
3840
3841 func (m *CapabilitiesVMResponse) Size() (n int) {
3842 if m == nil {
3843 return 0
3844 }
3845 var l int
3846 _ = l
3847 if len(m.SupportedResources) > 0 {
3848 for _, e := range m.SupportedResources {
3849 l = e.Size()
3850 n += 1 + l + sovVmservice(uint64(l))
3851 }
3852 }
3853 if len(m.SupportedGuestOs) > 0 {
3854 l = 0
3855 for _, e := range m.SupportedGuestOs {
3856 l += sovVmservice(uint64(e))
3857 }
3858 n += 1 + sovVmservice(uint64(l)) + l
3859 }
3860 if m.XXX_unrecognized != nil {
3861 n += len(m.XXX_unrecognized)
3862 }
3863 return n
3864 }
3865
3866 func (m *CapabilitiesVMResponse_SupportedResource) Size() (n int) {
3867 if m == nil {
3868 return 0
3869 }
3870 var l int
3871 _ = l
3872 if m.Add {
3873 n += 2
3874 }
3875 if m.Remove {
3876 n += 2
3877 }
3878 if m.Update {
3879 n += 2
3880 }
3881 if m.Resource != 0 {
3882 n += 1 + sovVmservice(uint64(m.Resource))
3883 }
3884 if m.XXX_unrecognized != nil {
3885 n += len(m.XXX_unrecognized)
3886 }
3887 return n
3888 }
3889
3890 func (m *HVSocketListen) Size() (n int) {
3891 if m == nil {
3892 return 0
3893 }
3894 var l int
3895 _ = l
3896 l = len(m.ServiceID)
3897 if l > 0 {
3898 n += 1 + l + sovVmservice(uint64(l))
3899 }
3900 l = len(m.ListenerPath)
3901 if l > 0 {
3902 n += 1 + l + sovVmservice(uint64(l))
3903 }
3904 if m.XXX_unrecognized != nil {
3905 n += len(m.XXX_unrecognized)
3906 }
3907 return n
3908 }
3909
3910 func (m *VSockListen) Size() (n int) {
3911 if m == nil {
3912 return 0
3913 }
3914 var l int
3915 _ = l
3916 if m.Port != 0 {
3917 n += 1 + sovVmservice(uint64(m.Port))
3918 }
3919 l = len(m.ListenerPath)
3920 if l > 0 {
3921 n += 1 + l + sovVmservice(uint64(l))
3922 }
3923 if m.XXX_unrecognized != nil {
3924 n += len(m.XXX_unrecognized)
3925 }
3926 return n
3927 }
3928
3929 func (m *VMSocketRequest) Size() (n int) {
3930 if m == nil {
3931 return 0
3932 }
3933 var l int
3934 _ = l
3935 if m.Type != 0 {
3936 n += 1 + sovVmservice(uint64(m.Type))
3937 }
3938 if m.Config != nil {
3939 n += m.Config.Size()
3940 }
3941 if m.XXX_unrecognized != nil {
3942 n += len(m.XXX_unrecognized)
3943 }
3944 return n
3945 }
3946
3947 func (m *VMSocketRequest_HvsocketList) Size() (n int) {
3948 if m == nil {
3949 return 0
3950 }
3951 var l int
3952 _ = l
3953 if m.HvsocketList != nil {
3954 l = m.HvsocketList.Size()
3955 n += 1 + l + sovVmservice(uint64(l))
3956 }
3957 return n
3958 }
3959 func (m *VMSocketRequest_VsockListen) Size() (n int) {
3960 if m == nil {
3961 return 0
3962 }
3963 var l int
3964 _ = l
3965 if m.VsockListen != nil {
3966 l = m.VsockListen.Size()
3967 n += 1 + l + sovVmservice(uint64(l))
3968 }
3969 return n
3970 }
3971 func (m *SCSIDisk) Size() (n int) {
3972 if m == nil {
3973 return 0
3974 }
3975 var l int
3976 _ = l
3977 if m.Controller != 0 {
3978 n += 1 + sovVmservice(uint64(m.Controller))
3979 }
3980 if m.Lun != 0 {
3981 n += 1 + sovVmservice(uint64(m.Lun))
3982 }
3983 l = len(m.HostPath)
3984 if l > 0 {
3985 n += 1 + l + sovVmservice(uint64(l))
3986 }
3987 if m.Type != 0 {
3988 n += 1 + sovVmservice(uint64(m.Type))
3989 }
3990 if m.ReadOnly {
3991 n += 2
3992 }
3993 if m.XXX_unrecognized != nil {
3994 n += len(m.XXX_unrecognized)
3995 }
3996 return n
3997 }
3998
3999 func (m *VPMEMDisk) Size() (n int) {
4000 if m == nil {
4001 return 0
4002 }
4003 var l int
4004 _ = l
4005 l = len(m.HostPath)
4006 if l > 0 {
4007 n += 1 + l + sovVmservice(uint64(l))
4008 }
4009 if m.Type != 0 {
4010 n += 1 + sovVmservice(uint64(m.Type))
4011 }
4012 if m.ReadOnly {
4013 n += 2
4014 }
4015 if m.XXX_unrecognized != nil {
4016 n += len(m.XXX_unrecognized)
4017 }
4018 return n
4019 }
4020
4021 func (m *NICConfig) Size() (n int) {
4022 if m == nil {
4023 return 0
4024 }
4025 var l int
4026 _ = l
4027 l = len(m.NicID)
4028 if l > 0 {
4029 n += 1 + l + sovVmservice(uint64(l))
4030 }
4031 l = len(m.PortID)
4032 if l > 0 {
4033 n += 1 + l + sovVmservice(uint64(l))
4034 }
4035 l = len(m.MacAddress)
4036 if l > 0 {
4037 n += 1 + l + sovVmservice(uint64(l))
4038 }
4039 l = len(m.SwitchID)
4040 if l > 0 {
4041 n += 1 + l + sovVmservice(uint64(l))
4042 }
4043 l = len(m.NicName)
4044 if l > 0 {
4045 n += 1 + l + sovVmservice(uint64(l))
4046 }
4047 if m.XXX_unrecognized != nil {
4048 n += len(m.XXX_unrecognized)
4049 }
4050 return n
4051 }
4052
4053 func (m *WindowsPCIDevice) Size() (n int) {
4054 if m == nil {
4055 return 0
4056 }
4057 var l int
4058 _ = l
4059 l = len(m.InstanceID)
4060 if l > 0 {
4061 n += 1 + l + sovVmservice(uint64(l))
4062 }
4063 if m.XXX_unrecognized != nil {
4064 n += len(m.XXX_unrecognized)
4065 }
4066 return n
4067 }
4068
4069 func (m *ModifyMemoryRequest) Size() (n int) {
4070 if m == nil {
4071 return 0
4072 }
4073 var l int
4074 _ = l
4075 if m.MemoryMb != 0 {
4076 n += 1 + sovVmservice(uint64(m.MemoryMb))
4077 }
4078 if m.XXX_unrecognized != nil {
4079 n += len(m.XXX_unrecognized)
4080 }
4081 return n
4082 }
4083
4084 func (m *ModifyProcessorRequest) Size() (n int) {
4085 if m == nil {
4086 return 0
4087 }
4088 var l int
4089 _ = l
4090 if m.ProcessorIndex != 0 {
4091 n += 1 + sovVmservice(uint64(m.ProcessorIndex))
4092 }
4093 if m.XXX_unrecognized != nil {
4094 n += len(m.XXX_unrecognized)
4095 }
4096 return n
4097 }
4098
4099 func (m *ModifyProcessorConfigRequest) Size() (n int) {
4100 if m == nil {
4101 return 0
4102 }
4103 var l int
4104 _ = l
4105 if m.ProcessorWeight != 0 {
4106 n += 1 + sovVmservice(uint64(m.ProcessorWeight))
4107 }
4108 if m.ProcessorLimit != 0 {
4109 n += 1 + sovVmservice(uint64(m.ProcessorLimit))
4110 }
4111 if m.XXX_unrecognized != nil {
4112 n += len(m.XXX_unrecognized)
4113 }
4114 return n
4115 }
4116
4117 func (m *ModifyResourceRequest) Size() (n int) {
4118 if m == nil {
4119 return 0
4120 }
4121 var l int
4122 _ = l
4123 if m.Type != 0 {
4124 n += 1 + sovVmservice(uint64(m.Type))
4125 }
4126 if m.Resource != nil {
4127 n += m.Resource.Size()
4128 }
4129 if m.XXX_unrecognized != nil {
4130 n += len(m.XXX_unrecognized)
4131 }
4132 return n
4133 }
4134
4135 func (m *ModifyResourceRequest_Processor) Size() (n int) {
4136 if m == nil {
4137 return 0
4138 }
4139 var l int
4140 _ = l
4141 if m.Processor != nil {
4142 l = m.Processor.Size()
4143 n += 1 + l + sovVmservice(uint64(l))
4144 }
4145 return n
4146 }
4147 func (m *ModifyResourceRequest_ProcessorConfig) Size() (n int) {
4148 if m == nil {
4149 return 0
4150 }
4151 var l int
4152 _ = l
4153 if m.ProcessorConfig != nil {
4154 l = m.ProcessorConfig.Size()
4155 n += 1 + l + sovVmservice(uint64(l))
4156 }
4157 return n
4158 }
4159 func (m *ModifyResourceRequest_Memory) Size() (n int) {
4160 if m == nil {
4161 return 0
4162 }
4163 var l int
4164 _ = l
4165 if m.Memory != nil {
4166 l = m.Memory.Size()
4167 n += 1 + l + sovVmservice(uint64(l))
4168 }
4169 return n
4170 }
4171 func (m *ModifyResourceRequest_ScsiDisk) Size() (n int) {
4172 if m == nil {
4173 return 0
4174 }
4175 var l int
4176 _ = l
4177 if m.ScsiDisk != nil {
4178 l = m.ScsiDisk.Size()
4179 n += 1 + l + sovVmservice(uint64(l))
4180 }
4181 return n
4182 }
4183 func (m *ModifyResourceRequest_VpmemDisk) Size() (n int) {
4184 if m == nil {
4185 return 0
4186 }
4187 var l int
4188 _ = l
4189 if m.VpmemDisk != nil {
4190 l = m.VpmemDisk.Size()
4191 n += 1 + l + sovVmservice(uint64(l))
4192 }
4193 return n
4194 }
4195 func (m *ModifyResourceRequest_NicConfig) Size() (n int) {
4196 if m == nil {
4197 return 0
4198 }
4199 var l int
4200 _ = l
4201 if m.NicConfig != nil {
4202 l = m.NicConfig.Size()
4203 n += 1 + l + sovVmservice(uint64(l))
4204 }
4205 return n
4206 }
4207 func (m *ModifyResourceRequest_WindowsDevice) Size() (n int) {
4208 if m == nil {
4209 return 0
4210 }
4211 var l int
4212 _ = l
4213 if m.WindowsDevice != nil {
4214 l = m.WindowsDevice.Size()
4215 n += 1 + l + sovVmservice(uint64(l))
4216 }
4217 return n
4218 }
4219
4220 func sovVmservice(x uint64) (n int) {
4221 return (math_bits.Len64(x|1) + 6) / 7
4222 }
4223 func sozVmservice(x uint64) (n int) {
4224 return sovVmservice(uint64((x << 1) ^ uint64((int64(x) >> 63))))
4225 }
4226 func (this *DirectBoot) String() string {
4227 if this == nil {
4228 return "nil"
4229 }
4230 s := strings.Join([]string{`&DirectBoot{`,
4231 `KernelPath:` + fmt.Sprintf("%v", this.KernelPath) + `,`,
4232 `InitrdPath:` + fmt.Sprintf("%v", this.InitrdPath) + `,`,
4233 `KernelCmdline:` + fmt.Sprintf("%v", this.KernelCmdline) + `,`,
4234 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4235 `}`,
4236 }, "")
4237 return s
4238 }
4239 func (this *UEFI) String() string {
4240 if this == nil {
4241 return "nil"
4242 }
4243 s := strings.Join([]string{`&UEFI{`,
4244 `FirmwarePath:` + fmt.Sprintf("%v", this.FirmwarePath) + `,`,
4245 `DevicePath:` + fmt.Sprintf("%v", this.DevicePath) + `,`,
4246 `OptionalData:` + fmt.Sprintf("%v", this.OptionalData) + `,`,
4247 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4248 `}`,
4249 }, "")
4250 return s
4251 }
4252 func (this *MemoryConfig) String() string {
4253 if this == nil {
4254 return "nil"
4255 }
4256 s := strings.Join([]string{`&MemoryConfig{`,
4257 `MemoryMb:` + fmt.Sprintf("%v", this.MemoryMb) + `,`,
4258 `AllowOvercommit:` + fmt.Sprintf("%v", this.AllowOvercommit) + `,`,
4259 `DeferredCommit:` + fmt.Sprintf("%v", this.DeferredCommit) + `,`,
4260 `HotHint:` + fmt.Sprintf("%v", this.HotHint) + `,`,
4261 `ColdHint:` + fmt.Sprintf("%v", this.ColdHint) + `,`,
4262 `ColdDiscardHint:` + fmt.Sprintf("%v", this.ColdDiscardHint) + `,`,
4263 `LowMmioGapInMb:` + fmt.Sprintf("%v", this.LowMmioGapInMb) + `,`,
4264 `HighMmioBaseInMb:` + fmt.Sprintf("%v", this.HighMmioBaseInMb) + `,`,
4265 `HighMmioGapInMb:` + fmt.Sprintf("%v", this.HighMmioGapInMb) + `,`,
4266 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4267 `}`,
4268 }, "")
4269 return s
4270 }
4271 func (this *ProcessorConfig) String() string {
4272 if this == nil {
4273 return "nil"
4274 }
4275 s := strings.Join([]string{`&ProcessorConfig{`,
4276 `ProcessorCount:` + fmt.Sprintf("%v", this.ProcessorCount) + `,`,
4277 `ProcessorWeight:` + fmt.Sprintf("%v", this.ProcessorWeight) + `,`,
4278 `ProcessorLimit:` + fmt.Sprintf("%v", this.ProcessorLimit) + `,`,
4279 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4280 `}`,
4281 }, "")
4282 return s
4283 }
4284 func (this *DevicesConfig) String() string {
4285 if this == nil {
4286 return "nil"
4287 }
4288 repeatedStringForScsiDisks := "[]*SCSIDisk{"
4289 for _, f := range this.ScsiDisks {
4290 repeatedStringForScsiDisks += strings.Replace(f.String(), "SCSIDisk", "SCSIDisk", 1) + ","
4291 }
4292 repeatedStringForScsiDisks += "}"
4293 repeatedStringForVpmemDisks := "[]*VPMEMDisk{"
4294 for _, f := range this.VpmemDisks {
4295 repeatedStringForVpmemDisks += strings.Replace(f.String(), "VPMEMDisk", "VPMEMDisk", 1) + ","
4296 }
4297 repeatedStringForVpmemDisks += "}"
4298 repeatedStringForNicConfig := "[]*NICConfig{"
4299 for _, f := range this.NicConfig {
4300 repeatedStringForNicConfig += strings.Replace(f.String(), "NICConfig", "NICConfig", 1) + ","
4301 }
4302 repeatedStringForNicConfig += "}"
4303 repeatedStringForWindowsDevice := "[]*WindowsPCIDevice{"
4304 for _, f := range this.WindowsDevice {
4305 repeatedStringForWindowsDevice += strings.Replace(f.String(), "WindowsPCIDevice", "WindowsPCIDevice", 1) + ","
4306 }
4307 repeatedStringForWindowsDevice += "}"
4308 s := strings.Join([]string{`&DevicesConfig{`,
4309 `ScsiDisks:` + repeatedStringForScsiDisks + `,`,
4310 `VpmemDisks:` + repeatedStringForVpmemDisks + `,`,
4311 `NicConfig:` + repeatedStringForNicConfig + `,`,
4312 `WindowsDevice:` + repeatedStringForWindowsDevice + `,`,
4313 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4314 `}`,
4315 }, "")
4316 return s
4317 }
4318 func (this *VMConfig) String() string {
4319 if this == nil {
4320 return "nil"
4321 }
4322 keysForExtraData := make([]string, 0, len(this.ExtraData))
4323 for k, _ := range this.ExtraData {
4324 keysForExtraData = append(keysForExtraData, k)
4325 }
4326 github_com_gogo_protobuf_sortkeys.Strings(keysForExtraData)
4327 mapStringForExtraData := "map[string]string{"
4328 for _, k := range keysForExtraData {
4329 mapStringForExtraData += fmt.Sprintf("%v: %v,", k, this.ExtraData[k])
4330 }
4331 mapStringForExtraData += "}"
4332 s := strings.Join([]string{`&VMConfig{`,
4333 `MemoryConfig:` + strings.Replace(this.MemoryConfig.String(), "MemoryConfig", "MemoryConfig", 1) + `,`,
4334 `ProcessorConfig:` + strings.Replace(this.ProcessorConfig.String(), "ProcessorConfig", "ProcessorConfig", 1) + `,`,
4335 `DevicesConfig:` + strings.Replace(this.DevicesConfig.String(), "DevicesConfig", "DevicesConfig", 1) + `,`,
4336 `SerialConfig:` + strings.Replace(this.SerialConfig.String(), "SerialConfig", "SerialConfig", 1) + `,`,
4337 `BootConfig:` + fmt.Sprintf("%v", this.BootConfig) + `,`,
4338 `WindowsOptions:` + strings.Replace(this.WindowsOptions.String(), "WindowsOptions", "WindowsOptions", 1) + `,`,
4339 `ExtraData:` + mapStringForExtraData + `,`,
4340 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4341 `}`,
4342 }, "")
4343 return s
4344 }
4345 func (this *VMConfig_DirectBoot) String() string {
4346 if this == nil {
4347 return "nil"
4348 }
4349 s := strings.Join([]string{`&VMConfig_DirectBoot{`,
4350 `DirectBoot:` + strings.Replace(fmt.Sprintf("%v", this.DirectBoot), "DirectBoot", "DirectBoot", 1) + `,`,
4351 `}`,
4352 }, "")
4353 return s
4354 }
4355 func (this *VMConfig_Uefi) String() string {
4356 if this == nil {
4357 return "nil"
4358 }
4359 s := strings.Join([]string{`&VMConfig_Uefi{`,
4360 `Uefi:` + strings.Replace(fmt.Sprintf("%v", this.Uefi), "UEFI", "UEFI", 1) + `,`,
4361 `}`,
4362 }, "")
4363 return s
4364 }
4365 func (this *WindowsOptions) String() string {
4366 if this == nil {
4367 return "nil"
4368 }
4369 s := strings.Join([]string{`&WindowsOptions{`,
4370 `CpuGroupID:` + fmt.Sprintf("%v", this.CpuGroupID) + `,`,
4371 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4372 `}`,
4373 }, "")
4374 return s
4375 }
4376 func (this *SerialConfig) String() string {
4377 if this == nil {
4378 return "nil"
4379 }
4380 repeatedStringForPorts := "[]*SerialConfig_Config{"
4381 for _, f := range this.Ports {
4382 repeatedStringForPorts += strings.Replace(fmt.Sprintf("%v", f), "SerialConfig_Config", "SerialConfig_Config", 1) + ","
4383 }
4384 repeatedStringForPorts += "}"
4385 s := strings.Join([]string{`&SerialConfig{`,
4386 `Ports:` + repeatedStringForPorts + `,`,
4387 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4388 `}`,
4389 }, "")
4390 return s
4391 }
4392 func (this *SerialConfig_Config) String() string {
4393 if this == nil {
4394 return "nil"
4395 }
4396 s := strings.Join([]string{`&SerialConfig_Config{`,
4397 `Port:` + fmt.Sprintf("%v", this.Port) + `,`,
4398 `SocketPath:` + fmt.Sprintf("%v", this.SocketPath) + `,`,
4399 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4400 `}`,
4401 }, "")
4402 return s
4403 }
4404 func (this *CreateVMRequest) String() string {
4405 if this == nil {
4406 return "nil"
4407 }
4408 s := strings.Join([]string{`&CreateVMRequest{`,
4409 `Config:` + strings.Replace(this.Config.String(), "VMConfig", "VMConfig", 1) + `,`,
4410 `LogID:` + fmt.Sprintf("%v", this.LogID) + `,`,
4411 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4412 `}`,
4413 }, "")
4414 return s
4415 }
4416 func (this *InspectVMRequest) String() string {
4417 if this == nil {
4418 return "nil"
4419 }
4420 s := strings.Join([]string{`&InspectVMRequest{`,
4421 `Query:` + fmt.Sprintf("%v", this.Query) + `,`,
4422 `RecursionLimit:` + fmt.Sprintf("%v", this.RecursionLimit) + `,`,
4423 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4424 `}`,
4425 }, "")
4426 return s
4427 }
4428 func (this *InspectVMResponse) String() string {
4429 if this == nil {
4430 return "nil"
4431 }
4432 s := strings.Join([]string{`&InspectVMResponse{`,
4433 `Result:` + strings.Replace(fmt.Sprintf("%v", this.Result), "Value", "types.Value", 1) + `,`,
4434 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4435 `}`,
4436 }, "")
4437 return s
4438 }
4439 func (this *MemoryStats) String() string {
4440 if this == nil {
4441 return "nil"
4442 }
4443 s := strings.Join([]string{`&MemoryStats{`,
4444 `WorkingSetBytes:` + fmt.Sprintf("%v", this.WorkingSetBytes) + `,`,
4445 `AvailableMemory:` + fmt.Sprintf("%v", this.AvailableMemory) + `,`,
4446 `ReservedMemory:` + fmt.Sprintf("%v", this.ReservedMemory) + `,`,
4447 `AssignedMemory:` + fmt.Sprintf("%v", this.AssignedMemory) + `,`,
4448 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4449 `}`,
4450 }, "")
4451 return s
4452 }
4453 func (this *ProcessorStats) String() string {
4454 if this == nil {
4455 return "nil"
4456 }
4457 s := strings.Join([]string{`&ProcessorStats{`,
4458 `TotalRuntimeNs:` + fmt.Sprintf("%v", this.TotalRuntimeNs) + `,`,
4459 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4460 `}`,
4461 }, "")
4462 return s
4463 }
4464 func (this *PropertiesVMRequest) String() string {
4465 if this == nil {
4466 return "nil"
4467 }
4468 s := strings.Join([]string{`&PropertiesVMRequest{`,
4469 `Types:` + fmt.Sprintf("%v", this.Types) + `,`,
4470 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4471 `}`,
4472 }, "")
4473 return s
4474 }
4475 func (this *PropertiesVMResponse) String() string {
4476 if this == nil {
4477 return "nil"
4478 }
4479 s := strings.Join([]string{`&PropertiesVMResponse{`,
4480 `MemoryStats:` + strings.Replace(this.MemoryStats.String(), "MemoryStats", "MemoryStats", 1) + `,`,
4481 `ProcessorStats:` + strings.Replace(this.ProcessorStats.String(), "ProcessorStats", "ProcessorStats", 1) + `,`,
4482 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4483 `}`,
4484 }, "")
4485 return s
4486 }
4487 func (this *CapabilitiesVMResponse) String() string {
4488 if this == nil {
4489 return "nil"
4490 }
4491 repeatedStringForSupportedResources := "[]*CapabilitiesVMResponse_SupportedResource{"
4492 for _, f := range this.SupportedResources {
4493 repeatedStringForSupportedResources += strings.Replace(fmt.Sprintf("%v", f), "CapabilitiesVMResponse_SupportedResource", "CapabilitiesVMResponse_SupportedResource", 1) + ","
4494 }
4495 repeatedStringForSupportedResources += "}"
4496 s := strings.Join([]string{`&CapabilitiesVMResponse{`,
4497 `SupportedResources:` + repeatedStringForSupportedResources + `,`,
4498 `SupportedGuestOs:` + fmt.Sprintf("%v", this.SupportedGuestOs) + `,`,
4499 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4500 `}`,
4501 }, "")
4502 return s
4503 }
4504 func (this *CapabilitiesVMResponse_SupportedResource) String() string {
4505 if this == nil {
4506 return "nil"
4507 }
4508 s := strings.Join([]string{`&CapabilitiesVMResponse_SupportedResource{`,
4509 `Add:` + fmt.Sprintf("%v", this.Add) + `,`,
4510 `Remove:` + fmt.Sprintf("%v", this.Remove) + `,`,
4511 `Update:` + fmt.Sprintf("%v", this.Update) + `,`,
4512 `Resource:` + fmt.Sprintf("%v", this.Resource) + `,`,
4513 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4514 `}`,
4515 }, "")
4516 return s
4517 }
4518 func (this *HVSocketListen) String() string {
4519 if this == nil {
4520 return "nil"
4521 }
4522 s := strings.Join([]string{`&HVSocketListen{`,
4523 `ServiceID:` + fmt.Sprintf("%v", this.ServiceID) + `,`,
4524 `ListenerPath:` + fmt.Sprintf("%v", this.ListenerPath) + `,`,
4525 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4526 `}`,
4527 }, "")
4528 return s
4529 }
4530 func (this *VSockListen) String() string {
4531 if this == nil {
4532 return "nil"
4533 }
4534 s := strings.Join([]string{`&VSockListen{`,
4535 `Port:` + fmt.Sprintf("%v", this.Port) + `,`,
4536 `ListenerPath:` + fmt.Sprintf("%v", this.ListenerPath) + `,`,
4537 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4538 `}`,
4539 }, "")
4540 return s
4541 }
4542 func (this *VMSocketRequest) String() string {
4543 if this == nil {
4544 return "nil"
4545 }
4546 s := strings.Join([]string{`&VMSocketRequest{`,
4547 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
4548 `Config:` + fmt.Sprintf("%v", this.Config) + `,`,
4549 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4550 `}`,
4551 }, "")
4552 return s
4553 }
4554 func (this *VMSocketRequest_HvsocketList) String() string {
4555 if this == nil {
4556 return "nil"
4557 }
4558 s := strings.Join([]string{`&VMSocketRequest_HvsocketList{`,
4559 `HvsocketList:` + strings.Replace(fmt.Sprintf("%v", this.HvsocketList), "HVSocketListen", "HVSocketListen", 1) + `,`,
4560 `}`,
4561 }, "")
4562 return s
4563 }
4564 func (this *VMSocketRequest_VsockListen) String() string {
4565 if this == nil {
4566 return "nil"
4567 }
4568 s := strings.Join([]string{`&VMSocketRequest_VsockListen{`,
4569 `VsockListen:` + strings.Replace(fmt.Sprintf("%v", this.VsockListen), "VSockListen", "VSockListen", 1) + `,`,
4570 `}`,
4571 }, "")
4572 return s
4573 }
4574 func (this *SCSIDisk) String() string {
4575 if this == nil {
4576 return "nil"
4577 }
4578 s := strings.Join([]string{`&SCSIDisk{`,
4579 `Controller:` + fmt.Sprintf("%v", this.Controller) + `,`,
4580 `Lun:` + fmt.Sprintf("%v", this.Lun) + `,`,
4581 `HostPath:` + fmt.Sprintf("%v", this.HostPath) + `,`,
4582 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
4583 `ReadOnly:` + fmt.Sprintf("%v", this.ReadOnly) + `,`,
4584 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4585 `}`,
4586 }, "")
4587 return s
4588 }
4589 func (this *VPMEMDisk) String() string {
4590 if this == nil {
4591 return "nil"
4592 }
4593 s := strings.Join([]string{`&VPMEMDisk{`,
4594 `HostPath:` + fmt.Sprintf("%v", this.HostPath) + `,`,
4595 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
4596 `ReadOnly:` + fmt.Sprintf("%v", this.ReadOnly) + `,`,
4597 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4598 `}`,
4599 }, "")
4600 return s
4601 }
4602 func (this *NICConfig) String() string {
4603 if this == nil {
4604 return "nil"
4605 }
4606 s := strings.Join([]string{`&NICConfig{`,
4607 `NicID:` + fmt.Sprintf("%v", this.NicID) + `,`,
4608 `PortID:` + fmt.Sprintf("%v", this.PortID) + `,`,
4609 `MacAddress:` + fmt.Sprintf("%v", this.MacAddress) + `,`,
4610 `SwitchID:` + fmt.Sprintf("%v", this.SwitchID) + `,`,
4611 `NicName:` + fmt.Sprintf("%v", this.NicName) + `,`,
4612 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4613 `}`,
4614 }, "")
4615 return s
4616 }
4617 func (this *WindowsPCIDevice) String() string {
4618 if this == nil {
4619 return "nil"
4620 }
4621 s := strings.Join([]string{`&WindowsPCIDevice{`,
4622 `InstanceID:` + fmt.Sprintf("%v", this.InstanceID) + `,`,
4623 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4624 `}`,
4625 }, "")
4626 return s
4627 }
4628 func (this *ModifyMemoryRequest) String() string {
4629 if this == nil {
4630 return "nil"
4631 }
4632 s := strings.Join([]string{`&ModifyMemoryRequest{`,
4633 `MemoryMb:` + fmt.Sprintf("%v", this.MemoryMb) + `,`,
4634 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4635 `}`,
4636 }, "")
4637 return s
4638 }
4639 func (this *ModifyProcessorRequest) String() string {
4640 if this == nil {
4641 return "nil"
4642 }
4643 s := strings.Join([]string{`&ModifyProcessorRequest{`,
4644 `ProcessorIndex:` + fmt.Sprintf("%v", this.ProcessorIndex) + `,`,
4645 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4646 `}`,
4647 }, "")
4648 return s
4649 }
4650 func (this *ModifyProcessorConfigRequest) String() string {
4651 if this == nil {
4652 return "nil"
4653 }
4654 s := strings.Join([]string{`&ModifyProcessorConfigRequest{`,
4655 `ProcessorWeight:` + fmt.Sprintf("%v", this.ProcessorWeight) + `,`,
4656 `ProcessorLimit:` + fmt.Sprintf("%v", this.ProcessorLimit) + `,`,
4657 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4658 `}`,
4659 }, "")
4660 return s
4661 }
4662 func (this *ModifyResourceRequest) String() string {
4663 if this == nil {
4664 return "nil"
4665 }
4666 s := strings.Join([]string{`&ModifyResourceRequest{`,
4667 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
4668 `Resource:` + fmt.Sprintf("%v", this.Resource) + `,`,
4669 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4670 `}`,
4671 }, "")
4672 return s
4673 }
4674 func (this *ModifyResourceRequest_Processor) String() string {
4675 if this == nil {
4676 return "nil"
4677 }
4678 s := strings.Join([]string{`&ModifyResourceRequest_Processor{`,
4679 `Processor:` + strings.Replace(fmt.Sprintf("%v", this.Processor), "ModifyProcessorRequest", "ModifyProcessorRequest", 1) + `,`,
4680 `}`,
4681 }, "")
4682 return s
4683 }
4684 func (this *ModifyResourceRequest_ProcessorConfig) String() string {
4685 if this == nil {
4686 return "nil"
4687 }
4688 s := strings.Join([]string{`&ModifyResourceRequest_ProcessorConfig{`,
4689 `ProcessorConfig:` + strings.Replace(fmt.Sprintf("%v", this.ProcessorConfig), "ModifyProcessorConfigRequest", "ModifyProcessorConfigRequest", 1) + `,`,
4690 `}`,
4691 }, "")
4692 return s
4693 }
4694 func (this *ModifyResourceRequest_Memory) String() string {
4695 if this == nil {
4696 return "nil"
4697 }
4698 s := strings.Join([]string{`&ModifyResourceRequest_Memory{`,
4699 `Memory:` + strings.Replace(fmt.Sprintf("%v", this.Memory), "ModifyMemoryRequest", "ModifyMemoryRequest", 1) + `,`,
4700 `}`,
4701 }, "")
4702 return s
4703 }
4704 func (this *ModifyResourceRequest_ScsiDisk) String() string {
4705 if this == nil {
4706 return "nil"
4707 }
4708 s := strings.Join([]string{`&ModifyResourceRequest_ScsiDisk{`,
4709 `ScsiDisk:` + strings.Replace(fmt.Sprintf("%v", this.ScsiDisk), "SCSIDisk", "SCSIDisk", 1) + `,`,
4710 `}`,
4711 }, "")
4712 return s
4713 }
4714 func (this *ModifyResourceRequest_VpmemDisk) String() string {
4715 if this == nil {
4716 return "nil"
4717 }
4718 s := strings.Join([]string{`&ModifyResourceRequest_VpmemDisk{`,
4719 `VpmemDisk:` + strings.Replace(fmt.Sprintf("%v", this.VpmemDisk), "VPMEMDisk", "VPMEMDisk", 1) + `,`,
4720 `}`,
4721 }, "")
4722 return s
4723 }
4724 func (this *ModifyResourceRequest_NicConfig) String() string {
4725 if this == nil {
4726 return "nil"
4727 }
4728 s := strings.Join([]string{`&ModifyResourceRequest_NicConfig{`,
4729 `NicConfig:` + strings.Replace(fmt.Sprintf("%v", this.NicConfig), "NICConfig", "NICConfig", 1) + `,`,
4730 `}`,
4731 }, "")
4732 return s
4733 }
4734 func (this *ModifyResourceRequest_WindowsDevice) String() string {
4735 if this == nil {
4736 return "nil"
4737 }
4738 s := strings.Join([]string{`&ModifyResourceRequest_WindowsDevice{`,
4739 `WindowsDevice:` + strings.Replace(fmt.Sprintf("%v", this.WindowsDevice), "WindowsPCIDevice", "WindowsPCIDevice", 1) + `,`,
4740 `}`,
4741 }, "")
4742 return s
4743 }
4744 func valueToStringVmservice(v interface{}) string {
4745 rv := reflect.ValueOf(v)
4746 if rv.IsNil() {
4747 return "nil"
4748 }
4749 pv := reflect.Indirect(rv).Interface()
4750 return fmt.Sprintf("*%v", pv)
4751 }
4752
4753 type VMService interface {
4754 CreateVM(ctx context.Context, req *CreateVMRequest) (*types.Empty, error)
4755 TeardownVM(ctx context.Context, req *types.Empty) (*types.Empty, error)
4756 PauseVM(ctx context.Context, req *types.Empty) (*types.Empty, error)
4757 ResumeVM(ctx context.Context, req *types.Empty) (*types.Empty, error)
4758 WaitVM(ctx context.Context, req *types.Empty) (*types.Empty, error)
4759 InspectVM(ctx context.Context, req *InspectVMRequest) (*InspectVMResponse, error)
4760 CapabilitiesVM(ctx context.Context, req *types.Empty) (*CapabilitiesVMResponse, error)
4761 PropertiesVM(ctx context.Context, req *PropertiesVMRequest) (*PropertiesVMResponse, error)
4762 ModifyResource(ctx context.Context, req *ModifyResourceRequest) (*types.Empty, error)
4763 VMSocket(ctx context.Context, req *VMSocketRequest) (*types.Empty, error)
4764 Quit(ctx context.Context, req *types.Empty) (*types.Empty, error)
4765 }
4766
4767 func RegisterVMService(srv *github_com_containerd_ttrpc.Server, svc VMService) {
4768 srv.Register("vmservice.VM", map[string]github_com_containerd_ttrpc.Method{
4769 "CreateVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
4770 var req CreateVMRequest
4771 if err := unmarshal(&req); err != nil {
4772 return nil, err
4773 }
4774 return svc.CreateVM(ctx, &req)
4775 },
4776 "TeardownVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
4777 var req types.Empty
4778 if err := unmarshal(&req); err != nil {
4779 return nil, err
4780 }
4781 return svc.TeardownVM(ctx, &req)
4782 },
4783 "PauseVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
4784 var req types.Empty
4785 if err := unmarshal(&req); err != nil {
4786 return nil, err
4787 }
4788 return svc.PauseVM(ctx, &req)
4789 },
4790 "ResumeVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
4791 var req types.Empty
4792 if err := unmarshal(&req); err != nil {
4793 return nil, err
4794 }
4795 return svc.ResumeVM(ctx, &req)
4796 },
4797 "WaitVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
4798 var req types.Empty
4799 if err := unmarshal(&req); err != nil {
4800 return nil, err
4801 }
4802 return svc.WaitVM(ctx, &req)
4803 },
4804 "InspectVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
4805 var req InspectVMRequest
4806 if err := unmarshal(&req); err != nil {
4807 return nil, err
4808 }
4809 return svc.InspectVM(ctx, &req)
4810 },
4811 "CapabilitiesVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
4812 var req types.Empty
4813 if err := unmarshal(&req); err != nil {
4814 return nil, err
4815 }
4816 return svc.CapabilitiesVM(ctx, &req)
4817 },
4818 "PropertiesVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
4819 var req PropertiesVMRequest
4820 if err := unmarshal(&req); err != nil {
4821 return nil, err
4822 }
4823 return svc.PropertiesVM(ctx, &req)
4824 },
4825 "ModifyResource": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
4826 var req ModifyResourceRequest
4827 if err := unmarshal(&req); err != nil {
4828 return nil, err
4829 }
4830 return svc.ModifyResource(ctx, &req)
4831 },
4832 "VMSocket": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
4833 var req VMSocketRequest
4834 if err := unmarshal(&req); err != nil {
4835 return nil, err
4836 }
4837 return svc.VMSocket(ctx, &req)
4838 },
4839 "Quit": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
4840 var req types.Empty
4841 if err := unmarshal(&req); err != nil {
4842 return nil, err
4843 }
4844 return svc.Quit(ctx, &req)
4845 },
4846 })
4847 }
4848
4849 type vMClient struct {
4850 client *github_com_containerd_ttrpc.Client
4851 }
4852
4853 func NewVMClient(client *github_com_containerd_ttrpc.Client) VMService {
4854 return &vMClient{
4855 client: client,
4856 }
4857 }
4858
4859 func (c *vMClient) CreateVM(ctx context.Context, req *CreateVMRequest) (*types.Empty, error) {
4860 var resp types.Empty
4861 if err := c.client.Call(ctx, "vmservice.VM", "CreateVM", req, &resp); err != nil {
4862 return nil, err
4863 }
4864 return &resp, nil
4865 }
4866
4867 func (c *vMClient) TeardownVM(ctx context.Context, req *types.Empty) (*types.Empty, error) {
4868 var resp types.Empty
4869 if err := c.client.Call(ctx, "vmservice.VM", "TeardownVM", req, &resp); err != nil {
4870 return nil, err
4871 }
4872 return &resp, nil
4873 }
4874
4875 func (c *vMClient) PauseVM(ctx context.Context, req *types.Empty) (*types.Empty, error) {
4876 var resp types.Empty
4877 if err := c.client.Call(ctx, "vmservice.VM", "PauseVM", req, &resp); err != nil {
4878 return nil, err
4879 }
4880 return &resp, nil
4881 }
4882
4883 func (c *vMClient) ResumeVM(ctx context.Context, req *types.Empty) (*types.Empty, error) {
4884 var resp types.Empty
4885 if err := c.client.Call(ctx, "vmservice.VM", "ResumeVM", req, &resp); err != nil {
4886 return nil, err
4887 }
4888 return &resp, nil
4889 }
4890
4891 func (c *vMClient) WaitVM(ctx context.Context, req *types.Empty) (*types.Empty, error) {
4892 var resp types.Empty
4893 if err := c.client.Call(ctx, "vmservice.VM", "WaitVM", req, &resp); err != nil {
4894 return nil, err
4895 }
4896 return &resp, nil
4897 }
4898
4899 func (c *vMClient) InspectVM(ctx context.Context, req *InspectVMRequest) (*InspectVMResponse, error) {
4900 var resp InspectVMResponse
4901 if err := c.client.Call(ctx, "vmservice.VM", "InspectVM", req, &resp); err != nil {
4902 return nil, err
4903 }
4904 return &resp, nil
4905 }
4906
4907 func (c *vMClient) CapabilitiesVM(ctx context.Context, req *types.Empty) (*CapabilitiesVMResponse, error) {
4908 var resp CapabilitiesVMResponse
4909 if err := c.client.Call(ctx, "vmservice.VM", "CapabilitiesVM", req, &resp); err != nil {
4910 return nil, err
4911 }
4912 return &resp, nil
4913 }
4914
4915 func (c *vMClient) PropertiesVM(ctx context.Context, req *PropertiesVMRequest) (*PropertiesVMResponse, error) {
4916 var resp PropertiesVMResponse
4917 if err := c.client.Call(ctx, "vmservice.VM", "PropertiesVM", req, &resp); err != nil {
4918 return nil, err
4919 }
4920 return &resp, nil
4921 }
4922
4923 func (c *vMClient) ModifyResource(ctx context.Context, req *ModifyResourceRequest) (*types.Empty, error) {
4924 var resp types.Empty
4925 if err := c.client.Call(ctx, "vmservice.VM", "ModifyResource", req, &resp); err != nil {
4926 return nil, err
4927 }
4928 return &resp, nil
4929 }
4930
4931 func (c *vMClient) VMSocket(ctx context.Context, req *VMSocketRequest) (*types.Empty, error) {
4932 var resp types.Empty
4933 if err := c.client.Call(ctx, "vmservice.VM", "VMSocket", req, &resp); err != nil {
4934 return nil, err
4935 }
4936 return &resp, nil
4937 }
4938
4939 func (c *vMClient) Quit(ctx context.Context, req *types.Empty) (*types.Empty, error) {
4940 var resp types.Empty
4941 if err := c.client.Call(ctx, "vmservice.VM", "Quit", req, &resp); err != nil {
4942 return nil, err
4943 }
4944 return &resp, nil
4945 }
4946 func (m *DirectBoot) Unmarshal(dAtA []byte) error {
4947 l := len(dAtA)
4948 iNdEx := 0
4949 for iNdEx < l {
4950 preIndex := iNdEx
4951 var wire uint64
4952 for shift := uint(0); ; shift += 7 {
4953 if shift >= 64 {
4954 return ErrIntOverflowVmservice
4955 }
4956 if iNdEx >= l {
4957 return io.ErrUnexpectedEOF
4958 }
4959 b := dAtA[iNdEx]
4960 iNdEx++
4961 wire |= uint64(b&0x7F) << shift
4962 if b < 0x80 {
4963 break
4964 }
4965 }
4966 fieldNum := int32(wire >> 3)
4967 wireType := int(wire & 0x7)
4968 if wireType == 4 {
4969 return fmt.Errorf("proto: DirectBoot: wiretype end group for non-group")
4970 }
4971 if fieldNum <= 0 {
4972 return fmt.Errorf("proto: DirectBoot: illegal tag %d (wire type %d)", fieldNum, wire)
4973 }
4974 switch fieldNum {
4975 case 1:
4976 if wireType != 2 {
4977 return fmt.Errorf("proto: wrong wireType = %d for field KernelPath", wireType)
4978 }
4979 var stringLen uint64
4980 for shift := uint(0); ; shift += 7 {
4981 if shift >= 64 {
4982 return ErrIntOverflowVmservice
4983 }
4984 if iNdEx >= l {
4985 return io.ErrUnexpectedEOF
4986 }
4987 b := dAtA[iNdEx]
4988 iNdEx++
4989 stringLen |= uint64(b&0x7F) << shift
4990 if b < 0x80 {
4991 break
4992 }
4993 }
4994 intStringLen := int(stringLen)
4995 if intStringLen < 0 {
4996 return ErrInvalidLengthVmservice
4997 }
4998 postIndex := iNdEx + intStringLen
4999 if postIndex < 0 {
5000 return ErrInvalidLengthVmservice
5001 }
5002 if postIndex > l {
5003 return io.ErrUnexpectedEOF
5004 }
5005 m.KernelPath = string(dAtA[iNdEx:postIndex])
5006 iNdEx = postIndex
5007 case 2:
5008 if wireType != 2 {
5009 return fmt.Errorf("proto: wrong wireType = %d for field InitrdPath", wireType)
5010 }
5011 var stringLen uint64
5012 for shift := uint(0); ; shift += 7 {
5013 if shift >= 64 {
5014 return ErrIntOverflowVmservice
5015 }
5016 if iNdEx >= l {
5017 return io.ErrUnexpectedEOF
5018 }
5019 b := dAtA[iNdEx]
5020 iNdEx++
5021 stringLen |= uint64(b&0x7F) << shift
5022 if b < 0x80 {
5023 break
5024 }
5025 }
5026 intStringLen := int(stringLen)
5027 if intStringLen < 0 {
5028 return ErrInvalidLengthVmservice
5029 }
5030 postIndex := iNdEx + intStringLen
5031 if postIndex < 0 {
5032 return ErrInvalidLengthVmservice
5033 }
5034 if postIndex > l {
5035 return io.ErrUnexpectedEOF
5036 }
5037 m.InitrdPath = string(dAtA[iNdEx:postIndex])
5038 iNdEx = postIndex
5039 case 3:
5040 if wireType != 2 {
5041 return fmt.Errorf("proto: wrong wireType = %d for field KernelCmdline", wireType)
5042 }
5043 var stringLen uint64
5044 for shift := uint(0); ; shift += 7 {
5045 if shift >= 64 {
5046 return ErrIntOverflowVmservice
5047 }
5048 if iNdEx >= l {
5049 return io.ErrUnexpectedEOF
5050 }
5051 b := dAtA[iNdEx]
5052 iNdEx++
5053 stringLen |= uint64(b&0x7F) << shift
5054 if b < 0x80 {
5055 break
5056 }
5057 }
5058 intStringLen := int(stringLen)
5059 if intStringLen < 0 {
5060 return ErrInvalidLengthVmservice
5061 }
5062 postIndex := iNdEx + intStringLen
5063 if postIndex < 0 {
5064 return ErrInvalidLengthVmservice
5065 }
5066 if postIndex > l {
5067 return io.ErrUnexpectedEOF
5068 }
5069 m.KernelCmdline = string(dAtA[iNdEx:postIndex])
5070 iNdEx = postIndex
5071 default:
5072 iNdEx = preIndex
5073 skippy, err := skipVmservice(dAtA[iNdEx:])
5074 if err != nil {
5075 return err
5076 }
5077 if (skippy < 0) || (iNdEx+skippy) < 0 {
5078 return ErrInvalidLengthVmservice
5079 }
5080 if (iNdEx + skippy) > l {
5081 return io.ErrUnexpectedEOF
5082 }
5083 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5084 iNdEx += skippy
5085 }
5086 }
5087
5088 if iNdEx > l {
5089 return io.ErrUnexpectedEOF
5090 }
5091 return nil
5092 }
5093 func (m *UEFI) Unmarshal(dAtA []byte) error {
5094 l := len(dAtA)
5095 iNdEx := 0
5096 for iNdEx < l {
5097 preIndex := iNdEx
5098 var wire uint64
5099 for shift := uint(0); ; shift += 7 {
5100 if shift >= 64 {
5101 return ErrIntOverflowVmservice
5102 }
5103 if iNdEx >= l {
5104 return io.ErrUnexpectedEOF
5105 }
5106 b := dAtA[iNdEx]
5107 iNdEx++
5108 wire |= uint64(b&0x7F) << shift
5109 if b < 0x80 {
5110 break
5111 }
5112 }
5113 fieldNum := int32(wire >> 3)
5114 wireType := int(wire & 0x7)
5115 if wireType == 4 {
5116 return fmt.Errorf("proto: UEFI: wiretype end group for non-group")
5117 }
5118 if fieldNum <= 0 {
5119 return fmt.Errorf("proto: UEFI: illegal tag %d (wire type %d)", fieldNum, wire)
5120 }
5121 switch fieldNum {
5122 case 1:
5123 if wireType != 2 {
5124 return fmt.Errorf("proto: wrong wireType = %d for field FirmwarePath", wireType)
5125 }
5126 var stringLen uint64
5127 for shift := uint(0); ; shift += 7 {
5128 if shift >= 64 {
5129 return ErrIntOverflowVmservice
5130 }
5131 if iNdEx >= l {
5132 return io.ErrUnexpectedEOF
5133 }
5134 b := dAtA[iNdEx]
5135 iNdEx++
5136 stringLen |= uint64(b&0x7F) << shift
5137 if b < 0x80 {
5138 break
5139 }
5140 }
5141 intStringLen := int(stringLen)
5142 if intStringLen < 0 {
5143 return ErrInvalidLengthVmservice
5144 }
5145 postIndex := iNdEx + intStringLen
5146 if postIndex < 0 {
5147 return ErrInvalidLengthVmservice
5148 }
5149 if postIndex > l {
5150 return io.ErrUnexpectedEOF
5151 }
5152 m.FirmwarePath = string(dAtA[iNdEx:postIndex])
5153 iNdEx = postIndex
5154 case 2:
5155 if wireType != 2 {
5156 return fmt.Errorf("proto: wrong wireType = %d for field DevicePath", wireType)
5157 }
5158 var stringLen uint64
5159 for shift := uint(0); ; shift += 7 {
5160 if shift >= 64 {
5161 return ErrIntOverflowVmservice
5162 }
5163 if iNdEx >= l {
5164 return io.ErrUnexpectedEOF
5165 }
5166 b := dAtA[iNdEx]
5167 iNdEx++
5168 stringLen |= uint64(b&0x7F) << shift
5169 if b < 0x80 {
5170 break
5171 }
5172 }
5173 intStringLen := int(stringLen)
5174 if intStringLen < 0 {
5175 return ErrInvalidLengthVmservice
5176 }
5177 postIndex := iNdEx + intStringLen
5178 if postIndex < 0 {
5179 return ErrInvalidLengthVmservice
5180 }
5181 if postIndex > l {
5182 return io.ErrUnexpectedEOF
5183 }
5184 m.DevicePath = string(dAtA[iNdEx:postIndex])
5185 iNdEx = postIndex
5186 case 3:
5187 if wireType != 2 {
5188 return fmt.Errorf("proto: wrong wireType = %d for field OptionalData", wireType)
5189 }
5190 var stringLen uint64
5191 for shift := uint(0); ; shift += 7 {
5192 if shift >= 64 {
5193 return ErrIntOverflowVmservice
5194 }
5195 if iNdEx >= l {
5196 return io.ErrUnexpectedEOF
5197 }
5198 b := dAtA[iNdEx]
5199 iNdEx++
5200 stringLen |= uint64(b&0x7F) << shift
5201 if b < 0x80 {
5202 break
5203 }
5204 }
5205 intStringLen := int(stringLen)
5206 if intStringLen < 0 {
5207 return ErrInvalidLengthVmservice
5208 }
5209 postIndex := iNdEx + intStringLen
5210 if postIndex < 0 {
5211 return ErrInvalidLengthVmservice
5212 }
5213 if postIndex > l {
5214 return io.ErrUnexpectedEOF
5215 }
5216 m.OptionalData = string(dAtA[iNdEx:postIndex])
5217 iNdEx = postIndex
5218 default:
5219 iNdEx = preIndex
5220 skippy, err := skipVmservice(dAtA[iNdEx:])
5221 if err != nil {
5222 return err
5223 }
5224 if (skippy < 0) || (iNdEx+skippy) < 0 {
5225 return ErrInvalidLengthVmservice
5226 }
5227 if (iNdEx + skippy) > l {
5228 return io.ErrUnexpectedEOF
5229 }
5230 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5231 iNdEx += skippy
5232 }
5233 }
5234
5235 if iNdEx > l {
5236 return io.ErrUnexpectedEOF
5237 }
5238 return nil
5239 }
5240 func (m *MemoryConfig) Unmarshal(dAtA []byte) error {
5241 l := len(dAtA)
5242 iNdEx := 0
5243 for iNdEx < l {
5244 preIndex := iNdEx
5245 var wire uint64
5246 for shift := uint(0); ; shift += 7 {
5247 if shift >= 64 {
5248 return ErrIntOverflowVmservice
5249 }
5250 if iNdEx >= l {
5251 return io.ErrUnexpectedEOF
5252 }
5253 b := dAtA[iNdEx]
5254 iNdEx++
5255 wire |= uint64(b&0x7F) << shift
5256 if b < 0x80 {
5257 break
5258 }
5259 }
5260 fieldNum := int32(wire >> 3)
5261 wireType := int(wire & 0x7)
5262 if wireType == 4 {
5263 return fmt.Errorf("proto: MemoryConfig: wiretype end group for non-group")
5264 }
5265 if fieldNum <= 0 {
5266 return fmt.Errorf("proto: MemoryConfig: illegal tag %d (wire type %d)", fieldNum, wire)
5267 }
5268 switch fieldNum {
5269 case 1:
5270 if wireType != 0 {
5271 return fmt.Errorf("proto: wrong wireType = %d for field MemoryMb", wireType)
5272 }
5273 m.MemoryMb = 0
5274 for shift := uint(0); ; shift += 7 {
5275 if shift >= 64 {
5276 return ErrIntOverflowVmservice
5277 }
5278 if iNdEx >= l {
5279 return io.ErrUnexpectedEOF
5280 }
5281 b := dAtA[iNdEx]
5282 iNdEx++
5283 m.MemoryMb |= uint64(b&0x7F) << shift
5284 if b < 0x80 {
5285 break
5286 }
5287 }
5288 case 2:
5289 if wireType != 0 {
5290 return fmt.Errorf("proto: wrong wireType = %d for field AllowOvercommit", wireType)
5291 }
5292 var v int
5293 for shift := uint(0); ; shift += 7 {
5294 if shift >= 64 {
5295 return ErrIntOverflowVmservice
5296 }
5297 if iNdEx >= l {
5298 return io.ErrUnexpectedEOF
5299 }
5300 b := dAtA[iNdEx]
5301 iNdEx++
5302 v |= int(b&0x7F) << shift
5303 if b < 0x80 {
5304 break
5305 }
5306 }
5307 m.AllowOvercommit = bool(v != 0)
5308 case 3:
5309 if wireType != 0 {
5310 return fmt.Errorf("proto: wrong wireType = %d for field DeferredCommit", wireType)
5311 }
5312 var v int
5313 for shift := uint(0); ; shift += 7 {
5314 if shift >= 64 {
5315 return ErrIntOverflowVmservice
5316 }
5317 if iNdEx >= l {
5318 return io.ErrUnexpectedEOF
5319 }
5320 b := dAtA[iNdEx]
5321 iNdEx++
5322 v |= int(b&0x7F) << shift
5323 if b < 0x80 {
5324 break
5325 }
5326 }
5327 m.DeferredCommit = bool(v != 0)
5328 case 4:
5329 if wireType != 0 {
5330 return fmt.Errorf("proto: wrong wireType = %d for field HotHint", wireType)
5331 }
5332 var v int
5333 for shift := uint(0); ; shift += 7 {
5334 if shift >= 64 {
5335 return ErrIntOverflowVmservice
5336 }
5337 if iNdEx >= l {
5338 return io.ErrUnexpectedEOF
5339 }
5340 b := dAtA[iNdEx]
5341 iNdEx++
5342 v |= int(b&0x7F) << shift
5343 if b < 0x80 {
5344 break
5345 }
5346 }
5347 m.HotHint = bool(v != 0)
5348 case 5:
5349 if wireType != 0 {
5350 return fmt.Errorf("proto: wrong wireType = %d for field ColdHint", wireType)
5351 }
5352 var v int
5353 for shift := uint(0); ; shift += 7 {
5354 if shift >= 64 {
5355 return ErrIntOverflowVmservice
5356 }
5357 if iNdEx >= l {
5358 return io.ErrUnexpectedEOF
5359 }
5360 b := dAtA[iNdEx]
5361 iNdEx++
5362 v |= int(b&0x7F) << shift
5363 if b < 0x80 {
5364 break
5365 }
5366 }
5367 m.ColdHint = bool(v != 0)
5368 case 6:
5369 if wireType != 0 {
5370 return fmt.Errorf("proto: wrong wireType = %d for field ColdDiscardHint", wireType)
5371 }
5372 var v int
5373 for shift := uint(0); ; shift += 7 {
5374 if shift >= 64 {
5375 return ErrIntOverflowVmservice
5376 }
5377 if iNdEx >= l {
5378 return io.ErrUnexpectedEOF
5379 }
5380 b := dAtA[iNdEx]
5381 iNdEx++
5382 v |= int(b&0x7F) << shift
5383 if b < 0x80 {
5384 break
5385 }
5386 }
5387 m.ColdDiscardHint = bool(v != 0)
5388 case 7:
5389 if wireType != 0 {
5390 return fmt.Errorf("proto: wrong wireType = %d for field LowMmioGapInMb", wireType)
5391 }
5392 m.LowMmioGapInMb = 0
5393 for shift := uint(0); ; shift += 7 {
5394 if shift >= 64 {
5395 return ErrIntOverflowVmservice
5396 }
5397 if iNdEx >= l {
5398 return io.ErrUnexpectedEOF
5399 }
5400 b := dAtA[iNdEx]
5401 iNdEx++
5402 m.LowMmioGapInMb |= uint64(b&0x7F) << shift
5403 if b < 0x80 {
5404 break
5405 }
5406 }
5407 case 8:
5408 if wireType != 0 {
5409 return fmt.Errorf("proto: wrong wireType = %d for field HighMmioBaseInMb", wireType)
5410 }
5411 m.HighMmioBaseInMb = 0
5412 for shift := uint(0); ; shift += 7 {
5413 if shift >= 64 {
5414 return ErrIntOverflowVmservice
5415 }
5416 if iNdEx >= l {
5417 return io.ErrUnexpectedEOF
5418 }
5419 b := dAtA[iNdEx]
5420 iNdEx++
5421 m.HighMmioBaseInMb |= uint64(b&0x7F) << shift
5422 if b < 0x80 {
5423 break
5424 }
5425 }
5426 case 9:
5427 if wireType != 0 {
5428 return fmt.Errorf("proto: wrong wireType = %d for field HighMmioGapInMb", wireType)
5429 }
5430 m.HighMmioGapInMb = 0
5431 for shift := uint(0); ; shift += 7 {
5432 if shift >= 64 {
5433 return ErrIntOverflowVmservice
5434 }
5435 if iNdEx >= l {
5436 return io.ErrUnexpectedEOF
5437 }
5438 b := dAtA[iNdEx]
5439 iNdEx++
5440 m.HighMmioGapInMb |= uint64(b&0x7F) << shift
5441 if b < 0x80 {
5442 break
5443 }
5444 }
5445 default:
5446 iNdEx = preIndex
5447 skippy, err := skipVmservice(dAtA[iNdEx:])
5448 if err != nil {
5449 return err
5450 }
5451 if (skippy < 0) || (iNdEx+skippy) < 0 {
5452 return ErrInvalidLengthVmservice
5453 }
5454 if (iNdEx + skippy) > l {
5455 return io.ErrUnexpectedEOF
5456 }
5457 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5458 iNdEx += skippy
5459 }
5460 }
5461
5462 if iNdEx > l {
5463 return io.ErrUnexpectedEOF
5464 }
5465 return nil
5466 }
5467 func (m *ProcessorConfig) Unmarshal(dAtA []byte) error {
5468 l := len(dAtA)
5469 iNdEx := 0
5470 for iNdEx < l {
5471 preIndex := iNdEx
5472 var wire uint64
5473 for shift := uint(0); ; shift += 7 {
5474 if shift >= 64 {
5475 return ErrIntOverflowVmservice
5476 }
5477 if iNdEx >= l {
5478 return io.ErrUnexpectedEOF
5479 }
5480 b := dAtA[iNdEx]
5481 iNdEx++
5482 wire |= uint64(b&0x7F) << shift
5483 if b < 0x80 {
5484 break
5485 }
5486 }
5487 fieldNum := int32(wire >> 3)
5488 wireType := int(wire & 0x7)
5489 if wireType == 4 {
5490 return fmt.Errorf("proto: ProcessorConfig: wiretype end group for non-group")
5491 }
5492 if fieldNum <= 0 {
5493 return fmt.Errorf("proto: ProcessorConfig: illegal tag %d (wire type %d)", fieldNum, wire)
5494 }
5495 switch fieldNum {
5496 case 1:
5497 if wireType != 0 {
5498 return fmt.Errorf("proto: wrong wireType = %d for field ProcessorCount", wireType)
5499 }
5500 m.ProcessorCount = 0
5501 for shift := uint(0); ; shift += 7 {
5502 if shift >= 64 {
5503 return ErrIntOverflowVmservice
5504 }
5505 if iNdEx >= l {
5506 return io.ErrUnexpectedEOF
5507 }
5508 b := dAtA[iNdEx]
5509 iNdEx++
5510 m.ProcessorCount |= uint32(b&0x7F) << shift
5511 if b < 0x80 {
5512 break
5513 }
5514 }
5515 case 2:
5516 if wireType != 0 {
5517 return fmt.Errorf("proto: wrong wireType = %d for field ProcessorWeight", wireType)
5518 }
5519 m.ProcessorWeight = 0
5520 for shift := uint(0); ; shift += 7 {
5521 if shift >= 64 {
5522 return ErrIntOverflowVmservice
5523 }
5524 if iNdEx >= l {
5525 return io.ErrUnexpectedEOF
5526 }
5527 b := dAtA[iNdEx]
5528 iNdEx++
5529 m.ProcessorWeight |= uint32(b&0x7F) << shift
5530 if b < 0x80 {
5531 break
5532 }
5533 }
5534 case 3:
5535 if wireType != 0 {
5536 return fmt.Errorf("proto: wrong wireType = %d for field ProcessorLimit", wireType)
5537 }
5538 m.ProcessorLimit = 0
5539 for shift := uint(0); ; shift += 7 {
5540 if shift >= 64 {
5541 return ErrIntOverflowVmservice
5542 }
5543 if iNdEx >= l {
5544 return io.ErrUnexpectedEOF
5545 }
5546 b := dAtA[iNdEx]
5547 iNdEx++
5548 m.ProcessorLimit |= uint32(b&0x7F) << shift
5549 if b < 0x80 {
5550 break
5551 }
5552 }
5553 default:
5554 iNdEx = preIndex
5555 skippy, err := skipVmservice(dAtA[iNdEx:])
5556 if err != nil {
5557 return err
5558 }
5559 if (skippy < 0) || (iNdEx+skippy) < 0 {
5560 return ErrInvalidLengthVmservice
5561 }
5562 if (iNdEx + skippy) > l {
5563 return io.ErrUnexpectedEOF
5564 }
5565 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5566 iNdEx += skippy
5567 }
5568 }
5569
5570 if iNdEx > l {
5571 return io.ErrUnexpectedEOF
5572 }
5573 return nil
5574 }
5575 func (m *DevicesConfig) Unmarshal(dAtA []byte) error {
5576 l := len(dAtA)
5577 iNdEx := 0
5578 for iNdEx < l {
5579 preIndex := iNdEx
5580 var wire uint64
5581 for shift := uint(0); ; shift += 7 {
5582 if shift >= 64 {
5583 return ErrIntOverflowVmservice
5584 }
5585 if iNdEx >= l {
5586 return io.ErrUnexpectedEOF
5587 }
5588 b := dAtA[iNdEx]
5589 iNdEx++
5590 wire |= uint64(b&0x7F) << shift
5591 if b < 0x80 {
5592 break
5593 }
5594 }
5595 fieldNum := int32(wire >> 3)
5596 wireType := int(wire & 0x7)
5597 if wireType == 4 {
5598 return fmt.Errorf("proto: DevicesConfig: wiretype end group for non-group")
5599 }
5600 if fieldNum <= 0 {
5601 return fmt.Errorf("proto: DevicesConfig: illegal tag %d (wire type %d)", fieldNum, wire)
5602 }
5603 switch fieldNum {
5604 case 1:
5605 if wireType != 2 {
5606 return fmt.Errorf("proto: wrong wireType = %d for field ScsiDisks", wireType)
5607 }
5608 var msglen int
5609 for shift := uint(0); ; shift += 7 {
5610 if shift >= 64 {
5611 return ErrIntOverflowVmservice
5612 }
5613 if iNdEx >= l {
5614 return io.ErrUnexpectedEOF
5615 }
5616 b := dAtA[iNdEx]
5617 iNdEx++
5618 msglen |= int(b&0x7F) << shift
5619 if b < 0x80 {
5620 break
5621 }
5622 }
5623 if msglen < 0 {
5624 return ErrInvalidLengthVmservice
5625 }
5626 postIndex := iNdEx + msglen
5627 if postIndex < 0 {
5628 return ErrInvalidLengthVmservice
5629 }
5630 if postIndex > l {
5631 return io.ErrUnexpectedEOF
5632 }
5633 m.ScsiDisks = append(m.ScsiDisks, &SCSIDisk{})
5634 if err := m.ScsiDisks[len(m.ScsiDisks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5635 return err
5636 }
5637 iNdEx = postIndex
5638 case 2:
5639 if wireType != 2 {
5640 return fmt.Errorf("proto: wrong wireType = %d for field VpmemDisks", wireType)
5641 }
5642 var msglen int
5643 for shift := uint(0); ; shift += 7 {
5644 if shift >= 64 {
5645 return ErrIntOverflowVmservice
5646 }
5647 if iNdEx >= l {
5648 return io.ErrUnexpectedEOF
5649 }
5650 b := dAtA[iNdEx]
5651 iNdEx++
5652 msglen |= int(b&0x7F) << shift
5653 if b < 0x80 {
5654 break
5655 }
5656 }
5657 if msglen < 0 {
5658 return ErrInvalidLengthVmservice
5659 }
5660 postIndex := iNdEx + msglen
5661 if postIndex < 0 {
5662 return ErrInvalidLengthVmservice
5663 }
5664 if postIndex > l {
5665 return io.ErrUnexpectedEOF
5666 }
5667 m.VpmemDisks = append(m.VpmemDisks, &VPMEMDisk{})
5668 if err := m.VpmemDisks[len(m.VpmemDisks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5669 return err
5670 }
5671 iNdEx = postIndex
5672 case 3:
5673 if wireType != 2 {
5674 return fmt.Errorf("proto: wrong wireType = %d for field NicConfig", wireType)
5675 }
5676 var msglen int
5677 for shift := uint(0); ; shift += 7 {
5678 if shift >= 64 {
5679 return ErrIntOverflowVmservice
5680 }
5681 if iNdEx >= l {
5682 return io.ErrUnexpectedEOF
5683 }
5684 b := dAtA[iNdEx]
5685 iNdEx++
5686 msglen |= int(b&0x7F) << shift
5687 if b < 0x80 {
5688 break
5689 }
5690 }
5691 if msglen < 0 {
5692 return ErrInvalidLengthVmservice
5693 }
5694 postIndex := iNdEx + msglen
5695 if postIndex < 0 {
5696 return ErrInvalidLengthVmservice
5697 }
5698 if postIndex > l {
5699 return io.ErrUnexpectedEOF
5700 }
5701 m.NicConfig = append(m.NicConfig, &NICConfig{})
5702 if err := m.NicConfig[len(m.NicConfig)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5703 return err
5704 }
5705 iNdEx = postIndex
5706 case 4:
5707 if wireType != 2 {
5708 return fmt.Errorf("proto: wrong wireType = %d for field WindowsDevice", wireType)
5709 }
5710 var msglen int
5711 for shift := uint(0); ; shift += 7 {
5712 if shift >= 64 {
5713 return ErrIntOverflowVmservice
5714 }
5715 if iNdEx >= l {
5716 return io.ErrUnexpectedEOF
5717 }
5718 b := dAtA[iNdEx]
5719 iNdEx++
5720 msglen |= int(b&0x7F) << shift
5721 if b < 0x80 {
5722 break
5723 }
5724 }
5725 if msglen < 0 {
5726 return ErrInvalidLengthVmservice
5727 }
5728 postIndex := iNdEx + msglen
5729 if postIndex < 0 {
5730 return ErrInvalidLengthVmservice
5731 }
5732 if postIndex > l {
5733 return io.ErrUnexpectedEOF
5734 }
5735 m.WindowsDevice = append(m.WindowsDevice, &WindowsPCIDevice{})
5736 if err := m.WindowsDevice[len(m.WindowsDevice)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5737 return err
5738 }
5739 iNdEx = postIndex
5740 default:
5741 iNdEx = preIndex
5742 skippy, err := skipVmservice(dAtA[iNdEx:])
5743 if err != nil {
5744 return err
5745 }
5746 if (skippy < 0) || (iNdEx+skippy) < 0 {
5747 return ErrInvalidLengthVmservice
5748 }
5749 if (iNdEx + skippy) > l {
5750 return io.ErrUnexpectedEOF
5751 }
5752 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5753 iNdEx += skippy
5754 }
5755 }
5756
5757 if iNdEx > l {
5758 return io.ErrUnexpectedEOF
5759 }
5760 return nil
5761 }
5762 func (m *VMConfig) Unmarshal(dAtA []byte) error {
5763 l := len(dAtA)
5764 iNdEx := 0
5765 for iNdEx < l {
5766 preIndex := iNdEx
5767 var wire uint64
5768 for shift := uint(0); ; shift += 7 {
5769 if shift >= 64 {
5770 return ErrIntOverflowVmservice
5771 }
5772 if iNdEx >= l {
5773 return io.ErrUnexpectedEOF
5774 }
5775 b := dAtA[iNdEx]
5776 iNdEx++
5777 wire |= uint64(b&0x7F) << shift
5778 if b < 0x80 {
5779 break
5780 }
5781 }
5782 fieldNum := int32(wire >> 3)
5783 wireType := int(wire & 0x7)
5784 if wireType == 4 {
5785 return fmt.Errorf("proto: VMConfig: wiretype end group for non-group")
5786 }
5787 if fieldNum <= 0 {
5788 return fmt.Errorf("proto: VMConfig: illegal tag %d (wire type %d)", fieldNum, wire)
5789 }
5790 switch fieldNum {
5791 case 1:
5792 if wireType != 2 {
5793 return fmt.Errorf("proto: wrong wireType = %d for field MemoryConfig", wireType)
5794 }
5795 var msglen int
5796 for shift := uint(0); ; shift += 7 {
5797 if shift >= 64 {
5798 return ErrIntOverflowVmservice
5799 }
5800 if iNdEx >= l {
5801 return io.ErrUnexpectedEOF
5802 }
5803 b := dAtA[iNdEx]
5804 iNdEx++
5805 msglen |= int(b&0x7F) << shift
5806 if b < 0x80 {
5807 break
5808 }
5809 }
5810 if msglen < 0 {
5811 return ErrInvalidLengthVmservice
5812 }
5813 postIndex := iNdEx + msglen
5814 if postIndex < 0 {
5815 return ErrInvalidLengthVmservice
5816 }
5817 if postIndex > l {
5818 return io.ErrUnexpectedEOF
5819 }
5820 if m.MemoryConfig == nil {
5821 m.MemoryConfig = &MemoryConfig{}
5822 }
5823 if err := m.MemoryConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5824 return err
5825 }
5826 iNdEx = postIndex
5827 case 2:
5828 if wireType != 2 {
5829 return fmt.Errorf("proto: wrong wireType = %d for field ProcessorConfig", wireType)
5830 }
5831 var msglen int
5832 for shift := uint(0); ; shift += 7 {
5833 if shift >= 64 {
5834 return ErrIntOverflowVmservice
5835 }
5836 if iNdEx >= l {
5837 return io.ErrUnexpectedEOF
5838 }
5839 b := dAtA[iNdEx]
5840 iNdEx++
5841 msglen |= int(b&0x7F) << shift
5842 if b < 0x80 {
5843 break
5844 }
5845 }
5846 if msglen < 0 {
5847 return ErrInvalidLengthVmservice
5848 }
5849 postIndex := iNdEx + msglen
5850 if postIndex < 0 {
5851 return ErrInvalidLengthVmservice
5852 }
5853 if postIndex > l {
5854 return io.ErrUnexpectedEOF
5855 }
5856 if m.ProcessorConfig == nil {
5857 m.ProcessorConfig = &ProcessorConfig{}
5858 }
5859 if err := m.ProcessorConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5860 return err
5861 }
5862 iNdEx = postIndex
5863 case 3:
5864 if wireType != 2 {
5865 return fmt.Errorf("proto: wrong wireType = %d for field DevicesConfig", wireType)
5866 }
5867 var msglen int
5868 for shift := uint(0); ; shift += 7 {
5869 if shift >= 64 {
5870 return ErrIntOverflowVmservice
5871 }
5872 if iNdEx >= l {
5873 return io.ErrUnexpectedEOF
5874 }
5875 b := dAtA[iNdEx]
5876 iNdEx++
5877 msglen |= int(b&0x7F) << shift
5878 if b < 0x80 {
5879 break
5880 }
5881 }
5882 if msglen < 0 {
5883 return ErrInvalidLengthVmservice
5884 }
5885 postIndex := iNdEx + msglen
5886 if postIndex < 0 {
5887 return ErrInvalidLengthVmservice
5888 }
5889 if postIndex > l {
5890 return io.ErrUnexpectedEOF
5891 }
5892 if m.DevicesConfig == nil {
5893 m.DevicesConfig = &DevicesConfig{}
5894 }
5895 if err := m.DevicesConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5896 return err
5897 }
5898 iNdEx = postIndex
5899 case 4:
5900 if wireType != 2 {
5901 return fmt.Errorf("proto: wrong wireType = %d for field SerialConfig", wireType)
5902 }
5903 var msglen int
5904 for shift := uint(0); ; shift += 7 {
5905 if shift >= 64 {
5906 return ErrIntOverflowVmservice
5907 }
5908 if iNdEx >= l {
5909 return io.ErrUnexpectedEOF
5910 }
5911 b := dAtA[iNdEx]
5912 iNdEx++
5913 msglen |= int(b&0x7F) << shift
5914 if b < 0x80 {
5915 break
5916 }
5917 }
5918 if msglen < 0 {
5919 return ErrInvalidLengthVmservice
5920 }
5921 postIndex := iNdEx + msglen
5922 if postIndex < 0 {
5923 return ErrInvalidLengthVmservice
5924 }
5925 if postIndex > l {
5926 return io.ErrUnexpectedEOF
5927 }
5928 if m.SerialConfig == nil {
5929 m.SerialConfig = &SerialConfig{}
5930 }
5931 if err := m.SerialConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5932 return err
5933 }
5934 iNdEx = postIndex
5935 case 5:
5936 if wireType != 2 {
5937 return fmt.Errorf("proto: wrong wireType = %d for field DirectBoot", wireType)
5938 }
5939 var msglen int
5940 for shift := uint(0); ; shift += 7 {
5941 if shift >= 64 {
5942 return ErrIntOverflowVmservice
5943 }
5944 if iNdEx >= l {
5945 return io.ErrUnexpectedEOF
5946 }
5947 b := dAtA[iNdEx]
5948 iNdEx++
5949 msglen |= int(b&0x7F) << shift
5950 if b < 0x80 {
5951 break
5952 }
5953 }
5954 if msglen < 0 {
5955 return ErrInvalidLengthVmservice
5956 }
5957 postIndex := iNdEx + msglen
5958 if postIndex < 0 {
5959 return ErrInvalidLengthVmservice
5960 }
5961 if postIndex > l {
5962 return io.ErrUnexpectedEOF
5963 }
5964 v := &DirectBoot{}
5965 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5966 return err
5967 }
5968 m.BootConfig = &VMConfig_DirectBoot{v}
5969 iNdEx = postIndex
5970 case 6:
5971 if wireType != 2 {
5972 return fmt.Errorf("proto: wrong wireType = %d for field Uefi", wireType)
5973 }
5974 var msglen int
5975 for shift := uint(0); ; shift += 7 {
5976 if shift >= 64 {
5977 return ErrIntOverflowVmservice
5978 }
5979 if iNdEx >= l {
5980 return io.ErrUnexpectedEOF
5981 }
5982 b := dAtA[iNdEx]
5983 iNdEx++
5984 msglen |= int(b&0x7F) << shift
5985 if b < 0x80 {
5986 break
5987 }
5988 }
5989 if msglen < 0 {
5990 return ErrInvalidLengthVmservice
5991 }
5992 postIndex := iNdEx + msglen
5993 if postIndex < 0 {
5994 return ErrInvalidLengthVmservice
5995 }
5996 if postIndex > l {
5997 return io.ErrUnexpectedEOF
5998 }
5999 v := &UEFI{}
6000 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6001 return err
6002 }
6003 m.BootConfig = &VMConfig_Uefi{v}
6004 iNdEx = postIndex
6005 case 7:
6006 if wireType != 2 {
6007 return fmt.Errorf("proto: wrong wireType = %d for field WindowsOptions", wireType)
6008 }
6009 var msglen int
6010 for shift := uint(0); ; shift += 7 {
6011 if shift >= 64 {
6012 return ErrIntOverflowVmservice
6013 }
6014 if iNdEx >= l {
6015 return io.ErrUnexpectedEOF
6016 }
6017 b := dAtA[iNdEx]
6018 iNdEx++
6019 msglen |= int(b&0x7F) << shift
6020 if b < 0x80 {
6021 break
6022 }
6023 }
6024 if msglen < 0 {
6025 return ErrInvalidLengthVmservice
6026 }
6027 postIndex := iNdEx + msglen
6028 if postIndex < 0 {
6029 return ErrInvalidLengthVmservice
6030 }
6031 if postIndex > l {
6032 return io.ErrUnexpectedEOF
6033 }
6034 if m.WindowsOptions == nil {
6035 m.WindowsOptions = &WindowsOptions{}
6036 }
6037 if err := m.WindowsOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6038 return err
6039 }
6040 iNdEx = postIndex
6041 case 8:
6042 if wireType != 2 {
6043 return fmt.Errorf("proto: wrong wireType = %d for field ExtraData", wireType)
6044 }
6045 var msglen int
6046 for shift := uint(0); ; shift += 7 {
6047 if shift >= 64 {
6048 return ErrIntOverflowVmservice
6049 }
6050 if iNdEx >= l {
6051 return io.ErrUnexpectedEOF
6052 }
6053 b := dAtA[iNdEx]
6054 iNdEx++
6055 msglen |= int(b&0x7F) << shift
6056 if b < 0x80 {
6057 break
6058 }
6059 }
6060 if msglen < 0 {
6061 return ErrInvalidLengthVmservice
6062 }
6063 postIndex := iNdEx + msglen
6064 if postIndex < 0 {
6065 return ErrInvalidLengthVmservice
6066 }
6067 if postIndex > l {
6068 return io.ErrUnexpectedEOF
6069 }
6070 if m.ExtraData == nil {
6071 m.ExtraData = make(map[string]string)
6072 }
6073 var mapkey string
6074 var mapvalue string
6075 for iNdEx < postIndex {
6076 entryPreIndex := iNdEx
6077 var wire uint64
6078 for shift := uint(0); ; shift += 7 {
6079 if shift >= 64 {
6080 return ErrIntOverflowVmservice
6081 }
6082 if iNdEx >= l {
6083 return io.ErrUnexpectedEOF
6084 }
6085 b := dAtA[iNdEx]
6086 iNdEx++
6087 wire |= uint64(b&0x7F) << shift
6088 if b < 0x80 {
6089 break
6090 }
6091 }
6092 fieldNum := int32(wire >> 3)
6093 if fieldNum == 1 {
6094 var stringLenmapkey uint64
6095 for shift := uint(0); ; shift += 7 {
6096 if shift >= 64 {
6097 return ErrIntOverflowVmservice
6098 }
6099 if iNdEx >= l {
6100 return io.ErrUnexpectedEOF
6101 }
6102 b := dAtA[iNdEx]
6103 iNdEx++
6104 stringLenmapkey |= uint64(b&0x7F) << shift
6105 if b < 0x80 {
6106 break
6107 }
6108 }
6109 intStringLenmapkey := int(stringLenmapkey)
6110 if intStringLenmapkey < 0 {
6111 return ErrInvalidLengthVmservice
6112 }
6113 postStringIndexmapkey := iNdEx + intStringLenmapkey
6114 if postStringIndexmapkey < 0 {
6115 return ErrInvalidLengthVmservice
6116 }
6117 if postStringIndexmapkey > l {
6118 return io.ErrUnexpectedEOF
6119 }
6120 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
6121 iNdEx = postStringIndexmapkey
6122 } else if fieldNum == 2 {
6123 var stringLenmapvalue uint64
6124 for shift := uint(0); ; shift += 7 {
6125 if shift >= 64 {
6126 return ErrIntOverflowVmservice
6127 }
6128 if iNdEx >= l {
6129 return io.ErrUnexpectedEOF
6130 }
6131 b := dAtA[iNdEx]
6132 iNdEx++
6133 stringLenmapvalue |= uint64(b&0x7F) << shift
6134 if b < 0x80 {
6135 break
6136 }
6137 }
6138 intStringLenmapvalue := int(stringLenmapvalue)
6139 if intStringLenmapvalue < 0 {
6140 return ErrInvalidLengthVmservice
6141 }
6142 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
6143 if postStringIndexmapvalue < 0 {
6144 return ErrInvalidLengthVmservice
6145 }
6146 if postStringIndexmapvalue > l {
6147 return io.ErrUnexpectedEOF
6148 }
6149 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
6150 iNdEx = postStringIndexmapvalue
6151 } else {
6152 iNdEx = entryPreIndex
6153 skippy, err := skipVmservice(dAtA[iNdEx:])
6154 if err != nil {
6155 return err
6156 }
6157 if (skippy < 0) || (iNdEx+skippy) < 0 {
6158 return ErrInvalidLengthVmservice
6159 }
6160 if (iNdEx + skippy) > postIndex {
6161 return io.ErrUnexpectedEOF
6162 }
6163 iNdEx += skippy
6164 }
6165 }
6166 m.ExtraData[mapkey] = mapvalue
6167 iNdEx = postIndex
6168 default:
6169 iNdEx = preIndex
6170 skippy, err := skipVmservice(dAtA[iNdEx:])
6171 if err != nil {
6172 return err
6173 }
6174 if (skippy < 0) || (iNdEx+skippy) < 0 {
6175 return ErrInvalidLengthVmservice
6176 }
6177 if (iNdEx + skippy) > l {
6178 return io.ErrUnexpectedEOF
6179 }
6180 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6181 iNdEx += skippy
6182 }
6183 }
6184
6185 if iNdEx > l {
6186 return io.ErrUnexpectedEOF
6187 }
6188 return nil
6189 }
6190 func (m *WindowsOptions) Unmarshal(dAtA []byte) error {
6191 l := len(dAtA)
6192 iNdEx := 0
6193 for iNdEx < l {
6194 preIndex := iNdEx
6195 var wire uint64
6196 for shift := uint(0); ; shift += 7 {
6197 if shift >= 64 {
6198 return ErrIntOverflowVmservice
6199 }
6200 if iNdEx >= l {
6201 return io.ErrUnexpectedEOF
6202 }
6203 b := dAtA[iNdEx]
6204 iNdEx++
6205 wire |= uint64(b&0x7F) << shift
6206 if b < 0x80 {
6207 break
6208 }
6209 }
6210 fieldNum := int32(wire >> 3)
6211 wireType := int(wire & 0x7)
6212 if wireType == 4 {
6213 return fmt.Errorf("proto: WindowsOptions: wiretype end group for non-group")
6214 }
6215 if fieldNum <= 0 {
6216 return fmt.Errorf("proto: WindowsOptions: illegal tag %d (wire type %d)", fieldNum, wire)
6217 }
6218 switch fieldNum {
6219 case 1:
6220 if wireType != 0 {
6221 return fmt.Errorf("proto: wrong wireType = %d for field CpuGroupID", wireType)
6222 }
6223 m.CpuGroupID = 0
6224 for shift := uint(0); ; shift += 7 {
6225 if shift >= 64 {
6226 return ErrIntOverflowVmservice
6227 }
6228 if iNdEx >= l {
6229 return io.ErrUnexpectedEOF
6230 }
6231 b := dAtA[iNdEx]
6232 iNdEx++
6233 m.CpuGroupID |= uint64(b&0x7F) << shift
6234 if b < 0x80 {
6235 break
6236 }
6237 }
6238 default:
6239 iNdEx = preIndex
6240 skippy, err := skipVmservice(dAtA[iNdEx:])
6241 if err != nil {
6242 return err
6243 }
6244 if (skippy < 0) || (iNdEx+skippy) < 0 {
6245 return ErrInvalidLengthVmservice
6246 }
6247 if (iNdEx + skippy) > l {
6248 return io.ErrUnexpectedEOF
6249 }
6250 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6251 iNdEx += skippy
6252 }
6253 }
6254
6255 if iNdEx > l {
6256 return io.ErrUnexpectedEOF
6257 }
6258 return nil
6259 }
6260 func (m *SerialConfig) Unmarshal(dAtA []byte) error {
6261 l := len(dAtA)
6262 iNdEx := 0
6263 for iNdEx < l {
6264 preIndex := iNdEx
6265 var wire uint64
6266 for shift := uint(0); ; shift += 7 {
6267 if shift >= 64 {
6268 return ErrIntOverflowVmservice
6269 }
6270 if iNdEx >= l {
6271 return io.ErrUnexpectedEOF
6272 }
6273 b := dAtA[iNdEx]
6274 iNdEx++
6275 wire |= uint64(b&0x7F) << shift
6276 if b < 0x80 {
6277 break
6278 }
6279 }
6280 fieldNum := int32(wire >> 3)
6281 wireType := int(wire & 0x7)
6282 if wireType == 4 {
6283 return fmt.Errorf("proto: SerialConfig: wiretype end group for non-group")
6284 }
6285 if fieldNum <= 0 {
6286 return fmt.Errorf("proto: SerialConfig: illegal tag %d (wire type %d)", fieldNum, wire)
6287 }
6288 switch fieldNum {
6289 case 3:
6290 if wireType != 2 {
6291 return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
6292 }
6293 var msglen int
6294 for shift := uint(0); ; shift += 7 {
6295 if shift >= 64 {
6296 return ErrIntOverflowVmservice
6297 }
6298 if iNdEx >= l {
6299 return io.ErrUnexpectedEOF
6300 }
6301 b := dAtA[iNdEx]
6302 iNdEx++
6303 msglen |= int(b&0x7F) << shift
6304 if b < 0x80 {
6305 break
6306 }
6307 }
6308 if msglen < 0 {
6309 return ErrInvalidLengthVmservice
6310 }
6311 postIndex := iNdEx + msglen
6312 if postIndex < 0 {
6313 return ErrInvalidLengthVmservice
6314 }
6315 if postIndex > l {
6316 return io.ErrUnexpectedEOF
6317 }
6318 m.Ports = append(m.Ports, &SerialConfig_Config{})
6319 if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6320 return err
6321 }
6322 iNdEx = postIndex
6323 default:
6324 iNdEx = preIndex
6325 skippy, err := skipVmservice(dAtA[iNdEx:])
6326 if err != nil {
6327 return err
6328 }
6329 if (skippy < 0) || (iNdEx+skippy) < 0 {
6330 return ErrInvalidLengthVmservice
6331 }
6332 if (iNdEx + skippy) > l {
6333 return io.ErrUnexpectedEOF
6334 }
6335 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6336 iNdEx += skippy
6337 }
6338 }
6339
6340 if iNdEx > l {
6341 return io.ErrUnexpectedEOF
6342 }
6343 return nil
6344 }
6345 func (m *SerialConfig_Config) Unmarshal(dAtA []byte) error {
6346 l := len(dAtA)
6347 iNdEx := 0
6348 for iNdEx < l {
6349 preIndex := iNdEx
6350 var wire uint64
6351 for shift := uint(0); ; shift += 7 {
6352 if shift >= 64 {
6353 return ErrIntOverflowVmservice
6354 }
6355 if iNdEx >= l {
6356 return io.ErrUnexpectedEOF
6357 }
6358 b := dAtA[iNdEx]
6359 iNdEx++
6360 wire |= uint64(b&0x7F) << shift
6361 if b < 0x80 {
6362 break
6363 }
6364 }
6365 fieldNum := int32(wire >> 3)
6366 wireType := int(wire & 0x7)
6367 if wireType == 4 {
6368 return fmt.Errorf("proto: Config: wiretype end group for non-group")
6369 }
6370 if fieldNum <= 0 {
6371 return fmt.Errorf("proto: Config: illegal tag %d (wire type %d)", fieldNum, wire)
6372 }
6373 switch fieldNum {
6374 case 1:
6375 if wireType != 0 {
6376 return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
6377 }
6378 m.Port = 0
6379 for shift := uint(0); ; shift += 7 {
6380 if shift >= 64 {
6381 return ErrIntOverflowVmservice
6382 }
6383 if iNdEx >= l {
6384 return io.ErrUnexpectedEOF
6385 }
6386 b := dAtA[iNdEx]
6387 iNdEx++
6388 m.Port |= uint32(b&0x7F) << shift
6389 if b < 0x80 {
6390 break
6391 }
6392 }
6393 case 2:
6394 if wireType != 2 {
6395 return fmt.Errorf("proto: wrong wireType = %d for field SocketPath", wireType)
6396 }
6397 var stringLen uint64
6398 for shift := uint(0); ; shift += 7 {
6399 if shift >= 64 {
6400 return ErrIntOverflowVmservice
6401 }
6402 if iNdEx >= l {
6403 return io.ErrUnexpectedEOF
6404 }
6405 b := dAtA[iNdEx]
6406 iNdEx++
6407 stringLen |= uint64(b&0x7F) << shift
6408 if b < 0x80 {
6409 break
6410 }
6411 }
6412 intStringLen := int(stringLen)
6413 if intStringLen < 0 {
6414 return ErrInvalidLengthVmservice
6415 }
6416 postIndex := iNdEx + intStringLen
6417 if postIndex < 0 {
6418 return ErrInvalidLengthVmservice
6419 }
6420 if postIndex > l {
6421 return io.ErrUnexpectedEOF
6422 }
6423 m.SocketPath = string(dAtA[iNdEx:postIndex])
6424 iNdEx = postIndex
6425 default:
6426 iNdEx = preIndex
6427 skippy, err := skipVmservice(dAtA[iNdEx:])
6428 if err != nil {
6429 return err
6430 }
6431 if (skippy < 0) || (iNdEx+skippy) < 0 {
6432 return ErrInvalidLengthVmservice
6433 }
6434 if (iNdEx + skippy) > l {
6435 return io.ErrUnexpectedEOF
6436 }
6437 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6438 iNdEx += skippy
6439 }
6440 }
6441
6442 if iNdEx > l {
6443 return io.ErrUnexpectedEOF
6444 }
6445 return nil
6446 }
6447 func (m *CreateVMRequest) Unmarshal(dAtA []byte) error {
6448 l := len(dAtA)
6449 iNdEx := 0
6450 for iNdEx < l {
6451 preIndex := iNdEx
6452 var wire uint64
6453 for shift := uint(0); ; shift += 7 {
6454 if shift >= 64 {
6455 return ErrIntOverflowVmservice
6456 }
6457 if iNdEx >= l {
6458 return io.ErrUnexpectedEOF
6459 }
6460 b := dAtA[iNdEx]
6461 iNdEx++
6462 wire |= uint64(b&0x7F) << shift
6463 if b < 0x80 {
6464 break
6465 }
6466 }
6467 fieldNum := int32(wire >> 3)
6468 wireType := int(wire & 0x7)
6469 if wireType == 4 {
6470 return fmt.Errorf("proto: CreateVMRequest: wiretype end group for non-group")
6471 }
6472 if fieldNum <= 0 {
6473 return fmt.Errorf("proto: CreateVMRequest: illegal tag %d (wire type %d)", fieldNum, wire)
6474 }
6475 switch fieldNum {
6476 case 1:
6477 if wireType != 2 {
6478 return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType)
6479 }
6480 var msglen int
6481 for shift := uint(0); ; shift += 7 {
6482 if shift >= 64 {
6483 return ErrIntOverflowVmservice
6484 }
6485 if iNdEx >= l {
6486 return io.ErrUnexpectedEOF
6487 }
6488 b := dAtA[iNdEx]
6489 iNdEx++
6490 msglen |= int(b&0x7F) << shift
6491 if b < 0x80 {
6492 break
6493 }
6494 }
6495 if msglen < 0 {
6496 return ErrInvalidLengthVmservice
6497 }
6498 postIndex := iNdEx + msglen
6499 if postIndex < 0 {
6500 return ErrInvalidLengthVmservice
6501 }
6502 if postIndex > l {
6503 return io.ErrUnexpectedEOF
6504 }
6505 if m.Config == nil {
6506 m.Config = &VMConfig{}
6507 }
6508 if err := m.Config.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6509 return err
6510 }
6511 iNdEx = postIndex
6512 case 2:
6513 if wireType != 2 {
6514 return fmt.Errorf("proto: wrong wireType = %d for field LogID", wireType)
6515 }
6516 var stringLen uint64
6517 for shift := uint(0); ; shift += 7 {
6518 if shift >= 64 {
6519 return ErrIntOverflowVmservice
6520 }
6521 if iNdEx >= l {
6522 return io.ErrUnexpectedEOF
6523 }
6524 b := dAtA[iNdEx]
6525 iNdEx++
6526 stringLen |= uint64(b&0x7F) << shift
6527 if b < 0x80 {
6528 break
6529 }
6530 }
6531 intStringLen := int(stringLen)
6532 if intStringLen < 0 {
6533 return ErrInvalidLengthVmservice
6534 }
6535 postIndex := iNdEx + intStringLen
6536 if postIndex < 0 {
6537 return ErrInvalidLengthVmservice
6538 }
6539 if postIndex > l {
6540 return io.ErrUnexpectedEOF
6541 }
6542 m.LogID = string(dAtA[iNdEx:postIndex])
6543 iNdEx = postIndex
6544 default:
6545 iNdEx = preIndex
6546 skippy, err := skipVmservice(dAtA[iNdEx:])
6547 if err != nil {
6548 return err
6549 }
6550 if (skippy < 0) || (iNdEx+skippy) < 0 {
6551 return ErrInvalidLengthVmservice
6552 }
6553 if (iNdEx + skippy) > l {
6554 return io.ErrUnexpectedEOF
6555 }
6556 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6557 iNdEx += skippy
6558 }
6559 }
6560
6561 if iNdEx > l {
6562 return io.ErrUnexpectedEOF
6563 }
6564 return nil
6565 }
6566 func (m *InspectVMRequest) Unmarshal(dAtA []byte) error {
6567 l := len(dAtA)
6568 iNdEx := 0
6569 for iNdEx < l {
6570 preIndex := iNdEx
6571 var wire uint64
6572 for shift := uint(0); ; shift += 7 {
6573 if shift >= 64 {
6574 return ErrIntOverflowVmservice
6575 }
6576 if iNdEx >= l {
6577 return io.ErrUnexpectedEOF
6578 }
6579 b := dAtA[iNdEx]
6580 iNdEx++
6581 wire |= uint64(b&0x7F) << shift
6582 if b < 0x80 {
6583 break
6584 }
6585 }
6586 fieldNum := int32(wire >> 3)
6587 wireType := int(wire & 0x7)
6588 if wireType == 4 {
6589 return fmt.Errorf("proto: InspectVMRequest: wiretype end group for non-group")
6590 }
6591 if fieldNum <= 0 {
6592 return fmt.Errorf("proto: InspectVMRequest: illegal tag %d (wire type %d)", fieldNum, wire)
6593 }
6594 switch fieldNum {
6595 case 1:
6596 if wireType != 2 {
6597 return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
6598 }
6599 var stringLen uint64
6600 for shift := uint(0); ; shift += 7 {
6601 if shift >= 64 {
6602 return ErrIntOverflowVmservice
6603 }
6604 if iNdEx >= l {
6605 return io.ErrUnexpectedEOF
6606 }
6607 b := dAtA[iNdEx]
6608 iNdEx++
6609 stringLen |= uint64(b&0x7F) << shift
6610 if b < 0x80 {
6611 break
6612 }
6613 }
6614 intStringLen := int(stringLen)
6615 if intStringLen < 0 {
6616 return ErrInvalidLengthVmservice
6617 }
6618 postIndex := iNdEx + intStringLen
6619 if postIndex < 0 {
6620 return ErrInvalidLengthVmservice
6621 }
6622 if postIndex > l {
6623 return io.ErrUnexpectedEOF
6624 }
6625 m.Query = string(dAtA[iNdEx:postIndex])
6626 iNdEx = postIndex
6627 case 2:
6628 if wireType != 0 {
6629 return fmt.Errorf("proto: wrong wireType = %d for field RecursionLimit", wireType)
6630 }
6631 m.RecursionLimit = 0
6632 for shift := uint(0); ; shift += 7 {
6633 if shift >= 64 {
6634 return ErrIntOverflowVmservice
6635 }
6636 if iNdEx >= l {
6637 return io.ErrUnexpectedEOF
6638 }
6639 b := dAtA[iNdEx]
6640 iNdEx++
6641 m.RecursionLimit |= uint32(b&0x7F) << shift
6642 if b < 0x80 {
6643 break
6644 }
6645 }
6646 default:
6647 iNdEx = preIndex
6648 skippy, err := skipVmservice(dAtA[iNdEx:])
6649 if err != nil {
6650 return err
6651 }
6652 if (skippy < 0) || (iNdEx+skippy) < 0 {
6653 return ErrInvalidLengthVmservice
6654 }
6655 if (iNdEx + skippy) > l {
6656 return io.ErrUnexpectedEOF
6657 }
6658 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6659 iNdEx += skippy
6660 }
6661 }
6662
6663 if iNdEx > l {
6664 return io.ErrUnexpectedEOF
6665 }
6666 return nil
6667 }
6668 func (m *InspectVMResponse) Unmarshal(dAtA []byte) error {
6669 l := len(dAtA)
6670 iNdEx := 0
6671 for iNdEx < l {
6672 preIndex := iNdEx
6673 var wire uint64
6674 for shift := uint(0); ; shift += 7 {
6675 if shift >= 64 {
6676 return ErrIntOverflowVmservice
6677 }
6678 if iNdEx >= l {
6679 return io.ErrUnexpectedEOF
6680 }
6681 b := dAtA[iNdEx]
6682 iNdEx++
6683 wire |= uint64(b&0x7F) << shift
6684 if b < 0x80 {
6685 break
6686 }
6687 }
6688 fieldNum := int32(wire >> 3)
6689 wireType := int(wire & 0x7)
6690 if wireType == 4 {
6691 return fmt.Errorf("proto: InspectVMResponse: wiretype end group for non-group")
6692 }
6693 if fieldNum <= 0 {
6694 return fmt.Errorf("proto: InspectVMResponse: illegal tag %d (wire type %d)", fieldNum, wire)
6695 }
6696 switch fieldNum {
6697 case 1:
6698 if wireType != 2 {
6699 return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
6700 }
6701 var msglen int
6702 for shift := uint(0); ; shift += 7 {
6703 if shift >= 64 {
6704 return ErrIntOverflowVmservice
6705 }
6706 if iNdEx >= l {
6707 return io.ErrUnexpectedEOF
6708 }
6709 b := dAtA[iNdEx]
6710 iNdEx++
6711 msglen |= int(b&0x7F) << shift
6712 if b < 0x80 {
6713 break
6714 }
6715 }
6716 if msglen < 0 {
6717 return ErrInvalidLengthVmservice
6718 }
6719 postIndex := iNdEx + msglen
6720 if postIndex < 0 {
6721 return ErrInvalidLengthVmservice
6722 }
6723 if postIndex > l {
6724 return io.ErrUnexpectedEOF
6725 }
6726 if m.Result == nil {
6727 m.Result = &types.Value{}
6728 }
6729 if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6730 return err
6731 }
6732 iNdEx = postIndex
6733 default:
6734 iNdEx = preIndex
6735 skippy, err := skipVmservice(dAtA[iNdEx:])
6736 if err != nil {
6737 return err
6738 }
6739 if (skippy < 0) || (iNdEx+skippy) < 0 {
6740 return ErrInvalidLengthVmservice
6741 }
6742 if (iNdEx + skippy) > l {
6743 return io.ErrUnexpectedEOF
6744 }
6745 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6746 iNdEx += skippy
6747 }
6748 }
6749
6750 if iNdEx > l {
6751 return io.ErrUnexpectedEOF
6752 }
6753 return nil
6754 }
6755 func (m *MemoryStats) Unmarshal(dAtA []byte) error {
6756 l := len(dAtA)
6757 iNdEx := 0
6758 for iNdEx < l {
6759 preIndex := iNdEx
6760 var wire uint64
6761 for shift := uint(0); ; shift += 7 {
6762 if shift >= 64 {
6763 return ErrIntOverflowVmservice
6764 }
6765 if iNdEx >= l {
6766 return io.ErrUnexpectedEOF
6767 }
6768 b := dAtA[iNdEx]
6769 iNdEx++
6770 wire |= uint64(b&0x7F) << shift
6771 if b < 0x80 {
6772 break
6773 }
6774 }
6775 fieldNum := int32(wire >> 3)
6776 wireType := int(wire & 0x7)
6777 if wireType == 4 {
6778 return fmt.Errorf("proto: MemoryStats: wiretype end group for non-group")
6779 }
6780 if fieldNum <= 0 {
6781 return fmt.Errorf("proto: MemoryStats: illegal tag %d (wire type %d)", fieldNum, wire)
6782 }
6783 switch fieldNum {
6784 case 1:
6785 if wireType != 0 {
6786 return fmt.Errorf("proto: wrong wireType = %d for field WorkingSetBytes", wireType)
6787 }
6788 m.WorkingSetBytes = 0
6789 for shift := uint(0); ; shift += 7 {
6790 if shift >= 64 {
6791 return ErrIntOverflowVmservice
6792 }
6793 if iNdEx >= l {
6794 return io.ErrUnexpectedEOF
6795 }
6796 b := dAtA[iNdEx]
6797 iNdEx++
6798 m.WorkingSetBytes |= uint64(b&0x7F) << shift
6799 if b < 0x80 {
6800 break
6801 }
6802 }
6803 case 2:
6804 if wireType != 0 {
6805 return fmt.Errorf("proto: wrong wireType = %d for field AvailableMemory", wireType)
6806 }
6807 m.AvailableMemory = 0
6808 for shift := uint(0); ; shift += 7 {
6809 if shift >= 64 {
6810 return ErrIntOverflowVmservice
6811 }
6812 if iNdEx >= l {
6813 return io.ErrUnexpectedEOF
6814 }
6815 b := dAtA[iNdEx]
6816 iNdEx++
6817 m.AvailableMemory |= uint64(b&0x7F) << shift
6818 if b < 0x80 {
6819 break
6820 }
6821 }
6822 case 3:
6823 if wireType != 0 {
6824 return fmt.Errorf("proto: wrong wireType = %d for field ReservedMemory", wireType)
6825 }
6826 m.ReservedMemory = 0
6827 for shift := uint(0); ; shift += 7 {
6828 if shift >= 64 {
6829 return ErrIntOverflowVmservice
6830 }
6831 if iNdEx >= l {
6832 return io.ErrUnexpectedEOF
6833 }
6834 b := dAtA[iNdEx]
6835 iNdEx++
6836 m.ReservedMemory |= uint64(b&0x7F) << shift
6837 if b < 0x80 {
6838 break
6839 }
6840 }
6841 case 4:
6842 if wireType != 0 {
6843 return fmt.Errorf("proto: wrong wireType = %d for field AssignedMemory", wireType)
6844 }
6845 m.AssignedMemory = 0
6846 for shift := uint(0); ; shift += 7 {
6847 if shift >= 64 {
6848 return ErrIntOverflowVmservice
6849 }
6850 if iNdEx >= l {
6851 return io.ErrUnexpectedEOF
6852 }
6853 b := dAtA[iNdEx]
6854 iNdEx++
6855 m.AssignedMemory |= uint64(b&0x7F) << shift
6856 if b < 0x80 {
6857 break
6858 }
6859 }
6860 default:
6861 iNdEx = preIndex
6862 skippy, err := skipVmservice(dAtA[iNdEx:])
6863 if err != nil {
6864 return err
6865 }
6866 if (skippy < 0) || (iNdEx+skippy) < 0 {
6867 return ErrInvalidLengthVmservice
6868 }
6869 if (iNdEx + skippy) > l {
6870 return io.ErrUnexpectedEOF
6871 }
6872 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6873 iNdEx += skippy
6874 }
6875 }
6876
6877 if iNdEx > l {
6878 return io.ErrUnexpectedEOF
6879 }
6880 return nil
6881 }
6882 func (m *ProcessorStats) Unmarshal(dAtA []byte) error {
6883 l := len(dAtA)
6884 iNdEx := 0
6885 for iNdEx < l {
6886 preIndex := iNdEx
6887 var wire uint64
6888 for shift := uint(0); ; shift += 7 {
6889 if shift >= 64 {
6890 return ErrIntOverflowVmservice
6891 }
6892 if iNdEx >= l {
6893 return io.ErrUnexpectedEOF
6894 }
6895 b := dAtA[iNdEx]
6896 iNdEx++
6897 wire |= uint64(b&0x7F) << shift
6898 if b < 0x80 {
6899 break
6900 }
6901 }
6902 fieldNum := int32(wire >> 3)
6903 wireType := int(wire & 0x7)
6904 if wireType == 4 {
6905 return fmt.Errorf("proto: ProcessorStats: wiretype end group for non-group")
6906 }
6907 if fieldNum <= 0 {
6908 return fmt.Errorf("proto: ProcessorStats: illegal tag %d (wire type %d)", fieldNum, wire)
6909 }
6910 switch fieldNum {
6911 case 1:
6912 if wireType != 0 {
6913 return fmt.Errorf("proto: wrong wireType = %d for field TotalRuntimeNs", wireType)
6914 }
6915 m.TotalRuntimeNs = 0
6916 for shift := uint(0); ; shift += 7 {
6917 if shift >= 64 {
6918 return ErrIntOverflowVmservice
6919 }
6920 if iNdEx >= l {
6921 return io.ErrUnexpectedEOF
6922 }
6923 b := dAtA[iNdEx]
6924 iNdEx++
6925 m.TotalRuntimeNs |= uint64(b&0x7F) << shift
6926 if b < 0x80 {
6927 break
6928 }
6929 }
6930 default:
6931 iNdEx = preIndex
6932 skippy, err := skipVmservice(dAtA[iNdEx:])
6933 if err != nil {
6934 return err
6935 }
6936 if (skippy < 0) || (iNdEx+skippy) < 0 {
6937 return ErrInvalidLengthVmservice
6938 }
6939 if (iNdEx + skippy) > l {
6940 return io.ErrUnexpectedEOF
6941 }
6942 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6943 iNdEx += skippy
6944 }
6945 }
6946
6947 if iNdEx > l {
6948 return io.ErrUnexpectedEOF
6949 }
6950 return nil
6951 }
6952 func (m *PropertiesVMRequest) Unmarshal(dAtA []byte) error {
6953 l := len(dAtA)
6954 iNdEx := 0
6955 for iNdEx < l {
6956 preIndex := iNdEx
6957 var wire uint64
6958 for shift := uint(0); ; shift += 7 {
6959 if shift >= 64 {
6960 return ErrIntOverflowVmservice
6961 }
6962 if iNdEx >= l {
6963 return io.ErrUnexpectedEOF
6964 }
6965 b := dAtA[iNdEx]
6966 iNdEx++
6967 wire |= uint64(b&0x7F) << shift
6968 if b < 0x80 {
6969 break
6970 }
6971 }
6972 fieldNum := int32(wire >> 3)
6973 wireType := int(wire & 0x7)
6974 if wireType == 4 {
6975 return fmt.Errorf("proto: PropertiesVMRequest: wiretype end group for non-group")
6976 }
6977 if fieldNum <= 0 {
6978 return fmt.Errorf("proto: PropertiesVMRequest: illegal tag %d (wire type %d)", fieldNum, wire)
6979 }
6980 switch fieldNum {
6981 case 1:
6982 if wireType == 0 {
6983 var v PropertiesVMRequest_PropertiesType
6984 for shift := uint(0); ; shift += 7 {
6985 if shift >= 64 {
6986 return ErrIntOverflowVmservice
6987 }
6988 if iNdEx >= l {
6989 return io.ErrUnexpectedEOF
6990 }
6991 b := dAtA[iNdEx]
6992 iNdEx++
6993 v |= PropertiesVMRequest_PropertiesType(b&0x7F) << shift
6994 if b < 0x80 {
6995 break
6996 }
6997 }
6998 m.Types = append(m.Types, v)
6999 } else if wireType == 2 {
7000 var packedLen int
7001 for shift := uint(0); ; shift += 7 {
7002 if shift >= 64 {
7003 return ErrIntOverflowVmservice
7004 }
7005 if iNdEx >= l {
7006 return io.ErrUnexpectedEOF
7007 }
7008 b := dAtA[iNdEx]
7009 iNdEx++
7010 packedLen |= int(b&0x7F) << shift
7011 if b < 0x80 {
7012 break
7013 }
7014 }
7015 if packedLen < 0 {
7016 return ErrInvalidLengthVmservice
7017 }
7018 postIndex := iNdEx + packedLen
7019 if postIndex < 0 {
7020 return ErrInvalidLengthVmservice
7021 }
7022 if postIndex > l {
7023 return io.ErrUnexpectedEOF
7024 }
7025 var elementCount int
7026 if elementCount != 0 && len(m.Types) == 0 {
7027 m.Types = make([]PropertiesVMRequest_PropertiesType, 0, elementCount)
7028 }
7029 for iNdEx < postIndex {
7030 var v PropertiesVMRequest_PropertiesType
7031 for shift := uint(0); ; shift += 7 {
7032 if shift >= 64 {
7033 return ErrIntOverflowVmservice
7034 }
7035 if iNdEx >= l {
7036 return io.ErrUnexpectedEOF
7037 }
7038 b := dAtA[iNdEx]
7039 iNdEx++
7040 v |= PropertiesVMRequest_PropertiesType(b&0x7F) << shift
7041 if b < 0x80 {
7042 break
7043 }
7044 }
7045 m.Types = append(m.Types, v)
7046 }
7047 } else {
7048 return fmt.Errorf("proto: wrong wireType = %d for field Types", wireType)
7049 }
7050 default:
7051 iNdEx = preIndex
7052 skippy, err := skipVmservice(dAtA[iNdEx:])
7053 if err != nil {
7054 return err
7055 }
7056 if (skippy < 0) || (iNdEx+skippy) < 0 {
7057 return ErrInvalidLengthVmservice
7058 }
7059 if (iNdEx + skippy) > l {
7060 return io.ErrUnexpectedEOF
7061 }
7062 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
7063 iNdEx += skippy
7064 }
7065 }
7066
7067 if iNdEx > l {
7068 return io.ErrUnexpectedEOF
7069 }
7070 return nil
7071 }
7072 func (m *PropertiesVMResponse) Unmarshal(dAtA []byte) error {
7073 l := len(dAtA)
7074 iNdEx := 0
7075 for iNdEx < l {
7076 preIndex := iNdEx
7077 var wire uint64
7078 for shift := uint(0); ; shift += 7 {
7079 if shift >= 64 {
7080 return ErrIntOverflowVmservice
7081 }
7082 if iNdEx >= l {
7083 return io.ErrUnexpectedEOF
7084 }
7085 b := dAtA[iNdEx]
7086 iNdEx++
7087 wire |= uint64(b&0x7F) << shift
7088 if b < 0x80 {
7089 break
7090 }
7091 }
7092 fieldNum := int32(wire >> 3)
7093 wireType := int(wire & 0x7)
7094 if wireType == 4 {
7095 return fmt.Errorf("proto: PropertiesVMResponse: wiretype end group for non-group")
7096 }
7097 if fieldNum <= 0 {
7098 return fmt.Errorf("proto: PropertiesVMResponse: illegal tag %d (wire type %d)", fieldNum, wire)
7099 }
7100 switch fieldNum {
7101 case 1:
7102 if wireType != 2 {
7103 return fmt.Errorf("proto: wrong wireType = %d for field MemoryStats", wireType)
7104 }
7105 var msglen int
7106 for shift := uint(0); ; shift += 7 {
7107 if shift >= 64 {
7108 return ErrIntOverflowVmservice
7109 }
7110 if iNdEx >= l {
7111 return io.ErrUnexpectedEOF
7112 }
7113 b := dAtA[iNdEx]
7114 iNdEx++
7115 msglen |= int(b&0x7F) << shift
7116 if b < 0x80 {
7117 break
7118 }
7119 }
7120 if msglen < 0 {
7121 return ErrInvalidLengthVmservice
7122 }
7123 postIndex := iNdEx + msglen
7124 if postIndex < 0 {
7125 return ErrInvalidLengthVmservice
7126 }
7127 if postIndex > l {
7128 return io.ErrUnexpectedEOF
7129 }
7130 if m.MemoryStats == nil {
7131 m.MemoryStats = &MemoryStats{}
7132 }
7133 if err := m.MemoryStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7134 return err
7135 }
7136 iNdEx = postIndex
7137 case 2:
7138 if wireType != 2 {
7139 return fmt.Errorf("proto: wrong wireType = %d for field ProcessorStats", wireType)
7140 }
7141 var msglen int
7142 for shift := uint(0); ; shift += 7 {
7143 if shift >= 64 {
7144 return ErrIntOverflowVmservice
7145 }
7146 if iNdEx >= l {
7147 return io.ErrUnexpectedEOF
7148 }
7149 b := dAtA[iNdEx]
7150 iNdEx++
7151 msglen |= int(b&0x7F) << shift
7152 if b < 0x80 {
7153 break
7154 }
7155 }
7156 if msglen < 0 {
7157 return ErrInvalidLengthVmservice
7158 }
7159 postIndex := iNdEx + msglen
7160 if postIndex < 0 {
7161 return ErrInvalidLengthVmservice
7162 }
7163 if postIndex > l {
7164 return io.ErrUnexpectedEOF
7165 }
7166 if m.ProcessorStats == nil {
7167 m.ProcessorStats = &ProcessorStats{}
7168 }
7169 if err := m.ProcessorStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7170 return err
7171 }
7172 iNdEx = postIndex
7173 default:
7174 iNdEx = preIndex
7175 skippy, err := skipVmservice(dAtA[iNdEx:])
7176 if err != nil {
7177 return err
7178 }
7179 if (skippy < 0) || (iNdEx+skippy) < 0 {
7180 return ErrInvalidLengthVmservice
7181 }
7182 if (iNdEx + skippy) > l {
7183 return io.ErrUnexpectedEOF
7184 }
7185 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
7186 iNdEx += skippy
7187 }
7188 }
7189
7190 if iNdEx > l {
7191 return io.ErrUnexpectedEOF
7192 }
7193 return nil
7194 }
7195 func (m *CapabilitiesVMResponse) Unmarshal(dAtA []byte) error {
7196 l := len(dAtA)
7197 iNdEx := 0
7198 for iNdEx < l {
7199 preIndex := iNdEx
7200 var wire uint64
7201 for shift := uint(0); ; shift += 7 {
7202 if shift >= 64 {
7203 return ErrIntOverflowVmservice
7204 }
7205 if iNdEx >= l {
7206 return io.ErrUnexpectedEOF
7207 }
7208 b := dAtA[iNdEx]
7209 iNdEx++
7210 wire |= uint64(b&0x7F) << shift
7211 if b < 0x80 {
7212 break
7213 }
7214 }
7215 fieldNum := int32(wire >> 3)
7216 wireType := int(wire & 0x7)
7217 if wireType == 4 {
7218 return fmt.Errorf("proto: CapabilitiesVMResponse: wiretype end group for non-group")
7219 }
7220 if fieldNum <= 0 {
7221 return fmt.Errorf("proto: CapabilitiesVMResponse: illegal tag %d (wire type %d)", fieldNum, wire)
7222 }
7223 switch fieldNum {
7224 case 1:
7225 if wireType != 2 {
7226 return fmt.Errorf("proto: wrong wireType = %d for field SupportedResources", wireType)
7227 }
7228 var msglen int
7229 for shift := uint(0); ; shift += 7 {
7230 if shift >= 64 {
7231 return ErrIntOverflowVmservice
7232 }
7233 if iNdEx >= l {
7234 return io.ErrUnexpectedEOF
7235 }
7236 b := dAtA[iNdEx]
7237 iNdEx++
7238 msglen |= int(b&0x7F) << shift
7239 if b < 0x80 {
7240 break
7241 }
7242 }
7243 if msglen < 0 {
7244 return ErrInvalidLengthVmservice
7245 }
7246 postIndex := iNdEx + msglen
7247 if postIndex < 0 {
7248 return ErrInvalidLengthVmservice
7249 }
7250 if postIndex > l {
7251 return io.ErrUnexpectedEOF
7252 }
7253 m.SupportedResources = append(m.SupportedResources, &CapabilitiesVMResponse_SupportedResource{})
7254 if err := m.SupportedResources[len(m.SupportedResources)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7255 return err
7256 }
7257 iNdEx = postIndex
7258 case 2:
7259 if wireType == 0 {
7260 var v CapabilitiesVMResponse_SupportedGuestOS
7261 for shift := uint(0); ; shift += 7 {
7262 if shift >= 64 {
7263 return ErrIntOverflowVmservice
7264 }
7265 if iNdEx >= l {
7266 return io.ErrUnexpectedEOF
7267 }
7268 b := dAtA[iNdEx]
7269 iNdEx++
7270 v |= CapabilitiesVMResponse_SupportedGuestOS(b&0x7F) << shift
7271 if b < 0x80 {
7272 break
7273 }
7274 }
7275 m.SupportedGuestOs = append(m.SupportedGuestOs, v)
7276 } else if wireType == 2 {
7277 var packedLen int
7278 for shift := uint(0); ; shift += 7 {
7279 if shift >= 64 {
7280 return ErrIntOverflowVmservice
7281 }
7282 if iNdEx >= l {
7283 return io.ErrUnexpectedEOF
7284 }
7285 b := dAtA[iNdEx]
7286 iNdEx++
7287 packedLen |= int(b&0x7F) << shift
7288 if b < 0x80 {
7289 break
7290 }
7291 }
7292 if packedLen < 0 {
7293 return ErrInvalidLengthVmservice
7294 }
7295 postIndex := iNdEx + packedLen
7296 if postIndex < 0 {
7297 return ErrInvalidLengthVmservice
7298 }
7299 if postIndex > l {
7300 return io.ErrUnexpectedEOF
7301 }
7302 var elementCount int
7303 if elementCount != 0 && len(m.SupportedGuestOs) == 0 {
7304 m.SupportedGuestOs = make([]CapabilitiesVMResponse_SupportedGuestOS, 0, elementCount)
7305 }
7306 for iNdEx < postIndex {
7307 var v CapabilitiesVMResponse_SupportedGuestOS
7308 for shift := uint(0); ; shift += 7 {
7309 if shift >= 64 {
7310 return ErrIntOverflowVmservice
7311 }
7312 if iNdEx >= l {
7313 return io.ErrUnexpectedEOF
7314 }
7315 b := dAtA[iNdEx]
7316 iNdEx++
7317 v |= CapabilitiesVMResponse_SupportedGuestOS(b&0x7F) << shift
7318 if b < 0x80 {
7319 break
7320 }
7321 }
7322 m.SupportedGuestOs = append(m.SupportedGuestOs, v)
7323 }
7324 } else {
7325 return fmt.Errorf("proto: wrong wireType = %d for field SupportedGuestOs", wireType)
7326 }
7327 default:
7328 iNdEx = preIndex
7329 skippy, err := skipVmservice(dAtA[iNdEx:])
7330 if err != nil {
7331 return err
7332 }
7333 if (skippy < 0) || (iNdEx+skippy) < 0 {
7334 return ErrInvalidLengthVmservice
7335 }
7336 if (iNdEx + skippy) > l {
7337 return io.ErrUnexpectedEOF
7338 }
7339 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
7340 iNdEx += skippy
7341 }
7342 }
7343
7344 if iNdEx > l {
7345 return io.ErrUnexpectedEOF
7346 }
7347 return nil
7348 }
7349 func (m *CapabilitiesVMResponse_SupportedResource) Unmarshal(dAtA []byte) error {
7350 l := len(dAtA)
7351 iNdEx := 0
7352 for iNdEx < l {
7353 preIndex := iNdEx
7354 var wire uint64
7355 for shift := uint(0); ; shift += 7 {
7356 if shift >= 64 {
7357 return ErrIntOverflowVmservice
7358 }
7359 if iNdEx >= l {
7360 return io.ErrUnexpectedEOF
7361 }
7362 b := dAtA[iNdEx]
7363 iNdEx++
7364 wire |= uint64(b&0x7F) << shift
7365 if b < 0x80 {
7366 break
7367 }
7368 }
7369 fieldNum := int32(wire >> 3)
7370 wireType := int(wire & 0x7)
7371 if wireType == 4 {
7372 return fmt.Errorf("proto: SupportedResource: wiretype end group for non-group")
7373 }
7374 if fieldNum <= 0 {
7375 return fmt.Errorf("proto: SupportedResource: illegal tag %d (wire type %d)", fieldNum, wire)
7376 }
7377 switch fieldNum {
7378 case 1:
7379 if wireType != 0 {
7380 return fmt.Errorf("proto: wrong wireType = %d for field Add", wireType)
7381 }
7382 var v int
7383 for shift := uint(0); ; shift += 7 {
7384 if shift >= 64 {
7385 return ErrIntOverflowVmservice
7386 }
7387 if iNdEx >= l {
7388 return io.ErrUnexpectedEOF
7389 }
7390 b := dAtA[iNdEx]
7391 iNdEx++
7392 v |= int(b&0x7F) << shift
7393 if b < 0x80 {
7394 break
7395 }
7396 }
7397 m.Add = bool(v != 0)
7398 case 2:
7399 if wireType != 0 {
7400 return fmt.Errorf("proto: wrong wireType = %d for field Remove", wireType)
7401 }
7402 var v int
7403 for shift := uint(0); ; shift += 7 {
7404 if shift >= 64 {
7405 return ErrIntOverflowVmservice
7406 }
7407 if iNdEx >= l {
7408 return io.ErrUnexpectedEOF
7409 }
7410 b := dAtA[iNdEx]
7411 iNdEx++
7412 v |= int(b&0x7F) << shift
7413 if b < 0x80 {
7414 break
7415 }
7416 }
7417 m.Remove = bool(v != 0)
7418 case 3:
7419 if wireType != 0 {
7420 return fmt.Errorf("proto: wrong wireType = %d for field Update", wireType)
7421 }
7422 var v int
7423 for shift := uint(0); ; shift += 7 {
7424 if shift >= 64 {
7425 return ErrIntOverflowVmservice
7426 }
7427 if iNdEx >= l {
7428 return io.ErrUnexpectedEOF
7429 }
7430 b := dAtA[iNdEx]
7431 iNdEx++
7432 v |= int(b&0x7F) << shift
7433 if b < 0x80 {
7434 break
7435 }
7436 }
7437 m.Update = bool(v != 0)
7438 case 4:
7439 if wireType != 0 {
7440 return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
7441 }
7442 m.Resource = 0
7443 for shift := uint(0); ; shift += 7 {
7444 if shift >= 64 {
7445 return ErrIntOverflowVmservice
7446 }
7447 if iNdEx >= l {
7448 return io.ErrUnexpectedEOF
7449 }
7450 b := dAtA[iNdEx]
7451 iNdEx++
7452 m.Resource |= CapabilitiesVMResponse_Resource(b&0x7F) << shift
7453 if b < 0x80 {
7454 break
7455 }
7456 }
7457 default:
7458 iNdEx = preIndex
7459 skippy, err := skipVmservice(dAtA[iNdEx:])
7460 if err != nil {
7461 return err
7462 }
7463 if (skippy < 0) || (iNdEx+skippy) < 0 {
7464 return ErrInvalidLengthVmservice
7465 }
7466 if (iNdEx + skippy) > l {
7467 return io.ErrUnexpectedEOF
7468 }
7469 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
7470 iNdEx += skippy
7471 }
7472 }
7473
7474 if iNdEx > l {
7475 return io.ErrUnexpectedEOF
7476 }
7477 return nil
7478 }
7479 func (m *HVSocketListen) Unmarshal(dAtA []byte) error {
7480 l := len(dAtA)
7481 iNdEx := 0
7482 for iNdEx < l {
7483 preIndex := iNdEx
7484 var wire uint64
7485 for shift := uint(0); ; shift += 7 {
7486 if shift >= 64 {
7487 return ErrIntOverflowVmservice
7488 }
7489 if iNdEx >= l {
7490 return io.ErrUnexpectedEOF
7491 }
7492 b := dAtA[iNdEx]
7493 iNdEx++
7494 wire |= uint64(b&0x7F) << shift
7495 if b < 0x80 {
7496 break
7497 }
7498 }
7499 fieldNum := int32(wire >> 3)
7500 wireType := int(wire & 0x7)
7501 if wireType == 4 {
7502 return fmt.Errorf("proto: HVSocketListen: wiretype end group for non-group")
7503 }
7504 if fieldNum <= 0 {
7505 return fmt.Errorf("proto: HVSocketListen: illegal tag %d (wire type %d)", fieldNum, wire)
7506 }
7507 switch fieldNum {
7508 case 1:
7509 if wireType != 2 {
7510 return fmt.Errorf("proto: wrong wireType = %d for field ServiceID", wireType)
7511 }
7512 var stringLen uint64
7513 for shift := uint(0); ; shift += 7 {
7514 if shift >= 64 {
7515 return ErrIntOverflowVmservice
7516 }
7517 if iNdEx >= l {
7518 return io.ErrUnexpectedEOF
7519 }
7520 b := dAtA[iNdEx]
7521 iNdEx++
7522 stringLen |= uint64(b&0x7F) << shift
7523 if b < 0x80 {
7524 break
7525 }
7526 }
7527 intStringLen := int(stringLen)
7528 if intStringLen < 0 {
7529 return ErrInvalidLengthVmservice
7530 }
7531 postIndex := iNdEx + intStringLen
7532 if postIndex < 0 {
7533 return ErrInvalidLengthVmservice
7534 }
7535 if postIndex > l {
7536 return io.ErrUnexpectedEOF
7537 }
7538 m.ServiceID = string(dAtA[iNdEx:postIndex])
7539 iNdEx = postIndex
7540 case 2:
7541 if wireType != 2 {
7542 return fmt.Errorf("proto: wrong wireType = %d for field ListenerPath", wireType)
7543 }
7544 var stringLen uint64
7545 for shift := uint(0); ; shift += 7 {
7546 if shift >= 64 {
7547 return ErrIntOverflowVmservice
7548 }
7549 if iNdEx >= l {
7550 return io.ErrUnexpectedEOF
7551 }
7552 b := dAtA[iNdEx]
7553 iNdEx++
7554 stringLen |= uint64(b&0x7F) << shift
7555 if b < 0x80 {
7556 break
7557 }
7558 }
7559 intStringLen := int(stringLen)
7560 if intStringLen < 0 {
7561 return ErrInvalidLengthVmservice
7562 }
7563 postIndex := iNdEx + intStringLen
7564 if postIndex < 0 {
7565 return ErrInvalidLengthVmservice
7566 }
7567 if postIndex > l {
7568 return io.ErrUnexpectedEOF
7569 }
7570 m.ListenerPath = string(dAtA[iNdEx:postIndex])
7571 iNdEx = postIndex
7572 default:
7573 iNdEx = preIndex
7574 skippy, err := skipVmservice(dAtA[iNdEx:])
7575 if err != nil {
7576 return err
7577 }
7578 if (skippy < 0) || (iNdEx+skippy) < 0 {
7579 return ErrInvalidLengthVmservice
7580 }
7581 if (iNdEx + skippy) > l {
7582 return io.ErrUnexpectedEOF
7583 }
7584 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
7585 iNdEx += skippy
7586 }
7587 }
7588
7589 if iNdEx > l {
7590 return io.ErrUnexpectedEOF
7591 }
7592 return nil
7593 }
7594 func (m *VSockListen) Unmarshal(dAtA []byte) error {
7595 l := len(dAtA)
7596 iNdEx := 0
7597 for iNdEx < l {
7598 preIndex := iNdEx
7599 var wire uint64
7600 for shift := uint(0); ; shift += 7 {
7601 if shift >= 64 {
7602 return ErrIntOverflowVmservice
7603 }
7604 if iNdEx >= l {
7605 return io.ErrUnexpectedEOF
7606 }
7607 b := dAtA[iNdEx]
7608 iNdEx++
7609 wire |= uint64(b&0x7F) << shift
7610 if b < 0x80 {
7611 break
7612 }
7613 }
7614 fieldNum := int32(wire >> 3)
7615 wireType := int(wire & 0x7)
7616 if wireType == 4 {
7617 return fmt.Errorf("proto: VSockListen: wiretype end group for non-group")
7618 }
7619 if fieldNum <= 0 {
7620 return fmt.Errorf("proto: VSockListen: illegal tag %d (wire type %d)", fieldNum, wire)
7621 }
7622 switch fieldNum {
7623 case 1:
7624 if wireType != 0 {
7625 return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
7626 }
7627 m.Port = 0
7628 for shift := uint(0); ; shift += 7 {
7629 if shift >= 64 {
7630 return ErrIntOverflowVmservice
7631 }
7632 if iNdEx >= l {
7633 return io.ErrUnexpectedEOF
7634 }
7635 b := dAtA[iNdEx]
7636 iNdEx++
7637 m.Port |= uint32(b&0x7F) << shift
7638 if b < 0x80 {
7639 break
7640 }
7641 }
7642 case 2:
7643 if wireType != 2 {
7644 return fmt.Errorf("proto: wrong wireType = %d for field ListenerPath", wireType)
7645 }
7646 var stringLen uint64
7647 for shift := uint(0); ; shift += 7 {
7648 if shift >= 64 {
7649 return ErrIntOverflowVmservice
7650 }
7651 if iNdEx >= l {
7652 return io.ErrUnexpectedEOF
7653 }
7654 b := dAtA[iNdEx]
7655 iNdEx++
7656 stringLen |= uint64(b&0x7F) << shift
7657 if b < 0x80 {
7658 break
7659 }
7660 }
7661 intStringLen := int(stringLen)
7662 if intStringLen < 0 {
7663 return ErrInvalidLengthVmservice
7664 }
7665 postIndex := iNdEx + intStringLen
7666 if postIndex < 0 {
7667 return ErrInvalidLengthVmservice
7668 }
7669 if postIndex > l {
7670 return io.ErrUnexpectedEOF
7671 }
7672 m.ListenerPath = string(dAtA[iNdEx:postIndex])
7673 iNdEx = postIndex
7674 default:
7675 iNdEx = preIndex
7676 skippy, err := skipVmservice(dAtA[iNdEx:])
7677 if err != nil {
7678 return err
7679 }
7680 if (skippy < 0) || (iNdEx+skippy) < 0 {
7681 return ErrInvalidLengthVmservice
7682 }
7683 if (iNdEx + skippy) > l {
7684 return io.ErrUnexpectedEOF
7685 }
7686 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
7687 iNdEx += skippy
7688 }
7689 }
7690
7691 if iNdEx > l {
7692 return io.ErrUnexpectedEOF
7693 }
7694 return nil
7695 }
7696 func (m *VMSocketRequest) Unmarshal(dAtA []byte) error {
7697 l := len(dAtA)
7698 iNdEx := 0
7699 for iNdEx < l {
7700 preIndex := iNdEx
7701 var wire uint64
7702 for shift := uint(0); ; shift += 7 {
7703 if shift >= 64 {
7704 return ErrIntOverflowVmservice
7705 }
7706 if iNdEx >= l {
7707 return io.ErrUnexpectedEOF
7708 }
7709 b := dAtA[iNdEx]
7710 iNdEx++
7711 wire |= uint64(b&0x7F) << shift
7712 if b < 0x80 {
7713 break
7714 }
7715 }
7716 fieldNum := int32(wire >> 3)
7717 wireType := int(wire & 0x7)
7718 if wireType == 4 {
7719 return fmt.Errorf("proto: VMSocketRequest: wiretype end group for non-group")
7720 }
7721 if fieldNum <= 0 {
7722 return fmt.Errorf("proto: VMSocketRequest: illegal tag %d (wire type %d)", fieldNum, wire)
7723 }
7724 switch fieldNum {
7725 case 1:
7726 if wireType != 0 {
7727 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
7728 }
7729 m.Type = 0
7730 for shift := uint(0); ; shift += 7 {
7731 if shift >= 64 {
7732 return ErrIntOverflowVmservice
7733 }
7734 if iNdEx >= l {
7735 return io.ErrUnexpectedEOF
7736 }
7737 b := dAtA[iNdEx]
7738 iNdEx++
7739 m.Type |= ModifyType(b&0x7F) << shift
7740 if b < 0x80 {
7741 break
7742 }
7743 }
7744 case 2:
7745 if wireType != 2 {
7746 return fmt.Errorf("proto: wrong wireType = %d for field HvsocketList", wireType)
7747 }
7748 var msglen int
7749 for shift := uint(0); ; shift += 7 {
7750 if shift >= 64 {
7751 return ErrIntOverflowVmservice
7752 }
7753 if iNdEx >= l {
7754 return io.ErrUnexpectedEOF
7755 }
7756 b := dAtA[iNdEx]
7757 iNdEx++
7758 msglen |= int(b&0x7F) << shift
7759 if b < 0x80 {
7760 break
7761 }
7762 }
7763 if msglen < 0 {
7764 return ErrInvalidLengthVmservice
7765 }
7766 postIndex := iNdEx + msglen
7767 if postIndex < 0 {
7768 return ErrInvalidLengthVmservice
7769 }
7770 if postIndex > l {
7771 return io.ErrUnexpectedEOF
7772 }
7773 v := &HVSocketListen{}
7774 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7775 return err
7776 }
7777 m.Config = &VMSocketRequest_HvsocketList{v}
7778 iNdEx = postIndex
7779 case 3:
7780 if wireType != 2 {
7781 return fmt.Errorf("proto: wrong wireType = %d for field VsockListen", wireType)
7782 }
7783 var msglen int
7784 for shift := uint(0); ; shift += 7 {
7785 if shift >= 64 {
7786 return ErrIntOverflowVmservice
7787 }
7788 if iNdEx >= l {
7789 return io.ErrUnexpectedEOF
7790 }
7791 b := dAtA[iNdEx]
7792 iNdEx++
7793 msglen |= int(b&0x7F) << shift
7794 if b < 0x80 {
7795 break
7796 }
7797 }
7798 if msglen < 0 {
7799 return ErrInvalidLengthVmservice
7800 }
7801 postIndex := iNdEx + msglen
7802 if postIndex < 0 {
7803 return ErrInvalidLengthVmservice
7804 }
7805 if postIndex > l {
7806 return io.ErrUnexpectedEOF
7807 }
7808 v := &VSockListen{}
7809 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7810 return err
7811 }
7812 m.Config = &VMSocketRequest_VsockListen{v}
7813 iNdEx = postIndex
7814 default:
7815 iNdEx = preIndex
7816 skippy, err := skipVmservice(dAtA[iNdEx:])
7817 if err != nil {
7818 return err
7819 }
7820 if (skippy < 0) || (iNdEx+skippy) < 0 {
7821 return ErrInvalidLengthVmservice
7822 }
7823 if (iNdEx + skippy) > l {
7824 return io.ErrUnexpectedEOF
7825 }
7826 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
7827 iNdEx += skippy
7828 }
7829 }
7830
7831 if iNdEx > l {
7832 return io.ErrUnexpectedEOF
7833 }
7834 return nil
7835 }
7836 func (m *SCSIDisk) Unmarshal(dAtA []byte) error {
7837 l := len(dAtA)
7838 iNdEx := 0
7839 for iNdEx < l {
7840 preIndex := iNdEx
7841 var wire uint64
7842 for shift := uint(0); ; shift += 7 {
7843 if shift >= 64 {
7844 return ErrIntOverflowVmservice
7845 }
7846 if iNdEx >= l {
7847 return io.ErrUnexpectedEOF
7848 }
7849 b := dAtA[iNdEx]
7850 iNdEx++
7851 wire |= uint64(b&0x7F) << shift
7852 if b < 0x80 {
7853 break
7854 }
7855 }
7856 fieldNum := int32(wire >> 3)
7857 wireType := int(wire & 0x7)
7858 if wireType == 4 {
7859 return fmt.Errorf("proto: SCSIDisk: wiretype end group for non-group")
7860 }
7861 if fieldNum <= 0 {
7862 return fmt.Errorf("proto: SCSIDisk: illegal tag %d (wire type %d)", fieldNum, wire)
7863 }
7864 switch fieldNum {
7865 case 1:
7866 if wireType != 0 {
7867 return fmt.Errorf("proto: wrong wireType = %d for field Controller", wireType)
7868 }
7869 m.Controller = 0
7870 for shift := uint(0); ; shift += 7 {
7871 if shift >= 64 {
7872 return ErrIntOverflowVmservice
7873 }
7874 if iNdEx >= l {
7875 return io.ErrUnexpectedEOF
7876 }
7877 b := dAtA[iNdEx]
7878 iNdEx++
7879 m.Controller |= uint32(b&0x7F) << shift
7880 if b < 0x80 {
7881 break
7882 }
7883 }
7884 case 2:
7885 if wireType != 0 {
7886 return fmt.Errorf("proto: wrong wireType = %d for field Lun", wireType)
7887 }
7888 m.Lun = 0
7889 for shift := uint(0); ; shift += 7 {
7890 if shift >= 64 {
7891 return ErrIntOverflowVmservice
7892 }
7893 if iNdEx >= l {
7894 return io.ErrUnexpectedEOF
7895 }
7896 b := dAtA[iNdEx]
7897 iNdEx++
7898 m.Lun |= uint32(b&0x7F) << shift
7899 if b < 0x80 {
7900 break
7901 }
7902 }
7903 case 3:
7904 if wireType != 2 {
7905 return fmt.Errorf("proto: wrong wireType = %d for field HostPath", wireType)
7906 }
7907 var stringLen uint64
7908 for shift := uint(0); ; shift += 7 {
7909 if shift >= 64 {
7910 return ErrIntOverflowVmservice
7911 }
7912 if iNdEx >= l {
7913 return io.ErrUnexpectedEOF
7914 }
7915 b := dAtA[iNdEx]
7916 iNdEx++
7917 stringLen |= uint64(b&0x7F) << shift
7918 if b < 0x80 {
7919 break
7920 }
7921 }
7922 intStringLen := int(stringLen)
7923 if intStringLen < 0 {
7924 return ErrInvalidLengthVmservice
7925 }
7926 postIndex := iNdEx + intStringLen
7927 if postIndex < 0 {
7928 return ErrInvalidLengthVmservice
7929 }
7930 if postIndex > l {
7931 return io.ErrUnexpectedEOF
7932 }
7933 m.HostPath = string(dAtA[iNdEx:postIndex])
7934 iNdEx = postIndex
7935 case 4:
7936 if wireType != 0 {
7937 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
7938 }
7939 m.Type = 0
7940 for shift := uint(0); ; shift += 7 {
7941 if shift >= 64 {
7942 return ErrIntOverflowVmservice
7943 }
7944 if iNdEx >= l {
7945 return io.ErrUnexpectedEOF
7946 }
7947 b := dAtA[iNdEx]
7948 iNdEx++
7949 m.Type |= DiskType(b&0x7F) << shift
7950 if b < 0x80 {
7951 break
7952 }
7953 }
7954 case 5:
7955 if wireType != 0 {
7956 return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
7957 }
7958 var v int
7959 for shift := uint(0); ; shift += 7 {
7960 if shift >= 64 {
7961 return ErrIntOverflowVmservice
7962 }
7963 if iNdEx >= l {
7964 return io.ErrUnexpectedEOF
7965 }
7966 b := dAtA[iNdEx]
7967 iNdEx++
7968 v |= int(b&0x7F) << shift
7969 if b < 0x80 {
7970 break
7971 }
7972 }
7973 m.ReadOnly = bool(v != 0)
7974 default:
7975 iNdEx = preIndex
7976 skippy, err := skipVmservice(dAtA[iNdEx:])
7977 if err != nil {
7978 return err
7979 }
7980 if (skippy < 0) || (iNdEx+skippy) < 0 {
7981 return ErrInvalidLengthVmservice
7982 }
7983 if (iNdEx + skippy) > l {
7984 return io.ErrUnexpectedEOF
7985 }
7986 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
7987 iNdEx += skippy
7988 }
7989 }
7990
7991 if iNdEx > l {
7992 return io.ErrUnexpectedEOF
7993 }
7994 return nil
7995 }
7996 func (m *VPMEMDisk) Unmarshal(dAtA []byte) error {
7997 l := len(dAtA)
7998 iNdEx := 0
7999 for iNdEx < l {
8000 preIndex := iNdEx
8001 var wire uint64
8002 for shift := uint(0); ; shift += 7 {
8003 if shift >= 64 {
8004 return ErrIntOverflowVmservice
8005 }
8006 if iNdEx >= l {
8007 return io.ErrUnexpectedEOF
8008 }
8009 b := dAtA[iNdEx]
8010 iNdEx++
8011 wire |= uint64(b&0x7F) << shift
8012 if b < 0x80 {
8013 break
8014 }
8015 }
8016 fieldNum := int32(wire >> 3)
8017 wireType := int(wire & 0x7)
8018 if wireType == 4 {
8019 return fmt.Errorf("proto: VPMEMDisk: wiretype end group for non-group")
8020 }
8021 if fieldNum <= 0 {
8022 return fmt.Errorf("proto: VPMEMDisk: illegal tag %d (wire type %d)", fieldNum, wire)
8023 }
8024 switch fieldNum {
8025 case 1:
8026 if wireType != 2 {
8027 return fmt.Errorf("proto: wrong wireType = %d for field HostPath", wireType)
8028 }
8029 var stringLen uint64
8030 for shift := uint(0); ; shift += 7 {
8031 if shift >= 64 {
8032 return ErrIntOverflowVmservice
8033 }
8034 if iNdEx >= l {
8035 return io.ErrUnexpectedEOF
8036 }
8037 b := dAtA[iNdEx]
8038 iNdEx++
8039 stringLen |= uint64(b&0x7F) << shift
8040 if b < 0x80 {
8041 break
8042 }
8043 }
8044 intStringLen := int(stringLen)
8045 if intStringLen < 0 {
8046 return ErrInvalidLengthVmservice
8047 }
8048 postIndex := iNdEx + intStringLen
8049 if postIndex < 0 {
8050 return ErrInvalidLengthVmservice
8051 }
8052 if postIndex > l {
8053 return io.ErrUnexpectedEOF
8054 }
8055 m.HostPath = string(dAtA[iNdEx:postIndex])
8056 iNdEx = postIndex
8057 case 2:
8058 if wireType != 0 {
8059 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
8060 }
8061 m.Type = 0
8062 for shift := uint(0); ; shift += 7 {
8063 if shift >= 64 {
8064 return ErrIntOverflowVmservice
8065 }
8066 if iNdEx >= l {
8067 return io.ErrUnexpectedEOF
8068 }
8069 b := dAtA[iNdEx]
8070 iNdEx++
8071 m.Type |= DiskType(b&0x7F) << shift
8072 if b < 0x80 {
8073 break
8074 }
8075 }
8076 case 3:
8077 if wireType != 0 {
8078 return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
8079 }
8080 var v int
8081 for shift := uint(0); ; shift += 7 {
8082 if shift >= 64 {
8083 return ErrIntOverflowVmservice
8084 }
8085 if iNdEx >= l {
8086 return io.ErrUnexpectedEOF
8087 }
8088 b := dAtA[iNdEx]
8089 iNdEx++
8090 v |= int(b&0x7F) << shift
8091 if b < 0x80 {
8092 break
8093 }
8094 }
8095 m.ReadOnly = bool(v != 0)
8096 default:
8097 iNdEx = preIndex
8098 skippy, err := skipVmservice(dAtA[iNdEx:])
8099 if err != nil {
8100 return err
8101 }
8102 if (skippy < 0) || (iNdEx+skippy) < 0 {
8103 return ErrInvalidLengthVmservice
8104 }
8105 if (iNdEx + skippy) > l {
8106 return io.ErrUnexpectedEOF
8107 }
8108 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
8109 iNdEx += skippy
8110 }
8111 }
8112
8113 if iNdEx > l {
8114 return io.ErrUnexpectedEOF
8115 }
8116 return nil
8117 }
8118 func (m *NICConfig) Unmarshal(dAtA []byte) error {
8119 l := len(dAtA)
8120 iNdEx := 0
8121 for iNdEx < l {
8122 preIndex := iNdEx
8123 var wire uint64
8124 for shift := uint(0); ; shift += 7 {
8125 if shift >= 64 {
8126 return ErrIntOverflowVmservice
8127 }
8128 if iNdEx >= l {
8129 return io.ErrUnexpectedEOF
8130 }
8131 b := dAtA[iNdEx]
8132 iNdEx++
8133 wire |= uint64(b&0x7F) << shift
8134 if b < 0x80 {
8135 break
8136 }
8137 }
8138 fieldNum := int32(wire >> 3)
8139 wireType := int(wire & 0x7)
8140 if wireType == 4 {
8141 return fmt.Errorf("proto: NICConfig: wiretype end group for non-group")
8142 }
8143 if fieldNum <= 0 {
8144 return fmt.Errorf("proto: NICConfig: illegal tag %d (wire type %d)", fieldNum, wire)
8145 }
8146 switch fieldNum {
8147 case 1:
8148 if wireType != 2 {
8149 return fmt.Errorf("proto: wrong wireType = %d for field NicID", wireType)
8150 }
8151 var stringLen uint64
8152 for shift := uint(0); ; shift += 7 {
8153 if shift >= 64 {
8154 return ErrIntOverflowVmservice
8155 }
8156 if iNdEx >= l {
8157 return io.ErrUnexpectedEOF
8158 }
8159 b := dAtA[iNdEx]
8160 iNdEx++
8161 stringLen |= uint64(b&0x7F) << shift
8162 if b < 0x80 {
8163 break
8164 }
8165 }
8166 intStringLen := int(stringLen)
8167 if intStringLen < 0 {
8168 return ErrInvalidLengthVmservice
8169 }
8170 postIndex := iNdEx + intStringLen
8171 if postIndex < 0 {
8172 return ErrInvalidLengthVmservice
8173 }
8174 if postIndex > l {
8175 return io.ErrUnexpectedEOF
8176 }
8177 m.NicID = string(dAtA[iNdEx:postIndex])
8178 iNdEx = postIndex
8179 case 2:
8180 if wireType != 2 {
8181 return fmt.Errorf("proto: wrong wireType = %d for field PortID", wireType)
8182 }
8183 var stringLen uint64
8184 for shift := uint(0); ; shift += 7 {
8185 if shift >= 64 {
8186 return ErrIntOverflowVmservice
8187 }
8188 if iNdEx >= l {
8189 return io.ErrUnexpectedEOF
8190 }
8191 b := dAtA[iNdEx]
8192 iNdEx++
8193 stringLen |= uint64(b&0x7F) << shift
8194 if b < 0x80 {
8195 break
8196 }
8197 }
8198 intStringLen := int(stringLen)
8199 if intStringLen < 0 {
8200 return ErrInvalidLengthVmservice
8201 }
8202 postIndex := iNdEx + intStringLen
8203 if postIndex < 0 {
8204 return ErrInvalidLengthVmservice
8205 }
8206 if postIndex > l {
8207 return io.ErrUnexpectedEOF
8208 }
8209 m.PortID = string(dAtA[iNdEx:postIndex])
8210 iNdEx = postIndex
8211 case 3:
8212 if wireType != 2 {
8213 return fmt.Errorf("proto: wrong wireType = %d for field MacAddress", wireType)
8214 }
8215 var stringLen uint64
8216 for shift := uint(0); ; shift += 7 {
8217 if shift >= 64 {
8218 return ErrIntOverflowVmservice
8219 }
8220 if iNdEx >= l {
8221 return io.ErrUnexpectedEOF
8222 }
8223 b := dAtA[iNdEx]
8224 iNdEx++
8225 stringLen |= uint64(b&0x7F) << shift
8226 if b < 0x80 {
8227 break
8228 }
8229 }
8230 intStringLen := int(stringLen)
8231 if intStringLen < 0 {
8232 return ErrInvalidLengthVmservice
8233 }
8234 postIndex := iNdEx + intStringLen
8235 if postIndex < 0 {
8236 return ErrInvalidLengthVmservice
8237 }
8238 if postIndex > l {
8239 return io.ErrUnexpectedEOF
8240 }
8241 m.MacAddress = string(dAtA[iNdEx:postIndex])
8242 iNdEx = postIndex
8243 case 4:
8244 if wireType != 2 {
8245 return fmt.Errorf("proto: wrong wireType = %d for field SwitchID", wireType)
8246 }
8247 var stringLen uint64
8248 for shift := uint(0); ; shift += 7 {
8249 if shift >= 64 {
8250 return ErrIntOverflowVmservice
8251 }
8252 if iNdEx >= l {
8253 return io.ErrUnexpectedEOF
8254 }
8255 b := dAtA[iNdEx]
8256 iNdEx++
8257 stringLen |= uint64(b&0x7F) << shift
8258 if b < 0x80 {
8259 break
8260 }
8261 }
8262 intStringLen := int(stringLen)
8263 if intStringLen < 0 {
8264 return ErrInvalidLengthVmservice
8265 }
8266 postIndex := iNdEx + intStringLen
8267 if postIndex < 0 {
8268 return ErrInvalidLengthVmservice
8269 }
8270 if postIndex > l {
8271 return io.ErrUnexpectedEOF
8272 }
8273 m.SwitchID = string(dAtA[iNdEx:postIndex])
8274 iNdEx = postIndex
8275 case 5:
8276 if wireType != 2 {
8277 return fmt.Errorf("proto: wrong wireType = %d for field NicName", wireType)
8278 }
8279 var stringLen uint64
8280 for shift := uint(0); ; shift += 7 {
8281 if shift >= 64 {
8282 return ErrIntOverflowVmservice
8283 }
8284 if iNdEx >= l {
8285 return io.ErrUnexpectedEOF
8286 }
8287 b := dAtA[iNdEx]
8288 iNdEx++
8289 stringLen |= uint64(b&0x7F) << shift
8290 if b < 0x80 {
8291 break
8292 }
8293 }
8294 intStringLen := int(stringLen)
8295 if intStringLen < 0 {
8296 return ErrInvalidLengthVmservice
8297 }
8298 postIndex := iNdEx + intStringLen
8299 if postIndex < 0 {
8300 return ErrInvalidLengthVmservice
8301 }
8302 if postIndex > l {
8303 return io.ErrUnexpectedEOF
8304 }
8305 m.NicName = string(dAtA[iNdEx:postIndex])
8306 iNdEx = postIndex
8307 default:
8308 iNdEx = preIndex
8309 skippy, err := skipVmservice(dAtA[iNdEx:])
8310 if err != nil {
8311 return err
8312 }
8313 if (skippy < 0) || (iNdEx+skippy) < 0 {
8314 return ErrInvalidLengthVmservice
8315 }
8316 if (iNdEx + skippy) > l {
8317 return io.ErrUnexpectedEOF
8318 }
8319 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
8320 iNdEx += skippy
8321 }
8322 }
8323
8324 if iNdEx > l {
8325 return io.ErrUnexpectedEOF
8326 }
8327 return nil
8328 }
8329 func (m *WindowsPCIDevice) Unmarshal(dAtA []byte) error {
8330 l := len(dAtA)
8331 iNdEx := 0
8332 for iNdEx < l {
8333 preIndex := iNdEx
8334 var wire uint64
8335 for shift := uint(0); ; shift += 7 {
8336 if shift >= 64 {
8337 return ErrIntOverflowVmservice
8338 }
8339 if iNdEx >= l {
8340 return io.ErrUnexpectedEOF
8341 }
8342 b := dAtA[iNdEx]
8343 iNdEx++
8344 wire |= uint64(b&0x7F) << shift
8345 if b < 0x80 {
8346 break
8347 }
8348 }
8349 fieldNum := int32(wire >> 3)
8350 wireType := int(wire & 0x7)
8351 if wireType == 4 {
8352 return fmt.Errorf("proto: WindowsPCIDevice: wiretype end group for non-group")
8353 }
8354 if fieldNum <= 0 {
8355 return fmt.Errorf("proto: WindowsPCIDevice: illegal tag %d (wire type %d)", fieldNum, wire)
8356 }
8357 switch fieldNum {
8358 case 1:
8359 if wireType != 2 {
8360 return fmt.Errorf("proto: wrong wireType = %d for field InstanceID", wireType)
8361 }
8362 var stringLen uint64
8363 for shift := uint(0); ; shift += 7 {
8364 if shift >= 64 {
8365 return ErrIntOverflowVmservice
8366 }
8367 if iNdEx >= l {
8368 return io.ErrUnexpectedEOF
8369 }
8370 b := dAtA[iNdEx]
8371 iNdEx++
8372 stringLen |= uint64(b&0x7F) << shift
8373 if b < 0x80 {
8374 break
8375 }
8376 }
8377 intStringLen := int(stringLen)
8378 if intStringLen < 0 {
8379 return ErrInvalidLengthVmservice
8380 }
8381 postIndex := iNdEx + intStringLen
8382 if postIndex < 0 {
8383 return ErrInvalidLengthVmservice
8384 }
8385 if postIndex > l {
8386 return io.ErrUnexpectedEOF
8387 }
8388 m.InstanceID = string(dAtA[iNdEx:postIndex])
8389 iNdEx = postIndex
8390 default:
8391 iNdEx = preIndex
8392 skippy, err := skipVmservice(dAtA[iNdEx:])
8393 if err != nil {
8394 return err
8395 }
8396 if (skippy < 0) || (iNdEx+skippy) < 0 {
8397 return ErrInvalidLengthVmservice
8398 }
8399 if (iNdEx + skippy) > l {
8400 return io.ErrUnexpectedEOF
8401 }
8402 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
8403 iNdEx += skippy
8404 }
8405 }
8406
8407 if iNdEx > l {
8408 return io.ErrUnexpectedEOF
8409 }
8410 return nil
8411 }
8412 func (m *ModifyMemoryRequest) Unmarshal(dAtA []byte) error {
8413 l := len(dAtA)
8414 iNdEx := 0
8415 for iNdEx < l {
8416 preIndex := iNdEx
8417 var wire uint64
8418 for shift := uint(0); ; shift += 7 {
8419 if shift >= 64 {
8420 return ErrIntOverflowVmservice
8421 }
8422 if iNdEx >= l {
8423 return io.ErrUnexpectedEOF
8424 }
8425 b := dAtA[iNdEx]
8426 iNdEx++
8427 wire |= uint64(b&0x7F) << shift
8428 if b < 0x80 {
8429 break
8430 }
8431 }
8432 fieldNum := int32(wire >> 3)
8433 wireType := int(wire & 0x7)
8434 if wireType == 4 {
8435 return fmt.Errorf("proto: ModifyMemoryRequest: wiretype end group for non-group")
8436 }
8437 if fieldNum <= 0 {
8438 return fmt.Errorf("proto: ModifyMemoryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
8439 }
8440 switch fieldNum {
8441 case 1:
8442 if wireType != 0 {
8443 return fmt.Errorf("proto: wrong wireType = %d for field MemoryMb", wireType)
8444 }
8445 m.MemoryMb = 0
8446 for shift := uint(0); ; shift += 7 {
8447 if shift >= 64 {
8448 return ErrIntOverflowVmservice
8449 }
8450 if iNdEx >= l {
8451 return io.ErrUnexpectedEOF
8452 }
8453 b := dAtA[iNdEx]
8454 iNdEx++
8455 m.MemoryMb |= uint64(b&0x7F) << shift
8456 if b < 0x80 {
8457 break
8458 }
8459 }
8460 default:
8461 iNdEx = preIndex
8462 skippy, err := skipVmservice(dAtA[iNdEx:])
8463 if err != nil {
8464 return err
8465 }
8466 if (skippy < 0) || (iNdEx+skippy) < 0 {
8467 return ErrInvalidLengthVmservice
8468 }
8469 if (iNdEx + skippy) > l {
8470 return io.ErrUnexpectedEOF
8471 }
8472 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
8473 iNdEx += skippy
8474 }
8475 }
8476
8477 if iNdEx > l {
8478 return io.ErrUnexpectedEOF
8479 }
8480 return nil
8481 }
8482 func (m *ModifyProcessorRequest) Unmarshal(dAtA []byte) error {
8483 l := len(dAtA)
8484 iNdEx := 0
8485 for iNdEx < l {
8486 preIndex := iNdEx
8487 var wire uint64
8488 for shift := uint(0); ; shift += 7 {
8489 if shift >= 64 {
8490 return ErrIntOverflowVmservice
8491 }
8492 if iNdEx >= l {
8493 return io.ErrUnexpectedEOF
8494 }
8495 b := dAtA[iNdEx]
8496 iNdEx++
8497 wire |= uint64(b&0x7F) << shift
8498 if b < 0x80 {
8499 break
8500 }
8501 }
8502 fieldNum := int32(wire >> 3)
8503 wireType := int(wire & 0x7)
8504 if wireType == 4 {
8505 return fmt.Errorf("proto: ModifyProcessorRequest: wiretype end group for non-group")
8506 }
8507 if fieldNum <= 0 {
8508 return fmt.Errorf("proto: ModifyProcessorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
8509 }
8510 switch fieldNum {
8511 case 1:
8512 if wireType != 0 {
8513 return fmt.Errorf("proto: wrong wireType = %d for field ProcessorIndex", wireType)
8514 }
8515 m.ProcessorIndex = 0
8516 for shift := uint(0); ; shift += 7 {
8517 if shift >= 64 {
8518 return ErrIntOverflowVmservice
8519 }
8520 if iNdEx >= l {
8521 return io.ErrUnexpectedEOF
8522 }
8523 b := dAtA[iNdEx]
8524 iNdEx++
8525 m.ProcessorIndex |= uint32(b&0x7F) << shift
8526 if b < 0x80 {
8527 break
8528 }
8529 }
8530 default:
8531 iNdEx = preIndex
8532 skippy, err := skipVmservice(dAtA[iNdEx:])
8533 if err != nil {
8534 return err
8535 }
8536 if (skippy < 0) || (iNdEx+skippy) < 0 {
8537 return ErrInvalidLengthVmservice
8538 }
8539 if (iNdEx + skippy) > l {
8540 return io.ErrUnexpectedEOF
8541 }
8542 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
8543 iNdEx += skippy
8544 }
8545 }
8546
8547 if iNdEx > l {
8548 return io.ErrUnexpectedEOF
8549 }
8550 return nil
8551 }
8552 func (m *ModifyProcessorConfigRequest) Unmarshal(dAtA []byte) error {
8553 l := len(dAtA)
8554 iNdEx := 0
8555 for iNdEx < l {
8556 preIndex := iNdEx
8557 var wire uint64
8558 for shift := uint(0); ; shift += 7 {
8559 if shift >= 64 {
8560 return ErrIntOverflowVmservice
8561 }
8562 if iNdEx >= l {
8563 return io.ErrUnexpectedEOF
8564 }
8565 b := dAtA[iNdEx]
8566 iNdEx++
8567 wire |= uint64(b&0x7F) << shift
8568 if b < 0x80 {
8569 break
8570 }
8571 }
8572 fieldNum := int32(wire >> 3)
8573 wireType := int(wire & 0x7)
8574 if wireType == 4 {
8575 return fmt.Errorf("proto: ModifyProcessorConfigRequest: wiretype end group for non-group")
8576 }
8577 if fieldNum <= 0 {
8578 return fmt.Errorf("proto: ModifyProcessorConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire)
8579 }
8580 switch fieldNum {
8581 case 1:
8582 if wireType != 0 {
8583 return fmt.Errorf("proto: wrong wireType = %d for field ProcessorWeight", wireType)
8584 }
8585 m.ProcessorWeight = 0
8586 for shift := uint(0); ; shift += 7 {
8587 if shift >= 64 {
8588 return ErrIntOverflowVmservice
8589 }
8590 if iNdEx >= l {
8591 return io.ErrUnexpectedEOF
8592 }
8593 b := dAtA[iNdEx]
8594 iNdEx++
8595 m.ProcessorWeight |= uint32(b&0x7F) << shift
8596 if b < 0x80 {
8597 break
8598 }
8599 }
8600 case 2:
8601 if wireType != 0 {
8602 return fmt.Errorf("proto: wrong wireType = %d for field ProcessorLimit", wireType)
8603 }
8604 m.ProcessorLimit = 0
8605 for shift := uint(0); ; shift += 7 {
8606 if shift >= 64 {
8607 return ErrIntOverflowVmservice
8608 }
8609 if iNdEx >= l {
8610 return io.ErrUnexpectedEOF
8611 }
8612 b := dAtA[iNdEx]
8613 iNdEx++
8614 m.ProcessorLimit |= uint32(b&0x7F) << shift
8615 if b < 0x80 {
8616 break
8617 }
8618 }
8619 default:
8620 iNdEx = preIndex
8621 skippy, err := skipVmservice(dAtA[iNdEx:])
8622 if err != nil {
8623 return err
8624 }
8625 if (skippy < 0) || (iNdEx+skippy) < 0 {
8626 return ErrInvalidLengthVmservice
8627 }
8628 if (iNdEx + skippy) > l {
8629 return io.ErrUnexpectedEOF
8630 }
8631 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
8632 iNdEx += skippy
8633 }
8634 }
8635
8636 if iNdEx > l {
8637 return io.ErrUnexpectedEOF
8638 }
8639 return nil
8640 }
8641 func (m *ModifyResourceRequest) Unmarshal(dAtA []byte) error {
8642 l := len(dAtA)
8643 iNdEx := 0
8644 for iNdEx < l {
8645 preIndex := iNdEx
8646 var wire uint64
8647 for shift := uint(0); ; shift += 7 {
8648 if shift >= 64 {
8649 return ErrIntOverflowVmservice
8650 }
8651 if iNdEx >= l {
8652 return io.ErrUnexpectedEOF
8653 }
8654 b := dAtA[iNdEx]
8655 iNdEx++
8656 wire |= uint64(b&0x7F) << shift
8657 if b < 0x80 {
8658 break
8659 }
8660 }
8661 fieldNum := int32(wire >> 3)
8662 wireType := int(wire & 0x7)
8663 if wireType == 4 {
8664 return fmt.Errorf("proto: ModifyResourceRequest: wiretype end group for non-group")
8665 }
8666 if fieldNum <= 0 {
8667 return fmt.Errorf("proto: ModifyResourceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
8668 }
8669 switch fieldNum {
8670 case 1:
8671 if wireType != 0 {
8672 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
8673 }
8674 m.Type = 0
8675 for shift := uint(0); ; shift += 7 {
8676 if shift >= 64 {
8677 return ErrIntOverflowVmservice
8678 }
8679 if iNdEx >= l {
8680 return io.ErrUnexpectedEOF
8681 }
8682 b := dAtA[iNdEx]
8683 iNdEx++
8684 m.Type |= ModifyType(b&0x7F) << shift
8685 if b < 0x80 {
8686 break
8687 }
8688 }
8689 case 2:
8690 if wireType != 2 {
8691 return fmt.Errorf("proto: wrong wireType = %d for field Processor", wireType)
8692 }
8693 var msglen int
8694 for shift := uint(0); ; shift += 7 {
8695 if shift >= 64 {
8696 return ErrIntOverflowVmservice
8697 }
8698 if iNdEx >= l {
8699 return io.ErrUnexpectedEOF
8700 }
8701 b := dAtA[iNdEx]
8702 iNdEx++
8703 msglen |= int(b&0x7F) << shift
8704 if b < 0x80 {
8705 break
8706 }
8707 }
8708 if msglen < 0 {
8709 return ErrInvalidLengthVmservice
8710 }
8711 postIndex := iNdEx + msglen
8712 if postIndex < 0 {
8713 return ErrInvalidLengthVmservice
8714 }
8715 if postIndex > l {
8716 return io.ErrUnexpectedEOF
8717 }
8718 v := &ModifyProcessorRequest{}
8719 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8720 return err
8721 }
8722 m.Resource = &ModifyResourceRequest_Processor{v}
8723 iNdEx = postIndex
8724 case 3:
8725 if wireType != 2 {
8726 return fmt.Errorf("proto: wrong wireType = %d for field ProcessorConfig", wireType)
8727 }
8728 var msglen int
8729 for shift := uint(0); ; shift += 7 {
8730 if shift >= 64 {
8731 return ErrIntOverflowVmservice
8732 }
8733 if iNdEx >= l {
8734 return io.ErrUnexpectedEOF
8735 }
8736 b := dAtA[iNdEx]
8737 iNdEx++
8738 msglen |= int(b&0x7F) << shift
8739 if b < 0x80 {
8740 break
8741 }
8742 }
8743 if msglen < 0 {
8744 return ErrInvalidLengthVmservice
8745 }
8746 postIndex := iNdEx + msglen
8747 if postIndex < 0 {
8748 return ErrInvalidLengthVmservice
8749 }
8750 if postIndex > l {
8751 return io.ErrUnexpectedEOF
8752 }
8753 v := &ModifyProcessorConfigRequest{}
8754 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8755 return err
8756 }
8757 m.Resource = &ModifyResourceRequest_ProcessorConfig{v}
8758 iNdEx = postIndex
8759 case 4:
8760 if wireType != 2 {
8761 return fmt.Errorf("proto: wrong wireType = %d for field Memory", wireType)
8762 }
8763 var msglen int
8764 for shift := uint(0); ; shift += 7 {
8765 if shift >= 64 {
8766 return ErrIntOverflowVmservice
8767 }
8768 if iNdEx >= l {
8769 return io.ErrUnexpectedEOF
8770 }
8771 b := dAtA[iNdEx]
8772 iNdEx++
8773 msglen |= int(b&0x7F) << shift
8774 if b < 0x80 {
8775 break
8776 }
8777 }
8778 if msglen < 0 {
8779 return ErrInvalidLengthVmservice
8780 }
8781 postIndex := iNdEx + msglen
8782 if postIndex < 0 {
8783 return ErrInvalidLengthVmservice
8784 }
8785 if postIndex > l {
8786 return io.ErrUnexpectedEOF
8787 }
8788 v := &ModifyMemoryRequest{}
8789 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8790 return err
8791 }
8792 m.Resource = &ModifyResourceRequest_Memory{v}
8793 iNdEx = postIndex
8794 case 5:
8795 if wireType != 2 {
8796 return fmt.Errorf("proto: wrong wireType = %d for field ScsiDisk", wireType)
8797 }
8798 var msglen int
8799 for shift := uint(0); ; shift += 7 {
8800 if shift >= 64 {
8801 return ErrIntOverflowVmservice
8802 }
8803 if iNdEx >= l {
8804 return io.ErrUnexpectedEOF
8805 }
8806 b := dAtA[iNdEx]
8807 iNdEx++
8808 msglen |= int(b&0x7F) << shift
8809 if b < 0x80 {
8810 break
8811 }
8812 }
8813 if msglen < 0 {
8814 return ErrInvalidLengthVmservice
8815 }
8816 postIndex := iNdEx + msglen
8817 if postIndex < 0 {
8818 return ErrInvalidLengthVmservice
8819 }
8820 if postIndex > l {
8821 return io.ErrUnexpectedEOF
8822 }
8823 v := &SCSIDisk{}
8824 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8825 return err
8826 }
8827 m.Resource = &ModifyResourceRequest_ScsiDisk{v}
8828 iNdEx = postIndex
8829 case 6:
8830 if wireType != 2 {
8831 return fmt.Errorf("proto: wrong wireType = %d for field VpmemDisk", wireType)
8832 }
8833 var msglen int
8834 for shift := uint(0); ; shift += 7 {
8835 if shift >= 64 {
8836 return ErrIntOverflowVmservice
8837 }
8838 if iNdEx >= l {
8839 return io.ErrUnexpectedEOF
8840 }
8841 b := dAtA[iNdEx]
8842 iNdEx++
8843 msglen |= int(b&0x7F) << shift
8844 if b < 0x80 {
8845 break
8846 }
8847 }
8848 if msglen < 0 {
8849 return ErrInvalidLengthVmservice
8850 }
8851 postIndex := iNdEx + msglen
8852 if postIndex < 0 {
8853 return ErrInvalidLengthVmservice
8854 }
8855 if postIndex > l {
8856 return io.ErrUnexpectedEOF
8857 }
8858 v := &VPMEMDisk{}
8859 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8860 return err
8861 }
8862 m.Resource = &ModifyResourceRequest_VpmemDisk{v}
8863 iNdEx = postIndex
8864 case 7:
8865 if wireType != 2 {
8866 return fmt.Errorf("proto: wrong wireType = %d for field NicConfig", wireType)
8867 }
8868 var msglen int
8869 for shift := uint(0); ; shift += 7 {
8870 if shift >= 64 {
8871 return ErrIntOverflowVmservice
8872 }
8873 if iNdEx >= l {
8874 return io.ErrUnexpectedEOF
8875 }
8876 b := dAtA[iNdEx]
8877 iNdEx++
8878 msglen |= int(b&0x7F) << shift
8879 if b < 0x80 {
8880 break
8881 }
8882 }
8883 if msglen < 0 {
8884 return ErrInvalidLengthVmservice
8885 }
8886 postIndex := iNdEx + msglen
8887 if postIndex < 0 {
8888 return ErrInvalidLengthVmservice
8889 }
8890 if postIndex > l {
8891 return io.ErrUnexpectedEOF
8892 }
8893 v := &NICConfig{}
8894 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8895 return err
8896 }
8897 m.Resource = &ModifyResourceRequest_NicConfig{v}
8898 iNdEx = postIndex
8899 case 8:
8900 if wireType != 2 {
8901 return fmt.Errorf("proto: wrong wireType = %d for field WindowsDevice", wireType)
8902 }
8903 var msglen int
8904 for shift := uint(0); ; shift += 7 {
8905 if shift >= 64 {
8906 return ErrIntOverflowVmservice
8907 }
8908 if iNdEx >= l {
8909 return io.ErrUnexpectedEOF
8910 }
8911 b := dAtA[iNdEx]
8912 iNdEx++
8913 msglen |= int(b&0x7F) << shift
8914 if b < 0x80 {
8915 break
8916 }
8917 }
8918 if msglen < 0 {
8919 return ErrInvalidLengthVmservice
8920 }
8921 postIndex := iNdEx + msglen
8922 if postIndex < 0 {
8923 return ErrInvalidLengthVmservice
8924 }
8925 if postIndex > l {
8926 return io.ErrUnexpectedEOF
8927 }
8928 v := &WindowsPCIDevice{}
8929 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8930 return err
8931 }
8932 m.Resource = &ModifyResourceRequest_WindowsDevice{v}
8933 iNdEx = postIndex
8934 default:
8935 iNdEx = preIndex
8936 skippy, err := skipVmservice(dAtA[iNdEx:])
8937 if err != nil {
8938 return err
8939 }
8940 if (skippy < 0) || (iNdEx+skippy) < 0 {
8941 return ErrInvalidLengthVmservice
8942 }
8943 if (iNdEx + skippy) > l {
8944 return io.ErrUnexpectedEOF
8945 }
8946 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
8947 iNdEx += skippy
8948 }
8949 }
8950
8951 if iNdEx > l {
8952 return io.ErrUnexpectedEOF
8953 }
8954 return nil
8955 }
8956 func skipVmservice(dAtA []byte) (n int, err error) {
8957 l := len(dAtA)
8958 iNdEx := 0
8959 depth := 0
8960 for iNdEx < l {
8961 var wire uint64
8962 for shift := uint(0); ; shift += 7 {
8963 if shift >= 64 {
8964 return 0, ErrIntOverflowVmservice
8965 }
8966 if iNdEx >= l {
8967 return 0, io.ErrUnexpectedEOF
8968 }
8969 b := dAtA[iNdEx]
8970 iNdEx++
8971 wire |= (uint64(b) & 0x7F) << shift
8972 if b < 0x80 {
8973 break
8974 }
8975 }
8976 wireType := int(wire & 0x7)
8977 switch wireType {
8978 case 0:
8979 for shift := uint(0); ; shift += 7 {
8980 if shift >= 64 {
8981 return 0, ErrIntOverflowVmservice
8982 }
8983 if iNdEx >= l {
8984 return 0, io.ErrUnexpectedEOF
8985 }
8986 iNdEx++
8987 if dAtA[iNdEx-1] < 0x80 {
8988 break
8989 }
8990 }
8991 case 1:
8992 iNdEx += 8
8993 case 2:
8994 var length int
8995 for shift := uint(0); ; shift += 7 {
8996 if shift >= 64 {
8997 return 0, ErrIntOverflowVmservice
8998 }
8999 if iNdEx >= l {
9000 return 0, io.ErrUnexpectedEOF
9001 }
9002 b := dAtA[iNdEx]
9003 iNdEx++
9004 length |= (int(b) & 0x7F) << shift
9005 if b < 0x80 {
9006 break
9007 }
9008 }
9009 if length < 0 {
9010 return 0, ErrInvalidLengthVmservice
9011 }
9012 iNdEx += length
9013 case 3:
9014 depth++
9015 case 4:
9016 if depth == 0 {
9017 return 0, ErrUnexpectedEndOfGroupVmservice
9018 }
9019 depth--
9020 case 5:
9021 iNdEx += 4
9022 default:
9023 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
9024 }
9025 if iNdEx < 0 {
9026 return 0, ErrInvalidLengthVmservice
9027 }
9028 if depth == 0 {
9029 return iNdEx, nil
9030 }
9031 }
9032 return 0, io.ErrUnexpectedEOF
9033 }
9034
9035 var (
9036 ErrInvalidLengthVmservice = fmt.Errorf("proto: negative length found during unmarshaling")
9037 ErrIntOverflowVmservice = fmt.Errorf("proto: integer overflow")
9038 ErrUnexpectedEndOfGroupVmservice = fmt.Errorf("proto: unexpected end of group")
9039 )
9040
View as plain text