Buckets:
| import functools | |
| import re | |
| from oslo_log import log as logging | |
| from oslo_serialization import jsonutils | |
| from oslo_utils import versionutils | |
| from oslo_versionedobjects import exception as ovoo_exc | |
| import six | |
| from sqlalchemy.sql import null | |
| from nova.db.sqlalchemy import api as db | |
| from nova.db.sqlalchemy import api_models | |
| from nova import exception | |
| from nova.i18n import _LE | |
| from nova import objects | |
| from nova.objects import base | |
| from nova.objects import fields | |
| LOG = logging.getLogger(__name__) | |
| @base.NovaObjectRegistry.register | |
| class BuildRequest(base.NovaObject, ): | |
| VERSION = '1.3' | |
| fields = {'id': fields.IntegerField(), 'instance_uuid': fields.UUIDField(), 'project_id': fields.StringField(), 'instance': fields.ObjectField('Instance'), 'block_device_mappings': fields.ObjectField('BlockDeviceMappingList'), 'created_at': fields.DateTimeField(nullable=True), 'updated_at': fields.DateTimeField(nullable=True), 'tags': fields.ObjectField('TagList')} | |
| def obj_make_compatible(self, primitive, target_version): | |
| super(BuildRequest, self).obj_make_compatible(primitive, target_version) | |
| target_version = versionutils.convert_version_to_tuple(target_version) | |
| if ((target_version < (1, 1)) and ('block_device_mappings' in primitive)): | |
| del primitive['block_device_mappings'] | |
| elif ((target_version < (1, 3)) and ('tags' in primitive)): | |
| del primitive['tags'] | |
| def _load_instance(self, db_instance): | |
| try: | |
| self.instance = objects.Instance.obj_from_primitive(jsonutils.loads(db_instance)) | |
| except TypeError: | |
| LOG.debug('Failed to load instance from BuildRequest with uuid %s because it is None', self.instance_uuid) | |
| raise exception.BuildRequestNotFound(uuid=self.instance_uuid) | |
| except ovoo_exc.IncompatibleObjectVersion as exc: | |
| LOG.debug('Could not deserialize instance store in BuildRequest with uuid %(instance_uuid)s. Found version %(version)s which is not supported here.', dict(instance_uuid=self.instance_uuid, version=exc.objver)) | |
| LOG.exception(_LE('Could not deserialize instance in BuildRequest')) | |
| raise exception.BuildRequestNotFound(uuid=self.instance_uuid) | |
| self.instance.obj_set_defaults('deleted') | |
| self.instance.disable_terminate = False | |
| self.instance.terminated_at = None | |
| self.instance.host = None | |
| self.instance.node = None | |
| self.instance.launched_at = None | |
| self.instance.launched_on = None | |
| self.instance.cell_name = None | |
| if (not self.instance.obj_attr_is_set('locked_by')): | |
| self.instance.locked_by = None | |
| self.instance.created_at = self.created_at | |
| self.instance.updated_at = self.updated_at | |
| self.instance.tags = self.tags | |
| def _load_block_device_mappings(self, db_bdms): | |
| if (db_bdms is None): | |
| LOG.debug('Failed to load block_device_mappings from BuildRequest for instance %s because it is None', self.instance_uuid) | |
| self.block_device_mappings = objects.BlockDeviceMappingList() | |
| return | |
| self.block_device_mappings = objects.BlockDeviceMappingList.obj_from_primitive(jsonutils.loads(db_bdms)) | |
| def _load_tags(self, db_tags): | |
| if (db_tags is None): | |
| LOG.debug('Failed to load tags from BuildRequest for instance %s because it is None', self.instance_uuid) | |
| self.tags = objects.TagList() | |
| return | |
| self.tags = objects.TagList.obj_from_primitive(jsonutils.loads(db_tags)) | |
| @staticmethod | |
| def _from_db_object(context, req, db_req): | |
| req.instance_uuid = db_req['instance_uuid'] | |
| for key in req.fields: | |
| if (key == 'instance'): | |
| continue | |
| elif isinstance(req.fields[key], fields.ObjectField): | |
| try: | |
| getattr(req, ('_load_%s' % key))(db_req[key]) | |
| except AttributeError: | |
| LOG.exception(_LE('No load handler for %s'), key) | |
| else: | |
| setattr(req, key, db_req[key]) | |
| req._load_instance(db_req['instance']) | |
| req.obj_reset_changes(recursive=True) | |
| req._context = context | |
| return req | |
| @staticmethod | |
| @db.api_context_manager.reader | |
| def _get_by_instance_uuid_from_db(context, instance_uuid): | |
| db_req = context.session.query(api_models.BuildRequest).filter_by(instance_uuid=instance_uuid).first() | |
| if (not db_req): | |
| raise exception.BuildRequestNotFound(uuid=instance_uuid) | |
| return db_req | |
| @base.remotable_classmethod | |
| def get_by_instance_uuid(cls, context, instance_uuid): | |
| db_req = cls._get_by_instance_uuid_from_db(context, instance_uuid) | |
| return cls._from_db_object(context, cls(), db_req) | |
| @staticmethod | |
| @db.api_context_manager.writer | |
| def _create_in_db(context, updates): | |
| db_req = api_models.BuildRequest() | |
| db_req.update(updates) | |
| db_req.save(context.session) | |
| return db_req | |
| def _get_update_primitives(self): | |
| updates = self.obj_get_changes() | |
| for (key, value) in updates.items(): | |
| if isinstance(self.fields[key], fields.ObjectField): | |
| updates[key] = jsonutils.dumps(value.obj_to_primitive()) | |
| return updates | |
| @base.remotable | |
| def create(self): | |
| if self.obj_attr_is_set('id'): | |
| raise exception.ObjectActionError(action='create', reason='already created') | |
| if (not self.obj_attr_is_set('instance_uuid')): | |
| raise exception.ObjectActionError(action='create', reason='instance_uuid must be set') | |
| updates = self._get_update_primitives() | |
| db_req = self._create_in_db(self._context, updates) | |
| self._from_db_object(self._context, self, db_req) | |
| @staticmethod | |
| @db.api_context_manager.writer | |
| def _destroy_in_db(context, instance_uuid): | |
| result = context.session.query(api_models.BuildRequest).filter_by(instance_uuid=instance_uuid).delete() | |
| if (not result): | |
| raise exception.BuildRequestNotFound(uuid=instance_uuid) | |
| @base.remotable | |
| def destroy(self): | |
| self._destroy_in_db(self._context, self.instance_uuid) | |
| @db.api_context_manager.writer | |
| def _save_in_db(self, context, req_id, updates): | |
| db_req = context.session.query(api_models.BuildRequest).filter_by(id=req_id).first() | |
| if (not db_req): | |
| raise exception.BuildRequestNotFound(uuid=self.instance_uuid) | |
| db_req.update(updates) | |
| context.session.add(db_req) | |
| return db_req | |
| @base.remotable | |
| def save(self): | |
| updates = self._get_update_primitives() | |
| db_req = self._save_in_db(self._context, self.id, updates) | |
| self._from_db_object(self._context, self, db_req) | |
| def get_new_instance(self, context): | |
| instance = objects.Instance(context) | |
| for field in self.instance.obj_fields: | |
| if (field == 'tags'): | |
| continue | |
| if self.instance.obj_attr_is_set(field): | |
| setattr(instance, field, getattr(self.instance, field)) | |
| return instance | |
| @base.NovaObjectRegistry.register | |
| class BuildRequestList(base.ObjectListBase, base.NovaObject, ): | |
| VERSION = '1.0' | |
| fields = {'objects': fields.ListOfObjectsField('BuildRequest')} | |
| @staticmethod | |
| @db.api_context_manager.reader | |
| def _get_all_from_db(context): | |
| query = context.session.query(api_models.BuildRequest) | |
| if (not context.is_admin): | |
| query = query.filter_by(project_id=context.project_id) | |
| db_reqs = query.all() | |
| return db_reqs | |
| @base.remotable_classmethod | |
| def get_all(cls, context): | |
| db_build_reqs = cls._get_all_from_db(context) | |
| return base.obj_make_list(context, cls(context), objects.BuildRequest, db_build_reqs) | |
| @staticmethod | |
| def _pass_exact_filters(instance, filters): | |
| for (filter_key, filter_val) in filters.items(): | |
| if (filter_key in ('metadata', 'system_metadata')): | |
| if isinstance(filter_val, list): | |
| for item in filter_val: | |
| for (k, v) in item.items(): | |
| if ((k not in instance.metadata) or (v != instance.metadata[k])): | |
| return False | |
| else: | |
| for (k, v) in filter_val.items(): | |
| if ((k not in instance.metadata) or (v != instance.metadata[k])): | |
| return False | |
| elif (filter_key in ('tags', 'tags-any', 'not-tags', 'not-tags-any')): | |
| tags = ([tag.tag for tag in instance.tags] if instance.tags else []) | |
| if (filter_key == 'tags'): | |
| for item in filter_val: | |
| if (item not in tags): | |
| return False | |
| elif (filter_key == 'tags-any'): | |
| found = [] | |
| for item in filter_val: | |
| if (item in tags): | |
| found.append(item) | |
| if (not found): | |
| return False | |
| elif (filter_key == 'not-tags'): | |
| found = [] | |
| for item in filter_val: | |
| if (item in tags): | |
| found.append(item) | |
| if (len(found) == len(filter_val)): | |
| return False | |
| elif (filter_key == 'not-tags-any'): | |
| for item in filter_val: | |
| if (item in tags): | |
| return False | |
| elif isinstance(filter_val, (list, tuple, set, frozenset)): | |
| if (not filter_val): | |
| return None | |
| if (instance.get(filter_key, None) not in filter_val): | |
| return False | |
| elif (instance.get(filter_key, None) != filter_val): | |
| return False | |
| return True | |
| @staticmethod | |
| def _pass_regex_filters(instance, filters): | |
| for (filter_name, filter_val) in filters.items(): | |
| try: | |
| instance_attr = getattr(instance, filter_name) | |
| except AttributeError: | |
| continue | |
| if (not isinstance(filter_val, six.string_types)): | |
| filter_val = str(filter_val) | |
| filter_re = re.compile(filter_val) | |
| if (instance_attr and (not filter_re.search(str(instance_attr)))): | |
| return False | |
| return True | |
| @staticmethod | |
| def _sort_build_requests(build_req_list, sort_keys, sort_dirs): | |
| sort_keys.reverse() | |
| sort_dirs.reverse() | |
| def sort_attr(sort_key, build_req): | |
| if (sort_key == 'id'): | |
| return build_req.id | |
| return getattr(build_req.instance, sort_key) | |
| for (sort_key, sort_dir) in zip(sort_keys, sort_dirs): | |
| reverse = (False if sort_dir.lower().startswith('asc') else True) | |
| build_req_list.sort(key=functools.partial(sort_attr, sort_key), reverse=reverse) | |
| return build_req_list | |
| @base.remotable_classmethod | |
| def get_by_filters(cls, context, filters, limit=None, marker=None, sort_keys=None, sort_dirs=None): | |
| if (limit == 0): | |
| return cls(context, objects=[]) | |
| if filters.get('deleted', False): | |
| return cls(context, objects=[]) | |
| if filters.get('cleaned', False): | |
| return cls(context, objects=[]) | |
| build_requests = cls.get_all(context) | |
| (sort_keys, sort_dirs) = db.process_sort_params(sort_keys, sort_dirs, default_dir='desc') | |
| exact_match_filter_names = ['project_id', 'user_id', 'image_ref', 'vm_state', 'instance_type_id', 'uuid', 'metadata', 'host', 'task_state', 'system_metadata', 'tags', 'tags-any', 'not-tags', 'not-tags-any'] | |
| exact_filters = {} | |
| regex_filters = {} | |
| for (key, value) in filters.items(): | |
| if (key in exact_match_filter_names): | |
| exact_filters[key] = value | |
| else: | |
| regex_filters[key] = value | |
| filtered_build_reqs = [] | |
| for build_req in build_requests: | |
| instance = build_req.instance | |
| filter_result = cls._pass_exact_filters(instance, exact_filters) | |
| if (filter_result is None): | |
| return cls(context, objects=[]) | |
| if (filter_result is False): | |
| continue | |
| if (not cls._pass_regex_filters(instance, regex_filters)): | |
| continue | |
| filtered_build_reqs.append(build_req) | |
| if (((len(filtered_build_reqs) < 2) or (not sort_keys)) and (not marker)): | |
| return cls(context, objects=filtered_build_reqs) | |
| sorted_build_reqs = cls._sort_build_requests(filtered_build_reqs, sort_keys, sort_dirs) | |
| marker_index = 0 | |
| if marker: | |
| for (i, build_req) in enumerate(sorted_build_reqs): | |
| if (build_req.instance.uuid == marker): | |
| marker_index = i | |
| break | |
| else: | |
| raise exception.MarkerNotFound(marker=marker) | |
| len_build_reqs = len(sorted_build_reqs) | |
| limit_index = len_build_reqs | |
| if limit: | |
| limit_index = (marker_index + limit) | |
| if (limit_index > len_build_reqs): | |
| limit_index = len_build_reqs | |
| return cls(context, objects=sorted_build_reqs[marker_index:limit_index]) | |
| @db.api_context_manager.reader | |
| def _get_build_requests_with_no_instance_uuid(context, limit): | |
| 'Returns up to $limit build_requests where instance_uuid is null' | |
| return context.session.query(api_models.BuildRequest).filter_by(instance_uuid=null()).limit(limit).all() | |
| @db.api_context_manager.writer | |
| def _destroy_in_db(context, id): | |
| return context.session.query(api_models.BuildRequest).filter_by(id=id).delete() | |
| def delete_build_requests_with_no_instance_uuid(context, count): | |
| "Online data migration which cleans up failed build requests from Mitaka\n\n build_requests were initially a mirror of instances and had similar fields\n to satisfy listing/showing instances while they were building. In Mitaka\n if an instance failed to build we'd delete the instance but didn't delete\n the associated BuildRequest. In the Newton release we changed the schema\n on the build_requests table to just store a serialized Instance object and\n added an instance_uuid field which is expected to not be None as seen how\n it's used in _from_db_object. However, failed build requests created before\n that schema migration won't have the instance_uuid set and fail to load\n as an object when calling BuildRequestList.get_all(). So we need to perform\n a cleanup routine here where we search for build requests which do not have\n the instance_uuid field set and delete them.\n\n :param context: The auth context used to query the database.\n :type context: nova.context.RequestContext\n :param count: The max number of build requests to delete.\n :type count: int\n :returns: 2-item tuple of\n (number of orphaned build requests read from DB, number deleted)\n " | |
| orphaned_build_requests = _get_build_requests_with_no_instance_uuid(context, count) | |
| done = 0 | |
| for orphan_buildreq in orphaned_build_requests: | |
| result = _destroy_in_db(context, orphan_buildreq.id) | |
| if result: | |
| done += 1 | |
| return (len(orphaned_build_requests), done) | |
Xet Storage Details
- Size:
- 15.5 kB
- Xet hash:
- 4dc0cc621f193613b60b0482afd52f4f61d3d61c36f684b1a2b042f6141590eb
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.