v1alpha2

package
v1.8.6 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 4, 2024 License: Apache-2.0 Imports: 12 Imported by: 15

Documentation

Overview

+k8s:openapi-gen=true +kubebuilder:object:generate=true +groupName=vmoperator.vmware.com

Index

Constants

View Source 
const (
	// VirtualMachineConditionClassReady indicates that a referenced
	// VirtualMachineClass is ready.
	//
	// For more information please see VirtualMachineClass.Status.Ready.
	VirtualMachineConditionClassReady = "VirtualMachineClassReady"

	// VirtualMachineConditionImageReady indicates that a referenced
	// VirtualMachineImage is ready.
	//
	// For more information please see VirtualMachineImage.Status.Ready.
	VirtualMachineConditionImageReady = "VirtualMachineImageReady"

	// VirtualMachineConditionVMSetResourcePolicyReady indicates that a referenced
	// VirtualMachineSetResourcePolicy is Ready.
	VirtualMachineConditionVMSetResourcePolicyReady = "VirtualMachineConditionVMSetResourcePolicyReady"

	// VirtualMachineConditionStorageReady indicates that the storage prerequisites for the VM are ready.
	VirtualMachineConditionStorageReady = "VirtualMachineStorageReady"

	// VirtualMachineConditionBootstrapReady indicates that the bootstrap prerequisites for the VM are ready.
	VirtualMachineConditionBootstrapReady = "VirtualMachineBootstrapReady"

	// VirtualMachineConditionNetworkReady indicates that the network prerequisites for the VM are ready.
	VirtualMachineConditionNetworkReady = "VirtualMachineNetworkReady"

	// VirtualMachineConditionPlacementReady indicates that the placement decision for the VM is ready.
	VirtualMachineConditionPlacementReady = "VirtualMachineConditionPlacementReady"

	// VirtualMachineConditionCreated indicates that the VM has been created.
	VirtualMachineConditionCreated = "VirtualMachineCreated"
)
View Source 
const (
	// GuestCustomizationCondition exposes the status of guest customization
	// from within the guest OS, when available.
	GuestCustomizationCondition = "GuestCustomization"

	// GuestCustomizationIdleReason documents that guest
	// customizations were not applied for the VirtualMachine.
	GuestCustomizationIdleReason = "GuestCustomizationIdle"

	// GuestCustomizationPendingReason documents that guest
	// customization is still pending within the guest OS.
	GuestCustomizationPendingReason = "GuestCustomizationPending"

	// GuestCustomizationRunningReason documents that the guest
	// customization is now running on the guest OS.
	GuestCustomizationRunningReason = "GuestCustomizationRunning"

	// GuestCustomizationSucceededReason documents that the
	// guest customization succeeded within the guest OS.
	GuestCustomizationSucceededReason = "GuestCustomizationSucceeded"

	// GuestCustomizationFailedReason documents that the guest
	// customization failed within the guest OS.
	GuestCustomizationFailedReason = "GuestCustomizationFailed"
)
View Source 
const (
	// VirtualMachineToolsCondition exposes the status of VMware Tools running
	// in the guest OS, when available.
	VirtualMachineToolsCondition = "VirtualMachineTools"

	// VirtualMachineToolsNotRunningReason documents that
	// VMware Tools is not running.
	VirtualMachineToolsNotRunningReason = "VirtualMachineToolsNotRunning"

	// VirtualMachineToolsRunningReason documents that VMware
	// Tools is running.
	VirtualMachineToolsRunningReason = "VirtualMachineToolsRunning"
)
View Source 
const (
	// PauseAnnotation is an annotation that prevents a VM from being
	// reconciled.
	//
	// This can be used when a VM needs to be modified directly on the
	// underlying infrastructure without VM Service attempting to direct the
	// VM back to its intended state.
	//
	// The VM will not be reconciled again until this annotation is removed.
	PauseAnnotation = GroupName + "/pause-reconcile"

	// InstanceIDAnnotation is an annotation that can be applied to set Cloud-Init metadata Instance ID.
	//
	// This cannot be set by users. It is for VM Operator to handle corner cases.
	//
	// In a corner case where a VM first boot failed to bootstrap with Cloud-Init, VM Operator sets Instance ID
	// the same with the first boot Instance ID to prevent Cloud-Init from treating this VM as first boot
	// due to different Instance ID. This annotation is used in upgrade script.
	InstanceIDAnnotation = GroupName + "/cloud-init-instance-id"

	// FirstBootDoneAnnotation is an annotation that indicates the VM has been
	// booted at least once. This annotation cannot be set by users and will not
	// be removed once set until the VM is deleted.
	FirstBootDoneAnnotation = "virtualmachine." + GroupName + "/first-boot-done"
)
View Source 
const (
	// ManagedByExtensionKey and ManagedByExtensionType represent the ManagedBy
	// field on the VM. They are used to differentiate VM Service managed VMs
	// from traditional vSphere VMs.
	ManagedByExtensionKey  = "com.vmware.vcenter.wcp"
	ManagedByExtensionType = "VirtualMachine"
)
View Source 
const (
	// VMResourceYAMLExtraConfigKey is the ExtraConfig key to persist VM
	// Kubernetes resource YAML, compressed using gzip and base64-encoded.
	VMResourceYAMLExtraConfigKey = "vmservice.virtualmachine.resource.yaml"
	// AdditionalResourcesYAMLExtraConfigKey is the ExtraConfig key to persist
	// VM-relevant Kubernetes resource YAML, compressed using gzip and base64-encoded.
	AdditionalResourcesYAMLExtraConfigKey = "vmservice.virtualmachine.additional.resources.yaml"
	// PVCDiskDataExtraConfigKey is the ExtraConfig key to persist the VM's
	// PVC disk data in JSON, compressed using gzip and base64-encoded.
	PVCDiskDataExtraConfigKey = "vmservice.virtualmachine.pvc.disk.data"
)

VirtualMachine backup/restore related constants.

View Source 
const (

	// VirtualMachineImageOSIDLabel is a label applied to images with
	// a value that specifies the operating system ID.
	VirtualMachineImageOSIDLabel = imageOSLabelPrefix + "id"

	// VirtualMachineImageOSTypeLabel is a label applied to images with a
	// value that specifies the operating system type.
	VirtualMachineImageOSTypeLabel = imageOSLabelPrefix + "type"

	// VirtualMachineImageOSVersionLabel is a label applied to images with
	// a value that specifies the operating system version.
	VirtualMachineImageOSVersionLabel = imageOSLabelPrefix + "version"
)
View Source 
const (
	// VirtualMachineImageNotSyncedReason documents that the VirtualMachineImage is not synced with
	// the vSphere content library item that contains the source of this image's information.
	VirtualMachineImageNotSyncedReason = "VirtualMachineImageNotSynced"

	// VirtualMachineImageProviderNotReadyReason documents that the VirtualMachineImage provider
	// is not in ready state.
	VirtualMachineImageProviderNotReadyReason = "VirtualMachineImageProviderNotReady"

	// VirtualMachineImageProviderSecurityNotCompliantReason documents that the
	// VirtualMachineImage provider doesn't meet security compliance requirements.
	VirtualMachineImageProviderSecurityNotCompliantReason = "VirtualMachineImageProviderSecurityNotCompliant"
)

Condition reasons for VirtualMachineImages.

View Source 
const (
	// VirtualMachinePublishRequestConditionSourceValid is the Type for a
	// VirtualMachinePublishRequest resource's status condition.
	//
	// The condition's status is set to true only when the information
	// that describes the source side of the publication has been validated.
	VirtualMachinePublishRequestConditionSourceValid = "SourceValid"

	// VirtualMachinePublishRequestConditionTargetValid is the Type for a
	// VirtualMachinePublishRequest resource's status condition.
	//
	// The condition's status is set to true only when the information
	// that describes the target side of the publication has been
	// validated.
	VirtualMachinePublishRequestConditionTargetValid = "TargetValid"

	// VirtualMachinePublishRequestConditionUploaded is the Type for a
	// VirtualMachinePublishRequest resource's status condition.
	//
	// The condition's status is set to true only when the VM being
	// published has been successfully uploaded.
	VirtualMachinePublishRequestConditionUploaded = "Uploaded"

	// VirtualMachinePublishRequestConditionImageAvailable is the Type for a
	// VirtualMachinePublishRequest resource's status condition.
	//
	// The condition's status is set to true only when a new
	// VirtualMachineImage resource has been realized from the published
	// VM.
	VirtualMachinePublishRequestConditionImageAvailable = "ImageAvailable"

	// VirtualMachinePublishRequestConditionComplete is the Type for a
	// VirtualMachinePublishRequest resource's status condition.
	//
	// The condition's status is set to true only when all other conditions
	// present on the resource have a truthy status.
	VirtualMachinePublishRequestConditionComplete = "Complete"
)
View Source 
const (
	// SourceVirtualMachineNotExistReason documents that the source VM of
	// the VirtualMachinePublishRequest doesn't exist.
	SourceVirtualMachineNotExistReason = "SourceVirtualMachineNotExist"

	// SourceVirtualMachineNotCreatedReason documents that the source VM of
	// the VirtualMachinePublishRequest hasn't been created.
	SourceVirtualMachineNotCreatedReason = "SourceVirtualMachineNotCreated"

	// TargetContentLibraryNotExistReason documents that the target content
	// library of the VirtualMachinePublishRequest doesn't exist.
	TargetContentLibraryNotExistReason = "TargetContentLibraryNotExist"

	// TargetContentLibraryNotWritableReason documents that the target content
	// library of the VirtualMachinePublishRequest isn't writable.
	TargetContentLibraryNotWritableReason = "TargetContentLibraryNotWritable"

	// TargetContentLibraryNotReadyReason documents that the target content
	// library of the VirtualMachinePublishRequest isn't ready.
	TargetContentLibraryNotReadyReason = "TargetContentLibraryNotReady"

	// TargetItemAlreadyExistsReason documents that an item with the same name
	// as the VirtualMachinePublishRequest's target item name exists in
	// the target content library.
	TargetItemAlreadyExistsReason = "TargetItemAlreadyExists"

	// TargetVirtualMachineImageNotFoundReason documents that the expected
	// VirtualMachineImage resource corresponding to the VirtualMachinePublishRequest's
	// target item is not found in the namespace.
	TargetVirtualMachineImageNotFoundReason = "VirtualMachineImageNotFound"

	// UploadTaskNotStartedReason documents that the VM publish task hasn't started.
	UploadTaskNotStartedReason = "NotStarted"

	// UploadTaskQueuedReason documents that the VM publish task is in queued status.
	UploadTaskQueuedReason = "Queued"

	// UploadingReason documents that the VM publish task is in running status
	// and the published item is being uploaded to the target location.
	UploadingReason = "Uploading"

	// UploadItemIDInvalidReason documents that the VM publish task result
	// returns an invalid Item id.
	UploadItemIDInvalidReason = "ItemIDInvalid"

	// UploadFailureReason documents that uploading published item to the
	// target location failed.
	UploadFailureReason = "UploadFailure"

	// HasNotBeenUploadedReason documents that the VirtualMachinePublishRequest
	// hasn't completed because the published item hasn't been uploaded
	// to the target location.
	HasNotBeenUploadedReason = "HasNotBeenUploaded"

	// ImageUnavailableReason documents that the VirtualMachinePublishRequest
	// hasn't been completed because the expected VirtualMachineImage resource
	// isn't available yet.
	ImageUnavailableReason = "ImageUnavailable"
)

Condition.Reason for Conditions related to VirtualMachinePublishRequest.

View Source 
const GroupName = "vmoperator.vmware.com"

GroupName specifies the group name used to register the objects.

View Source 
const (
	// GuestBootstrapCondition exposes the status of guest bootstrap from within
	// the guest OS, when available.
	GuestBootstrapCondition = "GuestBootstrap"
)
View Source 
const (
	// ReadyConditionType is the Ready condition type that summarizes the operational state of a VM Operator API object.
	ReadyConditionType = "Ready"
)
View Source 
const (
	// VMIContentLibRefAnnotation is the key for the annotation that stores the content library
	// reference for VMI and CVMI down conversion.
	VMIContentLibRefAnnotation = "vmoperator.vmware.com/conversion-content-lib-ref"
)
View Source 
const (
	// VirtualMachineImageCapabilityLabel is the prefix for a label that
	// advertises an image capability.
	VirtualMachineImageCapabilityLabel = "capability.image." + GroupName + "/"
)
View Source 
const (
	// VirtualMachineImageV1Alpha1CompatibleCondition denotes that an image was prepared by
	// VMware specifically for compatibility with VMService.
	VirtualMachineImageV1Alpha1CompatibleCondition = "VirtualMachineImageV1Alpha1Compatible"
)

Variables

View Source 
var (
	// SchemeGroupVersion is group version used to register these objects
	SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha2"}

	// SchemeBuilder is used to add go types to the GroupVersionKind scheme
	SchemeBuilder = &scheme.Builder{GroupVersion: SchemeGroupVersion}

	// AddToScheme adds the types in this group-version to the given scheme.
	AddToScheme = SchemeBuilder.AddToScheme
)

Functions

This section is empty.

Types

type ClusterVirtualMachineImage 

type ClusterVirtualMachineImage struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   VirtualMachineImageSpec   `json:"spec,omitempty"`
	Status VirtualMachineImageStatus `json:"status,omitempty"`
}

ClusterVirtualMachineImage is the schema for the clustervirtualmachineimages API.

func (*ClusterVirtualMachineImage) DeepCopy 

func (in *ClusterVirtualMachineImage) DeepCopy() *ClusterVirtualMachineImage

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterVirtualMachineImage.

func (*ClusterVirtualMachineImage) DeepCopyInto 

func (in *ClusterVirtualMachineImage) DeepCopyInto(out *ClusterVirtualMachineImage)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterVirtualMachineImage) DeepCopyObject 

func (in *ClusterVirtualMachineImage) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*ClusterVirtualMachineImage) GetConditions added in v1.8.5 

func (i *ClusterVirtualMachineImage) GetConditions() []metav1.Condition

func (*ClusterVirtualMachineImage) Hub 

func (*ClusterVirtualMachineImage) Hub()

Hub marks ClusterVirtualMachineImage as a conversion hub.

func (*ClusterVirtualMachineImage) SetConditions added in v1.8.5 

func (i *ClusterVirtualMachineImage) SetConditions(conditions []metav1.Condition)

func (*ClusterVirtualMachineImage) SetupWebhookWithManager 

func (r *ClusterVirtualMachineImage) SetupWebhookWithManager(mgr ctrl.Manager) error

type ClusterVirtualMachineImageList 

type ClusterVirtualMachineImageList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ClusterVirtualMachineImage `json:"items"`
}

ClusterVirtualMachineImageList contains a list of ClusterVirtualMachineImage.

func (*ClusterVirtualMachineImageList) DeepCopy 

func (in *ClusterVirtualMachineImageList) DeepCopy() *ClusterVirtualMachineImageList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterVirtualMachineImageList.

func (*ClusterVirtualMachineImageList) DeepCopyInto 

func (in *ClusterVirtualMachineImageList) DeepCopyInto(out *ClusterVirtualMachineImageList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*ClusterVirtualMachineImageList) DeepCopyObject 

func (in *ClusterVirtualMachineImageList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*ClusterVirtualMachineImageList) Hub 

func (*ClusterVirtualMachineImageList) Hub()

Hub marks ClusterVirtualMachineImageList as a conversion hub.

type DynamicDirectPathIODevice 

type DynamicDirectPathIODevice struct {
	VendorID int64 `json:"vendorID"`
	DeviceID int64 `json:"deviceID"`

	// +optional
	CustomLabel string `json:"customLabel,omitempty"`
}

DynamicDirectPathIODevice contains the configuration corresponding to a Dynamic DirectPath I/O device.

func (*DynamicDirectPathIODevice) DeepCopy 

func (in *DynamicDirectPathIODevice) DeepCopy() *DynamicDirectPathIODevice

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DynamicDirectPathIODevice.

func (*DynamicDirectPathIODevice) DeepCopyInto 

func (in *DynamicDirectPathIODevice) DeepCopyInto(out *DynamicDirectPathIODevice)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type GuestHeartbeatAction 

type GuestHeartbeatAction struct {
	// ThresholdStatus is the value that the guest heartbeat status must be at or above to be
	// considered successful.
	// +kubebuilder:validation:Optional
	// +kubebuilder:default=green
	// +kubebuilder:validation:Enum=yellow;green
	ThresholdStatus GuestHeartbeatStatus `json:"thresholdStatus,omitempty"`
}

GuestHeartbeatAction describes an action based on the guest heartbeat.

func (*GuestHeartbeatAction) DeepCopy 

func (in *GuestHeartbeatAction) DeepCopy() *GuestHeartbeatAction

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GuestHeartbeatAction.

func (*GuestHeartbeatAction) DeepCopyInto 

func (in *GuestHeartbeatAction) DeepCopyInto(out *GuestHeartbeatAction)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type GuestHeartbeatStatus 

type GuestHeartbeatStatus string

GuestHeartbeatStatus is the guest heartbeat status. 

const (
	// GrayHeartbeatStatus means VMware Tools are not installed or not running.
	GrayHeartbeatStatus GuestHeartbeatStatus = "gray"
	// RedHeartbeatStatus means no heartbeat.
	// Guest operating system may have stopped responding.
	RedHeartbeatStatus GuestHeartbeatStatus = "red"
	// YellowHeartbeatStatus means an intermittent heartbeat.
	// This may be due to guest load.
	YellowHeartbeatStatus GuestHeartbeatStatus = "yellow"
	// GreenHeartbeatStatus means the guest operating system is responding normally.
	GreenHeartbeatStatus GuestHeartbeatStatus = "green"
)

See govmomi.vim25.types.ManagedEntityStatus

type GuestInfoAction 

type GuestInfoAction struct {
	// Key is the name of the GuestInfo key.
	//
	// The key is automatically prefixed with "guestinfo." before being
	// evaluated. Thus if the key "guestinfo.mykey" is provided, it will be
	// evaluated as "guestinfo.guestinfo.mykey".
	Key string `json:"key"`

	// Value is a regular expression that is matched against the value of the
	// specified key.
	//
	// An empty value is the equivalent of "match any" or ".*".
	//
	// All values must adhere to the RE2 regular expression syntax as documented
	// at https://golang.org/s/re2syntax. Invalid values may be rejected or
	// ignored depending on the implementation of this API. Either way, invalid
	// values will not be considered when evaluating the ready state of a VM.
	//
	// +optional
	Value string `json:"value,omitempty"`
}

GuestInfoAction describes a key from GuestInfo that must match the associated value expression.

func (*GuestInfoAction) DeepCopy 

func (in *GuestInfoAction) DeepCopy() *GuestInfoAction

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GuestInfoAction.

func (*GuestInfoAction) DeepCopyInto 

func (in *GuestInfoAction) DeepCopyInto(out *GuestInfoAction)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type InstanceStorage 

type InstanceStorage struct {
	// StorageClass refers to the name of a StorageClass resource used to
	// provide the storage for the configured instance storage volumes.
	// The value of this field has no relationship to or bearing on the field
	// virtualMachine.spec.storageClass. Please note the referred StorageClass
	// must be available in the same namespace as the VirtualMachineClass that
	// uses it for configuring instance storage.
	StorageClass string `json:"storageClass,omitempty"`

	// Volumes describes instance storage volumes created for a VirtualMachine
	// instance that use this VirtualMachineClass.
	Volumes []InstanceStorageVolume `json:"volumes,omitempty"`
}

InstanceStorage provides information used to configure instance storage volumes for a VirtualMachine.

func (*InstanceStorage) DeepCopy 

func (in *InstanceStorage) DeepCopy() *InstanceStorage

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new InstanceStorage.

func (*InstanceStorage) DeepCopyInto 

func (in *InstanceStorage) DeepCopyInto(out *InstanceStorage)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type InstanceStorageVolume 

type InstanceStorageVolume struct {
	Size resource.Quantity `json:"size"`
}

InstanceStorageVolume contains information required to create an instance storage volume on a VirtualMachine.

func (*InstanceStorageVolume) DeepCopy 

func (in *InstanceStorageVolume) DeepCopy() *InstanceStorageVolume

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new InstanceStorageVolume.

func (*InstanceStorageVolume) DeepCopyInto 

func (in *InstanceStorageVolume) DeepCopyInto(out *InstanceStorageVolume)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type InstanceVolumeClaimVolumeSource 

type InstanceVolumeClaimVolumeSource struct {
	// StorageClass is the name of the Kubernetes StorageClass that provides
	// the backing storage for this instance storage volume.
	StorageClass string `json:"storageClass"`

	// Size is the size of the requested instance storage volume.
	Size resource.Quantity `json:"size"`
}

InstanceVolumeClaimVolumeSource contains information about the instance storage volume claimed as a PVC.

func (*InstanceVolumeClaimVolumeSource) DeepCopy 

func (in *InstanceVolumeClaimVolumeSource) DeepCopy() *InstanceVolumeClaimVolumeSource

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new InstanceVolumeClaimVolumeSource.

func (*InstanceVolumeClaimVolumeSource) DeepCopyInto 

func (in *InstanceVolumeClaimVolumeSource) DeepCopyInto(out *InstanceVolumeClaimVolumeSource)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type LoadBalancerIngress 

type LoadBalancerIngress struct {
	// IP is set for load balancer ingress points that are specified by an IP
	// address.
	// +optional
	IP string `json:"ip,omitempty"`

	// Hostname is set for load balancer ingress points that are specified by a
	// DNS address.
	// +optional
	Hostname string `json:"hostname,omitempty"`
}

LoadBalancerIngress represents the status of a load balancer ingress point: traffic intended for the service should be sent to an ingress point. IP or Hostname may both be set in this structure. It is up to the consumer to determine which field should be used when accessing this LoadBalancer.

func (*LoadBalancerIngress) DeepCopy 

func (in *LoadBalancerIngress) DeepCopy() *LoadBalancerIngress

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LoadBalancerIngress.

func (*LoadBalancerIngress) DeepCopyInto 

func (in *LoadBalancerIngress) DeepCopyInto(out *LoadBalancerIngress)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type LoadBalancerStatus 

type LoadBalancerStatus struct {
	// Ingress is a list containing ingress addresses for the load balancer.
	// Traffic intended for the service should be sent to any of these ingress
	// points.
	// +optional
	Ingress []LoadBalancerIngress `json:"ingress,omitempty"`
}

LoadBalancerStatus represents the status of a load balancer.

func (*LoadBalancerStatus) DeepCopy 

func (in *LoadBalancerStatus) DeepCopy() *LoadBalancerStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LoadBalancerStatus.

func (*LoadBalancerStatus) DeepCopyInto 

func (in *LoadBalancerStatus) DeepCopyInto(out *LoadBalancerStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type NetworkDeviceStatus 

type NetworkDeviceStatus struct {
	// Gateway4 is the gateway for the IPv4 address family for this device.
	// +optional
	Gateway4 string

	// MacAddress is the MAC address of the network device.
	// +optional
	MacAddress string

	// IpAddresses represents one or more IP addresses assigned to the network
	// device in CIDR notation, ex. "192.0.2.1/16".
	// +optional
	IPAddresses []string
}

NetworkDeviceStatus defines the network interface IP configuration including gateway, subnet mask and IP address as seen by OVF properties.

func (*NetworkDeviceStatus) DeepCopy 

func (in *NetworkDeviceStatus) DeepCopy() *NetworkDeviceStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NetworkDeviceStatus.

func (*NetworkDeviceStatus) DeepCopyInto 

func (in *NetworkDeviceStatus) DeepCopyInto(out *NetworkDeviceStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type NetworkStatus 

type NetworkStatus struct {
	// Devices describe a list of current status information for each
	// network interface that is desired to be attached to the
	// VirtualMachineTemplate.
	// +optional
	Devices []NetworkDeviceStatus

	// Nameservers describe a list of the DNS servers accessible by one of the
	// VM's configured network devices.
	// +optional
	Nameservers []string
}

NetworkStatus describes the observed state of the VM's network configuration.

func (*NetworkStatus) DeepCopy 

func (in *NetworkStatus) DeepCopy() *NetworkStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NetworkStatus.

func (*NetworkStatus) DeepCopyInto 

func (in *NetworkStatus) DeepCopyInto(out *NetworkStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type OVFProperty 

type OVFProperty struct {
	// Key describes the OVF property's key.
	Key string `json:"key"`

	// Type describes the OVF property's type.
	Type string `json:"type"`

	// Default describes the OVF property's default value.
	// +optional
	Default *string `json:"default,omitempty"`
}

OVFProperty describes an OVF property associated with an image. OVF properties may be used in conjunction with the vAppConfig bootstrap provider to customize a VM during its creation.

func (*OVFProperty) DeepCopy 

func (in *OVFProperty) DeepCopy() *OVFProperty

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OVFProperty.

func (*OVFProperty) DeepCopyInto 

func (in *OVFProperty) DeepCopyInto(out *OVFProperty)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type PersistentVolumeClaimVolumeSource 

type PersistentVolumeClaimVolumeSource struct {
	corev1.PersistentVolumeClaimVolumeSource `json:",inline" yaml:",inline"`

	// InstanceVolumeClaim is set if the PVC is backed by instance storage.
	// +optional
	InstanceVolumeClaim *InstanceVolumeClaimVolumeSource `json:"instanceVolumeClaim,omitempty"`
}

PersistentVolumeClaimVolumeSource is a composite for the Kubernetes corev1.PersistentVolumeClaimVolumeSource and instance storage options.

func (*PersistentVolumeClaimVolumeSource) DeepCopy 

func (in *PersistentVolumeClaimVolumeSource) DeepCopy() *PersistentVolumeClaimVolumeSource

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PersistentVolumeClaimVolumeSource.

func (*PersistentVolumeClaimVolumeSource) DeepCopyInto 

func (in *PersistentVolumeClaimVolumeSource) DeepCopyInto(out *PersistentVolumeClaimVolumeSource)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ResourcePoolSpec 

type ResourcePoolSpec struct {
	// Name describes the name of the ResourcePool grouping.
	// +optional
	Name string `json:"name,omitempty"`

	// Reservations describes the guaranteed resources reserved for the
	// ResourcePool.
	// +optional
	Reservations VirtualMachineResourceSpec `json:"reservations,omitempty"`

	// Limits describes the limit to resources available to the ResourcePool.
	// +optional
	Limits VirtualMachineResourceSpec `json:"limits,omitempty"`
}

ResourcePoolSpec defines a Logical Grouping of workloads that share resource policies.

func (*ResourcePoolSpec) DeepCopy 

func (in *ResourcePoolSpec) DeepCopy() *ResourcePoolSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourcePoolSpec.

func (*ResourcePoolSpec) DeepCopyInto 

func (in *ResourcePoolSpec) DeepCopyInto(out *ResourcePoolSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type TCPSocketAction 

type TCPSocketAction struct {
	// Port specifies a number or name of the port to access on the VM.
	// If the format of port is a number, it must be in the range 1 to 65535.
	// If the format of name is a string, it must be an IANA_SVC_NAME.
	Port intstr.IntOrString `json:"port"`

	// Host is an optional host name to connect to. Host defaults to the VM IP.
	// +optional
	Host string `json:"host,omitempty"`
}

TCPSocketAction describes an action based on opening a socket.

func (*TCPSocketAction) DeepCopy 

func (in *TCPSocketAction) DeepCopy() *TCPSocketAction

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TCPSocketAction.

func (*TCPSocketAction) DeepCopyInto 

func (in *TCPSocketAction) DeepCopyInto(out *TCPSocketAction)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VGPUDevice 

type VGPUDevice struct {
	ProfileName string `json:"profileName"`
}

VGPUDevice contains the configuration corresponding to a vGPU device.

func (*VGPUDevice) DeepCopy 

func (in *VGPUDevice) DeepCopy() *VGPUDevice

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VGPUDevice.

func (*VGPUDevice) DeepCopyInto 

func (in *VGPUDevice) DeepCopyInto(out *VGPUDevice)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VSphereClusterModuleStatus 

type VSphereClusterModuleStatus struct {
	GroupName   string `json:"groupName"`
	ModuleUuid  string `json:"moduleUUID"` //nolint:revive,stylecheck
	ClusterMoID string `json:"clusterMoID"`
}

VSphereClusterModuleStatus describes the observed state of a vSphere cluster module.

func (*VSphereClusterModuleStatus) DeepCopy 

func (in *VSphereClusterModuleStatus) DeepCopy() *VSphereClusterModuleStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VSphereClusterModuleStatus.

func (*VSphereClusterModuleStatus) DeepCopyInto 

func (in *VSphereClusterModuleStatus) DeepCopyInto(out *VSphereClusterModuleStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualDevices 

type VirtualDevices struct {
	// +optional
	// +listType=map
	// +listMapKey=profileName
	VGPUDevices []VGPUDevice `json:"vgpuDevices,omitempty"`

	// +optional
	DynamicDirectPathIODevices []DynamicDirectPathIODevice `json:"dynamicDirectPathIODevices,omitempty"`
}

VirtualDevices contains information about the virtual devices associated with a VirtualMachineClass.

func (*VirtualDevices) DeepCopy 

func (in *VirtualDevices) DeepCopy() *VirtualDevices

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualDevices.

func (*VirtualDevices) DeepCopyInto 

func (in *VirtualDevices) DeepCopyInto(out *VirtualDevices)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachine 

type VirtualMachine struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   VirtualMachineSpec   `json:"spec,omitempty"`
	Status VirtualMachineStatus `json:"status,omitempty"`
}

VirtualMachine is the schema for the virtualmachines API and represents the desired state and observed status of a virtualmachines resource.

func (*VirtualMachine) DeepCopy 

func (in *VirtualMachine) DeepCopy() *VirtualMachine

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachine.

func (*VirtualMachine) DeepCopyInto 

func (in *VirtualMachine) DeepCopyInto(out *VirtualMachine)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*VirtualMachine) DeepCopyObject 

func (in *VirtualMachine) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*VirtualMachine) GetConditions added in v1.8.5 

func (vm *VirtualMachine) GetConditions() []metav1.Condition

func (*VirtualMachine) Hub 

func (*VirtualMachine) Hub()

Hub marks VirtualMachine as a conversion hub.

func (*VirtualMachine) NamespacedName 

func (vm *VirtualMachine) NamespacedName() string

func (*VirtualMachine) SetConditions added in v1.8.5 

func (vm *VirtualMachine) SetConditions(conditions []metav1.Condition)

func (*VirtualMachine) SetupWebhookWithManager 

func (r *VirtualMachine) SetupWebhookWithManager(mgr ctrl.Manager) error

type VirtualMachineAdvancedSpec 

type VirtualMachineAdvancedSpec struct {
	// BootDiskCapacity is the capacity of the VM's boot disk -- the first disk
	// from the VirtualMachineImage from which the VM was deployed.
	//
	// Please note it is not advised to change this value while the VM is
	// running. Also, resizing the VM's boot disk may require actions inside of
	// the guest to take advantage of the additional capacity. Finally, changing
	// the size of the VM's boot disk, even increasing it, could adversely
	// affect the VM.
	//
	// +optional
	BootDiskCapacity *resource.Quantity `json:"bootDiskCapacity,omitempty"`

	// DefaultVolumeProvisioningMode specifies the default provisioning mode for
	// persistent volumes managed by this VM.
	//
	// +optional
	DefaultVolumeProvisioningMode VirtualMachineVolumeProvisioningMode `json:"defaultVolumeProvisioningMode,omitempty"`

	// ChangeBlockTracking is a flag that enables incremental backup support
	// for this VM, a feature utilized by external backup systems such as
	// VMware Data Recovery.
	//
	// +optional
	ChangeBlockTracking bool `json:"changeBlockTracking,omitempty"`
}

VirtualMachineAdvancedSpec describes a set of optional, advanced VM configuration options.

func (*VirtualMachineAdvancedSpec) DeepCopy 

func (in *VirtualMachineAdvancedSpec) DeepCopy() *VirtualMachineAdvancedSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineAdvancedSpec.

func (*VirtualMachineAdvancedSpec) DeepCopyInto 

func (in *VirtualMachineAdvancedSpec) DeepCopyInto(out *VirtualMachineAdvancedSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineBootstrapCloudInitSpec 

type VirtualMachineBootstrapCloudInitSpec struct {
	// CloudConfig describes a subset of a Cloud-Init CloudConfig, used to
	// bootstrap the VM.
	//
	// Please note this field and RawCloudConfig are mutually exclusive.
	//
	// +optional
	CloudConfig *cloudinit.CloudConfig `json:"cloudConfig,omitempty"`

	// RawCloudConfig describes a key in a Secret resource that contains the
	// CloudConfig data used to bootstrap the VM.
	//
	// The CloudConfig data specified by the key may be plain-text,
	// base64-encoded, or gzipped and base64-encoded.
	//
	// Please note this field and CloudConfig are mutually exclusive.
	//
	// +optional
	RawCloudConfig *common.SecretKeySelector `json:"rawCloudConfig,omitempty"`

	// SSHAuthorizedKeys is a list of public keys that CloudInit will apply to
	// the guest's default user.
	//
	// +optional
	SSHAuthorizedKeys []string `json:"sshAuthorizedKeys,omitempty"`
}

VirtualMachineBootstrapCloudInitSpec describes the CloudInit configuration used to bootstrap the VM.

func (*VirtualMachineBootstrapCloudInitSpec) DeepCopy 

func (in *VirtualMachineBootstrapCloudInitSpec) DeepCopy() *VirtualMachineBootstrapCloudInitSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineBootstrapCloudInitSpec.

func (*VirtualMachineBootstrapCloudInitSpec) DeepCopyInto 

func (in *VirtualMachineBootstrapCloudInitSpec) DeepCopyInto(out *VirtualMachineBootstrapCloudInitSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineBootstrapLinuxPrepSpec 

type VirtualMachineBootstrapLinuxPrepSpec struct {
	// HardwareClockIsUTC specifies whether the hardware clock is in UTC or
	// local time.
	//
	// +optional
	HardwareClockIsUTC bool `json:"hardwareClockIsUTC,omitempty"`

	// TimeZone is a case-sensitive timezone, such as Europe/Sofia.
	//
	// Valid values are based on the tz (timezone) database used by Linux and
	// other Unix systems. The values are strings in the form of
	// "Area/Location," in which Area is a continent or ocean name, and
	// Location is the city, island, or other regional designation.
	//
	// Please see https://kb.vmware.com/s/article/2145518 for a list of valid
	// time zones for Linux systems.
	//
	// +optional
	TimeZone string `json:"timeZone,omitempty"`
}

VirtualMachineBootstrapLinuxPrepSpec describes the LinuxPrep configuration used to bootstrap the VM.

func (*VirtualMachineBootstrapLinuxPrepSpec) DeepCopy 

func (in *VirtualMachineBootstrapLinuxPrepSpec) DeepCopy() *VirtualMachineBootstrapLinuxPrepSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineBootstrapLinuxPrepSpec.

func (*VirtualMachineBootstrapLinuxPrepSpec) DeepCopyInto 

func (in *VirtualMachineBootstrapLinuxPrepSpec) DeepCopyInto(out *VirtualMachineBootstrapLinuxPrepSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineBootstrapSpec 

type VirtualMachineBootstrapSpec struct {

	// CloudInit may be used to bootstrap Linux guests with Cloud-Init or
	// Windows guests that support Cloudbase-Init.
	//
	// The guest's networking stack is configured by Cloud-Init on Linux guests
	// and Cloudbase-Init on Windows guests.
	//
	// Please note this bootstrap provider may not be used in conjunction with
	// the other bootstrap providers.
	//
	// +optional
	CloudInit *VirtualMachineBootstrapCloudInitSpec `json:"cloudInit,omitempty"`

	// LinuxPrep may be used to bootstrap Linux guests.
	//
	// The guest's networking stack is configured by Guest OS Customization
	// (GOSC).
	//
	// Please note this bootstrap provider may be used in conjunction with the
	// VAppConfig bootstrap provider when wanting to configure the guest's
	// network with GOSC but also send vApp/OVF properties into the guest.
	//
	// This bootstrap provider may not be used in conjunction with the CloudInit
	// or Sysprep bootstrap providers.
	//
	// +optional
	LinuxPrep *VirtualMachineBootstrapLinuxPrepSpec `json:"linuxPrep,omitempty"`

	// Sysprep may be used to bootstrap Windows guests.
	//
	// The guest's networking stack is configured by Guest OS Customization
	// (GOSC).
	//
	// Please note this bootstrap provider may be used in conjunction with the
	// VAppConfig bootstrap provider when wanting to configure the guest's
	// network with GOSC but also send vApp/OVF properties into the guest.
	//
	// This bootstrap provider may not be used in conjunction with the CloudInit
	// or LinuxPrep bootstrap providers.
	//
	// +optional
	Sysprep *VirtualMachineBootstrapSysprepSpec `json:"sysprep,omitempty"`

	// VAppConfig may be used to bootstrap guests that rely on vApp properties
	// (how VMware surfaces OVF properties on guests) to transport data into the
	// guest.
	//
	// The guest's networking stack may be configured using either vApp
	// properties or GOSC.
	//
	// Many OVFs define one or more properties that are used by the guest to
	// bootstrap its networking stack. If the VirtualMachineImage defines one or
	// more properties like this, then they can be configured to use the network
	// data provided for this VM at runtime by setting these properties to Go
	// template strings.
	//
	// It is also possible to use GOSC to bootstrap this VM's network stack by
	// configuring either the LinuxPrep or Sysprep bootstrap providers.
	//
	// Please note the VAppConfig bootstrap provider in conjunction with the
	// LinuxPrep bootstrap provider is the equivalent of setting the v1alpha1
	// VM metadata transport to "OvfEnv".
	//
	// This bootstrap provider may not be used in conjunction with the CloudInit
	// bootstrap provider.
	//
	// +optional
	VAppConfig *VirtualMachineBootstrapVAppConfigSpec `json:"vAppConfig,omitempty"`
}

VirtualMachineBootstrapSpec defines the desired state of a VM's bootstrap configuration.

func (*VirtualMachineBootstrapSpec) DeepCopy 

func (in *VirtualMachineBootstrapSpec) DeepCopy() *VirtualMachineBootstrapSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineBootstrapSpec.

func (*VirtualMachineBootstrapSpec) DeepCopyInto 

func (in *VirtualMachineBootstrapSpec) DeepCopyInto(out *VirtualMachineBootstrapSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineBootstrapSysprepSpec 

type VirtualMachineBootstrapSysprepSpec struct {
	// Sysprep is an object representation of a Windows sysprep.xml answer file.
	//
	// This field encloses all the individual keys listed in a sysprep.xml file.
	//
	// For more detailed information please see
	// https://technet.microsoft.com/en-us/library/cc771830(v=ws.10).aspx.
	//
	// Please note this field and RawSysprep are mutually exclusive.
	//
	// +optional
	Sysprep *sysprep.Sysprep `json:"sysprep,omitempty"`

	// RawSysprep describes a key in a Secret resource that contains an XML
	// string of the Sysprep text used to bootstrap the VM.
	//
	// The data specified by the Secret key may be plain-text, base64-encoded,
	// or gzipped and base64-encoded.
	//
	// Please note this field and Sysprep are mutually exclusive.
	//
	// +optional
	RawSysprep *common.SecretKeySelector `json:"rawSysprep,omitempty"`
}

VirtualMachineBootstrapSysprepSpec describes the Sysprep configuration used to bootstrap the VM.

func (*VirtualMachineBootstrapSysprepSpec) DeepCopy 

func (in *VirtualMachineBootstrapSysprepSpec) DeepCopy() *VirtualMachineBootstrapSysprepSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineBootstrapSysprepSpec.

func (*VirtualMachineBootstrapSysprepSpec) DeepCopyInto 

func (in *VirtualMachineBootstrapSysprepSpec) DeepCopyInto(out *VirtualMachineBootstrapSysprepSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineBootstrapVAppConfigSpec 

type VirtualMachineBootstrapVAppConfigSpec struct {
	// Properties is a list of vApp/OVF property key/value pairs.
	//
	// Please note this field and RawProperties are mutually exclusive.
	//
	// +optional
	// +listType=map
	// +listMapKey=key
	Properties []common.KeyValueOrSecretKeySelectorPair `json:"properties,omitempty"`

	// RawProperties is the name of a Secret resource in the same Namespace as
	// this VM where each key/value pair from the Secret is used as a vApp
	// key/value pair.
	//
	// Please note this field and Properties are mutually exclusive.
	//
	// +optional
	RawProperties string `json:"rawProperties,omitempty"`
}

VirtualMachineBootstrapVAppConfigSpec describes the vApp configuration used to bootstrap the VM.

func (*VirtualMachineBootstrapVAppConfigSpec) DeepCopy 

func (in *VirtualMachineBootstrapVAppConfigSpec) DeepCopy() *VirtualMachineBootstrapVAppConfigSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineBootstrapVAppConfigSpec.

func (*VirtualMachineBootstrapVAppConfigSpec) DeepCopyInto 

func (in *VirtualMachineBootstrapVAppConfigSpec) DeepCopyInto(out *VirtualMachineBootstrapVAppConfigSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineClass 

type VirtualMachineClass struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   VirtualMachineClassSpec   `json:"spec,omitempty"`
	Status VirtualMachineClassStatus `json:"status,omitempty"`
}

VirtualMachineClass is the schema for the virtualmachineclasses API and represents the desired state and observed status of a virtualmachineclasses resource.

func (*VirtualMachineClass) DeepCopy 

func (in *VirtualMachineClass) DeepCopy() *VirtualMachineClass

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineClass.

func (*VirtualMachineClass) DeepCopyInto 

func (in *VirtualMachineClass) DeepCopyInto(out *VirtualMachineClass)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*VirtualMachineClass) DeepCopyObject 

func (in *VirtualMachineClass) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*VirtualMachineClass) Hub 

func (*VirtualMachineClass) Hub()

Hub marks VirtualMachineClass as a conversion hub.

func (*VirtualMachineClass) SetupWebhookWithManager 

func (r *VirtualMachineClass) SetupWebhookWithManager(mgr ctrl.Manager) error

type VirtualMachineClassHardware 

type VirtualMachineClassHardware struct {
	// +optional
	Cpus int64 `json:"cpus,omitempty"`

	// +optional
	Memory resource.Quantity `json:"memory,omitempty"`

	// +optional
	Devices VirtualDevices `json:"devices,omitempty"`

	// +optional
	InstanceStorage InstanceStorage `json:"instanceStorage,omitempty"`
}

VirtualMachineClassHardware describes a virtual hardware resource specification.

func (*VirtualMachineClassHardware) DeepCopy 

func (in *VirtualMachineClassHardware) DeepCopy() *VirtualMachineClassHardware

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineClassHardware.

func (*VirtualMachineClassHardware) DeepCopyInto 

func (in *VirtualMachineClassHardware) DeepCopyInto(out *VirtualMachineClassHardware)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineClassList 

type VirtualMachineClassList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []VirtualMachineClass `json:"items"`
}

VirtualMachineClassList contains a list of VirtualMachineClass.

func (*VirtualMachineClassList) DeepCopy 

func (in *VirtualMachineClassList) DeepCopy() *VirtualMachineClassList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineClassList.

func (*VirtualMachineClassList) DeepCopyInto 

func (in *VirtualMachineClassList) DeepCopyInto(out *VirtualMachineClassList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*VirtualMachineClassList) DeepCopyObject 

func (in *VirtualMachineClassList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*VirtualMachineClassList) Hub 

func (*VirtualMachineClassList) Hub()

Hub marks VirtualMachineClassList as a conversion hub.

type VirtualMachineClassPolicies 

type VirtualMachineClassPolicies struct {
	Resources VirtualMachineClassResources `json:"resources,omitempty"`
}

VirtualMachineClassPolicies describes the policy configuration to be used by a VirtualMachineClass.

func (*VirtualMachineClassPolicies) DeepCopy 

func (in *VirtualMachineClassPolicies) DeepCopy() *VirtualMachineClassPolicies

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineClassPolicies.

func (*VirtualMachineClassPolicies) DeepCopyInto 

func (in *VirtualMachineClassPolicies) DeepCopyInto(out *VirtualMachineClassPolicies)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineClassResources 

type VirtualMachineClassResources struct {
	// +optional
	Requests VirtualMachineResourceSpec `json:"requests,omitempty"`

	// +optional
	Limits VirtualMachineResourceSpec `json:"limits,omitempty"`
}

VirtualMachineClassResources describes the virtual hardware resource reservations and limits configuration to be used by a VirtualMachineClass.

func (*VirtualMachineClassResources) DeepCopy 

func (in *VirtualMachineClassResources) DeepCopy() *VirtualMachineClassResources

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineClassResources.

func (*VirtualMachineClassResources) DeepCopyInto 

func (in *VirtualMachineClassResources) DeepCopyInto(out *VirtualMachineClassResources)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineClassSpec 

type VirtualMachineClassSpec struct {
	// ControllerName describes the name of the controller responsible for
	// reconciling VirtualMachine resources that are realized from this
	// VirtualMachineClass.
	//
	// When omitted, controllers reconciling VirtualMachine resources determine
	// the default controller name from the environment variable
	// DEFAULT_VM_CLASS_CONTROLLER_NAME. If this environment variable is not
	// defined or empty, it defaults to vmoperator.vmware.com/vsphere.
	//
	// Once a non-empty value is assigned to this field, attempts to set this
	// field to an empty value will be silently ignored.
	//
	// +optional
	ControllerName string `json:"controllerName,omitempty"`

	// Hardware describes the configuration of the VirtualMachineClass
	// attributes related to virtual hardware. The configuration specified in
	// this field is used to customize the virtual hardware characteristics of
	// any VirtualMachine associated with this VirtualMachineClass.
	//
	// +optional
	Hardware VirtualMachineClassHardware `json:"hardware,omitempty"`

	// Policies describes the configuration of the VirtualMachineClass
	// attributes related to virtual infrastructure policy. The configuration
	// specified in this field is used to customize various policies related to
	// infrastructure resource consumption.
	//
	// +optional
	Policies VirtualMachineClassPolicies `json:"policies,omitempty"`

	// Description describes the configuration of the VirtualMachineClass which
	// is not related to virtual hardware or infrastructure policy. This field
	// is used to address remaining specs about this VirtualMachineClass.
	//
	// +optional
	Description string `json:"description,omitempty"`

	// ConfigSpec describes additional configuration information for a
	// VirtualMachine.
	// The contents of this field are the VirtualMachineConfigSpec data object
	// (https://bit.ly/3HDtiRu) marshaled to JSON using the discriminator
	// field "_typeName" to preserve type information.
	//
	// +optional
	// +kubebuilder:validation:Schemaless
	// +kubebuilder:validation:Type=object
	// +kubebuilder:pruning:PreserveUnknownFields
	ConfigSpec json.RawMessage `json:"configSpec,omitempty"`
}

VirtualMachineClassSpec defines the desired state of VirtualMachineClass.

func (*VirtualMachineClassSpec) DeepCopy 

func (in *VirtualMachineClassSpec) DeepCopy() *VirtualMachineClassSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineClassSpec.

func (*VirtualMachineClassSpec) DeepCopyInto 

func (in *VirtualMachineClassSpec) DeepCopyInto(out *VirtualMachineClassSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineClassStatus 

type VirtualMachineClassStatus struct {
}

VirtualMachineClassStatus defines the observed state of VirtualMachineClass.

func (*VirtualMachineClassStatus) DeepCopy 

func (in *VirtualMachineClassStatus) DeepCopy() *VirtualMachineClassStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineClassStatus.

func (*VirtualMachineClassStatus) DeepCopyInto 

func (in *VirtualMachineClassStatus) DeepCopyInto(out *VirtualMachineClassStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineConfigSpec 

type VirtualMachineConfigSpec struct {
	// XML contains a vim.vm.ConfigSpec object that has been serialized to XML
	// and base64-encoded.
	//
	// +optional
	XML string `json:"xml,omitempty"`
}

VirtualMachineConfigSpec contains additional virtual machine configuration settings including hardware specifications for the VirtualMachine.

We only support XML for now, but that may change in the future.

func (*VirtualMachineConfigSpec) DeepCopy 

func (in *VirtualMachineConfigSpec) DeepCopy() *VirtualMachineConfigSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineConfigSpec.

func (*VirtualMachineConfigSpec) DeepCopyInto 

func (in *VirtualMachineConfigSpec) DeepCopyInto(out *VirtualMachineConfigSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineImage 

type VirtualMachineImage struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   VirtualMachineImageSpec   `json:"spec,omitempty"`
	Status VirtualMachineImageStatus `json:"status,omitempty"`
}

VirtualMachineImage is the schema for the virtualmachineimages API.

func (*VirtualMachineImage) DeepCopy 

func (in *VirtualMachineImage) DeepCopy() *VirtualMachineImage

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineImage.

func (*VirtualMachineImage) DeepCopyInto 

func (in *VirtualMachineImage) DeepCopyInto(out *VirtualMachineImage)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*VirtualMachineImage) DeepCopyObject 

func (in *VirtualMachineImage) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*VirtualMachineImage) GetConditions added in v1.8.5 

func (i *VirtualMachineImage) GetConditions() []metav1.Condition

func (*VirtualMachineImage) Hub 

func (*VirtualMachineImage) Hub()

Hub marks VirtualMachineImage as a conversion hub.

func (*VirtualMachineImage) SetConditions added in v1.8.5 

func (i *VirtualMachineImage) SetConditions(conditions []metav1.Condition)

func (*VirtualMachineImage) SetupWebhookWithManager 

func (r *VirtualMachineImage) SetupWebhookWithManager(mgr ctrl.Manager) error

type VirtualMachineImageList 

type VirtualMachineImageList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []VirtualMachineImage `json:"items"`
}

VirtualMachineImageList contains a list of VirtualMachineImage.

func (*VirtualMachineImageList) DeepCopy 

func (in *VirtualMachineImageList) DeepCopy() *VirtualMachineImageList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineImageList.

func (*VirtualMachineImageList) DeepCopyInto 

func (in *VirtualMachineImageList) DeepCopyInto(out *VirtualMachineImageList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*VirtualMachineImageList) DeepCopyObject 

func (in *VirtualMachineImageList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*VirtualMachineImageList) Hub 

func (*VirtualMachineImageList) Hub()

Hub marks VirtualMachineImageList as a conversion hub.

type VirtualMachineImageOSInfo 

type VirtualMachineImageOSInfo struct {
	// ID describes the operating system ID.
	//
	// This value is also added to the image resource's labels as
	// VirtualMachineImageOSIDLabel.
	//
	// +optional
	ID string `json:"id,omitempty"`

	// Type describes the operating system type.
	//
	// This value is also added to the image resource's labels as
	// VirtualMachineImageOSTypeLabel.
	//
	// +optional
	Type string `json:"type,omitempty"`

	// Version describes the operating system version.
	//
	// This value is also added to the image resource's labels as
	// VirtualMachineImageOSVersionLabel.
	//
	// +optional
	Version string `json:"version,omitempty"`
}

VirtualMachineImageOSInfo describes the image's guest operating system.

func (*VirtualMachineImageOSInfo) DeepCopy 

func (in *VirtualMachineImageOSInfo) DeepCopy() *VirtualMachineImageOSInfo

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineImageOSInfo.

func (*VirtualMachineImageOSInfo) DeepCopyInto 

func (in *VirtualMachineImageOSInfo) DeepCopyInto(out *VirtualMachineImageOSInfo)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineImageProductInfo 

type VirtualMachineImageProductInfo struct {
	// Product is a general descriptor for the image.
	// +optional
	Product string `json:"product,omitempty"`

	// Vendor describes the organization/user that produced the image.
	// +optional
	Vendor string `json:"vendor,omitempty"`

	// Version describes the short-form version of the image.
	// +optional
	Version string `json:"version,omitempty"`

	// FullVersion describes the long-form version of the image.
	// +optional
	FullVersion string `json:"fullVersion,omitempty"`
}

VirtualMachineImageProductInfo describes product information for an image.

func (*VirtualMachineImageProductInfo) DeepCopy 

func (in *VirtualMachineImageProductInfo) DeepCopy() *VirtualMachineImageProductInfo

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineImageProductInfo.

func (*VirtualMachineImageProductInfo) DeepCopyInto 

func (in *VirtualMachineImageProductInfo) DeepCopyInto(out *VirtualMachineImageProductInfo)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineImageSpec 

type VirtualMachineImageSpec struct {
	// ProviderRef is a reference to the resource that contains the source of
	// this image's information.
	//
	// +optional
	ProviderRef common.LocalObjectRef `json:"providerRef,omitempty"`
}

VirtualMachineImageSpec defines the desired state of VirtualMachineImage.

func (*VirtualMachineImageSpec) DeepCopy 

func (in *VirtualMachineImageSpec) DeepCopy() *VirtualMachineImageSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineImageSpec.

func (*VirtualMachineImageSpec) DeepCopyInto 

func (in *VirtualMachineImageSpec) DeepCopyInto(out *VirtualMachineImageSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineImageStatus 

type VirtualMachineImageStatus struct {

	// Name describes the display name of this image.
	//
	// +optional
	Name string `json:"name,omitempty"`

	// Capabilities describes the image's observed capabilities.
	//
	// The capabilities are discerned when VM Operator reconciles an image.
	// If the source of an image is an OVF in Content Library, then the
	// capabilities are parsed from the OVF property
	// capabilities.image.vmoperator.vmware.com as a comma-separated list of
	// values. Well-known capabilities include:
	//
	// * cloud-init
	// * nvidia-gpu
	// * sriov-net
	//
	// Every capability is also added to the resource's labels as
	// VirtualMachineImageCapabilityLabel + Value. For example, if the
	// capability is "cloud-init" then the following label will be added to the
	// resource: capability.image.vmoperator.vmware.com/cloud-init.
	//
	// +optional
	// +listType=set
	Capabilities []string `json:"capabilities,omitempty"`

	// Firmware describe the firmware type used by this image, ex. BIOS, EFI.
	// +optional
	Firmware string `json:"firmware,omitempty"`

	// HardwareVersion describes the observed hardware version of this image.
	//
	// +optional
	HardwareVersion *int32 `json:"hardwareVersion,omitempty"`

	// OSInfo describes the observed operating system information for this
	// image.
	//
	// The OS information is also added to the image resource's labels. Please
	// refer to VirtualMachineImageOSInfo for more information.
	//
	//
	// +optional
	OSInfo VirtualMachineImageOSInfo `json:"osInfo,omitempty"`

	// OVFProperties describes the observed user configurable OVF properties defined for this
	// image.
	//
	// +optional
	OVFProperties []OVFProperty `json:"ovfProperties,omitempty"`

	// VMwareSystemProperties describes the observed VMware system properties defined for
	// this image.
	//
	// +optional
	VMwareSystemProperties []common.KeyValuePair `json:"vmwareSystemProperties,omitempty"`

	// ProductInfo describes the observed product information for this image.
	// +optional
	ProductInfo VirtualMachineImageProductInfo `json:"productInfo,omitempty"`

	// ProviderContentVersion describes the content version from the provider item
	// that this image corresponds to. If the provider of this image is a Content
	// Library, this will be the version of the corresponding Content Library item.
	// +optional
	ProviderContentVersion string `json:"providerContentVersion,omitempty"`

	// ProviderItemID describes the ID of the provider item that this image corresponds to.
	// If the provider of this image is a Content Library, this ID will be that of the
	// corresponding Content Library item.
	// +optional
	ProviderItemID string `json:"providerItemID,omitempty"`

	// Conditions describes the observed conditions for this image.
	//
	// +optional
	// +listType=map
	// +listMapKey=type
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

VirtualMachineImageStatus defines the observed state of VirtualMachineImage.

func (*VirtualMachineImageStatus) DeepCopy 

func (in *VirtualMachineImageStatus) DeepCopy() *VirtualMachineImageStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineImageStatus.

func (*VirtualMachineImageStatus) DeepCopyInto 

func (in *VirtualMachineImageStatus) DeepCopyInto(out *VirtualMachineImageStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineList 

type VirtualMachineList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []VirtualMachine `json:"items"`
}

VirtualMachineList contains a list of VirtualMachine.

func (*VirtualMachineList) DeepCopy 

func (in *VirtualMachineList) DeepCopy() *VirtualMachineList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineList.

func (*VirtualMachineList) DeepCopyInto 

func (in *VirtualMachineList) DeepCopyInto(out *VirtualMachineList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*VirtualMachineList) DeepCopyObject 

func (in *VirtualMachineList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*VirtualMachineList) Hub 

func (*VirtualMachineList) Hub()

Hub marks VirtualMachineList as a conversion hub.

type VirtualMachineNetworkConfigDHCPOptionsStatus added in v1.8.6 

type VirtualMachineNetworkConfigDHCPOptionsStatus struct {
	// Enabled describes whether DHCP is enabled.
	// +omitempty
	Enabled bool `json:"enabled,omitempty"`
}

VirtualMachineNetworkConfigDHCPOptionsStatus describes the configured DHCP options.

func (*VirtualMachineNetworkConfigDHCPOptionsStatus) DeepCopy added in v1.8.6 

func (in *VirtualMachineNetworkConfigDHCPOptionsStatus) DeepCopy() *VirtualMachineNetworkConfigDHCPOptionsStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineNetworkConfigDHCPOptionsStatus.

func (*VirtualMachineNetworkConfigDHCPOptionsStatus) DeepCopyInto added in v1.8.6 

func (in *VirtualMachineNetworkConfigDHCPOptionsStatus) DeepCopyInto(out *VirtualMachineNetworkConfigDHCPOptionsStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineNetworkConfigDHCPStatus added in v1.8.6 

type VirtualMachineNetworkConfigDHCPStatus struct {

	// IP4 describes the configured state of the IP4 DHCP settings.
	//
	// +optional
	IP4 *VirtualMachineNetworkConfigDHCPOptionsStatus `json:"ip4,omitempty"`

	// IP6 describes the configured state of the IP6 DHCP settings.
	//
	// +optional
	IP6 *VirtualMachineNetworkConfigDHCPOptionsStatus `json:"ip6,omitempty"`
}

VirtualMachineNetworkConfigDHCPStatus describes the configured state of the system-wide DHCP settings for IP4 and IP6.

func (*VirtualMachineNetworkConfigDHCPStatus) DeepCopy added in v1.8.6 

func (in *VirtualMachineNetworkConfigDHCPStatus) DeepCopy() *VirtualMachineNetworkConfigDHCPStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineNetworkConfigDHCPStatus.

func (*VirtualMachineNetworkConfigDHCPStatus) DeepCopyInto added in v1.8.6 

func (in *VirtualMachineNetworkConfigDHCPStatus) DeepCopyInto(out *VirtualMachineNetworkConfigDHCPStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineNetworkConfigDNSStatus added in v1.8.6 

type VirtualMachineNetworkConfigDNSStatus struct {
	// HostName is the host name portion of the DNS name. For example,
	// the "my-vm" part of "my-vm.domain.local".
	//
	// +optional
	HostName string `json:"hostName,omitempty"`

	// Nameservers is a list of the IP addresses for the DNS servers to use.
	//
	// IP4 addresses are specified using dotted decimal notation. For example,
	// "192.0.2.1".
	//
	// IP6 addresses are 128-bit addresses represented as eight fields of up to
	// four hexadecimal digits. A colon separates each field (:). For example,
	// 2001:DB8:101::230:6eff:fe04:d9ff. The address can also consist of the
	// symbol '::' to represent multiple 16-bit groups of contiguous 0's only
	// once in an address as described in RFC 2373.
	//
	// +optional
	Nameservers []string `json:"nameservers,omitempty"`

	// SearchDomains is a list of domains in which to search for hosts, in the
	// order of preference.
	//
	// +optional
	SearchDomains []string `json:"searchDomains,omitempty"`
}

VirtualMachineNetworkConfigDNSStatus describes the configured state of the RFC 1034 client-side DNS settings.

func (*VirtualMachineNetworkConfigDNSStatus) DeepCopy added in v1.8.6 

func (in *VirtualMachineNetworkConfigDNSStatus) DeepCopy() *VirtualMachineNetworkConfigDNSStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineNetworkConfigDNSStatus.

func (*VirtualMachineNetworkConfigDNSStatus) DeepCopyInto added in v1.8.6 

func (in *VirtualMachineNetworkConfigDNSStatus) DeepCopyInto(out *VirtualMachineNetworkConfigDNSStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineNetworkConfigInterfaceIPStatus added in v1.8.6 

type VirtualMachineNetworkConfigInterfaceIPStatus struct {
	// DHCP describes the interface's configured DHCP options.
	//
	// +optional
	DHCP *VirtualMachineNetworkConfigDHCPStatus `json:"dhcp,omitempty"`

	// Addresses describes configured IP addresses for this interface.
	// Addresses include the network's prefix length, ex. 192.168.0.0/24 or
	// 2001:DB8:101::230:6eff:fe04:d9ff::/64.
	//
	// +optional
	Addresses []string `json:"addresses,omitempty"`

	// Gateway4 describes the interface's configured, default, IP4 gateway.
	//
	// Please note the IP address include the network prefix length, ex.
	// 192.168.0.1/24.
	//
	// +optional
	Gateway4 string `json:"gateway4,omitempty"`

	// Gateway6 describes the interface's configured, default, IP6 gateway.
	//
	// Please note the IP address includes the network prefix length, ex.
	// 2001:db8:101::1/64.
	//
	// +optional
	Gateway6 string `json:"gateway6,omitempty"`
}

VirtualMachineNetworkConfigInterfaceIPStatus describes the configured state of a VM's network interface's IP configuration.

func (*VirtualMachineNetworkConfigInterfaceIPStatus) DeepCopy added in v1.8.6 

func (in *VirtualMachineNetworkConfigInterfaceIPStatus) DeepCopy() *VirtualMachineNetworkConfigInterfaceIPStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineNetworkConfigInterfaceIPStatus.

func (*VirtualMachineNetworkConfigInterfaceIPStatus) DeepCopyInto added in v1.8.6 

func (in *VirtualMachineNetworkConfigInterfaceIPStatus) DeepCopyInto(out *VirtualMachineNetworkConfigInterfaceIPStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineNetworkConfigInterfaceStatus added in v1.8.6 

type VirtualMachineNetworkConfigInterfaceStatus struct {
	// Name describes the corresponding network interface with the same name
	// in the VM's desired network interface list.
	//
	// Please note this name is not necessarily related to the name of the
	// device as it is surfaced inside of the guest.
	Name string `json:"name"`

	// IP describes the interface's configured IP information.
	//
	// +optional
	IP *VirtualMachineNetworkConfigInterfaceIPStatus `json:"ip,omitempty"`

	// DNS describes the interface's configured DNS information.
	//
	// +optional
	DNS *VirtualMachineNetworkConfigDNSStatus `json:"dns,omitempty"`
}

VirtualMachineNetworkConfigInterfaceStatus describes the configured state of network interface.

func (*VirtualMachineNetworkConfigInterfaceStatus) DeepCopy added in v1.8.6 

func (in *VirtualMachineNetworkConfigInterfaceStatus) DeepCopy() *VirtualMachineNetworkConfigInterfaceStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineNetworkConfigInterfaceStatus.

func (*VirtualMachineNetworkConfigInterfaceStatus) DeepCopyInto added in v1.8.6 

func (in *VirtualMachineNetworkConfigInterfaceStatus) DeepCopyInto(out *VirtualMachineNetworkConfigInterfaceStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineNetworkConfigStatus added in v1.8.6 

type VirtualMachineNetworkConfigStatus struct {
	// Interfaces describes the configured state of the network interfaces.
	//
	// +optional
	Interfaces []VirtualMachineNetworkConfigInterfaceStatus `json:"interfaces,omitempty"`

	// DNS describes the configured state of client-side DNS.
	//
	// +optional
	DNS *VirtualMachineNetworkConfigDNSStatus `json:"dns,omitempty"`
}

func (*VirtualMachineNetworkConfigStatus) DeepCopy added in v1.8.6 

func (in *VirtualMachineNetworkConfigStatus) DeepCopy() *VirtualMachineNetworkConfigStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineNetworkConfigStatus.

func (*VirtualMachineNetworkConfigStatus) DeepCopyInto added in v1.8.6 

func (in *VirtualMachineNetworkConfigStatus) DeepCopyInto(out *VirtualMachineNetworkConfigStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineNetworkDHCPOptionsStatus 

type VirtualMachineNetworkDHCPOptionsStatus struct {
	// Config describes platform-dependent settings for the DHCP client.
	//
	// The key part is a unique number while the value part is the platform
	// specific configuration command. For example on Linux and BSD systems
	// using the file dhclient.conf output would be reported at system scope:
	// key='1', value='timeout 60;' key='2', value='reboot 10;'. The output
	// reported per interface would be:
	// key='1', value='prepend domain-name-servers 192.0.2.1;'
	// key='2', value='require subnet-mask, domain-name-servers;'.
	//
	// +optional
	// +listType=map
	// +listMapKey=key
	Config []common.KeyValuePair `json:"config,omitempty"`

	// Enabled reports the status of the DHCP client services.
	// +omitempty
	Enabled bool `json:"enabled,omitempty"`
}

VirtualMachineNetworkDHCPOptionsStatus describes the observed state of DHCP options.

func (*VirtualMachineNetworkDHCPOptionsStatus) DeepCopy 

func (in *VirtualMachineNetworkDHCPOptionsStatus) DeepCopy() *VirtualMachineNetworkDHCPOptionsStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineNetworkDHCPOptionsStatus.

func (*VirtualMachineNetworkDHCPOptionsStatus) DeepCopyInto 

func (in *VirtualMachineNetworkDHCPOptionsStatus) DeepCopyInto(out *VirtualMachineNetworkDHCPOptionsStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineNetworkDHCPStatus 

type VirtualMachineNetworkDHCPStatus struct {

	// IP4 describes the observed state of the IP4 DHCP client settings.
	//
	// +optional
	IP4 VirtualMachineNetworkDHCPOptionsStatus `json:"ip4,omitempty"`

	// IP6 describes the observed state of the IP6 DHCP client settings.
	//
	// +optional
	IP6 VirtualMachineNetworkDHCPOptionsStatus `json:"ip6,omitempty"`
}

VirtualMachineNetworkDHCPStatus describes the observed state of the client-side, system-wide DHCP settings for IP4 and IP6.

func (*VirtualMachineNetworkDHCPStatus) DeepCopy 

func (in *VirtualMachineNetworkDHCPStatus) DeepCopy() *VirtualMachineNetworkDHCPStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineNetworkDHCPStatus.

func (*VirtualMachineNetworkDHCPStatus) DeepCopyInto 

func (in *VirtualMachineNetworkDHCPStatus) DeepCopyInto(out *VirtualMachineNetworkDHCPStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineNetworkDNSStatus 

type VirtualMachineNetworkDNSStatus struct {
	// DHCP indicates whether or not dynamic host control protocol (DHCP) was
	// used to configure DNS configuration.
	//
	// +optional
	DHCP bool `json:"dhcp,omitempty"`

	// DomainName is the domain name portion of the DNS name. For example,
	// the "domain.local" part of "my-vm.domain.local".
	//
	// +optional
	DomainName string `json:"domainName,omitempty"`

	// HostName is the host name portion of the DNS name. For example,
	// the "my-vm" part of "my-vm.domain.local".
	//
	// +optional
	HostName string `json:"hostName,omitempty"`

	// Nameservers is a list of the IP addresses for the DNS servers to use.
	//
	// IP4 addresses are specified using dotted decimal notation. For example,
	// "192.0.2.1".
	//
	// IP6 addresses are 128-bit addresses represented as eight fields of up to
	// four hexadecimal digits. A colon separates each field (:). For example,
	// 2001:DB8:101::230:6eff:fe04:d9ff. The address can also consist of the
	// symbol '::' to represent multiple 16-bit groups of contiguous 0's only
	// once in an address as described in RFC 2373.
	//
	// +optional
	Nameservers []string `json:"nameservers,omitempty"`

	// SearchDomains is a list of domains in which to search for hosts, in the
	// order of preference.
	//
	// +optional
	SearchDomains []string `json:"searchDomains,omitempty"`
}

VirtualMachineNetworkDNSStatus describes the observed state of the guest's RFC 1034 client-side DNS settings.

func (*VirtualMachineNetworkDNSStatus) DeepCopy 

func (in *VirtualMachineNetworkDNSStatus) DeepCopy() *VirtualMachineNetworkDNSStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineNetworkDNSStatus.

func (*VirtualMachineNetworkDNSStatus) DeepCopyInto 

func (in *VirtualMachineNetworkDNSStatus) DeepCopyInto(out *VirtualMachineNetworkDNSStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineNetworkIPRouteGatewayStatus 

type VirtualMachineNetworkIPRouteGatewayStatus struct {
	// Device is the name of the device in the guest for which this gateway
	// applies.
	//
	// +optional
	Device string `json:"device,omitempty"`

	// Address is the IP4 or IP6 address of the gateway.
	//
	// +optional
	Address string `json:"address,omitempty"`
}

VirtualMachineNetworkIPRouteGatewayStatus describes the observed state of a guest network's IP route's next hop gateway.

func (*VirtualMachineNetworkIPRouteGatewayStatus) DeepCopy 

func (in *VirtualMachineNetworkIPRouteGatewayStatus) DeepCopy() *VirtualMachineNetworkIPRouteGatewayStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineNetworkIPRouteGatewayStatus.

func (*VirtualMachineNetworkIPRouteGatewayStatus) DeepCopyInto 

func (in *VirtualMachineNetworkIPRouteGatewayStatus) DeepCopyInto(out *VirtualMachineNetworkIPRouteGatewayStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineNetworkIPRouteStatus 

type VirtualMachineNetworkIPRouteStatus struct {
	// Gateway describes where to send the packets to next.
	Gateway VirtualMachineNetworkIPRouteGatewayStatus `json:"gateway"`

	// NetworkAddress is the IP4 or IP6 address of the destination network.
	//
	// Addresses include the network's prefix length, ex. 192.168.0.0/24 or
	// 2001:DB8:101::230:6eff:fe04:d9ff::/64.
	//
	// IP6 addresses are 128-bit addresses represented as eight fields of up to
	// four hexadecimal digits. A colon separates each field (:). For example,
	// 2001:DB8:101::230:6eff:fe04:d9ff. The address can also consist of symbol
	// '::' to represent multiple 16-bit groups of contiguous 0's only once in
	// an address as described in RFC 2373.
	NetworkAddress string `json:"networkAddress"`
}

VirtualMachineNetworkIPRouteStatus describes the observed state of a guest network's IP routes.

func (*VirtualMachineNetworkIPRouteStatus) DeepCopy 

func (in *VirtualMachineNetworkIPRouteStatus) DeepCopy() *VirtualMachineNetworkIPRouteStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineNetworkIPRouteStatus.

func (*VirtualMachineNetworkIPRouteStatus) DeepCopyInto 

func (in *VirtualMachineNetworkIPRouteStatus) DeepCopyInto(out *VirtualMachineNetworkIPRouteStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineNetworkIPStackStatus 

type VirtualMachineNetworkIPStackStatus struct {
	// DHCP describes the VM's observed, client-side, system-wide DHCP options.
	//
	// +optional
	DHCP *VirtualMachineNetworkDHCPStatus `json:"dhcp,omitempty"`

	// DNS describes the VM's observed, client-side DNS configuration.
	//
	// +optional
	DNS *VirtualMachineNetworkDNSStatus `json:"dns,omitempty"`

	// IPRoutes contain the VM's routing tables for all address families.
	//
	// +optional
	IPRoutes []VirtualMachineNetworkIPRouteStatus `json:"ipRoutes,omitempty"`

	// KernelConfig describes the observed state of the VM's kernel IP
	// configuration settings.
	//
	// The key part contains a unique number while the value part contains the
	// 'key=value' as provided by the underlying provider. For example, on
	// Linux and/or BSD, the systcl -a output would be reported as:
	// key='5', value='net.ipv4.tcp_keepalive_time = 7200'.
	//
	// +optional
	// +listType=map
	// +listMapKey=key
	KernelConfig []common.KeyValuePair `json:"kernelConfig,omitempty"`
}

VirtualMachineNetworkIPStackStatus describes the observed state of a VM's IP stack.

func (*VirtualMachineNetworkIPStackStatus) DeepCopy 

func (in *VirtualMachineNetworkIPStackStatus) DeepCopy() *VirtualMachineNetworkIPStackStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineNetworkIPStackStatus.

func (*VirtualMachineNetworkIPStackStatus) DeepCopyInto 

func (in *VirtualMachineNetworkIPStackStatus) DeepCopyInto(out *VirtualMachineNetworkIPStackStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineNetworkInterfaceIPAddrStatus 

type VirtualMachineNetworkInterfaceIPAddrStatus struct {
	// Address is an IP4 or IP6 address and their network prefix length.
	//
	// An IP4 address is specified using dotted decimal notation. For example,
	// "192.0.2.1".
	//
	// IP6 addresses are 128-bit addresses represented as eight fields of up to
	// four hexadecimal digits. A colon separates each field (:). For example,
	// 2001:DB8:101::230:6eff:fe04:d9ff. The address can also consist of the
	// symbol '::' to represent multiple 16-bit groups of contiguous 0's only
	// once in an address as described in RFC 2373.
	Address string `json:"address"`

	// Lifetime describes when this address will expire.
	//
	// +optional
	Lifetime metav1.Time `json:"lifetime,omitempty"`

	// Origin describes how this address was configured.
	//
	// +optional
	// +kubebuilder:validation:Enum=dhcp;linklayer;manual;other;random
	Origin string `json:"origin,omitempty"`

	// State describes the state of this IP address.
	//
	// +optional
	// +kubebuilder:validation:Enum=deprecated;duplicate;inaccessible;invalid;preferred;tentative;unknown
	State string `json:"state,omitempty"`
}

VirtualMachineNetworkInterfaceIPAddrStatus describes information about a specific IP address.

func (*VirtualMachineNetworkInterfaceIPAddrStatus) DeepCopy 

func (in *VirtualMachineNetworkInterfaceIPAddrStatus) DeepCopy() *VirtualMachineNetworkInterfaceIPAddrStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineNetworkInterfaceIPAddrStatus.

func (*VirtualMachineNetworkInterfaceIPAddrStatus) DeepCopyInto 

func (in *VirtualMachineNetworkInterfaceIPAddrStatus) DeepCopyInto(out *VirtualMachineNetworkInterfaceIPAddrStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineNetworkInterfaceIPStatus 

type VirtualMachineNetworkInterfaceIPStatus struct {
	// AutoConfigurationEnabled describes whether or not ICMPv6 router
	// solicitation requests are enabled or disabled from a given interface.
	//
	// These requests acquire an IP6 address and default gateway route from
	// zero-to-many routers on the connected network.
	//
	// If not set then ICMPv6 is not available on this VM.
	//
	// +optional
	AutoConfigurationEnabled *bool `json:"autoConfigurationEnabled,omitempty"`

	// DHCP describes the VM's observed, client-side, interface-specific DHCP
	// options.
	//
	// +optional
	DHCP *VirtualMachineNetworkDHCPStatus `json:"dhcp,omitempty"`

	// Addresses describes observed IP addresses for this interface.
	//
	// +optional
	Addresses []VirtualMachineNetworkInterfaceIPAddrStatus `json:"addresses,omitempty"`

	// MACAddr describes the observed MAC address for this interface.
	//
	// +optional
	MACAddr string `json:"macAddr,omitempty"`
}

VirtualMachineNetworkInterfaceIPStatus describes the observed state of a VM's network interface's IP configuration.

func (*VirtualMachineNetworkInterfaceIPStatus) DeepCopy 

func (in *VirtualMachineNetworkInterfaceIPStatus) DeepCopy() *VirtualMachineNetworkInterfaceIPStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineNetworkInterfaceIPStatus.

func (*VirtualMachineNetworkInterfaceIPStatus) DeepCopyInto 

func (in *VirtualMachineNetworkInterfaceIPStatus) DeepCopyInto(out *VirtualMachineNetworkInterfaceIPStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineNetworkInterfaceSpec 

type VirtualMachineNetworkInterfaceSpec struct {
	// Name describes the unique name of this network interface, used to
	// distinguish it from other network interfaces attached to this VM.
	//
	// When the bootstrap provider is Cloud-Init and GuestDeviceName is not
	// specified, the device inside the guest will be renamed to this value.
	// Please note it is up to the user to ensure the provided name does not
	// conflict with any other devices inside the guest, ex. dvd, cdrom, sda, etc.
	//
	// +kubebuilder:validation:Pattern="^[a-z0-9]{2,}$"
	Name string `json:"name"`

	// Network is the name of the network resource to which this interface is
	// connected.
	//
	// If no network is provided, then this interface will be connected to the
	// Namespace's default network.
	//
	// +optional
	Network common.PartialObjectRef `json:"network,omitempty"`

	// GuestDeviceName is used to rename the device inside the guest when the
	// bootstrap provider is Cloud-Init. Please note it is up to the user to
	// ensure the provided device name does not conflict with any other devices
	// inside the guest, ex. dvd, cdrom, sda, etc.
	//
	// +optional
	// +kubebuilder:validation:Pattern=^\w\w+$
	GuestDeviceName string `json:"guestDeviceName,omitempty"`

	// Addresses is an optional list of IP4 or IP6 addresses to assign to this
	// interface.
	//
	// Please note this field is only supported if the connected network
	// supports manual IP allocation.
	//
	// Please note IP4 and IP6 addresses must include the network prefix length,
	// ex. 192.168.0.10/24 or 2001:db8:101::a/64.
	//
	// Please note this field may not contain IP4 addresses if DHCP4 is set
	// to true or IP6 addresses if DHCP6 is set to true.
	//
	// Please note if the Interfaces field is non-empty then this field is
	// ignored and should be specified on the elements in the Interfaces list.
	//
	// +optional
	Addresses []string `json:"addresses,omitempty"`

	// DHCP4 indicates whether or not this interface uses DHCP for IP4
	// networking.
	//
	// Please note this field is only supported if the network connection
	// supports DHCP.
	//
	// Please note this field is mutually exclusive with IP4 addresses in the
	// Addresses field and the Gateway4 field.
	//
	// +optional
	DHCP4 bool `json:"dhcp4,omitempty"`

	// DHCP6 indicates whether or not this interface uses DHCP for IP6
	// networking.
	//
	// Please note this field is only supported if the network connection
	// supports DHCP.
	//
	// Please note this field is mutually exclusive with IP6 addresses in the
	// Addresses field and the Gateway6 field.
	//
	// +optional
	DHCP6 bool `json:"dhcp6,omitempty"`

	// Gateway4 is the default, IP4 gateway for this interface.
	//
	// Please note this field is only supported if the network connection
	// supports manual IP allocation.
	//
	// If the network connection supports manual IP allocation and the
	// Addresses field includes at least one IP4 address, then this field
	// is required.
	//
	// Please note the IP address must include the network prefix length, ex.
	// 192.168.0.1/24.
	//
	// Please note this field is mutually exclusive with DHCP4.
	//
	// +optional
	Gateway4 string `json:"gateway4,omitempty"`

	// Gateway6 is the primary IP6 gateway for this interface.
	//
	// Please note this field is only supported if the network connection
	// supports manual IP allocation.
	//
	// If the network connection supports manual IP allocation and the
	// Addresses field includes at least one IP6 address, then this field
	// is required.
	//
	// Please note the IP address must include the network prefix length, ex.
	// 2001:db8:101::1/64.
	//
	// Please note this field is mutually exclusive with DHCP6.
	//
	// +optional
	Gateway6 string `json:"gateway6,omitempty"`

	// MTU is the Maximum Transmission Unit size in bytes.
	//
	// Please note this feature is available only with the following bootstrap
	// providers: CloudInit.
	//
	// +optional
	MTU *int64 `json:"mtu,omitempty"`

	// Nameservers is a list of IP4 and/or IP6 addresses used as DNS
	// nameservers.
	//
	// Please note this feature is available only with the following bootstrap
	// providers: CloudInit and Sysprep.
	//
	// Please note that Linux allows only three nameservers
	// (https://linux.die.net/man/5/resolv.conf).
	//
	// +optional
	Nameservers []string `json:"nameservers,omitempty"`

	// Routes is a list of optional, static routes.
	//
	// Please note this feature is available only with the following bootstrap
	// providers: CloudInit.
	//
	// +optional
	Routes []VirtualMachineNetworkRouteSpec `json:"routes,omitempty"`

	// SearchDomains is a list of search domains used when resolving IP
	// addresses with DNS.
	//
	// Please note this feature is available only with the following bootstrap
	// providers: CloudInit.
	//
	// +optional
	SearchDomains []string `json:"searchDomains,omitempty"`
}

VirtualMachineNetworkInterfaceSpec describes the desired state of a VM's network interface.

func (*VirtualMachineNetworkInterfaceSpec) DeepCopy 

func (in *VirtualMachineNetworkInterfaceSpec) DeepCopy() *VirtualMachineNetworkInterfaceSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineNetworkInterfaceSpec.

func (*VirtualMachineNetworkInterfaceSpec) DeepCopyInto 

func (in *VirtualMachineNetworkInterfaceSpec) DeepCopyInto(out *VirtualMachineNetworkInterfaceSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineNetworkInterfaceStatus 

type VirtualMachineNetworkInterfaceStatus struct {
	// Name describes the corresponding network interface with the same name
	// in the VM's desired network interface list. If unset, then there is no
	// corresponding entry for this interface.
	//
	// Please note this name is not necessarily related to the name of the
	// device as it is surfaced inside of the guest.
	//
	// +optional
	Name string `json:"name,omitempty"`

	// DeviceKey describes the unique hardware device key of this network
	// interface.
	//
	// +optional
	DeviceKey int32 `json:"deviceKey,omitempty"`

	// IP describes the observed state of the interface's IP configuration.
	//
	// +optional
	IP *VirtualMachineNetworkInterfaceIPStatus `json:"ip,omitempty"`

	// DNS describes the observed state of the interface's DNS configuration.
	//
	// +optional
	DNS *VirtualMachineNetworkDNSStatus `json:"dns,omitempty"`
}

VirtualMachineNetworkInterfaceStatus describes the observed state of a VM's network interface.

func (*VirtualMachineNetworkInterfaceStatus) DeepCopy 

func (in *VirtualMachineNetworkInterfaceStatus) DeepCopy() *VirtualMachineNetworkInterfaceStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineNetworkInterfaceStatus.

func (*VirtualMachineNetworkInterfaceStatus) DeepCopyInto 

func (in *VirtualMachineNetworkInterfaceStatus) DeepCopyInto(out *VirtualMachineNetworkInterfaceStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineNetworkRouteSpec 

type VirtualMachineNetworkRouteSpec struct {
	// To is an IP4 or IP6 address.
	To string `json:"to"`

	// Via is an IP4 or IP6 address.
	Via string `json:"via"`

	// Metric is the weight/priority of the route.
	Metric int32 `json:"metric"`
}

VirtualMachineNetworkRouteSpec defines a static route for a guest.

func (*VirtualMachineNetworkRouteSpec) DeepCopy 

func (in *VirtualMachineNetworkRouteSpec) DeepCopy() *VirtualMachineNetworkRouteSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineNetworkRouteSpec.

func (*VirtualMachineNetworkRouteSpec) DeepCopyInto 

func (in *VirtualMachineNetworkRouteSpec) DeepCopyInto(out *VirtualMachineNetworkRouteSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineNetworkRouteStatus 

type VirtualMachineNetworkRouteStatus struct {
	// IPRoutes contain the VM's routing tables for all address families.
	//
	// +optional
	IPRoutes []VirtualMachineNetworkIPRouteStatus `json:"ipRoutes,omitempty"`
}

VirtualMachineNetworkRouteStatus describes the observed state of a guest network's routes.

func (*VirtualMachineNetworkRouteStatus) DeepCopy 

func (in *VirtualMachineNetworkRouteStatus) DeepCopy() *VirtualMachineNetworkRouteStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineNetworkRouteStatus.

func (*VirtualMachineNetworkRouteStatus) DeepCopyInto 

func (in *VirtualMachineNetworkRouteStatus) DeepCopyInto(out *VirtualMachineNetworkRouteStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineNetworkSpec 

type VirtualMachineNetworkSpec struct {
	// HostName is the value the guest uses as its host name.
	// If omitted then the name of the VM will be used.
	//
	// Please note this feature is available only with the following bootstrap
	// providers: CloudInit, LinuxPrep, and Sysprep (except for RawSysprep).
	//
	// When the bootstrap provider is Sysprep (except for RawSysprep) this is
	// used as the Computer Name.
	//
	// +optional
	HostName string `json:"hostName,omitempty"`

	// Disabled is a flag that indicates whether or not to disable networking
	// for this VM.
	//
	// When set to true, the VM is not configured with a default interface nor
	// any specified from the Interfaces field.
	//
	// +optional
	Disabled bool `json:"disabled,omitempty"`

	// Nameservers is a list of IP4 and/or IP6 addresses used as DNS
	// nameservers. These are applied globally.
	//
	// Please note global nameservers are only available with the following
	// bootstrap providers: LinuxPrep and Sysprep. The Cloud-Init bootstrap
	// provider supports per-interface nameservers.
	//
	// Please note that Linux allows only three nameservers
	// (https://linux.die.net/man/5/resolv.conf).
	//
	// +optional
	Nameservers []string `json:"nameservers,omitempty"`

	// SearchDomains is a list of search domains used when resolving IP
	// addresses with DNS. These are applied globally.
	//
	// Please note global search domains are only available with the following
	// bootstrap providers: LinuxPrep and Sysprep. The Cloud-Init bootstrap
	// provider supports per-interface search domains.
	//
	// +optional
	SearchDomains []string `json:"searchDomains,omitempty"`

	// Interfaces is the list of network interfaces used by this VM.
	//
	// If the Interfaces field is empty and the Disabled field is false, then
	// a default interface with the name eth0 will be created.
	//
	// The maximum number of network interface allowed is 10 because of the limit
	// built into vSphere.
	//
	// +optional
	// +listType=map
	// +listMapKey=name
	// +kubebuilder:validation:MaxItems=10
	Interfaces []VirtualMachineNetworkInterfaceSpec `json:"interfaces,omitempty"`
}

VirtualMachineNetworkSpec defines a VM's desired network configuration.

func (*VirtualMachineNetworkSpec) DeepCopy 

func (in *VirtualMachineNetworkSpec) DeepCopy() *VirtualMachineNetworkSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineNetworkSpec.

func (*VirtualMachineNetworkSpec) DeepCopyInto 

func (in *VirtualMachineNetworkSpec) DeepCopyInto(out *VirtualMachineNetworkSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineNetworkStatus 

type VirtualMachineNetworkStatus struct {
	// Config describes the resolved, configured network settings for the VM,
	// such as an interface's IP address obtained from IPAM, or global DNS
	// settings.
	//
	// Please note this information does *not* represent the *observed* network
	// state of the VM, but is intended for situations where someone boots a VM
	// with no appropriate bootstrap engine and needs to know the network config
	// valid for the deployed VM.
	//
	// +optional
	Config *VirtualMachineNetworkConfigStatus `json:"config,omitempty"`

	// Interfaces describes the status of the VM's network interfaces.
	//
	// +optional
	Interfaces []VirtualMachineNetworkInterfaceStatus `json:"interfaces,omitempty"`

	// IPStacks describes information about the guest's configured IP networking
	// stacks.
	//
	// +optional
	IPStacks []VirtualMachineNetworkIPStackStatus `json:"ipStacks,omitempty"`

	// PrimaryIP4 describes the VM's primary IP4 address.
	//
	// If the bootstrap provider is CloudInit then this value is set to the
	// value of the VM's "guestinfo.local-ipv4" property. Please see
	// https://bit.ly/3NJB534 for more information on how this value is
	// calculated.
	//
	// If the bootstrap provider is anything else then this field is set to the
	// value of the infrastructure VM's "guest.ipAddress" field. Please see
	// https://bit.ly/3Au0jM4 for more information.
	//
	// +optional
	PrimaryIP4 string `json:"primaryIP4,omitempty"`

	// PrimaryIP6 describes the VM's primary IP6 address.
	//
	// If the bootstrap provider is CloudInit then this value is set to the
	// value of the VM's "guestinfo.local-ipv6" property. Please see
	// https://bit.ly/3NJB534 for more information on how this value is
	// calculated.
	//
	// If the bootstrap provider is anything else then this field is set to the
	// value of the infrastructure VM's "guest.ipAddress" field. Please see
	// https://bit.ly/3Au0jM4 for more information.
	//
	// +optional
	PrimaryIP6 string `json:"primaryIP6,omitempty"`
}

VirtualMachineNetworkStatus defines the observed state of a VM's network configuration.

func (*VirtualMachineNetworkStatus) DeepCopy 

func (in *VirtualMachineNetworkStatus) DeepCopy() *VirtualMachineNetworkStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineNetworkStatus.

func (*VirtualMachineNetworkStatus) DeepCopyInto 

func (in *VirtualMachineNetworkStatus) DeepCopyInto(out *VirtualMachineNetworkStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachinePowerOpMode 

type VirtualMachinePowerOpMode string

VirtualMachinePowerOpMode represents the various power operation modes when powering off or suspending a VM. +kubebuilder:validation:Enum=Hard;Soft;TrySoft 

const (
	// VirtualMachinePowerOpModeHard indicates to halt a VM when powering it
	// off or when suspending a VM to not involve the guest.
	VirtualMachinePowerOpModeHard VirtualMachinePowerOpMode = "Hard"

	// VirtualMachinePowerOpModeSoft indicates to ask VM Tools running
	// inside of a VM's guest to shutdown the guest gracefully when powering
	// off a VM or when suspending a VM to allow the guest to participate.
	//
	// If this mode is set on a VM whose guest does not have VM Tools or if
	// VM Tools is present but the operation fails, the VM may never realize
	// the desired power state. This can prevent a VM from being deleted as well
	// as many other unexpected issues. It is recommended to use trySoft
	// instead.
	VirtualMachinePowerOpModeSoft VirtualMachinePowerOpMode = "Soft"

	// VirtualMachinePowerOpModeTrySoft indicates to first attempt a Soft
	// operation and fall back to Hard if VM Tools is not present in the guest,
	// if the Soft operation fails, or if the VM is not in the desired power
	// state within five minutes.
	VirtualMachinePowerOpModeTrySoft VirtualMachinePowerOpMode = "TrySoft"
)

type VirtualMachinePowerState 

type VirtualMachinePowerState string

VirtualMachinePowerState defines a VM's desired and observed power states. +kubebuilder:validation:Enum=PoweredOff;PoweredOn;Suspended 

const (
	// VirtualMachinePowerStateOff indicates to shut down a VM and/or it is
	// shut down.
	VirtualMachinePowerStateOff VirtualMachinePowerState = "PoweredOff"

	// VirtualMachinePowerStateOn indicates to power on a VM and/or it is
	// powered on.
	VirtualMachinePowerStateOn VirtualMachinePowerState = "PoweredOn"

	// VirtualMachinePowerStateSuspended indicates to suspend a VM and/or it is
	// suspended.
	VirtualMachinePowerStateSuspended VirtualMachinePowerState = "Suspended"
)

type VirtualMachinePublishRequest 

type VirtualMachinePublishRequest struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   VirtualMachinePublishRequestSpec   `json:"spec,omitempty"`
	Status VirtualMachinePublishRequestStatus `json:"status,omitempty"`
}

VirtualMachinePublishRequest defines the information necessary to publish a VirtualMachine as a VirtualMachineImage to an image registry.

func (*VirtualMachinePublishRequest) DeepCopy 

func (in *VirtualMachinePublishRequest) DeepCopy() *VirtualMachinePublishRequest

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachinePublishRequest.

func (*VirtualMachinePublishRequest) DeepCopyInto 

func (in *VirtualMachinePublishRequest) DeepCopyInto(out *VirtualMachinePublishRequest)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*VirtualMachinePublishRequest) DeepCopyObject 

func (in *VirtualMachinePublishRequest) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*VirtualMachinePublishRequest) GetConditions added in v1.8.5 

func (vmpub *VirtualMachinePublishRequest) GetConditions() []metav1.Condition

func (*VirtualMachinePublishRequest) Hub 

func (*VirtualMachinePublishRequest) Hub()

Hub marks VirtualMachinePublishRequest as a conversion hub.

func (*VirtualMachinePublishRequest) SetConditions added in v1.8.5 

func (vmpub *VirtualMachinePublishRequest) SetConditions(conditions []metav1.Condition)

func (*VirtualMachinePublishRequest) SetupWebhookWithManager 

func (r *VirtualMachinePublishRequest) SetupWebhookWithManager(mgr ctrl.Manager) error

type VirtualMachinePublishRequestList 

type VirtualMachinePublishRequestList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []VirtualMachinePublishRequest `json:"items"`
}

VirtualMachinePublishRequestList contains a list of VirtualMachinePublishRequest resources.

func (*VirtualMachinePublishRequestList) DeepCopy 

func (in *VirtualMachinePublishRequestList) DeepCopy() *VirtualMachinePublishRequestList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachinePublishRequestList.

func (*VirtualMachinePublishRequestList) DeepCopyInto 

func (in *VirtualMachinePublishRequestList) DeepCopyInto(out *VirtualMachinePublishRequestList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*VirtualMachinePublishRequestList) DeepCopyObject 

func (in *VirtualMachinePublishRequestList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*VirtualMachinePublishRequestList) Hub 

func (*VirtualMachinePublishRequestList) Hub()

Hub marks VirtualMachinePublishRequestList as a conversion hub.

type VirtualMachinePublishRequestSource 

type VirtualMachinePublishRequestSource struct {
	// Name is the name of the referenced object.
	//
	// If omitted this value defaults to the name of the
	// VirtualMachinePublishRequest resource.
	//
	// +optional
	Name string `json:"name,omitempty"`

	// APIVersion is the API version of the referenced object.
	//
	// +kubebuilder:default=vmoperator.vmware.com/v1alpha1
	// +optional
	APIVersion string `json:"apiVersion,omitempty"`

	// Kind is the kind of referenced object.
	//
	// +kubebuilder:default=VirtualMachine
	// +optional
	Kind string `json:"kind,omitempty"`
}

VirtualMachinePublishRequestSource is the source of a publication request, typically a VirtualMachine resource.

func (*VirtualMachinePublishRequestSource) DeepCopy 

func (in *VirtualMachinePublishRequestSource) DeepCopy() *VirtualMachinePublishRequestSource

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachinePublishRequestSource.

func (*VirtualMachinePublishRequestSource) DeepCopyInto 

func (in *VirtualMachinePublishRequestSource) DeepCopyInto(out *VirtualMachinePublishRequestSource)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachinePublishRequestSpec 

type VirtualMachinePublishRequestSpec struct {
	// Source is the source of the publication request, ex. a VirtualMachine
	// resource.
	//
	// If this value is omitted then the publication controller checks to
	// see if there is a resource with the same name as this
	// VirtualMachinePublishRequest resource, an API version equal to
	// spec.source.apiVersion, and a kind equal to spec.source.kind. If such
	// a resource exists, then it is the source of the publication.
	//
	// +optional
	Source VirtualMachinePublishRequestSource `json:"source,omitempty"`

	// Target is the target of the publication request, ex. item
	// information and a ContentLibrary resource.
	//
	// If this value is omitted, the controller uses spec.source.name + "-image"
	// as the name of the published item. Additionally, when omitted the
	// controller attempts to identify the target location by matching a
	// resource with an API version equal to spec.target.location.apiVersion, a
	// kind equal to spec.target.location.kind, w/ the label
	// "imageregistry.vmware.com/default".
	//
	// Please note that while optional, if a VirtualMachinePublishRequest sans
	// target information is applied to a namespace without a default
	// publication target, then the VirtualMachinePublishRequest resource
	// will be marked in error.
	//
	// +optional
	Target VirtualMachinePublishRequestTarget `json:"target,omitempty"`

	// TTLSecondsAfterFinished is the time-to-live duration for how long this
	// resource will be allowed to exist once the publication operation
	// completes. After the TTL expires, the resource will be automatically
	// deleted without the user having to take any direct action.
	//
	// If this field is unset then the request resource will not be
	// automatically deleted. If this field is set to zero then the request
	// resource is eligible for deletion immediately after it finishes.
	//
	// +optional
	// +kubebuilder:validation:Minimum=0
	TTLSecondsAfterFinished *int64 `json:"ttlSecondsAfterFinished,omitempty"`
}

VirtualMachinePublishRequestSpec defines the desired state of a VirtualMachinePublishRequest.

All the fields in this spec are optional. This is especially useful when a DevOps persona wants to publish a VM without doing anything more than applying a VirtualMachinePublishRequest resource that has the same name as said VM in the same namespace as said VM.

func (*VirtualMachinePublishRequestSpec) DeepCopy 

func (in *VirtualMachinePublishRequestSpec) DeepCopy() *VirtualMachinePublishRequestSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachinePublishRequestSpec.

func (*VirtualMachinePublishRequestSpec) DeepCopyInto 

func (in *VirtualMachinePublishRequestSpec) DeepCopyInto(out *VirtualMachinePublishRequestSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachinePublishRequestStatus 

type VirtualMachinePublishRequestStatus struct {
	// SourceRef is the reference to the source of the publication request,
	// ex. a VirtualMachine resource.
	//
	// +optional
	SourceRef *VirtualMachinePublishRequestSource `json:"sourceRef,omitempty"`

	// TargetRef is the reference to the target of the publication request,
	// ex. item information and a ContentLibrary resource.
	//
	//
	// +optional
	TargetRef *VirtualMachinePublishRequestTarget `json:"targetRef,omitempty"`

	// CompletionTime represents time when the request was completed. It is not
	// guaranteed to be set in happens-before order across separate operations.
	// It is represented in RFC3339 form and is in UTC.
	//
	// The value of this field should be equal to the value of the
	// LastTransitionTime for the status condition Type=Complete.
	//
	// +optional
	CompletionTime metav1.Time `json:"completionTime,omitempty"`

	// StartTime represents time when the request was acknowledged by the
	// controller. It is not guaranteed to be set in happens-before order
	// across separate operations. It is represented in RFC3339 form and is
	// in UTC.
	//
	// +optional
	StartTime metav1.Time `json:"startTime,omitempty"`

	// Attempts represents the number of times the request to publish the VM
	// has been attempted.
	//
	// +optional
	Attempts int64 `json:"attempts,omitempty"`

	// LastAttemptTime represents the time when the latest request was sent.
	//
	// +optional
	LastAttemptTime metav1.Time `json:"lastAttemptTime,omitempty"`

	// ImageName is the name of the VirtualMachineImage resource that is
	// eventually realized in the same namespace as the VM and publication
	// request after the publication operation completes.
	//
	// This field will not be set until the VirtualMachineImage resource
	// is realized.
	//
	// +optional
	ImageName string `json:"imageName,omitempty"`

	// Ready is set to true only when the VM has been published successfully
	// and the new VirtualMachineImage resource is ready.
	//
	// Readiness is determined by waiting until there is status condition
	// Type=Complete and ensuring it and all other status conditions present
	// have a Status=True. The conditions present will be:
	//
	//   * SourceValid
	//   * TargetValid
	//   * Uploaded
	//   * ImageAvailable
	//   * Complete
	//
	// +optional
	Ready bool `json:"ready,omitempty"`

	// Conditions is a list of the latest, available observations of the
	// request's current state.
	//
	// +optional
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

VirtualMachinePublishRequestStatus defines the observed state of a VirtualMachinePublishRequest.

func (*VirtualMachinePublishRequestStatus) DeepCopy 

func (in *VirtualMachinePublishRequestStatus) DeepCopy() *VirtualMachinePublishRequestStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachinePublishRequestStatus.

func (*VirtualMachinePublishRequestStatus) DeepCopyInto 

func (in *VirtualMachinePublishRequestStatus) DeepCopyInto(out *VirtualMachinePublishRequestStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachinePublishRequestTarget 

type VirtualMachinePublishRequestTarget struct {
	// Item contains information about the name of the object to which
	// the VM is published.
	//
	// Please note this value is optional and if omitted, the controller
	// will use spec.source.name + "-image" as the name of the published
	// item.
	//
	// +optional
	Item VirtualMachinePublishRequestTargetItem `json:"item,omitempty"`

	// Location contains information about the location to which to publish
	// the VM.
	//
	// +optional
	Location VirtualMachinePublishRequestTargetLocation `json:"location,omitempty"`
}

VirtualMachinePublishRequestTarget is the target of a publication request, typically a ContentLibrary resource.

func (*VirtualMachinePublishRequestTarget) DeepCopy 

func (in *VirtualMachinePublishRequestTarget) DeepCopy() *VirtualMachinePublishRequestTarget

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachinePublishRequestTarget.

func (*VirtualMachinePublishRequestTarget) DeepCopyInto 

func (in *VirtualMachinePublishRequestTarget) DeepCopyInto(out *VirtualMachinePublishRequestTarget)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachinePublishRequestTargetItem 

type VirtualMachinePublishRequestTargetItem struct {
	// Name is the name of the published object.
	//
	// If the spec.target.location.apiVersion equals
	// imageregistry.vmware.com/v1alpha1 and the spec.target.location.kind
	// equals ContentLibrary, then this should be the name that will
	// show up in vCenter Content Library, not the custom resource name
	// in the namespace.
	//
	// If omitted then the controller will use spec.source.name + "-image".
	//
	// +optional
	Name string `json:"name,omitempty"`

	// Description is the description to assign to the published object.
	//
	// +optional
	Description string `json:"description,omitempty"`
}

VirtualMachinePublishRequestTargetItem is the item part of a publication request's target.

func (*VirtualMachinePublishRequestTargetItem) DeepCopy 

func (in *VirtualMachinePublishRequestTargetItem) DeepCopy() *VirtualMachinePublishRequestTargetItem

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachinePublishRequestTargetItem.

func (*VirtualMachinePublishRequestTargetItem) DeepCopyInto 

func (in *VirtualMachinePublishRequestTargetItem) DeepCopyInto(out *VirtualMachinePublishRequestTargetItem)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachinePublishRequestTargetLocation 

type VirtualMachinePublishRequestTargetLocation struct {
	// Name is the name of the referenced object.
	//
	// Please note an error will be returned if this field is not
	// set in a namespace that lacks a default publication target.
	//
	// A default publication target is a resource with an API version
	// equal to spec.target.location.apiVersion, a kind equal to
	// spec.target.location.kind, and has the label
	// "imageregistry.vmware.com/default".
	//
	// +optional
	Name string `json:"name,omitempty"`

	// APIVersion is the API version of the referenced object.
	//
	// +kubebuilder:default=imageregistry.vmware.com/v1alpha1
	// +optional
	APIVersion string `json:"apiVersion,omitempty"`

	// Kind is the kind of referenced object.
	//
	// +kubebuilder:default=ContentLibrary
	// +optional
	Kind string `json:"kind,omitempty"`
}

VirtualMachinePublishRequestTargetLocation is the location part of a publication request's target.

func (*VirtualMachinePublishRequestTargetLocation) DeepCopy 

func (in *VirtualMachinePublishRequestTargetLocation) DeepCopy() *VirtualMachinePublishRequestTargetLocation

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachinePublishRequestTargetLocation.

func (*VirtualMachinePublishRequestTargetLocation) DeepCopyInto 

func (in *VirtualMachinePublishRequestTargetLocation) DeepCopyInto(out *VirtualMachinePublishRequestTargetLocation)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineReadinessProbeSpec 

type VirtualMachineReadinessProbeSpec struct {
	// TCPSocket specifies an action involving a TCP port.
	//
	// Deprecated: The TCPSocket action requires network connectivity that is not supported in all environments.
	// This field will be removed in a later API version.
	// +optional
	TCPSocket *TCPSocketAction `json:"tcpSocket,omitempty"`

	// GuestHeartbeat specifies an action involving the guest heartbeat status.
	// +optional
	GuestHeartbeat *GuestHeartbeatAction `json:"guestHeartbeat,omitempty"`

	// GuestInfo specifies an action involving key/value pairs from GuestInfo.
	//
	// The elements are evaluated with the logical AND operator, meaning
	// all expressions must evaluate as true for the probe to succeed.
	//
	// For example, a VM resource's probe definition could be specified as the
	// following:
	//
	//         guestInfo:
	//         - key:   ready
	//           value: true
	//
	// With the above configuration in place, the VM would not be considered
	// ready until the GuestInfo key "ready" was set to the value "true".
	//
	// From within the guest operating system it is possible to set GuestInfo
	// key/value pairs using the program "vmware-rpctool," which is included
	// with VM Tools. For example, the following command will set the key
	// "guestinfo.ready" to the value "true":
	//
	//         vmware-rpctool "info-set guestinfo.ready true"
	//
	// Once executed, the VM's readiness probe will be signaled and the
	// VM resource will be marked as ready.
	//
	// +optional
	GuestInfo []GuestInfoAction `json:"guestInfo,omitempty"`

	// TimeoutSeconds specifies a number of seconds after which the probe times out.
	// Defaults to 10 seconds. Minimum value is 1.
	// +optional
	// +kubebuilder:validation:Minimum:=1
	// +kubebuilder:validation:Maximum:=60
	TimeoutSeconds int32 `json:"timeoutSeconds,omitempty"`

	// PeriodSeconds specifics how often (in seconds) to perform the probe.
	// Defaults to 10 seconds. Minimum value is 1.
	// +optional
	// +kubebuilder:validation:Minimum:=1
	PeriodSeconds int32 `json:"periodSeconds,omitempty"`
}

VirtualMachineReadinessProbeSpec describes a probe used to determine if a VM is in a ready state. All probe actions are mutually exclusive.

func (*VirtualMachineReadinessProbeSpec) DeepCopy 

func (in *VirtualMachineReadinessProbeSpec) DeepCopy() *VirtualMachineReadinessProbeSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineReadinessProbeSpec.

func (*VirtualMachineReadinessProbeSpec) DeepCopyInto 

func (in *VirtualMachineReadinessProbeSpec) DeepCopyInto(out *VirtualMachineReadinessProbeSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineReservedSpec 

type VirtualMachineReservedSpec struct {
	// ResourcePolicyName describes the name of a
	// VirtualMachineSetResourcePolicy resource used to configure the VM's
	// resource policy.
	//
	// +optional
	ResourcePolicyName string `json:"resourcePolicyName,omitempty"`
}

VirtualMachineReservedSpec describes a set of VM configuration options reserved for system use. Modification attempts by DevOps users will result in a validation error.

func (*VirtualMachineReservedSpec) DeepCopy 

func (in *VirtualMachineReservedSpec) DeepCopy() *VirtualMachineReservedSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineReservedSpec.

func (*VirtualMachineReservedSpec) DeepCopyInto 

func (in *VirtualMachineReservedSpec) DeepCopyInto(out *VirtualMachineReservedSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineResourceSpec 

type VirtualMachineResourceSpec struct {
	// +optional
	Cpu resource.Quantity `json:"cpu,omitempty"` //nolint:stylecheck,revive

	// +optional
	Memory resource.Quantity `json:"memory,omitempty"`
}

VirtualMachineResourceSpec describes a virtual hardware policy specification.

func (*VirtualMachineResourceSpec) DeepCopy 

func (in *VirtualMachineResourceSpec) DeepCopy() *VirtualMachineResourceSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineResourceSpec.

func (*VirtualMachineResourceSpec) DeepCopyInto 

func (in *VirtualMachineResourceSpec) DeepCopyInto(out *VirtualMachineResourceSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineService 

type VirtualMachineService struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   VirtualMachineServiceSpec   `json:"spec,omitempty"`
	Status VirtualMachineServiceStatus `json:"status,omitempty"`
}

VirtualMachineService is the Schema for the virtualmachineservices API.

func (*VirtualMachineService) DeepCopy 

func (in *VirtualMachineService) DeepCopy() *VirtualMachineService

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineService.

func (*VirtualMachineService) DeepCopyInto 

func (in *VirtualMachineService) DeepCopyInto(out *VirtualMachineService)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*VirtualMachineService) DeepCopyObject 

func (in *VirtualMachineService) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*VirtualMachineService) Hub 

func (*VirtualMachineService) Hub()

Hub marks VirtualMachineService as a conversion hub.

func (*VirtualMachineService) NamespacedName 

func (s *VirtualMachineService) NamespacedName() string

func (*VirtualMachineService) SetupWebhookWithManager 

func (r *VirtualMachineService) SetupWebhookWithManager(mgr ctrl.Manager) error

type VirtualMachineServiceList 

type VirtualMachineServiceList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []VirtualMachineService `json:"items"`
}

VirtualMachineServiceList contains a list of VirtualMachineService.

func (*VirtualMachineServiceList) DeepCopy 

func (in *VirtualMachineServiceList) DeepCopy() *VirtualMachineServiceList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineServiceList.

func (*VirtualMachineServiceList) DeepCopyInto 

func (in *VirtualMachineServiceList) DeepCopyInto(out *VirtualMachineServiceList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*VirtualMachineServiceList) DeepCopyObject 

func (in *VirtualMachineServiceList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*VirtualMachineServiceList) Hub 

func (*VirtualMachineServiceList) Hub()

Hub marks VirtualMachineServiceList as a conversion hub.

type VirtualMachineServicePort 

type VirtualMachineServicePort struct {
	// Name describes the name to be used to identify this
	// VirtualMachineServicePort.
	Name string `json:"name"`

	// Protocol describes the Layer 4 transport protocol for this port.
	// Supports "TCP", "UDP", and "SCTP".
	Protocol string `json:"protocol"`

	// Port describes the external port that will be exposed by the service.
	Port int32 `json:"port"`

	// TargetPort describes the internal port open on a VirtualMachine that
	// should be mapped to the external Port.
	TargetPort int32 `json:"targetPort"`
}

VirtualMachineServicePort describes the specification of a service port to be exposed by a VirtualMachineService. This VirtualMachineServicePort specification includes attributes that define the external and internal representation of the service port.

func (*VirtualMachineServicePort) DeepCopy 

func (in *VirtualMachineServicePort) DeepCopy() *VirtualMachineServicePort

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineServicePort.

func (*VirtualMachineServicePort) DeepCopyInto 

func (in *VirtualMachineServicePort) DeepCopyInto(out *VirtualMachineServicePort)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineServiceSpec 

type VirtualMachineServiceSpec struct {
	// Type specifies a desired VirtualMachineServiceType for this
	// VirtualMachineService. Supported types are ClusterIP, LoadBalancer,
	// ExternalName.
	Type VirtualMachineServiceType `json:"type"`

	// Ports specifies a list of VirtualMachineServicePort to expose with this
	// VirtualMachineService. Each of these ports will be an accessible network
	// entry point to access this service by.
	Ports []VirtualMachineServicePort `json:"ports,omitempty"`

	// Selector specifies a map of key-value pairs, also known as a Label
	// Selector, that is used to match this VirtualMachineService with the set
	// of VirtualMachines that should back this VirtualMachineService.
	// +optional
	Selector map[string]string `json:"selector,omitempty"`

	// Only applies to VirtualMachineService Type: LoadBalancer
	// LoadBalancer will get created with the IP specified in this field.
	// This feature depends on whether the underlying load balancer provider
	// supports specifying the loadBalancerIP when a load balancer is created.
	// This field will be ignored if the provider does not support the feature.
	// Deprecated: This field was under-specified and its meaning varies across implementations.
	// Using it is non-portable and it may not support dual-stack.
	// Users are encouraged to use implementation-specific annotations when available.
	// +optional
	LoadBalancerIP string `json:"loadBalancerIP,omitempty"`

	// LoadBalancerSourceRanges is an array of IP addresses in the format of
	// CIDRs, for example: 103.21.244.0/22 and 10.0.0.0/24.
	// If specified and supported by the load balancer provider, this will
	// restrict ingress traffic to the specified client IPs. This field will be
	// ignored if the provider does not support the feature.
	// +optional
	LoadBalancerSourceRanges []string `json:"loadBalancerSourceRanges,omitempty"`

	// clusterIP is the IP address of the service and is usually assigned
	// randomly by the master. If an address is specified manually and is not in
	// use by others, it will be allocated to the service; otherwise, creation
	// of the service will fail. This field can not be changed through updates.
	// Valid values are "None", empty string (""), or a valid IP address. "None"
	// can be specified for headless services when proxying is not required.
	// Only applies to types ClusterIP and LoadBalancer.
	// Ignored if type is ExternalName.
	// More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies
	// +optional
	ClusterIP string `json:"clusterIp,omitempty"`

	// externalName is the external reference that kubedns or equivalent will
	// return as a CNAME record for this service. No proxying will be involved.
	// Must be a valid RFC-1123 hostname (https://tools.ietf.org/html/rfc1123)
	// and requires Type to be ExternalName.
	// +optional
	ExternalName string `json:"externalName,omitempty"`
}

VirtualMachineServiceSpec defines the desired state of VirtualMachineService.

func (*VirtualMachineServiceSpec) DeepCopy 

func (in *VirtualMachineServiceSpec) DeepCopy() *VirtualMachineServiceSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineServiceSpec.

func (*VirtualMachineServiceSpec) DeepCopyInto 

func (in *VirtualMachineServiceSpec) DeepCopyInto(out *VirtualMachineServiceSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineServiceStatus 

type VirtualMachineServiceStatus struct {
	// LoadBalancer contains the current status of the load balancer,
	// if one is present.
	// +optional
	LoadBalancer LoadBalancerStatus `json:"loadBalancer,omitempty"`
}

VirtualMachineServiceStatus defines the observed state of VirtualMachineService.

func (*VirtualMachineServiceStatus) DeepCopy 

func (in *VirtualMachineServiceStatus) DeepCopy() *VirtualMachineServiceStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineServiceStatus.

func (*VirtualMachineServiceStatus) DeepCopyInto 

func (in *VirtualMachineServiceStatus) DeepCopyInto(out *VirtualMachineServiceStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineServiceType 

type VirtualMachineServiceType string

VirtualMachineServiceType string describes ingress methods for a service. 

const (
	// VirtualMachineServiceTypeClusterIP means a service will only be
	// accessible inside the cluster, via the cluster IP.
	VirtualMachineServiceTypeClusterIP VirtualMachineServiceType = "ClusterIP"

	// VirtualMachineServiceTypeLoadBalancer means a service will be exposed via
	// an external load balancer (if the cloud provider supports it), in
	// addition to 'NodePort' type.
	VirtualMachineServiceTypeLoadBalancer VirtualMachineServiceType = "LoadBalancer"

	// VirtualMachineServiceTypeExternalName means a service consists of only a
	// reference to an external name that kubedns or equivalent will return as a
	// CNAME record, with no exposing or proxying of any VirtualMachines
	// involved.
	VirtualMachineServiceTypeExternalName VirtualMachineServiceType = "ExternalName"
)

These types correspond to a subset of the core Service Types.

type VirtualMachineSetResourcePolicy 

type VirtualMachineSetResourcePolicy struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   VirtualMachineSetResourcePolicySpec   `json:"spec,omitempty"`
	Status VirtualMachineSetResourcePolicyStatus `json:"status,omitempty"`
}

VirtualMachineSetResourcePolicy is the Schema for the virtualmachinesetresourcepolicies API.

func (*VirtualMachineSetResourcePolicy) DeepCopy 

func (in *VirtualMachineSetResourcePolicy) DeepCopy() *VirtualMachineSetResourcePolicy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineSetResourcePolicy.

func (*VirtualMachineSetResourcePolicy) DeepCopyInto 

func (in *VirtualMachineSetResourcePolicy) DeepCopyInto(out *VirtualMachineSetResourcePolicy)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*VirtualMachineSetResourcePolicy) DeepCopyObject 

func (in *VirtualMachineSetResourcePolicy) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*VirtualMachineSetResourcePolicy) Hub 

func (*VirtualMachineSetResourcePolicy) Hub()

Hub marks VirtualMachineSetResourcePolicy as a conversion hub.

func (*VirtualMachineSetResourcePolicy) NamespacedName added in v1.8.5 

func (p *VirtualMachineSetResourcePolicy) NamespacedName() string

func (*VirtualMachineSetResourcePolicy) SetupWebhookWithManager 

func (r *VirtualMachineSetResourcePolicy) SetupWebhookWithManager(mgr ctrl.Manager) error

type VirtualMachineSetResourcePolicyList 

type VirtualMachineSetResourcePolicyList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []VirtualMachineSetResourcePolicy `json:"items"`
}

VirtualMachineSetResourcePolicyList contains a list of VirtualMachineSetResourcePolicy.

func (*VirtualMachineSetResourcePolicyList) DeepCopy 

func (in *VirtualMachineSetResourcePolicyList) DeepCopy() *VirtualMachineSetResourcePolicyList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineSetResourcePolicyList.

func (*VirtualMachineSetResourcePolicyList) DeepCopyInto 

func (in *VirtualMachineSetResourcePolicyList) DeepCopyInto(out *VirtualMachineSetResourcePolicyList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*VirtualMachineSetResourcePolicyList) DeepCopyObject 

func (in *VirtualMachineSetResourcePolicyList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*VirtualMachineSetResourcePolicyList) Hub 

func (*VirtualMachineSetResourcePolicyList) Hub()

Hub marks VirtualMachineSetResourcePolicy as a conversion hub.

type VirtualMachineSetResourcePolicySpec 

type VirtualMachineSetResourcePolicySpec struct {
	ResourcePool        ResourcePoolSpec `json:"resourcePool,omitempty"`
	Folder              string           `json:"folder,omitempty"`
	ClusterModuleGroups []string         `json:"clusterModuleGroups,omitempty"`
}

VirtualMachineSetResourcePolicySpec defines the desired state of VirtualMachineSetResourcePolicy.

func (*VirtualMachineSetResourcePolicySpec) DeepCopy 

func (in *VirtualMachineSetResourcePolicySpec) DeepCopy() *VirtualMachineSetResourcePolicySpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineSetResourcePolicySpec.

func (*VirtualMachineSetResourcePolicySpec) DeepCopyInto 

func (in *VirtualMachineSetResourcePolicySpec) DeepCopyInto(out *VirtualMachineSetResourcePolicySpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineSetResourcePolicyStatus 

type VirtualMachineSetResourcePolicyStatus struct {
	ClusterModules []VSphereClusterModuleStatus `json:"clustermodules,omitempty"`
}

VirtualMachineSetResourcePolicyStatus defines the observed state of VirtualMachineSetResourcePolicy.

func (*VirtualMachineSetResourcePolicyStatus) DeepCopy 

func (in *VirtualMachineSetResourcePolicyStatus) DeepCopy() *VirtualMachineSetResourcePolicyStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineSetResourcePolicyStatus.

func (*VirtualMachineSetResourcePolicyStatus) DeepCopyInto 

func (in *VirtualMachineSetResourcePolicyStatus) DeepCopyInto(out *VirtualMachineSetResourcePolicyStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineSpec 

type VirtualMachineSpec struct {
	// ImageName describes the name of the image resource used to deploy this
	// VM.
	//
	// This field may be used to specify the name of a VirtualMachineImage
	// or ClusterVirtualMachineImage resource. The resolver first checks to see
	// if there is a VirtualMachineImage with the specified name. If no
	// such resource exists, the resolver then checks to see if there is a
	// ClusterVirtualMachineImage resource with the specified name in the same
	// Namespace as the VM being deployed.
	//
	// This field may also be used to specify the display name (vSphere name) of
	// a VirtualMachineImage or ClusterVirtualMachineImage resource. If the
	// display name unambiguously resolves to a distinct VM image (among all
	// existing VirtualMachineImages in the VM's namespace and all existing
	// ClusterVirtualMachineImages), then a mutation webhook updates this field
	// with the VM image resource name. If the display name resolves to multiple
	// or no VM images, then the mutation webhook denies the request and outputs
	// an error message accordingly.
	//
	// +optional
	ImageName string `json:"imageName,omitempty"`

	// ClassName describes the name of the VirtualMachineClass resource used to
	// deploy this VM.
	//
	// +optional
	ClassName string `json:"className,omitempty"`

	// StorageClass describes the name of a Kubernetes StorageClass resource
	// used to configure this VM's storage-related attributes.
	//
	// Please see https://kubernetes.io/docs/concepts/storage/storage-classes/
	// for more information on Kubernetes storage classes.
	//
	// +optional
	StorageClass string `json:"storageClass,omitempty"`

	// Bootstrap describes the desired state of the guest's bootstrap
	// configuration.
	//
	// If omitted, a default bootstrap method may be selected based on the
	// guest OS identifier. If Linux, then the LinuxPrep method is used.
	//
	// +optional
	Bootstrap *VirtualMachineBootstrapSpec `json:"bootstrap,omitempty"`

	// Network describes the desired network configuration for the VM.
	//
	// Please note this value may be omitted entirely and the VM will be
	// assigned a single, virtual network interface that is connected to the
	// Namespace's default network.
	//
	// +optional
	Network *VirtualMachineNetworkSpec `json:"network,omitempty"`

	// PowerState describes the desired power state of a VirtualMachine.
	//
	// Please note this field may be omitted when creating a new VM and will
	// default to "PoweredOn." However, once the field is set to a non-empty
	// value, it may no longer be set to an empty value.
	//
	// Additionally, setting this value to "Suspended" is not supported when
	// creating a new VM. The valid values when creating a new VM are
	// "PoweredOn" and "PoweredOff." An empty value is also allowed on create
	// since this value defaults to "PoweredOn" for new VMs.
	//
	// +optional
	PowerState VirtualMachinePowerState `json:"powerState,omitempty"`

	// PowerOffMode describes the desired behavior when powering off a VM.
	//
	// There are three, supported power off modes: Hard, Soft, and
	// TrySoft. The first mode, Hard, is the equivalent of a physical
	// system's power cord being ripped from the wall. The Soft mode
	// requires the VM's guest to have VM Tools installed and attempts to
	// gracefully shutdown the VM. Its variant, TrySoft, first attempts
	// a graceful shutdown, and if that fails or the VM is not in a powered off
	// state after five minutes, the VM is halted.
	//
	// If omitted, the mode defaults to TrySoft.
	//
	// +optional
	// +kubebuilder:default=TrySoft
	PowerOffMode VirtualMachinePowerOpMode `json:"powerOffMode,omitempty"`

	// SuspendMode describes the desired behavior when suspending a VM.
	//
	// There are three, supported suspend modes: Hard, Soft, and
	// TrySoft. The first mode, Hard, is where vSphere suspends the VM to
	// disk without any interaction inside of the guest. The Soft mode
	// requires the VM's guest to have VM Tools installed and attempts to
	// gracefully suspend the VM. Its variant, TrySoft, first attempts
	// a graceful suspend, and if that fails or the VM is not in a put into
	// standby by the guest after five minutes, the VM is suspended.
	//
	// If omitted, the mode defaults to TrySoft.
	//
	// +optional
	// +kubebuilder:default=TrySoft
	SuspendMode VirtualMachinePowerOpMode `json:"suspendMode,omitempty"`

	// NextRestartTime may be used to restart the VM, in accordance with
	// RestartMode, by setting the value of this field to "now"
	// (case-insensitive).
	//
	// A mutating webhook changes this value to the current time (UTC), which
	// the VM controller then uses to determine the VM should be restarted by
	// comparing the value to the timestamp of the last time the VM was
	// restarted.
	//
	// Please note it is not possible to schedule future restarts using this
	// field. The only value that users may set is the string "now"
	// (case-insensitive).
	//
	// +optional
	NextRestartTime string `json:"nextRestartTime,omitempty"`

	// RestartMode describes the desired behavior for restarting a VM when
	// spec.nextRestartTime is set to "now" (case-insensitive).
	//
	// There are three, supported suspend modes: Hard, Soft, and
	// TrySoft. The first mode, Hard, is where vSphere resets the VM without any
	// interaction inside of the guest. The Soft mode requires the VM's guest to
	// have VM Tools installed and asks the guest to restart the VM. Its
	// variant, TrySoft, first attempts a soft restart, and if that fails or
	// does not complete within five minutes, the VM is hard reset.
	//
	// If omitted, the mode defaults to TrySoft.
	//
	// +optional
	// +kubebuilder:default=TrySoft
	RestartMode VirtualMachinePowerOpMode `json:"restartMode,omitempty"`

	// Volumes describes a list of volumes that can be mounted to the VM.
	//
	// +optional
	// +listType=map
	// +listMapKey=name
	Volumes []VirtualMachineVolume `json:"volumes,omitempty"`

	// ReadinessProbe describes a probe used to determine the VM's ready state.
	//
	// +optional
	ReadinessProbe *VirtualMachineReadinessProbeSpec `json:"readinessProbe,omitempty"`

	// Advanced describes a set of optional, advanced VM configuration options.
	// +optional
	Advanced *VirtualMachineAdvancedSpec `json:"advanced,omitempty"`

	// Reserved describes a set of VM configuration options reserved for system
	// use.
	//
	// Please note attempts to modify the value of this field by a DevOps user
	// will result in a validation error.
	//
	// +optional
	Reserved *VirtualMachineReservedSpec `json:"reserved,omitempty"`

	// MinHardwareVersion describes the desired, minimum hardware version.
	//
	// The logic that determines the hardware version is as follows:
	//
	// 1. If this field is set, then its value is used.
	// 2. Otherwise, if the VirtualMachineClass used to deploy the VM contains a
	//    non-empty hardware version, then it is used.
	// 3. Finally, if the hardware version is still undetermined, the value is
	//    set to the default hardware version for the Datacenter/Cluster/Host
	//    where the VM is provisioned.
	//
	// This field is never updated to reflect the derived hardware version.
	// Instead, VirtualMachineStatus.HardwareVersion surfaces
	// the observed hardware version.
	//
	// Please note, setting this field's value to N ensures a VM's hardware
	// version is equal to or greater than N. For example, if a VM's observed
	// hardware version is 10 and this field's value is 13, then the VM will be
	// upgraded to hardware version 13. However, if the observed hardware
	// version is 17 and this field's value is 13, no change will occur.
	//
	// Several features are hardware version dependent, for example:
	//
	// * NVMe Controllers                >= 14
	// * Dynamic Direct Path I/O devices >= 17
	//
	// Please refer to https://kb.vmware.com/s/article/1003746 for a list of VM
	// hardware versions.
	//
	// It is important to remember that a VM's hardware version may not be
	// downgraded and upgrading a VM deployed from an image based on an older
	// hardware version to a more recent one may result in unpredictable
	// behavior. In other words, please be careful when choosing to upgrade a
	// VM to a newer hardware version.
	MinHardwareVersion int32 `json:"minHardwareVersion,omitempty"`
}

VirtualMachineSpec defines the desired state of a VirtualMachine.

func (*VirtualMachineSpec) DeepCopy 

func (in *VirtualMachineSpec) DeepCopy() *VirtualMachineSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineSpec.

func (*VirtualMachineSpec) DeepCopyInto 

func (in *VirtualMachineSpec) DeepCopyInto(out *VirtualMachineSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineStatus 

type VirtualMachineStatus struct {
	// Image is a reference to the VirtualMachineImage resource used to deploy
	// this VM.
	//
	// +optional
	Image *common.LocalObjectRef `json:"image,omitempty"`

	// Class is a reference to the VirtualMachineClass resource used to deploy
	// this VM.
	//
	// +optional
	Class *common.LocalObjectRef `json:"class,omitempty"`

	// Host describes the hostname or IP address of the infrastructure host
	// where the VM is executed.
	//
	// +optional
	Host string `json:"host,omitempty"`

	// PowerState describes the observed power state of the VirtualMachine.
	// +optional
	PowerState VirtualMachinePowerState `json:"powerState,omitempty"`

	// Conditions describes the observed conditions of the VirtualMachine.
	// +optional
	Conditions []metav1.Condition `json:"conditions,omitempty"`

	// Network describes the observed state of the VM's network configuration.
	// Please note much of the network status information is only available if
	// the guest has VM Tools installed.
	// +optional
	Network *VirtualMachineNetworkStatus `json:"network,omitempty"`

	// UniqueID describes a unique identifier that is provided by the underlying
	// infrastructure provider, such as vSphere.
	//
	// +optional
	UniqueID string `json:"uniqueID,omitempty"`

	// BiosUUID describes a unique identifier provided by the underlying
	// infrastructure provider that is exposed to the Guest OS BIOS as a unique
	// hardware identifier.
	//
	// +optional
	BiosUUID string `json:"biosUUID,omitempty"`

	// InstanceUUID describes the unique instance UUID provided by the
	// underlying infrastructure provider, such as vSphere.
	//
	// +optional
	InstanceUUID string `json:"instanceUUID,omitempty"`

	// Volumes describes a list of current status information for each Volume
	// that is desired to be attached to the VM.
	// +optional
	// +listType=map
	// +listMapKey=name
	Volumes []VirtualMachineVolumeStatus `json:"volumes,omitempty"`

	// ChangeBlockTracking describes the CBT enablement status on the VM.
	//
	// +optional
	ChangeBlockTracking *bool `json:"changeBlockTracking,omitempty"`

	// Zone describes the availability zone where the VirtualMachine has been
	// scheduled.
	//
	// Please note this field may be empty when the cluster is not zone-aware.
	//
	// +optional
	Zone string `json:"zone,omitempty"`

	// LastRestartTime describes the last time the VM was restarted.
	//
	// +optional
	LastRestartTime *metav1.Time `json:"lastRestartTime,omitempty"`

	// HardwareVersion describes the VirtualMachine resource's observed
	// hardware version.
	//
	// Please refer to VirtualMachineSpec.MinHardwareVersion for more
	// information on the topic of a VM's hardware version.
	//
	// +optional
	HardwareVersion int32 `json:"hardwareVersion,omitempty"`
}

VirtualMachineStatus defines the observed state of a VirtualMachine instance.

func (*VirtualMachineStatus) DeepCopy 

func (in *VirtualMachineStatus) DeepCopy() *VirtualMachineStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineStatus.

func (*VirtualMachineStatus) DeepCopyInto 

func (in *VirtualMachineStatus) DeepCopyInto(out *VirtualMachineStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineTemplate 

type VirtualMachineTemplate struct {
	// Net describes the observed state of the VM's network configuration.
	// +optional
	Net NetworkStatus

	// VM represents a pointer to a VirtualMachine instance that consist of the
	// desired specification and the observed status
	VM *VirtualMachine
}

VirtualMachineTemplate defines the specification for configuring VirtualMachine Template. A Virtual Machine Template is created during VM customization to populate OVF properties. Then by utilizing Golang-based templating, Virtual Machine Template provides access to dynamic configuration data.

func (*VirtualMachineTemplate) DeepCopy 

func (in *VirtualMachineTemplate) DeepCopy() *VirtualMachineTemplate

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineTemplate.

func (*VirtualMachineTemplate) DeepCopyInto 

func (in *VirtualMachineTemplate) DeepCopyInto(out *VirtualMachineTemplate)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineVolume 

type VirtualMachineVolume struct {
	// Name represents the volume's name. Must be a DNS_LABEL and unique within
	// the VM.
	Name string `json:"name"`

	// VirtualMachineVolumeSource represents the location and type of a volume
	// to mount.
	VirtualMachineVolumeSource `json:",inline"`
}

VirtualMachineVolume represents a named volume in a VM.

func (*VirtualMachineVolume) DeepCopy 

func (in *VirtualMachineVolume) DeepCopy() *VirtualMachineVolume

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineVolume.

func (*VirtualMachineVolume) DeepCopyInto 

func (in *VirtualMachineVolume) DeepCopyInto(out *VirtualMachineVolume)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineVolumeProvisioningMode 

type VirtualMachineVolumeProvisioningMode string

VirtualMachineVolumeProvisioningMode is the type used to express the desired or observed provisioning mode for a virtual machine disk.

+kubebuilder:validation:Enum=Thin;Thick;ThickEagerZero 

const (
	VirtualMachineVolumeProvisioningModeThin           VirtualMachineVolumeProvisioningMode = "Thin"
	VirtualMachineVolumeProvisioningModeThick          VirtualMachineVolumeProvisioningMode = "Thick"
	VirtualMachineVolumeProvisioningModeThickEagerZero VirtualMachineVolumeProvisioningMode = "ThickEagerZero"
)

type VirtualMachineVolumeSource 

type VirtualMachineVolumeSource struct {
	// PersistentVolumeClaim represents a reference to a PersistentVolumeClaim
	// in the same namespace.
	//
	// More information is available at
	// https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims.
	//
	// +optional
	PersistentVolumeClaim *PersistentVolumeClaimVolumeSource `json:"persistentVolumeClaim,omitempty"`
}

VirtualMachineVolumeSource represents the source location of a volume to mount. Only one of its members may be specified.

func (*VirtualMachineVolumeSource) DeepCopy 

func (in *VirtualMachineVolumeSource) DeepCopy() *VirtualMachineVolumeSource

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineVolumeSource.

func (*VirtualMachineVolumeSource) DeepCopyInto 

func (in *VirtualMachineVolumeSource) DeepCopyInto(out *VirtualMachineVolumeSource)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineVolumeStatus 

type VirtualMachineVolumeStatus struct {
	// Name is the name of the attached volume.
	Name string `json:"name"`

	// Attached represents whether a volume has been successfully attached to
	// the VirtualMachine or not.
	// +optional
	Attached bool `json:"attached,omitempty"`

	// DiskUUID represents the underlying virtual disk UUID and is present when
	// attachment succeeds.
	// +optional
	DiskUUID string `json:"diskUUID,omitempty"`

	// Error represents the last error seen when attaching or detaching a
	// volume.  Error will be empty if attachment succeeds.
	// +optional
	Error string `json:"error,omitempty"`
}

VirtualMachineVolumeStatus defines the observed state of a VirtualMachineVolume instance.

func (*VirtualMachineVolumeStatus) DeepCopy 

func (in *VirtualMachineVolumeStatus) DeepCopy() *VirtualMachineVolumeStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineVolumeStatus.

func (*VirtualMachineVolumeStatus) DeepCopyInto 

func (in *VirtualMachineVolumeStatus) DeepCopyInto(out *VirtualMachineVolumeStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineWebConsoleRequest 

type VirtualMachineWebConsoleRequest struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   VirtualMachineWebConsoleRequestSpec   `json:"spec,omitempty"`
	Status VirtualMachineWebConsoleRequestStatus `json:"status,omitempty"`
}

VirtualMachineWebConsoleRequest allows the creation of a one-time, web console connection to a VM.

func (*VirtualMachineWebConsoleRequest) DeepCopy 

func (in *VirtualMachineWebConsoleRequest) DeepCopy() *VirtualMachineWebConsoleRequest

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineWebConsoleRequest.

func (*VirtualMachineWebConsoleRequest) DeepCopyInto 

func (in *VirtualMachineWebConsoleRequest) DeepCopyInto(out *VirtualMachineWebConsoleRequest)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*VirtualMachineWebConsoleRequest) DeepCopyObject 

func (in *VirtualMachineWebConsoleRequest) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*VirtualMachineWebConsoleRequest) SetupWebhookWithManager 

func (r *VirtualMachineWebConsoleRequest) SetupWebhookWithManager(mgr ctrl.Manager) error

type VirtualMachineWebConsoleRequestList 

type VirtualMachineWebConsoleRequestList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []VirtualMachineWebConsoleRequest `json:"items"`
}

VirtualMachineWebConsoleRequestList contains a list of VirtualMachineWebConsoleRequests.

func (*VirtualMachineWebConsoleRequestList) DeepCopy 

func (in *VirtualMachineWebConsoleRequestList) DeepCopy() *VirtualMachineWebConsoleRequestList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineWebConsoleRequestList.

func (*VirtualMachineWebConsoleRequestList) DeepCopyInto 

func (in *VirtualMachineWebConsoleRequestList) DeepCopyInto(out *VirtualMachineWebConsoleRequestList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*VirtualMachineWebConsoleRequestList) DeepCopyObject 

func (in *VirtualMachineWebConsoleRequestList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type VirtualMachineWebConsoleRequestSpec 

type VirtualMachineWebConsoleRequestSpec struct {
	// Name is the name of a VM in the same Namespace as this web console
	// request.
	Name string `json:"name"`
	// PublicKey is used to encrypt the status.response. This is expected to be a RSA OAEP public key in X.509 PEM format.
	PublicKey string `json:"publicKey"`
}

VirtualMachineWebConsoleRequestSpec describes the desired state for a web console request to a VM.

func (*VirtualMachineWebConsoleRequestSpec) DeepCopy 

func (in *VirtualMachineWebConsoleRequestSpec) DeepCopy() *VirtualMachineWebConsoleRequestSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineWebConsoleRequestSpec.

func (*VirtualMachineWebConsoleRequestSpec) DeepCopyInto 

func (in *VirtualMachineWebConsoleRequestSpec) DeepCopyInto(out *VirtualMachineWebConsoleRequestSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type VirtualMachineWebConsoleRequestStatus 

type VirtualMachineWebConsoleRequestStatus struct {
	// Response will be the authenticated ticket corresponding to this web console request.
	Response string `json:"response,omitempty"`
	// ExpiryTime is the time at which access via this request will expire.
	ExpiryTime metav1.Time `json:"expiryTime,omitempty"`

	// ProxyAddr describes the host address and optional port used to access
	// the VM's web console.
	//
	// The value could be a DNS entry, IPv4, or IPv6 address, followed by an
	// optional port. For example, valid values include:
	//
	//     DNS
	//         * host.com
	//         * host.com:6443
	//
	//     IPv4
	//         * 1.2.3.4
	//         * 1.2.3.4:6443
	//
	//     IPv6
	//         * 1234:1234:1234:1234:1234:1234:1234:1234
	//         * [1234:1234:1234:1234:1234:1234:1234:1234]:6443
	//         * 1234:1234:1234:0000:0000:0000:1234:1234
	//         * 1234:1234:1234::::1234:1234
	//         * [1234:1234:1234::::1234:1234]:6443
	//
	// In other words, the field may be set to any value that is parsable
	// by Go's https://pkg.go.dev/net#ResolveIPAddr and
	// https://pkg.go.dev/net#ParseIP functions.
	ProxyAddr string `json:"proxyAddr,omitempty"`
}

VirtualMachineWebConsoleRequestStatus describes the observed state of the request.

func (*VirtualMachineWebConsoleRequestStatus) DeepCopy 

func (in *VirtualMachineWebConsoleRequestStatus) DeepCopy() *VirtualMachineWebConsoleRequestStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VirtualMachineWebConsoleRequestStatus.

func (*VirtualMachineWebConsoleRequestStatus) DeepCopyInto 

func (in *VirtualMachineWebConsoleRequestStatus) DeepCopyInto(out *VirtualMachineWebConsoleRequestStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.