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 _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) 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, 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 '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, 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']