c590843974
The 'bochs' display device is a recommended[1] safe option for UEFI guests. This is supported in libvirt from version 5.6.0; Nova's current MIN_LIBVIRT_VERSION (6.0.0) satisfies this requirement. Partially quoting the "bochs display device" section from a post written by a QEMU graphics maintainer[1]: [...] Main advantage over standard VGA is that this device is alot simpler. The code size and complexity needed to emulate this device is an order of magnitude smaller, resulting in a reduced attack surface. Another nice feature is that you can place this device in a PCI Express slot. For UEFI guests it is safe to use the bochs display device instead of the standard VGA device. The firmware will setup a linear framebuffer as GOP anyway and never use any legacy VGA features. For BIOS guests this device might be useable as well, depending on whenever they depend on direct VGA hardware access or not. There is a vgabios which supports text rendering on a linear framebuffer, so software which uses the vgabios services for text output will continue to work. Linux bootloaders typically fall into this category. The linux text mode console (vgacon) uses direct hardware access and does not work. The framebuffer console (fbcon running on vesafb or bochs-drm) works. [1] https://www.kraxel.org/blog/2019/09/display-devices-in-qemu/ Implements: blueprint add-bochs-display-device Change-Id: Id194028f5d2cbaac1c5e699b71fd9751f87f5da5 Signed-off-by: Kashyap Chamarthy <kchamart@redhat.com>
1362 lines
36 KiB
Python
1362 lines
36 KiB
Python
# Copyright 2013 Red Hat, Inc.
|
|
#
|
|
# 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.
|
|
|
|
import os
|
|
import re
|
|
|
|
from cursive import signature_utils
|
|
from oslo_serialization import jsonutils
|
|
from oslo_versionedobjects import fields
|
|
|
|
from nova import exception
|
|
from nova.i18n import _
|
|
from nova.network import model as network_model
|
|
from nova.virt import arch
|
|
|
|
|
|
# Import field errors from oslo.versionedobjects
|
|
KeyTypeError = fields.KeyTypeError
|
|
ElementTypeError = fields.ElementTypeError
|
|
|
|
|
|
# Import fields from oslo.versionedobjects
|
|
BooleanField = fields.BooleanField
|
|
UnspecifiedDefault = fields.UnspecifiedDefault
|
|
IntegerField = fields.IntegerField
|
|
NonNegativeIntegerField = fields.NonNegativeIntegerField
|
|
UUIDField = fields.UUIDField
|
|
FloatField = fields.FloatField
|
|
NonNegativeFloatField = fields.NonNegativeFloatField
|
|
StringField = fields.StringField
|
|
SensitiveStringField = fields.SensitiveStringField
|
|
EnumField = fields.EnumField
|
|
DateTimeField = fields.DateTimeField
|
|
DictOfStringsField = fields.DictOfStringsField
|
|
DictOfNullableStringsField = fields.DictOfNullableStringsField
|
|
DictOfIntegersField = fields.DictOfIntegersField
|
|
ListOfStringsField = fields.ListOfStringsField
|
|
ListOfUUIDField = fields.ListOfUUIDField
|
|
SetOfIntegersField = fields.SetOfIntegersField
|
|
ListOfSetsOfIntegersField = fields.ListOfSetsOfIntegersField
|
|
ListOfDictOfNullableStringsField = fields.ListOfDictOfNullableStringsField
|
|
DictProxyField = fields.DictProxyField
|
|
ObjectField = fields.ObjectField
|
|
ListOfObjectsField = fields.ListOfObjectsField
|
|
VersionPredicateField = fields.VersionPredicateField
|
|
FlexibleBooleanField = fields.FlexibleBooleanField
|
|
DictOfListOfStringsField = fields.DictOfListOfStringsField
|
|
IPAddressField = fields.IPAddressField
|
|
IPV4AddressField = fields.IPV4AddressField
|
|
IPV6AddressField = fields.IPV6AddressField
|
|
IPV4AndV6AddressField = fields.IPV4AndV6AddressField
|
|
IPNetworkField = fields.IPNetworkField
|
|
IPV4NetworkField = fields.IPV4NetworkField
|
|
IPV6NetworkField = fields.IPV6NetworkField
|
|
AutoTypedField = fields.AutoTypedField
|
|
BaseEnumField = fields.BaseEnumField
|
|
MACAddressField = fields.MACAddressField
|
|
ListOfIntegersField = fields.ListOfIntegersField
|
|
PCIAddressField = fields.PCIAddressField
|
|
|
|
|
|
# NOTE(danms): These are things we need to import for some of our
|
|
# own implementations below, our tests, or other transitional
|
|
# bits of code. These should be removable after we finish our
|
|
# conversion. So do not use these nova fields directly in any new code;
|
|
# instead, use the oslo.versionedobjects fields.
|
|
Enum = fields.Enum
|
|
Field = fields.Field
|
|
FieldType = fields.FieldType
|
|
Set = fields.Set
|
|
Dict = fields.Dict
|
|
List = fields.List
|
|
Object = fields.Object
|
|
IPAddress = fields.IPAddress
|
|
IPV4Address = fields.IPV4Address
|
|
IPV6Address = fields.IPV6Address
|
|
IPNetwork = fields.IPNetwork
|
|
IPV4Network = fields.IPV4Network
|
|
IPV6Network = fields.IPV6Network
|
|
|
|
|
|
class ResourceClass(fields.StringPattern):
|
|
|
|
PATTERN = r"^[A-Z0-9_]+$"
|
|
_REGEX = re.compile(PATTERN)
|
|
|
|
@staticmethod
|
|
def coerce(obj, attr, value):
|
|
if isinstance(value, str):
|
|
uppered = value.upper()
|
|
if ResourceClass._REGEX.match(uppered):
|
|
return uppered
|
|
raise ValueError(_("Malformed Resource Class %s") % value)
|
|
|
|
|
|
class ResourceClassField(AutoTypedField):
|
|
AUTO_TYPE = ResourceClass()
|
|
|
|
|
|
class SetOfStringsField(AutoTypedField):
|
|
AUTO_TYPE = Set(fields.String())
|
|
|
|
|
|
class BaseNovaEnum(Enum):
|
|
def __init__(self, **kwargs):
|
|
super(BaseNovaEnum, self).__init__(valid_values=self.__class__.ALL)
|
|
|
|
|
|
class Architecture(BaseNovaEnum):
|
|
"""Represents CPU architectures.
|
|
|
|
Provides the standard names for all known processor architectures.
|
|
Many have multiple variants to deal with big-endian vs little-endian
|
|
modes, as well as 32 vs 64 bit word sizes. These names are chosen to
|
|
be identical to the architecture names expected by libvirt, so if
|
|
ever adding new ones then ensure it matches libvirt's expectation.
|
|
"""
|
|
|
|
ALPHA = arch.ALPHA
|
|
ARMV6 = arch.ARMV6
|
|
ARMV7 = arch.ARMV7
|
|
ARMV7B = arch.ARMV7B
|
|
|
|
AARCH64 = arch.AARCH64
|
|
CRIS = arch.CRIS
|
|
I686 = arch.I686
|
|
IA64 = arch.IA64
|
|
LM32 = arch.LM32
|
|
|
|
M68K = arch.M68K
|
|
MICROBLAZE = arch.MICROBLAZE
|
|
MICROBLAZEEL = arch.MICROBLAZEEL
|
|
MIPS = arch.MIPS
|
|
MIPSEL = arch.MIPSEL
|
|
|
|
MIPS64 = arch.MIPS64
|
|
MIPS64EL = arch.MIPS64EL
|
|
OPENRISC = arch.OPENRISC
|
|
PARISC = arch.PARISC
|
|
PARISC64 = arch.PARISC64
|
|
|
|
PPC = arch.PPC
|
|
PPCLE = arch.PPCLE
|
|
PPC64 = arch.PPC64
|
|
PPC64LE = arch.PPC64LE
|
|
PPCEMB = arch.PPCEMB
|
|
|
|
S390 = arch.S390
|
|
S390X = arch.S390X
|
|
SH4 = arch.SH4
|
|
SH4EB = arch.SH4EB
|
|
SPARC = arch.SPARC
|
|
|
|
SPARC64 = arch.SPARC64
|
|
UNICORE32 = arch.UNICORE32
|
|
X86_64 = arch.X86_64
|
|
XTENSA = arch.XTENSA
|
|
XTENSAEB = arch.XTENSAEB
|
|
|
|
ALL = arch.ALL
|
|
|
|
@classmethod
|
|
def from_host(cls):
|
|
"""Get the architecture of the host OS
|
|
|
|
:returns: the canonicalized host architecture
|
|
"""
|
|
|
|
return cls.canonicalize(os.uname().machine)
|
|
|
|
@classmethod
|
|
def is_valid(cls, name):
|
|
"""Check if a string is a valid architecture
|
|
|
|
:param name: architecture name to validate
|
|
|
|
:returns: True if @name is valid
|
|
"""
|
|
|
|
return name in cls.ALL
|
|
|
|
@classmethod
|
|
def canonicalize(cls, name):
|
|
"""Canonicalize the architecture name
|
|
|
|
:param name: architecture name to canonicalize
|
|
|
|
:returns: a canonical architecture name
|
|
"""
|
|
|
|
if name is None:
|
|
return None
|
|
|
|
newname = name.lower()
|
|
|
|
if newname in ("i386", "i486", "i586"):
|
|
newname = cls.I686
|
|
|
|
# Xen mistake from Icehouse or earlier
|
|
if newname in ("x86_32", "x86_32p"):
|
|
newname = cls.I686
|
|
|
|
if newname == "amd64":
|
|
newname = cls.X86_64
|
|
|
|
if not cls.is_valid(newname):
|
|
raise exception.InvalidArchitectureName(arch=name)
|
|
|
|
return newname
|
|
|
|
def coerce(self, obj, attr, value):
|
|
try:
|
|
value = self.canonicalize(value)
|
|
except exception.InvalidArchitectureName:
|
|
msg = _("Architecture name '%s' is not valid") % value
|
|
raise ValueError(msg)
|
|
return super(Architecture, self).coerce(obj, attr, value)
|
|
|
|
|
|
class BlockDeviceDestinationType(BaseNovaEnum):
|
|
"""Represents possible destination_type values for a BlockDeviceMapping."""
|
|
|
|
LOCAL = 'local'
|
|
VOLUME = 'volume'
|
|
|
|
ALL = (LOCAL, VOLUME)
|
|
|
|
|
|
class BlockDeviceSourceType(BaseNovaEnum):
|
|
"""Represents the possible source_type values for a BlockDeviceMapping."""
|
|
|
|
BLANK = 'blank'
|
|
IMAGE = 'image'
|
|
SNAPSHOT = 'snapshot'
|
|
VOLUME = 'volume'
|
|
|
|
ALL = (BLANK, IMAGE, SNAPSHOT, VOLUME)
|
|
|
|
|
|
class BlockDeviceType(BaseNovaEnum):
|
|
"""Represents possible device_type values for a BlockDeviceMapping."""
|
|
|
|
CDROM = 'cdrom'
|
|
DISK = 'disk'
|
|
FLOPPY = 'floppy'
|
|
FS = 'fs'
|
|
LUN = 'lun'
|
|
|
|
ALL = (CDROM, DISK, FLOPPY, FS, LUN)
|
|
|
|
|
|
class ConfigDrivePolicy(BaseNovaEnum):
|
|
OPTIONAL = "optional"
|
|
MANDATORY = "mandatory"
|
|
|
|
ALL = (OPTIONAL, MANDATORY)
|
|
|
|
|
|
class CPUAllocationPolicy(BaseNovaEnum):
|
|
|
|
DEDICATED = "dedicated"
|
|
SHARED = "shared"
|
|
MIXED = "mixed"
|
|
|
|
ALL = (DEDICATED, SHARED, MIXED)
|
|
|
|
|
|
class CPUThreadAllocationPolicy(BaseNovaEnum):
|
|
|
|
# prefer (default): The host may or may not have hyperthreads. This
|
|
# retains the legacy behavior, whereby siblings are preferred when
|
|
# available. This is the default if no policy is specified.
|
|
PREFER = "prefer"
|
|
# isolate: The host may or many not have hyperthreads. If hyperthreads are
|
|
# present, each vCPU will be placed on a different core and no vCPUs from
|
|
# other guests will be able to be placed on the same core, i.e. one
|
|
# thread sibling is guaranteed to always be unused. If hyperthreads are
|
|
# not present, each vCPU will still be placed on a different core and
|
|
# there are no thread siblings to be concerned with.
|
|
ISOLATE = "isolate"
|
|
# require: The host must have hyperthreads. Each vCPU will be allocated on
|
|
# thread siblings.
|
|
REQUIRE = "require"
|
|
|
|
ALL = (PREFER, ISOLATE, REQUIRE)
|
|
|
|
|
|
class CPUEmulatorThreadsPolicy(BaseNovaEnum):
|
|
|
|
# share (default): Emulator threads float across the pCPUs
|
|
# associated to the guest.
|
|
SHARE = "share"
|
|
# isolate: Emulator threads are isolated on a single pCPU.
|
|
ISOLATE = "isolate"
|
|
|
|
ALL = (SHARE, ISOLATE)
|
|
|
|
|
|
class CPUMode(BaseNovaEnum):
|
|
|
|
CUSTOM = 'custom'
|
|
HOST_MODEL = 'host-model'
|
|
HOST_PASSTHROUGH = 'host-passthrough'
|
|
|
|
ALL = (CUSTOM, HOST_MODEL, HOST_PASSTHROUGH)
|
|
|
|
|
|
class CPUMatch(BaseNovaEnum):
|
|
|
|
MINIMUM = 'minimum'
|
|
EXACT = 'exact'
|
|
STRICT = 'strict'
|
|
|
|
ALL = (MINIMUM, EXACT, STRICT)
|
|
|
|
|
|
class CPUFeaturePolicy(BaseNovaEnum):
|
|
|
|
FORCE = 'force'
|
|
REQUIRE = 'require'
|
|
OPTIONAL = 'optional'
|
|
DISABLE = 'disable'
|
|
FORBID = 'forbid'
|
|
|
|
ALL = (FORCE, REQUIRE, OPTIONAL, DISABLE, FORBID)
|
|
|
|
|
|
class DiskBus(BaseNovaEnum):
|
|
|
|
# NOTE(aspiers): If you change this, don't forget to update the
|
|
# docs and metadata for hw_*_bus in glance.
|
|
# NOTE(lyarwood): Also update the possible values in the api-ref for the
|
|
# block_device_mapping_v2.disk_bus parameter.
|
|
FDC = "fdc"
|
|
IDE = "ide"
|
|
SATA = "sata"
|
|
SCSI = "scsi"
|
|
USB = "usb"
|
|
VIRTIO = "virtio"
|
|
XEN = "xen"
|
|
LXC = "lxc"
|
|
UML = "uml"
|
|
|
|
ALL = (FDC, IDE, SATA, SCSI, USB, VIRTIO, XEN, LXC, UML)
|
|
|
|
|
|
class DiskConfig(BaseNovaEnum):
|
|
|
|
MANUAL = "MANUAL"
|
|
AUTO = "AUTO"
|
|
|
|
ALL = (MANUAL, AUTO)
|
|
|
|
def coerce(self, obj, attr, value):
|
|
enum_value = DiskConfig.AUTO if value else DiskConfig.MANUAL
|
|
return super(DiskConfig, self).coerce(obj, attr, enum_value)
|
|
|
|
|
|
class FirmwareType(BaseNovaEnum):
|
|
|
|
UEFI = "uefi"
|
|
BIOS = "bios"
|
|
|
|
ALL = (UEFI, BIOS)
|
|
|
|
|
|
class HVType(BaseNovaEnum):
|
|
"""Represents virtualization types.
|
|
|
|
Provide the standard names for all known guest virtualization
|
|
types. This is not to be confused with the Nova hypervisor driver
|
|
types, since one driver may support multiple virtualization types
|
|
and one virtualization type may be supported by multiple drivers.
|
|
"""
|
|
|
|
BAREMETAL = 'baremetal'
|
|
BHYVE = 'bhyve'
|
|
DOCKER = 'docker'
|
|
FAKE = 'fake'
|
|
HYPERV = 'hyperv'
|
|
IRONIC = 'ironic'
|
|
KQEMU = 'kqemu'
|
|
KVM = 'kvm'
|
|
LXC = 'lxc'
|
|
LXD = 'lxd'
|
|
OPENVZ = 'openvz'
|
|
PARALLELS = 'parallels'
|
|
VIRTUOZZO = 'vz'
|
|
PHYP = 'phyp'
|
|
QEMU = 'qemu'
|
|
TEST = 'test'
|
|
UML = 'uml'
|
|
VBOX = 'vbox'
|
|
VMWARE = 'vmware'
|
|
XEN = 'xen'
|
|
ZVM = 'zvm'
|
|
PRSM = 'prsm'
|
|
|
|
ALL = (BAREMETAL, BHYVE, DOCKER, FAKE, HYPERV, IRONIC, KQEMU, KVM, LXC,
|
|
LXD, OPENVZ, PARALLELS, PHYP, QEMU, TEST, UML, VBOX, VIRTUOZZO,
|
|
VMWARE, XEN, ZVM, PRSM)
|
|
|
|
def coerce(self, obj, attr, value):
|
|
try:
|
|
value = self.canonicalize(value)
|
|
except exception.InvalidHypervisorVirtType:
|
|
msg = _("Hypervisor virt type '%s' is not valid") % value
|
|
raise ValueError(msg)
|
|
|
|
return super(HVType, self).coerce(obj, attr, value)
|
|
|
|
@classmethod
|
|
def is_valid(cls, name):
|
|
"""Check if a string is a valid hypervisor type
|
|
|
|
:param name: hypervisor type name to validate
|
|
|
|
:returns: True if @name is valid
|
|
"""
|
|
return name in cls.ALL
|
|
|
|
@classmethod
|
|
def canonicalize(cls, name):
|
|
"""Canonicalize the hypervisor type name
|
|
|
|
:param name: hypervisor type name to canonicalize
|
|
|
|
:returns: a canonical hypervisor type name
|
|
"""
|
|
if name is None:
|
|
return None
|
|
|
|
newname = name.lower()
|
|
|
|
if newname == 'xapi':
|
|
newname = cls.XEN
|
|
|
|
if not cls.is_valid(newname):
|
|
raise exception.InvalidHypervisorVirtType(hv_type=name)
|
|
|
|
return newname
|
|
|
|
|
|
class ImageSignatureHashType(BaseNovaEnum):
|
|
# Represents the possible hash methods used for image signing
|
|
ALL = tuple(sorted(signature_utils.HASH_METHODS.keys()))
|
|
|
|
|
|
class ImageSignatureKeyType(BaseNovaEnum):
|
|
# Represents the possible keypair types used for image signing
|
|
ALL = (
|
|
'DSA', 'ECC_SECP384R1', 'ECC_SECP521R1', 'ECC_SECT409K1',
|
|
'ECC_SECT409R1', 'ECC_SECT571K1', 'ECC_SECT571R1', 'RSA-PSS'
|
|
)
|
|
|
|
|
|
class InputBus(BaseNovaEnum):
|
|
|
|
USB = 'usb'
|
|
VIRTIO = 'virtio'
|
|
|
|
ALL = (USB, VIRTIO)
|
|
|
|
|
|
class MigrationType(BaseNovaEnum):
|
|
|
|
MIGRATION = 'migration' # cold migration
|
|
RESIZE = 'resize'
|
|
LIVE_MIGRATION = 'live-migration'
|
|
EVACUATION = 'evacuation'
|
|
|
|
ALL = (MIGRATION, RESIZE, LIVE_MIGRATION, EVACUATION)
|
|
|
|
|
|
class OSType(BaseNovaEnum):
|
|
|
|
LINUX = "linux"
|
|
WINDOWS = "windows"
|
|
|
|
ALL = (LINUX, WINDOWS)
|
|
|
|
def coerce(self, obj, attr, value):
|
|
# Some code/docs use upper case or initial caps
|
|
# so canonicalize to all lower case
|
|
value = value.lower()
|
|
return super(OSType, self).coerce(obj, attr, value)
|
|
|
|
|
|
class RNGModel(BaseNovaEnum):
|
|
|
|
# NOTE(kchamart): Along with "virtio", we may need to extend this (if a
|
|
# good reason shows up) to allow two more values for VirtIO
|
|
# transitional and non-transitional devices (available since libvirt
|
|
# 5.2.0):
|
|
#
|
|
# - virtio-transitional
|
|
# - virtio-nontransitional
|
|
#
|
|
# This allows one to choose whether you want to have compatibility
|
|
# with older guest operating systems. The value you select will in
|
|
# turn decide the kind of PCI topology the guest will get.
|
|
#
|
|
# Details:
|
|
# https://libvirt.org/formatdomain.html#elementsVirtioTransitional
|
|
VIRTIO = "virtio"
|
|
|
|
ALL = (VIRTIO,)
|
|
|
|
|
|
class TPMModel(BaseNovaEnum):
|
|
|
|
TIS = "tpm-tis"
|
|
CRB = "tpm-crb"
|
|
|
|
ALL = (TIS, CRB)
|
|
|
|
|
|
class TPMVersion(BaseNovaEnum):
|
|
v1_2 = "1.2"
|
|
v2_0 = "2.0"
|
|
|
|
ALL = (v1_2, v2_0)
|
|
|
|
|
|
class SCSIModel(BaseNovaEnum):
|
|
|
|
BUSLOGIC = "buslogic"
|
|
IBMVSCSI = "ibmvscsi"
|
|
LSILOGIC = "lsilogic"
|
|
LSISAS1068 = "lsisas1068"
|
|
LSISAS1078 = "lsisas1078"
|
|
VIRTIO_SCSI = "virtio-scsi"
|
|
VMPVSCSI = "vmpvscsi"
|
|
|
|
ALL = (BUSLOGIC, IBMVSCSI, LSILOGIC, LSISAS1068,
|
|
LSISAS1078, VIRTIO_SCSI, VMPVSCSI)
|
|
|
|
def coerce(self, obj, attr, value):
|
|
# Some compat for strings we'd see in the legacy
|
|
# vmware_adaptertype image property
|
|
value = value.lower()
|
|
if value == "lsilogicsas":
|
|
value = SCSIModel.LSISAS1068
|
|
elif value == "paravirtual":
|
|
value = SCSIModel.VMPVSCSI
|
|
|
|
return super(SCSIModel, self).coerce(obj, attr, value)
|
|
|
|
|
|
class SecureBoot(BaseNovaEnum):
|
|
|
|
REQUIRED = "required"
|
|
DISABLED = "disabled"
|
|
OPTIONAL = "optional"
|
|
|
|
ALL = (REQUIRED, DISABLED, OPTIONAL)
|
|
|
|
|
|
class VideoModel(BaseNovaEnum):
|
|
|
|
CIRRUS = "cirrus"
|
|
QXL = "qxl"
|
|
VGA = "vga"
|
|
VMVGA = "vmvga"
|
|
XEN = "xen"
|
|
VIRTIO = 'virtio'
|
|
GOP = 'gop'
|
|
NONE = 'none'
|
|
BOCHS = 'bochs'
|
|
|
|
ALL = (CIRRUS, QXL, VGA, VMVGA, XEN, VIRTIO, GOP, NONE, BOCHS)
|
|
|
|
|
|
class VIFModel(BaseNovaEnum):
|
|
|
|
LEGACY_VALUES = {"virtuale1000":
|
|
network_model.VIF_MODEL_E1000,
|
|
"virtuale1000e":
|
|
network_model.VIF_MODEL_E1000E,
|
|
"virtualpcnet32":
|
|
network_model.VIF_MODEL_PCNET,
|
|
"virtualsriovethernetcard":
|
|
network_model.VIF_MODEL_SRIOV,
|
|
"virtualvmxnet":
|
|
network_model.VIF_MODEL_VMXNET,
|
|
"virtualvmxnet3":
|
|
network_model.VIF_MODEL_VMXNET3,
|
|
}
|
|
|
|
ALL = network_model.VIF_MODEL_ALL
|
|
|
|
def coerce(self, obj, attr, value):
|
|
# Some compat for strings we'd see in the legacy
|
|
# hw_vif_model image property
|
|
value = value.lower()
|
|
value = VIFModel.LEGACY_VALUES.get(value, value)
|
|
return super(VIFModel, self).coerce(obj, attr, value)
|
|
|
|
|
|
class VMMode(BaseNovaEnum):
|
|
"""Represents possible vm modes for instances.
|
|
|
|
Compute instance VM modes represent the host/guest ABI used for the
|
|
virtual machine or container. Individual hypervisors may support
|
|
multiple different vm modes per host. Available VM modes for a
|
|
hypervisor driver may also vary according to the architecture it is
|
|
running on.
|
|
"""
|
|
HVM = 'hvm' # Native ABI (aka fully virtualized)
|
|
XEN = 'xen' # Xen 3.0 paravirtualized
|
|
UML = 'uml' # User Mode Linux paravirtualized
|
|
EXE = 'exe' # Executables in containers
|
|
|
|
ALL = (HVM, XEN, UML, EXE)
|
|
|
|
def coerce(self, obj, attr, value):
|
|
try:
|
|
value = self.canonicalize(value)
|
|
except exception.InvalidVirtualMachineMode:
|
|
msg = _("Virtual machine mode '%s' is not valid") % value
|
|
raise ValueError(msg)
|
|
|
|
return super(VMMode, self).coerce(obj, attr, value)
|
|
|
|
@classmethod
|
|
def get_from_instance(cls, instance):
|
|
"""Get the vm mode for an instance
|
|
|
|
:param instance: instance object to query
|
|
|
|
:returns: canonicalized vm mode for the instance
|
|
"""
|
|
mode = instance.vm_mode
|
|
|
|
return cls.canonicalize(mode)
|
|
|
|
@classmethod
|
|
def is_valid(cls, name):
|
|
"""Check if a string is a valid vm mode
|
|
|
|
:param name: vm mode name to validate
|
|
|
|
:returns: True if @name is valid
|
|
"""
|
|
return name in cls.ALL
|
|
|
|
@classmethod
|
|
def canonicalize(cls, mode):
|
|
"""Canonicalize the vm mode
|
|
|
|
:param name: vm mode name to canonicalize
|
|
|
|
:returns: a canonical vm mode name
|
|
"""
|
|
if mode is None:
|
|
return None
|
|
|
|
mode = mode.lower()
|
|
|
|
# For compatibility with pre-Folsom deployments
|
|
if mode == 'pv':
|
|
mode = cls.XEN
|
|
|
|
if mode == 'hv':
|
|
mode = cls.HVM
|
|
|
|
if mode == 'baremetal':
|
|
mode = cls.HVM
|
|
|
|
if not cls.is_valid(mode):
|
|
raise exception.InvalidVirtualMachineMode(vmmode=mode)
|
|
|
|
return mode
|
|
|
|
|
|
class WatchdogAction(BaseNovaEnum):
|
|
|
|
NONE = "none"
|
|
PAUSE = "pause"
|
|
POWEROFF = "poweroff"
|
|
RESET = "reset"
|
|
DISABLED = "disabled"
|
|
|
|
ALL = (NONE, PAUSE, POWEROFF, RESET, DISABLED)
|
|
|
|
|
|
class MonitorMetricType(BaseNovaEnum):
|
|
|
|
CPU_FREQUENCY = "cpu.frequency"
|
|
CPU_USER_TIME = "cpu.user.time"
|
|
CPU_KERNEL_TIME = "cpu.kernel.time"
|
|
CPU_IDLE_TIME = "cpu.idle.time"
|
|
CPU_IOWAIT_TIME = "cpu.iowait.time"
|
|
CPU_USER_PERCENT = "cpu.user.percent"
|
|
CPU_KERNEL_PERCENT = "cpu.kernel.percent"
|
|
CPU_IDLE_PERCENT = "cpu.idle.percent"
|
|
CPU_IOWAIT_PERCENT = "cpu.iowait.percent"
|
|
CPU_PERCENT = "cpu.percent"
|
|
NUMA_MEM_BW_MAX = "numa.membw.max"
|
|
NUMA_MEM_BW_CURRENT = "numa.membw.current"
|
|
|
|
ALL = (
|
|
CPU_FREQUENCY,
|
|
CPU_USER_TIME,
|
|
CPU_KERNEL_TIME,
|
|
CPU_IDLE_TIME,
|
|
CPU_IOWAIT_TIME,
|
|
CPU_USER_PERCENT,
|
|
CPU_KERNEL_PERCENT,
|
|
CPU_IDLE_PERCENT,
|
|
CPU_IOWAIT_PERCENT,
|
|
CPU_PERCENT,
|
|
NUMA_MEM_BW_MAX,
|
|
NUMA_MEM_BW_CURRENT,
|
|
)
|
|
|
|
|
|
class HostStatus(BaseNovaEnum):
|
|
|
|
UP = "UP" # The nova-compute is up.
|
|
DOWN = "DOWN" # The nova-compute is forced_down.
|
|
MAINTENANCE = "MAINTENANCE" # The nova-compute is disabled.
|
|
UNKNOWN = "UNKNOWN" # The nova-compute has not reported.
|
|
NONE = "" # No host or nova-compute.
|
|
|
|
ALL = (UP, DOWN, MAINTENANCE, UNKNOWN, NONE)
|
|
|
|
|
|
class PciDeviceStatus(BaseNovaEnum):
|
|
|
|
AVAILABLE = "available"
|
|
CLAIMED = "claimed"
|
|
ALLOCATED = "allocated"
|
|
REMOVED = "removed" # The device has been hot-removed and not yet deleted
|
|
DELETED = "deleted" # The device is marked not available/deleted.
|
|
UNCLAIMABLE = "unclaimable"
|
|
UNAVAILABLE = "unavailable"
|
|
|
|
ALL = (AVAILABLE, CLAIMED, ALLOCATED, REMOVED, DELETED, UNAVAILABLE,
|
|
UNCLAIMABLE)
|
|
|
|
|
|
class PciDeviceType(BaseNovaEnum):
|
|
|
|
# NOTE(jaypipes): It's silly that the word "type-" is in these constants,
|
|
# but alas, these were the original constant strings used...
|
|
STANDARD = "type-PCI"
|
|
SRIOV_PF = "type-PF"
|
|
SRIOV_VF = "type-VF"
|
|
# NOTE(sean-k-mooney): The DB field is Column(String(8), nullable=False)
|
|
# type-vdpa is 9 long...and as Jay notes above the prefix is silly so
|
|
# for the new vdpa value we drop the prefix to avoid a DB migration
|
|
VDPA = "vdpa"
|
|
|
|
ALL = (STANDARD, SRIOV_PF, SRIOV_VF, VDPA)
|
|
|
|
|
|
class PCINUMAAffinityPolicy(BaseNovaEnum):
|
|
|
|
REQUIRED = "required"
|
|
LEGACY = "legacy"
|
|
PREFERRED = "preferred"
|
|
SOCKET = "socket"
|
|
|
|
ALL = (REQUIRED, LEGACY, PREFERRED, SOCKET)
|
|
|
|
|
|
class DiskFormat(BaseNovaEnum):
|
|
RBD = "rbd"
|
|
LVM = "lvm"
|
|
QCOW2 = "qcow2"
|
|
RAW = "raw"
|
|
PLOOP = "ploop"
|
|
VHD = "vhd"
|
|
VMDK = "vmdk"
|
|
VDI = "vdi"
|
|
ISO = "iso"
|
|
|
|
ALL = (RBD, LVM, QCOW2, RAW, PLOOP, VHD, VMDK, VDI, ISO)
|
|
|
|
|
|
# TODO(stephenfin): Remove the xenapi value when we bump the 'Diagnostics'
|
|
# object (the only user of this enum) to 2.0
|
|
class HypervisorDriver(BaseNovaEnum):
|
|
LIBVIRT = "libvirt"
|
|
XENAPI = "xenapi"
|
|
VMWAREAPI = "vmwareapi"
|
|
IRONIC = "ironic"
|
|
HYPERV = "hyperv"
|
|
|
|
ALL = (LIBVIRT, XENAPI, VMWAREAPI, IRONIC, HYPERV)
|
|
|
|
|
|
class PointerModelType(BaseNovaEnum):
|
|
|
|
USBTABLET = "usbtablet"
|
|
|
|
ALL = (USBTABLET,)
|
|
|
|
|
|
class NotificationPriority(BaseNovaEnum):
|
|
AUDIT = 'audit'
|
|
CRITICAL = 'critical'
|
|
DEBUG = 'debug'
|
|
INFO = 'info'
|
|
ERROR = 'error'
|
|
SAMPLE = 'sample'
|
|
WARN = 'warn'
|
|
|
|
ALL = (AUDIT, CRITICAL, DEBUG, INFO, ERROR, SAMPLE, WARN)
|
|
|
|
|
|
class NotificationPhase(BaseNovaEnum):
|
|
START = 'start'
|
|
END = 'end'
|
|
ERROR = 'error'
|
|
PROGRESS = 'progress'
|
|
|
|
ALL = (START, END, ERROR, PROGRESS)
|
|
|
|
|
|
class NotificationSource(BaseNovaEnum):
|
|
"""Represents possible nova binary service names in notification envelope.
|
|
|
|
The publisher_id field of the nova notifications consists of the name of
|
|
the host and the name of the service binary that emits the notification.
|
|
The below values are the ones that is used in every notification. Please
|
|
note that on the REST API the nova-api service binary is called
|
|
nova-osapi_compute. This is not reflected here as notifications always used
|
|
the name nova-api instead.
|
|
"""
|
|
|
|
COMPUTE = 'nova-compute'
|
|
API = 'nova-api'
|
|
CONDUCTOR = 'nova-conductor'
|
|
SCHEDULER = 'nova-scheduler'
|
|
# TODO(stephenfin): Remove 'NETWORK' when 'NotificationPublisher' is
|
|
# updated to version 3.0
|
|
NETWORK = 'nova-network'
|
|
# TODO(stephenfin): Remove 'CONSOLEAUTH' when 'NotificationPublisher' is
|
|
# updated to version 3.0
|
|
CONSOLEAUTH = 'nova-consoleauth'
|
|
# TODO(stephenfin): Remove when 'NotificationPublisher' object version is
|
|
# bumped to 3.0
|
|
CELLS = 'nova-cells'
|
|
# TODO(stephenfin): Remove when 'NotificationPublisher' object version is
|
|
# bumped to 3.0
|
|
CONSOLE = 'nova-console'
|
|
METADATA = 'nova-metadata'
|
|
|
|
ALL = (API, COMPUTE, CONDUCTOR, SCHEDULER,
|
|
NETWORK, CONSOLEAUTH, CELLS, CONSOLE, METADATA)
|
|
|
|
@staticmethod
|
|
def get_source_by_binary(binary):
|
|
# nova-osapi_compute binary name needs to be translated to nova-api
|
|
# notification source enum value.
|
|
return "nova-api" if binary == "nova-osapi_compute" else binary
|
|
|
|
|
|
class NotificationAction(BaseNovaEnum):
|
|
UPDATE = 'update'
|
|
EXCEPTION = 'exception'
|
|
DELETE = 'delete'
|
|
PAUSE = 'pause'
|
|
UNPAUSE = 'unpause'
|
|
RESIZE = 'resize'
|
|
VOLUME_SWAP = 'volume_swap'
|
|
SUSPEND = 'suspend'
|
|
POWER_ON = 'power_on'
|
|
POWER_OFF = 'power_off'
|
|
REBOOT = 'reboot'
|
|
SHUTDOWN = 'shutdown'
|
|
SNAPSHOT = 'snapshot'
|
|
INTERFACE_ATTACH = 'interface_attach'
|
|
SHELVE = 'shelve'
|
|
RESUME = 'resume'
|
|
RESTORE = 'restore'
|
|
EXISTS = 'exists'
|
|
RESCUE = 'rescue'
|
|
VOLUME_ATTACH = 'volume_attach'
|
|
VOLUME_DETACH = 'volume_detach'
|
|
CREATE = 'create'
|
|
IMPORT = 'import'
|
|
EVACUATE = 'evacuate'
|
|
RESIZE_FINISH = 'resize_finish'
|
|
LIVE_MIGRATION_ABORT = 'live_migration_abort'
|
|
LIVE_MIGRATION_POST_DEST = 'live_migration_post_dest'
|
|
LIVE_MIGRATION_POST = 'live_migration_post'
|
|
LIVE_MIGRATION_PRE = 'live_migration_pre'
|
|
LIVE_MIGRATION_ROLLBACK_DEST = 'live_migration_rollback_dest'
|
|
LIVE_MIGRATION_ROLLBACK = 'live_migration_rollback'
|
|
LIVE_MIGRATION_FORCE_COMPLETE = 'live_migration_force_complete'
|
|
REBUILD = 'rebuild'
|
|
REBUILD_SCHEDULED = 'rebuild_scheduled'
|
|
INTERFACE_DETACH = 'interface_detach'
|
|
RESIZE_CONFIRM = 'resize_confirm'
|
|
RESIZE_PREP = 'resize_prep'
|
|
RESIZE_REVERT = 'resize_revert'
|
|
SELECT_DESTINATIONS = 'select_destinations'
|
|
SHELVE_OFFLOAD = 'shelve_offload'
|
|
SOFT_DELETE = 'soft_delete'
|
|
TRIGGER_CRASH_DUMP = 'trigger_crash_dump'
|
|
UNRESCUE = 'unrescue'
|
|
UNSHELVE = 'unshelve'
|
|
ADD_HOST = 'add_host'
|
|
REMOVE_HOST = 'remove_host'
|
|
ADD_MEMBER = 'add_member'
|
|
UPDATE_METADATA = 'update_metadata'
|
|
LOCK = 'lock'
|
|
UNLOCK = 'unlock'
|
|
UPDATE_PROP = 'update_prop'
|
|
CONNECT = 'connect'
|
|
USAGE = 'usage'
|
|
BUILD_INSTANCES = 'build_instances'
|
|
MIGRATE_SERVER = 'migrate_server'
|
|
REBUILD_SERVER = 'rebuild_server'
|
|
IMAGE_CACHE = 'cache_images'
|
|
|
|
ALL = (UPDATE, EXCEPTION, DELETE, PAUSE, UNPAUSE, RESIZE, VOLUME_SWAP,
|
|
SUSPEND, POWER_ON, REBOOT, SHUTDOWN, SNAPSHOT, INTERFACE_ATTACH,
|
|
POWER_OFF, SHELVE, RESUME, RESTORE, EXISTS, RESCUE, VOLUME_ATTACH,
|
|
VOLUME_DETACH, CREATE, IMPORT, EVACUATE, RESIZE_FINISH,
|
|
LIVE_MIGRATION_ABORT, LIVE_MIGRATION_POST_DEST, LIVE_MIGRATION_POST,
|
|
LIVE_MIGRATION_PRE, LIVE_MIGRATION_ROLLBACK,
|
|
LIVE_MIGRATION_ROLLBACK_DEST, REBUILD, INTERFACE_DETACH,
|
|
RESIZE_CONFIRM, RESIZE_PREP, RESIZE_REVERT, SHELVE_OFFLOAD,
|
|
SOFT_DELETE, TRIGGER_CRASH_DUMP, UNRESCUE, UNSHELVE, ADD_HOST,
|
|
REMOVE_HOST, ADD_MEMBER, UPDATE_METADATA, LOCK, UNLOCK,
|
|
REBUILD_SCHEDULED, UPDATE_PROP, LIVE_MIGRATION_FORCE_COMPLETE,
|
|
CONNECT, USAGE, BUILD_INSTANCES, MIGRATE_SERVER, REBUILD_SERVER,
|
|
SELECT_DESTINATIONS, IMAGE_CACHE)
|
|
|
|
|
|
# TODO(rlrossit): These should be changed over to be a StateMachine enum from
|
|
# oslo.versionedobjects using the valid state transitions described in
|
|
# nova.compute.vm_states
|
|
class InstanceState(BaseNovaEnum):
|
|
ACTIVE = 'active'
|
|
BUILDING = 'building'
|
|
PAUSED = 'paused'
|
|
SUSPENDED = 'suspended'
|
|
STOPPED = 'stopped'
|
|
RESCUED = 'rescued'
|
|
RESIZED = 'resized'
|
|
SOFT_DELETED = 'soft-delete'
|
|
DELETED = 'deleted'
|
|
ERROR = 'error'
|
|
SHELVED = 'shelved'
|
|
SHELVED_OFFLOADED = 'shelved_offloaded'
|
|
|
|
ALL = (ACTIVE, BUILDING, PAUSED, SUSPENDED, STOPPED, RESCUED, RESIZED,
|
|
SOFT_DELETED, DELETED, ERROR, SHELVED, SHELVED_OFFLOADED)
|
|
|
|
|
|
# TODO(rlrossit): These should be changed over to be a StateMachine enum from
|
|
# oslo.versionedobjects using the valid state transitions described in
|
|
# nova.compute.task_states
|
|
class InstanceTaskState(BaseNovaEnum):
|
|
SCHEDULING = 'scheduling'
|
|
BLOCK_DEVICE_MAPPING = 'block_device_mapping'
|
|
NETWORKING = 'networking'
|
|
SPAWNING = 'spawning'
|
|
IMAGE_SNAPSHOT = 'image_snapshot'
|
|
IMAGE_SNAPSHOT_PENDING = 'image_snapshot_pending'
|
|
IMAGE_PENDING_UPLOAD = 'image_pending_upload'
|
|
IMAGE_UPLOADING = 'image_uploading'
|
|
IMAGE_BACKUP = 'image_backup'
|
|
UPDATING_PASSWORD = 'updating_password'
|
|
RESIZE_PREP = 'resize_prep'
|
|
RESIZE_MIGRATING = 'resize_migrating'
|
|
RESIZE_MIGRATED = 'resize_migrated'
|
|
RESIZE_FINISH = 'resize_finish'
|
|
RESIZE_REVERTING = 'resize_reverting'
|
|
RESIZE_CONFIRMING = 'resize_confirming'
|
|
REBOOTING = 'rebooting'
|
|
REBOOT_PENDING = 'reboot_pending'
|
|
REBOOT_STARTED = 'reboot_started'
|
|
REBOOTING_HARD = 'rebooting_hard'
|
|
REBOOT_PENDING_HARD = 'reboot_pending_hard'
|
|
REBOOT_STARTED_HARD = 'reboot_started_hard'
|
|
PAUSING = 'pausing'
|
|
UNPAUSING = 'unpausing'
|
|
SUSPENDING = 'suspending'
|
|
RESUMING = 'resuming'
|
|
POWERING_OFF = 'powering-off'
|
|
POWERING_ON = 'powering-on'
|
|
RESCUING = 'rescuing'
|
|
UNRESCUING = 'unrescuing'
|
|
REBUILDING = 'rebuilding'
|
|
REBUILD_BLOCK_DEVICE_MAPPING = "rebuild_block_device_mapping"
|
|
REBUILD_SPAWNING = 'rebuild_spawning'
|
|
MIGRATING = "migrating"
|
|
DELETING = 'deleting'
|
|
SOFT_DELETING = 'soft-deleting'
|
|
RESTORING = 'restoring'
|
|
SHELVING = 'shelving'
|
|
SHELVING_IMAGE_PENDING_UPLOAD = 'shelving_image_pending_upload'
|
|
SHELVING_IMAGE_UPLOADING = 'shelving_image_uploading'
|
|
SHELVING_OFFLOADING = 'shelving_offloading'
|
|
UNSHELVING = 'unshelving'
|
|
|
|
ALL = (SCHEDULING, BLOCK_DEVICE_MAPPING, NETWORKING, SPAWNING,
|
|
IMAGE_SNAPSHOT, IMAGE_SNAPSHOT_PENDING, IMAGE_PENDING_UPLOAD,
|
|
IMAGE_UPLOADING, IMAGE_BACKUP, UPDATING_PASSWORD, RESIZE_PREP,
|
|
RESIZE_MIGRATING, RESIZE_MIGRATED, RESIZE_FINISH, RESIZE_REVERTING,
|
|
RESIZE_CONFIRMING, REBOOTING, REBOOT_PENDING, REBOOT_STARTED,
|
|
REBOOTING_HARD, REBOOT_PENDING_HARD, REBOOT_STARTED_HARD, PAUSING,
|
|
UNPAUSING, SUSPENDING, RESUMING, POWERING_OFF, POWERING_ON,
|
|
RESCUING, UNRESCUING, REBUILDING, REBUILD_BLOCK_DEVICE_MAPPING,
|
|
REBUILD_SPAWNING, MIGRATING, DELETING, SOFT_DELETING, RESTORING,
|
|
SHELVING, SHELVING_IMAGE_PENDING_UPLOAD, SHELVING_IMAGE_UPLOADING,
|
|
SHELVING_OFFLOADING, UNSHELVING)
|
|
|
|
|
|
class InstancePowerState(Enum):
|
|
_UNUSED = '_unused'
|
|
NOSTATE = 'pending'
|
|
RUNNING = 'running'
|
|
PAUSED = 'paused'
|
|
SHUTDOWN = 'shutdown'
|
|
CRASHED = 'crashed'
|
|
SUSPENDED = 'suspended'
|
|
# The order is important here. If you make changes, only *append*
|
|
# values to the end of the list.
|
|
ALL = (
|
|
NOSTATE,
|
|
RUNNING,
|
|
_UNUSED,
|
|
PAUSED,
|
|
SHUTDOWN,
|
|
_UNUSED,
|
|
CRASHED,
|
|
SUSPENDED,
|
|
)
|
|
|
|
def __init__(self):
|
|
super(InstancePowerState, self).__init__(
|
|
valid_values=InstancePowerState.ALL)
|
|
|
|
def coerce(self, obj, attr, value):
|
|
try:
|
|
value = int(value)
|
|
value = self.from_index(value)
|
|
except (ValueError, KeyError):
|
|
pass
|
|
return super(InstancePowerState, self).coerce(obj, attr, value)
|
|
|
|
@classmethod
|
|
def index(cls, value):
|
|
"""Return an index into the Enum given a value."""
|
|
return cls.ALL.index(value)
|
|
|
|
@classmethod
|
|
def from_index(cls, index):
|
|
"""Return the Enum value at a given index."""
|
|
return cls.ALL[index]
|
|
|
|
|
|
class NetworkModel(FieldType):
|
|
@staticmethod
|
|
def coerce(obj, attr, value):
|
|
if isinstance(value, network_model.NetworkInfo):
|
|
return value
|
|
elif isinstance(value, str):
|
|
# Hmm, do we need this?
|
|
return network_model.NetworkInfo.hydrate(value)
|
|
else:
|
|
raise ValueError(_('A NetworkModel is required in field %s') %
|
|
attr)
|
|
|
|
@staticmethod
|
|
def to_primitive(obj, attr, value):
|
|
return value.json()
|
|
|
|
@staticmethod
|
|
def from_primitive(obj, attr, value):
|
|
return network_model.NetworkInfo.hydrate(value)
|
|
|
|
def stringify(self, value):
|
|
return 'NetworkModel(%s)' % (
|
|
','.join([str(vif['id']) for vif in value]))
|
|
|
|
def get_schema(self):
|
|
return {'type': ['string']}
|
|
|
|
|
|
class NetworkVIFModel(FieldType):
|
|
"""Represents a nova.network.model.VIF object, which is a dict of stuff."""
|
|
|
|
@staticmethod
|
|
def coerce(obj, attr, value):
|
|
if isinstance(value, network_model.VIF):
|
|
return value
|
|
elif isinstance(value, str):
|
|
return NetworkVIFModel.from_primitive(obj, attr, value)
|
|
else:
|
|
raise ValueError(_('A nova.network.model.VIF object is required '
|
|
'in field %s') % attr)
|
|
|
|
@staticmethod
|
|
def to_primitive(obj, attr, value):
|
|
return jsonutils.dumps(value)
|
|
|
|
@staticmethod
|
|
def from_primitive(obj, attr, value):
|
|
return network_model.VIF.hydrate(jsonutils.loads(value))
|
|
|
|
def get_schema(self):
|
|
return {'type': ['string']}
|
|
|
|
|
|
class AddressBase(FieldType):
|
|
@staticmethod
|
|
def coerce(obj, attr, value):
|
|
if re.match(obj.PATTERN, str(value)):
|
|
return str(value)
|
|
else:
|
|
raise ValueError(_('Value must match %s') % obj.PATTERN)
|
|
|
|
def get_schema(self):
|
|
return {'type': ['string'], 'pattern': self.PATTERN}
|
|
|
|
|
|
class USBAddress(AddressBase):
|
|
PATTERN = '[a-f0-9]+:[a-f0-9]+'
|
|
|
|
@staticmethod
|
|
def coerce(obj, attr, value):
|
|
return AddressBase.coerce(USBAddress, attr, value)
|
|
|
|
|
|
class SCSIAddress(AddressBase):
|
|
PATTERN = '[a-f0-9]+:[a-f0-9]+:[a-f0-9]+:[a-f0-9]+'
|
|
|
|
@staticmethod
|
|
def coerce(obj, attr, value):
|
|
return AddressBase.coerce(SCSIAddress, attr, value)
|
|
|
|
|
|
class IDEAddress(AddressBase):
|
|
PATTERN = '[0-1]:[0-1]'
|
|
|
|
@staticmethod
|
|
def coerce(obj, attr, value):
|
|
return AddressBase.coerce(IDEAddress, attr, value)
|
|
|
|
|
|
class XenAddress(AddressBase):
|
|
PATTERN = '(00[0-9]{2}00)|[1-9][0-9]+'
|
|
|
|
@staticmethod
|
|
def coerce(obj, attr, value):
|
|
return AddressBase.coerce(XenAddress, attr, value)
|
|
|
|
|
|
class USBAddressField(AutoTypedField):
|
|
AUTO_TYPE = USBAddress()
|
|
|
|
|
|
class SCSIAddressField(AutoTypedField):
|
|
AUTO_TYPE = SCSIAddress()
|
|
|
|
|
|
class IDEAddressField(AutoTypedField):
|
|
AUTO_TYPE = IDEAddress()
|
|
|
|
|
|
class XenAddressField(AutoTypedField):
|
|
AUTO_TYPE = XenAddress()
|
|
|
|
|
|
class ArchitectureField(BaseEnumField):
|
|
AUTO_TYPE = Architecture()
|
|
|
|
|
|
class BlockDeviceDestinationTypeField(BaseEnumField):
|
|
AUTO_TYPE = BlockDeviceDestinationType()
|
|
|
|
|
|
class BlockDeviceSourceTypeField(BaseEnumField):
|
|
AUTO_TYPE = BlockDeviceSourceType()
|
|
|
|
|
|
class BlockDeviceTypeField(BaseEnumField):
|
|
AUTO_TYPE = BlockDeviceType()
|
|
|
|
|
|
class ConfigDrivePolicyField(BaseEnumField):
|
|
AUTO_TYPE = ConfigDrivePolicy()
|
|
|
|
|
|
class CPUAllocationPolicyField(BaseEnumField):
|
|
AUTO_TYPE = CPUAllocationPolicy()
|
|
|
|
|
|
class CPUThreadAllocationPolicyField(BaseEnumField):
|
|
AUTO_TYPE = CPUThreadAllocationPolicy()
|
|
|
|
|
|
class CPUEmulatorThreadsPolicyField(BaseEnumField):
|
|
AUTO_TYPE = CPUEmulatorThreadsPolicy()
|
|
|
|
|
|
class CPUModeField(BaseEnumField):
|
|
AUTO_TYPE = CPUMode()
|
|
|
|
|
|
class CPUMatchField(BaseEnumField):
|
|
AUTO_TYPE = CPUMatch()
|
|
|
|
|
|
class CPUFeaturePolicyField(BaseEnumField):
|
|
AUTO_TYPE = CPUFeaturePolicy()
|
|
|
|
|
|
class DiskBusField(BaseEnumField):
|
|
AUTO_TYPE = DiskBus()
|
|
|
|
|
|
class DiskConfigField(BaseEnumField):
|
|
AUTO_TYPE = DiskConfig()
|
|
|
|
|
|
class FirmwareTypeField(BaseEnumField):
|
|
AUTO_TYPE = FirmwareType()
|
|
|
|
|
|
class HVTypeField(BaseEnumField):
|
|
AUTO_TYPE = HVType()
|
|
|
|
|
|
class ImageSignatureHashTypeField(BaseEnumField):
|
|
AUTO_TYPE = ImageSignatureHashType()
|
|
|
|
|
|
class ImageSignatureKeyTypeField(BaseEnumField):
|
|
AUTO_TYPE = ImageSignatureKeyType()
|
|
|
|
|
|
class InputBusField(BaseEnumField):
|
|
AUTO_TYPE = InputBus()
|
|
|
|
|
|
class MigrationTypeField(BaseEnumField):
|
|
AUTO_TYPE = MigrationType()
|
|
|
|
|
|
class OSTypeField(BaseEnumField):
|
|
AUTO_TYPE = OSType()
|
|
|
|
|
|
class RNGModelField(BaseEnumField):
|
|
AUTO_TYPE = RNGModel()
|
|
|
|
|
|
class TPMModelField(BaseEnumField):
|
|
AUTO_TYPE = TPMModel()
|
|
|
|
|
|
class TPMVersionField(BaseEnumField):
|
|
AUTO_TYPE = TPMVersion()
|
|
|
|
|
|
class SCSIModelField(BaseEnumField):
|
|
AUTO_TYPE = SCSIModel()
|
|
|
|
|
|
class SecureBootField(BaseEnumField):
|
|
AUTO_TYPE = SecureBoot()
|
|
|
|
|
|
class VideoModelField(BaseEnumField):
|
|
AUTO_TYPE = VideoModel()
|
|
|
|
|
|
class VIFModelField(BaseEnumField):
|
|
AUTO_TYPE = VIFModel()
|
|
|
|
|
|
class VMModeField(BaseEnumField):
|
|
AUTO_TYPE = VMMode()
|
|
|
|
|
|
class WatchdogActionField(BaseEnumField):
|
|
AUTO_TYPE = WatchdogAction()
|
|
|
|
|
|
class MonitorMetricTypeField(BaseEnumField):
|
|
AUTO_TYPE = MonitorMetricType()
|
|
|
|
|
|
class PciDeviceStatusField(BaseEnumField):
|
|
AUTO_TYPE = PciDeviceStatus()
|
|
|
|
|
|
class PciDeviceTypeField(BaseEnumField):
|
|
AUTO_TYPE = PciDeviceType()
|
|
|
|
|
|
class PCINUMAAffinityPolicyField(BaseEnumField):
|
|
AUTO_TYPE = PCINUMAAffinityPolicy()
|
|
|
|
|
|
class DiskFormatField(BaseEnumField):
|
|
AUTO_TYPE = DiskFormat()
|
|
|
|
|
|
class HypervisorDriverField(BaseEnumField):
|
|
AUTO_TYPE = HypervisorDriver()
|
|
|
|
|
|
class PointerModelField(BaseEnumField):
|
|
AUTO_TYPE = PointerModelType()
|
|
|
|
|
|
class NotificationPriorityField(BaseEnumField):
|
|
AUTO_TYPE = NotificationPriority()
|
|
|
|
|
|
class NotificationPhaseField(BaseEnumField):
|
|
AUTO_TYPE = NotificationPhase()
|
|
|
|
|
|
class NotificationActionField(BaseEnumField):
|
|
AUTO_TYPE = NotificationAction()
|
|
|
|
|
|
class NotificationSourceField(BaseEnumField):
|
|
AUTO_TYPE = NotificationSource()
|
|
|
|
|
|
class InstanceStateField(BaseEnumField):
|
|
AUTO_TYPE = InstanceState()
|
|
|
|
|
|
class InstanceTaskStateField(BaseEnumField):
|
|
AUTO_TYPE = InstanceTaskState()
|
|
|
|
|
|
class InstancePowerStateField(BaseEnumField):
|
|
AUTO_TYPE = InstancePowerState()
|
|
|
|
|
|
class ListOfListsOfStringsField(AutoTypedField):
|
|
AUTO_TYPE = List(List(fields.String()))
|
|
|
|
|
|
class DictOfSetOfIntegersField(AutoTypedField):
|
|
AUTO_TYPE = Dict(Set(fields.Integer()))
|