Cesar77RR's picture
download
raw
15.5 kB
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.