def obj_calculate_child_version(self, target_version, child):
"""Calculate the appropriate version for a child object.
This is to be used when backporting an object for an older client.
A sub-object will need to be backported to a suitable version for
the client as well, and this method will calculate what that
version should be, based on obj_relationships.
:param target_version: Version this object is being backported to
:param child: The child field for which the appropriate version
is to be calculated
:returns: None if the child should be omitted from the backport,
otherwise, the version to which the child should be
backported
"""
target_version = utils.convert_version_to_tuple(target_version)
for index, versions in enumerate(self.obj_relationships[child]):
my_version, child_version = versions
my_version = utils.convert_version_to_tuple(my_version)
if target_version < my_version:
if index == 0:
# We're backporting to a version from before this
# subobject was added: delete it from the primitive.
return None
else:
# We're in the gap between index-1 and index, so
# backport to the older version
return self.obj_relationships[child][index - 1][1]
elif target_version == my_version:
# This is the first mapping that satisfies the
# target_version request: backport the object.
return child_version
# No need to backport, as far as we know, so return the latest
# version of the sub-object we know about
return self.obj_relationships[child][-1][1]
def obj_make_compatible(self, primitive, target_version):
primitives = primitive['objects']
target_version = utils.convert_version_to_tuple(target_version)
if self.child_versions:
child_target_version = self.child_versions.get(target_version,
'1.0')
else:
child_target_version = '1.0'
rel_versions = self.obj_relationships['objects']
for index, versions in enumerate(rel_versions):
my_version, child_version = versions
my_version = utils.convert_version_to_tuple(my_version)
if target_version < my_version:
if index == 0:
# if the target is before we existed, delete objects
# from the primitive
# (we should never get here, because lists should
# always have an 'objects' field)
del primitive['objects']
else:
# We still don't match, but we'll grab the latest
# child version up to this point
child_target_version = rel_versions[index - 1][1]
elif target_version == my_version:
child_target_version = child_version
break
for index, item in enumerate(self.objects):
self.objects[index].obj_make_compatible(
self._obj_primitive_field(primitives[index], 'data'),
child_target_version)
verkey = self._obj_primitive_key('version')
primitives[index][verkey] = child_target_version
def obj_calculate_child_version(self, target_version, child):
"""Calculate the appropriate version for a child object.
This is to be used when backporting an object for an older client.
A sub-object will need to be backported to a suitable version for
the client as well, and this method will calculate what that
version should be, based on obj_relationships.
:param target_version: Version this object is being backported to
:param child: The child field for which the appropriate version
is to be calculated
:returns: None if the child should be omitted from the backport,
otherwise, the version to which the child should be
backported
"""
target_version = utils.convert_version_to_tuple(target_version)
for index, versions in enumerate(self.obj_relationships[child]):
my_version, child_version = versions
my_version = utils.convert_version_to_tuple(my_version)
if target_version < my_version:
if index == 0:
# We're backporting to a version from before this
# subobject was added: delete it from the primitive.
return None
else:
# We're in the gap between index-1 and index, so
# backport to the older version
return self.obj_relationships[child][index - 1][1]
elif target_version == my_version:
# This is the first mapping that satisfies the
# target_version request: backport the object.
return child_version
# No need to backport, as far as we know, so return the latest
# version of the sub-object we know about
return self.obj_relationships[child][-1][1]
def obj_make_compatible(self, primitive, target_version):
primitives = primitive['objects']
target_version = utils.convert_version_to_tuple(target_version)
if self.child_versions:
child_target_version = self.child_versions.get(target_version,
'1.0')
else:
child_target_version = '1.0'
rel_versions = self.obj_relationships['objects']
for index, versions in enumerate(rel_versions):
my_version, child_version = versions
my_version = utils.convert_version_to_tuple(my_version)
if target_version < my_version:
if index == 0:
# if the target is before we existed, delete objects
# from the primitive
# (we should never get here, because lists should
# always have an 'objects' field)
del primitive['objects']
else:
# We still don't match, but we'll grab the latest
# child version up to this point
child_target_version = rel_versions[index - 1][1]
elif target_version == my_version:
child_target_version = child_version
break
for index, item in enumerate(self.objects):
self.objects[index].obj_make_compatible(
self._obj_primitive_field(primitives[index], 'data'),
child_target_version)
verkey = self._obj_primitive_key('version')
primitives[index][verkey] = child_target_version
def registration_hook(self, cls, index):
# NOTE(danms): This is called when an object is registered,
# and is responsible for maintaining nova.objects.$OBJECT
# as the highest-versioned implementation of a given object.
version = utils.convert_version_to_tuple(cls.VERSION)
if not hasattr(objects, cls.obj_name()):
setattr(objects, cls.obj_name(), cls)
else:
cur_version = utils.convert_version_to_tuple(
getattr(objects, cls.obj_name()).VERSION)
if version >= cur_version:
setattr(objects, cls.obj_name(), cls)
def registration_hook(self, cls, index):
# NOTE(danms): This is called when an object is registered,
# and is responsible for maintaining nova.objects.$OBJECT
# as the highest-versioned implementation of a given object.
version = utils.convert_version_to_tuple(cls.VERSION)
if not hasattr(objects, cls.obj_name()):
setattr(objects, cls.obj_name(), cls)
else:
cur_version = utils.convert_version_to_tuple(
getattr(objects, cls.obj_name()).VERSION)
if version >= cur_version:
setattr(objects, cls.obj_name(), cls)
def _obj_make_obj_compatible(self, primitive, target_version, field):
"""Backlevel a sub-object based on our versioning rules.
This is responsible for backporting objects contained within
this object's primitive according to a set of rules we
maintain about version dependencies between objects. This
requires that the obj_relationships table in this object is
correct and up-to-date.
:param:primitive: The primitive version of this object
:param:target_version: The version string requested for this object
:param:field: The name of the field in this object containing the
sub-object to be backported
"""
def _do_backport(to_version):
obj = getattr(self, field)
if not obj:
return
if isinstance(obj, NovaObject):
obj.obj_make_compatible(
primitive[field]['nova_object.data'],
to_version)
primitive[field]['nova_object.version'] = to_version
elif isinstance(obj, list):
for i, element in enumerate(obj):
element.obj_make_compatible(
primitive[field][i]['nova_object.data'],
to_version)
primitive[field][i]['nova_object.version'] = to_version
target_version = utils.convert_version_to_tuple(target_version)
for index, versions in enumerate(self.obj_relationships[field]):
my_version, child_version = versions
my_version = utils.convert_version_to_tuple(my_version)
if target_version < my_version:
if index == 0:
# We're backporting to a version from before this
# subobject was added: delete it from the primitive.
del primitive[field]
else:
# We're in the gap between index-1 and index, so
# backport to the older version
last_child_version = \
self.obj_relationships[field][index - 1][1]
_do_backport(last_child_version)
return
elif target_version == my_version:
# This is the first mapping that satisfies the
# target_version request: backport the object.
_do_backport(child_version)
return
def _obj_make_obj_compatible(self, primitive, target_version, field):
"""Backlevel a sub-object based on our versioning rules.
This is responsible for backporting objects contained within
this object's primitive according to a set of rules we
maintain about version dependencies between objects. This
requires that the obj_relationships table in this object is
correct and up-to-date.
:param:primitive: The primitive version of this object
:param:target_version: The version string requested for this object
:param:field: The name of the field in this object containing the
sub-object to be backported
"""
def _do_backport(to_version):
obj = getattr(self, field)
if not obj:
return
if isinstance(obj, NovaObject):
obj.obj_make_compatible(
primitive[field]['nova_object.data'],
to_version)
primitive[field]['nova_object.version'] = to_version
elif isinstance(obj, list):
for i, element in enumerate(obj):
element.obj_make_compatible(
primitive[field][i]['nova_object.data'],
to_version)
primitive[field][i]['nova_object.version'] = to_version
target_version = utils.convert_version_to_tuple(target_version)
for index, versions in enumerate(self.obj_relationships[field]):
my_version, child_version = versions
my_version = utils.convert_version_to_tuple(my_version)
if target_version < my_version:
if index == 0:
# We're backporting to a version from before this
# subobject was added: delete it from the primitive.
del primitive[field]
else:
# We're in the gap between index-1 and index, so
# backport to the older version
last_child_version = \
self.obj_relationships[field][index - 1][1]
_do_backport(last_child_version)
return
elif target_version == my_version:
# This is the first mapping that satisfies the
# target_version request: backport the object.
_do_backport(child_version)
return
def has_min_version(self, lv_ver=None, hv_ver=None, hv_type=None):
conn = self.get_connection()
try:
if lv_ver is not None:
libvirt_version = conn.getLibVersion()
if CONF.libvirt.version_cap:
libvirt_version_cap = utils.convert_version_to_int(
utils.convert_version_to_tuple(
CONF.libvirt.version_cap))
if libvirt_version > libvirt_version_cap:
libvirt_version = libvirt_version_cap
if libvirt_version < utils.convert_version_to_int(lv_ver):
return False
if hv_ver is not None:
hypervisor_version = conn.getVersion()
if hypervisor_version < utils.convert_version_to_int(hv_ver):
return False
if hv_type is not None:
hypervisor_type = conn.getType()
if hypervisor_type != hv_type:
return False
return True
except Exception:
return False
def obj_make_compatible(self, primitive, target_version):
super(ComputeNode, self).obj_make_compatible(primitive, target_version)
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 14):
if 'ram_allocation_ratio' in primitive:
del primitive['ram_allocation_ratio']
if 'cpu_allocation_ratio' in primitive:
del primitive['cpu_allocation_ratio']
if target_version < (1, 13) and primitive.get('service_id') is None:
# service_id is non-nullable in versions before 1.13
try:
service = objects.Service.get_by_compute_host(
self._context, primitive['host'])
primitive['service_id'] = service.id
except (exception.ComputeHostNotFound, KeyError):
# NOTE(hanlind): In case anything goes wrong like service not
# found or host not being set, catch and set a fake value just
# to allow for older versions that demand a value to work.
# Setting to -1 will, if value is later used result in a
# ServiceNotFound, so should be safe.
primitive['service_id'] = -1
if target_version < (1, 7) and 'host' in primitive:
del primitive['host']
if target_version < (1, 5) and 'numa_topology' in primitive:
del primitive['numa_topology']
if target_version < (1, 4) and 'host_ip' in primitive:
del primitive['host_ip']
if target_version < (1, 3) and 'stats' in primitive:
# pre 1.3 version does not have a stats field
del primitive['stats']
def obj_make_compatible(self, primitive, target_version):
target_version = utils.convert_version_to_tuple(target_version)
unicode_attributes = [
'user_id', 'project_id', 'image_ref', 'kernel_id', 'ramdisk_id',
'hostname', 'key_name', 'key_data', 'host', 'node', 'user_data',
'availability_zone', 'display_name', 'display_description',
'launched_on', 'locked_by', 'os_type', 'architecture', 'vm_mode',
'root_device_name', 'default_ephemeral_device',
'default_swap_device', 'config_drive', 'cell_name'
]
if target_version < (1, 14) and 'numa_topology' in primitive:
del primitive['numa_topology']
if target_version < (1, 10) and 'info_cache' in primitive:
# NOTE(danms): Instance <= 1.9 (havana) had info_cache 1.4
self.info_cache.obj_make_compatible(
primitive['info_cache']['nova_object.data'], '1.4')
primitive['info_cache']['nova_object.version'] = '1.4'
if target_version < (1, 7):
# NOTE(danms): Before 1.7, we couldn't handle unicode in
# string fields, so squash it here
for field in [
x for x in unicode_attributes
if x in primitive and primitive[x] is not None
]:
primitive[field] = primitive[field].encode('ascii', 'replace')
if target_version < (1, 15) and 'pci_devices' in primitive:
# NOTE(baoli): Instance <= 1.14 (icehouse) had PciDeviceList 1.0
self.pci_devices.obj_make_compatible(
primitive['pci_devices']['nova_object.data'], '1.0')
primitive['pci_devices']['nova_object.version'] = '1.0'
if target_version < (1, 6):
# NOTE(danms): Before 1.6 there was no pci_devices list
if 'pci_devices' in primitive:
del primitive['pci_devices']
def obj_make_compatible(self, primitive, target_version):
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 4) and 'host_ip' in primitive:
del primitive['host_ip']
if target_version < (1, 3) and 'stats' in primitive:
# pre 1.3 version does not have a stats field
del primitive['stats']
def obj_make_compatible(self, primitive, target_version):
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 1) and 'requests' in primitive:
for index, request in enumerate(self.requests):
request.obj_make_compatible(
primitive['requests'][index]['nova_object.data'], '1.0')
primitive['requests'][index]['nova_object.version'] = '1.0'
def obj_make_compatible(self, primitive, target_version):
super(ComputeNode, self).obj_make_compatible(primitive, target_version)
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 14):
if "ram_allocation_ratio" in primitive:
del primitive["ram_allocation_ratio"]
if "cpu_allocation_ratio" in primitive:
del primitive["cpu_allocation_ratio"]
if target_version < (1, 13) and primitive.get("service_id") is None:
# service_id is non-nullable in versions before 1.13
try:
service = objects.Service.get_by_compute_host(self._context, primitive["host"])
primitive["service_id"] = service.id
except (exception.ComputeHostNotFound, KeyError):
# NOTE(hanlind): In case anything goes wrong like service not
# found or host not being set, catch and set a fake value just
# to allow for older versions that demand a value to work.
# Setting to -1 will, if value is later used result in a
# ServiceNotFound, so should be safe.
primitive["service_id"] = -1
if target_version < (1, 7) and "host" in primitive:
del primitive["host"]
if target_version < (1, 5) and "numa_topology" in primitive:
del primitive["numa_topology"]
if target_version < (1, 4) and "host_ip" in primitive:
del primitive["host_ip"]
if target_version < (1, 3) and "stats" in primitive:
# pre 1.3 version does not have a stats field
del primitive["stats"]
def obj_make_compatible(self, primitive, target_version):
super(Migration, self).obj_make_compatible(primitive, target_version)
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 2):
if 'migration_type' in primitive:
del primitive['migration_type']
del primitive['hidden']
def obj_make_compatible(self, primitive, target_version):
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 1) and 'requests' in primitive:
for index, request in enumerate(self.requests):
request.obj_make_compatible(
primitive['requests'][index]['nova_object.data'], '1.0')
primitive['requests'][index]['nova_object.version'] = '1.0'
def obj_make_compatible(self, primitive, target_version):
super(Migration, self).obj_make_compatible(primitive, target_version)
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 2):
if 'migration_type' in primitive:
del primitive['migration_type']
del primitive['hidden']
def obj_make_compatible(self, primitive, target_version):
target_version = utils.convert_version_to_tuple(target_version)
unicode_attributes = ['user_id', 'project_id', 'image_ref',
'kernel_id', 'ramdisk_id', 'hostname',
'key_name', 'key_data', 'host', 'node',
'user_data', 'availability_zone',
'display_name', 'display_description',
'launched_on', 'locked_by', 'os_type',
'architecture', 'vm_mode', 'root_device_name',
'default_ephemeral_device',
'default_swap_device', 'config_drive',
'cell_name']
if target_version < (1, 10) and 'info_cache' in primitive:
# NOTE(danms): Instance <= 1.9 (havana) had info_cache 1.4
self.info_cache.obj_make_compatible(primitive['info_cache'],
'1.4')
primitive['info_cache']['nova_object.version'] = '1.4'
if target_version < (1, 7):
# NOTE(danms): Before 1.7, we couldn't handle unicode in
# string fields, so squash it here
for field in [x for x in unicode_attributes if x in primitive
and primitive[x] is not None]:
primitive[field] = primitive[field].encode('ascii', 'replace')
if target_version < (1, 6):
# NOTE(danms): Before 1.6 there was no pci_devices list
if 'pci_devices' in primitive:
del primitive['pci_devices']
def obj_make_compatible(self, primitive, target_version):
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 3) and "compute_node" in primitive:
self.compute_node.obj_make_compatible(primitive["compute_node"]["nova_object.data"], "1.4")
primitive["compute_node"]["nova_object.version"] = "1.4"
elif target_version < (1, 5) and "compute_node" in primitive:
self.compute_node.obj_make_compatible(primitive["compute_node"]["nova_object.data"], "1.5")
primitive["compute_node"]["nova_object.version"] = "1.5"
def obj_make_compatible(self, primitive, target_version):
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 5) and 'numa_topology' in primitive:
del primitive['numa_topology']
if target_version < (1, 4) and 'host_ip' in primitive:
del primitive['host_ip']
if target_version < (1, 3) and 'stats' in primitive:
# pre 1.3 version does not have a stats field
del primitive['stats']
def obj_make_compatible(self, primitive, target_version):
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 2) and 'instance' in primitive:
self.instance.obj_make_compatible(
primitive['instance']['nova_object.data'], '1.13')
primitive['instance']['nova_object.version'] = '1.13'
elif target_version < (1, 3) and 'instance' in primitive:
self.instance.obj_make_compatible(
primitive['instance']['nova_object.data'], '1.14')
primitive['instance']['nova_object.version'] = '1.14'
def obj_make_compatible(self, primitive, target_version):
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 2) and 'instance' in primitive:
self.instance.obj_make_compatible(
primitive['instance']['nova_object.data'], '1.13')
primitive['instance']['nova_object.version'] = '1.13'
elif target_version < (1, 3) and 'instance' in primitive:
self.instance.obj_make_compatible(
primitive['instance']['nova_object.data'], '1.14')
primitive['instance']['nova_object.version'] = '1.14'
def obj_make_compatible(self, primitive, target_version):
_target_version = utils.convert_version_to_tuple(target_version)
if _target_version < (1, 10):
target_compute_version = self.obj_calculate_child_version(
target_version, 'compute_node')
# service.compute_node was not lazy-loaded, we need to provide it
# when called
self._do_compute_node(self._context, primitive,
target_compute_version)
super(Service, self).obj_make_compatible(primitive, target_version)
def obj_make_compatible(self, primitive, target_version):
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 3) and 'numa_node' in primitive:
if primitive['numa_node'] is not None:
extra_info = primitive.get('extra_info', {})
extra_info['numa_node'] = str(primitive['numa_node'])
primitive['extra_info'] = extra_info
del primitive['numa_node']
if target_version < (1, 2) and 'request_id' in primitive:
del primitive['request_id']
def obj_make_compatible(self, primitive, target_version):
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 3) and 'numa_node' in primitive:
if primitive['numa_node'] is not None:
extra_info = primitive.get('extra_info', {})
extra_info['numa_node'] = str(primitive['numa_node'])
primitive['extra_info'] = extra_info
del primitive['numa_node']
if target_version < (1, 2) and 'request_id' in primitive:
del primitive['request_id']
def obj_make_compatible(self, primitive, target_version):
_target_version = utils.convert_version_to_tuple(target_version)
if _target_version < (1, 10):
target_compute_version = self.obj_calculate_child_version(
target_version, 'compute_node')
# service.compute_node was not lazy-loaded, we need to provide it
# when called
self._do_compute_node(self._context, primitive,
target_compute_version)
super(Service, self).obj_make_compatible(primitive, target_version)
def obj_make_compatible(self, primitive, target_version):
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 3) and 'compute_node' in primitive:
self.compute_node.obj_make_compatible(
primitive['compute_node']['nova_object.data'], '1.4')
primitive['compute_node']['nova_object.version'] = '1.4'
elif target_version < (1, 5) and 'compute_node' in primitive:
self.compute_node.obj_make_compatible(
primitive['compute_node']['nova_object.data'], '1.5')
primitive['compute_node']['nova_object.version'] = '1.5'
def _maybe_migrate_flavor(self, db_inst, expected_attrs):
"""Determine the proper place and format for flavor loading.
This method loads the flavor information into the instance. If
the information is already migrated to instance_extra, then we
load that. If it is in system_metadata, we migrate it to extra.
If, however, we're loading an instance for an older client and
the flavor has already been migrated, we need to stash it back
into system metadata, which we do here.
This is transitional and can be removed when we remove
_migrate_flavor().
"""
version = utils.convert_version_to_tuple(self.VERSION)
flavor_requested = any([flavor in expected_attrs for flavor in ("flavor", "old_flavor", "new_flavor")])
flavor_implied = version < (1, 18) and "system_metadata" in expected_attrs
# NOTE(danms): This is compatibility logic. If the flavor
# attributes were requested, then we do this load/migrate
# logic. However, if the instance is old, we might need to
# do it anyway in order to satisfy our sysmeta-based contract.
if not (flavor_requested or flavor_implied):
return False
migrated_flavor = False
if flavor_implied:
# This instance is from before flavors were migrated out of
# system_metadata. Make sure that we honor that.
if db_inst["extra"]["flavor"] is not None:
self._flavor_from_db(db_inst["extra"]["flavor"])
sysmeta = self.system_metadata
flavors.save_flavor_info(sysmeta, self.flavor)
# FIXME(danms): Unfortunately NovaObject doesn't have
# a __del__ which means we have to peer behind the
# facade here to get these attributes deleted. Since
# they're stored as "_$name" we can do that here, but
# I need to follow up with a proper handler on the
# base class.
del self._flavor
if self.old_flavor:
flavors.save_flavor_info(sysmeta, self.old_flavor, "old_")
del self._old_flavor
if self.new_flavor:
flavors.save_flavor_info(sysmeta, self.new_flavor, "new_")
del self._new_flavor
self.system_metadata = sysmeta
else:
# Migrate the flavor from system_metadata to extra,
# if needed
if db_inst.get("extra", {}).get("flavor") is not None:
self._flavor_from_db(db_inst["extra"]["flavor"])
elif "instance_type_id" in self.system_metadata:
self._migrate_flavor(self)
migrated_flavor = True
return migrated_flavor
def obj_make_compatible(self, primitive, target_version):
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 2) and 'fixed_ip' in primitive:
self.fixed_ip.obj_make_compatible(primitive['fixed_ip'], '1.1')
primitive['fixed_ip']['nova_object.version'] = '1.1'
elif target_version < (1, 3) and self.obj_attr_is_set('fixed_ip'):
self.fixed_ip.obj_make_compatible(primitive['fixed_ip'], '1.2')
primitive['fixed_ip']['nova_object.version'] = '1.2'
elif target_version < (1, 4) and self.obj_attr_is_set('fixed_ip'):
self.fixed_ip.obj_make_compatible(primitive['fixed_ip'], '1.3')
primitive['fixed_ip']['nova_object.version'] = '1.3'
def obj_make_compatible(self, primitive, target_version):
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 2):
if 'mtu' in primitive:
del primitive['mtu']
if 'enable_dhcp' in primitive:
del primitive['enable_dhcp']
if 'dhcp_server' in primitive:
del primitive['dhcp_server']
if 'share_address' in primitive:
del primitive['share_address']
def obj_make_compatible(self, primitive, target_version):
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 2):
if 'mtu' in primitive:
del primitive['mtu']
if 'enable_dhcp' in primitive:
del primitive['enable_dhcp']
if 'dhcp_server' in primitive:
del primitive['dhcp_server']
if 'share_address' in primitive:
del primitive['share_address']
def obj_make_compatible(self, primitive, target_version):
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 6) and 'supported_hv_specs' in primitive:
del primitive['supported_hv_specs']
if target_version < (1, 5) and 'numa_topology' in primitive:
del primitive['numa_topology']
if target_version < (1, 4) and 'host_ip' in primitive:
del primitive['host_ip']
if target_version < (1, 3) and 'stats' in primitive:
# pre 1.3 version does not have a stats field
del primitive['stats']
def obj_make_compatible(self, primitive, target_version):
super(ComputeNode, self).obj_make_compatible(primitive, target_version)
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 7) and 'host' in primitive:
del primitive['host']
if target_version < (1, 5) and 'numa_topology' in primitive:
del primitive['numa_topology']
if target_version < (1, 4) and 'host_ip' in primitive:
del primitive['host_ip']
if target_version < (1, 3) and 'stats' in primitive:
# pre 1.3 version does not have a stats field
del primitive['stats']
def test_obj_relationships_in_order(self):
# Iterate all object classes and verify that we can run
# obj_make_compatible with every older version than current.
# This doesn't actually test the data conversions, but it at least
# makes sure the method doesn't blow up on something basic like
# expecting the wrong version format.
for obj_name in base.NovaObject._obj_classes:
obj_class = base.NovaObject._obj_classes[obj_name][0]
for field, versions in obj_class.obj_relationships.items():
last_my_version = (0, 0)
last_child_version = (0, 0)
for my_version, child_version in versions:
_my_version = utils.convert_version_to_tuple(my_version)
_ch_version = utils.convert_version_to_tuple(child_version)
self.assertTrue(
(last_my_version < _my_version and last_child_version <= _ch_version),
"Object %s relationship "
"%s->%s for field %s is out of order" % (obj_name, my_version, child_version, field),
)
last_my_version = _my_version
last_child_version = _ch_version
def obj_make_compatible(self, primitive, target_version):
super(ComputeNode, self).obj_make_compatible(primitive, target_version)
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 7) and "host" in primitive:
del primitive["host"]
if target_version < (1, 5) and "numa_topology" in primitive:
del primitive["numa_topology"]
if target_version < (1, 4) and "host_ip" in primitive:
del primitive["host_ip"]
if target_version < (1, 3) and "stats" in primitive:
# pre 1.3 version does not have a stats field
del primitive["stats"]
def obj_make_compatible(self, primitive, target_version):
_target_version = utils.convert_version_to_tuple(target_version)
if _target_version < (1, 14) and "forced_down" in primitive:
del primitive["forced_down"]
if _target_version < (1, 13) and "last_seen_up" in primitive:
del primitive["last_seen_up"]
if _target_version < (1, 10):
target_compute_version = self.obj_calculate_child_version(target_version, "compute_node")
# service.compute_node was not lazy-loaded, we need to provide it
# when called
self._do_compute_node(self._context, primitive, target_compute_version)
super(Service, self).obj_make_compatible(primitive, target_version)
def test_obj_make_compatible(self):
# Iterate all object classes and verify that we can run
# obj_make_compatible with every older version than current.
# This doesn't actually test the data conversions, but it at least
# makes sure the method doesn't blow up on something basic like
# expecting the wrong version format.
for obj_name in base.NovaObject._obj_classes:
obj_class = base.NovaObject._obj_classes[obj_name][0]
version = utils.convert_version_to_tuple(obj_class.VERSION)
for n in range(version[1]):
test_version = "%d.%d" % (version[0], n)
LOG.info("testing obj: %s version: %s" % (obj_name, test_version))
obj_class().obj_to_primitive(target_version=test_version)
def test_obj_relationships_in_order(self):
# Iterate all object classes and verify that we can run
# obj_make_compatible with every older version than current.
# This doesn't actually test the data conversions, but it at least
# makes sure the method doesn't blow up on something basic like
# expecting the wrong version format.
for obj_name in base.NovaObject._obj_classes:
obj_class = base.NovaObject._obj_classes[obj_name][0]
for field, versions in obj_class.obj_relationships.items():
last_my_version = (0, 0)
last_child_version = (0, 0)
for my_version, child_version in versions:
_my_version = utils.convert_version_to_tuple(my_version)
_ch_version = utils.convert_version_to_tuple(child_version)
self.assertTrue((last_my_version < _my_version
and last_child_version <= _ch_version),
'Object %s relationship '
'%s->%s for field %s is out of order' % (
obj_name, my_version, child_version,
field))
last_my_version = _my_version
last_child_version = _ch_version
def test_obj_make_compatible(self):
# Iterate all object classes and verify that we can run
# obj_make_compatible with every older version than current.
# This doesn't actually test the data conversions, but it at least
# makes sure the method doesn't blow up on something basic like
# expecting the wrong version format.
for obj_name in base.NovaObject._obj_classes:
obj_class = base.NovaObject._obj_classes[obj_name][0]
version = utils.convert_version_to_tuple(obj_class.VERSION)
for n in range(version[1]):
test_version = '%d.%d' % (version[0], n)
LOG.info('testing obj: %s version: %s' %
(obj_name, test_version))
obj_class().obj_to_primitive(target_version=test_version)
def obj_make_compatible(self, primitive, target_version):
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 3) and 'compute_node' in primitive:
self.compute_node.obj_make_compatible(
primitive['compute_node']['nova_object.data'], '1.4')
primitive['compute_node']['nova_object.version'] = '1.4'
elif target_version < (1, 5) and 'compute_node' in primitive:
self.compute_node.obj_make_compatible(
primitive['compute_node']['nova_object.data'], '1.5')
primitive['compute_node']['nova_object.version'] = '1.5'
elif target_version < (1, 6) and 'compute_node' in primitive:
self.compute_node.obj_make_compatible(
primitive['compute_node']['nova_object.data'], '1.6')
primitive['compute_node']['nova_object.version'] = '1.6'
def obj_make_compatible(self, primitive, target_version):
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 5) and 'floating_ips' in primitive:
del primitive['floating_ips']
if target_version < (1, 4) and 'default_route' in primitive:
del primitive['default_route']
if target_version < (1, 3) and 'instance' in primitive:
self.instance.obj_make_compatible(
primitive['instance']['nova_object.data'], '1.14')
primitive['instance']['nova_object.version'] = '1.14'
if target_version < (1, 2) and 'instance' in primitive:
self.instance.obj_make_compatible(
primitive['instance']['nova_object.data'], '1.13')
primitive['instance']['nova_object.version'] = '1.13'
def obj_make_compatible(self, primitive, target_version):
target_version = utils.convert_version_to_tuple(target_version)
unicode_attributes = [
"user_id",
"project_id",
"image_ref",
"kernel_id",
"ramdisk_id",
"hostname",
"key_name",
"key_data",
"host",
"node",
"user_data",
"availability_zone",
"display_name",
"display_description",
"launched_on",
"locked_by",
"os_type",
"architecture",
"vm_mode",
"root_device_name",
"default_ephemeral_device",
"default_swap_device",
"config_drive",
"cell_name",
]
if target_version < (1, 14) and "numa_topology" in primitive:
del primitive["numa_topology"]
if target_version < (1, 10) and "info_cache" in primitive:
# NOTE(danms): Instance <= 1.9 (havana) had info_cache 1.4
self.info_cache.obj_make_compatible(primitive["info_cache"], "1.4")
primitive["info_cache"]["nova_object.version"] = "1.4"
if target_version < (1, 7):
# NOTE(danms): Before 1.7, we couldn't handle unicode in
# string fields, so squash it here
for field in [x for x in unicode_attributes if x in primitive and primitive[x] is not None]:
primitive[field] = primitive[field].encode("ascii", "replace")
if target_version < (1, 15) and "pci_devices" in primitive:
# NOTE(baoli): Instance <= 1.14 (icehouse) had PciDeviceList 1.0
# NOTE(vish): pci_devices is a list object so we must pull the
# underlying primitive out of the nova_object_data.
self.pci_devices.obj_make_compatible(primitive["pci_devices"]["nova_object.data"], "1.0")
primitive["pci_devices"]["nova_object.version"] = "1.0"
if target_version < (1, 6):
# NOTE(danms): Before 1.6 there was no pci_devices list
if "pci_devices" in primitive:
del primitive["pci_devices"]
def obj_make_compatible_from_manifest(self, primitive, target_version,
version_manifest):
super(Service, self).obj_make_compatible_from_manifest(
primitive, target_version, version_manifest)
_target_version = utils.convert_version_to_tuple(target_version)
if _target_version < (1, 16) and 'version' in primitive:
del primitive['version']
if _target_version < (1, 14) and 'forced_down' in primitive:
del primitive['forced_down']
if _target_version < (1, 13) and 'last_seen_up' in primitive:
del primitive['last_seen_up']
if _target_version < (1, 10):
# service.compute_node was not lazy-loaded, we need to provide it
# when called
self._do_compute_node(self._context, primitive,
version_manifest)
def _get_product_version_and_brand(self):
"""Return a tuple of (major, minor, rev) for the host version and
a string of the product brand.
"""
software_version = self._get_software_version()
product_version_str = software_version.get("product_version")
# Product version is only set in some cases (e.g. XCP, XenServer) and
# not in others (e.g. xenserver-core, XAPI-XCP).
# In these cases, the platform version is the best number to use.
if product_version_str is None:
product_version_str = software_version.get("platform_version", "0.0.0")
product_brand = software_version.get("product_brand")
product_version = utils.convert_version_to_tuple(product_version_str)
return product_version, product_brand
def obj_make_compatible(self, primitive, target_version):
_target_version = utils.convert_version_to_tuple(target_version)
if _target_version < (1, 16) and 'version' in primitive:
del primitive['version']
if _target_version < (1, 14) and 'forced_down' in primitive:
del primitive['forced_down']
if _target_version < (1, 13) and 'last_seen_up' in primitive:
del primitive['last_seen_up']
if _target_version < (1, 10):
target_compute_version = self.obj_calculate_child_version(
target_version, 'compute_node')
# service.compute_node was not lazy-loaded, we need to provide it
# when called
self._do_compute_node(self._context, primitive,
target_compute_version)
super(Service, self).obj_make_compatible(primitive, target_version)
def _get_product_version_and_brand(self):
"""Return a tuple of (major, minor, rev) for the host version and
a string of the product brand.
"""
software_version = self._get_software_version()
product_version_str = software_version.get('product_version')
# Product version is only set in some cases (e.g. XCP, XenServer) and
# not in others (e.g. xenserver-core, XAPI-XCP).
# In these cases, the platform version is the best number to use.
if product_version_str is None:
product_version_str = software_version.get('platform_version',
'0.0.0')
product_brand = software_version.get('product_brand')
product_version = utils.convert_version_to_tuple(product_version_str)
return product_version, product_brand
def obj_make_compatible(self, primitive, target_version):
super(Instance, self).obj_make_compatible(primitive, target_version)
target_version = utils.convert_version_to_tuple(target_version)
unicode_attributes = [
'user_id', 'project_id', 'image_ref', 'kernel_id', 'ramdisk_id',
'hostname', 'key_name', 'key_data', 'host', 'node', 'user_data',
'availability_zone', 'display_name', 'display_description',
'launched_on', 'locked_by', 'os_type', 'architecture', 'vm_mode',
'root_device_name', 'default_ephemeral_device',
'default_swap_device', 'config_drive', 'cell_name'
]
if target_version < (1, 7):
# NOTE(danms): Before 1.7, we couldn't handle unicode in
# string fields, so squash it here
for field in [
x for x in unicode_attributes
if x in primitive and primitive[x] is not None
]:
primitive[field] = primitive[field].encode('ascii', 'replace')
def obj_make_compatible(self, primitive, target_version):
super(Instance, self).obj_make_compatible(primitive, target_version)
target_version = utils.convert_version_to_tuple(target_version)
unicode_attributes = ['user_id', 'project_id', 'image_ref',
'kernel_id', 'ramdisk_id', 'hostname',
'key_name', 'key_data', 'host', 'node',
'user_data', 'availability_zone',
'display_name', 'display_description',
'launched_on', 'locked_by', 'os_type',
'architecture', 'vm_mode', 'root_device_name',
'default_ephemeral_device',
'default_swap_device', 'config_drive',
'cell_name']
if target_version < (1, 7):
# NOTE(danms): Before 1.7, we couldn't handle unicode in
# string fields, so squash it here
for field in [x for x in unicode_attributes if x in primitive
and primitive[x] is not None]:
primitive[field] = primitive[field].encode('ascii', 'replace')
def obj_make_compatible(self, primitive, target_version):
super(Instance, self).obj_make_compatible(primitive, target_version)
target_version = utils.convert_version_to_tuple(target_version)
unicode_attributes = [
"user_id",
"project_id",
"image_ref",
"kernel_id",
"ramdisk_id",
"hostname",
"key_name",
"key_data",
"host",
"node",
"user_data",
"availability_zone",
"display_name",
"display_description",
"launched_on",
"locked_by",
"os_type",
"architecture",
"vm_mode",
"root_device_name",
"default_ephemeral_device",
"default_swap_device",
"config_drive",
"cell_name",
]
if target_version < (1, 7):
# NOTE(danms): Before 1.7, we couldn't handle unicode in
# string fields, so squash it here
for field in [x for x in unicode_attributes if x in primitive and primitive[x] is not None]:
primitive[field] = primitive[field].encode("ascii", "replace")
if target_version < (1, 18):
if "system_metadata" in primitive:
for ftype in ("", "old_", "new_"):
attrname = "%sflavor" % ftype
primitive.pop(attrname, None)
if self[attrname] is not None:
flavors.save_flavor_info(primitive["system_metadata"], getattr(self, attrname), ftype)
def obj_make_compatible(self, primitive, target_version):
super(ImageMetaProps,
self).obj_make_compatible(primitive, target_version)
target_version = utils.convert_version_to_tuple(target_version)
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))
def obj_make_compatible(self, primitive, target_version):
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 1) and 'numa_node' in primitive:
del primitive['numa_node']
def obj_make_compatible(self, primitive, target_version):
super(FixedIP, self).obj_make_compatible(primitive, target_version)
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 4) and 'default_route' in primitive:
del primitive['default_route']
def obj_make_compatible(self, primitive, target_version):
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 2) and 'request_id' in primitive:
del primitive['request_id']
def test_convert_version_to_tuple(self):
self.assertEqual(utils.convert_version_to_tuple('6.7.0'), (6, 7, 0))
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'] = {}
def obj_make_compatible(self, primitive, target_version):
super(MonitorMetric, self).obj_make_compatible(primitive,
target_version)
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 1) and 'numa_nodes_values' in primitive:
del primitive['numa_membw_values']
def obj_make_compatible(self, primitive, target_version):
super(KeyPair, self).obj_make_compatible(primitive, target_version)
target_version = utils.convert_version_to_tuple(target_version)
if target_version < (1, 2) and 'type' in primitive:
del primitive['type']
