From c0bfec12cdb1b511a253af4d71f7cd277c674b8e Mon Sep 17 00:00:00 2001 From: akutz Date: Fri, 4 Apr 2025 11:50:02 -0500 Subject: [PATCH] Revert v1a3 vm.status.storage.usage to 9.x This patch updates the VM API status.storage.usage data structure to be what it used to be, and what it shipped as in vC 9.0. The intent was to ship vC 9.0 with the same status.storage.usage structure now seen in v1alpha4, but there were some reverts, and those changes were discarded. --- api/v1alpha3/conversion_test.go | 4 + api/v1alpha3/virtualmachine_conversion.go | 28 +- .../virtualmachine_conversion_test.go | 324 ++++++++++++++++++ api/v1alpha3/virtualmachine_storage_types.go | 18 +- ...virtualmachine_storage_types_conversion.go | 35 ++ api/v1alpha3/zz_generated.conversion.go | 126 +++++-- api/v1alpha3/zz_generated.deepcopy.go | 12 +- ...vmoperator.vmware.com_virtualmachines.yaml | 20 +- 8 files changed, 504 insertions(+), 63 deletions(-) create mode 100644 api/v1alpha3/virtualmachine_conversion_test.go create mode 100644 api/v1alpha3/virtualmachine_storage_types_conversion.go diff --git a/api/v1alpha3/conversion_test.go b/api/v1alpha3/conversion_test.go index da29a4cbc..db862e664 100644 --- a/api/v1alpha3/conversion_test.go +++ b/api/v1alpha3/conversion_test.go @@ -280,3 +280,7 @@ func overrideVirtualMachineImageFieldsFuncs(codecs runtimeserializer.CodecFactor }, } } + +func ptrOf[T any](v T) *T { + return &v +} diff --git a/api/v1alpha3/virtualmachine_conversion.go b/api/v1alpha3/virtualmachine_conversion.go index fca319d48..7171d8bc3 100644 --- a/api/v1alpha3/virtualmachine_conversion.go +++ b/api/v1alpha3/virtualmachine_conversion.go @@ -7,19 +7,43 @@ package v1alpha3 import ( ctrlconversion "sigs.k8s.io/controller-runtime/pkg/conversion" + "github.com/vmware-tanzu/vm-operator/api/utilconversion" vmopv1 "github.com/vmware-tanzu/vm-operator/api/v1alpha4" ) // ConvertTo converts this VirtualMachine to the Hub version. func (src *VirtualMachine) ConvertTo(dstRaw ctrlconversion.Hub) error { dst := dstRaw.(*vmopv1.VirtualMachine) - return Convert_v1alpha3_VirtualMachine_To_v1alpha4_VirtualMachine(src, dst, nil) + if err := Convert_v1alpha3_VirtualMachine_To_v1alpha4_VirtualMachine(src, dst, nil); err != nil { + return err + } + + // Manually restore data. + restored := &vmopv1.VirtualMachine{} + if ok, err := utilconversion.UnmarshalData(src, restored); err != nil || !ok { + return err + } + + // BEGIN RESTORE + + // TODO(akutz) This is where any future restoration of spec data will go. + + // END RESTORE + + dst.Status = restored.Status + + return nil } // ConvertFrom converts the hub version to this VirtualMachine. func (dst *VirtualMachine) ConvertFrom(srcRaw ctrlconversion.Hub) error { src := srcRaw.(*vmopv1.VirtualMachine) - return Convert_v1alpha4_VirtualMachine_To_v1alpha3_VirtualMachine(src, dst, nil) + if err := Convert_v1alpha4_VirtualMachine_To_v1alpha3_VirtualMachine(src, dst, nil); err != nil { + return err + } + + // Preserve Hub data on down-conversion except for metadata + return utilconversion.MarshalData(src, dst) } // ConvertTo converts this VirtualMachineList to the Hub version. diff --git a/api/v1alpha3/virtualmachine_conversion_test.go b/api/v1alpha3/virtualmachine_conversion_test.go new file mode 100644 index 000000000..f019e78f5 --- /dev/null +++ b/api/v1alpha3/virtualmachine_conversion_test.go @@ -0,0 +1,324 @@ +// © Broadcom. All Rights Reserved. +// The term “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +// SPDX-License-Identifier: Apache-2.0 + +package v1alpha3_test + +import ( + "testing" + + . "github.com/onsi/gomega" + + "github.com/google/go-cmp/cmp" + "github.com/google/uuid" + corev1 "k8s.io/api/core/v1" + apiequality "k8s.io/apimachinery/pkg/api/equality" + "k8s.io/apimachinery/pkg/api/resource" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/util/intstr" + ctrlconversion "sigs.k8s.io/controller-runtime/pkg/conversion" + + vmopv1a3 "github.com/vmware-tanzu/vm-operator/api/v1alpha3" + vmopv1 "github.com/vmware-tanzu/vm-operator/api/v1alpha4" + vmopv1cloudinit "github.com/vmware-tanzu/vm-operator/api/v1alpha4/cloudinit" + vmopv1common "github.com/vmware-tanzu/vm-operator/api/v1alpha4/common" + vmopv1sysprep "github.com/vmware-tanzu/vm-operator/api/v1alpha4/sysprep" +) + +func TestVirtualMachineConversion(t *testing.T) { + + hubSpokeHub := func(g *WithT, hub, hubAfter ctrlconversion.Hub, spoke ctrlconversion.Convertible) { + hubBefore := hub.DeepCopyObject().(ctrlconversion.Hub) + + // First convert hub to spoke + dstCopy := spoke.DeepCopyObject().(ctrlconversion.Convertible) + g.Expect(dstCopy.ConvertFrom(hubBefore)).To(Succeed()) + + // Convert spoke back to hub and check if the resulting hub is equal to the hub before the round trip + g.Expect(dstCopy.ConvertTo(hubAfter)).To(Succeed()) + + g.Expect(apiequality.Semantic.DeepEqual(hubBefore, hubAfter)).To(BeTrue(), cmp.Diff(hubBefore, hubAfter)) + } + + t.Run("VirtualMachine hub-spoke-hub", func(t *testing.T) { + g := NewWithT(t) + + hub := vmopv1.VirtualMachine{ + Spec: vmopv1.VirtualMachineSpec{ + Image: &vmopv1.VirtualMachineImageRef{ + Name: "my-name", + }, + ImageName: "my-name", + ClassName: "my-class", + StorageClass: "my-storage-class", + Bootstrap: &vmopv1.VirtualMachineBootstrapSpec{ + CloudInit: &vmopv1.VirtualMachineBootstrapCloudInitSpec{ + CloudConfig: &vmopv1cloudinit.CloudConfig{ + Timezone: "my-tz", + Users: []vmopv1cloudinit.User{ + { + Name: "not-root", + }, + }, + }, + RawCloudConfig: &vmopv1common.SecretKeySelector{ + Name: "cloud-init-secret", + Key: "user-data", + }, + SSHAuthorizedKeys: []string{"my-ssh-key"}, + UseGlobalNameserversAsDefault: ptrOf(true), + UseGlobalSearchDomainsAsDefault: ptrOf(true), + }, + LinuxPrep: &vmopv1.VirtualMachineBootstrapLinuxPrepSpec{ + HardwareClockIsUTC: ptrOf(true), + TimeZone: "my-tz", + }, + Sysprep: &vmopv1.VirtualMachineBootstrapSysprepSpec{ + Sysprep: &vmopv1sysprep.Sysprep{ + GUIRunOnce: &vmopv1sysprep.GUIRunOnce{ + Commands: []string{"echo", "hello"}, + }, + GUIUnattended: &vmopv1sysprep.GUIUnattended{ + AutoLogon: true, + }, + Identification: &vmopv1sysprep.Identification{ + DomainAdmin: "my-admin", + }, + UserData: vmopv1sysprep.UserData{ + FullName: "vmware", + }, + }, + }, + VAppConfig: &vmopv1.VirtualMachineBootstrapVAppConfigSpec{ + Properties: []vmopv1common.KeyValueOrSecretKeySelectorPair{ + { + Key: "my-key", + Value: vmopv1common.ValueOrSecretKeySelector{ + Value: ptrOf("my-value"), + }, + }, + }, + RawProperties: "my-secret", + }, + }, + Network: &vmopv1.VirtualMachineNetworkSpec{ + DomainName: "my-domain.com", + HostName: "my-test-vm", + Disabled: true, + Nameservers: []string{"10.11.12.13", "9.9.9.9"}, + SearchDomains: []string{"foo.local", "bar.local"}, + Interfaces: []vmopv1.VirtualMachineNetworkInterfaceSpec{ + { + Name: "vds-interface", + Network: &vmopv1common.PartialObjectRef{ + TypeMeta: metav1.TypeMeta{ + Kind: "Network", + APIVersion: "netoperator.vmware.com/v1alpha1", + }, + Name: "primary", + }, + GuestDeviceName: "eth10", + }, + { + Name: "ncp-interface", + Network: &vmopv1common.PartialObjectRef{ + TypeMeta: metav1.TypeMeta{ + Kind: "VirtualNetwork", + APIVersion: "vmware.com/v1alpha1", + }, + Name: "segment1", + }, + GuestDeviceName: "eth20", + }, + { + Name: "nsx-vpc-subnet-interface", + Network: &vmopv1common.PartialObjectRef{ + TypeMeta: metav1.TypeMeta{ + Kind: "Subnet", + APIVersion: "crd.nsx.vmware.com/v1alpha1", + }, + Name: "segment-subnet", + }, + GuestDeviceName: "eth30", + }, + { + Name: "nsx-vpc-subnetset-interface", + Network: &vmopv1common.PartialObjectRef{ + TypeMeta: metav1.TypeMeta{ + Kind: "SubnetSet", + APIVersion: "crd.nsx.vmware.com/v1alpha1", + }, + Name: "segment-subnetset", + }, + }, + { + Name: "my-interface", + Network: &vmopv1common.PartialObjectRef{ + TypeMeta: metav1.TypeMeta{ + Kind: "Network", + APIVersion: "netoperator.vmware.com/v1alpha1", + }, + Name: "secondary", + }, + GuestDeviceName: "eth40", + Addresses: []string{"1.1.1.11", "2.2.2.22"}, + DHCP4: true, + DHCP6: true, + Gateway4: "1.1.1.1", + Gateway6: "2.2.2.2", + MTU: ptrOf[int64](9000), + Nameservers: []string{"9.9.9.9"}, + Routes: []vmopv1.VirtualMachineNetworkRouteSpec{ + { + To: "3.3.3.3", + Via: "1.1.1.111", + Metric: 42, + }, + }, + SearchDomains: []string{"vmware.com"}, + }, + }, + }, + PowerState: vmopv1.VirtualMachinePowerStateOff, + PowerOffMode: vmopv1.VirtualMachinePowerOpModeHard, + SuspendMode: vmopv1.VirtualMachinePowerOpModeTrySoft, + NextRestartTime: "tomorrow", + RestartMode: vmopv1.VirtualMachinePowerOpModeSoft, + Volumes: []vmopv1.VirtualMachineVolume{ + { + Name: "my-volume", + VirtualMachineVolumeSource: vmopv1.VirtualMachineVolumeSource{ + PersistentVolumeClaim: ptrOf(vmopv1.PersistentVolumeClaimVolumeSource{ + PersistentVolumeClaimVolumeSource: corev1.PersistentVolumeClaimVolumeSource{ + ClaimName: "my-claim", + }, + }), + }, + }, + { + Name: "my-volume-2", + VirtualMachineVolumeSource: vmopv1.VirtualMachineVolumeSource{ + PersistentVolumeClaim: ptrOf(vmopv1.PersistentVolumeClaimVolumeSource{ + PersistentVolumeClaimVolumeSource: corev1.PersistentVolumeClaimVolumeSource{ + ClaimName: "my-claim-2", + }, + InstanceVolumeClaim: &vmopv1.InstanceVolumeClaimVolumeSource{ + StorageClass: "instance-storage-class", + Size: resource.MustParse("2048k"), + }, + }), + }, + }, + }, + ReadinessProbe: &vmopv1.VirtualMachineReadinessProbeSpec{ + TCPSocket: &vmopv1.TCPSocketAction{ + Host: "some-host", + Port: intstr.FromString("https"), + }, + GuestHeartbeat: &vmopv1.GuestHeartbeatAction{ + ThresholdStatus: vmopv1.RedHeartbeatStatus, + }, + GuestInfo: []vmopv1.GuestInfoAction{ + { + Key: "guest-key", + Value: "guest-value", + }, + }, + TimeoutSeconds: 100, + PeriodSeconds: 200, + }, + Advanced: &vmopv1.VirtualMachineAdvancedSpec{ + BootDiskCapacity: ptrOf(resource.MustParse("1024k")), + DefaultVolumeProvisioningMode: vmopv1.VirtualMachineVolumeProvisioningModeThickEagerZero, + ChangeBlockTracking: ptrOf(true), + }, + Reserved: &vmopv1.VirtualMachineReservedSpec{ + ResourcePolicyName: "my-resource-policy", + }, + MinHardwareVersion: 42, + InstanceUUID: uuid.NewString(), + BiosUUID: uuid.NewString(), + GuestID: "my-guest-id", + Cdrom: []vmopv1.VirtualMachineCdromSpec{ + { + Name: "cdrom1", + Image: vmopv1.VirtualMachineImageRef{ + Name: "my-cdrom-image", + Kind: "VirtualMachineImage", + }, + AllowGuestControl: ptrOf(true), + Connected: ptrOf(true), + }, + }, + }, + } + + hubSpokeHub(g, &hub, &vmopv1.VirtualMachine{}, &vmopv1a3.VirtualMachine{}) + }) + + t.Run("VirtualMachine status.storage", func(t *testing.T) { + t.Run("hub-spoke-hub", func(t *testing.T) { + g := NewWithT(t) + hub := vmopv1.VirtualMachine{ + Status: vmopv1.VirtualMachineStatus{ + Storage: &vmopv1.VirtualMachineStorageStatus{ + Usage: &vmopv1.VirtualMachineStorageStatusUsage{ + Total: ptrOf(resource.MustParse("20Gi")), + Disks: ptrOf(resource.MustParse("10Gi")), + Other: ptrOf(resource.MustParse("5Gi")), + }, + }, + }, + } + hubSpokeHub(g, &hub, &vmopv1.VirtualMachine{}, &vmopv1a3.VirtualMachine{}) + }) + + t.Run("hub-spoke", func(t *testing.T) { + g := NewWithT(t) + hub := vmopv1.VirtualMachine{ + Status: vmopv1.VirtualMachineStatus{ + Storage: &vmopv1.VirtualMachineStorageStatus{ + Usage: &vmopv1.VirtualMachineStorageStatusUsage{ + Total: ptrOf(resource.MustParse("20Gi")), + Disks: ptrOf(resource.MustParse("10Gi")), + Other: ptrOf(resource.MustParse("5Gi")), + }, + }, + }, + } + + var spoke vmopv1a3.VirtualMachine + g.Expect(spoke.ConvertFrom(&hub)).To(Succeed()) + g.Expect(spoke.Status.Storage).ToNot(BeNil()) + g.Expect(spoke.Status.Storage.Usage).ToNot(BeNil()) + g.Expect(spoke.Status.Storage.Usage.Committed).To(BeNil()) + g.Expect(spoke.Status.Storage.Usage.Uncommitted).To(BeNil()) + g.Expect(spoke.Status.Storage.Usage.Unshared).To(Equal(ptrOf(resource.MustParse("20Gi")))) + }) + + t.Run("spoke-hub", func(t *testing.T) { + g := NewWithT(t) + spoke := vmopv1a3.VirtualMachine{ + Status: vmopv1a3.VirtualMachineStatus{ + Storage: &vmopv1a3.VirtualMachineStorageStatus{ + Usage: &vmopv1a3.VirtualMachineStorageStatusUsage{ + Committed: ptrOf(resource.MustParse("20Gi")), + Uncommitted: ptrOf(resource.MustParse("10Gi")), + Unshared: ptrOf(resource.MustParse("5Gi")), + }, + }, + }, + } + + var hub vmopv1.VirtualMachine + + g.Expect(spoke.ConvertTo(&hub)).To(Succeed()) + g.Expect(hub.Status.Storage).ToNot(BeNil()) + g.Expect(hub.Status.Storage.Usage).ToNot(BeNil()) + g.Expect(hub.Status.Storage.Usage.Total).To(Equal(ptrOf(resource.MustParse("5Gi")))) + g.Expect(hub.Status.Storage.Usage.Disks).To(BeNil()) + g.Expect(hub.Status.Storage.Usage.Other).To(BeNil()) + }) + }) + +} diff --git a/api/v1alpha3/virtualmachine_storage_types.go b/api/v1alpha3/virtualmachine_storage_types.go index 3ffd82601..a0e0360bb 100644 --- a/api/v1alpha3/virtualmachine_storage_types.go +++ b/api/v1alpha3/virtualmachine_storage_types.go @@ -175,20 +175,18 @@ type VirtualMachineStorageStatus struct { type VirtualMachineStorageStatusUsage struct { // +optional - // Total describes the total storage space used by a VirtualMachine that - // counts against the Namespace's storage quota. - Total *resource.Quantity `json:"total,omitempty"` + // Committed is the total storage space committed to this VirtualMachine. + Committed *resource.Quantity `json:"committed,omitempty"` // +optional - // Disks describes the total storage space used by a VirtualMachine's - // non-PVC disks. - Disks *resource.Quantity `json:"disks,omitempty"` + // Uncommitted is the total storage space potentially used by this + // VirtualMachine. + Uncommitted *resource.Quantity `json:"uncommitted,omitempty"` // +optional - // Other describes the total storage space used by the VirtualMachine's - // non disk files, ex. the configuration file, swap space, logs, snapshots, - // etc. - Other *resource.Quantity `json:"other,omitempty"` + // Unshared is the total storage space occupied by this VirtualMachine that + // is not shared with any other VirtualMachine. + Unshared *resource.Quantity `json:"unshared,omitempty"` } diff --git a/api/v1alpha3/virtualmachine_storage_types_conversion.go b/api/v1alpha3/virtualmachine_storage_types_conversion.go new file mode 100644 index 000000000..cbdc283cd --- /dev/null +++ b/api/v1alpha3/virtualmachine_storage_types_conversion.go @@ -0,0 +1,35 @@ +// © Broadcom. All Rights Reserved. +// The term “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +// SPDX-License-Identifier: Apache-2.0 + +package v1alpha3 + +import ( + apiconversion "k8s.io/apimachinery/pkg/conversion" + + vmopv1 "github.com/vmware-tanzu/vm-operator/api/v1alpha4" +) + +func Convert_v1alpha3_VirtualMachineStorageStatusUsage_To_v1alpha4_VirtualMachineStorageStatusUsage( + in *VirtualMachineStorageStatusUsage, out *vmopv1.VirtualMachineStorageStatusUsage, s apiconversion.Scope) error { + + if err := autoConvert_v1alpha3_VirtualMachineStorageStatusUsage_To_v1alpha4_VirtualMachineStorageStatusUsage(in, out, s); err != nil { + return err + } + + out.Total = in.Unshared + + return nil +} + +func Convert_v1alpha4_VirtualMachineStorageStatusUsage_To_v1alpha3_VirtualMachineStorageStatusUsage( + in *vmopv1.VirtualMachineStorageStatusUsage, out *VirtualMachineStorageStatusUsage, s apiconversion.Scope) error { + + if err := autoConvert_v1alpha4_VirtualMachineStorageStatusUsage_To_v1alpha3_VirtualMachineStorageStatusUsage(in, out, s); err != nil { + return err + } + + out.Unshared = in.Total + + return nil +} diff --git a/api/v1alpha3/zz_generated.conversion.go b/api/v1alpha3/zz_generated.conversion.go index de58f2351..88c3a34ff 100644 --- a/api/v1alpha3/zz_generated.conversion.go +++ b/api/v1alpha3/zz_generated.conversion.go @@ -1035,16 +1035,6 @@ func RegisterConversions(s *runtime.Scheme) error { }); err != nil { return err } - if err := s.AddGeneratedConversionFunc((*VirtualMachineStorageStatusUsage)(nil), (*v1alpha4.VirtualMachineStorageStatusUsage)(nil), func(a, b interface{}, scope conversion.Scope) error { - return Convert_v1alpha3_VirtualMachineStorageStatusUsage_To_v1alpha4_VirtualMachineStorageStatusUsage(a.(*VirtualMachineStorageStatusUsage), b.(*v1alpha4.VirtualMachineStorageStatusUsage), scope) - }); err != nil { - return err - } - if err := s.AddGeneratedConversionFunc((*v1alpha4.VirtualMachineStorageStatusUsage)(nil), (*VirtualMachineStorageStatusUsage)(nil), func(a, b interface{}, scope conversion.Scope) error { - return Convert_v1alpha4_VirtualMachineStorageStatusUsage_To_v1alpha3_VirtualMachineStorageStatusUsage(a.(*v1alpha4.VirtualMachineStorageStatusUsage), b.(*VirtualMachineStorageStatusUsage), scope) - }); err != nil { - return err - } if err := s.AddGeneratedConversionFunc((*VirtualMachineTemplate)(nil), (*v1alpha4.VirtualMachineTemplate)(nil), func(a, b interface{}, scope conversion.Scope) error { return Convert_v1alpha3_VirtualMachineTemplate_To_v1alpha4_VirtualMachineTemplate(a.(*VirtualMachineTemplate), b.(*v1alpha4.VirtualMachineTemplate), scope) }); err != nil { @@ -1145,6 +1135,16 @@ func RegisterConversions(s *runtime.Scheme) error { }); err != nil { return err } + if err := s.AddConversionFunc((*VirtualMachineStorageStatusUsage)(nil), (*v1alpha4.VirtualMachineStorageStatusUsage)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha3_VirtualMachineStorageStatusUsage_To_v1alpha4_VirtualMachineStorageStatusUsage(a.(*VirtualMachineStorageStatusUsage), b.(*v1alpha4.VirtualMachineStorageStatusUsage), scope) + }); err != nil { + return err + } + if err := s.AddConversionFunc((*v1alpha4.VirtualMachineStorageStatusUsage)(nil), (*VirtualMachineStorageStatusUsage)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1alpha4_VirtualMachineStorageStatusUsage_To_v1alpha3_VirtualMachineStorageStatusUsage(a.(*v1alpha4.VirtualMachineStorageStatusUsage), b.(*VirtualMachineStorageStatusUsage), scope) + }); err != nil { + return err + } return nil } @@ -2456,7 +2456,17 @@ func Convert_v1alpha4_VirtualMachineImageStatus_To_v1alpha3_VirtualMachineImageS func autoConvert_v1alpha3_VirtualMachineList_To_v1alpha4_VirtualMachineList(in *VirtualMachineList, out *v1alpha4.VirtualMachineList, s conversion.Scope) error { out.ListMeta = in.ListMeta - out.Items = *(*[]v1alpha4.VirtualMachine)(unsafe.Pointer(&in.Items)) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]v1alpha4.VirtualMachine, len(*in)) + for i := range *in { + if err := Convert_v1alpha3_VirtualMachine_To_v1alpha4_VirtualMachine(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.Items = nil + } return nil } @@ -2467,7 +2477,17 @@ func Convert_v1alpha3_VirtualMachineList_To_v1alpha4_VirtualMachineList(in *Virt func autoConvert_v1alpha4_VirtualMachineList_To_v1alpha3_VirtualMachineList(in *v1alpha4.VirtualMachineList, out *VirtualMachineList, s conversion.Scope) error { out.ListMeta = in.ListMeta - out.Items = *(*[]VirtualMachine)(unsafe.Pointer(&in.Items)) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]VirtualMachine, len(*in)) + for i := range *in { + if err := Convert_v1alpha4_VirtualMachine_To_v1alpha3_VirtualMachine(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.Items = nil + } return nil } @@ -3729,7 +3749,15 @@ func autoConvert_v1alpha3_VirtualMachineStatus_To_v1alpha4_VirtualMachineStatus( out.Zone = in.Zone out.LastRestartTime = (*v1.Time)(unsafe.Pointer(in.LastRestartTime)) out.HardwareVersion = in.HardwareVersion - out.Storage = (*v1alpha4.VirtualMachineStorageStatus)(unsafe.Pointer(in.Storage)) + if in.Storage != nil { + in, out := &in.Storage, &out.Storage + *out = new(v1alpha4.VirtualMachineStorageStatus) + if err := Convert_v1alpha3_VirtualMachineStorageStatus_To_v1alpha4_VirtualMachineStorageStatus(*in, *out, s); err != nil { + return err + } + } else { + out.Storage = nil + } return nil } @@ -3753,7 +3781,15 @@ func autoConvert_v1alpha4_VirtualMachineStatus_To_v1alpha3_VirtualMachineStatus( out.Zone = in.Zone out.LastRestartTime = (*v1.Time)(unsafe.Pointer(in.LastRestartTime)) out.HardwareVersion = in.HardwareVersion - out.Storage = (*VirtualMachineStorageStatus)(unsafe.Pointer(in.Storage)) + if in.Storage != nil { + in, out := &in.Storage, &out.Storage + *out = new(VirtualMachineStorageStatus) + if err := Convert_v1alpha4_VirtualMachineStorageStatus_To_v1alpha3_VirtualMachineStorageStatus(*in, *out, s); err != nil { + return err + } + } else { + out.Storage = nil + } return nil } @@ -3763,7 +3799,15 @@ func Convert_v1alpha4_VirtualMachineStatus_To_v1alpha3_VirtualMachineStatus(in * } func autoConvert_v1alpha3_VirtualMachineStorageStatus_To_v1alpha4_VirtualMachineStorageStatus(in *VirtualMachineStorageStatus, out *v1alpha4.VirtualMachineStorageStatus, s conversion.Scope) error { - out.Usage = (*v1alpha4.VirtualMachineStorageStatusUsage)(unsafe.Pointer(in.Usage)) + if in.Usage != nil { + in, out := &in.Usage, &out.Usage + *out = new(v1alpha4.VirtualMachineStorageStatusUsage) + if err := Convert_v1alpha3_VirtualMachineStorageStatusUsage_To_v1alpha4_VirtualMachineStorageStatusUsage(*in, *out, s); err != nil { + return err + } + } else { + out.Usage = nil + } return nil } @@ -3773,7 +3817,15 @@ func Convert_v1alpha3_VirtualMachineStorageStatus_To_v1alpha4_VirtualMachineStor } func autoConvert_v1alpha4_VirtualMachineStorageStatus_To_v1alpha3_VirtualMachineStorageStatus(in *v1alpha4.VirtualMachineStorageStatus, out *VirtualMachineStorageStatus, s conversion.Scope) error { - out.Usage = (*VirtualMachineStorageStatusUsage)(unsafe.Pointer(in.Usage)) + if in.Usage != nil { + in, out := &in.Usage, &out.Usage + *out = new(VirtualMachineStorageStatusUsage) + if err := Convert_v1alpha4_VirtualMachineStorageStatusUsage_To_v1alpha3_VirtualMachineStorageStatusUsage(*in, *out, s); err != nil { + return err + } + } else { + out.Usage = nil + } return nil } @@ -3783,34 +3835,32 @@ func Convert_v1alpha4_VirtualMachineStorageStatus_To_v1alpha3_VirtualMachineStor } func autoConvert_v1alpha3_VirtualMachineStorageStatusUsage_To_v1alpha4_VirtualMachineStorageStatusUsage(in *VirtualMachineStorageStatusUsage, out *v1alpha4.VirtualMachineStorageStatusUsage, s conversion.Scope) error { - out.Total = (*resource.Quantity)(unsafe.Pointer(in.Total)) - out.Disks = (*resource.Quantity)(unsafe.Pointer(in.Disks)) - out.Other = (*resource.Quantity)(unsafe.Pointer(in.Other)) + // WARNING: in.Committed requires manual conversion: does not exist in peer-type + // WARNING: in.Uncommitted requires manual conversion: does not exist in peer-type + // WARNING: in.Unshared requires manual conversion: does not exist in peer-type return nil } -// Convert_v1alpha3_VirtualMachineStorageStatusUsage_To_v1alpha4_VirtualMachineStorageStatusUsage is an autogenerated conversion function. -func Convert_v1alpha3_VirtualMachineStorageStatusUsage_To_v1alpha4_VirtualMachineStorageStatusUsage(in *VirtualMachineStorageStatusUsage, out *v1alpha4.VirtualMachineStorageStatusUsage, s conversion.Scope) error { - return autoConvert_v1alpha3_VirtualMachineStorageStatusUsage_To_v1alpha4_VirtualMachineStorageStatusUsage(in, out, s) -} - func autoConvert_v1alpha4_VirtualMachineStorageStatusUsage_To_v1alpha3_VirtualMachineStorageStatusUsage(in *v1alpha4.VirtualMachineStorageStatusUsage, out *VirtualMachineStorageStatusUsage, s conversion.Scope) error { - out.Total = (*resource.Quantity)(unsafe.Pointer(in.Total)) - out.Disks = (*resource.Quantity)(unsafe.Pointer(in.Disks)) - out.Other = (*resource.Quantity)(unsafe.Pointer(in.Other)) + // WARNING: in.Total requires manual conversion: does not exist in peer-type + // WARNING: in.Disks requires manual conversion: does not exist in peer-type + // WARNING: in.Other requires manual conversion: does not exist in peer-type return nil } -// Convert_v1alpha4_VirtualMachineStorageStatusUsage_To_v1alpha3_VirtualMachineStorageStatusUsage is an autogenerated conversion function. -func Convert_v1alpha4_VirtualMachineStorageStatusUsage_To_v1alpha3_VirtualMachineStorageStatusUsage(in *v1alpha4.VirtualMachineStorageStatusUsage, out *VirtualMachineStorageStatusUsage, s conversion.Scope) error { - return autoConvert_v1alpha4_VirtualMachineStorageStatusUsage_To_v1alpha3_VirtualMachineStorageStatusUsage(in, out, s) -} - func autoConvert_v1alpha3_VirtualMachineTemplate_To_v1alpha4_VirtualMachineTemplate(in *VirtualMachineTemplate, out *v1alpha4.VirtualMachineTemplate, s conversion.Scope) error { if err := Convert_v1alpha3_NetworkStatus_To_v1alpha4_NetworkStatus(&in.Net, &out.Net, s); err != nil { return err } - out.VM = (*v1alpha4.VirtualMachine)(unsafe.Pointer(in.VM)) + if in.VM != nil { + in, out := &in.VM, &out.VM + *out = new(v1alpha4.VirtualMachine) + if err := Convert_v1alpha3_VirtualMachine_To_v1alpha4_VirtualMachine(*in, *out, s); err != nil { + return err + } + } else { + out.VM = nil + } return nil } @@ -3823,7 +3873,15 @@ func autoConvert_v1alpha4_VirtualMachineTemplate_To_v1alpha3_VirtualMachineTempl if err := Convert_v1alpha4_NetworkStatus_To_v1alpha3_NetworkStatus(&in.Net, &out.Net, s); err != nil { return err } - out.VM = (*VirtualMachine)(unsafe.Pointer(in.VM)) + if in.VM != nil { + in, out := &in.VM, &out.VM + *out = new(VirtualMachine) + if err := Convert_v1alpha4_VirtualMachine_To_v1alpha3_VirtualMachine(*in, *out, s); err != nil { + return err + } + } else { + out.VM = nil + } return nil } diff --git a/api/v1alpha3/zz_generated.deepcopy.go b/api/v1alpha3/zz_generated.deepcopy.go index 0ed833d56..0b27b8506 100644 --- a/api/v1alpha3/zz_generated.deepcopy.go +++ b/api/v1alpha3/zz_generated.deepcopy.go @@ -2415,18 +2415,18 @@ func (in *VirtualMachineStorageStatus) DeepCopy() *VirtualMachineStorageStatus { // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *VirtualMachineStorageStatusUsage) DeepCopyInto(out *VirtualMachineStorageStatusUsage) { *out = *in - if in.Total != nil { - in, out := &in.Total, &out.Total + if in.Committed != nil { + in, out := &in.Committed, &out.Committed x := (*in).DeepCopy() *out = &x } - if in.Disks != nil { - in, out := &in.Disks, &out.Disks + if in.Uncommitted != nil { + in, out := &in.Uncommitted, &out.Uncommitted x := (*in).DeepCopy() *out = &x } - if in.Other != nil { - in, out := &in.Other, &out.Other + if in.Unshared != nil { + in, out := &in.Unshared, &out.Unshared x := (*in).DeepCopy() *out = &x } diff --git a/config/crd/bases/vmoperator.vmware.com_virtualmachines.yaml b/config/crd/bases/vmoperator.vmware.com_virtualmachines.yaml index 975155cfd..ff9a0b24f 100644 --- a/config/crd/bases/vmoperator.vmware.com_virtualmachines.yaml +++ b/config/crd/bases/vmoperator.vmware.com_virtualmachines.yaml @@ -5426,32 +5426,30 @@ spec: description: Usage describes the observed amount of storage used by a VirtualMachine. properties: - disks: + committed: anyOf: - type: integer - type: string - description: |- - Disks describes the total storage space used by a VirtualMachine's - non-PVC disks. + description: Committed is the total storage space committed + to this VirtualMachine. pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$ x-kubernetes-int-or-string: true - other: + uncommitted: anyOf: - type: integer - type: string description: |- - Other describes the total storage space used by the VirtualMachine's - non disk files, ex. the configuration file, swap space, logs, snapshots, - etc. + Uncommitted is the total storage space potentially used by this + VirtualMachine. pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$ x-kubernetes-int-or-string: true - total: + unshared: anyOf: - type: integer - type: string description: |- - Total describes the total storage space used by a VirtualMachine that - counts against the Namespace's storage quota. + Unshared is the total storage space occupied by this VirtualMachine that + is not shared with any other VirtualMachine. pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$ x-kubernetes-int-or-string: true type: object