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