v1

package
v0.59.2 Latest Latest
Warning

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

 Go to latest Published: Jun 20, 2023 License: Apache-2.0 Imports: 13 Imported by: 589

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"

	// Used by functional tests to ignore backoff applied to migrations
	FuncTestForceIgnoreMigrationBackoffAnnotation string = "kubevirt.io/func-test-ignore-migration-backoff"

	// 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/"
	NodeHostModelIsObsoleteLabel   = "node-labeller.kubevirt.io/obsolete-host-model"

	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"
)
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,omitempty"`
}

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 CustomProfile added in v0.59.0 

type CustomProfile struct {
	LocalhostProfile      *string `json:"localhostProfile,omitempty"`
	RuntimeDefaultProfile bool    `json:"runtimeDefaultProfile,omitempty"`
}

func (*CustomProfile) DeepCopy added in v0.59.0 

func (in *CustomProfile) DeepCopy() *CustomProfile

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

func (*CustomProfile) DeepCopyInto added in v0.59.0 

func (in *CustomProfile) DeepCopyInto(out *CustomProfile)

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

func (CustomProfile) SwaggerDoc added in v0.59.0 

func (CustomProfile) 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 of both the DataVolume and the PVC in the same namespace.
	// After PVC population the DataVolume is garbage collected by default.
	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
	//
	// +optional
	Name string `json:"name,omitempty"`

	// 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"`

	// InferFromVolume lists the name of a volume that should be used to infer or discover the instancetype
	// to be used through known annotations on the underlying resource. Once applied to the InstancetypeMatcher
	// this field is removed.
	//
	// +optional
	InferFromVolume string `json:"inferFromVolume,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) GetName added in v0.59.1 

func (i InstancetypeMatcher) GetName() string

func (InstancetypeMatcher) GetRevisionName added in v0.59.1 

func (i InstancetypeMatcher) GetRevisionName() string

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"`
	// If specified, the ACPI index is used to provide network interface device naming, that is stable across changes
	// in PCI addresses assigned to the device.
	// This value is required to be unique across all devices and be between 1 and (16*1024-1).
	// +optional
	ACPIIndex int `json:"acpiIndex,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"`

	// AdditionalGuestMemoryOverheadRatio can be used to increase the virtualization infrastructure
	// overhead. This is useful, since the calculation of this overhead is not accurate and cannot
	// be entirely known in advance. The ratio that is being set determines by which factor to increase
	// the overhead calculated by Kubevirt. A higher ratio means that the VMs would be less compromised
	// by node pressures, but would mean that fewer VMs could be scheduled to a node.
	// If not set, the default is 1.
	AdditionalGuestMemoryOverheadRatio *string `json:"additionalGuestMemoryOverheadRatio,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"`
	SeccompConfiguration           *SeccompConfiguration             `json:"seccompConfiguration,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 imagePullSecrets to pull the container images from
	// Defaults to none
	// +listType=atomic
	ImagePullSecrets []k8sv1.LocalObjectReference `json:"imagePullSecrets,omitempty"`

	// 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 Matcher added in v0.59.1 

type Matcher interface {
	GetName() string
	GetRevisionName() string
}

type MediatedDevicesConfiguration 

type MediatedDevicesConfiguration struct {
	// Deprecated. Use mediatedDeviceTypes instead.
	// +optional
	// +listType=atomic
	MediatedDevicesTypes []string `json:"mediatedDevicesTypes,omitempty"`
	// +optional
	// +listType=atomic
	MediatedDeviceTypes []string `json:"mediatedDeviceTypes,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"`
	// Deprecated. Use mediatedDeviceTypes instead.
	// +optional
	// +listType=atomic
	MediatedDevicesTypes []string `json:"mediatedDevicesTypes,omitempty"`
	// +optional
	// +listType=atomic
	MediatedDeviceTypes []string `json:"mediatedDeviceTypes"`
}

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
	//
	// +optional
	Name string `json:"name,omitempty"`

	// 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"`

	// InferFromVolume lists the name of a volume that should be used to infer or discover the preference
	// to be used through known annotations on the underlying resource. Once applied to the PreferenceMatcher
	// this field is removed.
	//
	// +optional
	InferFromVolume string `json:"inferFromVolume,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) GetName added in v0.59.1 

func (p PreferenceMatcher) GetName() string

func (PreferenceMatcher) GetRevisionName added in v0.59.1 

func (p PreferenceMatcher) GetRevisionName() string

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 SeccompConfiguration added in v0.59.0 

type SeccompConfiguration struct {
	// VirtualMachineInstanceProfile defines what profile should be used with virt-launcher. Defaults to none
	VirtualMachineInstanceProfile *VirtualMachineInstanceProfile `json:"virtualMachineInstanceProfile,omitempty"`
}

SeccompConfiguration holds Seccomp configuration for Kubevirt components

func (*SeccompConfiguration) DeepCopy added in v0.59.0 

func (in *SeccompConfiguration) DeepCopy() *SeccompConfiguration

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

func (*SeccompConfiguration) DeepCopyInto added in v0.59.0 

func (in *SeccompConfiguration) DeepCopyInto(out *SeccompConfiguration)

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

func (SeccompConfiguration) SwaggerDoc added in v0.59.0 

func (SeccompConfiguration) 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 VSOCKOptions added in v0.59.0 

type VSOCKOptions struct {
	TargetPort uint32 `json:"targetPort"`
	UseTLS     *bool  `json:"useTLS,omitempty"`
}

func (*VSOCKOptions) DeepCopy added in v0.59.0 

func (in *VSOCKOptions) DeepCopy() *VSOCKOptions

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

func (*VSOCKOptions) DeepCopyInto added in v0.59.0 

func (in *VSOCKOptions) DeepCopyInto(out *VSOCKOptions)

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

func (VSOCKOptions) SwaggerDoc added in v0.59.0 

func (VSOCKOptions) 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"
	VirtualMachineInstanceMigrationRejectedByResourceQuota VirtualMachineInstanceMigrationConditionType = "migrationRejectedByResourceQuota"
)

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"`
	// Represents the status of a live migration
	MigrationState *VirtualMachineInstanceMigrationState `json:"migrationState,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 VirtualMachineInstanceProfile added in v0.59.0 

type VirtualMachineInstanceProfile struct {
	// CustomProfile allows to request arbitrary profile for virt-launcher
	CustomProfile *CustomProfile `json:"customProfile,omitempty"`
}

func (*VirtualMachineInstanceProfile) DeepCopy added in v0.59.0 

func (in *VirtualMachineInstanceProfile) DeepCopy() *VirtualMachineInstanceProfile

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

func (*VirtualMachineInstanceProfile) DeepCopyInto added in v0.59.0 

func (in *VirtualMachineInstanceProfile) DeepCopyInto(out *VirtualMachineInstanceProfile)

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

func (VirtualMachineInstanceProfile) SwaggerDoc added in v0.59.0 

func (VirtualMachineInstanceProfile) 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"`

	// SELinuxContext is the actual SELinux context of the virt-launcher pod
	// +optional
	SelinuxContext string `json:"selinuxContext,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.