class ServerGroupPayload(base.NotificationPayloadBase):
SCHEMA = {
'uuid': ('group', 'uuid'),
'name': ('group', 'name'),
'user_id': ('group', 'user_id'),
'project_id': ('group', 'project_id'),
'policies': ('group', 'policies'),
'members': ('group', 'members'),
'hosts': ('group', 'hosts'),
}
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'uuid': fields.UUIDField(),
'name': fields.StringField(nullable=True),
'user_id': fields.StringField(nullable=True),
'project_id': fields.StringField(nullable=True),
'policies': fields.ListOfStringsField(nullable=True),
'members': fields.ListOfStringsField(nullable=True),
'hosts': fields.ListOfStringsField(nullable=True),
}
def __init__(self, group):
super(ServerGroupPayload, self).__init__()
# Note: The group is orphaned here to avoid triggering lazy-loading of
# the group.hosts field.
cgroup = copy.deepcopy(group)
cgroup._context = None
self.populate_schema(group=cgroup)
class AggregateCachePayload(base.NotificationPayloadBase):
SCHEMA = {
'id': ('aggregate', 'id'),
'uuid': ('aggregate', 'uuid'),
'name': ('aggregate', 'name'),
}
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'id': fields.IntegerField(),
'uuid': fields.UUIDField(),
'name': fields.StringField(),
# The host that we just worked
'host': fields.StringField(),
# The images that were downloaded or are already there
'images_cached': fields.ListOfStringsField(),
# The images that are unable to be cached for some reason
'images_failed': fields.ListOfStringsField(),
# The N/M progress information for this operation
'index': fields.IntegerField(),
'total': fields.IntegerField(),
}
def __init__(self, aggregate, host, index, total):
super(AggregateCachePayload, self).__init__()
self.populate_schema(aggregate=aggregate)
self.host = host
self.index = index
self.total = total
class Destination(base.NovaObject):
# Version 1.0: Initial version
# Version 1.1: Add cell field
# Version 1.2: Add aggregates field
# Version 1.3: Add allow_cross_cell_move field.
VERSION = '1.3'
fields = {
'host': fields.StringField(),
# NOTE(sbauza): Given we want to split the host/node relationship later
# and also remove the possibility to have multiple nodes per service,
# let's provide a possible nullable node here.
'node': fields.StringField(nullable=True),
'cell': fields.ObjectField('CellMapping', nullable=True),
# NOTE(dansmith): These are required aggregates (or sets) and
# are passed to placement. See require_aggregates() below.
'aggregates': fields.ListOfStringsField(nullable=True, default=None),
# NOTE(mriedem): allow_cross_cell_move defaults to False so that the
# scheduler by default selects hosts from the cell specified in the
# cell field.
'allow_cross_cell_move': fields.BooleanField(default=False),
}
def obj_make_compatible(self, primitive, target_version):
super(Destination, self).obj_make_compatible(primitive, target_version)
target_version = versionutils.convert_version_to_tuple(target_version)
if target_version < (1, 3) and 'allow_cross_cell_move' in primitive:
del primitive['allow_cross_cell_move']
if target_version < (1, 2):
if 'aggregates' in primitive:
del primitive['aggregates']
if target_version < (1, 1):
if 'cell' in primitive:
del primitive['cell']
def obj_load_attr(self, attrname):
self.obj_set_defaults(attrname)
def require_aggregates(self, aggregates):
"""Add a set of aggregates to the list of required aggregates.
This will take a list of aggregates, which are to be logically OR'd
together and add them to the list of required aggregates that will
be used to query placement. Aggregate sets provided in sequential calls
to this method will be AND'd together.
For example, the following set of calls:
dest.require_aggregates(['foo', 'bar'])
dest.require_aggregates(['baz'])
will generate the following logical query to placement:
"Candidates should be in 'foo' OR 'bar', but definitely in 'baz'"
:param aggregates: A list of aggregates, at least one of which
must contain the destination host.
"""
if self.aggregates is None:
self.aggregates = []
self.aggregates.append(','.join(aggregates))
class DeviceMetadata(base.NovaObject):
VERSION = '1.0'
fields = {
'bus': fields.ObjectField("DeviceBus", subclasses=True),
'tags': fields.ListOfStringsField(),
}
class InstanceCreatePayload(InstanceActionPayload):
# No SCHEMA as all the additional fields are calculated
# Version 1.2: Initial version. It starts at 1.2 to match with the version
# of the InstanceActionPayload at the time when this specific
# payload is created as a child of it so that the
# instance.create notification using this new payload does not
# have decreasing version.
# 1.3: Add keypairs field
# 1.4: Add key_name field to InstancePayload
# 1.5: Add BDM related data to InstancePayload
# 1.6: Add tags field to InstanceCreatePayload
# 1.7: Added updated_at field to InstancePayload
VERSION = '1.7'
fields = {
'keypairs': fields.ListOfObjectsField('KeypairPayload'),
'tags': fields.ListOfStringsField(),
}
def __init__(self, instance, fault, bdms):
super(InstanceCreatePayload, self).__init__(
instance=instance,
fault=fault,
bdms=bdms)
self.keypairs = [keypair_payload.KeypairPayload(keypair=keypair)
for keypair in instance.keypairs]
self.tags = [instance_tag.tag
for instance_tag in instance.tags]
class InstanceUpdatePayload(InstancePayload):
# Version 1.0: Initial version
# Version 1.1: locked and display_description added to InstancePayload
# Version 1.2: Added tags field
# Version 1.3: Added auto_disk_config field to InstancePayload
# Version 1.4: Added key_name field to InstancePayload
# Version 1.5: Add BDM related data
# Version 1.6: Added updated_at field to InstancePayload
VERSION = '1.6'
fields = {
'state_update': fields.ObjectField('InstanceStateUpdatePayload'),
'audit_period': fields.ObjectField('AuditPeriodPayload'),
'bandwidth': fields.ListOfObjectsField('BandwidthPayload'),
'old_display_name': fields.StringField(nullable=True),
'tags': fields.ListOfStringsField(),
}
def __init__(self, instance, state_update, audit_period, bandwidth,
old_display_name):
super(InstanceUpdatePayload, self).__init__(instance=instance)
self.state_update = state_update
self.audit_period = audit_period
self.bandwidth = bandwidth
self.old_display_name = old_display_name
self.tags = [instance_tag.tag
for instance_tag in instance.tags.objects]
def setUp(self):
super(TestListOfStrings, self).setUp()
self.field = fields.ListOfStringsField()
self.coerce_good_values = [(['foo', 'bar'], ['foo', 'bar'])]
self.coerce_bad_values = ['foo']
self.to_primitive_values = [(['foo'], ['foo'])]
self.from_primitive_values = [(['foo'], ['foo'])]
class InstanceActionRebuildPayload(InstanceActionPayload):
# No SCHEMA as all the additional fields are calculated
# Version 1.7: Initial version. It starts at 1.7 to equal one more than
# the version of the InstanceActionPayload at the time
# when this specific payload is created so that the
# instance.rebuild.* notifications using this new payload
# signal the change of nova_object.name.
# Version 1.8: Added action_initiator_user and action_initiator_project to
# InstancePayload
VERSION = '1.8'
fields = {
'trusted_image_certificates': fields.ListOfStringsField(
nullable=True)
}
def __init__(self, context, instance, fault, bdms=None):
super(InstanceActionRebuildPayload, self).__init__(
context=context,
instance=instance,
fault=fault,
bdms=bdms)
self.trusted_image_certificates = None
if instance.trusted_certs:
self.trusted_image_certificates = instance.trusted_certs.ids
class DestinationPayload(base.NotificationPayloadBase):
# Version 1.0: Initial version
VERSION = '1.0'
SCHEMA = {
'aggregates': ('destination', 'aggregates'),
}
fields = {
'host': fields.StringField(),
'node': fields.StringField(nullable=True),
'cell': fields.ObjectField('CellMappingPayload', nullable=True),
'aggregates': fields.ListOfStringsField(nullable=True, default=None),
}
def __init__(self, destination):
super(DestinationPayload, self).__init__()
if (destination.obj_attr_is_set('host')
and destination.host is not None):
self.host = destination.host
if (destination.obj_attr_is_set('node')
and destination.node is not None):
self.node = destination.node
if (destination.obj_attr_is_set('cell')
and destination.cell is not None):
self.cell = CellMappingPayload(destination.cell)
self.populate_schema(destination=destination)
class InstanceUpdatePayload(InstancePayload):
# Version 1.0: Initial version
# Version 1.1: locked and display_description added to InstancePayload
# Version 1.2: Added tags field
# Version 1.3: Added auto_disk_config field to InstancePayload
# Version 1.4: Added key_name field to InstancePayload
# Version 1.5: Add BDM related data
# Version 1.6: Added updated_at field to InstancePayload
# Version 1.7: Added request_id field to InstancePayload
# Version 1.8: Added action_initiator_user and action_initiator_project to
# InstancePayload
# Version 1.9: Added locked_reason field to InstancePayload
VERSION = '1.9'
fields = {
'state_update': fields.ObjectField('InstanceStateUpdatePayload'),
'audit_period': fields.ObjectField('AuditPeriodPayload'),
# TODO(stephenfin): Remove this field in 2.0
'bandwidth': fields.ListOfObjectsField('BandwidthPayload'),
'old_display_name': fields.StringField(nullable=True),
'tags': fields.ListOfStringsField(),
}
def __init__(self, context, instance, state_update, audit_period,
bandwidth, old_display_name):
super(InstanceUpdatePayload, self).__init__(
context=context, instance=instance)
self.state_update = state_update
self.audit_period = audit_period
self.bandwidth = bandwidth
self.old_display_name = old_display_name
self.tags = [instance_tag.tag
for instance_tag in instance.tags.objects]
class FlavorPayload(base.NotificationPayloadBase):
# Version 1.0: Initial version
# Version 1.1: Add other fields for Flavor
# Version 1.2: Add extra_specs and projects fields
VERSION = '1.2'
# NOTE: if we'd want to rename some fields(memory_mb->ram, root_gb->disk,
# ephemeral_gb: ephemeral), bumping to payload version 2.0 will be needed.
SCHEMA = {
'flavorid': ('flavor', 'flavorid'),
'memory_mb': ('flavor', 'memory_mb'),
'vcpus': ('flavor', 'vcpus'),
'root_gb': ('flavor', 'root_gb'),
'ephemeral_gb': ('flavor', 'ephemeral_gb'),
'name': ('flavor', 'name'),
'swap': ('flavor', 'swap'),
'rxtx_factor': ('flavor', 'rxtx_factor'),
'vcpu_weight': ('flavor', 'vcpu_weight'),
'disabled': ('flavor', 'disabled'),
'is_public': ('flavor', 'is_public'),
'extra_specs': ('flavor', 'extra_specs'),
'projects': ('flavor', 'projects'),
}
fields = {
'flavorid': fields.StringField(nullable=True),
'memory_mb': fields.IntegerField(nullable=True),
'vcpus': fields.IntegerField(nullable=True),
'root_gb': fields.IntegerField(nullable=True),
'ephemeral_gb': fields.IntegerField(nullable=True),
'name': fields.StringField(),
'swap': fields.IntegerField(),
'rxtx_factor': fields.FloatField(nullable=True),
'vcpu_weight': fields.IntegerField(nullable=True),
'disabled': fields.BooleanField(),
'is_public': fields.BooleanField(),
'extra_specs': fields.DictOfStringsField(),
'projects': fields.ListOfStringsField(),
}
def __init__(self, flavor, **kwargs):
super(FlavorPayload, self).__init__(**kwargs)
self.populate_schema(flavor=flavor)
def obj_make_compatible(self, primitive, target_version):
super(FlavorPayload, self).obj_make_compatible(primitive,
target_version)
target_version = versionutils.convert_version_to_tuple(target_version)
if target_version < (1, 1):
primitive.pop('name', None)
primitive.pop('swap', None)
primitive.pop('rxtx_factor', None)
primitive.pop('vcpu_weight', None)
primitive.pop('disabled', None)
primitive.pop('is_public', None)
if target_version < (1, 2):
primitive.pop('extra_specs', None)
primitive.pop('projects', None)
class InstanceCreatePayload(InstanceActionPayload):
# No SCHEMA as all the additional fields are calculated
# Version 1.2: Initial version. It starts at 1.2 to match with the version
# of the InstanceActionPayload at the time when this specific
# payload is created as a child of it so that the
# instance.create notification using this new payload does not
# have decreasing version.
# 1.3: Add keypairs field
# 1.4: Add key_name field to InstancePayload
# 1.5: Add BDM related data to InstancePayload
# 1.6: Add tags field to InstanceCreatePayload
# 1.7: Added updated_at field to InstancePayload
# 1.8: Added request_id field to InstancePayload
# 1.9: Add trusted_image_certificates field to
# InstanceCreatePayload
# 1.10: Added action_initiator_user and action_initiator_project to
# InstancePayload
# 1.11: Added instance_name to InstanceCreatePayload
# Version 1.12: Added locked_reason field to InstancePayload
VERSION = '1.12'
fields = {
'keypairs': fields.ListOfObjectsField('KeypairPayload'),
'tags': fields.ListOfStringsField(),
'trusted_image_certificates': fields.ListOfStringsField(
nullable=True),
'instance_name': fields.StringField(nullable=True),
}
def __init__(self, context, instance, fault, bdms):
super(InstanceCreatePayload, self).__init__(
context=context,
instance=instance,
fault=fault,
bdms=bdms)
self.keypairs = [keypair_payload.KeypairPayload(keypair=keypair)
for keypair in instance.keypairs]
self.tags = [instance_tag.tag
for instance_tag in instance.tags]
self.trusted_image_certificates = None
if instance.trusted_certs:
self.trusted_image_certificates = instance.trusted_certs.ids
self.instance_name = instance.name
class FlavorPayload(base.NotificationPayloadBase):
# Version 1.0: Initial version
# Version 1.1: Add other fields for Flavor
# Version 1.2: Add extra_specs and projects fields
# Version 1.3: Make projects and extra_specs field nullable as they are
# not always available when a notification is emitted.
# Version 1.4: Added description field.
VERSION = '1.4'
# NOTE: if we'd want to rename some fields(memory_mb->ram, root_gb->disk,
# ephemeral_gb: ephemeral), bumping to payload version 2.0 will be needed.
SCHEMA = {
'flavorid': ('flavor', 'flavorid'),
'memory_mb': ('flavor', 'memory_mb'),
'vcpus': ('flavor', 'vcpus'),
'root_gb': ('flavor', 'root_gb'),
'ephemeral_gb': ('flavor', 'ephemeral_gb'),
'name': ('flavor', 'name'),
'swap': ('flavor', 'swap'),
'rxtx_factor': ('flavor', 'rxtx_factor'),
'vcpu_weight': ('flavor', 'vcpu_weight'),
'disabled': ('flavor', 'disabled'),
'is_public': ('flavor', 'is_public'),
'extra_specs': ('flavor', 'extra_specs'),
'projects': ('flavor', 'projects'),
'description': ('flavor', 'description')
}
fields = {
'flavorid': fields.StringField(nullable=True),
'memory_mb': fields.IntegerField(nullable=True),
'vcpus': fields.IntegerField(nullable=True),
'root_gb': fields.IntegerField(nullable=True),
'ephemeral_gb': fields.IntegerField(nullable=True),
'name': fields.StringField(),
'swap': fields.IntegerField(),
'rxtx_factor': fields.FloatField(nullable=True),
'vcpu_weight': fields.IntegerField(nullable=True),
'disabled': fields.BooleanField(),
'is_public': fields.BooleanField(),
'extra_specs': fields.DictOfStringsField(nullable=True),
'projects': fields.ListOfStringsField(nullable=True),
'description': fields.StringField(nullable=True)
}
def __init__(self, flavor):
super(FlavorPayload, self).__init__()
if 'projects' not in flavor:
# NOTE(danms): If projects is not loaded in the flavor,
# don't attempt to load it. If we're in a child cell then
# we can't load the real flavor, and if we're a flavor on
# an instance then we don't want to anyway.
flavor = flavor.obj_clone()
flavor._context = None
self.populate_schema(flavor=flavor)
class ServerGroupPayload(base.NotificationPayloadBase):
SCHEMA = {
'uuid': ('group', 'uuid'),
'name': ('group', 'name'),
'user_id': ('group', 'user_id'),
'project_id': ('group', 'project_id'),
'policies': ('group', 'policies'),
'members': ('group', 'members'),
'hosts': ('group', 'hosts'),
'policy': ('group', 'policy'),
'rules': ('group', 'rules'),
}
# Version 1.0: Initial version
# Version 1.1: Deprecate policies, add policy and add rules
VERSION = '1.1'
fields = {
'uuid': fields.UUIDField(),
'name': fields.StringField(nullable=True),
'user_id': fields.StringField(nullable=True),
'project_id': fields.StringField(nullable=True),
# NOTE(yikun): policies is deprecated and should
# be removed on the next major version bump
'policies': fields.ListOfStringsField(nullable=True),
'members': fields.ListOfStringsField(nullable=True),
'hosts': fields.ListOfStringsField(nullable=True),
'policy': fields.StringField(nullable=True),
'rules': fields.DictOfStringsField(),
}
def __init__(self, group):
super(ServerGroupPayload, self).__init__()
# Note: The group is orphaned here to avoid triggering lazy-loading of
# the group.hosts field.
cgroup = copy.deepcopy(group)
cgroup._context = None
self.populate_schema(group=cgroup)
class TrustedCerts(base.NovaObject):
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'ids': fields.ListOfStringsField(nullable=False),
}
@base.remotable_classmethod
def get_by_instance_uuid(cls, context, instance_uuid):
db_extra = db.instance_extra_get_by_instance_uuid(
context, instance_uuid, columns=['trusted_certs'])
if not db_extra or not db_extra['trusted_certs']:
return None
return cls.obj_from_primitive(
jsonutils.loads(db_extra['trusted_certs']))
class SchedulerRetriesPayload(base.NotificationPayloadBase):
# Version 1.0: Initial version
VERSION = '1.0'
SCHEMA = {
'num_attempts': ('retry', 'num_attempts'),
}
fields = {
'num_attempts': fields.IntegerField(),
'hosts': fields.ListOfStringsField(),
}
def __init__(self, retry):
super(SchedulerRetriesPayload, self).__init__()
self.hosts = []
for compute_node in retry.hosts:
self.hosts.append(compute_node.hypervisor_hostname)
self.populate_schema(retry=retry)
class AggregatePayload(base.NotificationPayloadBase):
SCHEMA = {
'id': ('aggregate', 'id'),
'uuid': ('aggregate', 'uuid'),
'name': ('aggregate', 'name'),
'hosts': ('aggregate', 'hosts'),
'metadata': ('aggregate', 'metadata'),
}
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'id': fields.IntegerField(),
'uuid': fields.UUIDField(nullable=False),
'name': fields.StringField(),
'hosts': fields.ListOfStringsField(nullable=True),
'metadata': fields.DictOfStringsField(nullable=True),
}
def __init__(self, aggregate, **kwargs):
super(AggregatePayload, self).__init__(**kwargs)
self.populate_schema(aggregate=aggregate)
class AggregatePayload(base.NotificationPayloadBase):
SCHEMA = {
'id': ('aggregate', 'id'),
'uuid': ('aggregate', 'uuid'),
'name': ('aggregate', 'name'),
'hosts': ('aggregate', 'hosts'),
'metadata': ('aggregate', 'metadata'),
}
# Version 1.0: Initial version
# 1.1: Making the id field nullable
VERSION = '1.1'
fields = {
# NOTE(gibi): id is nullable as aggregate.create.start is sent before
# the id is generated by the db
'id': fields.IntegerField(nullable=True),
'uuid': fields.UUIDField(nullable=False),
'name': fields.StringField(),
'hosts': fields.ListOfStringsField(nullable=True),
'metadata': fields.DictOfStringsField(nullable=True),
}
def __init__(self, aggregate):
super(AggregatePayload, self).__init__()
self.populate_schema(aggregate=aggregate)
class ImageMeta(base.NovaObject):
# Version 1.0: Initial version
# Version 1.1: updated ImageMetaProps
# Version 1.2: ImageMetaProps version 1.2
# Version 1.3: ImageMetaProps version 1.3
# Version 1.4: ImageMetaProps version 1.4
# Version 1.5: ImageMetaProps version 1.5
VERSION = '1.5'
# These are driven by what the image client API returns
# to Nova from Glance. This is defined in the glance
# code glance/api/v2/images.py get_base_properties()
# method. A few things are currently left out:
# self, file, schema - Nova does not appear to ever use
# these field; locations - modelling the arbitrary
# data in the 'metadata' subfield is non-trivial as
# there's no clear spec.
#
# TODO(ft): In version 2.0, these fields should be nullable:
# name, checksum, owner, size, virtual_size, container_format, disk_format
#
fields = {
'id': fields.UUIDField(),
'name': fields.StringField(),
'status': fields.StringField(),
'visibility': fields.StringField(),
'protected': fields.FlexibleBooleanField(),
'checksum': fields.StringField(),
'owner': fields.StringField(),
'size': fields.IntegerField(),
'virtual_size': fields.IntegerField(),
'container_format': fields.StringField(),
'disk_format': fields.StringField(),
'created_at': fields.DateTimeField(nullable=True),
'updated_at': fields.DateTimeField(nullable=True),
'tags': fields.ListOfStringsField(),
'direct_url': fields.StringField(),
'min_ram': fields.IntegerField(),
'min_disk': fields.IntegerField(),
'properties': fields.ObjectField('ImageMetaProps'),
}
obj_relationships = {
'properties': [
('1.0', '1.0'),
('1.1', '1.1'),
('1.2', '1.2'),
('1.3', '1.3'),
('1.4', '1.4'),
('1.5', '1.5'),
],
}
@classmethod
def from_dict(cls, image_meta):
"""Create instance from image metadata dict
:param image_meta: image metadata dictionary
Creates a new object instance, initializing from the
properties associated with the image metadata instance
:returns: an ImageMeta instance
"""
if image_meta is None:
image_meta = {}
# We must turn 'properties' key dict into an object
# so copy image_meta to avoid changing original
image_meta = copy.deepcopy(image_meta)
image_meta["properties"] = \
objects.ImageMetaProps.from_dict(
image_meta.get("properties", {}))
# Some fields are nullable in Glance DB schema, but was not marked that
# in ImageMeta initially by mistake. To keep compatibility with compute
# nodes which are run with previous versions these fields are still
# not nullable in ImageMeta, but the code below converts None to
# approppriate empty values.
for fld in NULLABLE_STRING_FIELDS:
if fld in image_meta and image_meta[fld] is None:
image_meta[fld] = ''
for fld in NULLABLE_INTEGER_FIELDS:
if fld in image_meta and image_meta[fld] is None:
image_meta[fld] = 0
return cls(**image_meta)
@classmethod
def from_instance(cls, instance):
"""Create instance from instance system metadata
:param instance: Instance object
Creates a new object instance, initializing from the
system metadata "image_*" properties associated with
instance
:returns: an ImageMeta instance
"""
sysmeta = utils.instance_sys_meta(instance)
image_meta = utils.get_image_from_system_metadata(sysmeta)
return cls.from_dict(image_meta)
class ImageMetaPayload(base.NotificationPayloadBase):
# Version 1.0: Initial version
VERSION = '1.0'
SCHEMA = {
'id': ('image_meta', 'id'),
'name': ('image_meta', 'name'),
'status': ('image_meta', 'status'),
'visibility': ('image_meta', 'visibility'),
'protected': ('image_meta', 'protected'),
'checksum': ('image_meta', 'checksum'),
'owner': ('image_meta', 'owner'),
'size': ('image_meta', 'size'),
'virtual_size': ('image_meta', 'virtual_size'),
'container_format': ('image_meta', 'container_format'),
'disk_format': ('image_meta', 'disk_format'),
'created_at': ('image_meta', 'created_at'),
'updated_at': ('image_meta', 'updated_at'),
'tags': ('image_meta', 'tags'),
'direct_url': ('image_meta', 'direct_url'),
'min_ram': ('image_meta', 'min_ram'),
'min_disk': ('image_meta', 'min_disk')
}
# NOTE(takashin): The reason that each field is nullable is as follows.
#
# a. It is defined as "The value might be null (JSON null data type)."
# in the "Show image" API (GET /v2/images/{image_id})
# in the glance API v2 Reference.
# (https://docs.openstack.org/api-ref/image/v2/index.html)
#
# * checksum
# * container_format
# * disk_format
# * min_disk
# * min_ram
# * name
# * owner
# * size
# * updated_at
# * virtual_size
#
# b. It is optional in the response from glance.
# * direct_url
#
# a. It is defined as nullable in the ImageMeta object.
# * created_at
#
# c. It cannot be got in the boot from volume case.
# See VIM_IMAGE_ATTRIBUTES in nova/utils.py.
#
# * id (not 'image_id')
# * visibility
# * protected
# * status
# * tags
fields = {
'id': fields.UUIDField(nullable=True),
'name': fields.StringField(nullable=True),
'status': fields.StringField(nullable=True),
'visibility': fields.StringField(nullable=True),
'protected': fields.FlexibleBooleanField(nullable=True),
'checksum': fields.StringField(nullable=True),
'owner': fields.StringField(nullable=True),
'size': fields.IntegerField(nullable=True),
'virtual_size': fields.IntegerField(nullable=True),
'container_format': fields.StringField(nullable=True),
'disk_format': fields.StringField(nullable=True),
'created_at': fields.DateTimeField(nullable=True),
'updated_at': fields.DateTimeField(nullable=True),
'tags': fields.ListOfStringsField(nullable=True),
'direct_url': fields.StringField(nullable=True),
'min_ram': fields.IntegerField(nullable=True),
'min_disk': fields.IntegerField(nullable=True),
'properties': fields.ObjectField('ImageMetaPropsPayload')
}
def __init__(self, image_meta):
super(ImageMetaPayload, self).__init__()
self.properties = ImageMetaPropsPayload(
image_meta_props=image_meta.properties)
self.populate_schema(image_meta=image_meta)
class Flavor(base.NovaPersistentObject, base.NovaObject,
base.NovaObjectDictCompat):
# Version 1.0: Initial version
# Version 1.1: Added save_projects(), save_extra_specs(), removed
# remotable from save()
VERSION = '1.1'
fields = {
'id': fields.IntegerField(),
'name': fields.StringField(nullable=True),
'memory_mb': fields.IntegerField(),
'vcpus': fields.IntegerField(),
'root_gb': fields.IntegerField(),
'ephemeral_gb': fields.IntegerField(),
'flavorid': fields.StringField(),
'swap': fields.IntegerField(),
'rxtx_factor': fields.FloatField(nullable=True, default=1.0),
'vcpu_weight': fields.IntegerField(nullable=True),
'disabled': fields.BooleanField(),
'is_public': fields.BooleanField(),
'extra_specs': fields.DictOfStringsField(),
'projects': fields.ListOfStringsField(),
}
def __init__(self, *args, **kwargs):
super(Flavor, self).__init__(*args, **kwargs)
self._orig_extra_specs = {}
self._orig_projects = []
self._in_api = False
@property
def in_api(self):
if self._in_api:
return True
else:
try:
if 'id' in self:
self._flavor_get_from_db(self._context, self.id)
else:
flavor = self._flavor_get_by_flavor_id_from_db(
self._context, self.flavorid)
# Fix us up so we can use our real id
self.id = flavor['id']
self._in_api = True
except exception.FlavorNotFound:
pass
return self._in_api
@staticmethod
def _from_db_object(context, flavor, db_flavor, expected_attrs=None):
if expected_attrs is None:
expected_attrs = []
flavor._context = context
for name, field in flavor.fields.items():
if name in OPTIONAL_FIELDS:
continue
if name in DEPRECATED_FIELDS and name not in db_flavor:
continue
value = db_flavor[name]
if isinstance(field, fields.IntegerField):
value = value if value is not None else 0
flavor[name] = value
# NOTE(danms): This is to support processing the API flavor
# model, which does not have these deprecated fields. When we
# remove compatibility with the old InstanceType model, we can
# remove this as well.
if any(f not in db_flavor for f in DEPRECATED_FIELDS):
flavor.deleted_at = None
flavor.deleted = False
if 'extra_specs' in expected_attrs:
flavor.extra_specs = db_flavor['extra_specs']
if 'projects' in expected_attrs:
if 'projects' in db_flavor:
flavor['projects'] = [
x['project_id'] for x in db_flavor['projects']
]
else:
flavor._load_projects()
flavor.obj_reset_changes()
return flavor
@staticmethod
@db_api.api_context_manager.reader
def _flavor_get_query_from_db(context):
query = context.session.query(api_models.Flavors).\
options(joinedload('extra_specs'))
if not context.is_admin:
the_filter = [api_models.Flavors.is_public == true()]
the_filter.extend([
api_models.Flavors.projects.any(project_id=context.project_id)
])
query = query.filter(or_(*the_filter))
return query
@staticmethod
@require_context
def _flavor_get_from_db(context, id):
"""Returns a dict describing specific flavor."""
result = Flavor._flavor_get_query_from_db(context).\
filter_by(id=id).\
first()
if not result:
raise exception.FlavorNotFound(flavor_id=id)
return db_api._dict_with_extra_specs(result)
@staticmethod
@require_context
def _flavor_get_by_name_from_db(context, name):
"""Returns a dict describing specific flavor."""
result = Flavor._flavor_get_query_from_db(context).\
filter_by(name=name).\
first()
if not result:
raise exception.FlavorNotFoundByName(flavor_name=name)
return db_api._dict_with_extra_specs(result)
@staticmethod
@require_context
def _flavor_get_by_flavor_id_from_db(context, flavor_id):
"""Returns a dict describing specific flavor_id."""
result = Flavor._flavor_get_query_from_db(context).\
filter_by(flavorid=flavor_id).\
order_by(asc(api_models.Flavors.id)).\
first()
if not result:
raise exception.FlavorNotFound(flavor_id=flavor_id)
return db_api._dict_with_extra_specs(result)
@staticmethod
def _get_projects_from_db(context, flavorid):
return _get_projects_from_db(context, flavorid)
@base.remotable
def _load_projects(self):
try:
self.projects = self._get_projects_from_db(self._context,
self.flavorid)
except exception.FlavorNotFound:
self.projects = [
x['project_id'] for x in db.flavor_access_get_by_flavor_id(
self._context, self.flavorid)
]
self.obj_reset_changes(['projects'])
def obj_load_attr(self, attrname):
# NOTE(danms): Only projects could be lazy-loaded right now
if attrname != 'projects':
raise exception.ObjectActionError(action='obj_load_attr',
reason='unable to load %s' %
attrname)
self._load_projects()
def obj_reset_changes(self, fields=None, recursive=False):
super(Flavor, self).obj_reset_changes(fields=fields,
recursive=recursive)
if fields is None or 'extra_specs' in fields:
self._orig_extra_specs = (dict(self.extra_specs)
if self.obj_attr_is_set('extra_specs')
else {})
if fields is None or 'projects' in fields:
self._orig_projects = (list(self.projects)
if self.obj_attr_is_set('projects') else [])
def obj_what_changed(self):
changes = super(Flavor, self).obj_what_changed()
if ('extra_specs' in self
and self.extra_specs != self._orig_extra_specs):
changes.add('extra_specs')
if 'projects' in self and self.projects != self._orig_projects:
changes.add('projects')
return changes
@classmethod
def _obj_from_primitive(cls, context, objver, primitive):
self = super(Flavor, cls)._obj_from_primitive(context, objver,
primitive)
changes = self.obj_what_changed()
if 'extra_specs' not in changes:
# This call left extra_specs "clean" so update our tracker
self._orig_extra_specs = (dict(self.extra_specs)
if self.obj_attr_is_set('extra_specs')
else {})
if 'projects' not in changes:
# This call left projects "clean" so update our tracker
self._orig_projects = (list(self.projects)
if self.obj_attr_is_set('projects') else [])
return self
@base.remotable_classmethod
def get_by_id(cls, context, id):
try:
db_flavor = cls._flavor_get_from_db(context, id)
except exception.FlavorNotFound:
db_flavor = db.flavor_get(context, id)
return cls._from_db_object(context,
cls(context),
db_flavor,
expected_attrs=['extra_specs'])
@base.remotable_classmethod
def get_by_name(cls, context, name):
try:
db_flavor = cls._flavor_get_by_name_from_db(context, name)
except exception.FlavorNotFoundByName:
db_flavor = db.flavor_get_by_name(context, name)
return cls._from_db_object(context,
cls(context),
db_flavor,
expected_attrs=['extra_specs'])
@base.remotable_classmethod
def get_by_flavor_id(cls, context, flavor_id, read_deleted=None):
try:
db_flavor = cls._flavor_get_by_flavor_id_from_db(
context, flavor_id)
except exception.FlavorNotFound:
db_flavor = db.flavor_get_by_flavor_id(context, flavor_id,
read_deleted)
return cls._from_db_object(context,
cls(context),
db_flavor,
expected_attrs=['extra_specs'])
@staticmethod
def _flavor_add_project(context, flavor_id, project_id):
return _flavor_add_project(context, flavor_id, project_id)
@staticmethod
def _flavor_del_project(context, flavor_id, project_id):
return _flavor_del_project(context, flavor_id, project_id)
def _add_access(self, project_id):
if self.in_api:
self._flavor_add_project(self._context, self.id, project_id)
else:
db.flavor_access_add(self._context, self.flavorid, project_id)
@base.remotable
def add_access(self, project_id):
if 'projects' in self.obj_what_changed():
raise exception.ObjectActionError(action='add_access',
reason='projects modified')
self._add_access(project_id)
self._load_projects()
self._send_notification(fields.NotificationAction.UPDATE)
def _remove_access(self, project_id):
if self.in_api:
self._flavor_del_project(self._context, self.id, project_id)
else:
db.flavor_access_remove(self._context, self.flavorid, project_id)
@base.remotable
def remove_access(self, project_id):
if 'projects' in self.obj_what_changed():
raise exception.ObjectActionError(action='remove_access',
reason='projects modified')
self._remove_access(project_id)
self._load_projects()
self._send_notification(fields.NotificationAction.UPDATE)
@staticmethod
def _flavor_create(context, updates):
return _flavor_create(context, updates)
@staticmethod
def _ensure_migrated(context):
return _ensure_migrated(context)
@base.remotable
def create(self):
if self.obj_attr_is_set('id'):
raise exception.ObjectActionError(action='create',
reason='already created')
# NOTE(danms): Once we have made it past a point where we know
# all flavors have been migrated, we can remove this. Ideally
# in Ocata with a blocker migration to be sure.
if not self._ensure_migrated(self._context):
raise exception.ObjectActionError(
action='create', reason='main database still contains flavors')
updates = self.obj_get_changes()
expected_attrs = []
for attr in OPTIONAL_FIELDS:
if attr in updates:
expected_attrs.append(attr)
db_flavor = self._flavor_create(self._context, updates)
self._from_db_object(self._context,
self,
db_flavor,
expected_attrs=expected_attrs)
self._send_notification(fields.NotificationAction.CREATE)
@base.remotable
def save_projects(self, to_add=None, to_delete=None):
"""Add or delete projects.
:param:to_add: A list of projects to add
:param:to_delete: A list of projects to remove
"""
to_add = to_add if to_add is not None else []
to_delete = to_delete if to_delete is not None else []
for project_id in to_add:
self._add_access(project_id)
for project_id in to_delete:
self._remove_access(project_id)
self.obj_reset_changes(['projects'])
@staticmethod
def _flavor_extra_specs_add(context, flavor_id, specs, max_retries=10):
return _flavor_extra_specs_add(context, flavor_id, specs, max_retries)
@staticmethod
def _flavor_extra_specs_del(context, flavor_id, key):
return _flavor_extra_specs_del(context, flavor_id, key)
@base.remotable
def save_extra_specs(self, to_add=None, to_delete=None):
"""Add or delete extra_specs.
:param:to_add: A dict of new keys to add/update
:param:to_delete: A list of keys to remove
"""
if self.in_api:
add_fn = self._flavor_extra_specs_add
del_fn = self._flavor_extra_specs_del
ident = self.id
else:
add_fn = db.flavor_extra_specs_update_or_create
del_fn = db.flavor_extra_specs_delete
ident = self.flavorid
to_add = to_add if to_add is not None else {}
to_delete = to_delete if to_delete is not None else []
if to_add:
add_fn(self._context, ident, to_add)
for key in to_delete:
del_fn(self._context, ident, key)
self.obj_reset_changes(['extra_specs'])
def save(self):
updates = self.obj_get_changes()
projects = updates.pop('projects', None)
extra_specs = updates.pop('extra_specs', None)
if updates:
raise exception.ObjectActionError(
action='save', reason='read-only fields were changed')
if extra_specs is not None:
deleted_keys = (set(self._orig_extra_specs.keys()) -
set(extra_specs.keys()))
added_keys = self.extra_specs
else:
added_keys = deleted_keys = None
if projects is not None:
deleted_projects = set(self._orig_projects) - set(projects)
added_projects = set(projects) - set(self._orig_projects)
else:
added_projects = deleted_projects = None
# NOTE(danms): The first remotable method we call will reset
# our of the original values for projects and extra_specs. Thus,
# we collect the added/deleted lists for both above and /then/
# call these methods to update them.
if added_keys or deleted_keys:
self.save_extra_specs(self.extra_specs, deleted_keys)
if added_projects or deleted_projects:
self.save_projects(added_projects, deleted_projects)
if added_keys or deleted_keys or added_projects or deleted_projects:
self._send_notification(fields.NotificationAction.UPDATE)
@staticmethod
def _flavor_destroy(context, flavor_id=None, flavorid=None):
return _flavor_destroy(context, flavor_id=flavor_id, flavorid=flavorid)
@base.remotable
def destroy(self):
# NOTE(danms): Historically the only way to delete a flavor
# is via name, which is not very precise. We need to be able to
# support the light construction of a flavor object and subsequent
# delete request with only our name filled out. However, if we have
# our id property, we should instead delete with that since it's
# far more specific.
try:
if 'id' in self:
db_flavor = self._flavor_destroy(self._context,
flavor_id=self.id)
else:
db_flavor = self._flavor_destroy(self._context,
flavorid=self.flavorid)
self._from_db_object(self._context, self, db_flavor)
self._send_notification(fields.NotificationAction.DELETE)
except exception.FlavorNotFound:
db.flavor_destroy(self._context, self.flavorid)
def _send_notification(self, action):
# NOTE(danms): Instead of making the below notification
# lazy-load projects (which is a problem for instance-bound
# flavors and compute-cell operations), just load them here.
if 'projects' not in self:
self._load_projects()
notification_type = flavor_notification.FlavorNotification
payload_type = flavor_notification.FlavorPayload
payload = payload_type(self)
notification_type(publisher=notification.NotificationPublisher(
host=CONF.host, binary="nova-api"),
event_type=notification.EventType(object="flavor",
action=action),
priority=fields.NotificationPriority.INFO,
payload=payload).emit(self._context)
class Flavor(base.NovaPersistentObject, base.NovaObject,
base.NovaObjectDictCompat):
# Version 1.0: Initial version
# Version 1.1: Added save_projects(), save_extra_specs(), removed
# remoteable from save()
VERSION = '1.1'
fields = {
'id': fields.IntegerField(),
'name': fields.StringField(nullable=True),
'memory_mb': fields.IntegerField(),
'vcpus': fields.IntegerField(),
'root_gb': fields.IntegerField(),
'ephemeral_gb': fields.IntegerField(),
'flavorid': fields.StringField(),
'swap': fields.IntegerField(),
'rxtx_factor': fields.FloatField(nullable=True, default=1.0),
'vcpu_weight': fields.IntegerField(nullable=True),
'disabled': fields.BooleanField(),
'is_public': fields.BooleanField(),
'extra_specs': fields.DictOfStringsField(),
'projects': fields.ListOfStringsField(),
}
def __init__(self, *args, **kwargs):
super(Flavor, self).__init__(*args, **kwargs)
self._orig_extra_specs = {}
self._orig_projects = []
@staticmethod
def _from_db_object(context, flavor, db_flavor, expected_attrs=None):
if expected_attrs is None:
expected_attrs = []
flavor._context = context
for name, field in flavor.fields.items():
if name in OPTIONAL_FIELDS:
continue
value = db_flavor[name]
if isinstance(field, fields.IntegerField):
value = value if value is not None else 0
flavor[name] = value
if 'extra_specs' in expected_attrs:
flavor.extra_specs = db_flavor['extra_specs']
if 'projects' in expected_attrs:
flavor._load_projects()
flavor.obj_reset_changes()
return flavor
@base.remotable
def _load_projects(self):
self.projects = [
x['project_id'] for x in db.flavor_access_get_by_flavor_id(
self._context, self.flavorid)
]
self.obj_reset_changes(['projects'])
def obj_load_attr(self, attrname):
# NOTE(danms): Only projects could be lazy-loaded right now
if attrname != 'projects':
raise exception.ObjectActionError(action='obj_load_attr',
reason='unable to load %s' %
attrname)
self._load_projects()
def obj_reset_changes(self, fields=None, recursive=False):
super(Flavor, self).obj_reset_changes(fields=fields,
recursive=recursive)
if fields is None or 'extra_specs' in fields:
self._orig_extra_specs = (dict(self.extra_specs)
if self.obj_attr_is_set('extra_specs')
else {})
if fields is None or 'projects' in fields:
self._orig_projects = (list(self.projects)
if self.obj_attr_is_set('projects') else [])
def obj_what_changed(self):
changes = super(Flavor, self).obj_what_changed()
if ('extra_specs' in self
and self.extra_specs != self._orig_extra_specs):
changes.add('extra_specs')
if 'projects' in self and self.projects != self._orig_projects:
changes.add('projects')
return changes
@classmethod
def _obj_from_primitive(cls, context, objver, primitive):
self = super(Flavor, cls)._obj_from_primitive(context, objver,
primitive)
changes = self.obj_what_changed()
if 'extra_specs' not in changes:
# This call left extra_specs "clean" so update our tracker
self._orig_extra_specs = (dict(self.extra_specs)
if self.obj_attr_is_set('extra_specs')
else {})
if 'projects' not in changes:
# This call left projects "clean" so update our tracker
self._orig_projects = (list(self.projects)
if self.obj_attr_is_set('projects') else [])
return self
@base.remotable_classmethod
def get_by_id(cls, context, id):
db_flavor = db.flavor_get(context, id)
return cls._from_db_object(context,
cls(context),
db_flavor,
expected_attrs=['extra_specs'])
@base.remotable_classmethod
def get_by_name(cls, context, name):
db_flavor = db.flavor_get_by_name(context, name)
return cls._from_db_object(context,
cls(context),
db_flavor,
expected_attrs=['extra_specs'])
@base.remotable_classmethod
def get_by_flavor_id(cls, context, flavor_id, read_deleted=None):
db_flavor = db.flavor_get_by_flavor_id(context, flavor_id,
read_deleted)
return cls._from_db_object(context,
cls(context),
db_flavor,
expected_attrs=['extra_specs'])
@base.remotable
def add_access(self, project_id):
if 'projects' in self.obj_what_changed():
raise exception.ObjectActionError(action='add_access',
reason='projects modified')
db.flavor_access_add(self._context, self.flavorid, project_id)
self._load_projects()
@base.remotable
def remove_access(self, project_id):
if 'projects' in self.obj_what_changed():
raise exception.ObjectActionError(action='remove_access',
reason='projects modified')
db.flavor_access_remove(self._context, self.flavorid, project_id)
self._load_projects()
@base.remotable
def create(self):
if self.obj_attr_is_set('id'):
raise exception.ObjectActionError(action='create',
reason='already created')
updates = self.obj_get_changes()
expected_attrs = []
for attr in OPTIONAL_FIELDS:
if attr in updates:
expected_attrs.append(attr)
projects = updates.pop('projects', [])
db_flavor = db.flavor_create(self._context, updates, projects=projects)
self._from_db_object(self._context,
self,
db_flavor,
expected_attrs=expected_attrs)
@base.remotable
def save_projects(self, to_add=None, to_delete=None):
"""Add or delete projects.
:param:to_add: A list of projects to add
:param:to_delete: A list of projects to remove
"""
to_add = to_add if to_add is not None else []
to_delete = to_delete if to_delete is not None else []
for project_id in to_add:
db.flavor_access_add(self._context, self.flavorid, project_id)
for project_id in to_delete:
db.flavor_access_remove(self._context, self.flavorid, project_id)
self.obj_reset_changes(['projects'])
@base.remotable
def save_extra_specs(self, to_add=None, to_delete=None):
"""Add or delete extra_specs.
:param:to_add: A dict of new keys to add/update
:param:to_delete: A list of keys to remove
"""
to_add = to_add if to_add is not None else {}
to_delete = to_delete if to_delete is not None else []
if to_add:
db.flavor_extra_specs_update_or_create(self._context,
self.flavorid, to_add)
for key in to_delete:
db.flavor_extra_specs_delete(self._context, self.flavorid, key)
self.obj_reset_changes(['extra_specs'])
def save(self):
updates = self.obj_get_changes()
projects = updates.pop('projects', None)
extra_specs = updates.pop('extra_specs', None)
if updates:
raise exception.ObjectActionError(
action='save', reason='read-only fields were changed')
if extra_specs is not None:
deleted_keys = (set(self._orig_extra_specs.keys()) -
set(extra_specs.keys()))
added_keys = self.extra_specs
else:
added_keys = deleted_keys = None
if projects is not None:
deleted_projects = set(self._orig_projects) - set(projects)
added_projects = set(projects) - set(self._orig_projects)
else:
added_projects = deleted_projects = None
# NOTE(danms): The first remotable method we call will reset
# our of the original values for projects and extra_specs. Thus,
# we collect the added/deleted lists for both above and /then/
# call these methods to update them.
if added_keys or deleted_keys:
self.save_extra_specs(self.extra_specs, deleted_keys)
if added_projects or deleted_projects:
self.save_projects(added_projects, deleted_projects)
@base.remotable
def destroy(self):
db.flavor_destroy(self._context, self.name)
class ImageMetaPropsPayload(base.NotificationPayloadBase):
# Version 1.0: Initial version
# Version 1.1: Added 'gop', 'virtio' and 'none' to hw_video_model field
VERSION = '1.1'
SCHEMA = {
'hw_architecture': ('image_meta_props', 'hw_architecture'),
'hw_auto_disk_config': ('image_meta_props', 'hw_auto_disk_config'),
'hw_boot_menu': ('image_meta_props', 'hw_boot_menu'),
'hw_cdrom_bus': ('image_meta_props', 'hw_cdrom_bus'),
'hw_cpu_cores': ('image_meta_props', 'hw_cpu_cores'),
'hw_cpu_sockets': ('image_meta_props', 'hw_cpu_sockets'),
'hw_cpu_max_cores': ('image_meta_props', 'hw_cpu_max_cores'),
'hw_cpu_max_sockets': ('image_meta_props', 'hw_cpu_max_sockets'),
'hw_cpu_max_threads': ('image_meta_props', 'hw_cpu_max_threads'),
'hw_cpu_policy': ('image_meta_props', 'hw_cpu_policy'),
'hw_cpu_thread_policy': ('image_meta_props', 'hw_cpu_thread_policy'),
'hw_cpu_realtime_mask': ('image_meta_props', 'hw_cpu_realtime_mask'),
'hw_cpu_threads': ('image_meta_props', 'hw_cpu_threads'),
'hw_device_id': ('image_meta_props', 'hw_device_id'),
'hw_disk_bus': ('image_meta_props', 'hw_disk_bus'),
'hw_disk_type': ('image_meta_props', 'hw_disk_type'),
'hw_floppy_bus': ('image_meta_props', 'hw_floppy_bus'),
'hw_firmware_type': ('image_meta_props', 'hw_firmware_type'),
'hw_ipxe_boot': ('image_meta_props', 'hw_ipxe_boot'),
'hw_machine_type': ('image_meta_props', 'hw_machine_type'),
'hw_mem_page_size': ('image_meta_props', 'hw_mem_page_size'),
'hw_numa_nodes': ('image_meta_props', 'hw_numa_nodes'),
'hw_numa_cpus': ('image_meta_props', 'hw_numa_cpus'),
'hw_numa_mem': ('image_meta_props', 'hw_numa_mem'),
'hw_pointer_model': ('image_meta_props', 'hw_pointer_model'),
'hw_qemu_guest_agent': ('image_meta_props', 'hw_qemu_guest_agent'),
'hw_rescue_bus': ('image_meta_props', 'hw_rescue_bus'),
'hw_rescue_device': ('image_meta_props', 'hw_rescue_device'),
'hw_rng_model': ('image_meta_props', 'hw_rng_model'),
'hw_serial_port_count': ('image_meta_props', 'hw_serial_port_count'),
'hw_scsi_model': ('image_meta_props', 'hw_scsi_model'),
'hw_video_model': ('image_meta_props', 'hw_video_model'),
'hw_video_ram': ('image_meta_props', 'hw_video_ram'),
'hw_vif_model': ('image_meta_props', 'hw_vif_model'),
'hw_vm_mode': ('image_meta_props', 'hw_vm_mode'),
'hw_watchdog_action': ('image_meta_props', 'hw_watchdog_action'),
'hw_vif_multiqueue_enabled':
('image_meta_props', 'hw_vif_multiqueue_enabled'),
'img_bittorrent': ('image_meta_props', 'img_bittorrent'),
'img_bdm_v2': ('image_meta_props', 'img_bdm_v2'),
'img_block_device_mapping':
('image_meta_props', 'img_block_device_mapping'),
'img_cache_in_nova': ('image_meta_props', 'img_cache_in_nova'),
'img_compression_level': ('image_meta_props', 'img_compression_level'),
'img_hv_requested_version':
('image_meta_props', 'img_hv_requested_version'),
'img_hv_type': ('image_meta_props', 'img_hv_type'),
'img_config_drive': ('image_meta_props', 'img_config_drive'),
'img_linked_clone': ('image_meta_props', 'img_linked_clone'),
'img_mappings': ('image_meta_props', 'img_mappings'),
'img_owner_id': ('image_meta_props', 'img_owner_id'),
'img_root_device_name': ('image_meta_props', 'img_root_device_name'),
'img_use_agent': ('image_meta_props', 'img_use_agent'),
'img_version': ('image_meta_props', 'img_version'),
'img_signature': ('image_meta_props', 'img_signature'),
'img_signature_hash_method': ('image_meta_props',
'img_signature_hash_method'),
'img_signature_certificate_uuid': ('image_meta_props',
'img_signature_certificate_uuid'),
'img_signature_key_type': ('image_meta_props',
'img_signature_key_type'),
'img_hide_hypervisor_id': ('image_meta_props',
'img_hide_hypervisor_id'),
'os_admin_user': ('image_meta_props', 'os_admin_user'),
'os_command_line': ('image_meta_props', 'os_command_line'),
'os_distro': ('image_meta_props', 'os_distro'),
'os_require_quiesce': ('image_meta_props', 'os_require_quiesce'),
'os_secure_boot': ('image_meta_props', 'os_secure_boot'),
'os_skip_agent_inject_files_at_boot':
('image_meta_props', 'os_skip_agent_inject_files_at_boot'),
'os_skip_agent_inject_ssh': ('image_meta_props',
'os_skip_agent_inject_ssh'),
'os_type': ('image_meta_props', 'os_type'),
'traits_required': ('image_meta_props', 'traits_required')
}
fields = {
'hw_architecture': fields.ArchitectureField(),
'hw_auto_disk_config': fields.StringField(),
'hw_boot_menu': fields.FlexibleBooleanField(),
'hw_cdrom_bus': fields.DiskBusField(),
'hw_cpu_cores': fields.IntegerField(),
'hw_cpu_sockets': fields.IntegerField(),
'hw_cpu_max_cores': fields.IntegerField(),
'hw_cpu_max_sockets': fields.IntegerField(),
'hw_cpu_max_threads': fields.IntegerField(),
'hw_cpu_policy': fields.CPUAllocationPolicyField(),
'hw_cpu_thread_policy': fields.CPUThreadAllocationPolicyField(),
'hw_cpu_realtime_mask': fields.StringField(),
'hw_cpu_threads': fields.IntegerField(),
'hw_device_id': fields.IntegerField(),
'hw_disk_bus': fields.DiskBusField(),
'hw_disk_type': fields.StringField(),
'hw_floppy_bus': fields.DiskBusField(),
'hw_firmware_type': fields.FirmwareTypeField(),
'hw_ipxe_boot': fields.FlexibleBooleanField(),
'hw_machine_type': fields.StringField(),
'hw_mem_page_size': fields.StringField(),
'hw_numa_nodes': fields.IntegerField(),
'hw_numa_cpus': fields.ListOfSetsOfIntegersField(),
'hw_numa_mem': fields.ListOfIntegersField(),
'hw_pointer_model': fields.PointerModelField(),
'hw_qemu_guest_agent': fields.FlexibleBooleanField(),
'hw_rescue_bus': fields.DiskBusField(),
'hw_rescue_device': fields.BlockDeviceTypeField(),
'hw_rng_model': fields.RNGModelField(),
'hw_serial_port_count': fields.IntegerField(),
'hw_scsi_model': fields.SCSIModelField(),
'hw_video_model': fields.VideoModelField(),
'hw_video_ram': fields.IntegerField(),
'hw_vif_model': fields.VIFModelField(),
'hw_vm_mode': fields.VMModeField(),
'hw_watchdog_action': fields.WatchdogActionField(),
'hw_vif_multiqueue_enabled': fields.FlexibleBooleanField(),
'img_bittorrent': fields.FlexibleBooleanField(),
'img_bdm_v2': fields.FlexibleBooleanField(),
'img_block_device_mapping': fields.ListOfDictOfNullableStringsField(),
'img_cache_in_nova': fields.FlexibleBooleanField(),
'img_compression_level': fields.IntegerField(),
'img_hv_requested_version': fields.VersionPredicateField(),
'img_hv_type': fields.HVTypeField(),
'img_config_drive': fields.ConfigDrivePolicyField(),
'img_linked_clone': fields.FlexibleBooleanField(),
'img_mappings': fields.ListOfDictOfNullableStringsField(),
'img_owner_id': fields.StringField(),
'img_root_device_name': fields.StringField(),
'img_use_agent': fields.FlexibleBooleanField(),
'img_version': fields.IntegerField(),
'img_signature': fields.StringField(),
'img_signature_hash_method': fields.ImageSignatureHashTypeField(),
'img_signature_certificate_uuid': fields.UUIDField(),
'img_signature_key_type': fields.ImageSignatureKeyTypeField(),
'img_hide_hypervisor_id': fields.FlexibleBooleanField(),
'os_admin_user': fields.StringField(),
'os_command_line': fields.StringField(),
'os_distro': fields.StringField(),
'os_require_quiesce': fields.FlexibleBooleanField(),
'os_secure_boot': fields.SecureBootField(),
'os_skip_agent_inject_files_at_boot': fields.FlexibleBooleanField(),
'os_skip_agent_inject_ssh': fields.FlexibleBooleanField(),
'os_type': fields.OSTypeField(),
'traits_required': fields.ListOfStringsField()
}
def __init__(self, image_meta_props):
super(ImageMetaPropsPayload, self).__init__()
# NOTE(takashin): If fields are not set in the ImageMetaProps object,
# it will not set the fields in the ImageMetaPropsPayload
# in order to avoid too many fields whose values are None.
self.populate_schema(set_none=False, image_meta_props=image_meta_props)
class RequestSpec(base.NovaObject):
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'id': fields.IntegerField(),
'image': fields.ObjectField('ImageMeta', nullable=True),
'numa_topology': fields.ObjectField('InstanceNUMATopology',
nullable=True),
'pci_requests': fields.ObjectField('InstancePCIRequests',
nullable=True),
'project_id': fields.StringField(nullable=True),
'availability_zone': fields.StringField(nullable=True),
'flavor': fields.ObjectField('Flavor', nullable=False),
'num_instances': fields.IntegerField(default=1),
'ignore_hosts': fields.ListOfStringsField(nullable=True),
'force_hosts': fields.ListOfStringsField(nullable=True),
'force_nodes': fields.ListOfStringsField(nullable=True),
'retry': fields.ObjectField('SchedulerRetries', nullable=True),
'limits': fields.ObjectField('SchedulerLimits', nullable=True),
'instance_group': fields.ObjectField('InstanceGroup', nullable=True),
# NOTE(sbauza): Since hints are depending on running filters, we prefer
# to leave the API correctly validating the hints per the filters and
# just provide to the RequestSpec object a free-form dictionary
'scheduler_hints': fields.DictOfListOfStringsField(nullable=True),
'instance_uuid': fields.UUIDField(),
}
obj_relationships = {
'image': [('1.0', '1.5')],
'numa_topology': [('1.0', '1.2')],
'flavor': [('1.0', '1.1')],
'pci_requests': [('1.0', '1.1')],
'retry': [('1.0', '1.0')],
'limits': [('1.0', '1.0')],
'instance_group': [('1.0', '1.9')],
}
@property
def vcpus(self):
return self.flavor.vcpus
@property
def memory_mb(self):
return self.flavor.memory_mb
@property
def root_gb(self):
return self.flavor.root_gb
@property
def ephemeral_gb(self):
return self.flavor.ephemeral_gb
@property
def swap(self):
return self.flavor.swap
def _image_meta_from_image(self, image):
if isinstance(image, objects.ImageMeta):
self.image = image
elif isinstance(image, dict):
# NOTE(sbauza): Until Nova is fully providing an ImageMeta object
# for getting properties, we still need to hydrate it here
# TODO(sbauza): To be removed once all RequestSpec hydrations are
# done on the conductor side and if the image is an ImageMeta
self.image = objects.ImageMeta.from_dict(image)
else:
self.image = None
def _from_instance(self, instance):
if isinstance(instance, objects.Instance):
# NOTE(sbauza): Instance should normally be a NovaObject...
getter = getattr
elif isinstance(instance, dict):
# NOTE(sbauza): ... but there are some cases where request_spec
# has an instance key as a dictionary, just because
# select_destinations() is getting a request_spec dict made by
# sched_utils.build_request_spec()
# TODO(sbauza): To be removed once all RequestSpec hydrations are
# done on the conductor side
getter = lambda x, y: x.get(y)
else:
# If the instance is None, there is no reason to set the fields
return
instance_fields = [
'numa_topology', 'pci_requests', 'uuid', 'project_id',
'availability_zone'
]
for field in instance_fields:
if field == 'uuid':
setattr(self, 'instance_uuid', getter(instance, field))
else:
setattr(self, field, getter(instance, field))
def _from_flavor(self, flavor):
if isinstance(flavor, objects.Flavor):
self.flavor = flavor
elif isinstance(flavor, dict):
# NOTE(sbauza): Again, request_spec is primitived by
# sched_utils.build_request_spec() and passed to
# select_destinations() like this
# TODO(sbauza): To be removed once all RequestSpec hydrations are
# done on the conductor side
self.flavor = objects.Flavor(**flavor)
def _from_retry(self, retry_dict):
self.retry = (SchedulerRetries.from_dict(self._context, retry_dict)
if retry_dict else None)
def _populate_group_info(self, filter_properties):
if filter_properties.get('instance_group'):
# New-style group information as a NovaObject, we can directly set
# the field
self.instance_group = filter_properties.get('instance_group')
elif filter_properties.get('group_updated') is True:
# Old-style group information having ugly dict keys containing sets
# NOTE(sbauza): Can be dropped once select_destinations is removed
policies = list(filter_properties.get('group_policies'))
members = list(filter_properties.get('group_hosts'))
self.instance_group = objects.InstanceGroup(policies=policies,
members=members)
else:
# Set the value anyway to avoid any call to obj_attr_is_set for it
self.instance_group = None
def _from_limits(self, limits_dict):
self.limits = SchedulerLimits.from_dict(limits_dict)
def _from_hints(self, hints_dict):
if hints_dict is None:
self.scheduler_hints = None
return
self.scheduler_hints = {
hint: value if isinstance(value, list) else [value]
for hint, value in six.iteritems(hints_dict)
}
@classmethod
def from_primitives(cls, context, request_spec, filter_properties):
"""Returns a new RequestSpec object by hydrating it from legacy dicts.
That helper is not intended to leave the legacy dicts kept in the nova
codebase, but is rather just for giving a temporary solution for
populating the Spec object until we get rid of scheduler_utils'
build_request_spec() and the filter_properties hydratation in the
conductor.
:param context: a context object
:param request_spec: An old-style request_spec dictionary
:param filter_properties: An old-style filter_properties dictionary
"""
num_instances = request_spec.get('num_instances', 1)
spec = cls(context, num_instances=num_instances)
# Hydrate from request_spec first
image = request_spec.get('image')
spec._image_meta_from_image(image)
instance = request_spec.get('instance_properties')
spec._from_instance(instance)
flavor = request_spec.get('instance_type')
spec._from_flavor(flavor)
# Hydrate now from filter_properties
spec.ignore_hosts = filter_properties.get('ignore_hosts')
spec.force_hosts = filter_properties.get('force_hosts')
spec.force_nodes = filter_properties.get('force_nodes')
retry = filter_properties.get('retry', {})
spec._from_retry(retry)
limits = filter_properties.get('limits', {})
spec._from_limits(limits)
spec._populate_group_info(filter_properties)
scheduler_hints = filter_properties.get('scheduler_hints', {})
spec._from_hints(scheduler_hints)
return spec
def get_scheduler_hint(self, hint_name, default=None):
"""Convenient helper for accessing a particular scheduler hint since
it is hydrated by putting a single item into a list.
In order to reduce the complexity, that helper returns a string if the
requested hint is a list of only one value, and if not, returns the
value directly (ie. the list). If the hint is not existing (or
scheduler_hints is None), then it returns the default value.
:param hint_name: name of the hint
:param default: the default value if the hint is not there
"""
if (not self.obj_attr_is_set('scheduler_hints')
or self.scheduler_hints is None):
return default
hint_val = self.scheduler_hints.get(hint_name, default)
return (hint_val[0] if isinstance(hint_val, list)
and len(hint_val) == 1 else hint_val)
class RequestSpec(base.NovaObject):
# Version 1.0: Initial version
# Version 1.1: ImageMeta version 1.6
# Version 1.2: SchedulerRetries version 1.1
# Version 1.3: InstanceGroup version 1.10
# Version 1.4: ImageMeta version 1.7
# Version 1.5: Added get_by_instance_uuid(), create(), save()
# Version 1.6: Added requested_destination
# Version 1.7: Added destroy()
# Version 1.8: Added security_groups
VERSION = '1.8'
fields = {
'id':
fields.IntegerField(),
'image':
fields.ObjectField('ImageMeta', nullable=True),
'numa_topology':
fields.ObjectField('InstanceNUMATopology', nullable=True),
'pci_requests':
fields.ObjectField('InstancePCIRequests', nullable=True),
'project_id':
fields.StringField(nullable=True),
'availability_zone':
fields.StringField(nullable=True),
'flavor':
fields.ObjectField('Flavor', nullable=False),
'num_instances':
fields.IntegerField(default=1),
'ignore_hosts':
fields.ListOfStringsField(nullable=True),
'force_hosts':
fields.ListOfStringsField(nullable=True),
'force_nodes':
fields.ListOfStringsField(nullable=True),
'requested_destination':
fields.ObjectField('Destination', nullable=True, default=None),
'retry':
fields.ObjectField('SchedulerRetries', nullable=True),
'limits':
fields.ObjectField('SchedulerLimits', nullable=True),
'instance_group':
fields.ObjectField('InstanceGroup', nullable=True),
# NOTE(sbauza): Since hints are depending on running filters, we prefer
# to leave the API correctly validating the hints per the filters and
# just provide to the RequestSpec object a free-form dictionary
'scheduler_hints':
fields.DictOfListOfStringsField(nullable=True),
'instance_uuid':
fields.UUIDField(),
'security_groups':
fields.ObjectField('SecurityGroupList'),
}
def obj_make_compatible(self, primitive, target_version):
super(RequestSpec, self).obj_make_compatible(primitive, target_version)
target_version = versionutils.convert_version_to_tuple(target_version)
if target_version < (1, 8):
if 'security_groups' in primitive:
del primitive['security_groups']
if target_version < (1, 6):
if 'requested_destination' in primitive:
del primitive['requested_destination']
def obj_load_attr(self, attrname):
if attrname not in REQUEST_SPEC_OPTIONAL_ATTRS:
raise exception.ObjectActionError(
action='obj_load_attr',
reason='attribute %s not lazy-loadable' % attrname)
if attrname == 'security_groups':
self.security_groups = objects.SecurityGroupList(objects=[])
return
# NOTE(sbauza): In case the primitive was not providing that field
# because of a previous RequestSpec version, we want to default
# that field in order to have the same behaviour.
self.obj_set_defaults(attrname)
@property
def vcpus(self):
return self.flavor.vcpus
@property
def memory_mb(self):
return self.flavor.memory_mb
@property
def root_gb(self):
return self.flavor.root_gb
@property
def ephemeral_gb(self):
return self.flavor.ephemeral_gb
@property
def swap(self):
return self.flavor.swap
def _image_meta_from_image(self, image):
if isinstance(image, objects.ImageMeta):
self.image = image
elif isinstance(image, dict):
# NOTE(sbauza): Until Nova is fully providing an ImageMeta object
# for getting properties, we still need to hydrate it here
# TODO(sbauza): To be removed once all RequestSpec hydrations are
# done on the conductor side and if the image is an ImageMeta
self.image = objects.ImageMeta.from_dict(image)
else:
self.image = None
def _from_instance(self, instance):
if isinstance(instance, obj_instance.Instance):
# NOTE(sbauza): Instance should normally be a NovaObject...
getter = getattr
elif isinstance(instance, dict):
# NOTE(sbauza): ... but there are some cases where request_spec
# has an instance key as a dictionary, just because
# select_destinations() is getting a request_spec dict made by
# sched_utils.build_request_spec()
# TODO(sbauza): To be removed once all RequestSpec hydrations are
# done on the conductor side
getter = lambda x, y: x.get(y)
else:
# If the instance is None, there is no reason to set the fields
return
instance_fields = [
'numa_topology', 'pci_requests', 'uuid', 'project_id',
'availability_zone'
]
for field in instance_fields:
if field == 'uuid':
setattr(self, 'instance_uuid', getter(instance, field))
elif field == 'pci_requests':
self._from_instance_pci_requests(getter(instance, field))
elif field == 'numa_topology':
self._from_instance_numa_topology(getter(instance, field))
else:
setattr(self, field, getter(instance, field))
def _from_instance_pci_requests(self, pci_requests):
if isinstance(pci_requests, dict):
pci_req_cls = objects.InstancePCIRequests
self.pci_requests = pci_req_cls.from_request_spec_instance_props(
pci_requests)
else:
self.pci_requests = pci_requests
def _from_instance_numa_topology(self, numa_topology):
if isinstance(numa_topology, dict):
self.numa_topology = hardware.instance_topology_from_instance(
dict(numa_topology=numa_topology))
else:
self.numa_topology = numa_topology
def _from_flavor(self, flavor):
if isinstance(flavor, objects.Flavor):
self.flavor = flavor
elif isinstance(flavor, dict):
# NOTE(sbauza): Again, request_spec is primitived by
# sched_utils.build_request_spec() and passed to
# select_destinations() like this
# TODO(sbauza): To be removed once all RequestSpec hydrations are
# done on the conductor side
self.flavor = objects.Flavor(**flavor)
def _from_retry(self, retry_dict):
self.retry = (SchedulerRetries.from_dict(self._context, retry_dict)
if retry_dict else None)
def _populate_group_info(self, filter_properties):
if filter_properties.get('instance_group'):
# New-style group information as a NovaObject, we can directly set
# the field
self.instance_group = filter_properties.get('instance_group')
elif filter_properties.get('group_updated') is True:
# Old-style group information having ugly dict keys containing sets
# NOTE(sbauza): Can be dropped once select_destinations is removed
policies = list(filter_properties.get('group_policies'))
hosts = list(filter_properties.get('group_hosts'))
members = list(filter_properties.get('group_members'))
self.instance_group = objects.InstanceGroup(policies=policies,
hosts=hosts,
members=members)
# hosts has to be not part of the updates for saving the object
self.instance_group.obj_reset_changes(['hosts'])
else:
# Set the value anyway to avoid any call to obj_attr_is_set for it
self.instance_group = None
def _from_limits(self, limits_dict):
self.limits = SchedulerLimits.from_dict(limits_dict)
def _from_hints(self, hints_dict):
if hints_dict is None:
self.scheduler_hints = None
return
self.scheduler_hints = {
hint: value if isinstance(value, list) else [value]
for hint, value in six.iteritems(hints_dict)
}
@classmethod
def from_primitives(cls, context, request_spec, filter_properties):
"""Returns a new RequestSpec object by hydrating it from legacy dicts.
Deprecated. A RequestSpec object is created early in the boot process
using the from_components method. That object will either be passed to
places that require it, or it can be looked up with
get_by_instance_uuid. This method can be removed when there are no
longer any callers. Because the method is not remotable it is not tied
to object versioning.
That helper is not intended to leave the legacy dicts kept in the nova
codebase, but is rather just for giving a temporary solution for
populating the Spec object until we get rid of scheduler_utils'
build_request_spec() and the filter_properties hydratation in the
conductor.
:param context: a context object
:param request_spec: An old-style request_spec dictionary
:param filter_properties: An old-style filter_properties dictionary
"""
num_instances = request_spec.get('num_instances', 1)
spec = cls(context, num_instances=num_instances)
# Hydrate from request_spec first
image = request_spec.get('image')
spec._image_meta_from_image(image)
instance = request_spec.get('instance_properties')
spec._from_instance(instance)
flavor = request_spec.get('instance_type')
spec._from_flavor(flavor)
# Hydrate now from filter_properties
spec.ignore_hosts = filter_properties.get('ignore_hosts')
spec.force_hosts = filter_properties.get('force_hosts')
spec.force_nodes = filter_properties.get('force_nodes')
retry = filter_properties.get('retry', {})
spec._from_retry(retry)
limits = filter_properties.get('limits', {})
spec._from_limits(limits)
spec._populate_group_info(filter_properties)
scheduler_hints = filter_properties.get('scheduler_hints', {})
spec._from_hints(scheduler_hints)
# NOTE(sbauza): Default the other fields that are not part of the
# original contract
spec.obj_set_defaults()
return spec
def get_scheduler_hint(self, hint_name, default=None):
"""Convenient helper for accessing a particular scheduler hint since
it is hydrated by putting a single item into a list.
In order to reduce the complexity, that helper returns a string if the
requested hint is a list of only one value, and if not, returns the
value directly (ie. the list). If the hint is not existing (or
scheduler_hints is None), then it returns the default value.
:param hint_name: name of the hint
:param default: the default value if the hint is not there
"""
if (not self.obj_attr_is_set('scheduler_hints')
or self.scheduler_hints is None):
return default
hint_val = self.scheduler_hints.get(hint_name, default)
return (hint_val[0] if isinstance(hint_val, list)
and len(hint_val) == 1 else hint_val)
def _to_legacy_image(self):
return base.obj_to_primitive(self.image) if (
self.obj_attr_is_set('image') and self.image) else {}
def _to_legacy_instance(self):
# NOTE(sbauza): Since the RequestSpec only persists a few Instance
# fields, we can only return a dict.
instance = {}
instance_fields = [
'numa_topology', 'pci_requests', 'project_id', 'availability_zone',
'instance_uuid'
]
for field in instance_fields:
if not self.obj_attr_is_set(field):
continue
if field == 'instance_uuid':
instance['uuid'] = getattr(self, field)
else:
instance[field] = getattr(self, field)
flavor_fields = ['root_gb', 'ephemeral_gb', 'memory_mb', 'vcpus']
if not self.obj_attr_is_set('flavor'):
return instance
for field in flavor_fields:
instance[field] = getattr(self.flavor, field)
return instance
def _to_legacy_group_info(self):
# NOTE(sbauza): Since this is only needed until the AffinityFilters are
# modified by using directly the RequestSpec object, we need to keep
# the existing dictionary as a primitive.
return {
'group_updated': True,
'group_hosts': set(self.instance_group.hosts),
'group_policies': set(self.instance_group.policies)
}
def to_legacy_request_spec_dict(self):
"""Returns a legacy request_spec dict from the RequestSpec object.
Since we need to manage backwards compatibility and rolling upgrades
within our RPC API, we need to accept to provide an helper for
primitiving the right RequestSpec object into a legacy dict until we
drop support for old Scheduler RPC API versions.
If you don't understand why this method is needed, please don't use it.
"""
req_spec = {}
if not self.obj_attr_is_set('num_instances'):
req_spec['num_instances'] = self.fields['num_instances'].default
else:
req_spec['num_instances'] = self.num_instances
req_spec['image'] = self._to_legacy_image()
req_spec['instance_properties'] = self._to_legacy_instance()
if self.obj_attr_is_set('flavor'):
req_spec['instance_type'] = self.flavor
else:
req_spec['instance_type'] = {}
return req_spec
def to_legacy_filter_properties_dict(self):
"""Returns a legacy filter_properties dict from the RequestSpec object.
Since we need to manage backwards compatibility and rolling upgrades
within our RPC API, we need to accept to provide an helper for
primitiving the right RequestSpec object into a legacy dict until we
drop support for old Scheduler RPC API versions.
If you don't understand why this method is needed, please don't use it.
"""
filt_props = {}
if self.obj_attr_is_set('ignore_hosts') and self.ignore_hosts:
filt_props['ignore_hosts'] = self.ignore_hosts
if self.obj_attr_is_set('force_hosts') and self.force_hosts:
filt_props['force_hosts'] = self.force_hosts
if self.obj_attr_is_set('force_nodes') and self.force_nodes:
filt_props['force_nodes'] = self.force_nodes
if self.obj_attr_is_set('retry') and self.retry:
filt_props['retry'] = self.retry.to_dict()
if self.obj_attr_is_set('limits') and self.limits:
filt_props['limits'] = self.limits.to_dict()
if self.obj_attr_is_set('instance_group') and self.instance_group:
filt_props.update(self._to_legacy_group_info())
if self.obj_attr_is_set('scheduler_hints') and self.scheduler_hints:
# NOTE(sbauza): We need to backport all the hints correctly since
# we had to hydrate the field by putting a single item into a list.
filt_props['scheduler_hints'] = {
hint: self.get_scheduler_hint(hint)
for hint in self.scheduler_hints
}
return filt_props
@classmethod
def from_components(cls,
context,
instance_uuid,
image,
flavor,
numa_topology,
pci_requests,
filter_properties,
instance_group,
availability_zone,
security_groups=None):
"""Returns a new RequestSpec object hydrated by various components.
This helper is useful in creating the RequestSpec from the various
objects that are assembled early in the boot process. This method
creates a complete RequestSpec object with all properties set or
intentionally left blank.
:param context: a context object
:param instance_uuid: the uuid of the instance to schedule
:param image: a dict of properties for an image or volume
:param flavor: a flavor NovaObject
:param numa_topology: InstanceNUMATopology or None
:param pci_requests: InstancePCIRequests
:param filter_properties: a dict of properties for scheduling
:param instance_group: None or an instance group NovaObject
:param availability_zone: an availability_zone string
:param security_groups: A SecurityGroupList object. If None, don't
set security_groups on the resulting object.
"""
spec_obj = cls(context)
spec_obj.num_instances = 1
spec_obj.instance_uuid = instance_uuid
spec_obj.instance_group = instance_group
if spec_obj.instance_group is None and filter_properties:
spec_obj._populate_group_info(filter_properties)
spec_obj.project_id = context.project_id
spec_obj._image_meta_from_image(image)
spec_obj._from_flavor(flavor)
spec_obj._from_instance_pci_requests(pci_requests)
spec_obj._from_instance_numa_topology(numa_topology)
spec_obj.ignore_hosts = filter_properties.get('ignore_hosts')
spec_obj.force_hosts = filter_properties.get('force_hosts')
spec_obj.force_nodes = filter_properties.get('force_nodes')
spec_obj._from_retry(filter_properties.get('retry', {}))
spec_obj._from_limits(filter_properties.get('limits', {}))
spec_obj._from_hints(filter_properties.get('scheduler_hints', {}))
spec_obj.availability_zone = availability_zone
if security_groups is not None:
spec_obj.security_groups = security_groups
# NOTE(sbauza): Default the other fields that are not part of the
# original contract
spec_obj.obj_set_defaults()
return spec_obj
@staticmethod
def _from_db_object(context, spec, db_spec):
spec_obj = spec.obj_from_primitive(jsonutils.loads(db_spec['spec']))
for key in spec.fields:
# Load these from the db model not the serialized object within,
# though they should match.
if key in ['id', 'instance_uuid']:
setattr(spec, key, db_spec[key])
else:
setattr(spec, key, getattr(spec_obj, key))
spec._context = context
spec.obj_reset_changes()
return spec
@staticmethod
@db.api_context_manager.reader
def _get_by_instance_uuid_from_db(context, instance_uuid):
db_spec = context.session.query(api_models.RequestSpec).filter_by(
instance_uuid=instance_uuid).first()
if not db_spec:
raise exception.RequestSpecNotFound(instance_uuid=instance_uuid)
return db_spec
@base.remotable_classmethod
def get_by_instance_uuid(cls, context, instance_uuid):
db_spec = cls._get_by_instance_uuid_from_db(context, instance_uuid)
return cls._from_db_object(context, cls(), db_spec)
@staticmethod
@db.api_context_manager.writer
def _create_in_db(context, updates):
db_spec = api_models.RequestSpec()
db_spec.update(updates)
db_spec.save(context.session)
return db_spec
def _get_update_primitives(self):
"""Serialize object to match the db model.
We store copies of embedded objects rather than
references to these objects because we want a snapshot of the request
at this point. If the references changed or were deleted we would
not be able to reschedule this instance under the same conditions as
it was originally scheduled with.
"""
updates = self.obj_get_changes()
# NOTE(alaski): The db schema is the full serialized object in a
# 'spec' column. If anything has changed we rewrite the full thing.
if updates:
db_updates = {'spec': jsonutils.dumps(self.obj_to_primitive())}
if 'instance_uuid' in updates:
db_updates['instance_uuid'] = updates['instance_uuid']
return db_updates
@base.remotable
def create(self):
if self.obj_attr_is_set('id'):
raise exception.ObjectActionError(action='create',
reason='already created')
updates = self._get_update_primitives()
db_spec = self._create_in_db(self._context, updates)
self._from_db_object(self._context, self, db_spec)
@staticmethod
@db.api_context_manager.writer
def _save_in_db(context, instance_uuid, updates):
# FIXME(sbauza): Provide a classmethod when oslo.db bug #1520195 is
# fixed and released
db_spec = RequestSpec._get_by_instance_uuid_from_db(
context, instance_uuid)
db_spec.update(updates)
db_spec.save(context.session)
return db_spec
@base.remotable
def save(self):
updates = self._get_update_primitives()
db_spec = self._save_in_db(self._context, self.instance_uuid, updates)
self._from_db_object(self._context, self, db_spec)
self.obj_reset_changes()
@staticmethod
@db.api_context_manager.writer
def _destroy_in_db(context, instance_uuid):
result = context.session.query(api_models.RequestSpec).filter_by(
instance_uuid=instance_uuid).delete()
if not result:
raise exception.RequestSpecNotFound(instance_uuid=instance_uuid)
@base.remotable
def destroy(self):
self._destroy_in_db(self._context, self.instance_uuid)
def reset_forced_destinations(self):
"""Clears the forced destination fields from the RequestSpec object.
This method is for making sure we don't ask the scheduler to give us
again the same destination(s) without persisting the modifications.
"""
self.force_hosts = None
self.force_nodes = None
# NOTE(sbauza): Make sure we don't persist this, we need to keep the
# original request for the forced hosts
self.obj_reset_changes(['force_hosts', 'force_nodes'])
class LibvirtLiveMigrateData(LiveMigrateData):
# Version 1.0: Initial version
# Version 1.1: Added target_connect_addr
# Version 1.2: Added 'serial_listen_ports' to allow live migration with
# serial console.
# Version 1.3: Added 'supported_perf_events'
# Version 1.4: Added old_vol_attachment_ids
# Version 1.5: Added src_supports_native_luks
# Version 1.6: Added wait_for_vif_plugged
# Version 1.7: Added dst_wants_file_backed_memory
# Version 1.8: Added file_backed_memory_discard
# Version 1.9: Inherited vifs from LiveMigrateData
# Version 1.10: Added dst_numa_info, src_supports_numa_live_migration, and
# dst_supports_numa_live_migration fields
VERSION = '1.10'
fields = {
'filename': fields.StringField(),
# FIXME: image_type should be enum?
'image_type': fields.StringField(),
'block_migration': fields.BooleanField(),
'disk_over_commit': fields.BooleanField(),
'disk_available_mb': fields.IntegerField(nullable=True),
'is_shared_instance_path': fields.BooleanField(),
'is_shared_block_storage': fields.BooleanField(),
'instance_relative_path': fields.StringField(),
'graphics_listen_addr_vnc': fields.IPAddressField(nullable=True),
'graphics_listen_addr_spice': fields.IPAddressField(nullable=True),
'serial_listen_addr': fields.StringField(nullable=True),
'serial_listen_ports': fields.ListOfIntegersField(),
'bdms': fields.ListOfObjectsField('LibvirtLiveMigrateBDMInfo'),
'target_connect_addr': fields.StringField(nullable=True),
'supported_perf_events': fields.ListOfStringsField(),
# TODO(lyarwood): No longer used, drop in version 2.0
'src_supports_native_luks': fields.BooleanField(),
'dst_wants_file_backed_memory': fields.BooleanField(),
# TODO(lyarwood): No longer used, drop in version 2.0
'file_backed_memory_discard': fields.BooleanField(),
# TODO(artom) (src|dst)_supports_numa_live_migration are only used as
# flags to indicate that the compute host is new enough to perform a
# NUMA-aware live migration. Remove in version 2.0.
'src_supports_numa_live_migration': fields.BooleanField(),
'dst_supports_numa_live_migration': fields.BooleanField(),
'dst_numa_info': fields.ObjectField('LibvirtLiveMigrateNUMAInfo'),
}
def obj_make_compatible(self, primitive, target_version):
super(LibvirtLiveMigrateData,
self).obj_make_compatible(primitive, target_version)
target_version = versionutils.convert_version_to_tuple(target_version)
if (target_version < (1, 10)
and 'src_supports_numa_live_migration' in primitive):
del primitive['src_supports_numa_live_migration']
if (target_version < (1, 10)
and 'dst_supports_numa_live_migration' in primitive):
del primitive['dst_supports_numa_live_migration']
if target_version < (1, 10) and 'dst_numa_info' in primitive:
del primitive['dst_numa_info']
if target_version < (1, 9) and 'vifs' in primitive:
del primitive['vifs']
if target_version < (1, 8):
if 'file_backed_memory_discard' in primitive:
del primitive['file_backed_memory_discard']
if target_version < (1, 7):
if 'dst_wants_file_backed_memory' in primitive:
del primitive['dst_wants_file_backed_memory']
if target_version < (1, 6) and 'wait_for_vif_plugged' in primitive:
del primitive['wait_for_vif_plugged']
if target_version < (1, 5):
if 'src_supports_native_luks' in primitive:
del primitive['src_supports_native_luks']
if target_version < (1, 4):
if 'old_vol_attachment_ids' in primitive:
del primitive['old_vol_attachment_ids']
if target_version < (1, 3):
if 'supported_perf_events' in primitive:
del primitive['supported_perf_events']
if target_version < (1, 2):
if 'serial_listen_ports' in primitive:
del primitive['serial_listen_ports']
if target_version < (1, 1) and 'target_connect_addr' in primitive:
del primitive['target_connect_addr']
def is_on_shared_storage(self):
return self.is_shared_block_storage or self.is_shared_instance_path
class ImageMetaProps(base.NovaObject):
# Version 1.0: Initial version
# Version 1.1: added os_require_quiesce field
# Version 1.2: added img_hv_type and img_hv_requested_version fields
# Version 1.3: HVSpec version 1.1
# Version 1.4: added hw_vif_multiqueue_enabled field
# Version 1.5: added os_admin_user field
# Version 1.6: Added 'lxc' and 'uml' enum types to DiskBusField
# Version 1.7: added img_config_drive field
# Version 1.8: Added 'lxd' to hypervisor types
# Version 1.9: added hw_cpu_thread_policy field
# Version 1.10: added hw_cpu_realtime_mask field
# Version 1.11: Added hw_firmware_type field
# Version 1.12: Added properties for image signature verification
# Version 1.13: added os_secure_boot field
# Version 1.14: Added 'hw_pointer_model' field
# Version 1.15: Added hw_rescue_bus and hw_rescue_device.
# Version 1.16: WatchdogActionField supports 'disabled' enum.
# Version 1.17: Add lan9118 as valid nic for hw_vif_model property for qemu
# Version 1.18: Pull signature properties from cursive library
# Version 1.19: Added 'img_hide_hypervisor_id' type field
# Version 1.20: Added 'traits_required' list field
# Version 1.21: Added 'hw_time_hpet' field
# Version 1.22: Added 'gop', 'virtio' and 'none' to hw_video_model field
# Version 1.23: Added 'hw_pmu' field
VERSION = '1.23'
def obj_make_compatible(self, primitive, target_version):
super(ImageMetaProps,
self).obj_make_compatible(primitive, target_version)
target_version = versionutils.convert_version_to_tuple(target_version)
if target_version < (1, 23):
primitive.pop('hw_pmu', None)
# NOTE(sean-k-mooney): unlike other nova object we version this object
# when composed object are updated.
if target_version < (1, 22):
video = primitive.get('hw_video_model', None)
if video in ('gop', 'virtio', 'none'):
raise exception.ObjectActionError(
action='obj_make_compatible',
reason='hw_video_model=%s not supported in version %s' %
(video, target_version))
if target_version < (1, 21):
primitive.pop('hw_time_hpet', None)
if target_version < (1, 20):
primitive.pop('traits_required', None)
if target_version < (1, 19):
primitive.pop('img_hide_hypervisor_id', None)
if target_version < (1, 16) and 'hw_watchdog_action' in primitive:
# Check to see if hw_watchdog_action was set to 'disabled' and if
# so, remove it since not specifying it is the same behavior.
if primitive['hw_watchdog_action'] == \
fields.WatchdogAction.DISABLED:
primitive.pop('hw_watchdog_action')
if target_version < (1, 15):
primitive.pop('hw_rescue_bus', None)
primitive.pop('hw_rescue_device', None)
if target_version < (1, 14):
primitive.pop('hw_pointer_model', None)
if target_version < (1, 13):
primitive.pop('os_secure_boot', None)
if target_version < (1, 11):
primitive.pop('hw_firmware_type', None)
if target_version < (1, 10):
primitive.pop('hw_cpu_realtime_mask', None)
if target_version < (1, 9):
primitive.pop('hw_cpu_thread_policy', None)
if target_version < (1, 7):
primitive.pop('img_config_drive', None)
if target_version < (1, 5):
primitive.pop('os_admin_user', None)
if target_version < (1, 4):
primitive.pop('hw_vif_multiqueue_enabled', None)
if target_version < (1, 2):
primitive.pop('img_hv_type', None)
primitive.pop('img_hv_requested_version', None)
if target_version < (1, 1):
primitive.pop('os_require_quiesce', None)
if target_version < (1, 6):
bus = primitive.get('hw_disk_bus', None)
if bus in ('lxc', 'uml'):
raise exception.ObjectActionError(
action='obj_make_compatible',
reason='hw_disk_bus=%s not supported in version %s' %
(bus, target_version))
# Maximum number of NUMA nodes permitted for the guest topology
NUMA_NODES_MAX = 128
# 'hw_' - settings affecting the guest virtual machine hardware
# 'img_' - settings affecting the use of images by the compute node
# 'os_' - settings affecting the guest operating system setup
# 'traits_required' - The required traits associated with the image
fields = {
# name of guest hardware architecture eg i686, x86_64, ppc64
'hw_architecture': fields.ArchitectureField(),
# used to decide to expand root disk partition and fs to full size of
# root disk
'hw_auto_disk_config': fields.StringField(),
# whether to display BIOS boot device menu
'hw_boot_menu': fields.FlexibleBooleanField(),
# name of the CDROM bus to use eg virtio, scsi, ide
'hw_cdrom_bus': fields.DiskBusField(),
# preferred number of CPU cores per socket
'hw_cpu_cores': fields.IntegerField(),
# preferred number of CPU sockets
'hw_cpu_sockets': fields.IntegerField(),
# maximum number of CPU cores per socket
'hw_cpu_max_cores': fields.IntegerField(),
# maximum number of CPU sockets
'hw_cpu_max_sockets': fields.IntegerField(),
# maximum number of CPU threads per core
'hw_cpu_max_threads': fields.IntegerField(),
# CPU allocation policy
'hw_cpu_policy': fields.CPUAllocationPolicyField(),
# CPU thread allocation policy
'hw_cpu_thread_policy': fields.CPUThreadAllocationPolicyField(),
# CPU mask indicates which vCPUs will have realtime enable,
# example ^0-1 means that all vCPUs except 0 and 1 will have a
# realtime policy.
'hw_cpu_realtime_mask': fields.StringField(),
# preferred number of CPU threads per core
'hw_cpu_threads': fields.IntegerField(),
# guest ABI version for guest xentools either 1 or 2 (or 3 - depends on
# Citrix PV tools version installed in image)
'hw_device_id': fields.IntegerField(),
# name of the hard disk bus to use eg virtio, scsi, ide
'hw_disk_bus': fields.DiskBusField(),
# allocation mode eg 'preallocated'
'hw_disk_type': fields.StringField(),
# name of the floppy disk bus to use eg fd, scsi, ide
'hw_floppy_bus': fields.DiskBusField(),
# This indicates the guest needs UEFI firmware
'hw_firmware_type': fields.FirmwareTypeField(),
# boolean - used to trigger code to inject networking when booting a CD
# image with a network boot image
'hw_ipxe_boot': fields.FlexibleBooleanField(),
# There are sooooooooooo many possible machine types in
# QEMU - several new ones with each new release - that it
# is not practical to enumerate them all. So we use a free
# form string
'hw_machine_type': fields.StringField(),
# One of the magic strings 'small', 'any', 'large'
# or an explicit page size in KB (eg 4, 2048, ...)
'hw_mem_page_size': fields.StringField(),
# Number of guest NUMA nodes
'hw_numa_nodes': fields.IntegerField(),
# Each list entry corresponds to a guest NUMA node and the
# set members indicate CPUs for that node
'hw_numa_cpus': fields.ListOfSetsOfIntegersField(),
# Each list entry corresponds to a guest NUMA node and the
# list value indicates the memory size of that node.
'hw_numa_mem': fields.ListOfIntegersField(),
# Generic property to specify the pointer model type.
'hw_pointer_model': fields.PointerModelField(),
# boolean 'true' or 'false' to enable virtual performance
# monitoring unit (vPMU).
'hw_pmu': fields.FlexibleBooleanField(),
# boolean 'yes' or 'no' to enable QEMU guest agent
'hw_qemu_guest_agent': fields.FlexibleBooleanField(),
# name of the rescue bus to use with the associated rescue device.
'hw_rescue_bus': fields.DiskBusField(),
# name of rescue device to use.
'hw_rescue_device': fields.BlockDeviceTypeField(),
# name of the RNG device type eg virtio
'hw_rng_model': fields.RNGModelField(),
# boolean 'true' or 'false' to enable HPET
'hw_time_hpet': fields.FlexibleBooleanField(),
# number of serial ports to create
'hw_serial_port_count': fields.IntegerField(),
# name of the SCSI bus controller eg 'virtio-scsi', 'lsilogic', etc
'hw_scsi_model': fields.SCSIModelField(),
# name of the video adapter model to use, eg cirrus, vga, xen, qxl
'hw_video_model': fields.VideoModelField(),
# MB of video RAM to provide eg 64
'hw_video_ram': fields.IntegerField(),
# name of a NIC device model eg virtio, e1000, rtl8139
'hw_vif_model': fields.VIFModelField(),
# "xen" vs "hvm"
'hw_vm_mode': fields.VMModeField(),
# action to take when watchdog device fires eg reset, poweroff, pause,
# none
'hw_watchdog_action': fields.WatchdogActionField(),
# boolean - If true, this will enable the virtio-multiqueue feature
'hw_vif_multiqueue_enabled': fields.FlexibleBooleanField(),
# if true download using bittorrent
'img_bittorrent': fields.FlexibleBooleanField(),
# Which data format the 'img_block_device_mapping' field is
# using to represent the block device mapping
'img_bdm_v2': fields.FlexibleBooleanField(),
# Block device mapping - the may can be in one or two completely
# different formats. The 'img_bdm_v2' field determines whether
# it is in legacy format, or the new current format. Ideally
# we would have a formal data type for this field instead of a
# dict, but with 2 different formats to represent this is hard.
# See nova/block_device.py from_legacy_mapping() for the complex
# conversion code. So for now leave it as a dict and continue
# to use existing code that is able to convert dict into the
# desired internal BDM formats
'img_block_device_mapping': fields.ListOfDictOfNullableStringsField(),
# boolean - if True, and image cache set to "some" decides if image
# should be cached on host when server is booted on that host
'img_cache_in_nova': fields.FlexibleBooleanField(),
# Compression level for images. (1-9)
'img_compression_level': fields.IntegerField(),
# hypervisor supported version, eg. '>=2.6'
'img_hv_requested_version': fields.VersionPredicateField(),
# type of the hypervisor, eg kvm, ironic, xen
'img_hv_type': fields.HVTypeField(),
# Whether the image needs/expected config drive
'img_config_drive': fields.ConfigDrivePolicyField(),
# boolean flag to set space-saving or performance behavior on the
# Datastore
'img_linked_clone': fields.FlexibleBooleanField(),
# Image mappings - related to Block device mapping data - mapping
# of virtual image names to device names. This could be represented
# as a formal data type, but is left as dict for same reason as
# img_block_device_mapping field. It would arguably make sense for
# the two to be combined into a single field and data type in the
# future.
'img_mappings': fields.ListOfDictOfNullableStringsField(),
# image project id (set on upload)
'img_owner_id': fields.StringField(),
# root device name, used in snapshotting eg /dev/<blah>
'img_root_device_name': fields.StringField(),
# boolean - if false don't talk to nova agent
'img_use_agent': fields.FlexibleBooleanField(),
# integer value 1
'img_version': fields.IntegerField(),
# base64 of encoding of image signature
'img_signature': fields.StringField(),
# string indicating hash method used to compute image signature
'img_signature_hash_method': fields.ImageSignatureHashTypeField(),
# string indicating Castellan uuid of certificate
# used to compute the image's signature
'img_signature_certificate_uuid': fields.UUIDField(),
# string indicating type of key used to compute image signature
'img_signature_key_type': fields.ImageSignatureKeyTypeField(),
# boolean - hide hypervisor signature on instance
'img_hide_hypervisor_id': fields.FlexibleBooleanField(),
# string of username with admin privileges
'os_admin_user': fields.StringField(),
# string of boot time command line arguments for the guest kernel
'os_command_line': fields.StringField(),
# the name of the specific guest operating system distro. This
# is not done as an Enum since the list of operating systems is
# growing incredibly fast, and valid values can be arbitrarily
# user defined. Nova has no real need for strict validation so
# leave it freeform
'os_distro': fields.StringField(),
# boolean - if true, then guest must support disk quiesce
# or snapshot operation will be denied
'os_require_quiesce': fields.FlexibleBooleanField(),
# Secure Boot feature will be enabled by setting the "os_secure_boot"
# image property to "required". Other options can be: "disabled" or
# "optional".
# "os:secure_boot" flavor extra spec value overrides the image property
# value.
'os_secure_boot': fields.SecureBootField(),
# boolean - if using agent don't inject files, assume someone else is
# doing that (cloud-init)
'os_skip_agent_inject_files_at_boot': fields.FlexibleBooleanField(),
# boolean - if using agent don't try inject ssh key, assume someone
# else is doing that (cloud-init)
'os_skip_agent_inject_ssh': fields.FlexibleBooleanField(),
# The guest operating system family such as 'linux', 'windows' - this
# is a fairly generic type. For a detailed type consider os_distro
# instead
'os_type': fields.OSTypeField(),
# The required traits associated with the image. Traits are expected to
# be defined as starting with `trait:` like below:
# trait:HW_CPU_X86_AVX2=required
# for trait in image_meta.traits_required:
# will yield trait strings such as 'HW_CPU_X86_AVX2'
'traits_required': fields.ListOfStringsField(),
}
# The keys are the legacy property names and
# the values are the current preferred names
_legacy_property_map = {
'architecture': 'hw_architecture',
'owner_id': 'img_owner_id',
'vmware_disktype': 'hw_disk_type',
'vmware_image_version': 'img_version',
'vmware_ostype': 'os_distro',
'auto_disk_config': 'hw_auto_disk_config',
'ipxe_boot': 'hw_ipxe_boot',
'xenapi_device_id': 'hw_device_id',
'xenapi_image_compression_level': 'img_compression_level',
'vmware_linked_clone': 'img_linked_clone',
'xenapi_use_agent': 'img_use_agent',
'xenapi_skip_agent_inject_ssh': 'os_skip_agent_inject_ssh',
'xenapi_skip_agent_inject_files_at_boot':
'os_skip_agent_inject_files_at_boot',
'cache_in_nova': 'img_cache_in_nova',
'vm_mode': 'hw_vm_mode',
'bittorrent': 'img_bittorrent',
'mappings': 'img_mappings',
'block_device_mapping': 'img_block_device_mapping',
'bdm_v2': 'img_bdm_v2',
'root_device_name': 'img_root_device_name',
'hypervisor_version_requires': 'img_hv_requested_version',
'hypervisor_type': 'img_hv_type',
}
# TODO(berrange): Need to run this from a data migration
# at some point so we can eventually kill off the compat
def _set_attr_from_legacy_names(self, image_props):
for legacy_key in self._legacy_property_map:
new_key = self._legacy_property_map[legacy_key]
if legacy_key not in image_props:
continue
setattr(self, new_key, image_props[legacy_key])
vmware_adaptertype = image_props.get("vmware_adaptertype")
if vmware_adaptertype == "ide":
setattr(self, "hw_disk_bus", "ide")
elif vmware_adaptertype:
setattr(self, "hw_disk_bus", "scsi")
setattr(self, "hw_scsi_model", vmware_adaptertype)
def _set_numa_mem(self, image_props):
hw_numa_mem = []
hw_numa_mem_set = False
for cellid in range(ImageMetaProps.NUMA_NODES_MAX):
memprop = "hw_numa_mem.%d" % cellid
if memprop not in image_props:
break
hw_numa_mem.append(int(image_props[memprop]))
hw_numa_mem_set = True
del image_props[memprop]
if hw_numa_mem_set:
self.hw_numa_mem = hw_numa_mem
def _set_numa_cpus(self, image_props):
hw_numa_cpus = []
hw_numa_cpus_set = False
for cellid in range(ImageMetaProps.NUMA_NODES_MAX):
cpuprop = "hw_numa_cpus.%d" % cellid
if cpuprop not in image_props:
break
hw_numa_cpus.append(hardware.parse_cpu_spec(image_props[cpuprop]))
hw_numa_cpus_set = True
del image_props[cpuprop]
if hw_numa_cpus_set:
self.hw_numa_cpus = hw_numa_cpus
def _set_attr_from_current_names(self, image_props):
for key in self.fields:
# The two NUMA fields need special handling to
# un-stringify them correctly
if key == "hw_numa_mem":
self._set_numa_mem(image_props)
elif key == "hw_numa_cpus":
self._set_numa_cpus(image_props)
else:
# traits_required will be populated by
# _set_attr_from_trait_names
if key not in image_props or key == "traits_required":
continue
setattr(self, key, image_props[key])
def _set_attr_from_trait_names(self, image_props):
for trait in [
six.text_type(k[6:]) for k, v in image_props.items()
if six.text_type(k).startswith("trait:")
and six.text_type(v) == six.text_type('required')
]:
if 'traits_required' not in self:
self.traits_required = []
self.traits_required.append(trait)
@classmethod
def from_dict(cls, image_props):
"""Create instance from image properties dict
:param image_props: dictionary of image metadata properties
Creates a new object instance, initializing from a
dictionary of image metadata properties
:returns: an ImageMetaProps instance
"""
obj = cls()
# We look to see if the dict has entries for any
# of the legacy property names first. Then we use
# the current property names. That way if both the
# current and legacy names are set, the value
# associated with the current name takes priority
obj._set_attr_from_legacy_names(image_props)
obj._set_attr_from_current_names(image_props)
obj._set_attr_from_trait_names(image_props)
return obj
def get(self, name, defvalue=None):
"""Get the value of an attribute
:param name: the attribute to request
:param defvalue: the default value if not set
This returns the value of an attribute if it is currently
set, otherwise it will return None.
This differs from accessing props.attrname, because that
will raise an exception if the attribute has no value set.
So instead of
if image_meta.properties.obj_attr_is_set("some_attr"):
val = image_meta.properties.some_attr
else
val = None
Callers can rely on unconditional access
val = image_meta.properties.get("some_attr")
:returns: the attribute value or None
"""
if not self.obj_attr_is_set(name):
return defvalue
return getattr(self, name)
class InstanceGroup(base.NovaPersistentObject, base.NovaObject,
base.NovaObjectDictCompat):
# Version 1.0: Initial version
# Version 1.1: String attributes updated to support unicode
# Version 1.2: Use list/dict helpers for policies, metadetails, members
# Version 1.3: Make uuid a non-None real string
# Version 1.4: Add add_members()
# Version 1.5: Add get_hosts()
# Version 1.6: Add get_by_name()
# Version 1.7: Deprecate metadetails
# Version 1.8: Add count_members_by_user()
# Version 1.9: Add get_by_instance_uuid()
VERSION = '1.9'
fields = {
'id': fields.IntegerField(),
'user_id': fields.StringField(nullable=True),
'project_id': fields.StringField(nullable=True),
'uuid': fields.UUIDField(),
'name': fields.StringField(nullable=True),
'policies': fields.ListOfStringsField(nullable=True),
'members': fields.ListOfStringsField(nullable=True),
}
def obj_make_compatible(self, primitive, target_version):
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 7):
# NOTE(danms): Before 1.7, we had an always-empty
# metadetails property
primitive['metadetails'] = {}
@staticmethod
def _from_db_object(context, instance_group, db_inst):
"""Method to help with migration to objects.
Converts a database entity to a formal object.
"""
# Most of the field names match right now, so be quick
for field in instance_group.fields:
if field == 'deleted':
instance_group.deleted = db_inst['deleted'] == db_inst['id']
else:
instance_group[field] = db_inst[field]
instance_group._context = context
instance_group.obj_reset_changes()
return instance_group
@base.remotable_classmethod
def get_by_uuid(cls, context, uuid):
db_inst = db.instance_group_get(context, uuid)
return cls._from_db_object(context, cls(), db_inst)
@base.remotable_classmethod
def get_by_name(cls, context, name):
# TODO(russellb) We need to get the group by name here. There's no
# db.api method for this yet. Come back and optimize this by
# adding a new query by name. This is unnecessarily expensive if a
# tenant has lots of groups.
igs = objects.InstanceGroupList.get_by_project_id(
context, context.project_id)
for ig in igs:
if ig.name == name:
return ig
raise exception.InstanceGroupNotFound(group_uuid=name)
@base.remotable_classmethod
def get_by_instance_uuid(cls, context, instance_uuid):
db_inst = db.instance_group_get_by_instance(context, instance_uuid)
return cls._from_db_object(context, cls(), db_inst)
@classmethod
def get_by_hint(cls, context, hint):
if uuidutils.is_uuid_like(hint):
return cls.get_by_uuid(context, hint)
else:
return cls.get_by_name(context, hint)
@base.remotable
def save(self):
"""Save updates to this instance group."""
updates = self.obj_get_changes()
if not updates:
return
payload = dict(updates)
payload['server_group_id'] = self.uuid
db.instance_group_update(self._context, self.uuid, updates)
db_inst = db.instance_group_get(self._context, self.uuid)
self._from_db_object(self._context, self, db_inst)
compute_utils.notify_about_server_group_update(self._context, "update",
payload)
@base.remotable
def refresh(self):
"""Refreshes the instance group."""
current = self.__class__.get_by_uuid(self._context, self.uuid)
for field in self.fields:
if self.obj_attr_is_set(field) and self[field] != current[field]:
self[field] = current[field]
self.obj_reset_changes()
@base.remotable
def create(self):
if self.obj_attr_is_set('id'):
raise exception.ObjectActionError(action='create',
reason='already created')
updates = self.obj_get_changes()
payload = dict(updates)
updates.pop('id', None)
policies = updates.pop('policies', None)
members = updates.pop('members', None)
db_inst = db.instance_group_create(self._context,
updates,
policies=policies,
members=members)
self._from_db_object(self._context, self, db_inst)
payload['server_group_id'] = self.uuid
compute_utils.notify_about_server_group_update(self._context, "create",
payload)
@base.remotable
def destroy(self):
payload = {'server_group_id': self.uuid}
db.instance_group_delete(self._context, self.uuid)
self.obj_reset_changes()
compute_utils.notify_about_server_group_update(self._context, "delete",
payload)
@base.remotable_classmethod
def add_members(cls, context, group_uuid, instance_uuids):
payload = {
'server_group_id': group_uuid,
'instance_uuids': instance_uuids
}
members = db.instance_group_members_add(context, group_uuid,
instance_uuids)
compute_utils.notify_about_server_group_update(context, "addmember",
payload)
return list(members)
@base.remotable
def get_hosts(self, exclude=None):
"""Get a list of hosts for non-deleted instances in the group
This method allows you to get a list of the hosts where instances in
this group are currently running. There's also an option to exclude
certain instance UUIDs from this calculation.
"""
filter_uuids = self.members
if exclude:
filter_uuids = set(filter_uuids) - set(exclude)
filters = {'uuid': filter_uuids, 'deleted': False}
instances = objects.InstanceList.get_by_filters(self._context,
filters=filters)
return list(
set([instance.host for instance in instances if instance.host]))
@base.remotable
def count_members_by_user(self, user_id):
"""Count the number of instances in a group belonging to a user."""
filter_uuids = self.members
filters = {'uuid': filter_uuids, 'user_id': user_id, 'deleted': False}
instances = objects.InstanceList.get_by_filters(self._context,
filters=filters)
return len(instances)
class InstanceGroup(base.NovaPersistentObject, base.NovaObject,
base.NovaObjectDictCompat):
# Version 1.0: Initial version
# Version 1.1: String attributes updated to support unicode
# Version 1.2: Use list/dict helpers for policies, metadetails, members
# Version 1.3: Make uuid a non-None real string
# Version 1.4: Add add_members()
# Version 1.5: Add get_hosts()
# Version 1.6: Add get_by_name()
# Version 1.7: Deprecate metadetails
# Version 1.8: Add count_members_by_user()
# Version 1.9: Add get_by_instance_uuid()
# Version 1.10: Add hosts field
# Version 1.11: Add policy and deprecate policies, add _rules
VERSION = '1.11'
fields = {
'id': fields.IntegerField(),
'user_id': fields.StringField(nullable=True),
'project_id': fields.StringField(nullable=True),
'uuid': fields.UUIDField(),
'name': fields.StringField(nullable=True),
'policies': fields.ListOfStringsField(nullable=True, read_only=True),
'members': fields.ListOfStringsField(nullable=True),
'hosts': fields.ListOfStringsField(nullable=True),
'policy': fields.StringField(nullable=True),
# NOTE(danms): Use rules not _rules for general access
'_rules': fields.DictOfStringsField(),
}
def __init__(self, *args, **kwargs):
if 'rules' in kwargs:
kwargs['_rules'] = kwargs.pop('rules')
super(InstanceGroup, self).__init__(*args, **kwargs)
@property
def rules(self):
if '_rules' not in self:
return {}
# NOTE(danms): Coerce our rules into a typed dict for convenience
rules = {}
if 'max_server_per_host' in self._rules:
rules['max_server_per_host'] = \
int(self._rules['max_server_per_host'])
return rules
def obj_make_compatible(self, primitive, target_version):
target_version = versionutils.convert_version_to_tuple(target_version)
if target_version < (1, 11):
# NOTE(yikun): Before 1.11, we had a policies property which is
# the list of policy name, even though it was a list, there was
# ever only one entry in the list.
policy = primitive.pop('policy', None)
if policy:
primitive['policies'] = [policy]
else:
primitive['policies'] = []
primitive.pop('rules', None)
if target_version < (1, 7):
# NOTE(danms): Before 1.7, we had an always-empty
# metadetails property
primitive['metadetails'] = {}
@staticmethod
def _from_db_object(context, instance_group, db_inst):
"""Method to help with migration to objects.
Converts a database entity to a formal object.
"""
# Most of the field names match right now, so be quick
for field in instance_group.fields:
if field in LAZY_LOAD_FIELDS:
continue
# This is needed to handle db models from both the api
# database and the main database. In the migration to
# the api database, we have removed soft-delete, so
# the object fields for delete must be filled in with
# default values for db models from the api database.
# TODO(mriedem): Remove this when NovaPersistentObject is removed.
ignore = {'deleted': False, 'deleted_at': None}
if '_rules' == field:
db_policy = db_inst['policy']
instance_group._rules = (jsonutils.loads(db_policy['rules'])
if db_policy and db_policy['rules']
else {})
elif field in ignore and not hasattr(db_inst, field):
instance_group[field] = ignore[field]
elif 'policies' == field:
continue
# NOTE(yikun): The obj.policies is deprecated and marked as
# read_only in version 1.11, and there is no "policies" property
# in InstanceGroup model anymore, so we just skip to set
# "policies" and then load the "policies" when "policy" is set.
elif 'policy' == field:
db_policy = db_inst['policy']
if db_policy:
instance_group.policy = db_policy['policy']
instance_group.policies = [instance_group.policy]
else:
instance_group.policy = None
instance_group.policies = []
else:
instance_group[field] = db_inst[field]
instance_group._context = context
instance_group.obj_reset_changes()
return instance_group
@staticmethod
@db_api.api_context_manager.reader
def _get_from_db_by_uuid(context, uuid):
grp = _instance_group_get_query(context,
id_field=api_models.InstanceGroup.uuid,
id=uuid).first()
if not grp:
raise exception.InstanceGroupNotFound(group_uuid=uuid)
return grp
@staticmethod
@db_api.api_context_manager.reader
def _get_from_db_by_id(context, id):
grp = _instance_group_get_query(context,
id_field=api_models.InstanceGroup.id,
id=id).first()
if not grp:
raise exception.InstanceGroupNotFound(group_uuid=id)
return grp
@staticmethod
@db_api.api_context_manager.reader
def _get_from_db_by_name(context, name):
grp = _instance_group_get_query(context).filter_by(name=name).first()
if not grp:
raise exception.InstanceGroupNotFound(group_uuid=name)
return grp
@staticmethod
@db_api.api_context_manager.reader
def _get_from_db_by_instance(context, instance_uuid):
grp_member = context.session.query(api_models.InstanceGroupMember).\
filter_by(instance_uuid=instance_uuid).first()
if not grp_member:
raise exception.InstanceGroupNotFound(group_uuid='')
grp = InstanceGroup._get_from_db_by_id(context, grp_member.group_id)
return grp
@staticmethod
@db_api.api_context_manager.writer
def _save_in_db(context, group_uuid, values):
grp = InstanceGroup._get_from_db_by_uuid(context, group_uuid)
values_copy = copy.copy(values)
members = values_copy.pop('members', None)
grp.update(values_copy)
if members is not None:
_instance_group_members_add(context, grp, members)
return grp
@staticmethod
@db_api.api_context_manager.writer
def _create_in_db(context,
values,
policies=None,
members=None,
policy=None,
rules=None):
try:
group = api_models.InstanceGroup()
group.update(values)
group.save(context.session)
except db_exc.DBDuplicateEntry:
raise exception.InstanceGroupIdExists(group_uuid=values['uuid'])
if policies:
db_policy = api_models.InstanceGroupPolicy(group_id=group['id'],
policy=policies[0],
rules=None)
group._policies = [db_policy]
group.rules = None
elif policy:
db_rules = jsonutils.dumps(rules or {})
db_policy = api_models.InstanceGroupPolicy(group_id=group['id'],
policy=policy,
rules=db_rules)
group._policies = [db_policy]
else:
group._policies = []
if group._policies:
group.save(context.session)
if members:
group._members = _instance_group_members_add(
context, group, members)
else:
group._members = []
return group
@staticmethod
@db_api.api_context_manager.writer
def _destroy_in_db(context, group_uuid):
qry = _instance_group_get_query(context,
id_field=api_models.InstanceGroup.uuid,
id=group_uuid)
if qry.count() == 0:
raise exception.InstanceGroupNotFound(group_uuid=group_uuid)
# Delete policies and members
group_id = qry.first().id
instance_models = [
api_models.InstanceGroupPolicy, api_models.InstanceGroupMember
]
for model in instance_models:
context.session.query(model).filter_by(group_id=group_id).delete()
qry.delete()
@staticmethod
@db_api.api_context_manager.writer
def _add_members_in_db(context, group_uuid, members):
return _instance_group_members_add_by_uuid(context, group_uuid,
members)
@staticmethod
@db_api.api_context_manager.writer
def _remove_members_in_db(context, group_id, instance_uuids):
# There is no public method provided for removing members because the
# user-facing API doesn't allow removal of instance group members. We
# need to be able to remove members to address quota races.
context.session.query(api_models.InstanceGroupMember).\
filter_by(group_id=group_id).\
filter(api_models.InstanceGroupMember.instance_uuid.
in_(set(instance_uuids))).\
delete(synchronize_session=False)
@staticmethod
@db_api.api_context_manager.writer
def _destroy_members_bulk_in_db(context, instance_uuids):
return context.session.query(api_models.InstanceGroupMember).filter(
api_models.InstanceGroupMember.instance_uuid.in_(instance_uuids)).\
delete(synchronize_session=False)
@classmethod
def destroy_members_bulk(cls, context, instance_uuids):
return cls._destroy_members_bulk_in_db(context, instance_uuids)
def obj_load_attr(self, attrname):
# NOTE(sbauza): Only hosts could be lazy-loaded right now
if attrname != 'hosts':
raise exception.ObjectActionError(action='obj_load_attr',
reason='unable to load %s' %
attrname)
LOG.debug("Lazy-loading '%(attr)s' on %(name)s uuid %(uuid)s", {
'attr': attrname,
'name': self.obj_name(),
'uuid': self.uuid,
})
self.hosts = self.get_hosts()
self.obj_reset_changes(['hosts'])
@base.remotable_classmethod
def get_by_uuid(cls, context, uuid):
db_group = cls._get_from_db_by_uuid(context, uuid)
return cls._from_db_object(context, cls(), db_group)
@base.remotable_classmethod
def get_by_name(cls, context, name):
db_group = cls._get_from_db_by_name(context, name)
return cls._from_db_object(context, cls(), db_group)
@base.remotable_classmethod
def get_by_instance_uuid(cls, context, instance_uuid):
db_group = cls._get_from_db_by_instance(context, instance_uuid)
return cls._from_db_object(context, cls(), db_group)
@classmethod
def get_by_hint(cls, context, hint):
if uuidutils.is_uuid_like(hint):
return cls.get_by_uuid(context, hint)
else:
return cls.get_by_name(context, hint)
@base.remotable
def save(self):
"""Save updates to this instance group."""
updates = self.obj_get_changes()
# NOTE(sbauza): We do NOT save the set of compute nodes that an
# instance group is connected to in this method. Instance groups are
# implicitly connected to compute nodes when the
# InstanceGroup.add_members() method is called, which adds the mapping
# table entries.
# So, since the only way to have hosts in the updates is to set that
# field explicitly, we prefer to raise an Exception so the developer
# knows he has to call obj_reset_changes(['hosts']) right after setting
# the field.
if 'hosts' in updates:
raise exception.InstanceGroupSaveException(field='hosts')
# NOTE(yikun): You have to provide exactly one policy on group create,
# and also there are no group update APIs, so we do NOT support
# policies update.
if 'policies' in updates:
raise exception.InstanceGroupSaveException(field='policies')
if not updates:
return
payload = dict(updates)
payload['server_group_id'] = self.uuid
db_group = self._save_in_db(self._context, self.uuid, updates)
self._from_db_object(self._context, self, db_group)
compute_utils.notify_about_server_group_update(self._context, "update",
payload)
@base.remotable
def refresh(self):
"""Refreshes the instance group."""
current = self.__class__.get_by_uuid(self._context, self.uuid)
for field in self.fields:
if self.obj_attr_is_set(field) and self[field] != current[field]:
self[field] = current[field]
self.obj_reset_changes()
@base.remotable
def create(self):
if self.obj_attr_is_set('id'):
raise exception.ObjectActionError(action='create',
reason='already created')
updates = self.obj_get_changes()
payload = dict(updates)
updates.pop('id', None)
policies = updates.pop('policies', None)
policy = updates.pop('policy', None)
rules = updates.pop('_rules', None)
members = updates.pop('members', None)
if 'uuid' not in updates:
self.uuid = uuidutils.generate_uuid()
updates['uuid'] = self.uuid
db_group = self._create_in_db(self._context,
updates,
policies=policies,
members=members,
policy=policy,
rules=rules)
self._from_db_object(self._context, self, db_group)
payload['server_group_id'] = self.uuid
compute_utils.notify_about_server_group_update(self._context, "create",
payload)
compute_utils.notify_about_server_group_action(
context=self._context,
group=self,
action=fields.NotificationAction.CREATE)
@base.remotable
def destroy(self):
payload = {'server_group_id': self.uuid}
self._destroy_in_db(self._context, self.uuid)
self.obj_reset_changes()
compute_utils.notify_about_server_group_update(self._context, "delete",
payload)
compute_utils.notify_about_server_group_action(
context=self._context,
group=self,
action=fields.NotificationAction.DELETE)
@base.remotable_classmethod
def add_members(cls, context, group_uuid, instance_uuids):
payload = {
'server_group_id': group_uuid,
'instance_uuids': instance_uuids
}
members = cls._add_members_in_db(context, group_uuid, instance_uuids)
members = [member['instance_uuid'] for member in members]
compute_utils.notify_about_server_group_update(context, "addmember",
payload)
compute_utils.notify_about_server_group_add_member(context, group_uuid)
return list(members)
@base.remotable
def get_hosts(self, exclude=None):
"""Get a list of hosts for non-deleted instances in the group
This method allows you to get a list of the hosts where instances in
this group are currently running. There's also an option to exclude
certain instance UUIDs from this calculation.
"""
filter_uuids = self.members
if exclude:
filter_uuids = set(filter_uuids) - set(exclude)
filters = {'uuid': filter_uuids, 'deleted': False}
instances = objects.InstanceList.get_by_filters(self._context,
filters=filters)
return list(
set([instance.host for instance in instances if instance.host]))
@base.remotable
def count_members_by_user(self, user_id):
"""Count the number of instances in a group belonging to a user."""
filter_uuids = self.members
filters = {'uuid': filter_uuids, 'user_id': user_id, 'deleted': False}
instances = objects.InstanceList.get_by_filters(self._context,
filters=filters)
return len(instances)
class Quotas(base.NovaObject, base.NovaObjectDictCompat):
# Version 1.0: initial version
# Version 1.1: Added create_limit() and update_limit()
# Version 1.2: Added limit_check() and count()
VERSION = '1.2'
fields = {
'reservations': fields.ListOfStringsField(nullable=True),
'project_id': fields.StringField(nullable=True),
'user_id': fields.StringField(nullable=True),
}
def __init__(self, *args, **kwargs):
super(Quotas, self).__init__(*args, **kwargs)
# Set up defaults.
self.reservations = []
self.project_id = None
self.user_id = None
self.obj_reset_changes()
@classmethod
def from_reservations(cls, context, reservations, instance=None):
"""Transitional for compatibility."""
if instance is None:
project_id = None
user_id = None
else:
project_id, user_id = ids_from_instance(context, instance)
quotas = cls()
quotas._context = context
quotas.reservations = reservations
quotas.project_id = project_id
quotas.user_id = user_id
quotas.obj_reset_changes()
return quotas
@base.remotable
def reserve(self, expire=None, project_id=None, user_id=None, **deltas):
reservations = quota.QUOTAS.reserve(self._context,
expire=expire,
project_id=project_id,
user_id=user_id,
**deltas)
self.reservations = reservations
self.project_id = project_id
self.user_id = user_id
self.obj_reset_changes()
@base.remotable
def commit(self):
if not self.reservations:
return
quota.QUOTAS.commit(self._context,
self.reservations,
project_id=self.project_id,
user_id=self.user_id)
self.reservations = None
self.obj_reset_changes()
@base.remotable
def rollback(self):
"""Rollback quotas."""
if not self.reservations:
return
quota.QUOTAS.rollback(self._context,
self.reservations,
project_id=self.project_id,
user_id=self.user_id)
self.reservations = None
self.obj_reset_changes()
@base.remotable_classmethod
def limit_check(cls, context, project_id=None, user_id=None, **values):
"""Check quota limits."""
return quota.QUOTAS.limit_check(context,
project_id=project_id,
user_id=user_id,
**values)
@base.remotable_classmethod
def count(cls, context, resource, *args, **kwargs):
"""Count a resource."""
return quota.QUOTAS.count(context, resource, *args, **kwargs)
@base.remotable_classmethod
def create_limit(cls, context, project_id, resource, limit, user_id=None):
# NOTE(danms,comstud): Quotas likely needs an overhaul and currently
# doesn't map very well to objects. Since there is quite a bit of
# logic in the db api layer for this, just pass this through for now.
db.quota_create(context, project_id, resource, limit, user_id=user_id)
@base.remotable_classmethod
def update_limit(cls, context, project_id, resource, limit, user_id=None):
# NOTE(danms,comstud): Quotas likely needs an overhaul and currently
# doesn't map very well to objects. Since there is quite a bit of
# logic in the db api layer for this, just pass this through for now.
db.quota_update(context, project_id, resource, limit, user_id=user_id)
