v1

package
v0.59.0-alpha.0 Latest Latest
Warning

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

 Go to latest Published: Oct 31, 2022 License: Apache-2.0 Imports: 13 Imported by: 547

Documentation

Overview

+groupName=kubevirt.io +versionName=v1alpha3 +k8s:openapi-gen=true Package v1 is the v1 version of the API.

  • This file is part of the KubeVirt project *
  • Licensed under the Apache License, Version 2.0 (the "License");
  • you may not use this file except in compliance with the License.
  • You may obtain a copy of the License at *
  • http://www.apache.org/licenses/LICENSE-2.0 *
  • Unless required by applicable law or agreed to in writing, software
  • distributed under the License is distributed on an "AS IS" BASIS,
  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  • See the License for the specific language governing permissions and
  • limitations under the License. *
  • Copyright 2019 Red Hat, Inc. *

Index

Constants

View Source 
const (
	IOThreadsPolicyShared  IOThreadsPolicy = "shared"
	IOThreadsPolicyAuto    IOThreadsPolicy = "auto"
	CPUModeHostPassthrough                 = "host-passthrough"
	CPUModeHostModel                       = "host-model"
	DefaultCPUModel                        = CPUModeHostModel
)
View Source 
const (
	// HPETTickPolicyDelay delivers ticks at a constant rate. The guest time will
	// be delayed due to the late tick
	HPETTickPolicyDelay HPETTickPolicy = "delay"
	// HPETTickPolicyCatchup Delivers ticks at a higher rate to catch up with the
	// missed tick. The guest time should not be delayed once catchup is complete
	HPETTickPolicyCatchup HPETTickPolicy = "catchup"
	// HPETTickPolicyMerge merges the missed tick(s) into one tick and inject. The
	// guest time may be delayed, depending on how the OS reacts to the merging
	// of ticks.
	HPETTickPolicyMerge HPETTickPolicy = "merge"
	// HPETTickPolicyDiscard discards all missed ticks.
	HPETTickPolicyDiscard HPETTickPolicy = "discard"

	// PITTickPolicyDelay delivers ticks at a constant rate. The guest time will
	// be delayed due to the late tick.
	PITTickPolicyDelay PITTickPolicy = "delay"
	// PITTickPolicyCatchup Delivers ticks at a higher rate to catch up with the
	// missed tick. The guest time should not be delayed once catchup is complete.
	PITTickPolicyCatchup PITTickPolicy = "catchup"
	// PITTickPolicyDiscard discards all missed ticks.
	PITTickPolicyDiscard PITTickPolicy = "discard"

	// RTCTickPolicyDelay delivers ticks at a constant rate. The guest time will
	// be delayed due to the late tick.
	RTCTickPolicyDelay RTCTickPolicy = "delay"
	// RTCTickPolicyCatchup Delivers ticks at a higher rate to catch up with the
	// missed tick. The guest time should not be delayed once catchup is complete.
	RTCTickPolicyCatchup RTCTickPolicy = "catchup"
)
View Source 
const (
	// Provisioning means, a VMI depends on DataVolumes which are in Pending/WaitForFirstConsumer status,
	// and some actions are taken to provision the PVCs for the DataVolumes
	VirtualMachineInstanceProvisioning VirtualMachineInstanceConditionType = "Provisioning"

	// Ready means the VMI is able to service requests and should be added to the
	// load balancing pools of all matching services.
	VirtualMachineInstanceReady VirtualMachineInstanceConditionType = "Ready"

	// If there happens any error while trying to synchronize the VirtualMachineInstance with the Domain,
	// this is reported as false.
	VirtualMachineInstanceSynchronized VirtualMachineInstanceConditionType = "Synchronized"

	// If the VMI was paused by the user, this is reported as true.
	VirtualMachineInstancePaused VirtualMachineInstanceConditionType = "Paused"

	// Reflects whether the QEMU guest agent is connected through the channel
	VirtualMachineInstanceAgentConnected VirtualMachineInstanceConditionType = "AgentConnected"

	// Reflects whether the QEMU guest agent updated access credentials successfully
	VirtualMachineInstanceAccessCredentialsSynchronized VirtualMachineInstanceConditionType = "AccessCredentialsSynchronized"

	// Reflects whether the QEMU guest agent is connected through the channel
	VirtualMachineInstanceUnsupportedAgent VirtualMachineInstanceConditionType = "AgentVersionNotSupported"

	// Indicates whether the VMI is live migratable
	VirtualMachineInstanceIsMigratable VirtualMachineInstanceConditionType = "LiveMigratable"
	// Reason means that VMI is not live migratioable because of it's disks collection
	VirtualMachineInstanceReasonDisksNotMigratable = "DisksNotLiveMigratable"
	// Reason means that VMI is not live migratioable because of it's network interfaces collection
	VirtualMachineInstanceReasonInterfaceNotMigratable = "InterfaceNotLiveMigratable"
	// Reason means that VMI is not live migratioable because it uses hotplug
	VirtualMachineInstanceReasonHotplugNotMigratable = "HotplugNotLiveMigratable"
	// Reason means that VMI is not live migratioable because of it's CPU mode
	VirtualMachineInstanceReasonCPUModeNotMigratable = "CPUModeLiveMigratable"
	// Reason means that VMI is not live migratable because it uses virtiofs
	VirtualMachineInstanceReasonVirtIOFSNotMigratable = "VirtIOFSNotLiveMigratable"
	// Reason means that VMI is not live migratable because it uses PCI host devices
	VirtualMachineInstanceReasonHostDeviceNotMigratable = "HostDeviceNotLiveMigratable"
	// Reason means that VMI is not live migratable because it uses Secure Encrypted Virtualization (SEV)
	VirtualMachineInstanceReasonSEVNotMigratable = "SEVNotLiveMigratable"
	// Reason means that VMI is not live migratable because it uses HyperV Reenlightenment while TSC Frequency is not available
	VirtualMachineInstanceReasonNoTSCFrequencyMigratable = "NoTSCFrequencyNotLiveMigratable"
)

These are valid conditions of VMIs.

View Source 
const (
	// PodTerminatingReason indicates on the Ready condition on the VMI if the underlying pod is terminating
	PodTerminatingReason = "PodTerminating"

	// PodNotExistsReason indicates on the Ready condition on the VMI if the underlying pod does not exist
	PodNotExistsReason = "PodNotExists"

	// PodConditionMissingReason indicates on the Ready condition on the VMI if the underlying pod does not report a Ready condition
	PodConditionMissingReason = "PodConditionMissing"

	// GuestNotRunningReason indicates on the Ready condition on the VMI if the underlying guest VM is not running
	GuestNotRunningReason = "GuestNotRunning"
)
View Source 
const (
	// AppLabel and AppName labels marks resources that belong to KubeVirt. An optional value
	// may indicate which specific KubeVirt component a resource belongs to.
	AppLabel string = "kubevirt.io"
	AppName  string = "name"
	// This annotation is used to match virtual machine instances represented as
	// libvirt XML domains with their pods. Among other things, the annotation is
	// used to detect virtual machines with dead pods. Used on Pod.
	DomainAnnotation string = "kubevirt.io/domain"
	// Represents the name of the migration job this target pod is associated with
	MigrationJobNameAnnotation                    string = "kubevirt.io/migrationJobName"
	ControllerAPILatestVersionObservedAnnotation  string = "kubevirt.io/latest-observed-api-version"
	ControllerAPIStorageVersionObservedAnnotation string = "kubevirt.io/storage-observed-api-version"
	// Used by functional tests to force a VMI to fail the migration internally within launcher
	FuncTestForceLauncherMigrationFailureAnnotation string = "kubevirt.io/func-test-force-launcher-migration-failure"
	// Used by functional tests to prevent virt launcher from finishing the target pod preparation.
	FuncTestBlockLauncherPrepareMigrationTargetAnnotation string = "kubevirt.io/func-test-block-migration-target-preparation"

	// Used by functional tests set custom image on migration target pod
	FuncTestMigrationTargetImageOverrideAnnotation string = "kubevirt.io/func-test-migration-target-image-override"

	// Used by functional tests to simulate virt-launcher crash looping
	FuncTestLauncherFailFastAnnotation string = "kubevirt.io/func-test-virt-launcher-fail-fast"
	// This label is used to match virtual machine instance IDs with pods.
	// Similar to kubevirt.io/domain. Used on Pod.
	// Internal use only.
	CreatedByLabel string = "kubevirt.io/created-by"
	// This label is used to indicate that this pod is the target of a migration job.
	MigrationJobLabel string = "kubevirt.io/migrationJobUID"
	// This label indicates the migration name that a PDB is protecting.
	MigrationNameLabel string = "kubevirt.io/migrationName"
	// This label describes which cluster node runs the virtual machine
	// instance. Needed because with CRDs we can't use field selectors. Used on
	// VirtualMachineInstance.
	NodeNameLabel string = "kubevirt.io/nodeName"
	// This label describes which cluster node runs the target Pod for a Virtual
	// Machine Instance migration job. Needed because with CRDs we can't use field
	// selectors. Used on VirtualMachineInstance.
	MigrationTargetNodeNameLabel string = "kubevirt.io/migrationTargetNodeName"
	// This annotation indicates that a migration is the result of an
	// automated evacuation
	EvacuationMigrationAnnotation string = "kubevirt.io/evacuationMigration"
	// This annotation indicates that a migration is the result of an
	// automated workload update
	WorkloadUpdateMigrationAnnotation string = "kubevirt.io/workloadUpdateMigration"
	// This label declares whether a particular node is available for
	// scheduling virtual machine instances on it. Used on Node.
	NodeSchedulable string = "kubevirt.io/schedulable"
	// This annotation is regularly updated by virt-handler to help determine
	// if a particular node is alive and hence should be available for new
	// virtual machine instance scheduling. Used on Node.
	VirtHandlerHeartbeat string = "kubevirt.io/heartbeat"
	// This label indicates what launcher image a VMI is currently running with.
	OutdatedLauncherImageLabel string = "kubevirt.io/outdatedLauncherImage"
	// Namespace recommended by Kubernetes for commonly recognized labels
	AppLabelPrefix = "app.kubernetes.io"
	// This label is commonly used by 3rd party management tools to identify
	// an application's name.
	AppNameLabel = AppLabelPrefix + "/name"
	// This label is commonly used by 3rd party management tools to identify
	// an application's version.
	AppVersionLabel = AppLabelPrefix + "/version"
	// This label is commonly used by 3rd party management tools to identify
	// a higher level application.
	AppPartOfLabel = AppLabelPrefix + "/part-of"
	// This label is commonly used by 3rd party management tools to identify
	// the component this application is a part of.
	AppComponentLabel = AppLabelPrefix + "/component"
	// This label identifies each resource as part of KubeVirt
	AppComponent = "kubevirt"
	// This label will be set on all resources created by the operator
	ManagedByLabel                 = AppLabelPrefix + "/managed-by"
	ManagedByLabelOperatorValue    = "virt-operator"
	ManagedByLabelOperatorOldValue = "kubevirt-operator"
	// This annotation represents the kubevirt version for an install strategy configmap.
	InstallStrategyVersionAnnotation = "kubevirt.io/install-strategy-version"
	// This annotation represents the kubevirt registry used for an install strategy configmap.
	InstallStrategyRegistryAnnotation = "kubevirt.io/install-strategy-registry"
	// This annotation represents the kubevirt deployment identifier used for an install strategy configmap.
	InstallStrategyIdentifierAnnotation = "kubevirt.io/install-strategy-identifier"
	// This annotation shows the enconding used for the manifests in the Install Strategy ConfigMap.
	InstallStrategyConfigMapEncoding = "kubevirt.io/install-strategy-cm-encoding"
	// This annotation is a hash of all customizations that live under spec.CustomizeComponents
	KubeVirtCustomizeComponentAnnotationHash = "kubevirt.io/customizer-identifier"
	// This annotation represents the kubevirt generation that was used to create a resource
	KubeVirtGenerationAnnotation = "kubevirt.io/generation"
	// This annotation represents that this object is for temporary use during updates
	EphemeralBackupObject = "kubevirt.io/ephemeral-backup-object"
	// This annotation represents that the annotated object is for temporary use during pod/volume provisioning
	EphemeralProvisioningObject string = "kubevirt.io/ephemeral-provisioning"

	// This label indicates the object is a part of the install strategy retrieval process.
	InstallStrategyLabel = "kubevirt.io/install-strategy"

	// Set by virt-operator to coordinate component deletion
	VirtOperatorComponentFinalizer string = "kubevirt.io/virtOperatorFinalizer"

	// Set by VMI controller to ensure VMIs are processed during deletion
	VirtualMachineInstanceFinalizer string = "foregroundDeleteVirtualMachine"
	// Set By VM controller on VMIs to ensure VMIs are processed by VM controller during deletion
	VirtualMachineControllerFinalizer        string = "kubevirt.io/virtualMachineControllerFinalize"
	VirtualMachineInstanceMigrationFinalizer string = "kubevirt.io/migrationJobFinalize"
	CPUManager                               string = "cpumanager"
	// This annotation is used to inject ignition data
	// Used on VirtualMachineInstance.
	IgnitionAnnotation           string = "kubevirt.io/ignitiondata"
	PlacePCIDevicesOnRootComplex string = "kubevirt.io/placePCIDevicesOnRootComplex"

	// This label represents supported cpu features on the node
	CPUFeatureLabel = "cpu-feature.node.kubevirt.io/"
	// This label represents supported cpu models on the node
	CPUModelLabel                  = "cpu-model.node.kubevirt.io/"
	SupportedHostModelMigrationCPU = "cpu-model-migration.node.kubevirt.io/"
	CPUTimerLabel                  = "cpu-timer.node.kubevirt.io/"
	// This label represents supported HyperV features on the node
	HypervLabel = "hyperv.node.kubevirt.io/"
	// This label represents vendor of cpu model on the node
	CPUModelVendorLabel = "cpu-vendor.node.kubevirt.io/"

	VirtIO = "virtio"

	// This label represents the host model CPU name
	HostModelCPULabel = "host-model-cpu.node.kubevirt.io/"
	// This label represents the host model required features
	HostModelRequiredFeaturesLabel = "host-model-required-features.node.kubevirt.io/"

	LabellerSkipNodeAnnotation        = "node-labeller.kubevirt.io/skip-node"
	VirtualMachineLabel               = AppLabel + "/vm"
	MemfdMemoryBackend         string = "kubevirt.io/memfd"

	MigrationSelectorLabel = "kubevirt.io/vmi-name"

	// This annotation represents vmi running nonroot implementation
	DeprecatedNonRootVMIAnnotation = "kubevirt.io/nonroot"

	// This annotation is to keep virt launcher container alive when an VMI encounters a failure for debugging purpose
	KeepLauncherAfterFailureAnnotation string = "kubevirt.io/keep-launcher-alive-after-failure"

	// MigrationTransportUnixAnnotation means that the VMI will be migrated using the unix URI
	MigrationTransportUnixAnnotation string = "kubevirt.io/migrationTransportUnix"

	// MigrationUnschedulablePodTimeoutSecondsAnnotation represents a custom timeout period used for unschedulable target pods
	// This exists for functional testing
	MigrationUnschedulablePodTimeoutSecondsAnnotation string = "kubevirt.io/migrationUnschedulablePodTimeoutSeconds"

	// MigrationPendingPodTimeoutSecondsAnnotation represents a custom timeout period used for target pods stuck in pending for any reason
	// This exists for functional testing
	MigrationPendingPodTimeoutSecondsAnnotation string = "kubevirt.io/migrationPendingPodTimeoutSeconds"

	// CustomLibvirtLogFiltersAnnotation can be used to customized libvirt log filters. Example value could be
	// "3:remote 4:event 3:util.json 3:util.object 3:util.dbus 3:util.netlink 3:node_device 3:rpc 3:access 1:*".
	// For more info: https://libvirt.org/kbase/debuglogs.html
	CustomLibvirtLogFiltersAnnotation string = "kubevirt.io/libvirt-log-filters"

	// RealtimeLabel marks the node as capable of running realtime workloads
	RealtimeLabel string = "kubevirt.io/realtime"

	// VirtualMachineUnpaused is a custom pod condition set for the virt-launcher pod.
	// It's used as a readiness gate to prevent paused VMs from being marked as ready.
	VirtualMachineUnpaused k8sv1.PodConditionType = "kubevirt.io/virtual-machine-unpaused"

	// SEVLabel marks the node as capable of running workloads with SEV
	SEVLabel string = "kubevirt.io/sev"

	// InstancetypeAnnotation is the name of a VirtualMachineInstancetype
	InstancetypeAnnotation string = "kubevirt.io/instancetype-name"

	// ClusterInstancetypeAnnotation is the name of a VirtualMachineClusterInstancetype
	ClusterInstancetypeAnnotation string = "kubevirt.io/cluster-instancetype-name"

	// InstancetypeAnnotation is the name of a VirtualMachinePreference
	PreferenceAnnotation string = "kubevirt.io/preference-name"

	// ClusterInstancetypeAnnotation is the name of a VirtualMachinePreferenceInstancetype
	ClusterPreferenceAnnotation string = "kubevirt.io/cluster-preference-name"

	// VirtualMachinePoolRevisionName is used to store the vmpool revision's name this object
	// originated from.
	VirtualMachinePoolRevisionName string = "kubevirt.io/vm-pool-revision-name"

	// VirtualMachineNameLabel is the name of the Virtual Machine
	VirtualMachineNameLabel string = "vm.kubevirt.io/name"

	// PVCMemoryDumpAnnotation is the name of the memory dump representing the vm name,
	// pvc name and the timestamp the memory dump was collected
	PVCMemoryDumpAnnotation string = "kubevirt.io/memory-dump"
)
View Source 
const (
	// CacheNone - I/O from the guest is not cached on the host, but may be kept in a writeback disk cache.
	CacheNone DriverCache = "none"
	// CacheWriteThrough - I/O from the guest is cached on the host but written through to the physical medium.
	CacheWriteThrough DriverCache = "writethrough"
	// CacheWriteBack - I/O from the guest is cached on the host.
	CacheWriteBack DriverCache = "writeback"

	// IOThreads - User mode based threads with a shared lock that perform I/O tasks. Can impact performance but offers
	// more predictable behaviour. This method is also takes fewer CPU cycles to submit I/O requests.
	IOThreads DriverIO = "threads"
	// IONative - Kernel native I/O tasks (AIO) offer a better performance but can block the VM if the file is not fully
	// allocated so this method recommended only when the backing file/disk/etc is fully preallocated.
	IONative DriverIO = "native"
	// IODefault - Fallback to the default value from the kernel. With recent Kernel versions (for example RHEL-7) the
	// default is AIO.
	IODefault DriverIO = "default"
)
View Source 
const (
	StartRequestDataPausedKey  string = "paused"
	StartRequestDataPausedTrue string = "true"
)
View Source 
const (
	PCIResourcePrefix  = "PCI_RESOURCE"
	MDevResourcePrefix = "MDEV_PCI_RESOURCE"
)
View Source 
const DefaultGracePeriodSeconds int64 = 30
View Source 
const HotplugDiskDir = "/var/run/kubevirt/hotplug-disks/"
View Source 
const KubeVirtClientGoSchemeRegistrationVersionEnvVar = "KUBEVIRT_CLIENT_GO_SCHEME_REGISTRATION_VERSION"
View Source 
const SubresourceGroupName = "subresources.kubevirt.io"
View Source 
const (
	UsbClientPassthroughMaxNumberOf = 4
)

Represents the upper limit allowed by QEMU + KubeVirt.

Variables

View Source 
var (
	ApiLatestVersion            = "v1"
	ApiSupportedWebhookVersions = []string{"v1alpha3", "v1"}
	ApiStorageVersion           = "v1alpha3"
	ApiSupportedVersions        = []extv1.CustomResourceDefinitionVersion{
		{
			Name:    "v1",
			Served:  true,
			Storage: false,
		},
		{
			Name:    "v1alpha3",
			Served:  true,
			Storage: true,
		},
	}
)
View Source 
var (
	// GroupVersion is the latest group version for the KubeVirt api
	GroupVersion       = schema.GroupVersion{Group: core.GroupName, Version: ApiLatestVersion}
	SchemeGroupVersion = schema.GroupVersion{Group: core.GroupName, Version: ApiLatestVersion}

	// StorageGroupVersion is the group version our api is persistented internally as
	StorageGroupVersion = schema.GroupVersion{Group: core.GroupName, Version: ApiStorageVersion}

	// GroupVersions is group version list used to register these objects
	// The preferred group version is the first item in the list.
	GroupVersions = []schema.GroupVersion{{Group: core.GroupName, Version: "v1"}, {Group: core.GroupName, Version: "v1alpha3"}}

	// SubresourceGroupVersions is group version list used to register these objects
	// The preferred group version is the first item in the list.
	SubresourceGroupVersions = []schema.GroupVersion{{Group: SubresourceGroupName, Version: ApiLatestVersion}, {Group: SubresourceGroupName, Version: ApiStorageVersion}}

	// SubresourceStorageGroupVersion is the group version our api is persistented internally as
	SubresourceStorageGroupVersion = schema.GroupVersion{Group: SubresourceGroupName, Version: ApiStorageVersion}
)
View Source 
var (
	// GroupVersionKind
	VirtualMachineInstanceGroupVersionKind           = schema.GroupVersionKind{Group: core.GroupName, Version: GroupVersion.Version, Kind: "VirtualMachineInstance"}
	VirtualMachineInstanceReplicaSetGroupVersionKind = schema.GroupVersionKind{Group: core.GroupName, Version: GroupVersion.Version, Kind: "VirtualMachineInstanceReplicaSet"}
	VirtualMachineInstancePresetGroupVersionKind     = schema.GroupVersionKind{Group: core.GroupName, Version: GroupVersion.Version, Kind: "VirtualMachineInstancePreset"}
	VirtualMachineGroupVersionKind                   = schema.GroupVersionKind{Group: core.GroupName, Version: GroupVersion.Version, Kind: "VirtualMachine"}
	VirtualMachineInstanceMigrationGroupVersionKind  = schema.GroupVersionKind{Group: core.GroupName, Version: GroupVersion.Version, Kind: "VirtualMachineInstanceMigration"}
	KubeVirtGroupVersionKind                         = schema.GroupVersionKind{Group: core.GroupName, Version: GroupVersion.Version, Kind: "KubeVirt"}
)
View Source 
var (
	SchemeBuilder = runtime.NewSchemeBuilder(AddKnownTypesGenerator([]schema.GroupVersion{GroupVersion}))
	AddToScheme   = SchemeBuilder.AddToScheme
)

Functions

func AddKnownTypesGenerator 

func AddKnownTypesGenerator(groupVersions []schema.GroupVersion) func(scheme *runtime.Scheme) error

func Kind 

func Kind(kind string) schema.GroupKind

Kind takes an unqualified kind and returns back a Group qualified GroupKind

func PrepareVMINodeAntiAffinitySelectorRequirement 

func PrepareVMINodeAntiAffinitySelectorRequirement(vmi *VirtualMachineInstance) k8sv1.NodeSelectorRequirement

Given a VirtualMachineInstance, create a NodeSelectorTerm with anti-affinity for that VirtualMachineInstance's node. This is useful for the case when a migration away from a node must occur.

func RegisterDefaults 

func RegisterDefaults(scheme *runtime.Scheme) error

RegisterDefaults adds defaulters functions to the given scheme. Public to allow building arbitrary schemes. All generated defaulters are covering - they call all nested defaulters.

func Resource 

func Resource(resource string) schema.GroupResource

Resource takes an unqualified resource and returns a Group qualified GroupResource

func SetDefaults_CDRomTarget 

func SetDefaults_CDRomTarget(obj *CDRomTarget)

func SetDefaults_DiskDevice 

func SetDefaults_DiskDevice(obj *DiskDevice)

func SetDefaults_FeatureAPIC 

func SetDefaults_FeatureAPIC(obj *FeatureAPIC)

func SetDefaults_FeatureSpinlocks 

func SetDefaults_FeatureSpinlocks(obj *FeatureSpinlocks)

func SetDefaults_FeatureState 

func SetDefaults_FeatureState(obj *FeatureState)

func SetDefaults_FeatureVendorID 

func SetDefaults_FeatureVendorID(obj *FeatureVendorID)

func SetDefaults_Firmware 

func SetDefaults_Firmware(obj *Firmware)

func SetDefaults_HPETTimer 

func SetDefaults_HPETTimer(obj *HPETTimer)

func SetDefaults_HypervTimer 

func SetDefaults_HypervTimer(obj *HypervTimer)

func SetDefaults_I6300ESBWatchdog 

func SetDefaults_I6300ESBWatchdog(obj *I6300ESBWatchdog)

func SetDefaults_KVMTimer 

func SetDefaults_KVMTimer(obj *KVMTimer)

func SetDefaults_NetworkInterface 

func SetDefaults_NetworkInterface(obj *VirtualMachineInstance)

func SetDefaults_PITTimer 

func SetDefaults_PITTimer(obj *PITTimer)

func SetDefaults_Probe 

func SetDefaults_Probe(probe *Probe)

func SetDefaults_RTCTimer 

func SetDefaults_RTCTimer(obj *RTCTimer)

func SetDefaults_SyNICTimer 

func SetDefaults_SyNICTimer(obj *SyNICTimer)

func SetDefaults_VirtualMachineInstance 

func SetDefaults_VirtualMachineInstance(obj *VirtualMachineInstance)

func SetDefaults_Watchdog 

func SetDefaults_Watchdog(obj *Watchdog)

func SetObjectDefaults_VirtualMachine 

func SetObjectDefaults_VirtualMachine(in *VirtualMachine)

func SetObjectDefaults_VirtualMachineInstance 

func SetObjectDefaults_VirtualMachineInstance(in *VirtualMachineInstance)

func SetObjectDefaults_VirtualMachineInstanceList 

func SetObjectDefaults_VirtualMachineInstanceList(in *VirtualMachineInstanceList)

func SetObjectDefaults_VirtualMachineInstancePreset 

func SetObjectDefaults_VirtualMachineInstancePreset(in *VirtualMachineInstancePreset)

func SetObjectDefaults_VirtualMachineInstancePresetList 

func SetObjectDefaults_VirtualMachineInstancePresetList(in *VirtualMachineInstancePresetList)

func SetObjectDefaults_VirtualMachineInstanceReplicaSet 

func SetObjectDefaults_VirtualMachineInstanceReplicaSet(in *VirtualMachineInstanceReplicaSet)

func SetObjectDefaults_VirtualMachineInstanceReplicaSetList 

func SetObjectDefaults_VirtualMachineInstanceReplicaSetList(in *VirtualMachineInstanceReplicaSetList)

func SetObjectDefaults_VirtualMachineList 

func SetObjectDefaults_VirtualMachineList(in *VirtualMachineList)

func UpdateAntiAffinityFromVMINode 

func UpdateAntiAffinityFromVMINode(pod *k8sv1.Pod, vmi *VirtualMachineInstance) *k8sv1.Affinity

Given a VirtualMachineInstance, update all NodeSelectorTerms with anti-affinity for that VirtualMachineInstance's node. This is useful for the case when a migration away from a node must occur. This method returns the full Affinity structure updated the anti affinity terms

Types

type AccessCredential 

type AccessCredential struct {
	// SSHPublicKey represents the source and method of applying a ssh public
	// key into a guest virtual machine.
	// +optional
	SSHPublicKey *SSHPublicKeyAccessCredential `json:"sshPublicKey,omitempty"`
	// UserPassword represents the source and method for applying a guest user's
	// password
	// +optional
	UserPassword *UserPasswordAccessCredential `json:"userPassword,omitempty"`
}

AccessCredential represents a credential source that can be used to authorize remote access to the vm guest Only one of its members may be specified.

func (*AccessCredential) DeepCopy 

func (in *AccessCredential) DeepCopy() *AccessCredential

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

func (*AccessCredential) DeepCopyInto 

func (in *AccessCredential) DeepCopyInto(out *AccessCredential)

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

func (AccessCredential) SwaggerDoc 

func (AccessCredential) SwaggerDoc() map[string]string

type AccessCredentialSecretSource 

type AccessCredentialSecretSource struct {
	// SecretName represents the name of the secret in the VMI's namespace
	SecretName string `json:"secretName"`
}

func (*AccessCredentialSecretSource) DeepCopy 

func (in *AccessCredentialSecretSource) DeepCopy() *AccessCredentialSecretSource

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

func (*AccessCredentialSecretSource) DeepCopyInto 

func (in *AccessCredentialSecretSource) DeepCopyInto(out *AccessCredentialSecretSource)

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

func (AccessCredentialSecretSource) SwaggerDoc 

func (AccessCredentialSecretSource) SwaggerDoc() map[string]string

type AddVolumeOptions 

type AddVolumeOptions struct {
	// Name represents the name that will be used to map the
	// disk to the corresponding volume. This overrides any name
	// set inside the Disk struct itself.
	Name string `json:"name"`
	// Disk represents the hotplug disk that will be plugged into the running VMI
	Disk *Disk `json:"disk"`
	// VolumeSource represents the source of the volume to map to the disk.
	VolumeSource *HotplugVolumeSource `json:"volumeSource"`
	// When present, indicates that modifications should not be
	// persisted. An invalid or unrecognized dryRun directive will
	// result in an error response and no further processing of the
	// request. Valid values are:
	// - All: all dry run stages will be processed
	// +optional
	// +listType=atomic
	DryRun []string `json:"dryRun,omitempty"`
}

AddVolumeOptions is provided when dynamically hot plugging a volume and disk

func (*AddVolumeOptions) DeepCopy 

func (in *AddVolumeOptions) DeepCopy() *AddVolumeOptions

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

func (*AddVolumeOptions) DeepCopyInto 

func (in *AddVolumeOptions) DeepCopyInto(out *AddVolumeOptions)

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

func (AddVolumeOptions) SwaggerDoc 

func (AddVolumeOptions) SwaggerDoc() map[string]string

type AuthorizedKeysFile 

type AuthorizedKeysFile struct {
	// FilePath represents the place on the guest that the authorized_keys
	// file should be writen to. This is expected to be a full path including
	// both the base directory and file name.
	FilePath string `json:"filePath"`
}

AuthorizedKeysFile represents a path within the guest that ssh public keys should be propagated to

func (*AuthorizedKeysFile) DeepCopy 

func (in *AuthorizedKeysFile) DeepCopy() *AuthorizedKeysFile

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

func (*AuthorizedKeysFile) DeepCopyInto 

func (in *AuthorizedKeysFile) DeepCopyInto(out *AuthorizedKeysFile)

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

func (AuthorizedKeysFile) SwaggerDoc 

func (AuthorizedKeysFile) SwaggerDoc() map[string]string

type BIOS 

type BIOS struct {
	// If set, the BIOS output will be transmitted over serial
	// +optional
	UseSerial *bool `json:"useSerial,omitempty"`
}

If set (default), BIOS will be used.

func (*BIOS) DeepCopy 

func (in *BIOS) DeepCopy() *BIOS

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

func (*BIOS) DeepCopyInto 

func (in *BIOS) DeepCopyInto(out *BIOS)

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

func (BIOS) SwaggerDoc 

func (BIOS) SwaggerDoc() map[string]string

type BlockSize 

type BlockSize struct {
	Custom      *CustomBlockSize `json:"custom,omitempty"`
	MatchVolume *FeatureState    `json:"matchVolume,omitempty"`
}

BlockSize provides the option to change the block size presented to the VM for a disk. Only one of its members may be specified.

func (*BlockSize) DeepCopy 

func (in *BlockSize) DeepCopy() *BlockSize

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

func (*BlockSize) DeepCopyInto 

func (in *BlockSize) DeepCopyInto(out *BlockSize)

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

func (BlockSize) SwaggerDoc 

func (BlockSize) SwaggerDoc() map[string]string

type Bootloader 

type Bootloader struct {
	// If set (default), BIOS will be used.
	// +optional
	BIOS *BIOS `json:"bios,omitempty"`
	// If set, EFI will be used instead of BIOS.
	// +optional
	EFI *EFI `json:"efi,omitempty"`
}

Represents the firmware blob used to assist in the domain creation process. Used for setting the QEMU BIOS file path for the libvirt domain.

func (*Bootloader) DeepCopy 

func (in *Bootloader) DeepCopy() *Bootloader

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

func (*Bootloader) DeepCopyInto 

func (in *Bootloader) DeepCopyInto(out *Bootloader)

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

func (Bootloader) SwaggerDoc 

func (Bootloader) SwaggerDoc() map[string]string

type CDRomTarget 

type CDRomTarget struct {
	// Bus indicates the type of disk device to emulate.
	// supported values: virtio, sata, scsi.
	Bus DiskBus `json:"bus,omitempty"`
	// ReadOnly.
	// Defaults to true.
	ReadOnly *bool `json:"readonly,omitempty"`
	// Tray indicates if the tray of the device is open or closed.
	// Allowed values are "open" and "closed".
	// Defaults to closed.
	// +optional
	Tray TrayState `json:"tray,omitempty"`
}

func (*CDRomTarget) DeepCopy 

func (in *CDRomTarget) DeepCopy() *CDRomTarget

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

func (*CDRomTarget) DeepCopyInto 

func (in *CDRomTarget) DeepCopyInto(out *CDRomTarget)

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

func (CDRomTarget) SwaggerDoc 

func (CDRomTarget) SwaggerDoc() map[string]string

type CPU 

type CPU struct {
	// Cores specifies the number of cores inside the vmi.
	// Must be a value greater or equal 1.
	Cores uint32 `json:"cores,omitempty"`
	// Sockets specifies the number of sockets inside the vmi.
	// Must be a value greater or equal 1.
	Sockets uint32 `json:"sockets,omitempty"`
	// Threads specifies the number of threads inside the vmi.
	// Must be a value greater or equal 1.
	Threads uint32 `json:"threads,omitempty"`
	// Model specifies the CPU model inside the VMI.
	// List of available models https://github.com/libvirt/libvirt/tree/master/src/cpu_map.
	// It is possible to specify special cases like "host-passthrough" to get the same CPU as the node
	// and "host-model" to get CPU closest to the node one.
	// Defaults to host-model.
	// +optional
	Model string `json:"model,omitempty"`
	// Features specifies the CPU features list inside the VMI.
	// +optional
	Features []CPUFeature `json:"features,omitempty"`
	// DedicatedCPUPlacement requests the scheduler to place the VirtualMachineInstance on a node
	// with enough dedicated pCPUs and pin the vCPUs to it.
	// +optional
	DedicatedCPUPlacement bool `json:"dedicatedCpuPlacement,omitempty"`

	// NUMA allows specifying settings for the guest NUMA topology
	// +optional
	NUMA *NUMA `json:"numa,omitempty"`

	// IsolateEmulatorThread requests one more dedicated pCPU to be allocated for the VMI to place
	// the emulator thread on it.
	// +optional
	IsolateEmulatorThread bool `json:"isolateEmulatorThread,omitempty"`
	// Realtime instructs the virt-launcher to tune the VMI for lower latency, optional for real time workloads
	// +optional
	Realtime *Realtime `json:"realtime,omitempty"`
}

CPU allows specifying the CPU topology.

func (*CPU) DeepCopy 

func (in *CPU) DeepCopy() *CPU

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

func (*CPU) DeepCopyInto 

func (in *CPU) DeepCopyInto(out *CPU)

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

func (CPU) SwaggerDoc 

func (CPU) SwaggerDoc() map[string]string

type CPUFeature 

type CPUFeature struct {
	// Name of the CPU feature
	Name string `json:"name"`
	// Policy is the CPU feature attribute which can have the following attributes:
	// force    - The virtual CPU will claim the feature is supported regardless of it being supported by host CPU.
	// require  - Guest creation will fail unless the feature is supported by the host CPU or the hypervisor is able to emulate it.
	// optional - The feature will be supported by virtual CPU if and only if it is supported by host CPU.
	// disable  - The feature will not be supported by virtual CPU.
	// forbid   - Guest creation will fail if the feature is supported by host CPU.
	// Defaults to require
	// +optional
	Policy string `json:"policy,omitempty"`
}

CPUFeature allows specifying a CPU feature.

func (*CPUFeature) DeepCopy 

func (in *CPUFeature) DeepCopy() *CPUFeature

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

func (*CPUFeature) DeepCopyInto 

func (in *CPUFeature) DeepCopyInto(out *CPUFeature)

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

func (CPUFeature) SwaggerDoc 

func (CPUFeature) SwaggerDoc() map[string]string

type CertConfig 

type CertConfig struct {
	// The requested 'duration' (i.e. lifetime) of the Certificate.
	Duration *metav1.Duration `json:"duration,omitempty"`

	// The amount of time before the currently issued certificate's "notAfter"
	// time that we will begin to attempt to renew the certificate.
	RenewBefore *metav1.Duration `json:"renewBefore,omitempty"`
}

CertConfig contains the tunables for TLS certificates

func (*CertConfig) DeepCopy 

func (in *CertConfig) DeepCopy() *CertConfig

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

func (*CertConfig) DeepCopyInto 

func (in *CertConfig) DeepCopyInto(out *CertConfig)

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

func (CertConfig) SwaggerDoc 

func (CertConfig) SwaggerDoc() map[string]string

type Chassis 

type Chassis struct {
	Manufacturer string `json:"manufacturer,omitempty"`
	Version      string `json:"version,omitempty"`
	Serial       string `json:"serial,omitempty"`
	Asset        string `json:"asset,omitempty"`
	Sku          string `json:"sku,omitempty"`
}

Chassis specifies the chassis info passed to the domain.

func (*Chassis) DeepCopy 

func (in *Chassis) DeepCopy() *Chassis

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

func (*Chassis) DeepCopyInto 

func (in *Chassis) DeepCopyInto(out *Chassis)

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

func (Chassis) SwaggerDoc 

func (Chassis) SwaggerDoc() map[string]string

type ClientPassthroughDevices 

type ClientPassthroughDevices struct {
}

Represent a subset of client devices that can be accessed by VMI. At the moment only, USB devices using Usbredir's library and tooling. Another fit would be a smartcard with libcacard.

The struct is currently empty as there is no immediate request for user-facing APIs. This structure simply turns on USB redirection of UsbClientPassthroughMaxNumberOf devices.

func (*ClientPassthroughDevices) DeepCopy 

func (in *ClientPassthroughDevices) DeepCopy() *ClientPassthroughDevices

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

func (*ClientPassthroughDevices) DeepCopyInto 

func (in *ClientPassthroughDevices) DeepCopyInto(out *ClientPassthroughDevices)

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

func (ClientPassthroughDevices) SwaggerDoc 

func (ClientPassthroughDevices) SwaggerDoc() map[string]string

type Clock 

type Clock struct {
	// ClockOffset allows specifying the UTC offset or the timezone of the guest clock.
	ClockOffset `json:",inline"`
	// Timer specifies whih timers are attached to the vmi.
	// +optional
	Timer *Timer `json:"timer"`
}

Represents the clock and timers of a vmi. +kubebuilder:pruning:PreserveUnknownFields

func (*Clock) DeepCopy 

func (in *Clock) DeepCopy() *Clock

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

func (*Clock) DeepCopyInto 

func (in *Clock) DeepCopyInto(out *Clock)

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

func (Clock) SwaggerDoc 

func (Clock) SwaggerDoc() map[string]string

type ClockOffset 

type ClockOffset struct {
	// UTC sets the guest clock to UTC on each boot. If an offset is specified,
	// guest changes to the clock will be kept during reboots and are not reset.
	UTC *ClockOffsetUTC `json:"utc,omitempty"`
	// Timezone sets the guest clock to the specified timezone.
	// Zone name follows the TZ environment variable format (e.g. 'America/New_York').
	Timezone *ClockOffsetTimezone `json:"timezone,omitempty"`
}

Exactly one of its members must be set.

func (*ClockOffset) DeepCopy 

func (in *ClockOffset) DeepCopy() *ClockOffset

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

func (*ClockOffset) DeepCopyInto 

func (in *ClockOffset) DeepCopyInto(out *ClockOffset)

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

func (ClockOffset) SwaggerDoc 

func (ClockOffset) SwaggerDoc() map[string]string

type ClockOffsetTimezone 

type ClockOffsetTimezone string

ClockOffsetTimezone sets the guest clock to the specified timezone. Zone name follows the TZ environment variable format (e.g. 'America/New_York').

type ClockOffsetUTC 

type ClockOffsetUTC struct {
	// OffsetSeconds specifies an offset in seconds, relative to UTC. If set,
	// guest changes to the clock will be kept during reboots and not reset.
	OffsetSeconds *int `json:"offsetSeconds,omitempty"`
}

UTC sets the guest clock to UTC on each boot.

func (*ClockOffsetUTC) DeepCopy 

func (in *ClockOffsetUTC) DeepCopy() *ClockOffsetUTC

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

func (*ClockOffsetUTC) DeepCopyInto 

func (in *ClockOffsetUTC) DeepCopyInto(out *ClockOffsetUTC)

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

func (ClockOffsetUTC) SwaggerDoc 

func (ClockOffsetUTC) SwaggerDoc() map[string]string

type CloudInitConfigDriveSource 

type CloudInitConfigDriveSource struct {
	// UserDataSecretRef references a k8s secret that contains config drive userdata.
	// + optional
	UserDataSecretRef *v1.LocalObjectReference `json:"secretRef,omitempty"`
	// UserDataBase64 contains config drive cloud-init userdata as a base64 encoded string.
	// + optional
	UserDataBase64 string `json:"userDataBase64,omitempty"`
	// UserData contains config drive inline cloud-init userdata.
	// + optional
	UserData string `json:"userData,omitempty"`
	// NetworkDataSecretRef references a k8s secret that contains config drive networkdata.
	// + optional
	NetworkDataSecretRef *v1.LocalObjectReference `json:"networkDataSecretRef,omitempty"`
	// NetworkDataBase64 contains config drive cloud-init networkdata as a base64 encoded string.
	// + optional
	NetworkDataBase64 string `json:"networkDataBase64,omitempty"`
	// NetworkData contains config drive inline cloud-init networkdata.
	// + optional
	NetworkData string `json:"networkData,omitempty"`
}

Represents a cloud-init config drive user data source. More info: https://cloudinit.readthedocs.io/en/latest/topics/datasources/configdrive.html

func (*CloudInitConfigDriveSource) DeepCopy 

func (in *CloudInitConfigDriveSource) DeepCopy() *CloudInitConfigDriveSource

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

func (*CloudInitConfigDriveSource) DeepCopyInto 

func (in *CloudInitConfigDriveSource) DeepCopyInto(out *CloudInitConfigDriveSource)

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

func (CloudInitConfigDriveSource) SwaggerDoc 

func (CloudInitConfigDriveSource) SwaggerDoc() map[string]string

type CloudInitNoCloudSource 

type CloudInitNoCloudSource struct {
	// UserDataSecretRef references a k8s secret that contains NoCloud userdata.
	// + optional
	UserDataSecretRef *v1.LocalObjectReference `json:"secretRef,omitempty"`
	// UserDataBase64 contains NoCloud cloud-init userdata as a base64 encoded string.
	// + optional
	UserDataBase64 string `json:"userDataBase64,omitempty"`
	// UserData contains NoCloud inline cloud-init userdata.
	// + optional
	UserData string `json:"userData,omitempty"`
	// NetworkDataSecretRef references a k8s secret that contains NoCloud networkdata.
	// + optional
	NetworkDataSecretRef *v1.LocalObjectReference `json:"networkDataSecretRef,omitempty"`
	// NetworkDataBase64 contains NoCloud cloud-init networkdata as a base64 encoded string.
	// + optional
	NetworkDataBase64 string `json:"networkDataBase64,omitempty"`
	// NetworkData contains NoCloud inline cloud-init networkdata.
	// + optional
	NetworkData string `json:"networkData,omitempty"`
}

Represents a cloud-init nocloud user data source. More info: http://cloudinit.readthedocs.io/en/latest/topics/datasources/nocloud.html

func (*CloudInitNoCloudSource) DeepCopy 

func (in *CloudInitNoCloudSource) DeepCopy() *CloudInitNoCloudSource

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

func (*CloudInitNoCloudSource) DeepCopyInto 

func (in *CloudInitNoCloudSource) DeepCopyInto(out *CloudInitNoCloudSource)

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

func (CloudInitNoCloudSource) SwaggerDoc 

func (CloudInitNoCloudSource) SwaggerDoc() map[string]string

type ClusterProfilerRequest 

type ClusterProfilerRequest struct {
	LabelSelector string `json:"labelSelector,omitempty"`
	Continue      string `json:"continue,omitempty"`
	PageSize      int64  `json:"pageSize"`
}

func (*ClusterProfilerRequest) DeepCopy 

func (in *ClusterProfilerRequest) DeepCopy() *ClusterProfilerRequest

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

func (*ClusterProfilerRequest) DeepCopyInto 

func (in *ClusterProfilerRequest) DeepCopyInto(out *ClusterProfilerRequest)

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

func (ClusterProfilerRequest) SwaggerDoc 

func (ClusterProfilerRequest) SwaggerDoc() map[string]string

type ClusterProfilerResults 

type ClusterProfilerResults struct {
	ComponentResults map[string]ProfilerResult `json:"componentResults"`
	Continue         string                    `json:"continue,omitempty"`
}

func (*ClusterProfilerResults) DeepCopy 

func (in *ClusterProfilerResults) DeepCopy() *ClusterProfilerResults

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

func (*ClusterProfilerResults) DeepCopyInto 

func (in *ClusterProfilerResults) DeepCopyInto(out *ClusterProfilerResults)

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

func (ClusterProfilerResults) SwaggerDoc 

func (ClusterProfilerResults) SwaggerDoc() map[string]string

type ComponentConfig 

type ComponentConfig struct {
	// nodePlacement describes scheduling configuration for specific
	// KubeVirt components
	//+optional
	NodePlacement *NodePlacement `json:"nodePlacement,omitempty"`
	// replicas indicates how many replicas should be created for each KubeVirt infrastructure
	// component (like virt-api or virt-controller). Defaults to 2.
	// WARNING: this is an advanced feature that prevents auto-scaling for core kubevirt components. Please use with caution!
	//+optional
	Replicas *uint8 `json:"replicas,omitempty"`
}

func (*ComponentConfig) DeepCopy 

func (in *ComponentConfig) DeepCopy() *ComponentConfig

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

func (*ComponentConfig) DeepCopyInto 

func (in *ComponentConfig) DeepCopyInto(out *ComponentConfig)

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

type ConfigDriveSSHPublicKeyAccessCredentialPropagation 

type ConfigDriveSSHPublicKeyAccessCredentialPropagation struct{}

func (*ConfigDriveSSHPublicKeyAccessCredentialPropagation) DeepCopy 

func (in *ConfigDriveSSHPublicKeyAccessCredentialPropagation) DeepCopy() *ConfigDriveSSHPublicKeyAccessCredentialPropagation

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

func (*ConfigDriveSSHPublicKeyAccessCredentialPropagation) DeepCopyInto 

func (in *ConfigDriveSSHPublicKeyAccessCredentialPropagation) DeepCopyInto(out *ConfigDriveSSHPublicKeyAccessCredentialPropagation)

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

func (ConfigDriveSSHPublicKeyAccessCredentialPropagation) SwaggerDoc 

func (ConfigDriveSSHPublicKeyAccessCredentialPropagation) SwaggerDoc() map[string]string

type ConfigMapVolumeSource 

type ConfigMapVolumeSource struct {
	v1.LocalObjectReference `json:",inline"`
	// Specify whether the ConfigMap or it's keys must be defined
	// +optional
	Optional *bool `json:"optional,omitempty"`
	// The volume label of the resulting disk inside the VMI.
	// Different bootstrapping mechanisms require different values.
	// Typical values are "cidata" (cloud-init), "config-2" (cloud-init) or "OEMDRV" (kickstart).
	// +optional
	VolumeLabel string `json:"volumeLabel,omitempty"`
}

ConfigMapVolumeSource adapts a ConfigMap into a volume. More info: https://kubernetes.io/docs/concepts/storage/volumes/#configmap

func (*ConfigMapVolumeSource) DeepCopy 

func (in *ConfigMapVolumeSource) DeepCopy() *ConfigMapVolumeSource

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

func (*ConfigMapVolumeSource) DeepCopyInto 

func (in *ConfigMapVolumeSource) DeepCopyInto(out *ConfigMapVolumeSource)

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

func (ConfigMapVolumeSource) SwaggerDoc 

func (ConfigMapVolumeSource) SwaggerDoc() map[string]string

type ContainerDiskSource 

type ContainerDiskSource struct {
	// Image is the name of the image with the embedded disk.
	Image string `json:"image"`
	// ImagePullSecret is the name of the Docker registry secret required to pull the image. The secret must already exist.
	ImagePullSecret string `json:"imagePullSecret,omitempty"`
	// Path defines the path to disk file in the container
	Path string `json:"path,omitempty"`
	// Image pull policy.
	// One of Always, Never, IfNotPresent.
	// Defaults to Always if :latest tag is specified, or IfNotPresent otherwise.
	// Cannot be updated.
	// More info: https://kubernetes.io/docs/concepts/containers/images#updating-images
	// +optional
	ImagePullPolicy v1.PullPolicy `json:"imagePullPolicy,omitempty"`
}

Represents a docker image with an embedded disk.

func (*ContainerDiskSource) DeepCopy 

func (in *ContainerDiskSource) DeepCopy() *ContainerDiskSource

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

func (*ContainerDiskSource) DeepCopyInto 

func (in *ContainerDiskSource) DeepCopyInto(out *ContainerDiskSource)

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

func (ContainerDiskSource) SwaggerDoc 

func (ContainerDiskSource) SwaggerDoc() map[string]string

type CustomBlockSize 

type CustomBlockSize struct {
	Logical  uint `json:"logical"`
	Physical uint `json:"physical"`
}

CustomBlockSize represents the desired logical and physical block size for a VM disk.

func (*CustomBlockSize) DeepCopy 

func (in *CustomBlockSize) DeepCopy() *CustomBlockSize

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

func (*CustomBlockSize) DeepCopyInto 

func (in *CustomBlockSize) DeepCopyInto(out *CustomBlockSize)

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

func (CustomBlockSize) SwaggerDoc 

func (CustomBlockSize) SwaggerDoc() map[string]string

type CustomizeComponents 

type CustomizeComponents struct {
	// +listType=atomic
	Patches []CustomizeComponentsPatch `json:"patches,omitempty"`

	// Configure the value used for deployment and daemonset resources
	Flags *Flags `json:"flags,omitempty"`
}

func (*CustomizeComponents) DeepCopy 

func (in *CustomizeComponents) DeepCopy() *CustomizeComponents

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

func (*CustomizeComponents) DeepCopyInto 

func (in *CustomizeComponents) DeepCopyInto(out *CustomizeComponents)

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

func (CustomizeComponents) SwaggerDoc 

func (CustomizeComponents) SwaggerDoc() map[string]string

type CustomizeComponentsPatch 

type CustomizeComponentsPatch struct {
	// +kubebuilder:validation:MinLength=1
	ResourceName string `json:"resourceName"`
	// +kubebuilder:validation:MinLength=1
	ResourceType string    `json:"resourceType"`
	Patch        string    `json:"patch"`
	Type         PatchType `json:"type"`
}

func (*CustomizeComponentsPatch) DeepCopy 

func (in *CustomizeComponentsPatch) DeepCopy() *CustomizeComponentsPatch

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

func (*CustomizeComponentsPatch) DeepCopyInto 

func (in *CustomizeComponentsPatch) DeepCopyInto(out *CustomizeComponentsPatch)

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

func (CustomizeComponentsPatch) SwaggerDoc 

func (CustomizeComponentsPatch) SwaggerDoc() map[string]string

type DHCPOptions 

type DHCPOptions struct {
	// If specified will pass option 67 to interface's DHCP server
	// +optional
	BootFileName string `json:"bootFileName,omitempty"`
	// If specified will pass option 66 to interface's DHCP server
	// +optional
	TFTPServerName string `json:"tftpServerName,omitempty"`
	// If specified will pass the configured NTP server to the VM via DHCP option 042.
	// +optional
	NTPServers []string `json:"ntpServers,omitempty"`
	// If specified will pass extra DHCP options for private use, range: 224-254
	// +optional
	PrivateOptions []DHCPPrivateOptions `json:"privateOptions,omitempty"`
}

Extra DHCP options to use in the interface.

func (*DHCPOptions) DeepCopy 

func (in *DHCPOptions) DeepCopy() *DHCPOptions

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

func (*DHCPOptions) DeepCopyInto 

func (in *DHCPOptions) DeepCopyInto(out *DHCPOptions)

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

func (DHCPOptions) SwaggerDoc 

func (DHCPOptions) SwaggerDoc() map[string]string

func (*DHCPOptions) UnmarshalJSON added in v0.49.1 

func (d *DHCPOptions) UnmarshalJSON(data []byte) error

type DHCPPrivateOptions 

type DHCPPrivateOptions struct {
	// Option is an Integer value from 224-254
	// Required.
	Option int `json:"option"`
	// Value is a String value for the Option provided
	// Required.
	Value string `json:"value"`
}

DHCPExtraOptions defines Extra DHCP options for a VM.

func (*DHCPPrivateOptions) DeepCopy 

func (in *DHCPPrivateOptions) DeepCopy() *DHCPPrivateOptions

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

func (*DHCPPrivateOptions) DeepCopyInto 

func (in *DHCPPrivateOptions) DeepCopyInto(out *DHCPPrivateOptions)

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

func (DHCPPrivateOptions) SwaggerDoc 

func (DHCPPrivateOptions) SwaggerDoc() map[string]string

type DataVolumeSource 

type DataVolumeSource struct {
	// Name represents the name of the DataVolume in the same namespace
	Name string `json:"name"`
	// Hotpluggable indicates whether the volume can be hotplugged and hotunplugged.
	// +optional
	Hotpluggable bool `json:"hotpluggable,omitempty"`
}

func (*DataVolumeSource) DeepCopy 

func (in *DataVolumeSource) DeepCopy() *DataVolumeSource

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

func (*DataVolumeSource) DeepCopyInto 

func (in *DataVolumeSource) DeepCopyInto(out *DataVolumeSource)

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

func (DataVolumeSource) SwaggerDoc 

func (DataVolumeSource) SwaggerDoc() map[string]string

type DataVolumeTemplateDummyStatus 

type DataVolumeTemplateDummyStatus struct{}

func (*DataVolumeTemplateDummyStatus) DeepCopy 

func (in *DataVolumeTemplateDummyStatus) DeepCopy() *DataVolumeTemplateDummyStatus

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

func (*DataVolumeTemplateDummyStatus) DeepCopyInto 

func (in *DataVolumeTemplateDummyStatus) DeepCopyInto(out *DataVolumeTemplateDummyStatus)

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

func (DataVolumeTemplateDummyStatus) SwaggerDoc 

func (DataVolumeTemplateDummyStatus) SwaggerDoc() map[string]string

type DataVolumeTemplateSpec 

type DataVolumeTemplateSpec struct {
	// TypeMeta only exists on DataVolumeTemplate for API backwards compatibility
	// this field is not used by our controllers and is a no-op.
	// +nullable
	metav1.TypeMeta `json:",inline"`
	// +kubebuilder:pruning:PreserveUnknownFields
	// +nullable
	metav1.ObjectMeta `json:"metadata,omitempty"`
	// DataVolumeSpec contains the DataVolume specification.
	Spec cdiv1.DataVolumeSpec `json:"spec"`

	// DataVolumeTemplateDummyStatus is here simply for backwards compatibility with
	// a previous API.
	// +nullable
	// +optional
	Status *DataVolumeTemplateDummyStatus `json:"status,omitempty"`
}

func (*DataVolumeTemplateSpec) DeepCopy 

func (in *DataVolumeTemplateSpec) DeepCopy() *DataVolumeTemplateSpec

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

func (*DataVolumeTemplateSpec) DeepCopyInto 

func (in *DataVolumeTemplateSpec) DeepCopyInto(out *DataVolumeTemplateSpec)

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

func (DataVolumeTemplateSpec) SwaggerDoc 

func (DataVolumeTemplateSpec) SwaggerDoc() map[string]string

type DeveloperConfiguration 

type DeveloperConfiguration struct {
	// FeatureGates is the list of experimental features to enable. Defaults to none
	FeatureGates []string `json:"featureGates,omitempty"`
	// LessPVCSpaceToleration determines how much smaller, in percentage, disk PVCs are
	// allowed to be compared to the requested size (to account for various overheads).
	// Defaults to 10
	LessPVCSpaceToleration int `json:"pvcTolerateLessSpaceUpToPercent,omitempty"`
	// MinimumReservePVCBytes is the amount of space, in bytes, to leave unused on disks.
	// Defaults to 131072 (128KiB)
	MinimumReservePVCBytes uint64 `json:"minimumReservePVCBytes,omitempty"`
	// MemoryOvercommit is the percentage of memory we want to give VMIs compared to the amount
	// given to its parent pod (virt-launcher). For example, a value of 102 means the VMI will
	// "see" 2% more memory than its parent pod. Values under 100 are effectively "undercommits".
	// Overcommits can lead to memory exhaustion, which in turn can lead to crashes. Use carefully.
	// Defaults to 100
	MemoryOvercommit int `json:"memoryOvercommit,omitempty"`
	// NodeSelectors allows restricting VMI creation to nodes that match a set of labels.
	// Defaults to none
	NodeSelectors map[string]string `json:"nodeSelectors,omitempty"`
	// UseEmulation can be set to true to allow fallback to software emulation
	// in case hardware-assisted emulation is not available. Defaults to false
	UseEmulation bool `json:"useEmulation,omitempty"`
	// For each requested virtual CPU, CPUAllocationRatio defines how much physical CPU to request per VMI
	// from the hosting node. The value is in fraction of a CPU thread (or core on non-hyperthreaded nodes).
	// For example, a value of 1 means 1 physical CPU thread per VMI CPU thread.
	// A value of 100 would be 1% of a physical thread allocated for each requested VMI thread.
	// This option has no effect on VMIs that request dedicated CPUs. More information at:
	// https://kubevirt.io/user-guide/operations/node_overcommit/#node-cpu-allocation-ratio
	// Defaults to 10
	CPUAllocationRatio int `json:"cpuAllocationRatio,omitempty"`
	// Allow overriding the automatically determined minimum TSC frequency of the cluster
	// and fixate the minimum to this frequency.
	MinimumClusterTSCFrequency *int64            `json:"minimumClusterTSCFrequency,omitempty"`
	DiskVerification           *DiskVerification `json:"diskVerification,omitempty"`
	LogVerbosity               *LogVerbosity     `json:"logVerbosity,omitempty"`
}

DeveloperConfiguration holds developer options

func (*DeveloperConfiguration) DeepCopy 

func (in *DeveloperConfiguration) DeepCopy() *DeveloperConfiguration

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

func (*DeveloperConfiguration) DeepCopyInto 

func (in *DeveloperConfiguration) DeepCopyInto(out *DeveloperConfiguration)

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

func (DeveloperConfiguration) SwaggerDoc 

func (DeveloperConfiguration) SwaggerDoc() map[string]string

type Devices 

type Devices struct {
	// Fall back to legacy virtio 0.9 support if virtio bus is selected on devices.
	// This is helpful for old machines like CentOS6 or RHEL6 which
	// do not understand virtio_non_transitional (virtio 1.0).
	UseVirtioTransitional *bool `json:"useVirtioTransitional,omitempty"`
	// DisableHotplug disabled the ability to hotplug disks.
	DisableHotplug bool `json:"disableHotplug,omitempty"`
	// Disks describes disks, cdroms and luns which are connected to the vmi.
	Disks []Disk `json:"disks,omitempty"`
	// Watchdog describes a watchdog device which can be added to the vmi.
	Watchdog *Watchdog `json:"watchdog,omitempty"`
	// Interfaces describe network interfaces which are added to the vmi.
	Interfaces []Interface `json:"interfaces,omitempty"`
	// Inputs describe input devices
	Inputs []Input `json:"inputs,omitempty"`
	// Whether to attach a pod network interface. Defaults to true.
	AutoattachPodInterface *bool `json:"autoattachPodInterface,omitempty"`
	// Whether to attach the default graphics device or not.
	// VNC will not be available if set to false. Defaults to true.
	AutoattachGraphicsDevice *bool `json:"autoattachGraphicsDevice,omitempty"`
	// Whether to attach the default serial console or not.
	// Serial console access will not be available if set to false. Defaults to true.
	AutoattachSerialConsole *bool `json:"autoattachSerialConsole,omitempty"`
	// Whether to attach the Memory balloon device with default period.
	// Period can be adjusted in virt-config.
	// Defaults to true.
	// +optional
	AutoattachMemBalloon *bool `json:"autoattachMemBalloon,omitempty"`
	// Whether to attach an Input Device.
	// Defaults to false.
	// +optional
	AutoattachInputDevice *bool `json:"autoattachInputDevice,omitempty"`
	// Whether to attach the VSOCK CID to the VM or not.
	// VSOCK access will be available if set to true. Defaults to false.
	AutoattachVSOCK *bool `json:"autoattachVSOCK,omitempty"`
	// Whether to have random number generator from host
	// +optional
	Rng *Rng `json:"rng,omitempty"`
	// Whether or not to enable virtio multi-queue for block devices.
	// Defaults to false.
	// +optional
	BlockMultiQueue *bool `json:"blockMultiQueue,omitempty"`
	// If specified, virtual network interfaces configured with a virtio bus will also enable the vhost multiqueue feature for network devices. The number of queues created depends on additional factors of the VirtualMachineInstance, like the number of guest CPUs.
	// +optional
	NetworkInterfaceMultiQueue *bool `json:"networkInterfaceMultiqueue,omitempty"`
	//Whether to attach a GPU device to the vmi.
	// +optional
	// +listType=atomic
	GPUs []GPU `json:"gpus,omitempty"`
	// Filesystems describes filesystem which is connected to the vmi.
	// +optional
	// +listType=atomic
	Filesystems []Filesystem `json:"filesystems,omitempty"`
	//Whether to attach a host device to the vmi.
	// +optional
	// +listType=atomic
	HostDevices []HostDevice `json:"hostDevices,omitempty"`
	// To configure and access client devices such as redirecting USB
	// +optional
	ClientPassthrough *ClientPassthroughDevices `json:"clientPassthrough,omitempty"`
	// Whether to emulate a sound device.
	// +optional
	Sound *SoundDevice `json:"sound,omitempty"`
	// Whether to emulate a TPM device.
	// +optional
	TPM *TPMDevice `json:"tpm,omitempty"`
}

func (*Devices) DeepCopy 

func (in *Devices) DeepCopy() *Devices

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

func (*Devices) DeepCopyInto 

func (in *Devices) DeepCopyInto(out *Devices)

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

func (Devices) SwaggerDoc 

func (Devices) SwaggerDoc() map[string]string

type Disk 

type Disk struct {
	// Name is the device name
	Name string `json:"name"`
	// DiskDevice specifies as which device the disk should be added to the guest.
	// Defaults to Disk.
	DiskDevice `json:",inline"`
	// BootOrder is an integer value > 0, used to determine ordering of boot devices.
	// Lower values take precedence.
	// Each disk or interface that has a boot order must have a unique value.
	// Disks without a boot order are not tried if a disk with a boot order exists.
	// +optional
	BootOrder *uint `json:"bootOrder,omitempty"`
	// Serial provides the ability to specify a serial number for the disk device.
	// +optional
	Serial string `json:"serial,omitempty"`
	// dedicatedIOThread indicates this disk should have an exclusive IO Thread.
	// Enabling this implies useIOThreads = true.
	// Defaults to false.
	// +optional
	DedicatedIOThread *bool `json:"dedicatedIOThread,omitempty"`
	// Cache specifies which kvm disk cache mode should be used.
	// Supported values are: CacheNone, CacheWriteThrough.
	// +optional
	Cache DriverCache `json:"cache,omitempty"`
	// IO specifies which QEMU disk IO mode should be used.
	// Supported values are: native, default, threads.
	// +optional
	IO DriverIO `json:"io,omitempty"`
	// If specified, disk address and its tag will be provided to the guest via config drive metadata
	// +optional
	Tag string `json:"tag,omitempty"`
	// If specified, the virtual disk will be presented with the given block sizes.
	// +optional
	BlockSize *BlockSize `json:"blockSize,omitempty"`
	// If specified the disk is made sharable and multiple write from different VMs are permitted
	// +optional
	Shareable *bool `json:"shareable,omitempty"`
}

func (*Disk) DeepCopy 

func (in *Disk) DeepCopy() *Disk

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

func (*Disk) DeepCopyInto 

func (in *Disk) DeepCopyInto(out *Disk)

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

func (Disk) SwaggerDoc 

func (Disk) SwaggerDoc() map[string]string

type DiskBus added in v0.53.0 

type DiskBus string
const (
	DiskBusSCSI   DiskBus = "scsi"
	DiskBusSATA   DiskBus = "sata"
	DiskBusVirtio DiskBus = VirtIO
	DiskBusUSB    DiskBus = "usb"
)

type DiskDevice 

type DiskDevice struct {
	// Attach a volume as a disk to the vmi.
	Disk *DiskTarget `json:"disk,omitempty"`
	// Attach a volume as a LUN to the vmi.
	LUN *LunTarget `json:"lun,omitempty"`
	// Attach a volume as a cdrom to the vmi.
	CDRom *CDRomTarget `json:"cdrom,omitempty"`
}

Represents the target of a volume to mount. Only one of its members may be specified.

func (*DiskDevice) DeepCopy 

func (in *DiskDevice) DeepCopy() *DiskDevice

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

func (*DiskDevice) DeepCopyInto 

func (in *DiskDevice) DeepCopyInto(out *DiskDevice)

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

func (DiskDevice) SwaggerDoc 

func (DiskDevice) SwaggerDoc() map[string]string

type DiskTarget 

type DiskTarget struct {
	// Bus indicates the type of disk device to emulate.
	// supported values: virtio, sata, scsi, usb.
	Bus DiskBus `json:"bus,omitempty"`
	// ReadOnly.
	// Defaults to false.
	ReadOnly bool `json:"readonly,omitempty"`
	// If specified, the virtual disk will be placed on the guests pci address with the specified PCI address. For example: 0000:81:01.10
	// +optional
	PciAddress string `json:"pciAddress,omitempty"`
}

func (*DiskTarget) DeepCopy 

func (in *DiskTarget) DeepCopy() *DiskTarget

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

func (*DiskTarget) DeepCopyInto 

func (in *DiskTarget) DeepCopyInto(out *DiskTarget)

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

func (DiskTarget) SwaggerDoc 

func (DiskTarget) SwaggerDoc() map[string]string

type DiskVerification 

type DiskVerification struct {
	MemoryLimit *resource.Quantity `json:"memoryLimit"`
}

DiskVerification holds container disks verification limits

func (*DiskVerification) DeepCopy 

func (in *DiskVerification) DeepCopy() *DiskVerification

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

func (*DiskVerification) DeepCopyInto 

func (in *DiskVerification) DeepCopyInto(out *DiskVerification)

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

func (DiskVerification) SwaggerDoc 

func (DiskVerification) SwaggerDoc() map[string]string

type DomainMemoryDumpInfo added in v0.54.0 

type DomainMemoryDumpInfo struct {
	// StartTimestamp is the time when the memory dump started
	StartTimestamp *metav1.Time `json:"startTimestamp,omitempty"`
	// EndTimestamp is the time when the memory dump completed
	EndTimestamp *metav1.Time `json:"endTimestamp,omitempty"`
	// ClaimName is the name of the pvc the memory was dumped to
	ClaimName string `json:"claimName,omitempty"`
	// TargetFileName is the name of the memory dump output
	TargetFileName string `json:"targetFileName,omitempty"`
}

DomainMemoryDumpInfo represents the memory dump information

func (*DomainMemoryDumpInfo) DeepCopy added in v0.54.0 

func (in *DomainMemoryDumpInfo) DeepCopy() *DomainMemoryDumpInfo

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

func (*DomainMemoryDumpInfo) DeepCopyInto added in v0.54.0 

func (in *DomainMemoryDumpInfo) DeepCopyInto(out *DomainMemoryDumpInfo)

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

func (DomainMemoryDumpInfo) SwaggerDoc added in v0.54.0 

func (DomainMemoryDumpInfo) SwaggerDoc() map[string]string

type DomainSpec 

type DomainSpec struct {
	// Resources describes the Compute Resources required by this vmi.
	Resources ResourceRequirements `json:"resources,omitempty"`
	// CPU allow specified the detailed CPU topology inside the vmi.
	// +optional
	CPU *CPU `json:"cpu,omitempty"`
	// Memory allow specifying the VMI memory features.
	// +optional
	Memory *Memory `json:"memory,omitempty"`
	// Machine type.
	// +optional
	Machine *Machine `json:"machine,omitempty"`
	// Firmware.
	// +optional
	Firmware *Firmware `json:"firmware,omitempty"`
	// Clock sets the clock and timers of the vmi.
	// +optional
	Clock *Clock `json:"clock,omitempty"`
	// Features like acpi, apic, hyperv, smm.
	// +optional
	Features *Features `json:"features,omitempty"`
	// Devices allows adding disks, network interfaces, and others
	Devices Devices `json:"devices"`
	// Controls whether or not disks will share IOThreads.
	// Omitting IOThreadsPolicy disables use of IOThreads.
	// One of: shared, auto
	// +optional
	IOThreadsPolicy *IOThreadsPolicy `json:"ioThreadsPolicy,omitempty"`
	// Chassis specifies the chassis info passed to the domain.
	// +optional
	Chassis *Chassis `json:"chassis,omitempty"`
	// Launch Security setting of the vmi.
	// +optional
	LaunchSecurity *LaunchSecurity `json:"launchSecurity,omitempty"`
}

func (*DomainSpec) DeepCopy 

func (in *DomainSpec) DeepCopy() *DomainSpec

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

func (*DomainSpec) DeepCopyInto 

func (in *DomainSpec) DeepCopyInto(out *DomainSpec)

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

func (DomainSpec) SwaggerDoc 

func (DomainSpec) SwaggerDoc() map[string]string

type DownwardAPIVolumeSource 

type DownwardAPIVolumeSource struct {
	// Fields is a list of downward API volume file
	// +optional
	Fields []v1.DownwardAPIVolumeFile `json:"fields,omitempty"`
	// The volume label of the resulting disk inside the VMI.
	// Different bootstrapping mechanisms require different values.
	// Typical values are "cidata" (cloud-init), "config-2" (cloud-init) or "OEMDRV" (kickstart).
	// +optional
	VolumeLabel string `json:"volumeLabel,omitempty"`
}

DownwardAPIVolumeSource represents a volume containing downward API info.

func (*DownwardAPIVolumeSource) DeepCopy 

func (in *DownwardAPIVolumeSource) DeepCopy() *DownwardAPIVolumeSource

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

func (*DownwardAPIVolumeSource) DeepCopyInto 

func (in *DownwardAPIVolumeSource) DeepCopyInto(out *DownwardAPIVolumeSource)

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

func (DownwardAPIVolumeSource) SwaggerDoc 

func (DownwardAPIVolumeSource) SwaggerDoc() map[string]string

type DownwardMetricsVolumeSource 

type DownwardMetricsVolumeSource struct {
}

DownwardMetricsVolumeSource adds a very small disk to VMIs which contains a limited view of host and guest metrics. The disk content is compatible with vhostmd (https://github.com/vhostmd/vhostmd) and vm-dump-metrics.

func (*DownwardMetricsVolumeSource) DeepCopy 

func (in *DownwardMetricsVolumeSource) DeepCopy() *DownwardMetricsVolumeSource

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

func (*DownwardMetricsVolumeSource) DeepCopyInto 

func (in *DownwardMetricsVolumeSource) DeepCopyInto(out *DownwardMetricsVolumeSource)

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

func (DownwardMetricsVolumeSource) SwaggerDoc 

func (DownwardMetricsVolumeSource) SwaggerDoc() map[string]string

type DriverCache 

type DriverCache string

type DriverIO 

type DriverIO string

type EFI 

type EFI struct {
	// If set, SecureBoot will be enabled and the OVMF roms will be swapped for
	// SecureBoot-enabled ones.
	// Requires SMM to be enabled.
	// Defaults to true
	// +optional
	SecureBoot *bool `json:"secureBoot,omitempty"`
}

If set, EFI will be used instead of BIOS.

func (*EFI) DeepCopy 

func (in *EFI) DeepCopy() *EFI

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

func (*EFI) DeepCopyInto 

func (in *EFI) DeepCopyInto(out *EFI)

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

func (EFI) SwaggerDoc 

func (EFI) SwaggerDoc() map[string]string

type EmptyDiskSource 

type EmptyDiskSource struct {
	// Capacity of the sparse disk.
	Capacity resource.Quantity `json:"capacity"`
}

EmptyDisk represents a temporary disk which shares the vmis lifecycle.

func (*EmptyDiskSource) DeepCopy 

func (in *EmptyDiskSource) DeepCopy() *EmptyDiskSource

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

func (*EmptyDiskSource) DeepCopyInto 

func (in *EmptyDiskSource) DeepCopyInto(out *EmptyDiskSource)

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

func (EmptyDiskSource) SwaggerDoc 

func (EmptyDiskSource) SwaggerDoc() map[string]string

type EphemeralVolumeSource 

type EphemeralVolumeSource struct {
	// PersistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace.
	// Directly attached to the vmi via qemu.
	// More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims
	// +optional
	PersistentVolumeClaim *v1.PersistentVolumeClaimVolumeSource `json:"persistentVolumeClaim,omitempty"`
}

func (*EphemeralVolumeSource) DeepCopy 

func (in *EphemeralVolumeSource) DeepCopy() *EphemeralVolumeSource

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

func (*EphemeralVolumeSource) DeepCopyInto 

func (in *EphemeralVolumeSource) DeepCopyInto(out *EphemeralVolumeSource)

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

func (EphemeralVolumeSource) SwaggerDoc 

func (EphemeralVolumeSource) SwaggerDoc() map[string]string

type EvictionStrategy 

type EvictionStrategy string
const (
	EvictionStrategyNone        EvictionStrategy = "None"
	EvictionStrategyLiveMigrate EvictionStrategy = "LiveMigrate"
	EvictionStrategyExternal    EvictionStrategy = "External"
)

type FeatureAPIC 

type FeatureAPIC struct {
	// Enabled determines if the feature should be enabled or disabled on the guest.
	// Defaults to true.
	// +optional
	Enabled *bool `json:"enabled,omitempty"`
	// EndOfInterrupt enables the end of interrupt notification in the guest.
	// Defaults to false.
	// +optional
	EndOfInterrupt bool `json:"endOfInterrupt,omitempty"`
}

func (*FeatureAPIC) DeepCopy 

func (in *FeatureAPIC) DeepCopy() *FeatureAPIC

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

func (*FeatureAPIC) DeepCopyInto 

func (in *FeatureAPIC) DeepCopyInto(out *FeatureAPIC)

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

func (FeatureAPIC) SwaggerDoc 

func (FeatureAPIC) SwaggerDoc() map[string]string

type FeatureHyperv 

type FeatureHyperv struct {
	// Relaxed instructs the guest OS to disable watchdog timeouts.
	// Defaults to the machine type setting.
	// +optional
	Relaxed *FeatureState `json:"relaxed,omitempty"`
	// VAPIC improves the paravirtualized handling of interrupts.
	// Defaults to the machine type setting.
	// +optional
	VAPIC *FeatureState `json:"vapic,omitempty"`
	// Spinlocks allows to configure the spinlock retry attempts.
	// +optional
	Spinlocks *FeatureSpinlocks `json:"spinlocks,omitempty"`
	// VPIndex enables the Virtual Processor Index to help windows identifying virtual processors.
	// Defaults to the machine type setting.
	// +optional
	VPIndex *FeatureState `json:"vpindex,omitempty"`
	// Runtime improves the time accounting to improve scheduling in the guest.
	// Defaults to the machine type setting.
	// +optional
	Runtime *FeatureState `json:"runtime,omitempty"`
	// SyNIC enables the Synthetic Interrupt Controller.
	// Defaults to the machine type setting.
	// +optional
	SyNIC *FeatureState `json:"synic,omitempty"`
	// SyNICTimer enables Synthetic Interrupt Controller Timers, reducing CPU load.
	// Defaults to the machine type setting.
	// +optional
	SyNICTimer *SyNICTimer `json:"synictimer,omitempty"`
	// Reset enables Hyperv reboot/reset for the vmi. Requires synic.
	// Defaults to the machine type setting.
	// +optional
	Reset *FeatureState `json:"reset,omitempty"`
	// VendorID allows setting the hypervisor vendor id.
	// Defaults to the machine type setting.
	// +optional
	VendorID *FeatureVendorID `json:"vendorid,omitempty"`
	// Frequencies improves the TSC clock source handling for Hyper-V on KVM.
	// Defaults to the machine type setting.
	// +optional
	Frequencies *FeatureState `json:"frequencies,omitempty"`
	// Reenlightenment enables the notifications on TSC frequency changes.
	// Defaults to the machine type setting.
	// +optional
	Reenlightenment *FeatureState `json:"reenlightenment,omitempty"`
	// TLBFlush improves performances in overcommited environments. Requires vpindex.
	// Defaults to the machine type setting.
	// +optional
	TLBFlush *FeatureState `json:"tlbflush,omitempty"`
	// IPI improves performances in overcommited environments. Requires vpindex.
	// Defaults to the machine type setting.
	// +optional
	IPI *FeatureState `json:"ipi,omitempty"`
	// EVMCS Speeds up L2 vmexits, but disables other virtualization features. Requires vapic.
	// Defaults to the machine type setting.
	// +optional
	EVMCS *FeatureState `json:"evmcs,omitempty"`
}

Hyperv specific features.

func (*FeatureHyperv) DeepCopy 

func (in *FeatureHyperv) DeepCopy() *FeatureHyperv

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

func (*FeatureHyperv) DeepCopyInto 

func (in *FeatureHyperv) DeepCopyInto(out *FeatureHyperv)

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

func (FeatureHyperv) SwaggerDoc 

func (FeatureHyperv) SwaggerDoc() map[string]string

type FeatureKVM 

type FeatureKVM struct {
	// Hide the KVM hypervisor from standard MSR based discovery.
	// Defaults to false
	Hidden bool `json:"hidden,omitempty"`
}

func (*FeatureKVM) DeepCopy 

func (in *FeatureKVM) DeepCopy() *FeatureKVM

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

func (*FeatureKVM) DeepCopyInto 

func (in *FeatureKVM) DeepCopyInto(out *FeatureKVM)

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

func (FeatureKVM) SwaggerDoc 

func (FeatureKVM) SwaggerDoc() map[string]string

type FeatureSpinlocks 

type FeatureSpinlocks struct {
	// Enabled determines if the feature should be enabled or disabled on the guest.
	// Defaults to true.
	// +optional
	Enabled *bool `json:"enabled,omitempty"`
	// Retries indicates the number of retries.
	// Must be a value greater or equal 4096.
	// Defaults to 4096.
	// +optional
	Retries *uint32 `json:"spinlocks,omitempty"`
}

func (*FeatureSpinlocks) DeepCopy 

func (in *FeatureSpinlocks) DeepCopy() *FeatureSpinlocks

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

func (*FeatureSpinlocks) DeepCopyInto 

func (in *FeatureSpinlocks) DeepCopyInto(out *FeatureSpinlocks)

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

func (FeatureSpinlocks) SwaggerDoc 

func (FeatureSpinlocks) SwaggerDoc() map[string]string

type FeatureState 

type FeatureState struct {
	// Enabled determines if the feature should be enabled or disabled on the guest.
	// Defaults to true.
	// +optional
	Enabled *bool `json:"enabled,omitempty"`
}

Represents if a feature is enabled or disabled.

func (*FeatureState) DeepCopy 

func (in *FeatureState) DeepCopy() *FeatureState

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

func (*FeatureState) DeepCopyInto 

func (in *FeatureState) DeepCopyInto(out *FeatureState)

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

func (FeatureState) SwaggerDoc 

func (FeatureState) SwaggerDoc() map[string]string

type FeatureVendorID 

type FeatureVendorID struct {
	// Enabled determines if the feature should be enabled or disabled on the guest.
	// Defaults to true.
	// +optional
	Enabled *bool `json:"enabled,omitempty"`
	// VendorID sets the hypervisor vendor id, visible to the vmi.
	// String up to twelve characters.
	VendorID string `json:"vendorid,omitempty"`
}

func (*FeatureVendorID) DeepCopy 

func (in *FeatureVendorID) DeepCopy() *FeatureVendorID

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

func (*FeatureVendorID) DeepCopyInto 

func (in *FeatureVendorID) DeepCopyInto(out *FeatureVendorID)

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

func (FeatureVendorID) SwaggerDoc 

func (FeatureVendorID) SwaggerDoc() map[string]string

type Features 

type Features struct {
	// ACPI enables/disables ACPI inside the guest.
	// Defaults to enabled.
	// +optional
	ACPI FeatureState `json:"acpi,omitempty"`
	// Defaults to the machine type setting.
	// +optional
	APIC *FeatureAPIC `json:"apic,omitempty"`
	// Defaults to the machine type setting.
	// +optional
	Hyperv *FeatureHyperv `json:"hyperv,omitempty"`
	// SMM enables/disables System Management Mode.
	// TSEG not yet implemented.
	// +optional
	SMM *FeatureState `json:"smm,omitempty"`
	// Configure how KVM presence is exposed to the guest.
	// +optional
	KVM *FeatureKVM `json:"kvm,omitempty"`
	// Notify the guest that the host supports paravirtual spinlocks.
	// For older kernels this feature should be explicitly disabled.
	// +optional
	Pvspinlock *FeatureState `json:"pvspinlock,omitempty"`
}

func (*Features) DeepCopy 

func (in *Features) DeepCopy() *Features

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

func (*Features) DeepCopyInto 

func (in *Features) DeepCopyInto(out *Features)

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

func (Features) SwaggerDoc 

func (Features) SwaggerDoc() map[string]string

type Filesystem 

type Filesystem struct {
	// Name is the device name
	Name string `json:"name"`
	// Virtiofs is supported
	Virtiofs *FilesystemVirtiofs `json:"virtiofs"`
}

func (*Filesystem) DeepCopy 

func (in *Filesystem) DeepCopy() *Filesystem

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

func (*Filesystem) DeepCopyInto 

func (in *Filesystem) DeepCopyInto(out *Filesystem)

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

func (Filesystem) SwaggerDoc 

func (Filesystem) SwaggerDoc() map[string]string

type FilesystemVirtiofs 

type FilesystemVirtiofs struct{}

func (*FilesystemVirtiofs) DeepCopy 

func (in *FilesystemVirtiofs) DeepCopy() *FilesystemVirtiofs

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

func (*FilesystemVirtiofs) DeepCopyInto 

func (in *FilesystemVirtiofs) DeepCopyInto(out *FilesystemVirtiofs)

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

func (FilesystemVirtiofs) SwaggerDoc 

func (FilesystemVirtiofs) SwaggerDoc() map[string]string

type Firmware 

type Firmware struct {
	// UUID reported by the vmi bios.
	// Defaults to a random generated uid.
	UUID types.UID `json:"uuid,omitempty"`
	// Settings to control the bootloader that is used.
	// +optional
	Bootloader *Bootloader `json:"bootloader,omitempty"`
	// The system-serial-number in SMBIOS
	Serial string `json:"serial,omitempty"`
	// Settings to set the kernel for booting.
	// +optional
	KernelBoot *KernelBoot `json:"kernelBoot,omitempty"`
}

func (*Firmware) DeepCopy 

func (in *Firmware) DeepCopy() *Firmware

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

func (*Firmware) DeepCopyInto 

func (in *Firmware) DeepCopyInto(out *Firmware)

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

func (Firmware) SwaggerDoc 

func (Firmware) SwaggerDoc() map[string]string

type Flags 

type Flags struct {
	API        map[string]string `json:"api,omitempty"`
	Controller map[string]string `json:"controller,omitempty"`
	Handler    map[string]string `json:"handler,omitempty"`
}

Flags will create a patch that will replace all flags for the container's command field. The only flags that will be used are those define. There are no guarantees around forward/backward compatibility. If set incorrectly this will cause the resource when rolled out to error until flags are updated.

func (*Flags) DeepCopy 

func (in *Flags) DeepCopy() *Flags

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

func (*Flags) DeepCopyInto 

func (in *Flags) DeepCopyInto(out *Flags)

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

func (Flags) SwaggerDoc 

func (Flags) SwaggerDoc() map[string]string

type FreezeUnfreezeTimeout 

type FreezeUnfreezeTimeout struct {
	UnfreezeTimeout *metav1.Duration `json:"unfreezeTimeout"`
}

FreezeUnfreezeTimeout represent the time unfreeze will be triggered if guest was not unfrozen by unfreeze command

func (*FreezeUnfreezeTimeout) DeepCopy 

func (in *FreezeUnfreezeTimeout) DeepCopy() *FreezeUnfreezeTimeout

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

func (*FreezeUnfreezeTimeout) DeepCopyInto 

func (in *FreezeUnfreezeTimeout) DeepCopyInto(out *FreezeUnfreezeTimeout)

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

func (FreezeUnfreezeTimeout) SwaggerDoc 

func (FreezeUnfreezeTimeout) SwaggerDoc() map[string]string

type GPU 

type GPU struct {
	// Name of the GPU device as exposed by a device plugin
	Name              string       `json:"name"`
	DeviceName        string       `json:"deviceName"`
	VirtualGPUOptions *VGPUOptions `json:"virtualGPUOptions,omitempty"`
	// If specified, the virtual network interface address and its tag will be provided to the guest via config drive
	// +optional
	Tag string `json:"tag,omitempty"`
}

func (*GPU) DeepCopy 

func (in *GPU) DeepCopy() *GPU

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

func (*GPU) DeepCopyInto 

func (in *GPU) DeepCopyInto(out *GPU)

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

func (GPU) SwaggerDoc 

func (GPU) SwaggerDoc() map[string]string

type GenerationStatus 

type GenerationStatus struct {
	// group is the group of the thing you're tracking
	Group string `json:"group"`
	// resource is the resource type of the thing you're tracking
	Resource string `json:"resource"`
	// namespace is where the thing you're tracking is
	// +optional
	Namespace string `json:"namespace,omitempty" optional:"true"`
	// name is the name of the thing you're tracking
	Name string `json:"name"`
	// lastGeneration is the last generation of the workload controller involved
	LastGeneration int64 `json:"lastGeneration"`
	// hash is an optional field set for resources without generation that are content sensitive like secrets and configmaps
	// +optional
	Hash string `json:"hash,omitempty" optional:"true"`
}

GenerationStatus keeps track of the generation for a given resource so that decisions about forced updates can be made.

func (*GenerationStatus) DeepCopy 

func (in *GenerationStatus) DeepCopy() *GenerationStatus

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

func (*GenerationStatus) DeepCopyInto 

func (in *GenerationStatus) DeepCopyInto(out *GenerationStatus)

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

func (GenerationStatus) SwaggerDoc 

func (GenerationStatus) SwaggerDoc() map[string]string

type GuestAgentCommandInfo 

type GuestAgentCommandInfo struct {
	Name    string `json:"name"`
	Enabled bool   `json:"enabled,omitempty"`
}

List of commands that QEMU guest agent supports

func (*GuestAgentCommandInfo) DeepCopy 

func (in *GuestAgentCommandInfo) DeepCopy() *GuestAgentCommandInfo

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

func (*GuestAgentCommandInfo) DeepCopyInto 

func (in *GuestAgentCommandInfo) DeepCopyInto(out *GuestAgentCommandInfo)

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

func (GuestAgentCommandInfo) SwaggerDoc 

func (GuestAgentCommandInfo) SwaggerDoc() map[string]string

type GuestAgentPing 

type GuestAgentPing struct {
}

GuestAgentPing configures the guest-agent based ping probe

func (*GuestAgentPing) DeepCopy 

func (in *GuestAgentPing) DeepCopy() *GuestAgentPing

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

func (*GuestAgentPing) DeepCopyInto 

func (in *GuestAgentPing) DeepCopyInto(out *GuestAgentPing)

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

func (GuestAgentPing) SwaggerDoc 

func (GuestAgentPing) SwaggerDoc() map[string]string

type HPETTickPolicy 

type HPETTickPolicy string

HPETTickPolicy determines what happens when QEMU misses a deadline for injecting a tick to the guest.

type HPETTimer 

type HPETTimer struct {
	// TickPolicy determines what happens when QEMU misses a deadline for injecting a tick to the guest.
	// One of "delay", "catchup", "merge", "discard".
	TickPolicy HPETTickPolicy `json:"tickPolicy,omitempty"`
	// Enabled set to false makes sure that the machine type or a preset can't add the timer.
	// Defaults to true.
	// +optional
	Enabled *bool `json:"present,omitempty"`
}

func (*HPETTimer) DeepCopy 

func (in *HPETTimer) DeepCopy() *HPETTimer

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

func (*HPETTimer) DeepCopyInto 

func (in *HPETTimer) DeepCopyInto(out *HPETTimer)

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

func (HPETTimer) SwaggerDoc 

func (HPETTimer) SwaggerDoc() map[string]string

type Handler 

type Handler struct {
	// One and only one of the following should be specified.
	// Exec specifies the action to take, it will be executed on the guest through the qemu-guest-agent.
	// If the guest agent is not available, this probe will fail.
	// +optional
	Exec *k8sv1.ExecAction `json:"exec,omitempty" protobuf:"bytes,1,opt,name=exec"`
	// GuestAgentPing contacts the qemu-guest-agent for availability checks.
	// +optional
	GuestAgentPing *GuestAgentPing `json:"guestAgentPing,omitempty"`
	// HTTPGet specifies the http request to perform.
	// +optional
	HTTPGet *k8sv1.HTTPGetAction `json:"httpGet,omitempty"`
	// TCPSocket specifies an action involving a TCP port.
	// TCP hooks not yet supported
	// TODO: implement a realistic TCP lifecycle hook
	// +optional
	TCPSocket *k8sv1.TCPSocketAction `json:"tcpSocket,omitempty"`
}

Handler defines a specific action that should be taken TODO: pass structured data to these actions, and document that data here.

func (*Handler) DeepCopy 

func (in *Handler) DeepCopy() *Handler

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

func (*Handler) DeepCopyInto 

func (in *Handler) DeepCopyInto(out *Handler)

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

func (Handler) SwaggerDoc 

func (Handler) SwaggerDoc() map[string]string

type HostDevice 

type HostDevice struct {
	Name string `json:"name"`
	// DeviceName is the resource name of the host device exposed by a device plugin
	DeviceName string `json:"deviceName"`
	// If specified, the virtual network interface address and its tag will be provided to the guest via config drive
	// +optional
	Tag string `json:"tag,omitempty"`
}

func (*HostDevice) DeepCopy 

func (in *HostDevice) DeepCopy() *HostDevice

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

func (*HostDevice) DeepCopyInto 

func (in *HostDevice) DeepCopyInto(out *HostDevice)

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

func (HostDevice) SwaggerDoc 

func (HostDevice) SwaggerDoc() map[string]string

type HostDisk 

type HostDisk struct {
	// The path to HostDisk image located on the cluster
	Path string `json:"path"`
	// Contains information if disk.img exists or should be created
	// allowed options are 'Disk' and 'DiskOrCreate'
	Type HostDiskType `json:"type"`
	// Capacity of the sparse disk
	// +optional
	Capacity resource.Quantity `json:"capacity,omitempty"`
	// Shared indicate whether the path is shared between nodes
	Shared *bool `json:"shared,omitempty"`
}

Represents a disk created on the cluster level

func (*HostDisk) DeepCopy 

func (in *HostDisk) DeepCopy() *HostDisk

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

func (*HostDisk) DeepCopyInto 

func (in *HostDisk) DeepCopyInto(out *HostDisk)

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

func (HostDisk) SwaggerDoc 

func (HostDisk) SwaggerDoc() map[string]string

type HostDiskType 

type HostDiskType string
const (
	// if disk does not exist at the given path,
	// a disk image will be created there
	HostDiskExistsOrCreate HostDiskType = "DiskOrCreate"
	// a disk image must exist at given disk path
	HostDiskExists HostDiskType = "Disk"
)

type HotplugVolumeSource 

type HotplugVolumeSource struct {
	// PersistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace.
	// Directly attached to the vmi via qemu.
	// More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims
	// +optional
	PersistentVolumeClaim *PersistentVolumeClaimVolumeSource `json:"persistentVolumeClaim,omitempty"`
	// DataVolume represents the dynamic creation a PVC for this volume as well as
	// the process of populating that PVC with a disk image.
	// +optional
	DataVolume *DataVolumeSource `json:"dataVolume,omitempty"`
}

HotplugVolumeSource Represents the source of a volume to mount which are capable of being hotplugged on a live running VMI. Only one of its members may be specified.

func (*HotplugVolumeSource) DeepCopy 

func (in *HotplugVolumeSource) DeepCopy() *HotplugVolumeSource

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

func (*HotplugVolumeSource) DeepCopyInto 

func (in *HotplugVolumeSource) DeepCopyInto(out *HotplugVolumeSource)

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

func (HotplugVolumeSource) SwaggerDoc 

func (HotplugVolumeSource) SwaggerDoc() map[string]string

type HotplugVolumeStatus 

type HotplugVolumeStatus struct {
	// AttachPodName is the name of the pod used to attach the volume to the node.
	AttachPodName string `json:"attachPodName,omitempty"`
	// AttachPodUID is the UID of the pod used to attach the volume to the node.
	AttachPodUID types.UID `json:"attachPodUID,omitempty"`
}

HotplugVolumeStatus represents the hotplug status of the volume

func (*HotplugVolumeStatus) DeepCopy 

func (in *HotplugVolumeStatus) DeepCopy() *HotplugVolumeStatus

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

func (*HotplugVolumeStatus) DeepCopyInto 

func (in *HotplugVolumeStatus) DeepCopyInto(out *HotplugVolumeStatus)

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

func (HotplugVolumeStatus) SwaggerDoc 

func (HotplugVolumeStatus) SwaggerDoc() map[string]string

type Hugepages 

type Hugepages struct {
	// PageSize specifies the hugepage size, for x86_64 architecture valid values are 1Gi and 2Mi.
	PageSize string `json:"pageSize,omitempty"`
}

Hugepages allow to use hugepages for the VirtualMachineInstance instead of regular memory.

func (*Hugepages) DeepCopy 

func (in *Hugepages) DeepCopy() *Hugepages

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

func (*Hugepages) DeepCopyInto 

func (in *Hugepages) DeepCopyInto(out *Hugepages)

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

func (Hugepages) SwaggerDoc 

func (Hugepages) SwaggerDoc() map[string]string

type HypervTimer 

type HypervTimer struct {
	// Enabled set to false makes sure that the machine type or a preset can't add the timer.
	// Defaults to true.
	// +optional
	Enabled *bool `json:"present,omitempty"`
}

func (*HypervTimer) DeepCopy 

func (in *HypervTimer) DeepCopy() *HypervTimer

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

func (*HypervTimer) DeepCopyInto 

func (in *HypervTimer) DeepCopyInto(out *HypervTimer)

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

func (HypervTimer) SwaggerDoc 

func (HypervTimer) SwaggerDoc() map[string]string

type I6300ESBWatchdog 

type I6300ESBWatchdog struct {
	// The action to take. Valid values are poweroff, reset, shutdown.
	// Defaults to reset.
	Action WatchdogAction `json:"action,omitempty"`
}

i6300esb watchdog device.

func (*I6300ESBWatchdog) DeepCopy 

func (in *I6300ESBWatchdog) DeepCopy() *I6300ESBWatchdog

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

func (*I6300ESBWatchdog) DeepCopyInto 

func (in *I6300ESBWatchdog) DeepCopyInto(out *I6300ESBWatchdog)

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

func (I6300ESBWatchdog) SwaggerDoc 

func (I6300ESBWatchdog) SwaggerDoc() map[string]string

type IOThreadsPolicy 

type IOThreadsPolicy string

type Input 

type Input struct {
	// Bus indicates the bus of input device to emulate.
	// Supported values: virtio, usb.
	Bus InputBus `json:"bus,omitempty"`
	// Type indicated the type of input device.
	// Supported values: tablet.
	Type InputType `json:"type"`
	// Name is the device name
	Name string `json:"name"`
}

func (*Input) DeepCopy 

func (in *Input) DeepCopy() *Input

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

func (*Input) DeepCopyInto 

func (in *Input) DeepCopyInto(out *Input)

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

func (Input) SwaggerDoc 

func (Input) SwaggerDoc() map[string]string

type InputBus added in v0.57.0 

type InputBus string
const (
	InputBusUSB    InputBus = "usb"
	InputBusVirtio InputBus = "virtio"
)

type InputType added in v0.57.0 

type InputType string
const (
	InputTypeTablet   InputType = "tablet"
	InputTypeKeyboard InputType = "keyboard"
)

type InstancetypeMatcher added in v0.56.0 

type InstancetypeMatcher struct {
	// Name is the name of the VirtualMachineInstancetype or VirtualMachineClusterInstancetype
	Name string `json:"name"`

	// Kind specifies which instancetype resource is referenced.
	// Allowed values are: "VirtualMachineInstancetype" and "VirtualMachineClusterInstancetype".
	// If not specified, "VirtualMachineClusterInstancetype" is used by default.
	//
	// +optional
	Kind string `json:"kind,omitempty"`

	// RevisionName specifies a ControllerRevision containing a specific copy of the
	// VirtualMachineInstancetype or VirtualMachineClusterInstancetype to be used. This is initially
	// captured the first time the instancetype is applied to the VirtualMachineInstance.
	//
	// +optional
	RevisionName string `json:"revisionName,omitempty"`
}

InstancetypeMatcher references a instancetype that is used to fill fields in the VMI template.

func (*InstancetypeMatcher) DeepCopy added in v0.56.0 

func (in *InstancetypeMatcher) DeepCopy() *InstancetypeMatcher

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

func (*InstancetypeMatcher) DeepCopyInto added in v0.56.0 

func (in *InstancetypeMatcher) DeepCopyInto(out *InstancetypeMatcher)

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

func (InstancetypeMatcher) SwaggerDoc added in v0.56.0 

func (InstancetypeMatcher) SwaggerDoc() map[string]string

type Interface 

type Interface struct {
	// Logical name of the interface as well as a reference to the associated networks.
	// Must match the Name of a Network.
	Name string `json:"name"`
	// Interface model.
	// One of: e1000, e1000e, ne2k_pci, pcnet, rtl8139, virtio.
	// Defaults to virtio.
	// TODO:(ihar) switch to enums once opengen-api supports them. See: https://github.com/kubernetes/kube-openapi/issues/51
	Model string `json:"model,omitempty"`
	// BindingMethod specifies the method which will be used to connect the interface to the guest.
	// Defaults to Bridge.
	InterfaceBindingMethod `json:",inline"`
	// List of ports to be forwarded to the virtual machine.
	Ports []Port `json:"ports,omitempty"`
	// Interface MAC address. For example: de:ad:00:00:be:af or DE-AD-00-00-BE-AF.
	MacAddress string `json:"macAddress,omitempty"`
	// BootOrder is an integer value > 0, used to determine ordering of boot devices.
	// Lower values take precedence.
	// Each interface or disk that has a boot order must have a unique value.
	// Interfaces without a boot order are not tried.
	// +optional
	BootOrder *uint `json:"bootOrder,omitempty"`
	// If specified, the virtual network interface will be placed on the guests pci address with the specified PCI address. For example: 0000:81:01.10
	// +optional
	PciAddress string `json:"pciAddress,omitempty"`
	// If specified the network interface will pass additional DHCP options to the VMI
	// +optional
	DHCPOptions *DHCPOptions `json:"dhcpOptions,omitempty"`
	// If specified, the virtual network interface address and its tag will be provided to the guest via config drive
	// +optional
	Tag string `json:"tag,omitempty"`
}

func DefaultBridgeNetworkInterface 

func DefaultBridgeNetworkInterface() *Interface

func DefaultMacvtapNetworkInterface 

func DefaultMacvtapNetworkInterface(ifaceName string) *Interface

func DefaultMasqueradeNetworkInterface 

func DefaultMasqueradeNetworkInterface() *Interface

func DefaultSlirpNetworkInterface 

func DefaultSlirpNetworkInterface() *Interface

func (*Interface) DeepCopy 

func (in *Interface) DeepCopy() *Interface

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

func (*Interface) DeepCopyInto 

func (in *Interface) DeepCopyInto(out *Interface)

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

func (Interface) SwaggerDoc 

func (Interface) SwaggerDoc() map[string]string

type InterfaceBindingMethod 

type InterfaceBindingMethod struct {
	Bridge     *InterfaceBridge     `json:"bridge,omitempty"`
	Slirp      *InterfaceSlirp      `json:"slirp,omitempty"`
	Masquerade *InterfaceMasquerade `json:"masquerade,omitempty"`
	SRIOV      *InterfaceSRIOV      `json:"sriov,omitempty"`
	Macvtap    *InterfaceMacvtap    `json:"macvtap,omitempty"`
	Passt      *InterfacePasst      `json:"passt,omitempty"`
}

Represents the method which will be used to connect the interface to the guest. Only one of its members may be specified.

func (*InterfaceBindingMethod) DeepCopy 

func (in *InterfaceBindingMethod) DeepCopy() *InterfaceBindingMethod

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

func (*InterfaceBindingMethod) DeepCopyInto 

func (in *InterfaceBindingMethod) DeepCopyInto(out *InterfaceBindingMethod)

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

func (InterfaceBindingMethod) SwaggerDoc 

func (InterfaceBindingMethod) SwaggerDoc() map[string]string

type InterfaceBridge 

type InterfaceBridge struct{}

InterfaceBridge connects to a given network via a linux bridge.

func (*InterfaceBridge) DeepCopy 

func (in *InterfaceBridge) DeepCopy() *InterfaceBridge

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

func (*InterfaceBridge) DeepCopyInto 

func (in *InterfaceBridge) DeepCopyInto(out *InterfaceBridge)

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

func (InterfaceBridge) SwaggerDoc 

func (InterfaceBridge) SwaggerDoc() map[string]string

type InterfaceMacvtap 

type InterfaceMacvtap struct{}

InterfaceMacvtap connects to a given network by extending the Kubernetes node's L2 networks via a macvtap interface.

func (*InterfaceMacvtap) DeepCopy 

func (in *InterfaceMacvtap) DeepCopy() *InterfaceMacvtap

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

func (*InterfaceMacvtap) DeepCopyInto 

func (in *InterfaceMacvtap) DeepCopyInto(out *InterfaceMacvtap)

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

func (InterfaceMacvtap) SwaggerDoc 

func (InterfaceMacvtap) SwaggerDoc() map[string]string

type InterfaceMasquerade 

type InterfaceMasquerade struct{}

InterfaceMasquerade connects to a given network using netfilter rules to nat the traffic.

func (*InterfaceMasquerade) DeepCopy 

func (in *InterfaceMasquerade) DeepCopy() *InterfaceMasquerade

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

func (*InterfaceMasquerade) DeepCopyInto 

func (in *InterfaceMasquerade) DeepCopyInto(out *InterfaceMasquerade)

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

func (InterfaceMasquerade) SwaggerDoc 

func (InterfaceMasquerade) SwaggerDoc() map[string]string

type InterfacePasst added in v0.56.0 

type InterfacePasst struct{}

InterfacePasst connects to a given network.

func (*InterfacePasst) DeepCopy added in v0.56.0 

func (in *InterfacePasst) DeepCopy() *InterfacePasst

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

func (*InterfacePasst) DeepCopyInto added in v0.56.0 

func (in *InterfacePasst) DeepCopyInto(out *InterfacePasst)

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

func (InterfacePasst) SwaggerDoc added in v0.56.0 

func (InterfacePasst) SwaggerDoc() map[string]string

type InterfaceSRIOV 

type InterfaceSRIOV struct{}

InterfaceSRIOV connects to a given network by passing-through an SR-IOV PCI device via vfio.

func (*InterfaceSRIOV) DeepCopy 

func (in *InterfaceSRIOV) DeepCopy() *InterfaceSRIOV

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

func (*InterfaceSRIOV) DeepCopyInto 

func (in *InterfaceSRIOV) DeepCopyInto(out *InterfaceSRIOV)

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

func (InterfaceSRIOV) SwaggerDoc 

func (InterfaceSRIOV) SwaggerDoc() map[string]string

type InterfaceSlirp 

type InterfaceSlirp struct{}

InterfaceSlirp connects to a given network using QEMU user networking mode.

func (*InterfaceSlirp) DeepCopy 

func (in *InterfaceSlirp) DeepCopy() *InterfaceSlirp

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

func (*InterfaceSlirp) DeepCopyInto 

func (in *InterfaceSlirp) DeepCopyInto(out *InterfaceSlirp)

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

func (InterfaceSlirp) SwaggerDoc 

func (InterfaceSlirp) SwaggerDoc() map[string]string

type KVMTimer 

type KVMTimer struct {
	// Enabled set to false makes sure that the machine type or a preset can't add the timer.
	// Defaults to true.
	// +optional
	Enabled *bool `json:"present,omitempty"`
}

func (*KVMTimer) DeepCopy 

func (in *KVMTimer) DeepCopy() *KVMTimer

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

func (*KVMTimer) DeepCopyInto 

func (in *KVMTimer) DeepCopyInto(out *KVMTimer)

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

func (KVMTimer) SwaggerDoc 

func (KVMTimer) SwaggerDoc() map[string]string

type KernelBoot 

type KernelBoot struct {
	// Arguments to be passed to the kernel at boot time
	KernelArgs string `json:"kernelArgs,omitempty"`
	// Container defines the container that containes kernel artifacts
	Container *KernelBootContainer `json:"container,omitempty"`
}

Represents the firmware blob used to assist in the kernel boot process. Used for setting the kernel, initrd and command line arguments

func (*KernelBoot) DeepCopy 

func (in *KernelBoot) DeepCopy() *KernelBoot

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

func (*KernelBoot) DeepCopyInto 

func (in *KernelBoot) DeepCopyInto(out *KernelBoot)

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

func (KernelBoot) SwaggerDoc 

func (KernelBoot) SwaggerDoc() map[string]string

type KernelBootContainer 

type KernelBootContainer struct {
	// Image that contains initrd / kernel files.
	Image string `json:"image"`
	// ImagePullSecret is the name of the Docker registry secret required to pull the image. The secret must already exist.
	//+optional
	ImagePullSecret string `json:"imagePullSecret,omitempty"`
	// Image pull policy.
	// One of Always, Never, IfNotPresent.
	// Defaults to Always if :latest tag is specified, or IfNotPresent otherwise.
	// Cannot be updated.
	// More info: https://kubernetes.io/docs/concepts/containers/images#updating-images
	// +optional
	ImagePullPolicy v1.PullPolicy `json:"imagePullPolicy,omitempty"`
	// The fully-qualified path to the kernel image in the host OS
	//+optional
	KernelPath string `json:"kernelPath,omitempty"`
	// the fully-qualified path to the ramdisk image in the host OS
	//+optional
	InitrdPath string `json:"initrdPath,omitempty"`
}

If set, the VM will be booted from the defined kernel / initrd.

func (*KernelBootContainer) DeepCopy 

func (in *KernelBootContainer) DeepCopy() *KernelBootContainer

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

func (*KernelBootContainer) DeepCopyInto 

func (in *KernelBootContainer) DeepCopyInto(out *KernelBootContainer)

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

func (KernelBootContainer) SwaggerDoc 

func (KernelBootContainer) SwaggerDoc() map[string]string

type KubeVirt 

type KubeVirt struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	Spec              KubeVirtSpec   `json:"spec" valid:"required"`
	Status            KubeVirtStatus `json:"status,omitempty"`
}

KubeVirt represents the object deploying all KubeVirt resources

+k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +genclient

func (*KubeVirt) DeepCopy 

func (in *KubeVirt) DeepCopy() *KubeVirt

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

func (*KubeVirt) DeepCopyInto 

func (in *KubeVirt) DeepCopyInto(out *KubeVirt)

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

func (*KubeVirt) DeepCopyObject 

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

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

func (KubeVirt) SwaggerDoc 

func (KubeVirt) SwaggerDoc() map[string]string

type KubeVirtCertificateRotateStrategy 

type KubeVirtCertificateRotateStrategy struct {
	SelfSigned *KubeVirtSelfSignConfiguration `json:"selfSigned,omitempty"`
}

func (*KubeVirtCertificateRotateStrategy) DeepCopy 

func (in *KubeVirtCertificateRotateStrategy) DeepCopy() *KubeVirtCertificateRotateStrategy

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

func (*KubeVirtCertificateRotateStrategy) DeepCopyInto 

func (in *KubeVirtCertificateRotateStrategy) DeepCopyInto(out *KubeVirtCertificateRotateStrategy)

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

func (KubeVirtCertificateRotateStrategy) SwaggerDoc 

func (KubeVirtCertificateRotateStrategy) SwaggerDoc() map[string]string

type KubeVirtCondition 

type KubeVirtCondition struct {
	Type   KubeVirtConditionType `json:"type"`
	Status k8sv1.ConditionStatus `json:"status"`
	// +optional
	// +nullable
	LastProbeTime metav1.Time `json:"lastProbeTime,omitempty"`
	// +optional
	// +nullable
	LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty"`
	Reason             string      `json:"reason,omitempty"`
	Message            string      `json:"message,omitempty"`
}

KubeVirtCondition represents a condition of a KubeVirt deployment

func (*KubeVirtCondition) DeepCopy 

func (in *KubeVirtCondition) DeepCopy() *KubeVirtCondition

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

func (*KubeVirtCondition) DeepCopyInto 

func (in *KubeVirtCondition) DeepCopyInto(out *KubeVirtCondition)

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

func (KubeVirtCondition) SwaggerDoc 

func (KubeVirtCondition) SwaggerDoc() map[string]string

type KubeVirtConditionType 

type KubeVirtConditionType string
const (
	// Whether the deployment or deletion was successful (only used if false)
	KubeVirtConditionSynchronized KubeVirtConditionType = "Synchronized"
	// Whether all resources were created and up-to-date
	KubeVirtConditionCreated KubeVirtConditionType = "Created"

	// Conditions for HCO, see https://github.com/kubevirt/hyperconverged-cluster-operator/blob/master/docs/conditions.md
	// Whether KubeVirt is functional and available in the cluster.
	KubeVirtConditionAvailable KubeVirtConditionType = "Available"
	// Whether the operator is actively making changes to KubeVirt
	KubeVirtConditionProgressing KubeVirtConditionType = "Progressing"
	// Whether KubeVirt is not functioning completely
	KubeVirtConditionDegraded KubeVirtConditionType = "Degraded"
)

These are the valid KubeVirt condition types

type KubeVirtConfiguration 

type KubeVirtConfiguration struct {
	CPUModel               string                  `json:"cpuModel,omitempty"`
	CPURequest             *resource.Quantity      `json:"cpuRequest,omitempty"`
	DeveloperConfiguration *DeveloperConfiguration `json:"developerConfiguration,omitempty"`
	EmulatedMachines       []string                `json:"emulatedMachines,omitempty"`
	ImagePullPolicy        k8sv1.PullPolicy        `json:"imagePullPolicy,omitempty"`
	MigrationConfiguration *MigrationConfiguration `json:"migrations,omitempty"`
	MachineType            string                  `json:"machineType,omitempty"`
	NetworkConfiguration   *NetworkConfiguration   `json:"network,omitempty"`
	OVMFPath               string                  `json:"ovmfPath,omitempty"`
	SELinuxLauncherType    string                  `json:"selinuxLauncherType,omitempty"`
	DefaultRuntimeClass    string                  `json:"defaultRuntimeClass,omitempty"`
	SMBIOSConfig           *SMBiosConfiguration    `json:"smbios,omitempty"`

	// EvictionStrategy defines at the cluster level if the VirtualMachineInstance should be
	// migrated instead of shut-off in case of a node drain. If the VirtualMachineInstance specific
	// field is set it overrides the cluster level one.
	EvictionStrategy *EvictionStrategy `json:"evictionStrategy,omitempty"`

	// deprecated
	SupportedGuestAgentVersions    []string                          `json:"supportedGuestAgentVersions,omitempty"`
	MemBalloonStatsPeriod          *uint32                           `json:"memBalloonStatsPeriod,omitempty"`
	PermittedHostDevices           *PermittedHostDevices             `json:"permittedHostDevices,omitempty"`
	MediatedDevicesConfiguration   *MediatedDevicesConfiguration     `json:"mediatedDevicesConfiguration,omitempty"`
	MinCPUModel                    string                            `json:"minCPUModel,omitempty"`
	ObsoleteCPUModels              map[string]bool                   `json:"obsoleteCPUModels,omitempty"`
	VirtualMachineInstancesPerNode *int                              `json:"virtualMachineInstancesPerNode,omitempty"`
	APIConfiguration               *ReloadableComponentConfiguration `json:"apiConfiguration,omitempty"`
	WebhookConfiguration           *ReloadableComponentConfiguration `json:"webhookConfiguration,omitempty"`
	ControllerConfiguration        *ReloadableComponentConfiguration `json:"controllerConfiguration,omitempty"`
	HandlerConfiguration           *ReloadableComponentConfiguration `json:"handlerConfiguration,omitempty"`
	TLSConfiguration               *TLSConfiguration                 `json:"tlsConfiguration,omitempty"`
}

KubeVirtConfiguration holds all kubevirt configurations

func (*KubeVirtConfiguration) DeepCopy 

func (in *KubeVirtConfiguration) DeepCopy() *KubeVirtConfiguration

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

func (*KubeVirtConfiguration) DeepCopyInto 

func (in *KubeVirtConfiguration) DeepCopyInto(out *KubeVirtConfiguration)

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

func (KubeVirtConfiguration) SwaggerDoc 

func (KubeVirtConfiguration) SwaggerDoc() map[string]string

type KubeVirtList 

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

KubeVirtList is a list of KubeVirts

+k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

func (*KubeVirtList) DeepCopy 

func (in *KubeVirtList) DeepCopy() *KubeVirtList

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

func (*KubeVirtList) DeepCopyInto 

func (in *KubeVirtList) DeepCopyInto(out *KubeVirtList)

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

func (*KubeVirtList) DeepCopyObject 

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

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

func (KubeVirtList) SwaggerDoc 

func (KubeVirtList) SwaggerDoc() map[string]string

type KubeVirtPhase 

type KubeVirtPhase string

KubeVirtPhase is a label for the phase of a KubeVirt deployment at the current time. 

const (
	// The deployment is processing
	KubeVirtPhaseDeploying KubeVirtPhase = "Deploying"
	// The deployment succeeded
	KubeVirtPhaseDeployed KubeVirtPhase = "Deployed"
	// The deletion is processing
	KubeVirtPhaseDeleting KubeVirtPhase = "Deleting"
	// The deletion succeeeded
	KubeVirtPhaseDeleted KubeVirtPhase = "Deleted"
)

These are the valid KubeVirt deployment phases

type KubeVirtSelfSignConfiguration 

type KubeVirtSelfSignConfiguration struct {
	// Deprecated. Use CA.Duration instead
	CARotateInterval *metav1.Duration `json:"caRotateInterval,omitempty"`
	// Deprecated. Use Server.Duration instead
	CertRotateInterval *metav1.Duration `json:"certRotateInterval,omitempty"`
	// Deprecated. Use CA.Duration and CA.RenewBefore instead
	CAOverlapInterval *metav1.Duration `json:"caOverlapInterval,omitempty"`

	// CA configuration
	// CA certs are kept in the CA bundle as long as they are valid
	CA *CertConfig `json:"ca,omitempty"`

	// Server configuration
	// Certs are rotated and discarded
	Server *CertConfig `json:"server,omitempty"`
}

func (*KubeVirtSelfSignConfiguration) DeepCopy 

func (in *KubeVirtSelfSignConfiguration) DeepCopy() *KubeVirtSelfSignConfiguration

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

func (*KubeVirtSelfSignConfiguration) DeepCopyInto 

func (in *KubeVirtSelfSignConfiguration) DeepCopyInto(out *KubeVirtSelfSignConfiguration)

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

func (KubeVirtSelfSignConfiguration) SwaggerDoc 

func (KubeVirtSelfSignConfiguration) SwaggerDoc() map[string]string

type KubeVirtSpec 

type KubeVirtSpec struct {
	// The image tag to use for the continer images installed.
	// Defaults to the same tag as the operator's container image.
	ImageTag string `json:"imageTag,omitempty"`
	// The image registry to pull the container images from
	// Defaults to the same registry the operator's container image is pulled from.
	ImageRegistry string `json:"imageRegistry,omitempty"`

	// The ImagePullPolicy to use.
	ImagePullPolicy k8sv1.PullPolicy `json:"imagePullPolicy,omitempty" valid:"required"`

	// The namespace Prometheus is deployed in
	// Defaults to openshift-monitor
	MonitorNamespace string `json:"monitorNamespace,omitempty"`

	// The namespace the service monitor will be deployed
	//  When ServiceMonitorNamespace is set, then we'll install the service monitor object in that namespace
	// otherwise we will use the monitoring namespace.
	ServiceMonitorNamespace string `json:"serviceMonitorNamespace,omitempty"`

	// The name of the Prometheus service account that needs read-access to KubeVirt endpoints
	// Defaults to prometheus-k8s
	MonitorAccount string `json:"monitorAccount,omitempty"`

	// WorkloadUpdateStrategy defines at the cluster level how to handle
	// automated workload updates
	WorkloadUpdateStrategy KubeVirtWorkloadUpdateStrategy `json:"workloadUpdateStrategy,omitempty"`

	// Specifies if kubevirt can be deleted if workloads are still present.
	// This is mainly a precaution to avoid accidental data loss
	UninstallStrategy KubeVirtUninstallStrategy `json:"uninstallStrategy,omitempty"`

	CertificateRotationStrategy KubeVirtCertificateRotateStrategy `json:"certificateRotateStrategy,omitempty"`

	// Designate the apps.kubevirt.io/version label for KubeVirt components.
	// Useful if KubeVirt is included as part of a product.
	// If ProductVersion is not specified, KubeVirt's version will be used.
	ProductVersion string `json:"productVersion,omitempty"`

	// Designate the apps.kubevirt.io/part-of label for KubeVirt components.
	// Useful if KubeVirt is included as part of a product.
	// If ProductName is not specified, the part-of label will be omitted.
	ProductName string `json:"productName,omitempty"`

	// Designate the apps.kubevirt.io/component label for KubeVirt components.
	// Useful if KubeVirt is included as part of a product.
	// If ProductComponent is not specified, the component label default value is kubevirt.
	ProductComponent string `json:"productComponent,omitempty"`

	// holds kubevirt configurations.
	// same as the virt-configMap
	Configuration KubeVirtConfiguration `json:"configuration,omitempty"`

	// selectors and tolerations that should apply to KubeVirt infrastructure components
	// +optional
	Infra *ComponentConfig `json:"infra,omitempty"`

	// selectors and tolerations that should apply to KubeVirt workloads
	// +optional
	Workloads *ComponentConfig `json:"workloads,omitempty"`

	CustomizeComponents CustomizeComponents `json:"customizeComponents,omitempty"`
}

func (*KubeVirtSpec) DeepCopy 

func (in *KubeVirtSpec) DeepCopy() *KubeVirtSpec

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

func (*KubeVirtSpec) DeepCopyInto 

func (in *KubeVirtSpec) DeepCopyInto(out *KubeVirtSpec)

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

func (KubeVirtSpec) SwaggerDoc 

func (KubeVirtSpec) SwaggerDoc() map[string]string

type KubeVirtStatus 

type KubeVirtStatus struct {
	Phase                                   KubeVirtPhase       `json:"phase,omitempty"`
	Conditions                              []KubeVirtCondition `json:"conditions,omitempty" optional:"true"`
	OperatorVersion                         string              `json:"operatorVersion,omitempty" optional:"true"`
	TargetKubeVirtRegistry                  string              `json:"targetKubeVirtRegistry,omitempty" optional:"true"`
	TargetKubeVirtVersion                   string              `json:"targetKubeVirtVersion,omitempty" optional:"true"`
	TargetDeploymentConfig                  string              `json:"targetDeploymentConfig,omitempty" optional:"true"`
	TargetDeploymentID                      string              `json:"targetDeploymentID,omitempty" optional:"true"`
	ObservedKubeVirtRegistry                string              `json:"observedKubeVirtRegistry,omitempty" optional:"true"`
	ObservedKubeVirtVersion                 string              `json:"observedKubeVirtVersion,omitempty" optional:"true"`
	ObservedDeploymentConfig                string              `json:"observedDeploymentConfig,omitempty" optional:"true"`
	ObservedDeploymentID                    string              `json:"observedDeploymentID,omitempty" optional:"true"`
	OutdatedVirtualMachineInstanceWorkloads *int                `json:"outdatedVirtualMachineInstanceWorkloads,omitempty" optional:"true"`
	ObservedGeneration                      *int64              `json:"observedGeneration,omitempty"`
	// +listType=atomic
	Generations []GenerationStatus `json:"generations,omitempty" optional:"true"`
}

KubeVirtStatus represents information pertaining to a KubeVirt deployment.

func (*KubeVirtStatus) DeepCopy 

func (in *KubeVirtStatus) DeepCopy() *KubeVirtStatus

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

func (*KubeVirtStatus) DeepCopyInto 

func (in *KubeVirtStatus) DeepCopyInto(out *KubeVirtStatus)

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

func (KubeVirtStatus) SwaggerDoc 

func (KubeVirtStatus) SwaggerDoc() map[string]string

type KubeVirtUninstallStrategy 

type KubeVirtUninstallStrategy string
const (
	KubeVirtUninstallStrategyRemoveWorkloads                KubeVirtUninstallStrategy = "RemoveWorkloads"
	KubeVirtUninstallStrategyBlockUninstallIfWorkloadsExist KubeVirtUninstallStrategy = "BlockUninstallIfWorkloadsExist"
)

type KubeVirtWorkloadUpdateStrategy 

type KubeVirtWorkloadUpdateStrategy struct {
	// WorkloadUpdateMethods defines the methods that can be used to disrupt workloads
	// during automated workload updates.
	// When multiple methods are present, the least disruptive method takes
	// precedence over more disruptive methods. For example if both LiveMigrate and Shutdown
	// methods are listed, only VMs which are not live migratable will be restarted/shutdown
	//
	// An empty list defaults to no automated workload updating
	//
	// +listType=atomic
	// +optional
	WorkloadUpdateMethods []WorkloadUpdateMethod `json:"workloadUpdateMethods,omitempty"`

	// BatchEvictionSize Represents the number of VMIs that can be forced updated per
	// the BatchShutdownInteral interval
	//
	// Defaults to 10
	//
	// +optional
	BatchEvictionSize *int `json:"batchEvictionSize,omitempty"`

	// BatchEvictionInterval Represents the interval to wait before issuing the next
	// batch of shutdowns
	//
	// Defaults to 1 minute
	//
	// +optional
	BatchEvictionInterval *metav1.Duration `json:"batchEvictionInterval,omitempty"`
}

KubeVirtWorkloadUpdateStrategy defines options related to updating a KubeVirt install

func (*KubeVirtWorkloadUpdateStrategy) DeepCopy 

func (in *KubeVirtWorkloadUpdateStrategy) DeepCopy() *KubeVirtWorkloadUpdateStrategy

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

func (*KubeVirtWorkloadUpdateStrategy) DeepCopyInto 

func (in *KubeVirtWorkloadUpdateStrategy) DeepCopyInto(out *KubeVirtWorkloadUpdateStrategy)

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

func (KubeVirtWorkloadUpdateStrategy) SwaggerDoc 

func (KubeVirtWorkloadUpdateStrategy) SwaggerDoc() map[string]string

type LaunchSecurity added in v0.49.0 

type LaunchSecurity struct {
	// AMD Secure Encrypted Virtualization (SEV).
	SEV *SEV `json:"sev,omitempty"`
}

func (*LaunchSecurity) DeepCopy added in v0.49.0 

func (in *LaunchSecurity) DeepCopy() *LaunchSecurity

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

func (*LaunchSecurity) DeepCopyInto added in v0.49.0 

func (in *LaunchSecurity) DeepCopyInto(out *LaunchSecurity)

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

func (LaunchSecurity) SwaggerDoc added in v0.49.0 

func (LaunchSecurity) SwaggerDoc() map[string]string

type LogVerbosity 

type LogVerbosity struct {
	VirtAPI        uint `json:"virtAPI,omitempty"`
	VirtController uint `json:"virtController,omitempty"`
	VirtHandler    uint `json:"virtHandler,omitempty"`
	VirtLauncher   uint `json:"virtLauncher,omitempty"`
	VirtOperator   uint `json:"virtOperator,omitempty"`
	// NodeVerbosity represents a map of nodes with a specific verbosity level
	NodeVerbosity map[string]uint `json:"nodeVerbosity,omitempty"`
}

LogVerbosity sets log verbosity level of various components

func (*LogVerbosity) DeepCopy 

func (in *LogVerbosity) DeepCopy() *LogVerbosity

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

func (*LogVerbosity) DeepCopyInto 

func (in *LogVerbosity) DeepCopyInto(out *LogVerbosity)

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

func (LogVerbosity) SwaggerDoc 

func (LogVerbosity) SwaggerDoc() map[string]string

type LunTarget 

type LunTarget struct {
	// Bus indicates the type of disk device to emulate.
	// supported values: virtio, sata, scsi.
	Bus DiskBus `json:"bus,omitempty"`
	// ReadOnly.
	// Defaults to false.
	ReadOnly bool `json:"readonly,omitempty"`
}

func (*LunTarget) DeepCopy 

func (in *LunTarget) DeepCopy() *LunTarget

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

func (*LunTarget) DeepCopyInto 

func (in *LunTarget) DeepCopyInto(out *LunTarget)

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

func (LunTarget) SwaggerDoc 

func (LunTarget) SwaggerDoc() map[string]string

type Machine 

type Machine struct {
	// QEMU machine type is the actual chipset of the VirtualMachineInstance.
	// +optional
	Type string `json:"type"`
}

func (*Machine) DeepCopy 

func (in *Machine) DeepCopy() *Machine

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

func (*Machine) DeepCopyInto 

func (in *Machine) DeepCopyInto(out *Machine)

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

func (Machine) SwaggerDoc 

func (Machine) SwaggerDoc() map[string]string

type MediatedDevicesConfiguration 

type MediatedDevicesConfiguration struct {
	// +listType=atomic
	MediatedDevicesTypes []string `json:"mediatedDevicesTypes,omitempty"`
	// +optional
	// +listType=atomic
	NodeMediatedDeviceTypes []NodeMediatedDeviceTypesConfig `json:"nodeMediatedDeviceTypes,omitempty"`
}

MediatedDevicesConfiguration holds information about MDEV types to be defined, if available

func (*MediatedDevicesConfiguration) DeepCopy 

func (in *MediatedDevicesConfiguration) DeepCopy() *MediatedDevicesConfiguration

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

func (*MediatedDevicesConfiguration) DeepCopyInto 

func (in *MediatedDevicesConfiguration) DeepCopyInto(out *MediatedDevicesConfiguration)

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

func (MediatedDevicesConfiguration) SwaggerDoc 

func (MediatedDevicesConfiguration) SwaggerDoc() map[string]string

type MediatedHostDevice 

type MediatedHostDevice struct {
	MDEVNameSelector         string `json:"mdevNameSelector"`
	ResourceName             string `json:"resourceName"`
	ExternalResourceProvider bool   `json:"externalResourceProvider,omitempty"`
}

MediatedHostDevice represents a host mediated device allowed for passthrough

func (*MediatedHostDevice) DeepCopy 

func (in *MediatedHostDevice) DeepCopy() *MediatedHostDevice

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

func (*MediatedHostDevice) DeepCopyInto 

func (in *MediatedHostDevice) DeepCopyInto(out *MediatedHostDevice)

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

func (MediatedHostDevice) SwaggerDoc 

func (MediatedHostDevice) SwaggerDoc() map[string]string

type Memory 

type Memory struct {
	// Hugepages allow to use hugepages for the VirtualMachineInstance instead of regular memory.
	// +optional
	Hugepages *Hugepages `json:"hugepages,omitempty"`
	// Guest allows to specifying the amount of memory which is visible inside the Guest OS.
	// The Guest must lie between Requests and Limits from the resources section.
	// Defaults to the requested memory in the resources section if not specified.
	// + optional
	Guest *resource.Quantity `json:"guest,omitempty"`
}

Memory allows specifying the VirtualMachineInstance memory features.

func (*Memory) DeepCopy 

func (in *Memory) DeepCopy() *Memory

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

func (*Memory) DeepCopyInto 

func (in *Memory) DeepCopyInto(out *Memory)

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

func (Memory) SwaggerDoc 

func (Memory) SwaggerDoc() map[string]string

type MemoryDumpPhase added in v0.54.0 

type MemoryDumpPhase string
const (
	// The memorydump is during pvc Associating
	MemoryDumpAssociating MemoryDumpPhase = "Associating"
	// The memorydump is in progress
	MemoryDumpInProgress MemoryDumpPhase = "InProgress"
	// The memorydump is being unmounted
	MemoryDumpUnmounting MemoryDumpPhase = "Unmounting"
	// The memorydump is completed
	MemoryDumpCompleted MemoryDumpPhase = "Completed"
	// The memorydump is being unbound
	MemoryDumpDissociating MemoryDumpPhase = "Dissociating"
	// The memorydump failed
	MemoryDumpFailed MemoryDumpPhase = "Failed"
)

type MemoryDumpVolumeSource added in v0.54.0 

type MemoryDumpVolumeSource struct {
	// PersistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace.
	// Directly attached to the virt launcher
	// +optional
	PersistentVolumeClaimVolumeSource `json:",inline"`
}

func (*MemoryDumpVolumeSource) DeepCopy added in v0.54.0 

func (in *MemoryDumpVolumeSource) DeepCopy() *MemoryDumpVolumeSource

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

func (*MemoryDumpVolumeSource) DeepCopyInto added in v0.54.0 

func (in *MemoryDumpVolumeSource) DeepCopyInto(out *MemoryDumpVolumeSource)

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

func (MemoryDumpVolumeSource) SwaggerDoc added in v0.54.0 

func (MemoryDumpVolumeSource) SwaggerDoc() map[string]string

type MigrateOptions added in v0.49.0 

type MigrateOptions struct {
	metav1.TypeMeta `json:",inline"`
	// When present, indicates that modifications should not be
	// persisted. An invalid or unrecognized dryRun directive will
	// result in an error response and no further processing of the
	// request. Valid values are:
	// - All: all dry run stages will be processed
	// +optional
	// +listType=atomic
	DryRun []string `json:"dryRun,omitempty" protobuf:"bytes,1,rep,name=dryRun"`
}

MigrateOptions may be provided on migrate request.

func (*MigrateOptions) DeepCopy added in v0.49.0 

func (in *MigrateOptions) DeepCopy() *MigrateOptions

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

func (*MigrateOptions) DeepCopyInto added in v0.49.0 

func (in *MigrateOptions) DeepCopyInto(out *MigrateOptions)

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

func (MigrateOptions) SwaggerDoc added in v0.49.0 

func (MigrateOptions) SwaggerDoc() map[string]string

type MigrationAbortStatus 

type MigrationAbortStatus string
const (
	// MigrationAbortSucceeded means that the VirtualMachineInstance live migration has been aborted
	MigrationAbortSucceeded MigrationAbortStatus = "Succeeded"
	// MigrationAbortFailed means that the vmi live migration has failed to be abort
	MigrationAbortFailed MigrationAbortStatus = "Failed"
	// MigrationAbortInProgress mean that the vmi live migration is aborting
	MigrationAbortInProgress MigrationAbortStatus = "Aborting"
)

type MigrationConfigSource added in v0.49.0 

type MigrationConfigSource string

MigrationConfigSource indicates the source of migration configuration.

+k8s:openapi-gen=true

type MigrationConfiguration 

type MigrationConfiguration struct {
	// NodeDrainTaintKey defines the taint key that indicates a node should be drained.
	// Note: this option relies on the deprecated node taint feature. Default: kubevirt.io/drain
	NodeDrainTaintKey *string `json:"nodeDrainTaintKey,omitempty"`
	// ParallelOutboundMigrationsPerNode is the maximum number of concurrent outgoing live migrations
	// allowed per node. Defaults to 2
	ParallelOutboundMigrationsPerNode *uint32 `json:"parallelOutboundMigrationsPerNode,omitempty"`
	// ParallelMigrationsPerCluster is the total number of concurrent live migrations
	// allowed cluster-wide. Defaults to 5
	ParallelMigrationsPerCluster *uint32 `json:"parallelMigrationsPerCluster,omitempty"`
	// AllowAutoConverge allows the platform to compromise performance/availability of VMIs to
	// guarantee successful VMI live migrations. Defaults to false
	AllowAutoConverge *bool `json:"allowAutoConverge,omitempty"`
	// BandwidthPerMigration limits the amount of network bandwith live migrations are allowed to use.
	// The value is in quantity per second. Defaults to 0 (no limit)
	BandwidthPerMigration *resource.Quantity `json:"bandwidthPerMigration,omitempty"`
	// CompletionTimeoutPerGiB is the maximum number of seconds per GiB a migration is allowed to take.
	// If a live-migration takes longer to migrate than this value multiplied by the size of the VMI,
	// the migration will be cancelled, unless AllowPostCopy is true. Defaults to 800
	CompletionTimeoutPerGiB *int64 `json:"completionTimeoutPerGiB,omitempty"`
	// ProgressTimeout is the maximum number of seconds a live migration is allowed to make no progress.
	// Hitting this timeout means a migration transferred 0 data for that many seconds. The migration is
	// then considered stuck and therefore cancelled. Defaults to 150
	ProgressTimeout *int64 `json:"progressTimeout,omitempty"`
	// UnsafeMigrationOverride allows live migrations to occur even if the compatibility check
	// indicates the migration will be unsafe to the guest. Defaults to false
	UnsafeMigrationOverride *bool `json:"unsafeMigrationOverride,omitempty"`
	// AllowPostCopy enables post-copy live migrations. Such migrations allow even the busiest VMIs
	// to successfully live-migrate. However, events like a network failure can cause a VMI crash.
	// If set to true, migrations will still start in pre-copy, but switch to post-copy when
	// CompletionTimeoutPerGiB triggers. Defaults to false
	AllowPostCopy *bool `json:"allowPostCopy,omitempty"`
	// When set to true, DisableTLS will disable the additional layer of live migration encryption
	// provided by KubeVirt. This is usually a bad idea. Defaults to false
	DisableTLS *bool `json:"disableTLS,omitempty"`
	// Network is the name of the CNI network to use for live migrations. By default, migrations go
	// through the pod network.
	Network *string `json:"network,omitempty"`
}

MigrationConfiguration holds migration options. Can be overridden for specific groups of VMs though migration policies. Visit https://kubevirt.io/user-guide/operations/migration_policies/ for more information.

func (*MigrationConfiguration) DeepCopy 

func (in *MigrationConfiguration) DeepCopy() *MigrationConfiguration

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

func (*MigrationConfiguration) DeepCopyInto 

func (in *MigrationConfiguration) DeepCopyInto(out *MigrationConfiguration)

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

func (MigrationConfiguration) SwaggerDoc 

func (MigrationConfiguration) SwaggerDoc() map[string]string

type MigrationMode 

type MigrationMode string
const (
	// MigrationPreCopy means the VMI migrations that is currently running is in pre copy mode
	MigrationPreCopy MigrationMode = "PreCopy"
	// MigrationPostCopy means the VMI migrations that is currently running is in post copy mode
	MigrationPostCopy MigrationMode = "PostCopy"
)

type MultusNetwork 

type MultusNetwork struct {
	// References to a NetworkAttachmentDefinition CRD object. Format:
	// <networkName>, <namespace>/<networkName>. If namespace is not
	// specified, VMI namespace is assumed.
	NetworkName string `json:"networkName"`

	// Select the default network and add it to the
	// multus-cni.io/default-network annotation.
	Default bool `json:"default,omitempty"`
}

Represents the multus cni network.

func (*MultusNetwork) DeepCopy 

func (in *MultusNetwork) DeepCopy() *MultusNetwork

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

func (*MultusNetwork) DeepCopyInto 

func (in *MultusNetwork) DeepCopyInto(out *MultusNetwork)

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

func (MultusNetwork) SwaggerDoc 

func (MultusNetwork) SwaggerDoc() map[string]string

type NUMA 

type NUMA struct {
	// GuestMappingPassthrough will create an efficient guest topology based on host CPUs exclusively assigned to a pod.
	// The created topology ensures that memory and CPUs on the virtual numa nodes never cross boundaries of host numa nodes.
	// +opitonal
	GuestMappingPassthrough *NUMAGuestMappingPassthrough `json:"guestMappingPassthrough,omitempty"`
}

func (*NUMA) DeepCopy 

func (in *NUMA) DeepCopy() *NUMA

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

func (*NUMA) DeepCopyInto 

func (in *NUMA) DeepCopyInto(out *NUMA)

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

func (NUMA) SwaggerDoc 

func (NUMA) SwaggerDoc() map[string]string

type NUMAGuestMappingPassthrough 

type NUMAGuestMappingPassthrough struct {
}

NUMAGuestMappingPassthrough instructs kubevirt to model numa topology which is compatible with the CPU pinning on the guest. This will result in a subset of the node numa topology being passed through, ensuring that virtual numa nodes and their memory never cross boundaries coming from the node numa mapping.

func (*NUMAGuestMappingPassthrough) DeepCopy 

func (in *NUMAGuestMappingPassthrough) DeepCopy() *NUMAGuestMappingPassthrough

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

func (*NUMAGuestMappingPassthrough) DeepCopyInto 

func (in *NUMAGuestMappingPassthrough) DeepCopyInto(out *NUMAGuestMappingPassthrough)

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

func (NUMAGuestMappingPassthrough) SwaggerDoc 

func (NUMAGuestMappingPassthrough) SwaggerDoc() map[string]string

type Network 

type Network struct {
	// Network name.
	// Must be a DNS_LABEL and unique within the vm.
	// More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
	Name string `json:"name"`
	// NetworkSource represents the network type and the source interface that should be connected to the virtual machine.
	// Defaults to Pod, if no type is specified.
	NetworkSource `json:",inline"`
}

Network represents a network type and a resource that should be connected to the vm.

func DefaultPodNetwork 

func DefaultPodNetwork() *Network

func (*Network) DeepCopy 

func (in *Network) DeepCopy() *Network

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

func (*Network) DeepCopyInto 

func (in *Network) DeepCopyInto(out *Network)

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

func (Network) SwaggerDoc 

func (Network) SwaggerDoc() map[string]string

type NetworkConfiguration 

type NetworkConfiguration struct {
	NetworkInterface                  string `json:"defaultNetworkInterface,omitempty"`
	PermitSlirpInterface              *bool  `json:"permitSlirpInterface,omitempty"`
	PermitBridgeInterfaceOnPodNetwork *bool  `json:"permitBridgeInterfaceOnPodNetwork,omitempty"`
}

NetworkConfiguration holds network options

func (*NetworkConfiguration) DeepCopy 

func (in *NetworkConfiguration) DeepCopy() *NetworkConfiguration

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

func (*NetworkConfiguration) DeepCopyInto 

func (in *NetworkConfiguration) DeepCopyInto(out *NetworkConfiguration)

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

func (NetworkConfiguration) SwaggerDoc 

func (NetworkConfiguration) SwaggerDoc() map[string]string

type NetworkInterfaceType 

type NetworkInterfaceType string
const (
	// Virtual machine instance bride interface
	BridgeInterface NetworkInterfaceType = "bridge"
	// Virtual machine instance slirp interface
	SlirpInterface NetworkInterfaceType = "slirp"
	// Virtual machine instance masquerade interface
	MasqueradeInterface NetworkInterfaceType = "masquerade"
	// Virtual machine instance passt interface
	PasstInterface NetworkInterfaceType = "passt"
)

type NetworkSource 

type NetworkSource struct {
	Pod    *PodNetwork    `json:"pod,omitempty"`
	Multus *MultusNetwork `json:"multus,omitempty"`
}

Represents the source resource that will be connected to the vm. Only one of its members may be specified.

func (*NetworkSource) DeepCopy 

func (in *NetworkSource) DeepCopy() *NetworkSource

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

func (*NetworkSource) DeepCopyInto 

func (in *NetworkSource) DeepCopyInto(out *NetworkSource)

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

func (NetworkSource) SwaggerDoc 

func (NetworkSource) SwaggerDoc() map[string]string

type NodeMediatedDeviceTypesConfig added in v0.49.0 

type NodeMediatedDeviceTypesConfig struct {
	// NodeSelector is a selector which must be true for the vmi to fit on a node.
	// Selector which must match a node's labels for the vmi to be scheduled on that node.
	// More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/
	NodeSelector map[string]string `json:"nodeSelector"`
	// +listType=atomic
	MediatedDevicesTypes []string `json:"mediatedDevicesTypes"`
}

NodeMediatedDeviceTypesConfig holds information about MDEV types to be defined in a specifc node that matches the NodeSelector field. +k8s:openapi-gen=true

func (*NodeMediatedDeviceTypesConfig) DeepCopy added in v0.49.0 

func (in *NodeMediatedDeviceTypesConfig) DeepCopy() *NodeMediatedDeviceTypesConfig

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

func (*NodeMediatedDeviceTypesConfig) DeepCopyInto added in v0.49.0 

func (in *NodeMediatedDeviceTypesConfig) DeepCopyInto(out *NodeMediatedDeviceTypesConfig)

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

func (NodeMediatedDeviceTypesConfig) SwaggerDoc added in v0.49.0 

func (NodeMediatedDeviceTypesConfig) SwaggerDoc() map[string]string

type NodePlacement 

type NodePlacement struct {
	// nodeSelector is the node selector applied to the relevant kind of pods
	// It specifies a map of key-value pairs: for the pod to be eligible to run on a node,
	// the node must have each of the indicated key-value pairs as labels
	// (it can have additional labels as well).
	// See https://kubernetes.io/docs/concepts/configuration/assign-pod-node/#nodeselector
	// +kubebuilder:validation:Optional
	// +optional
	NodeSelector map[string]string `json:"nodeSelector,omitempty"`

	// affinity enables pod affinity/anti-affinity placement expanding the types of constraints
	// that can be expressed with nodeSelector.
	// affinity is going to be applied to the relevant kind of pods in parallel with nodeSelector
	// See https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#affinity-and-anti-affinity
	// +kubebuilder:validation:Optional
	// +optional
	Affinity *corev1.Affinity `json:"affinity,omitempty"`

	// tolerations is a list of tolerations applied to the relevant kind of pods
	// See https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/ for more info.
	// These are additional tolerations other than default ones.
	// +kubebuilder:validation:Optional
	// +optional
	Tolerations []corev1.Toleration `json:"tolerations,omitempty"`
}

NodePlacement describes node scheduling configuration.

func (*NodePlacement) DeepCopy 

func (in *NodePlacement) DeepCopy() *NodePlacement

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

func (*NodePlacement) DeepCopyInto 

func (in *NodePlacement) DeepCopyInto(out *NodePlacement)

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

type PITTickPolicy 

type PITTickPolicy string

PITTickPolicy determines what happens when QEMU misses a deadline for injecting a tick to the guest.

type PITTimer 

type PITTimer struct {
	// TickPolicy determines what happens when QEMU misses a deadline for injecting a tick to the guest.
	// One of "delay", "catchup", "discard".
	TickPolicy PITTickPolicy `json:"tickPolicy,omitempty"`
	// Enabled set to false makes sure that the machine type or a preset can't add the timer.
	// Defaults to true.
	// +optional
	Enabled *bool `json:"present,omitempty"`
}

func (*PITTimer) DeepCopy 

func (in *PITTimer) DeepCopy() *PITTimer

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

func (*PITTimer) DeepCopyInto 

func (in *PITTimer) DeepCopyInto(out *PITTimer)

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

func (PITTimer) SwaggerDoc 

func (PITTimer) SwaggerDoc() map[string]string

type PatchType 

type PatchType string
const (
	JSONPatchType           PatchType = "json"
	MergePatchType          PatchType = "merge"
	StrategicMergePatchType PatchType = "strategic"
)

type PauseOptions 

type PauseOptions struct {
	metav1.TypeMeta `json:",inline"`

	// When present, indicates that modifications should not be
	// persisted. An invalid or unrecognized dryRun directive will
	// result in an error response and no further processing of the
	// request. Valid values are:
	// - All: all dry run stages will be processed
	// +optional
	// +listType=atomic
	DryRun []string `json:"dryRun,omitempty" protobuf:"bytes,1,rep,name=dryRun"`
}

PauseOptions may be provided on pause request.

func (*PauseOptions) DeepCopy 

func (in *PauseOptions) DeepCopy() *PauseOptions

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

func (*PauseOptions) DeepCopyInto 

func (in *PauseOptions) DeepCopyInto(out *PauseOptions)

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

func (PauseOptions) SwaggerDoc 

func (PauseOptions) SwaggerDoc() map[string]string

type PciHostDevice 

type PciHostDevice struct {
	// The vendor_id:product_id tuple of the PCI device
	PCIVendorSelector string `json:"pciVendorSelector"`
	// The name of the resource that is representing the device. Exposed by
	// a device plugin and requested by VMs. Typically of the form
	// vendor.com/product_nameThe name of the resource that is representing
	// the device. Exposed by a device plugin and requested by VMs.
	// Typically of the form vendor.com/product_name
	ResourceName string `json:"resourceName"`
	// If true, KubeVirt will leave the allocation and monitoring to an
	// external device plugin
	ExternalResourceProvider bool `json:"externalResourceProvider,omitempty"`
}

PciHostDevice represents a host PCI device allowed for passthrough

func (*PciHostDevice) DeepCopy 

func (in *PciHostDevice) DeepCopy() *PciHostDevice

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

func (*PciHostDevice) DeepCopyInto 

func (in *PciHostDevice) DeepCopyInto(out *PciHostDevice)

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

func (PciHostDevice) SwaggerDoc 

func (PciHostDevice) SwaggerDoc() map[string]string

type PermittedHostDevices 

type PermittedHostDevices struct {
	// +listType=atomic
	PciHostDevices []PciHostDevice `json:"pciHostDevices,omitempty"`
	// +listType=atomic
	MediatedDevices []MediatedHostDevice `json:"mediatedDevices,omitempty"`
}

PermittedHostDevices holds information about devices allowed for passthrough

func (*PermittedHostDevices) DeepCopy 

func (in *PermittedHostDevices) DeepCopy() *PermittedHostDevices

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

func (*PermittedHostDevices) DeepCopyInto 

func (in *PermittedHostDevices) DeepCopyInto(out *PermittedHostDevices)

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

func (PermittedHostDevices) SwaggerDoc 

func (PermittedHostDevices) SwaggerDoc() map[string]string

type PersistentVolumeClaimInfo 

type PersistentVolumeClaimInfo struct {
	// AccessModes contains the desired access modes the volume should have.
	// More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1
	// +listType=atomic
	// +optional
	AccessModes []k8sv1.PersistentVolumeAccessMode `json:"accessModes,omitempty"`

	// VolumeMode defines what type of volume is required by the claim.
	// Value of Filesystem is implied when not included in claim spec.
	// +optional
	VolumeMode *k8sv1.PersistentVolumeMode `json:"volumeMode,omitempty"`

	// Capacity represents the capacity set on the corresponding PVC status
	// +optional
	Capacity k8sv1.ResourceList `json:"capacity,omitempty"`

	// Requests represents the resources requested by the corresponding PVC spec
	// +optional
	Requests k8sv1.ResourceList `json:"requests,omitempty"`

	// Preallocated indicates if the PVC's storage is preallocated or not
	// +optional
	Preallocated bool `json:"preallocated,omitempty"`

	// Percentage of filesystem's size to be reserved when resizing the PVC
	// +optional
	FilesystemOverhead *cdiv1.Percent `json:"filesystemOverhead,omitempty"`
}

PersistentVolumeClaimInfo contains the relavant information virt-handler needs cached about a PVC

func (*PersistentVolumeClaimInfo) DeepCopy 

func (in *PersistentVolumeClaimInfo) DeepCopy() *PersistentVolumeClaimInfo

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

func (*PersistentVolumeClaimInfo) DeepCopyInto 

func (in *PersistentVolumeClaimInfo) DeepCopyInto(out *PersistentVolumeClaimInfo)

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

func (PersistentVolumeClaimInfo) SwaggerDoc 

func (PersistentVolumeClaimInfo) SwaggerDoc() map[string]string

type PersistentVolumeClaimVolumeSource 

type PersistentVolumeClaimVolumeSource struct {
	v1.PersistentVolumeClaimVolumeSource `json:",inline"`
	// Hotpluggable indicates whether the volume can be hotplugged and hotunplugged.
	// +optional
	Hotpluggable bool `json:"hotpluggable,omitempty"`
}

PersistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. Directly attached to the vmi via qemu. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims

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.

func (PersistentVolumeClaimVolumeSource) SwaggerDoc 

func (PersistentVolumeClaimVolumeSource) SwaggerDoc() map[string]string

type PodNetwork 

type PodNetwork struct {
	// CIDR for vm network.
	// Default 10.0.2.0/24 if not specified.
	VMNetworkCIDR string `json:"vmNetworkCIDR,omitempty"`

	// IPv6 CIDR for the vm network.
	// Defaults to fd10:0:2::/120 if not specified.
	VMIPv6NetworkCIDR string `json:"vmIPv6NetworkCIDR,omitempty"`
}

Represents the stock pod network interface.

func (*PodNetwork) DeepCopy 

func (in *PodNetwork) DeepCopy() *PodNetwork

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

func (*PodNetwork) DeepCopyInto 

func (in *PodNetwork) DeepCopyInto(out *PodNetwork)

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

func (PodNetwork) SwaggerDoc 

func (PodNetwork) SwaggerDoc() map[string]string

func (*PodNetwork) UnmarshalJSON added in v0.49.1 

func (podNet *PodNetwork) UnmarshalJSON(data []byte) error

type Port 

type Port struct {
	// If specified, this must be an IANA_SVC_NAME and unique within the pod. Each
	// named port in a pod must have a unique name. Name for the port that can be
	// referred to by services.
	// +optional
	Name string `json:"name,omitempty"`
	// Protocol for port. Must be UDP or TCP.
	// Defaults to "TCP".
	// +optional
	Protocol string `json:"protocol,omitempty"`
	// Number of port to expose for the virtual machine.
	// This must be a valid port number, 0 < x < 65536.
	Port int32 `json:"port"`
}

Port represents a port to expose from the virtual machine. Default protocol TCP. The port field is mandatory

func (*Port) DeepCopy 

func (in *Port) DeepCopy() *Port

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

func (*Port) DeepCopyInto 

func (in *Port) DeepCopyInto(out *Port)

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

func (Port) SwaggerDoc 

func (Port) SwaggerDoc() map[string]string

type PreferenceMatcher added in v0.54.0 

type PreferenceMatcher struct {
	// Name is the name of the VirtualMachinePreference or VirtualMachineClusterPreference
	Name string `json:"name"`

	// Kind specifies which preference resource is referenced.
	// Allowed values are: "VirtualMachinePreference" and "VirtualMachineClusterPreference".
	// If not specified, "VirtualMachineClusterPreference" is used by default.
	//
	// +optional
	Kind string `json:"kind,omitempty"`

	// RevisionName specifies a ControllerRevision containing a specific copy of the
	// VirtualMachinePreference or VirtualMachineClusterPreference to be used. This is
	// initially captured the first time the instancetype is applied to the VirtualMachineInstance.
	//
	// +optional
	RevisionName string `json:"revisionName,omitempty"`
}

PreferenceMatcher references a set of preference that is used to fill fields in the VMI template.

func (*PreferenceMatcher) DeepCopy added in v0.54.0 

func (in *PreferenceMatcher) DeepCopy() *PreferenceMatcher

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

func (*PreferenceMatcher) DeepCopyInto added in v0.54.0 

func (in *PreferenceMatcher) DeepCopyInto(out *PreferenceMatcher)

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

func (PreferenceMatcher) SwaggerDoc added in v0.54.0 

func (PreferenceMatcher) SwaggerDoc() map[string]string

type Probe 

type Probe struct {
	// The action taken to determine the health of a VirtualMachineInstance
	Handler `json:",inline"`
	// Number of seconds after the VirtualMachineInstance has started before liveness probes are initiated.
	// More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
	// +optional
	InitialDelaySeconds int32 `json:"initialDelaySeconds,omitempty"`
	// Number of seconds after which the probe times out.
	// For exec probes the timeout fails the probe but does not terminate the command running on the guest.
	// This means a blocking command can result in an increasing load on the guest.
	// A small buffer will be added to the resulting workload exec probe to compensate for delays
	// caused by the qemu guest exec mechanism.
	// Defaults to 1 second. Minimum value is 1.
	// More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
	// +optional
	TimeoutSeconds int32 `json:"timeoutSeconds,omitempty"`
	// How often (in seconds) to perform the probe.
	// Default to 10 seconds. Minimum value is 1.
	// +optional
	PeriodSeconds int32 `json:"periodSeconds,omitempty"`
	// Minimum consecutive successes for the probe to be considered successful after having failed.
	// Defaults to 1. Must be 1 for liveness. Minimum value is 1.
	// +optional
	SuccessThreshold int32 `json:"successThreshold,omitempty"`
	// Minimum consecutive failures for the probe to be considered failed after having succeeded.
	// Defaults to 3. Minimum value is 1.
	// +optional
	FailureThreshold int32 `json:"failureThreshold,omitempty"`
}

Probe describes a health check to be performed against a VirtualMachineInstance to determine whether it is alive or ready to receive traffic.

func (*Probe) DeepCopy 

func (in *Probe) DeepCopy() *Probe

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

func (*Probe) DeepCopyInto 

func (in *Probe) DeepCopyInto(out *Probe)

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

func (Probe) SwaggerDoc 

func (Probe) SwaggerDoc() map[string]string

type ProfilerResult 

type ProfilerResult struct {
	PprofData map[string][]byte `json:"pprofData,omitempty"`
}

func (*ProfilerResult) DeepCopy 

func (in *ProfilerResult) DeepCopy() *ProfilerResult

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

func (*ProfilerResult) DeepCopyInto 

func (in *ProfilerResult) DeepCopyInto(out *ProfilerResult)

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

func (ProfilerResult) SwaggerDoc 

func (ProfilerResult) SwaggerDoc() map[string]string

type QemuGuestAgentSSHPublicKeyAccessCredentialPropagation 

type QemuGuestAgentSSHPublicKeyAccessCredentialPropagation struct {
	// Users represents a list of guest users that should have the ssh public keys
	// added to their authorized_keys file.
	// +listType=set
	Users []string `json:"users"`
}

func (*QemuGuestAgentSSHPublicKeyAccessCredentialPropagation) DeepCopy 

func (in *QemuGuestAgentSSHPublicKeyAccessCredentialPropagation) DeepCopy() *QemuGuestAgentSSHPublicKeyAccessCredentialPropagation

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

func (*QemuGuestAgentSSHPublicKeyAccessCredentialPropagation) DeepCopyInto 

func (in *QemuGuestAgentSSHPublicKeyAccessCredentialPropagation) DeepCopyInto(out *QemuGuestAgentSSHPublicKeyAccessCredentialPropagation)

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

func (QemuGuestAgentSSHPublicKeyAccessCredentialPropagation) SwaggerDoc 

func (QemuGuestAgentSSHPublicKeyAccessCredentialPropagation) SwaggerDoc() map[string]string

type QemuGuestAgentUserPasswordAccessCredentialPropagation 

type QemuGuestAgentUserPasswordAccessCredentialPropagation struct{}

func (*QemuGuestAgentUserPasswordAccessCredentialPropagation) DeepCopy 

func (in *QemuGuestAgentUserPasswordAccessCredentialPropagation) DeepCopy() *QemuGuestAgentUserPasswordAccessCredentialPropagation

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

func (*QemuGuestAgentUserPasswordAccessCredentialPropagation) DeepCopyInto 

func (in *QemuGuestAgentUserPasswordAccessCredentialPropagation) DeepCopyInto(out *QemuGuestAgentUserPasswordAccessCredentialPropagation)

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

func (QemuGuestAgentUserPasswordAccessCredentialPropagation) SwaggerDoc 

func (QemuGuestAgentUserPasswordAccessCredentialPropagation) SwaggerDoc() map[string]string

type RESTClientConfiguration 

type RESTClientConfiguration struct {
	//RateLimiter allows selecting and configuring different rate limiters for the k8s client.
	RateLimiter *RateLimiter `json:"rateLimiter,omitempty"`
}

RESTClientConfiguration allows configuring certain aspects of the k8s rest client.

func (*RESTClientConfiguration) DeepCopy 

func (in *RESTClientConfiguration) DeepCopy() *RESTClientConfiguration

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

func (*RESTClientConfiguration) DeepCopyInto 

func (in *RESTClientConfiguration) DeepCopyInto(out *RESTClientConfiguration)

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

func (RESTClientConfiguration) SwaggerDoc 

func (RESTClientConfiguration) SwaggerDoc() map[string]string

type RTCTickPolicy 

type RTCTickPolicy string

RTCTickPolicy determines what happens when QEMU misses a deadline for injecting a tick to the guest.

type RTCTimer 

type RTCTimer struct {
	// TickPolicy determines what happens when QEMU misses a deadline for injecting a tick to the guest.
	// One of "delay", "catchup".
	TickPolicy RTCTickPolicy `json:"tickPolicy,omitempty"`
	// Enabled set to false makes sure that the machine type or a preset can't add the timer.
	// Defaults to true.
	// +optional
	Enabled *bool `json:"present,omitempty"`
	// Track the guest or the wall clock.
	Track RTCTimerTrack `json:"track,omitempty"`
}

func (*RTCTimer) DeepCopy 

func (in *RTCTimer) DeepCopy() *RTCTimer

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

func (*RTCTimer) DeepCopyInto 

func (in *RTCTimer) DeepCopyInto(out *RTCTimer)

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

func (RTCTimer) SwaggerDoc 

func (RTCTimer) SwaggerDoc() map[string]string

type RTCTimerTrack 

type RTCTimerTrack string

RTCTimerTrack specifies from which source to track the time. 

const (
	// TrackGuest tracks the guest time.
	TrackGuest RTCTimerTrack = "guest"
	// TrackWall tracks the host time.
	TrackWall RTCTimerTrack = "wall"
)

type RateLimiter 

type RateLimiter struct {
	TokenBucketRateLimiter *TokenBucketRateLimiter `json:"tokenBucketRateLimiter,omitempty"`
}

func (*RateLimiter) DeepCopy 

func (in *RateLimiter) DeepCopy() *RateLimiter

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

func (*RateLimiter) DeepCopyInto 

func (in *RateLimiter) DeepCopyInto(out *RateLimiter)

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

func (RateLimiter) SwaggerDoc 

func (RateLimiter) SwaggerDoc() map[string]string

type Realtime 

type Realtime struct {
	// Mask defines the vcpu mask expression that defines which vcpus are used for realtime. Format matches libvirt's expressions.
	// Example: "0-3,^1","0,2,3","2-3"
	// +optional
	Mask string `json:"mask,omitempty"`
}

Realtime holds the tuning knobs specific for realtime workloads.

func (*Realtime) DeepCopy 

func (in *Realtime) DeepCopy() *Realtime

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

func (*Realtime) DeepCopyInto 

func (in *Realtime) DeepCopyInto(out *Realtime)

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

func (Realtime) SwaggerDoc 

func (Realtime) SwaggerDoc() map[string]string

type ReloadableComponentConfiguration 

type ReloadableComponentConfiguration struct {
	//RestClient can be used to tune certain aspects of the k8s client in use.
	RestClient *RESTClientConfiguration `json:"restClient,omitempty"`
}

ReloadableComponentConfiguration holds all generic k8s configuration options which can be reloaded by components without requiring a restart.

func (*ReloadableComponentConfiguration) DeepCopy 

func (in *ReloadableComponentConfiguration) DeepCopy() *ReloadableComponentConfiguration

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

func (*ReloadableComponentConfiguration) DeepCopyInto 

func (in *ReloadableComponentConfiguration) DeepCopyInto(out *ReloadableComponentConfiguration)

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

func (ReloadableComponentConfiguration) SwaggerDoc 

func (ReloadableComponentConfiguration) SwaggerDoc() map[string]string

type RemoveVolumeOptions 

type RemoveVolumeOptions struct {
	// Name represents the name that maps to both the disk and volume that
	// should be removed
	Name string `json:"name"`
	// When present, indicates that modifications should not be
	// persisted. An invalid or unrecognized dryRun directive will
	// result in an error response and no further processing of the
	// request. Valid values are:
	// - All: all dry run stages will be processed
	// +optional
	// +listType=atomic
	DryRun []string `json:"dryRun,omitempty"`
}

RemoveVolumeOptions is provided when dynamically hot unplugging volume and disk

func (*RemoveVolumeOptions) DeepCopy 

func (in *RemoveVolumeOptions) DeepCopy() *RemoveVolumeOptions

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

func (*RemoveVolumeOptions) DeepCopyInto 

func (in *RemoveVolumeOptions) DeepCopyInto(out *RemoveVolumeOptions)

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

func (RemoveVolumeOptions) SwaggerDoc 

func (RemoveVolumeOptions) SwaggerDoc() map[string]string

type ResourceRequirements 

type ResourceRequirements struct {
	// Requests is a description of the initial vmi resources.
	// Valid resource keys are "memory" and "cpu".
	// +optional
	Requests v1.ResourceList `json:"requests,omitempty"`
	// Limits describes the maximum amount of compute resources allowed.
	// Valid resource keys are "memory" and "cpu".
	// +optional
	Limits v1.ResourceList `json:"limits,omitempty"`
	// Don't ask the scheduler to take the guest-management overhead into account. Instead
	// put the overhead only into the container's memory limit. This can lead to crashes if
	// all memory is in use on a node. Defaults to false.
	OvercommitGuestOverhead bool `json:"overcommitGuestOverhead,omitempty"`
}

func (*ResourceRequirements) DeepCopy 

func (in *ResourceRequirements) DeepCopy() *ResourceRequirements

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

func (*ResourceRequirements) DeepCopyInto 

func (in *ResourceRequirements) DeepCopyInto(out *ResourceRequirements)

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

func (ResourceRequirements) SwaggerDoc 

func (ResourceRequirements) SwaggerDoc() map[string]string

type RestartOptions 

type RestartOptions struct {
	metav1.TypeMeta `json:",inline"`

	// The duration in seconds before the object should be force-restarted. Value must be non-negative integer.
	// The value zero indicates, restart immediately. If this value is nil, the default grace period for deletion of the corresponding VMI for the
	// specified type will be used to determine on how much time to give the VMI to restart.
	// Defaults to a per object value if not specified. zero means restart immediately.
	// Allowed Values: nil and 0
	// +optional
	GracePeriodSeconds *int64 `json:"gracePeriodSeconds,omitempty" protobuf:"varint,1,opt,name=gracePeriodSeconds"`

	// When present, indicates that modifications should not be
	// persisted. An invalid or unrecognized dryRun directive will
	// result in an error response and no further processing of the
	// request. Valid values are:
	// - All: all dry run stages will be processed
	// +optional
	// +listType=atomic
	DryRun []string `json:"dryRun,omitempty" protobuf:"bytes,2,rep,name=dryRun"`
}

RestartOptions may be provided when deleting an API object.

func (*RestartOptions) DeepCopy 

func (in *RestartOptions) DeepCopy() *RestartOptions

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

func (*RestartOptions) DeepCopyInto 

func (in *RestartOptions) DeepCopyInto(out *RestartOptions)

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

func (RestartOptions) SwaggerDoc 

func (RestartOptions) SwaggerDoc() map[string]string

type Rng 

type Rng struct {
}

Rng represents the random device passed from host

func (*Rng) DeepCopy 

func (in *Rng) DeepCopy() *Rng

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

func (*Rng) DeepCopyInto 

func (in *Rng) DeepCopyInto(out *Rng)

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

func (Rng) SwaggerDoc 

func (Rng) SwaggerDoc() map[string]string

type SEV added in v0.49.0 

type SEV struct {
}

func (*SEV) DeepCopy added in v0.49.0 

func (in *SEV) DeepCopy() *SEV

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

func (*SEV) DeepCopyInto added in v0.49.0 

func (in *SEV) DeepCopyInto(out *SEV)

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

func (SEV) SwaggerDoc added in v0.49.0 

func (SEV) SwaggerDoc() map[string]string

type SMBiosConfiguration 

type SMBiosConfiguration struct {
	Manufacturer string `json:"manufacturer,omitempty"`
	Product      string `json:"product,omitempty"`
	Version      string `json:"version,omitempty"`
	Sku          string `json:"sku,omitempty"`
	Family       string `json:"family,omitempty"`
}

func (*SMBiosConfiguration) DeepCopy 

func (in *SMBiosConfiguration) DeepCopy() *SMBiosConfiguration

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

func (*SMBiosConfiguration) DeepCopyInto 

func (in *SMBiosConfiguration) DeepCopyInto(out *SMBiosConfiguration)

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

func (SMBiosConfiguration) SwaggerDoc 

func (SMBiosConfiguration) SwaggerDoc() map[string]string

type SSHPublicKeyAccessCredential 

type SSHPublicKeyAccessCredential struct {
	// Source represents where the public keys are pulled from
	Source SSHPublicKeyAccessCredentialSource `json:"source"`

	// PropagationMethod represents how the public key is injected into the vm guest.
	PropagationMethod SSHPublicKeyAccessCredentialPropagationMethod `json:"propagationMethod"`
}

SSHPublicKeyAccessCredential represents a source and propagation method for injecting ssh public keys into a vm guest

func (*SSHPublicKeyAccessCredential) DeepCopy 

func (in *SSHPublicKeyAccessCredential) DeepCopy() *SSHPublicKeyAccessCredential

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

func (*SSHPublicKeyAccessCredential) DeepCopyInto 

func (in *SSHPublicKeyAccessCredential) DeepCopyInto(out *SSHPublicKeyAccessCredential)

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

func (SSHPublicKeyAccessCredential) SwaggerDoc 

func (SSHPublicKeyAccessCredential) SwaggerDoc() map[string]string

type SSHPublicKeyAccessCredentialPropagationMethod 

type SSHPublicKeyAccessCredentialPropagationMethod struct {
	// ConfigDrivePropagation means that the ssh public keys are injected
	// into the VM using metadata using the configDrive cloud-init provider
	// +optional
	ConfigDrive *ConfigDriveSSHPublicKeyAccessCredentialPropagation `json:"configDrive,omitempty"`

	// QemuGuestAgentAccessCredentailPropagation means ssh public keys are
	// dynamically injected into the vm at runtime via the qemu guest agent.
	// This feature requires the qemu guest agent to be running within the guest.
	// +optional
	QemuGuestAgent *QemuGuestAgentSSHPublicKeyAccessCredentialPropagation `json:"qemuGuestAgent,omitempty"`
}

SSHPublicKeyAccessCredentialPropagationMethod represents the method used to inject a ssh public key into the vm guest. Only one of its members may be specified.

func (*SSHPublicKeyAccessCredentialPropagationMethod) DeepCopy 

func (in *SSHPublicKeyAccessCredentialPropagationMethod) DeepCopy() *SSHPublicKeyAccessCredentialPropagationMethod

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

func (*SSHPublicKeyAccessCredentialPropagationMethod) DeepCopyInto 

func (in *SSHPublicKeyAccessCredentialPropagationMethod) DeepCopyInto(out *SSHPublicKeyAccessCredentialPropagationMethod)

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

func (SSHPublicKeyAccessCredentialPropagationMethod) SwaggerDoc 

func (SSHPublicKeyAccessCredentialPropagationMethod) SwaggerDoc() map[string]string

type SSHPublicKeyAccessCredentialSource 

type SSHPublicKeyAccessCredentialSource struct {
	// Secret means that the access credential is pulled from a kubernetes secret
	// +optional
	Secret *AccessCredentialSecretSource `json:"secret,omitempty"`
}

SSHPublicKeyAccessCredentialSource represents where to retrieve the ssh key credentials Only one of its members may be specified.

func (*SSHPublicKeyAccessCredentialSource) DeepCopy 

func (in *SSHPublicKeyAccessCredentialSource) DeepCopy() *SSHPublicKeyAccessCredentialSource

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

func (*SSHPublicKeyAccessCredentialSource) DeepCopyInto 

func (in *SSHPublicKeyAccessCredentialSource) DeepCopyInto(out *SSHPublicKeyAccessCredentialSource)

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

func (SSHPublicKeyAccessCredentialSource) SwaggerDoc 

func (SSHPublicKeyAccessCredentialSource) SwaggerDoc() map[string]string

type ScreenshotOptions added in v0.58.0 

type ScreenshotOptions struct {
	MoveCursor bool `json:"moveCursor"`
}

func (*ScreenshotOptions) DeepCopy added in v0.58.0 

func (in *ScreenshotOptions) DeepCopy() *ScreenshotOptions

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

func (*ScreenshotOptions) DeepCopyInto added in v0.58.0 

func (in *ScreenshotOptions) DeepCopyInto(out *ScreenshotOptions)

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

func (ScreenshotOptions) SwaggerDoc added in v0.58.0 

func (ScreenshotOptions) SwaggerDoc() map[string]string

type SecretVolumeSource 

type SecretVolumeSource struct {
	// Name of the secret in the pod's namespace to use.
	// More info: https://kubernetes.io/docs/concepts/storage/volumes#secret
	// +optional
	SecretName string `json:"secretName,omitempty"`
	// Specify whether the Secret or it's keys must be defined
	// +optional
	Optional *bool `json:"optional,omitempty"`
	// The volume label of the resulting disk inside the VMI.
	// Different bootstrapping mechanisms require different values.
	// Typical values are "cidata" (cloud-init), "config-2" (cloud-init) or "OEMDRV" (kickstart).
	// +optional
	VolumeLabel string `json:"volumeLabel,omitempty"`
}

SecretVolumeSource adapts a Secret into a volume.

func (*SecretVolumeSource) DeepCopy 

func (in *SecretVolumeSource) DeepCopy() *SecretVolumeSource

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

func (*SecretVolumeSource) DeepCopyInto 

func (in *SecretVolumeSource) DeepCopyInto(out *SecretVolumeSource)

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

func (SecretVolumeSource) SwaggerDoc 

func (SecretVolumeSource) SwaggerDoc() map[string]string

type ServiceAccountVolumeSource 

type ServiceAccountVolumeSource struct {
	// Name of the service account in the pod's namespace to use.
	// More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/
	ServiceAccountName string `json:"serviceAccountName,omitempty"`
}

ServiceAccountVolumeSource adapts a ServiceAccount into a volume.

func (*ServiceAccountVolumeSource) DeepCopy 

func (in *ServiceAccountVolumeSource) DeepCopy() *ServiceAccountVolumeSource

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

func (*ServiceAccountVolumeSource) DeepCopyInto 

func (in *ServiceAccountVolumeSource) DeepCopyInto(out *ServiceAccountVolumeSource)

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

func (ServiceAccountVolumeSource) SwaggerDoc 

func (ServiceAccountVolumeSource) SwaggerDoc() map[string]string

type SoundDevice 

type SoundDevice struct {
	// User's defined name for this sound device
	Name string `json:"name"`
	// We only support ich9 or ac97.
	// If SoundDevice is not set: No sound card is emulated.
	// If SoundDevice is set but Model is not: ich9
	// +optional
	Model string `json:"model,omitempty"`
}

Represents the user's configuration to emulate sound cards in the VMI.

func (*SoundDevice) DeepCopy 

func (in *SoundDevice) DeepCopy() *SoundDevice

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

func (*SoundDevice) DeepCopyInto 

func (in *SoundDevice) DeepCopyInto(out *SoundDevice)

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

func (SoundDevice) SwaggerDoc 

func (SoundDevice) SwaggerDoc() map[string]string

type StartOptions 

type StartOptions struct {
	metav1.TypeMeta `json:",inline"`

	// Indicates that VM will be started in paused state.
	// +optional
	Paused bool `json:"paused,omitempty" protobuf:"varint,7,opt,name=paused"`
	// When present, indicates that modifications should not be
	// persisted. An invalid or unrecognized dryRun directive will
	// result in an error response and no further processing of the
	// request. Valid values are:
	// - All: all dry run stages will be processed
	// +optional
	// +listType=atomic
	DryRun []string `json:"dryRun,omitempty" protobuf:"bytes,5,rep,name=dryRun"`
}

StartOptions may be provided on start request.

func (*StartOptions) DeepCopy 

func (in *StartOptions) DeepCopy() *StartOptions

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

func (*StartOptions) DeepCopyInto 

func (in *StartOptions) DeepCopyInto(out *StartOptions)

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

func (StartOptions) SwaggerDoc 

func (StartOptions) SwaggerDoc() map[string]string

type StartStrategy 

type StartStrategy string
const (
	StartStrategyPaused StartStrategy = "Paused"
)

type StateChangeRequestAction 

type StateChangeRequestAction string

StateChangeRequestType represents the existing state change requests that are possible 

const (
	StartRequest StateChangeRequestAction = "Start"
	StopRequest  StateChangeRequestAction = "Stop"
)

These are the currently defined state change requests

type StopOptions 

type StopOptions struct {
	metav1.TypeMeta `json:",inline"`

	// this updates the VMIs terminationGracePeriodSeconds during shutdown
	// +optional
	GracePeriod *int64 `json:"gracePeriod,omitempty" protobuf:"varint,1,opt,name=gracePeriod"`
	// When present, indicates that modifications should not be
	// persisted. An invalid or unrecognized dryRun directive will
	// result in an error response and no further processing of the
	// request. Valid values are:
	// - All: all dry run stages will be processed
	// +optional
	// +listType=atomic
	DryRun []string `json:"dryRun,omitempty" protobuf:"bytes,2,rep,name=dryRun"`
}

StopOptions may be provided when deleting an API object.

func (*StopOptions) DeepCopy 

func (in *StopOptions) DeepCopy() *StopOptions

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

func (*StopOptions) DeepCopyInto 

func (in *StopOptions) DeepCopyInto(out *StopOptions)

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

func (StopOptions) SwaggerDoc 

func (StopOptions) SwaggerDoc() map[string]string

type SyNICTimer 

type SyNICTimer struct {
	Enabled *bool         `json:"enabled,omitempty"`
	Direct  *FeatureState `json:"direct,omitempty"`
}

func (*SyNICTimer) DeepCopy 

func (in *SyNICTimer) DeepCopy() *SyNICTimer

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

func (*SyNICTimer) DeepCopyInto 

func (in *SyNICTimer) DeepCopyInto(out *SyNICTimer)

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

func (SyNICTimer) SwaggerDoc 

func (SyNICTimer) SwaggerDoc() map[string]string

type SyncEvent 

type SyncEvent string
const (
	Created                      SyncEvent = "Created"
	Deleted                      SyncEvent = "Deleted"
	PresetFailed                 SyncEvent = "PresetFailed"
	Override                     SyncEvent = "Override"
	Started                      SyncEvent = "Started"
	ShuttingDown                 SyncEvent = "ShuttingDown"
	Stopped                      SyncEvent = "Stopped"
	PreparingTarget              SyncEvent = "PreparingTarget"
	Migrating                    SyncEvent = "Migrating"
	Migrated                     SyncEvent = "Migrated"
	SyncFailed                   SyncEvent = "SyncFailed"
	Resumed                      SyncEvent = "Resumed"
	AccessCredentialsSyncFailed  SyncEvent = "AccessCredentialsSyncFailed"
	AccessCredentialsSyncSuccess SyncEvent = "AccessCredentialsSyncSuccess"
)

func (SyncEvent) String 

func (s SyncEvent) String() string

type SysprepSource 

type SysprepSource struct {
	// Secret references a k8s Secret that contains Sysprep answer file named autounattend.xml that should be attached as disk of CDROM type.
	// + optional
	Secret *v1.LocalObjectReference `json:"secret,omitempty"`
	// ConfigMap references a ConfigMap that contains Sysprep answer file named autounattend.xml that should be attached as disk of CDROM type.
	// + optional
	ConfigMap *v1.LocalObjectReference `json:"configMap,omitempty"`
}

Represents a Sysprep volume source.

func (*SysprepSource) DeepCopy 

func (in *SysprepSource) DeepCopy() *SysprepSource

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

func (*SysprepSource) DeepCopyInto 

func (in *SysprepSource) DeepCopyInto(out *SysprepSource)

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

func (SysprepSource) SwaggerDoc 

func (SysprepSource) SwaggerDoc() map[string]string

type TLSConfiguration added in v0.58.0 

type TLSConfiguration struct {
	// MinTLSVersion is a way to specify the minimum protocol version that is acceptable for TLS connections.
	// Protocol versions are based on the following most common TLS configurations:
	//
	//   https://ssl-config.mozilla.org/
	//
	// Note that SSLv3.0 is not a supported protocol version due to well known
	// vulnerabilities such as POODLE: https://en.wikipedia.org/wiki/POODLE
	// +kubebuilder:validation:Enum=VersionTLS10;VersionTLS11;VersionTLS12;VersionTLS13
	MinTLSVersion TLSProtocolVersion `json:"minTLSVersion,omitempty"`
	// +listType=set
	Ciphers []string `json:"ciphers,omitempty"`
}

TLSConfiguration holds TLS options

func (*TLSConfiguration) DeepCopy added in v0.58.0 

func (in *TLSConfiguration) DeepCopy() *TLSConfiguration

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

func (*TLSConfiguration) DeepCopyInto added in v0.58.0 

func (in *TLSConfiguration) DeepCopyInto(out *TLSConfiguration)

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

func (TLSConfiguration) SwaggerDoc added in v0.58.0 

func (TLSConfiguration) SwaggerDoc() map[string]string

type TLSProtocolVersion added in v0.58.0 

type TLSProtocolVersion string
const (
	// VersionTLS10 is version 1.0 of the TLS security protocol.
	VersionTLS10 TLSProtocolVersion = "VersionTLS10"
	// VersionTLS11 is version 1.1 of the TLS security protocol.
	VersionTLS11 TLSProtocolVersion = "VersionTLS11"
	// VersionTLS12 is version 1.2 of the TLS security protocol.
	VersionTLS12 TLSProtocolVersion = "VersionTLS12"
	// VersionTLS13 is version 1.3 of the TLS security protocol.
	VersionTLS13 TLSProtocolVersion = "VersionTLS13"
)

type TPMDevice added in v0.53.0 

type TPMDevice struct{}

func (*TPMDevice) DeepCopy added in v0.53.0 

func (in *TPMDevice) DeepCopy() *TPMDevice

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

func (*TPMDevice) DeepCopyInto added in v0.53.0 

func (in *TPMDevice) DeepCopyInto(out *TPMDevice)

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

func (TPMDevice) SwaggerDoc added in v0.53.0 

func (TPMDevice) SwaggerDoc() map[string]string

type Timer 

type Timer struct {
	// HPET (High Precision Event Timer) - multiple timers with periodic interrupts.
	HPET *HPETTimer `json:"hpet,omitempty"`
	// KVM 	(KVM clock) - lets guests read the host’s wall clock time (paravirtualized). For linux guests.
	KVM *KVMTimer `json:"kvm,omitempty"`
	// PIT (Programmable Interval Timer) - a timer with periodic interrupts.
	PIT *PITTimer `json:"pit,omitempty"`
	// RTC (Real Time Clock) - a continuously running timer with periodic interrupts.
	RTC *RTCTimer `json:"rtc,omitempty"`
	// Hyperv (Hypervclock) - lets guests read the host’s wall clock time (paravirtualized). For windows guests.
	Hyperv *HypervTimer `json:"hyperv,omitempty"`
}

Represents all available timers in a vmi.

func (*Timer) DeepCopy 

func (in *Timer) DeepCopy() *Timer

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

func (*Timer) DeepCopyInto 

func (in *Timer) DeepCopyInto(out *Timer)

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

func (Timer) SwaggerDoc 

func (Timer) SwaggerDoc() map[string]string

type TokenBucketRateLimiter 

type TokenBucketRateLimiter struct {
	// QPS indicates the maximum QPS to the apiserver from this client.
	// If it's zero, the component default will be used
	QPS float32 `json:"qps"`

	// Maximum burst for throttle.
	// If it's zero, the component default will be used
	Burst int `json:"burst"`
}

func (*TokenBucketRateLimiter) DeepCopy 

func (in *TokenBucketRateLimiter) DeepCopy() *TokenBucketRateLimiter

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

func (*TokenBucketRateLimiter) DeepCopyInto 

func (in *TokenBucketRateLimiter) DeepCopyInto(out *TokenBucketRateLimiter)

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

func (TokenBucketRateLimiter) SwaggerDoc 

func (TokenBucketRateLimiter) SwaggerDoc() map[string]string

type TopologyHints 

type TopologyHints struct {
	TSCFrequency *int64 `json:"tscFrequency,omitempty"`
}

func (*TopologyHints) DeepCopy 

func (in *TopologyHints) DeepCopy() *TopologyHints

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

func (*TopologyHints) DeepCopyInto 

func (in *TopologyHints) DeepCopyInto(out *TopologyHints)

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

func (TopologyHints) SwaggerDoc 

func (TopologyHints) SwaggerDoc() map[string]string

type TrayState 

type TrayState string

TrayState indicates if a tray of a cdrom is open or closed. 

const (
	// TrayStateOpen indicates that the tray of a cdrom is open.
	TrayStateOpen TrayState = "open"
	// TrayStateClosed indicates that the tray of a cdrom is closed.
	TrayStateClosed TrayState = "closed"
)

type UnpauseOptions 

type UnpauseOptions struct {
	metav1.TypeMeta `json:",inline"`

	// When present, indicates that modifications should not be
	// persisted. An invalid or unrecognized dryRun directive will
	// result in an error response and no further processing of the
	// request. Valid values are:
	// - All: all dry run stages will be processed
	// +optional
	// +listType=atomic
	DryRun []string `json:"dryRun,omitempty" protobuf:"bytes,1,rep,name=dryRun"`
}

UnpauseOptions may be provided on unpause request.

func (*UnpauseOptions) DeepCopy 

func (in *UnpauseOptions) DeepCopy() *UnpauseOptions

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

func (*UnpauseOptions) DeepCopyInto 

func (in *UnpauseOptions) DeepCopyInto(out *UnpauseOptions)

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

func (UnpauseOptions) SwaggerDoc 

func (UnpauseOptions) SwaggerDoc() map[string]string

type UserPasswordAccessCredential 

type UserPasswordAccessCredential struct {
	// Source represents where the user passwords are pulled from
	Source UserPasswordAccessCredentialSource `json:"source"`

	// propagationMethod represents how the user passwords are injected into the vm guest.
	PropagationMethod UserPasswordAccessCredentialPropagationMethod `json:"propagationMethod"`
}

UserPasswordAccessCredential represents a source and propagation method for injecting user passwords into a vm guest Only one of its members may be specified.

func (*UserPasswordAccessCredential) DeepCopy 

func (in *UserPasswordAccessCredential) DeepCopy() *UserPasswordAccessCredential

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

func (*UserPasswordAccessCredential) DeepCopyInto 

func (in *UserPasswordAccessCredential) DeepCopyInto(out *UserPasswordAccessCredential)

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

func (UserPasswordAccessCredential) SwaggerDoc 

func (UserPasswordAccessCredential) SwaggerDoc() map[string]string

type UserPasswordAccessCredentialPropagationMethod 

type UserPasswordAccessCredentialPropagationMethod struct {
	// QemuGuestAgentAccessCredentailPropagation means passwords are
	// dynamically injected into the vm at runtime via the qemu guest agent.
	// This feature requires the qemu guest agent to be running within the guest.
	// +optional
	QemuGuestAgent *QemuGuestAgentUserPasswordAccessCredentialPropagation `json:"qemuGuestAgent,omitempty"`
}

UserPasswordAccessCredentialPropagationMethod represents the method used to inject a user passwords into the vm guest. Only one of its members may be specified.

func (*UserPasswordAccessCredentialPropagationMethod) DeepCopy 

func (in *UserPasswordAccessCredentialPropagationMethod) DeepCopy() *UserPasswordAccessCredentialPropagationMethod

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

func (*UserPasswordAccessCredentialPropagationMethod) DeepCopyInto 

func (in *UserPasswordAccessCredentialPropagationMethod) DeepCopyInto(out *UserPasswordAccessCredentialPropagationMethod)

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

func (UserPasswordAccessCredentialPropagationMethod) SwaggerDoc 

func (UserPasswordAccessCredentialPropagationMethod) SwaggerDoc() map[string]string

type UserPasswordAccessCredentialSource 

type UserPasswordAccessCredentialSource struct {
	// Secret means that the access credential is pulled from a kubernetes secret
	// +optional
	Secret *AccessCredentialSecretSource `json:"secret,omitempty"`
}

UserPasswordAccessCredentialSource represents where to retrieve the user password credentials Only one of its members may be specified.

func (*UserPasswordAccessCredentialSource) DeepCopy 

func (in *UserPasswordAccessCredentialSource) DeepCopy() *UserPasswordAccessCredentialSource

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

func (*UserPasswordAccessCredentialSource) DeepCopyInto 

func (in *UserPasswordAccessCredentialSource) DeepCopyInto(out *UserPasswordAccessCredentialSource)

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

func (UserPasswordAccessCredentialSource) SwaggerDoc 

func (UserPasswordAccessCredentialSource) SwaggerDoc() map[string]string

type VGPUDisplayOptions 

type VGPUDisplayOptions struct {
	// Enabled determines if a display addapter backed by a vGPU should be enabled or disabled on the guest.
	// Defaults to true.
	// +optional
	Enabled *bool `json:"enabled,omitempty"`
	// Enables a boot framebuffer, until the guest OS loads a real GPU driver
	// Defaults to true.
	// +optional
	RamFB *FeatureState `json:"ramFB,omitempty"`
}

func (*VGPUDisplayOptions) DeepCopy 

func (in *VGPUDisplayOptions) DeepCopy() *VGPUDisplayOptions

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

func (*VGPUDisplayOptions) DeepCopyInto 

func (in *VGPUDisplayOptions) DeepCopyInto(out *VGPUDisplayOptions)

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

func (VGPUDisplayOptions) SwaggerDoc 

func (VGPUDisplayOptions) SwaggerDoc() map[string]string

type VGPUOptions 

type VGPUOptions struct {
	Display *VGPUDisplayOptions `json:"display,omitempty"`
}

func (*VGPUOptions) DeepCopy 

func (in *VGPUOptions) DeepCopy() *VGPUOptions

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

func (*VGPUOptions) DeepCopyInto 

func (in *VGPUOptions) DeepCopyInto(out *VGPUOptions)

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

func (VGPUOptions) SwaggerDoc 

func (VGPUOptions) SwaggerDoc() map[string]string

type VMISelector 

type VMISelector struct {
	// Name of the VirtualMachineInstance to migrate
	Name string `json:"name" valid:"required"`
}

func (*VMISelector) DeepCopy 

func (in *VMISelector) DeepCopy() *VMISelector

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

func (*VMISelector) DeepCopyInto 

func (in *VMISelector) DeepCopyInto(out *VMISelector)

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

func (VMISelector) SwaggerDoc 

func (VMISelector) SwaggerDoc() map[string]string

type VirtualMachine 

type VirtualMachine struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	// Spec contains the specification of VirtualMachineInstance created
	Spec VirtualMachineSpec `json:"spec" valid:"required"`
	// Status holds the current state of the controller and brief information
	// about its associated VirtualMachineInstance
	Status VirtualMachineStatus `json:"status,omitempty"`
}

VirtualMachine handles the VirtualMachines that are not running or are in a stopped state The VirtualMachine contains the template to create the VirtualMachineInstance. It also mirrors the running state of the created VirtualMachineInstance in its status.

+k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +genclient

func NewVMReferenceFromNameWithNS added in v0.49.0 

func NewVMReferenceFromNameWithNS(namespace string, name string) *VirtualMachine

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) RunStrategy 

func (vm *VirtualMachine) RunStrategy() (VirtualMachineRunStrategy, error)

Return the current runStrategy for the VirtualMachine if vm.spec.running is set, that will be mapped to runStrategy: 

false: RunStrategyHalted
true: RunStrategyAlways

func (VirtualMachine) SwaggerDoc 

func (VirtualMachine) SwaggerDoc() map[string]string

type VirtualMachineCondition 

type VirtualMachineCondition struct {
	Type   VirtualMachineConditionType `json:"type"`
	Status k8sv1.ConditionStatus       `json:"status"`
	// +nullable
	LastProbeTime metav1.Time `json:"lastProbeTime,omitempty"`
	// +nullable
	LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty"`
	Reason             string      `json:"reason,omitempty"`
	Message            string      `json:"message,omitempty"`
}

VirtualMachineCondition represents the state of VirtualMachine

func (*VirtualMachineCondition) DeepCopy 

func (in *VirtualMachineCondition) DeepCopy() *VirtualMachineCondition

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

func (*VirtualMachineCondition) DeepCopyInto 

func (in *VirtualMachineCondition) DeepCopyInto(out *VirtualMachineCondition)

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

func (VirtualMachineCondition) SwaggerDoc 

func (VirtualMachineCondition) SwaggerDoc() map[string]string

type VirtualMachineConditionType 

type VirtualMachineConditionType string
const (
	// VirtualMachineFailure is added in a virtual machine when its vmi
	// fails to be created due to insufficient quota, limit ranges, pod security policy, node selectors,
	// etc. or deleted due to kubelet being down or finalizers are failing.
	VirtualMachineFailure VirtualMachineConditionType = "Failure"

	// VirtualMachineReady is copied to the virtual machine from its vmi
	VirtualMachineReady VirtualMachineConditionType = "Ready"

	// VirtualMachinePaused is added in a virtual machine when its vmi
	// signals with its own condition that it is paused.
	VirtualMachinePaused VirtualMachineConditionType = "Paused"
)

type VirtualMachineInstance 

type VirtualMachineInstance struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	// VirtualMachineInstance Spec contains the VirtualMachineInstance specification.
	Spec VirtualMachineInstanceSpec `json:"spec" valid:"required"`
	// Status is the high level overview of how the VirtualMachineInstance is doing. It contains information available to controllers and users.
	Status VirtualMachineInstanceStatus `json:"status,omitempty"`
}

VirtualMachineInstance is *the* VirtualMachineInstance Definition. It represents a virtual machine in the runtime environment of kubernetes.

+k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +genclient

func NewVMI 

func NewVMI(name string, uid types.UID) *VirtualMachineInstance

func NewVMIReferenceFromName 

func NewVMIReferenceFromName(name string) *VirtualMachineInstance

TODO Namespace could be different, also store it somewhere in the domain, so that we can report deletes on handler startup properly

func NewVMIReferenceFromNameWithNS 

func NewVMIReferenceFromNameWithNS(namespace string, name string) *VirtualMachineInstance

func NewVMIReferenceWithUUID 

func NewVMIReferenceWithUUID(namespace string, name string, uuid types.UID) *VirtualMachineInstance

func (*VirtualMachineInstance) DeepCopy 

func (in *VirtualMachineInstance) DeepCopy() *VirtualMachineInstance

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

func (*VirtualMachineInstance) DeepCopyInto 

func (in *VirtualMachineInstance) DeepCopyInto(out *VirtualMachineInstance)

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

func (*VirtualMachineInstance) DeepCopyObject 

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

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

func (*VirtualMachineInstance) IsBootloaderEFI 

func (v *VirtualMachineInstance) IsBootloaderEFI() bool

func (*VirtualMachineInstance) IsCPUDedicated 

func (v *VirtualMachineInstance) IsCPUDedicated() bool

Checks if CPU pinning has been requested

func (*VirtualMachineInstance) IsFinal 

func (v *VirtualMachineInstance) IsFinal() bool

func (*VirtualMachineInstance) IsMarkedForDeletion 

func (v *VirtualMachineInstance) IsMarkedForDeletion() bool

func (*VirtualMachineInstance) IsMarkedForEviction 

func (v *VirtualMachineInstance) IsMarkedForEviction() bool

func (*VirtualMachineInstance) IsMigratable 

func (v *VirtualMachineInstance) IsMigratable() bool

func (*VirtualMachineInstance) IsRealtimeEnabled 

func (v *VirtualMachineInstance) IsRealtimeEnabled() bool

func (*VirtualMachineInstance) IsRunning 

func (v *VirtualMachineInstance) IsRunning() bool

func (*VirtualMachineInstance) IsScheduled 

func (v *VirtualMachineInstance) IsScheduled() bool

func (*VirtualMachineInstance) IsScheduling 

func (v *VirtualMachineInstance) IsScheduling() bool

func (*VirtualMachineInstance) IsUnknown 

func (v *VirtualMachineInstance) IsUnknown() bool

func (*VirtualMachineInstance) IsUnprocessed 

func (v *VirtualMachineInstance) IsUnprocessed() bool

func (*VirtualMachineInstance) MarshalBinary 

func (v *VirtualMachineInstance) MarshalBinary() (data []byte, err error)

func (*VirtualMachineInstance) ShouldStartPaused 

func (v *VirtualMachineInstance) ShouldStartPaused() bool

ShouldStartPaused returns true if VMI should be started in paused state

func (VirtualMachineInstance) SwaggerDoc 

func (VirtualMachineInstance) SwaggerDoc() map[string]string

func (*VirtualMachineInstance) UnmarshalBinary 

func (v *VirtualMachineInstance) UnmarshalBinary(data []byte) error

func (*VirtualMachineInstance) WantsToHaveQOSGuaranteed 

func (v *VirtualMachineInstance) WantsToHaveQOSGuaranteed() bool

WantsToHaveQOSGuaranteed checks if cpu and memoyr limits and requests are identical on the VMI. This is the indicator that people want a VMI with QOS of guaranteed

type VirtualMachineInstanceCondition 

type VirtualMachineInstanceCondition struct {
	Type   VirtualMachineInstanceConditionType `json:"type"`
	Status k8sv1.ConditionStatus               `json:"status"`
	// +nullable
	LastProbeTime metav1.Time `json:"lastProbeTime,omitempty"`
	// +nullable
	LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty"`
	Reason             string      `json:"reason,omitempty"`
	Message            string      `json:"message,omitempty"`
}

func (*VirtualMachineInstanceCondition) DeepCopy 

func (in *VirtualMachineInstanceCondition) DeepCopy() *VirtualMachineInstanceCondition

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

func (*VirtualMachineInstanceCondition) DeepCopyInto 

func (in *VirtualMachineInstanceCondition) DeepCopyInto(out *VirtualMachineInstanceCondition)

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

func (VirtualMachineInstanceCondition) SwaggerDoc 

func (VirtualMachineInstanceCondition) SwaggerDoc() map[string]string

type VirtualMachineInstanceConditionType 

type VirtualMachineInstanceConditionType string

type VirtualMachineInstanceFileSystem 

type VirtualMachineInstanceFileSystem struct {
	DiskName       string `json:"diskName"`
	MountPoint     string `json:"mountPoint"`
	FileSystemType string `json:"fileSystemType"`
	UsedBytes      int    `json:"usedBytes"`
	TotalBytes     int    `json:"totalBytes"`
}

VirtualMachineInstanceFileSystem represents guest os disk

func (*VirtualMachineInstanceFileSystem) DeepCopy 

func (in *VirtualMachineInstanceFileSystem) DeepCopy() *VirtualMachineInstanceFileSystem

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

func (*VirtualMachineInstanceFileSystem) DeepCopyInto 

func (in *VirtualMachineInstanceFileSystem) DeepCopyInto(out *VirtualMachineInstanceFileSystem)

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

func (VirtualMachineInstanceFileSystem) SwaggerDoc 

func (VirtualMachineInstanceFileSystem) SwaggerDoc() map[string]string

type VirtualMachineInstanceFileSystemInfo 

type VirtualMachineInstanceFileSystemInfo struct {
	Filesystems []VirtualMachineInstanceFileSystem `json:"disks"`
}

VirtualMachineInstanceFileSystemInfo represents information regarding single guest os filesystem

func (*VirtualMachineInstanceFileSystemInfo) DeepCopy 

func (in *VirtualMachineInstanceFileSystemInfo) DeepCopy() *VirtualMachineInstanceFileSystemInfo

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

func (*VirtualMachineInstanceFileSystemInfo) DeepCopyInto 

func (in *VirtualMachineInstanceFileSystemInfo) DeepCopyInto(out *VirtualMachineInstanceFileSystemInfo)

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

func (VirtualMachineInstanceFileSystemInfo) SwaggerDoc 

func (VirtualMachineInstanceFileSystemInfo) SwaggerDoc() map[string]string

type VirtualMachineInstanceFileSystemList 

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

VirtualMachineInstanceFileSystemList comprises the list of all filesystems on guest machine

+k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

func (*VirtualMachineInstanceFileSystemList) DeepCopy 

func (in *VirtualMachineInstanceFileSystemList) DeepCopy() *VirtualMachineInstanceFileSystemList

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

func (*VirtualMachineInstanceFileSystemList) DeepCopyInto 

func (in *VirtualMachineInstanceFileSystemList) DeepCopyInto(out *VirtualMachineInstanceFileSystemList)

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

func (*VirtualMachineInstanceFileSystemList) DeepCopyObject 

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

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

func (VirtualMachineInstanceFileSystemList) SwaggerDoc 

func (VirtualMachineInstanceFileSystemList) SwaggerDoc() map[string]string

type VirtualMachineInstanceGuestAgentInfo 

type VirtualMachineInstanceGuestAgentInfo struct {
	metav1.TypeMeta `json:",inline"`
	// GAVersion is a version of currently installed guest agent
	GAVersion string `json:"guestAgentVersion,omitempty"`
	// Return command list the guest agent supports
	// +listType=atomic
	SupportedCommands []GuestAgentCommandInfo `json:"supportedCommands,omitempty"`
	// Hostname represents FQDN of a guest
	Hostname string `json:"hostname,omitempty"`
	// OS contains the guest operating system information
	OS VirtualMachineInstanceGuestOSInfo `json:"os,omitempty"`
	// Timezone is guest os current timezone
	Timezone string `json:"timezone,omitempty"`
	// UserList is a list of active guest OS users
	UserList []VirtualMachineInstanceGuestOSUser `json:"userList,omitempty"`
	// FSInfo is a guest os filesystem information containing the disk mapping and disk mounts with usage
	FSInfo VirtualMachineInstanceFileSystemInfo `json:"fsInfo,omitempty"`
	// FSFreezeStatus is the state of the fs of the guest
	// it can be either frozen or thawed
	FSFreezeStatus string `json:"fsFreezeStatus,omitempty"`
}

VirtualMachineInstanceGuestAgentInfo represents information from the installed guest agent

+k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

func (*VirtualMachineInstanceGuestAgentInfo) DeepCopy 

func (in *VirtualMachineInstanceGuestAgentInfo) DeepCopy() *VirtualMachineInstanceGuestAgentInfo

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

func (*VirtualMachineInstanceGuestAgentInfo) DeepCopyInto 

func (in *VirtualMachineInstanceGuestAgentInfo) DeepCopyInto(out *VirtualMachineInstanceGuestAgentInfo)

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

func (*VirtualMachineInstanceGuestAgentInfo) DeepCopyObject 

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

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

func (VirtualMachineInstanceGuestAgentInfo) SwaggerDoc 

func (VirtualMachineInstanceGuestAgentInfo) SwaggerDoc() map[string]string

type VirtualMachineInstanceGuestOSInfo 

type VirtualMachineInstanceGuestOSInfo struct {
	// Name of the Guest OS
	Name string `json:"name,omitempty"`
	// Guest OS Kernel Release
	KernelRelease string `json:"kernelRelease,omitempty"`
	// Guest OS Version
	Version string `json:"version,omitempty"`
	// Guest OS Pretty Name
	PrettyName string `json:"prettyName,omitempty"`
	// Version ID of the Guest OS
	VersionID string `json:"versionId,omitempty"`
	// Kernel version of the Guest OS
	KernelVersion string `json:"kernelVersion,omitempty"`
	// Machine type of the Guest OS
	Machine string `json:"machine,omitempty"`
	// Guest OS Id
	ID string `json:"id,omitempty"`
}

func (*VirtualMachineInstanceGuestOSInfo) DeepCopy 

func (in *VirtualMachineInstanceGuestOSInfo) DeepCopy() *VirtualMachineInstanceGuestOSInfo

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

func (*VirtualMachineInstanceGuestOSInfo) DeepCopyInto 

func (in *VirtualMachineInstanceGuestOSInfo) DeepCopyInto(out *VirtualMachineInstanceGuestOSInfo)

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

func (VirtualMachineInstanceGuestOSInfo) SwaggerDoc 

func (VirtualMachineInstanceGuestOSInfo) SwaggerDoc() map[string]string

type VirtualMachineInstanceGuestOSUser 

type VirtualMachineInstanceGuestOSUser struct {
	UserName  string  `json:"userName"`
	Domain    string  `json:"domain,omitempty"`
	LoginTime float64 `json:"loginTime,omitempty"`
}

VirtualMachineGuestOSUser is the single user of the guest os

func (*VirtualMachineInstanceGuestOSUser) DeepCopy 

func (in *VirtualMachineInstanceGuestOSUser) DeepCopy() *VirtualMachineInstanceGuestOSUser

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

func (*VirtualMachineInstanceGuestOSUser) DeepCopyInto 

func (in *VirtualMachineInstanceGuestOSUser) DeepCopyInto(out *VirtualMachineInstanceGuestOSUser)

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

func (VirtualMachineInstanceGuestOSUser) SwaggerDoc 

func (VirtualMachineInstanceGuestOSUser) SwaggerDoc() map[string]string

type VirtualMachineInstanceGuestOSUserList 

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

VirtualMachineInstanceGuestOSUserList comprises the list of all active users on guest machine

+k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

func (*VirtualMachineInstanceGuestOSUserList) DeepCopy 

func (in *VirtualMachineInstanceGuestOSUserList) DeepCopy() *VirtualMachineInstanceGuestOSUserList

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

func (*VirtualMachineInstanceGuestOSUserList) DeepCopyInto 

func (in *VirtualMachineInstanceGuestOSUserList) DeepCopyInto(out *VirtualMachineInstanceGuestOSUserList)

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

func (*VirtualMachineInstanceGuestOSUserList) DeepCopyObject 

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

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

func (VirtualMachineInstanceGuestOSUserList) SwaggerDoc 

func (VirtualMachineInstanceGuestOSUserList) SwaggerDoc() map[string]string

type VirtualMachineInstanceList 

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

VirtualMachineInstanceList is a list of VirtualMachines

+k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

func (*VirtualMachineInstanceList) DeepCopy 

func (in *VirtualMachineInstanceList) DeepCopy() *VirtualMachineInstanceList

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

func (*VirtualMachineInstanceList) DeepCopyInto 

func (in *VirtualMachineInstanceList) DeepCopyInto(out *VirtualMachineInstanceList)

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

func (*VirtualMachineInstanceList) DeepCopyObject 

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

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

func (VirtualMachineInstanceList) SwaggerDoc 

func (VirtualMachineInstanceList) SwaggerDoc() map[string]string

type VirtualMachineInstanceMigration 

type VirtualMachineInstanceMigration struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	Spec              VirtualMachineInstanceMigrationSpec   `json:"spec" valid:"required"`
	Status            VirtualMachineInstanceMigrationStatus `json:"status,omitempty"`
}

VirtualMachineInstanceMigration represents the object tracking a VMI's migration to another host in the cluster

+k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +genclient

func (*VirtualMachineInstanceMigration) DeepCopy 

func (in *VirtualMachineInstanceMigration) DeepCopy() *VirtualMachineInstanceMigration

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

func (*VirtualMachineInstanceMigration) DeepCopyInto 

func (in *VirtualMachineInstanceMigration) DeepCopyInto(out *VirtualMachineInstanceMigration)

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

func (*VirtualMachineInstanceMigration) DeepCopyObject 

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

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

func (*VirtualMachineInstanceMigration) IsFinal 

func (m *VirtualMachineInstanceMigration) IsFinal() bool

The migration phase indicates that the job has completed

func (*VirtualMachineInstanceMigration) IsRunning 

func (m *VirtualMachineInstanceMigration) IsRunning() bool

func (VirtualMachineInstanceMigration) SwaggerDoc 

func (VirtualMachineInstanceMigration) SwaggerDoc() map[string]string

func (*VirtualMachineInstanceMigration) TargetIsCreated 

func (m *VirtualMachineInstanceMigration) TargetIsCreated() bool

The migration phase indicates that the target pod should have already been created

func (*VirtualMachineInstanceMigration) TargetIsHandedOff 

func (m *VirtualMachineInstanceMigration) TargetIsHandedOff() bool

The migration phase indicates that job has been handed off to the VMI controllers to complete.

type VirtualMachineInstanceMigrationCondition 

type VirtualMachineInstanceMigrationCondition struct {
	Type   VirtualMachineInstanceMigrationConditionType `json:"type"`
	Status k8sv1.ConditionStatus                        `json:"status"`
	// +nullable
	LastProbeTime metav1.Time `json:"lastProbeTime,omitempty"`
	// +nullable
	LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty"`
	Reason             string      `json:"reason,omitempty"`
	Message            string      `json:"message,omitempty"`
}

func (*VirtualMachineInstanceMigrationCondition) DeepCopy 

func (in *VirtualMachineInstanceMigrationCondition) DeepCopy() *VirtualMachineInstanceMigrationCondition

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

func (*VirtualMachineInstanceMigrationCondition) DeepCopyInto 

func (in *VirtualMachineInstanceMigrationCondition) DeepCopyInto(out *VirtualMachineInstanceMigrationCondition)

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

func (VirtualMachineInstanceMigrationCondition) SwaggerDoc 

func (VirtualMachineInstanceMigrationCondition) SwaggerDoc() map[string]string

type VirtualMachineInstanceMigrationConditionType 

type VirtualMachineInstanceMigrationConditionType string
const (
	// VirtualMachineInstanceMigrationAbortRequested indicates that live migration abort has been requested
	VirtualMachineInstanceMigrationAbortRequested VirtualMachineInstanceMigrationConditionType = "migrationAbortRequested"
)

These are valid conditions of VMIs.

type VirtualMachineInstanceMigrationList 

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

VirtualMachineInstanceMigrationList is a list of VirtualMachineMigrations

+k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

func (*VirtualMachineInstanceMigrationList) DeepCopy 

func (in *VirtualMachineInstanceMigrationList) DeepCopy() *VirtualMachineInstanceMigrationList

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

func (*VirtualMachineInstanceMigrationList) DeepCopyInto 

func (in *VirtualMachineInstanceMigrationList) DeepCopyInto(out *VirtualMachineInstanceMigrationList)

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

func (*VirtualMachineInstanceMigrationList) DeepCopyObject 

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

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

func (VirtualMachineInstanceMigrationList) SwaggerDoc 

func (VirtualMachineInstanceMigrationList) SwaggerDoc() map[string]string

type VirtualMachineInstanceMigrationMethod 

type VirtualMachineInstanceMigrationMethod string
const (
	// BlockMigration means that all VirtualMachineInstance disks should be copied over to the destination host
	BlockMigration VirtualMachineInstanceMigrationMethod = "BlockMigration"
	// LiveMigration means that VirtualMachineInstance disks will not be copied over to the destination host
	LiveMigration VirtualMachineInstanceMigrationMethod = "LiveMigration"
)

type VirtualMachineInstanceMigrationPhase 

type VirtualMachineInstanceMigrationPhase string

VirtualMachineInstanceMigrationPhase is a label for the condition of a VirtualMachineInstanceMigration at the current time. 

const (
	MigrationPhaseUnset VirtualMachineInstanceMigrationPhase = ""
	// The migration is accepted by the system
	MigrationPending VirtualMachineInstanceMigrationPhase = "Pending"
	// The migration's target pod is being scheduled
	MigrationScheduling VirtualMachineInstanceMigrationPhase = "Scheduling"
	// The migration's target pod is running
	MigrationScheduled VirtualMachineInstanceMigrationPhase = "Scheduled"
	// The migration's target pod is being prepared for migration
	MigrationPreparingTarget VirtualMachineInstanceMigrationPhase = "PreparingTarget"
	// The migration's target pod is prepared and ready for migration
	MigrationTargetReady VirtualMachineInstanceMigrationPhase = "TargetReady"
	// The migration is in progress
	MigrationRunning VirtualMachineInstanceMigrationPhase = "Running"
	// The migration passed
	MigrationSucceeded VirtualMachineInstanceMigrationPhase = "Succeeded"
	// The migration failed
	MigrationFailed VirtualMachineInstanceMigrationPhase = "Failed"
)

These are the valid migration phases

type VirtualMachineInstanceMigrationPhaseTransitionTimestamp added in v0.55.0 

type VirtualMachineInstanceMigrationPhaseTransitionTimestamp struct {
	// Phase is the status of the VirtualMachineInstanceMigrationPhase in kubernetes world. It is not the VirtualMachineInstanceMigrationPhase status, but partially correlates to it.
	Phase VirtualMachineInstanceMigrationPhase `json:"phase,omitempty"`
	// PhaseTransitionTimestamp is the timestamp of when the phase change occurred
	PhaseTransitionTimestamp metav1.Time `json:"phaseTransitionTimestamp,omitempty"`
}

VirtualMachineInstanceMigrationPhaseTransitionTimestamp gives a timestamp in relation to when a phase is set on a vmi

func (*VirtualMachineInstanceMigrationPhaseTransitionTimestamp) DeepCopy added in v0.55.0 

func (in *VirtualMachineInstanceMigrationPhaseTransitionTimestamp) DeepCopy() *VirtualMachineInstanceMigrationPhaseTransitionTimestamp

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

func (*VirtualMachineInstanceMigrationPhaseTransitionTimestamp) DeepCopyInto added in v0.55.0 

func (in *VirtualMachineInstanceMigrationPhaseTransitionTimestamp) DeepCopyInto(out *VirtualMachineInstanceMigrationPhaseTransitionTimestamp)

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

func (VirtualMachineInstanceMigrationPhaseTransitionTimestamp) SwaggerDoc added in v0.55.0 

func (VirtualMachineInstanceMigrationPhaseTransitionTimestamp) SwaggerDoc() map[string]string

type VirtualMachineInstanceMigrationSpec 

type VirtualMachineInstanceMigrationSpec struct {
	// The name of the VMI to perform the migration on. VMI must exist in the migration objects namespace
	VMIName string `json:"vmiName,omitempty" valid:"required"`
}

func (*VirtualMachineInstanceMigrationSpec) DeepCopy 

func (in *VirtualMachineInstanceMigrationSpec) DeepCopy() *VirtualMachineInstanceMigrationSpec

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

func (*VirtualMachineInstanceMigrationSpec) DeepCopyInto 

func (in *VirtualMachineInstanceMigrationSpec) DeepCopyInto(out *VirtualMachineInstanceMigrationSpec)

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

func (VirtualMachineInstanceMigrationSpec) SwaggerDoc 

func (VirtualMachineInstanceMigrationSpec) SwaggerDoc() map[string]string

type VirtualMachineInstanceMigrationState 

type VirtualMachineInstanceMigrationState struct {
	// The time the migration action began
	// +nullable
	StartTimestamp *metav1.Time `json:"startTimestamp,omitempty"`
	// The time the migration action ended
	// +nullable
	EndTimestamp *metav1.Time `json:"endTimestamp,omitempty"`

	// The Target Node has seen the Domain Start Event
	TargetNodeDomainDetected bool `json:"targetNodeDomainDetected,omitempty"`
	// The address of the target node to use for the migration
	TargetNodeAddress string `json:"targetNodeAddress,omitempty"`
	// The list of ports opened for live migration on the destination node
	TargetDirectMigrationNodePorts map[string]int `json:"targetDirectMigrationNodePorts,omitempty"`
	// The target node that the VMI is moving to
	TargetNode string `json:"targetNode,omitempty"`
	// The target pod that the VMI is moving to
	TargetPod string `json:"targetPod,omitempty"`
	// The UID of the target attachment pod for hotplug volumes
	TargetAttachmentPodUID types.UID `json:"targetAttachmentPodUID,omitempty"`
	// The source node that the VMI originated on
	SourceNode string `json:"sourceNode,omitempty"`
	// Indicates the migration completed
	Completed bool `json:"completed,omitempty"`
	// Indicates that the migration failed
	Failed bool `json:"failed,omitempty"`
	// Indicates that the migration has been requested to abort
	AbortRequested bool `json:"abortRequested,omitempty"`
	// Indicates the final status of the live migration abortion
	AbortStatus MigrationAbortStatus `json:"abortStatus,omitempty"`
	// The VirtualMachineInstanceMigration object associated with this migration
	MigrationUID types.UID `json:"migrationUid,omitempty"`
	// Lets us know if the vmi is currently running pre or post copy migration
	Mode MigrationMode `json:"mode,omitempty"`
	// Name of the migration policy. If string is empty, no policy is matched
	MigrationPolicyName *string `json:"migrationPolicyName,omitempty"`
	// Migration configurations to apply
	MigrationConfiguration *MigrationConfiguration `json:"migrationConfiguration,omitempty"`
	// If the VMI requires dedicated CPUs, this field will
	// hold the dedicated CPU set on the target node
	// +listType=atomic
	TargetCPUSet []int `json:"targetCPUSet,omitempty"`
	// If the VMI requires dedicated CPUs, this field will
	// hold the numa topology on the target node
	TargetNodeTopology string `json:"targetNodeTopology,omitempty"`
}

+k8s:openapi-gen=true

func (*VirtualMachineInstanceMigrationState) DeepCopy 

func (in *VirtualMachineInstanceMigrationState) DeepCopy() *VirtualMachineInstanceMigrationState

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

func (*VirtualMachineInstanceMigrationState) DeepCopyInto 

func (in *VirtualMachineInstanceMigrationState) DeepCopyInto(out *VirtualMachineInstanceMigrationState)

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

func (VirtualMachineInstanceMigrationState) SwaggerDoc 

func (VirtualMachineInstanceMigrationState) SwaggerDoc() map[string]string

type VirtualMachineInstanceMigrationStatus 

type VirtualMachineInstanceMigrationStatus struct {
	Phase      VirtualMachineInstanceMigrationPhase       `json:"phase,omitempty"`
	Conditions []VirtualMachineInstanceMigrationCondition `json:"conditions,omitempty"`
	// PhaseTransitionTimestamp is the timestamp of when the last phase change occurred
	// +listType=atomic
	// +optional
	PhaseTransitionTimestamps []VirtualMachineInstanceMigrationPhaseTransitionTimestamp `json:"phaseTransitionTimestamps,omitempty"`
}

VirtualMachineInstanceMigration reprents information pertaining to a VMI's migration.

func (*VirtualMachineInstanceMigrationStatus) DeepCopy 

func (in *VirtualMachineInstanceMigrationStatus) DeepCopy() *VirtualMachineInstanceMigrationStatus

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

func (*VirtualMachineInstanceMigrationStatus) DeepCopyInto 

func (in *VirtualMachineInstanceMigrationStatus) DeepCopyInto(out *VirtualMachineInstanceMigrationStatus)

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

func (VirtualMachineInstanceMigrationStatus) SwaggerDoc 

func (VirtualMachineInstanceMigrationStatus) SwaggerDoc() map[string]string

type VirtualMachineInstanceMigrationTransport 

type VirtualMachineInstanceMigrationTransport string
const (
	// MigrationTransportUnix means that the VMI will be migrated using the unix URI
	MigrationTransportUnix VirtualMachineInstanceMigrationTransport = "Unix"
)

type VirtualMachineInstanceNetworkInterface 

type VirtualMachineInstanceNetworkInterface struct {
	// IP address of a Virtual Machine interface. It is always the first item of
	// IPs
	IP string `json:"ipAddress,omitempty"`
	// Hardware address of a Virtual Machine interface
	MAC string `json:"mac,omitempty"`
	// Name of the interface, corresponds to name of the network assigned to the interface
	Name string `json:"name,omitempty"`
	// List of all IP addresses of a Virtual Machine interface
	IPs []string `json:"ipAddresses,omitempty"`
	// The interface name inside the Virtual Machine
	InterfaceName string `json:"interfaceName,omitempty"`
	// Specifies the origin of the interface data collected. values: domain, guest-agent, or both
	InfoSource string `json:"infoSource,omitempty"`
	// Specifies how many queues are allocated by MultiQueue
	QueueCount int32 `json:"queueCount,omitempty"`
}

func (*VirtualMachineInstanceNetworkInterface) DeepCopy 

func (in *VirtualMachineInstanceNetworkInterface) DeepCopy() *VirtualMachineInstanceNetworkInterface

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

func (*VirtualMachineInstanceNetworkInterface) DeepCopyInto 

func (in *VirtualMachineInstanceNetworkInterface) DeepCopyInto(out *VirtualMachineInstanceNetworkInterface)

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

func (VirtualMachineInstanceNetworkInterface) SwaggerDoc 

func (VirtualMachineInstanceNetworkInterface) SwaggerDoc() map[string]string

type VirtualMachineInstancePhase 

type VirtualMachineInstancePhase string

VirtualMachineInstancePhase is a label for the condition of a VirtualMachineInstance at the current time. 

const (
	//When a VirtualMachineInstance Object is first initialized and no phase, or Pending is present.
	VmPhaseUnset VirtualMachineInstancePhase = ""
	// Pending means the VirtualMachineInstance has been accepted by the system.
	Pending VirtualMachineInstancePhase = "Pending"
	// A target Pod exists but is not yet scheduled and in running state.
	Scheduling VirtualMachineInstancePhase = "Scheduling"
	// A target pod was scheduled and the system saw that Pod in runnig state.
	// Here is where the responsibility of virt-controller ends and virt-handler takes over.
	Scheduled VirtualMachineInstancePhase = "Scheduled"
	// Running means the pod has been bound to a node and the VirtualMachineInstance is started.
	Running VirtualMachineInstancePhase = "Running"
	// Succeeded means that the VirtualMachineInstance stopped voluntarily, e.g. reacted to SIGTERM or shutdown was invoked from
	// inside the VirtualMachineInstance.
	Succeeded VirtualMachineInstancePhase = "Succeeded"
	// Failed means that the vmi crashed, disappeared unexpectedly or got deleted from the cluster before it was ever started.
	Failed VirtualMachineInstancePhase = "Failed"
	// Unknown means that for some reason the state of the VirtualMachineInstance could not be obtained, typically due
	// to an error in communicating with the host of the VirtualMachineInstance.
	Unknown VirtualMachineInstancePhase = "Unknown"
)

These are the valid statuses of pods.

type VirtualMachineInstancePhaseTransitionTimestamp 

type VirtualMachineInstancePhaseTransitionTimestamp struct {
	// Phase is the status of the VirtualMachineInstance in kubernetes world. It is not the VirtualMachineInstance status, but partially correlates to it.
	Phase VirtualMachineInstancePhase `json:"phase,omitempty"`
	// PhaseTransitionTimestamp is the timestamp of when the phase change occurred
	PhaseTransitionTimestamp metav1.Time `json:"phaseTransitionTimestamp,omitempty"`
}

VirtualMachineInstancePhaseTransitionTimestamp gives a timestamp in relation to when a phase is set on a vmi

func (*VirtualMachineInstancePhaseTransitionTimestamp) DeepCopy 

func (in *VirtualMachineInstancePhaseTransitionTimestamp) DeepCopy() *VirtualMachineInstancePhaseTransitionTimestamp

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

func (*VirtualMachineInstancePhaseTransitionTimestamp) DeepCopyInto 

func (in *VirtualMachineInstancePhaseTransitionTimestamp) DeepCopyInto(out *VirtualMachineInstancePhaseTransitionTimestamp)

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

func (VirtualMachineInstancePhaseTransitionTimestamp) SwaggerDoc 

func (VirtualMachineInstancePhaseTransitionTimestamp) SwaggerDoc() map[string]string

type VirtualMachineInstancePreset 

type VirtualMachineInstancePreset struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	// VirtualMachineInstance Spec contains the VirtualMachineInstance specification.
	Spec VirtualMachineInstancePresetSpec `json:"spec,omitempty" valid:"required"`
}

Deprecated for removal in v2, please use VirtualMachineInstanceType and VirtualMachinePreference instead.

VirtualMachineInstancePreset defines a VMI spec.domain to be applied to all VMIs that match the provided label selector More info: https://kubevirt.io/user-guide/virtual_machines/presets/#overrides

+k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +genclient

func NewVirtualMachinePreset 

func NewVirtualMachinePreset(name string, selector metav1.LabelSelector) *VirtualMachineInstancePreset

func (*VirtualMachineInstancePreset) DeepCopy 

func (in *VirtualMachineInstancePreset) DeepCopy() *VirtualMachineInstancePreset

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

func (*VirtualMachineInstancePreset) DeepCopyInto 

func (in *VirtualMachineInstancePreset) DeepCopyInto(out *VirtualMachineInstancePreset)

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

func (*VirtualMachineInstancePreset) DeepCopyObject 

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

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

func (VirtualMachineInstancePreset) SwaggerDoc 

func (VirtualMachineInstancePreset) SwaggerDoc() map[string]string

type VirtualMachineInstancePresetList 

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

VirtualMachineInstancePresetList is a list of VirtualMachinePresets

+k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

func (*VirtualMachineInstancePresetList) DeepCopy 

func (in *VirtualMachineInstancePresetList) DeepCopy() *VirtualMachineInstancePresetList

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

func (*VirtualMachineInstancePresetList) DeepCopyInto 

func (in *VirtualMachineInstancePresetList) DeepCopyInto(out *VirtualMachineInstancePresetList)

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

func (*VirtualMachineInstancePresetList) DeepCopyObject 

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

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

func (VirtualMachineInstancePresetList) SwaggerDoc 

func (VirtualMachineInstancePresetList) SwaggerDoc() map[string]string

type VirtualMachineInstancePresetSpec 

type VirtualMachineInstancePresetSpec struct {
	// Selector is a label query over a set of VMIs.
	// Required.
	Selector metav1.LabelSelector `json:"selector"`
	// Domain is the same object type as contained in VirtualMachineInstanceSpec
	Domain *DomainSpec `json:"domain,omitempty"`
}

func (*VirtualMachineInstancePresetSpec) DeepCopy 

func (in *VirtualMachineInstancePresetSpec) DeepCopy() *VirtualMachineInstancePresetSpec

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

func (*VirtualMachineInstancePresetSpec) DeepCopyInto 

func (in *VirtualMachineInstancePresetSpec) DeepCopyInto(out *VirtualMachineInstancePresetSpec)

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

func (VirtualMachineInstancePresetSpec) SwaggerDoc 

func (VirtualMachineInstancePresetSpec) SwaggerDoc() map[string]string

type VirtualMachineInstanceReplicaSet 

type VirtualMachineInstanceReplicaSet struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	// VirtualMachineInstance Spec contains the VirtualMachineInstance specification.
	Spec VirtualMachineInstanceReplicaSetSpec `json:"spec" valid:"required"`
	// Status is the high level overview of how the VirtualMachineInstance is doing. It contains information available to controllers and users.
	// +nullable
	Status VirtualMachineInstanceReplicaSetStatus `json:"status,omitempty"`
}

VirtualMachineInstance is *the* VirtualMachineInstance Definition. It represents a virtual machine in the runtime environment of kubernetes.

+k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +genclient

func (*VirtualMachineInstanceReplicaSet) DeepCopy 

func (in *VirtualMachineInstanceReplicaSet) DeepCopy() *VirtualMachineInstanceReplicaSet

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

func (*VirtualMachineInstanceReplicaSet) DeepCopyInto 

func (in *VirtualMachineInstanceReplicaSet) DeepCopyInto(out *VirtualMachineInstanceReplicaSet)

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

func (*VirtualMachineInstanceReplicaSet) DeepCopyObject 

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

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

func (VirtualMachineInstanceReplicaSet) SwaggerDoc 

func (VirtualMachineInstanceReplicaSet) SwaggerDoc() map[string]string

type VirtualMachineInstanceReplicaSetCondition 

type VirtualMachineInstanceReplicaSetCondition struct {
	Type   VirtualMachineInstanceReplicaSetConditionType `json:"type"`
	Status k8sv1.ConditionStatus                         `json:"status"`
	// +nullable
	LastProbeTime metav1.Time `json:"lastProbeTime,omitempty"`
	// +nullable
	LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty"`
	Reason             string      `json:"reason,omitempty"`
	Message            string      `json:"message,omitempty"`
}

func (*VirtualMachineInstanceReplicaSetCondition) DeepCopy 

func (in *VirtualMachineInstanceReplicaSetCondition) DeepCopy() *VirtualMachineInstanceReplicaSetCondition

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

func (*VirtualMachineInstanceReplicaSetCondition) DeepCopyInto 

func (in *VirtualMachineInstanceReplicaSetCondition) DeepCopyInto(out *VirtualMachineInstanceReplicaSetCondition)

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

func (VirtualMachineInstanceReplicaSetCondition) SwaggerDoc 

func (VirtualMachineInstanceReplicaSetCondition) SwaggerDoc() map[string]string

type VirtualMachineInstanceReplicaSetConditionType 

type VirtualMachineInstanceReplicaSetConditionType string
const (
	// VirtualMachineInstanceReplicaSetReplicaFailure is added in a replica set when one of its vmis
	// fails to be created due to insufficient quota, limit ranges, pod security policy, node selectors,
	// etc. or deleted due to kubelet being down or finalizers are failing.
	VirtualMachineInstanceReplicaSetReplicaFailure VirtualMachineInstanceReplicaSetConditionType = "ReplicaFailure"

	// VirtualMachineInstanceReplicaSetReplicaPaused is added in a replica set when the replica set got paused by the controller.
	// After this condition was added, it is safe to remove or add vmis by hand and adjust the replica count by hand.
	VirtualMachineInstanceReplicaSetReplicaPaused VirtualMachineInstanceReplicaSetConditionType = "ReplicaPaused"
)

type VirtualMachineInstanceReplicaSetList 

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

VMIList is a list of VMIs

+k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

func (*VirtualMachineInstanceReplicaSetList) DeepCopy 

func (in *VirtualMachineInstanceReplicaSetList) DeepCopy() *VirtualMachineInstanceReplicaSetList

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

func (*VirtualMachineInstanceReplicaSetList) DeepCopyInto 

func (in *VirtualMachineInstanceReplicaSetList) DeepCopyInto(out *VirtualMachineInstanceReplicaSetList)

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

func (*VirtualMachineInstanceReplicaSetList) DeepCopyObject 

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

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

func (VirtualMachineInstanceReplicaSetList) SwaggerDoc 

func (VirtualMachineInstanceReplicaSetList) SwaggerDoc() map[string]string

type VirtualMachineInstanceReplicaSetSpec 

type VirtualMachineInstanceReplicaSetSpec struct {
	// Number of desired pods. This is a pointer to distinguish between explicit
	// zero and not specified. Defaults to 1.
	// +optional
	Replicas *int32 `json:"replicas,omitempty"`

	// Label selector for pods. Existing ReplicaSets whose pods are
	// selected by this will be the ones affected by this deployment.
	Selector *metav1.LabelSelector `json:"selector" valid:"required"`

	// Template describes the pods that will be created.
	Template *VirtualMachineInstanceTemplateSpec `json:"template" valid:"required"`

	// Indicates that the replica set is paused.
	// +optional
	Paused bool `json:"paused,omitempty" protobuf:"varint,7,opt,name=paused"`
}

func (*VirtualMachineInstanceReplicaSetSpec) DeepCopy 

func (in *VirtualMachineInstanceReplicaSetSpec) DeepCopy() *VirtualMachineInstanceReplicaSetSpec

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

func (*VirtualMachineInstanceReplicaSetSpec) DeepCopyInto 

func (in *VirtualMachineInstanceReplicaSetSpec) DeepCopyInto(out *VirtualMachineInstanceReplicaSetSpec)

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

func (VirtualMachineInstanceReplicaSetSpec) SwaggerDoc 

func (VirtualMachineInstanceReplicaSetSpec) SwaggerDoc() map[string]string

type VirtualMachineInstanceReplicaSetStatus 

type VirtualMachineInstanceReplicaSetStatus struct {
	// Total number of non-terminated pods targeted by this deployment (their labels match the selector).
	// +optional
	Replicas int32 `json:"replicas,omitempty" protobuf:"varint,2,opt,name=replicas"`

	// The number of ready replicas for this replica set.
	// +optional
	ReadyReplicas int32 `json:"readyReplicas,omitempty" protobuf:"varint,4,opt,name=readyReplicas"`

	Conditions []VirtualMachineInstanceReplicaSetCondition `json:"conditions,omitempty" optional:"true"`

	// Canonical form of the label selector for HPA which consumes it through the scale subresource.
	LabelSelector string `json:"labelSelector,omitempty"`
}

func (*VirtualMachineInstanceReplicaSetStatus) DeepCopy 

func (in *VirtualMachineInstanceReplicaSetStatus) DeepCopy() *VirtualMachineInstanceReplicaSetStatus

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

func (*VirtualMachineInstanceReplicaSetStatus) DeepCopyInto 

func (in *VirtualMachineInstanceReplicaSetStatus) DeepCopyInto(out *VirtualMachineInstanceReplicaSetStatus)

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

func (VirtualMachineInstanceReplicaSetStatus) SwaggerDoc 

func (VirtualMachineInstanceReplicaSetStatus) SwaggerDoc() map[string]string

type VirtualMachineInstanceSpec 

type VirtualMachineInstanceSpec struct {

	// If specified, indicates the pod's priority.
	// If not specified, the pod priority will be default or zero if there is no
	// default.
	// +optional
	PriorityClassName string `json:"priorityClassName,omitempty"`

	// Specification of the desired behavior of the VirtualMachineInstance on the host.
	Domain DomainSpec `json:"domain"`
	// NodeSelector is a selector which must be true for the vmi to fit on a node.
	// Selector which must match a node's labels for the vmi to be scheduled on that node.
	// More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/
	// +optional
	NodeSelector map[string]string `json:"nodeSelector,omitempty"`
	// If affinity is specifies, obey all the affinity rules
	Affinity *k8sv1.Affinity `json:"affinity,omitempty"`
	// If specified, the VMI will be dispatched by specified scheduler.
	// If not specified, the VMI will be dispatched by default scheduler.
	// +optional
	SchedulerName string `json:"schedulerName,omitempty"`
	// If toleration is specified, obey all the toleration rules.
	Tolerations []k8sv1.Toleration `json:"tolerations,omitempty"`
	// TopologySpreadConstraints describes how a group of VMIs will be spread across a given topology
	// domains. K8s scheduler will schedule VMI pods in a way which abides by the constraints.
	// +optional
	// +patchMergeKey=topologyKey
	// +patchStrategy=merge
	// +listType=map
	// +listMapKey=topologyKey
	// +listMapKey=whenUnsatisfiable
	TopologySpreadConstraints []k8sv1.TopologySpreadConstraint `json:"topologySpreadConstraints,omitempty" patchStrategy:"merge" patchMergeKey:"topologyKey"`
	// EvictionStrategy can be set to "LiveMigrate" if the VirtualMachineInstance should be
	// migrated instead of shut-off in case of a node drain.
	//
	// +optional
	EvictionStrategy *EvictionStrategy `json:"evictionStrategy,omitempty"`
	// StartStrategy can be set to "Paused" if Virtual Machine should be started in paused state.
	//
	// +optional
	StartStrategy *StartStrategy `json:"startStrategy,omitempty"`
	// Grace period observed after signalling a VirtualMachineInstance to stop after which the VirtualMachineInstance is force terminated.
	TerminationGracePeriodSeconds *int64 `json:"terminationGracePeriodSeconds,omitempty"`
	// List of volumes that can be mounted by disks belonging to the vmi.
	Volumes []Volume `json:"volumes,omitempty"`
	// Periodic probe of VirtualMachineInstance liveness.
	// VirtualmachineInstances will be stopped if the probe fails.
	// Cannot be updated.
	// More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
	// +optional
	LivenessProbe *Probe `json:"livenessProbe,omitempty"`
	// Periodic probe of VirtualMachineInstance service readiness.
	// VirtualmachineInstances will be removed from service endpoints if the probe fails.
	// Cannot be updated.
	// More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
	// +optional
	ReadinessProbe *Probe `json:"readinessProbe,omitempty"`
	// Specifies the hostname of the vmi
	// If not specified, the hostname will be set to the name of the vmi, if dhcp or cloud-init is configured properly.
	// +optional
	Hostname string `json:"hostname,omitempty"`
	// If specified, the fully qualified vmi hostname will be "<hostname>.<subdomain>.<pod namespace>.svc.<cluster domain>".
	// If not specified, the vmi will not have a domainname at all. The DNS entry will resolve to the vmi,
	// no matter if the vmi itself can pick up a hostname.
	// +optional
	Subdomain string `json:"subdomain,omitempty"`
	// List of networks that can be attached to a vm's virtual interface.
	Networks []Network `json:"networks,omitempty"`
	// Set DNS policy for the pod.
	// Defaults to "ClusterFirst".
	// Valid values are 'ClusterFirstWithHostNet', 'ClusterFirst', 'Default' or 'None'.
	// DNS parameters given in DNSConfig will be merged with the policy selected with DNSPolicy.
	// To have DNS options set along with hostNetwork, you have to specify DNS policy
	// explicitly to 'ClusterFirstWithHostNet'.
	// +optional
	DNSPolicy k8sv1.DNSPolicy `json:"dnsPolicy,omitempty" protobuf:"bytes,6,opt,name=dnsPolicy,casttype=DNSPolicy"`
	// Specifies the DNS parameters of a pod.
	// Parameters specified here will be merged to the generated DNS
	// configuration based on DNSPolicy.
	// +optional
	DNSConfig *k8sv1.PodDNSConfig `json:"dnsConfig,omitempty" protobuf:"bytes,26,opt,name=dnsConfig"`
	// Specifies a set of public keys to inject into the vm guest
	// +listType=atomic
	// +optional
	AccessCredentials []AccessCredential `json:"accessCredentials,omitempty"`
}

VirtualMachineInstanceSpec is a description of a VirtualMachineInstance.

func (*VirtualMachineInstanceSpec) DeepCopy 

func (in *VirtualMachineInstanceSpec) DeepCopy() *VirtualMachineInstanceSpec

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

func (*VirtualMachineInstanceSpec) DeepCopyInto 

func (in *VirtualMachineInstanceSpec) DeepCopyInto(out *VirtualMachineInstanceSpec)

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

func (VirtualMachineInstanceSpec) SwaggerDoc 

func (VirtualMachineInstanceSpec) SwaggerDoc() map[string]string

func (*VirtualMachineInstanceSpec) UnmarshalJSON added in v0.49.1 

func (vmiSpec *VirtualMachineInstanceSpec) UnmarshalJSON(data []byte) error

type VirtualMachineInstanceStatus 

type VirtualMachineInstanceStatus struct {
	// NodeName is the name where the VirtualMachineInstance is currently running.
	NodeName string `json:"nodeName,omitempty"`
	// A brief CamelCase message indicating details about why the VMI is in this state. e.g. 'NodeUnresponsive'
	// +optional
	Reason string `json:"reason,omitempty"`
	// Conditions are specific points in VirtualMachineInstance's pod runtime.
	Conditions []VirtualMachineInstanceCondition `json:"conditions,omitempty"`
	// Phase is the status of the VirtualMachineInstance in kubernetes world. It is not the VirtualMachineInstance status, but partially correlates to it.
	Phase VirtualMachineInstancePhase `json:"phase,omitempty"`
	// PhaseTransitionTimestamp is the timestamp of when the last phase change occurred
	// +listType=atomic
	// +optional
	PhaseTransitionTimestamps []VirtualMachineInstancePhaseTransitionTimestamp `json:"phaseTransitionTimestamps,omitempty"`
	// Interfaces represent the details of available network interfaces.
	Interfaces []VirtualMachineInstanceNetworkInterface `json:"interfaces,omitempty"`
	// Guest OS Information
	GuestOSInfo VirtualMachineInstanceGuestOSInfo `json:"guestOSInfo,omitempty"`
	// Represents the status of a live migration
	MigrationState *VirtualMachineInstanceMigrationState `json:"migrationState,omitempty"`
	// Represents the method using which the vmi can be migrated: live migration or block migration
	MigrationMethod VirtualMachineInstanceMigrationMethod `json:"migrationMethod,omitempty"`
	// This represents the migration transport
	MigrationTransport VirtualMachineInstanceMigrationTransport `json:"migrationTransport,omitempty"`
	// The Quality of Service (QOS) classification assigned to the virtual machine instance based on resource requirements
	// See PodQOSClass type for available QOS classes
	// More info: https://git.k8s.io/community/contributors/design-proposals/node/resource-qos.md
	// +optional
	QOSClass *k8sv1.PodQOSClass `json:"qosClass,omitempty"`

	// LauncherContainerImageVersion indicates what container image is currently active for the vmi.
	LauncherContainerImageVersion string `json:"launcherContainerImageVersion,omitempty"`

	// EvacuationNodeName is used to track the eviction process of a VMI. It stores the name of the node that we want
	// to evacuate. It is meant to be used by KubeVirt core components only and can't be set or modified by users.
	// +optional
	EvacuationNodeName string `json:"evacuationNodeName,omitempty"`

	// ActivePods is a mapping of pod UID to node name.
	// It is possible for multiple pods to be running for a single VMI during migration.
	ActivePods map[types.UID]string `json:"activePods,omitempty"`

	// VolumeStatus contains the statuses of all the volumes
	// +optional
	// +listType=atomic
	VolumeStatus []VolumeStatus `json:"volumeStatus,omitempty"`

	// FSFreezeStatus is the state of the fs of the guest
	// it can be either frozen or thawed
	// +optional
	FSFreezeStatus string `json:"fsFreezeStatus,omitempty"`

	// +optional
	TopologyHints *TopologyHints `json:"topologyHints,omitempty"`

	//VirtualMachineRevisionName is used to get the vm revision of the vmi when doing
	// an online vm snapshot
	// +optional
	VirtualMachineRevisionName string `json:"virtualMachineRevisionName,omitempty"`

	// RuntimeUser is used to determine what user will be used in launcher
	// +optional
	RuntimeUser uint64 `json:"runtimeUser"`

	// VSOCKCID is used to track the allocated VSOCK CID in the VM.
	// +optional
	VSOCKCID *uint32 `json:"VSOCKCID,omitempty"`
}

VirtualMachineInstanceStatus represents information about the status of a VirtualMachineInstance. Status may trail the actual state of a system.

func (*VirtualMachineInstanceStatus) DeepCopy 

func (in *VirtualMachineInstanceStatus) DeepCopy() *VirtualMachineInstanceStatus

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

func (*VirtualMachineInstanceStatus) DeepCopyInto 

func (in *VirtualMachineInstanceStatus) DeepCopyInto(out *VirtualMachineInstanceStatus)

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

func (VirtualMachineInstanceStatus) SwaggerDoc 

func (VirtualMachineInstanceStatus) SwaggerDoc() map[string]string

type VirtualMachineInstanceTemplateSpec 

type VirtualMachineInstanceTemplateSpec struct {
	// +kubebuilder:pruning:PreserveUnknownFields
	// +nullable
	ObjectMeta metav1.ObjectMeta `json:"metadata,omitempty"`
	// VirtualMachineInstance Spec contains the VirtualMachineInstance specification.
	Spec VirtualMachineInstanceSpec `json:"spec,omitempty" valid:"required"`
}

func (*VirtualMachineInstanceTemplateSpec) DeepCopy 

func (in *VirtualMachineInstanceTemplateSpec) DeepCopy() *VirtualMachineInstanceTemplateSpec

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

func (*VirtualMachineInstanceTemplateSpec) DeepCopyInto 

func (in *VirtualMachineInstanceTemplateSpec) DeepCopyInto(out *VirtualMachineInstanceTemplateSpec)

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

func (VirtualMachineInstanceTemplateSpec) SwaggerDoc 

func (VirtualMachineInstanceTemplateSpec) SwaggerDoc() map[string]string

type VirtualMachineList 

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

VirtualMachineList is a list of virtualmachines

+k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

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) SwaggerDoc 

func (VirtualMachineList) SwaggerDoc() map[string]string

type VirtualMachineMemoryDumpRequest added in v0.54.0 

type VirtualMachineMemoryDumpRequest struct {
	// ClaimName is the name of the pvc that will contain the memory dump
	ClaimName string `json:"claimName"`
	// Phase represents the memory dump phase
	Phase MemoryDumpPhase `json:"phase"`
	// Remove represents request of dissociating the memory dump pvc
	// +optional
	Remove bool `json:"remove,omitempty"`
	// StartTimestamp represents the time the memory dump started
	// +optional
	StartTimestamp *metav1.Time `json:"startTimestamp,omitempty"`
	// EndTimestamp represents the time the memory dump was completed
	// +optional
	EndTimestamp *metav1.Time `json:"endTimestamp,omitempty"`
	// FileName represents the name of the output file
	// +optional
	FileName *string `json:"fileName,omitempty"`
	// Message is a detailed message about failure of the memory dump
	// +optional
	Message string `json:"message,omitempty"`
}

VirtualMachineMemoryDumpRequest represent the memory dump request phase and info

func (*VirtualMachineMemoryDumpRequest) DeepCopy added in v0.54.0 

func (in *VirtualMachineMemoryDumpRequest) DeepCopy() *VirtualMachineMemoryDumpRequest

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

func (*VirtualMachineMemoryDumpRequest) DeepCopyInto added in v0.54.0 

func (in *VirtualMachineMemoryDumpRequest) DeepCopyInto(out *VirtualMachineMemoryDumpRequest)

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

func (VirtualMachineMemoryDumpRequest) SwaggerDoc added in v0.54.0 

func (VirtualMachineMemoryDumpRequest) SwaggerDoc() map[string]string

type VirtualMachinePrintableStatus 

type VirtualMachinePrintableStatus string

VirtualMachinePrintableStatus is a human readable, high-level representation of the status of the virtual machine. 

const (
	// VirtualMachineStatusStopped indicates that the virtual machine is currently stopped and isn't expected to start.
	VirtualMachineStatusStopped VirtualMachinePrintableStatus = "Stopped"
	// VirtualMachineStatusProvisioning indicates that cluster resources associated with the virtual machine
	// (e.g., DataVolumes) are being provisioned and prepared.
	VirtualMachineStatusProvisioning VirtualMachinePrintableStatus = "Provisioning"
	// VirtualMachineStatusStarting indicates that the virtual machine is being prepared for running.
	VirtualMachineStatusStarting VirtualMachinePrintableStatus = "Starting"
	// VirtualMachineStatusRunning indicates that the virtual machine is running.
	VirtualMachineStatusRunning VirtualMachinePrintableStatus = "Running"
	// VirtualMachineStatusPaused indicates that the virtual machine is paused.
	VirtualMachineStatusPaused VirtualMachinePrintableStatus = "Paused"
	// VirtualMachineStatusStopping indicates that the virtual machine is in the process of being stopped.
	VirtualMachineStatusStopping VirtualMachinePrintableStatus = "Stopping"
	// VirtualMachineStatusTerminating indicates that the virtual machine is in the process of deletion,
	// as well as its associated resources (VirtualMachineInstance, DataVolumes, …).
	VirtualMachineStatusTerminating VirtualMachinePrintableStatus = "Terminating"
	// VirtualMachineStatusCrashLoopBackOff indicates that the virtual machine is currently in a crash loop waiting to be retried.
	VirtualMachineStatusCrashLoopBackOff VirtualMachinePrintableStatus = "CrashLoopBackOff"
	// VirtualMachineStatusMigrating indicates that the virtual machine is in the process of being migrated
	// to another host.
	VirtualMachineStatusMigrating VirtualMachinePrintableStatus = "Migrating"
	// VirtualMachineStatusUnknown indicates that the state of the virtual machine could not be obtained,
	// typically due to an error in communicating with the host on which it's running.
	VirtualMachineStatusUnknown VirtualMachinePrintableStatus = "Unknown"
	// VirtualMachineStatusUnschedulable indicates that an error has occurred while scheduling the virtual machine,
	// e.g. due to unsatisfiable resource requests or unsatisfiable scheduling constraints.
	VirtualMachineStatusUnschedulable VirtualMachinePrintableStatus = "ErrorUnschedulable"
	// VirtualMachineStatusErrImagePull indicates that an error has occured while pulling an image for
	// a containerDisk VM volume.
	VirtualMachineStatusErrImagePull VirtualMachinePrintableStatus = "ErrImagePull"
	// VirtualMachineStatusImagePullBackOff indicates that an error has occured while pulling an image for
	// a containerDisk VM volume, and that kubelet is backing off before retrying.
	VirtualMachineStatusImagePullBackOff VirtualMachinePrintableStatus = "ImagePullBackOff"
	// VirtualMachineStatusPvcNotFound indicates that the virtual machine references a PVC volume which doesn't exist.
	VirtualMachineStatusPvcNotFound VirtualMachinePrintableStatus = "ErrorPvcNotFound"
	// VirtualMachineStatusDataVolumeError indicates that an error has been reported by one of the DataVolumes
	// referenced by the virtual machines.
	VirtualMachineStatusDataVolumeError VirtualMachinePrintableStatus = "DataVolumeError"
	// VirtualMachineStatusWaitingForVolumeBinding indicates that some PersistentVolumeClaims backing
	// the virtual machine volume are still not bound.
	VirtualMachineStatusWaitingForVolumeBinding VirtualMachinePrintableStatus = "WaitingForVolumeBinding"
)

A list of statuses defined for virtual machines

type VirtualMachineRunStrategy 

type VirtualMachineRunStrategy string

VirtualMachineRunStrategy is a label for the requested VirtualMachineInstance Running State at the current time. 

const (
	// Placeholder. Not a valid RunStrategy.
	RunStrategyUnknown VirtualMachineRunStrategy = ""
	// VMI should always be running.
	RunStrategyAlways VirtualMachineRunStrategy = "Always"
	// VMI should never be running.
	RunStrategyHalted VirtualMachineRunStrategy = "Halted"
	// VMI can be started/stopped using API endpoints.
	RunStrategyManual VirtualMachineRunStrategy = "Manual"
	// VMI will initially be running--and restarted if a failure occurs.
	// It will not be restarted upon successful completion.
	RunStrategyRerunOnFailure VirtualMachineRunStrategy = "RerunOnFailure"
	// VMI will run once and not be restarted upon completion regardless
	// if the completion is of phase Failure or Success
	RunStrategyOnce VirtualMachineRunStrategy = "Once"
)

These are the valid VMI run strategies

type VirtualMachineSpec 

type VirtualMachineSpec struct {
	// Running controls whether the associatied VirtualMachineInstance is created or not
	// Mutually exclusive with RunStrategy
	Running *bool `json:"running,omitempty" optional:"true"`

	// Running state indicates the requested running state of the VirtualMachineInstance
	// mutually exclusive with Running
	RunStrategy *VirtualMachineRunStrategy `json:"runStrategy,omitempty" optional:"true"`

	// InstancetypeMatcher references a instancetype that is used to fill fields in Template
	Instancetype *InstancetypeMatcher `json:"instancetype,omitempty" optional:"true"`

	// PreferenceMatcher references a set of preference that is used to fill fields in Template
	Preference *PreferenceMatcher `json:"preference,omitempty" optional:"true"`

	// Template is the direct specification of VirtualMachineInstance
	Template *VirtualMachineInstanceTemplateSpec `json:"template"`

	// dataVolumeTemplates is a list of dataVolumes that the VirtualMachineInstance template can reference.
	// DataVolumes in this list are dynamically created for the VirtualMachine and are tied to the VirtualMachine's life-cycle.
	DataVolumeTemplates []DataVolumeTemplateSpec `json:"dataVolumeTemplates,omitempty"`
}

VirtualMachineSpec describes how the proper VirtualMachine should look like

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.

func (VirtualMachineSpec) SwaggerDoc 

func (VirtualMachineSpec) SwaggerDoc() map[string]string

type VirtualMachineStartFailure 

type VirtualMachineStartFailure struct {
	ConsecutiveFailCount int          `json:"consecutiveFailCount,omitempty"`
	LastFailedVMIUID     types.UID    `json:"lastFailedVMIUID,omitempty"`
	RetryAfterTimestamp  *metav1.Time `json:"retryAfterTimestamp,omitempty"`
}

VirtualMachineStartFailure tracks VMIs which failed to transition successfully to running using the VM status

func (*VirtualMachineStartFailure) DeepCopy 

func (in *VirtualMachineStartFailure) DeepCopy() *VirtualMachineStartFailure

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

func (*VirtualMachineStartFailure) DeepCopyInto 

func (in *VirtualMachineStartFailure) DeepCopyInto(out *VirtualMachineStartFailure)

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

func (VirtualMachineStartFailure) SwaggerDoc 

func (VirtualMachineStartFailure) SwaggerDoc() map[string]string

type VirtualMachineStateChangeRequest 

type VirtualMachineStateChangeRequest struct {
	// Indicates the type of action that is requested. e.g. Start or Stop
	Action StateChangeRequestAction `json:"action"`
	// Provides additional data in order to perform the Action
	Data map[string]string `json:"data,omitempty" optional:"true"`
	// Indicates the UUID of an existing Virtual Machine Instance that this change request applies to -- if applicable
	UID *types.UID `json:"uid,omitempty" optional:"true" protobuf:"bytes,5,opt,name=uid,casttype=k8s.io/kubernetes/pkg/types.UID"`
}

func (*VirtualMachineStateChangeRequest) DeepCopy 

func (in *VirtualMachineStateChangeRequest) DeepCopy() *VirtualMachineStateChangeRequest

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

func (*VirtualMachineStateChangeRequest) DeepCopyInto 

func (in *VirtualMachineStateChangeRequest) DeepCopyInto(out *VirtualMachineStateChangeRequest)

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

func (VirtualMachineStateChangeRequest) SwaggerDoc 

func (VirtualMachineStateChangeRequest) SwaggerDoc() map[string]string

type VirtualMachineStatus 

type VirtualMachineStatus struct {
	// SnapshotInProgress is the name of the VirtualMachineSnapshot currently executing
	SnapshotInProgress *string `json:"snapshotInProgress,omitempty"`
	// RestoreInProgress is the name of the VirtualMachineRestore currently executing
	RestoreInProgress *string `json:"restoreInProgress,omitempty"`
	// Created indicates if the virtual machine is created in the cluster
	Created bool `json:"created,omitempty"`
	// Ready indicates if the virtual machine is running and ready
	Ready bool `json:"ready,omitempty"`
	// PrintableStatus is a human readable, high-level representation of the status of the virtual machine
	PrintableStatus VirtualMachinePrintableStatus `json:"printableStatus,omitempty"`
	// Hold the state information of the VirtualMachine and its VirtualMachineInstance
	Conditions []VirtualMachineCondition `json:"conditions,omitempty" optional:"true"`
	// StateChangeRequests indicates a list of actions that should be taken on a VMI
	// e.g. stop a specific VMI then start a new one.
	StateChangeRequests []VirtualMachineStateChangeRequest `json:"stateChangeRequests,omitempty" optional:"true"`
	// VolumeRequests indicates a list of volumes add or remove from the VMI template and
	// hotplug on an active running VMI.
	// +listType=atomic
	VolumeRequests []VirtualMachineVolumeRequest `json:"volumeRequests,omitempty" optional:"true"`

	// VolumeSnapshotStatuses indicates a list of statuses whether snapshotting is
	// supported by each volume.
	VolumeSnapshotStatuses []VolumeSnapshotStatus `json:"volumeSnapshotStatuses,omitempty" optional:"true"`

	// StartFailure tracks consecutive VMI startup failures for the purposes of
	// crash loop backoffs
	// +nullable
	// +optional
	StartFailure *VirtualMachineStartFailure `json:"startFailure,omitempty" optional:"true"`

	// MemoryDumpRequest tracks memory dump request phase and info of getting a memory
	// dump to the given pvc
	// +nullable
	// +optional
	MemoryDumpRequest *VirtualMachineMemoryDumpRequest `json:"memoryDumpRequest,omitempty" optional:"true"`
}

VirtualMachineStatus represents the status returned by the controller to describe how the VirtualMachine is doing

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.

func (VirtualMachineStatus) SwaggerDoc 

func (VirtualMachineStatus) SwaggerDoc() map[string]string

type VirtualMachineVolumeRequest 

type VirtualMachineVolumeRequest struct {
	// AddVolumeOptions when set indicates a volume should be added. The details
	// within this field specify how to add the volume
	AddVolumeOptions *AddVolumeOptions `json:"addVolumeOptions,omitempty" optional:"true"`
	// RemoveVolumeOptions when set indicates a volume should be removed. The details
	// within this field specify how to add the volume
	RemoveVolumeOptions *RemoveVolumeOptions `json:"removeVolumeOptions,omitempty" optional:"true"`
}

func (*VirtualMachineVolumeRequest) DeepCopy 

func (in *VirtualMachineVolumeRequest) DeepCopy() *VirtualMachineVolumeRequest

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

func (*VirtualMachineVolumeRequest) DeepCopyInto 

func (in *VirtualMachineVolumeRequest) DeepCopyInto(out *VirtualMachineVolumeRequest)

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

func (VirtualMachineVolumeRequest) SwaggerDoc 

func (VirtualMachineVolumeRequest) SwaggerDoc() map[string]string

type Volume 

type Volume struct {
	// Volume's name.
	// Must be a DNS_LABEL and unique within the vmi.
	// More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
	Name string `json:"name"`
	// VolumeSource represents the location and type of the mounted volume.
	// Defaults to Disk, if no type is specified.
	VolumeSource `json:",inline"`
}

Volume represents a named volume in a vmi.

func (*Volume) DeepCopy 

func (in *Volume) DeepCopy() *Volume

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

func (*Volume) DeepCopyInto 

func (in *Volume) DeepCopyInto(out *Volume)

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

func (Volume) SwaggerDoc 

func (Volume) SwaggerDoc() map[string]string

type VolumePhase 

type VolumePhase string

VolumePhase indicates the current phase of the hotplug process. 

const (
	// VolumePending means the Volume is pending and cannot be attached to the node yet.
	VolumePending VolumePhase = "Pending"
	// VolumeBound means the Volume is bound and can be attach to the node.
	VolumeBound VolumePhase = "Bound"
	// HotplugVolumeAttachedToNode means the volume has been attached to the node.
	HotplugVolumeAttachedToNode VolumePhase = "AttachedToNode"
	// HotplugVolumeMounted means the volume has been attached to the node and is mounted to the virt-launcher pod.
	HotplugVolumeMounted VolumePhase = "MountedToPod"
	// VolumeReady means the volume is ready to be used by the VirtualMachineInstance.
	VolumeReady VolumePhase = "Ready"
	// HotplugVolumeDetaching means the volume is being detached from the node, and the attachment pod is being removed.
	HotplugVolumeDetaching VolumePhase = "Detaching"
	// HotplugVolumeUnMounted means the volume has been unmounted from the virt-launcer pod.
	HotplugVolumeUnMounted VolumePhase = "UnMountedFromPod"
	// MemoryDumpVolumeCompleted means that the requested memory dump was completed and the dump is ready in the volume
	MemoryDumpVolumeCompleted VolumePhase = "MemoryDumpCompleted"
	// MemoryDumpVolumeInProgress means that the volume for the memory dump was attached, and now the command is being triggered
	MemoryDumpVolumeInProgress VolumePhase = "MemoryDumpInProgress"
	// MemoryDumpVolumeInProgress means that the volume for the memory dump was attached, and now the command is being triggered
	MemoryDumpVolumeFailed VolumePhase = "MemoryDumpFailed"
)

type VolumeSnapshotStatus 

type VolumeSnapshotStatus struct {
	// Volume name
	Name string `json:"name"`
	// True if the volume supports snapshotting
	Enabled bool `json:"enabled"`
	// Empty if snapshotting is enabled, contains reason otherwise
	Reason string `json:"reason,omitempty" optional:"true"`
}

func (*VolumeSnapshotStatus) DeepCopy 

func (in *VolumeSnapshotStatus) DeepCopy() *VolumeSnapshotStatus

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

func (*VolumeSnapshotStatus) DeepCopyInto 

func (in *VolumeSnapshotStatus) DeepCopyInto(out *VolumeSnapshotStatus)

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

func (VolumeSnapshotStatus) SwaggerDoc 

func (VolumeSnapshotStatus) SwaggerDoc() map[string]string

type VolumeSource 

type VolumeSource struct {
	// HostDisk represents a disk created on the cluster level
	// +optional
	HostDisk *HostDisk `json:"hostDisk,omitempty"`
	// PersistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace.
	// Directly attached to the vmi via qemu.
	// More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims
	// +optional
	PersistentVolumeClaim *PersistentVolumeClaimVolumeSource `json:"persistentVolumeClaim,omitempty"`
	// CloudInitNoCloud represents a cloud-init NoCloud user-data source.
	// The NoCloud data will be added as a disk to the vmi. A proper cloud-init installation is required inside the guest.
	// More info: http://cloudinit.readthedocs.io/en/latest/topics/datasources/nocloud.html
	// +optional
	CloudInitNoCloud *CloudInitNoCloudSource `json:"cloudInitNoCloud,omitempty"`
	// CloudInitConfigDrive represents a cloud-init Config Drive user-data source.
	// The Config Drive data will be added as a disk to the vmi. A proper cloud-init installation is required inside the guest.
	// More info: https://cloudinit.readthedocs.io/en/latest/topics/datasources/configdrive.html
	// +optional
	CloudInitConfigDrive *CloudInitConfigDriveSource `json:"cloudInitConfigDrive,omitempty"`
	// Represents a Sysprep volume source.
	// +optional
	Sysprep *SysprepSource `json:"sysprep,omitempty"`
	// ContainerDisk references a docker image, embedding a qcow or raw disk.
	// More info: https://kubevirt.gitbooks.io/user-guide/registry-disk.html
	// +optional
	ContainerDisk *ContainerDiskSource `json:"containerDisk,omitempty"`
	// Ephemeral is a special volume source that "wraps" specified source and provides copy-on-write image on top of it.
	// +optional
	Ephemeral *EphemeralVolumeSource `json:"ephemeral,omitempty"`
	// EmptyDisk represents a temporary disk which shares the vmis lifecycle.
	// More info: https://kubevirt.gitbooks.io/user-guide/disks-and-volumes.html
	// +optional
	EmptyDisk *EmptyDiskSource `json:"emptyDisk,omitempty"`
	// DataVolume represents the dynamic creation a PVC for this volume as well as
	// the process of populating that PVC with a disk image.
	// +optional
	DataVolume *DataVolumeSource `json:"dataVolume,omitempty"`
	// ConfigMapSource represents a reference to a ConfigMap in the same namespace.
	// More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-pod-configmap/
	// +optional
	ConfigMap *ConfigMapVolumeSource `json:"configMap,omitempty"`
	// SecretVolumeSource represents a reference to a secret data in the same namespace.
	// More info: https://kubernetes.io/docs/concepts/configuration/secret/
	// +optional
	Secret *SecretVolumeSource `json:"secret,omitempty"`
	// DownwardAPI represents downward API about the pod that should populate this volume
	// +optional
	DownwardAPI *DownwardAPIVolumeSource `json:"downwardAPI,omitempty"`
	// ServiceAccountVolumeSource represents a reference to a service account.
	// There can only be one volume of this type!
	// More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/
	// +optional
	ServiceAccount *ServiceAccountVolumeSource `json:"serviceAccount,omitempty"`
	// DownwardMetrics adds a very small disk to VMIs which contains a limited view of host and guest
	// metrics. The disk content is compatible with vhostmd (https://github.com/vhostmd/vhostmd) and vm-dump-metrics.
	DownwardMetrics *DownwardMetricsVolumeSource `json:"downwardMetrics,omitempty"`
	// MemoryDump is attached to the virt launcher and is populated with a memory dump of the vmi
	MemoryDump *MemoryDumpVolumeSource `json:"memoryDump,omitempty"`
}

Represents the source of a volume to mount. Only one of its members may be specified.

func (*VolumeSource) DeepCopy 

func (in *VolumeSource) DeepCopy() *VolumeSource

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

func (*VolumeSource) DeepCopyInto 

func (in *VolumeSource) DeepCopyInto(out *VolumeSource)

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

func (VolumeSource) SwaggerDoc 

func (VolumeSource) SwaggerDoc() map[string]string

type VolumeStatus 

type VolumeStatus struct {
	// Name is the name of the volume
	Name string `json:"name"`
	// Target is the target name used when adding the volume to the VM, eg: vda
	Target string `json:"target"`
	// Phase is the phase
	Phase VolumePhase `json:"phase,omitempty"`
	// Reason is a brief description of why we are in the current hotplug volume phase
	Reason string `json:"reason,omitempty"`
	// Message is a detailed message about the current hotplug volume phase
	Message string `json:"message,omitempty"`
	// PersistentVolumeClaimInfo is information about the PVC that handler requires during start flow
	PersistentVolumeClaimInfo *PersistentVolumeClaimInfo `json:"persistentVolumeClaimInfo,omitempty"`
	// If the volume is hotplug, this will contain the hotplug status.
	HotplugVolume *HotplugVolumeStatus `json:"hotplugVolume,omitempty"`
	// Represents the size of the volume
	Size int64 `json:"size,omitempty"`
	// If the volume is memorydump volume, this will contain the memorydump info.
	MemoryDumpVolume *DomainMemoryDumpInfo `json:"memoryDumpVolume,omitempty"`
}

VolumeStatus represents information about the status of volumes attached to the VirtualMachineInstance.

func (*VolumeStatus) DeepCopy 

func (in *VolumeStatus) DeepCopy() *VolumeStatus

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

func (*VolumeStatus) DeepCopyInto 

func (in *VolumeStatus) DeepCopyInto(out *VolumeStatus)

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

func (VolumeStatus) SwaggerDoc 

func (VolumeStatus) SwaggerDoc() map[string]string

type Watchdog 

type Watchdog struct {
	// Name of the watchdog.
	Name string `json:"name"`
	// WatchdogDevice contains the watchdog type and actions.
	// Defaults to i6300esb.
	WatchdogDevice `json:",inline"`
}

Named watchdog device.

func (*Watchdog) DeepCopy 

func (in *Watchdog) DeepCopy() *Watchdog

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

func (*Watchdog) DeepCopyInto 

func (in *Watchdog) DeepCopyInto(out *Watchdog)

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

func (Watchdog) SwaggerDoc 

func (Watchdog) SwaggerDoc() map[string]string

type WatchdogAction 

type WatchdogAction string

WatchdogAction defines the watchdog action, if a watchdog gets triggered. 

const (
	// WatchdogActionPoweroff will poweroff the vmi if the watchdog gets triggered.
	WatchdogActionPoweroff WatchdogAction = "poweroff"
	// WatchdogActionReset will reset the vmi if the watchdog gets triggered.
	WatchdogActionReset WatchdogAction = "reset"
	// WatchdogActionShutdown will shutdown the vmi if the watchdog gets triggered.
	WatchdogActionShutdown WatchdogAction = "shutdown"
)

type WatchdogDevice 

type WatchdogDevice struct {
	// i6300esb watchdog device.
	// +optional
	I6300ESB *I6300ESBWatchdog `json:"i6300esb,omitempty"`
}

Hardware watchdog device. Exactly one of its members must be set.

func (*WatchdogDevice) DeepCopy 

func (in *WatchdogDevice) DeepCopy() *WatchdogDevice

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

func (*WatchdogDevice) DeepCopyInto 

func (in *WatchdogDevice) DeepCopyInto(out *WatchdogDevice)

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

func (WatchdogDevice) SwaggerDoc 

func (WatchdogDevice) SwaggerDoc() map[string]string

type WorkloadUpdateMethod 

type WorkloadUpdateMethod string
const (
	// WorkloadUpdateMethodLiveMigrate allows VMIs which are capable of being
	// migrated to automatically migrate during automated workload updates.
	WorkloadUpdateMethodLiveMigrate WorkloadUpdateMethod = "LiveMigrate"
	// WorkloadUpdateMethodEvict results in a VMI's pod being evicted. Unless the
	// pod has a pod disruption budget allocated, the eviction will usually result in
	// the VMI being shutdown.
	// Depending on whether a VMI is backed by a VM or not, this will either result
	// in a restart of the VM by rescheduling a new VMI, or the shutdown via eviction
	// of a standalone VMI object.
	WorkloadUpdateMethodEvict WorkloadUpdateMethod = "Evict"
)

Source Files

View all Source files

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.