Cesar77RR's picture
download
raw
11.9 kB
from oslo_log import log as logging
from oslo_utils import versionutils
from nova import block_device
from nova.cells import opts as cells_opts
from nova.cells import rpcapi as cells_rpcapi
from nova import db
from nova import exception
from nova.i18n import _, _LW
from nova import objects
from nova.objects import base
from nova.objects import fields
LOG = logging.getLogger(__name__)
_BLOCK_DEVICE_OPTIONAL_JOINED_FIELD = ['instance']
BLOCK_DEVICE_OPTIONAL_ATTRS = _BLOCK_DEVICE_OPTIONAL_JOINED_FIELD
def _expected_cols(expected_attrs):
return [attr for attr in expected_attrs if (attr in _BLOCK_DEVICE_OPTIONAL_JOINED_FIELD)]
@base.NovaObjectRegistry.register
class BlockDeviceMapping(base.NovaPersistentObject, base.NovaObject, base.NovaObjectDictCompat, ):
VERSION = '1.18'
fields = {'id': fields.IntegerField(), 'instance_uuid': fields.UUIDField(), 'instance': fields.ObjectField('Instance', nullable=True), 'source_type': fields.BlockDeviceSourceTypeField(nullable=True), 'destination_type': fields.BlockDeviceDestinationTypeField(nullable=True), 'guest_format': fields.StringField(nullable=True), 'device_type': fields.BlockDeviceTypeField(nullable=True), 'disk_bus': fields.StringField(nullable=True), 'boot_index': fields.IntegerField(nullable=True), 'device_name': fields.StringField(nullable=True), 'delete_on_termination': fields.BooleanField(default=False), 'snapshot_id': fields.StringField(nullable=True), 'volume_id': fields.StringField(nullable=True), 'volume_size': fields.IntegerField(nullable=True), 'image_id': fields.StringField(nullable=True), 'no_device': fields.BooleanField(default=False), 'connection_info': fields.SensitiveStringField(nullable=True), 'tag': fields.StringField(nullable=True), 'attachment_id': fields.UUIDField(nullable=True)}
def obj_make_compatible(self, primitive, target_version):
target_version = versionutils.convert_version_to_tuple(target_version)
if ((target_version < (1, 18)) and ('attachment_id' in primitive)):
del primitive['attachment_id']
if ((target_version < (1, 17)) and ('tag' in primitive)):
del primitive['tag']
@staticmethod
def _from_db_object(context, block_device_obj, db_block_device, expected_attrs=None):
if (expected_attrs is None):
expected_attrs = []
for key in block_device_obj.fields:
if (key in BLOCK_DEVICE_OPTIONAL_ATTRS):
continue
block_device_obj[key] = db_block_device[key]
if ('instance' in expected_attrs):
my_inst = objects.Instance(context)
my_inst._from_db_object(context, my_inst, db_block_device['instance'])
block_device_obj.instance = my_inst
block_device_obj._context = context
block_device_obj.obj_reset_changes()
return block_device_obj
def _create(self, context, update_or_create=False):
'Create the block device record in the database.\n\n In case the id field is set on the object, and if the instance is set\n raise an ObjectActionError. Resets all the changes on the object.\n\n Returns None\n\n :param context: security context used for database calls\n :param update_or_create: consider existing block devices for the\n instance based on the device name and swap, and only update\n the ones that match. Normally only used when creating the\n instance for the first time.\n '
cell_type = cells_opts.get_cell_type()
if (cell_type == 'api'):
raise exception.ObjectActionError(action='create', reason='BlockDeviceMapping cannot be created in the API cell.')
if self.obj_attr_is_set('id'):
raise exception.ObjectActionError(action='create', reason='already created')
updates = self.obj_get_changes()
if ('instance' in updates):
raise exception.ObjectActionError(action='create', reason='instance assigned')
cells_create = (update_or_create or None)
if update_or_create:
db_bdm = db.block_device_mapping_update_or_create(context, updates, legacy=False)
else:
db_bdm = db.block_device_mapping_create(context, updates, legacy=False)
self._from_db_object(context, self, db_bdm)
if ((cell_type == 'compute') and (db_bdm.get('device_name') is not None)):
cells_api = cells_rpcapi.CellsAPI()
cells_api.bdm_update_or_create_at_top(context, self, create=cells_create)
@base.remotable
def create(self):
self._create(self._context)
@base.remotable
def update_or_create(self):
self._create(self._context, update_or_create=True)
@base.remotable
def destroy(self):
if (not self.obj_attr_is_set('id')):
raise exception.ObjectActionError(action='destroy', reason='already destroyed')
db.block_device_mapping_destroy(self._context, self.id)
delattr(self, base.get_attrname('id'))
cell_type = cells_opts.get_cell_type()
if (cell_type == 'compute'):
cells_api = cells_rpcapi.CellsAPI()
cells_api.bdm_destroy_at_top(self._context, self.instance_uuid, device_name=self.device_name, volume_id=self.volume_id)
@base.remotable
def save(self):
updates = self.obj_get_changes()
if ('instance' in updates):
raise exception.ObjectActionError(action='save', reason='instance changed')
updates.pop('id', None)
updated = db.block_device_mapping_update(self._context, self.id, updates, legacy=False)
if (not updated):
raise exception.BDMNotFound(id=self.id)
self._from_db_object(self._context, self, updated)
cell_type = cells_opts.get_cell_type()
if (cell_type == 'compute'):
create = False
if ('device_name' in updates):
create = None
cells_api = cells_rpcapi.CellsAPI()
cells_api.bdm_update_or_create_at_top(self._context, self, create=create)
@base.remotable_classmethod
def get_by_volume_id(cls, context, volume_id, instance_uuid=None, expected_attrs=None):
if (expected_attrs is None):
expected_attrs = []
db_bdms = db.block_device_mapping_get_all_by_volume_id(context, volume_id, _expected_cols(expected_attrs))
if (not db_bdms):
raise exception.VolumeBDMNotFound(volume_id=volume_id)
if (len(db_bdms) > 1):
LOG.warning(_LW('Legacy get_by_volume_id() call found multiple BDMs for volume %(volume)s'), {'volume': volume_id})
db_bdm = db_bdms[0]
if (instance_uuid and (instance_uuid != db_bdm['instance_uuid'])):
raise exception.InvalidVolume(reason=_('Volume does not belong to the requested instance.'))
return cls._from_db_object(context, cls(), db_bdm, expected_attrs=expected_attrs)
@base.remotable_classmethod
def get_by_volume_and_instance(cls, context, volume_id, instance_uuid, expected_attrs=None):
if (expected_attrs is None):
expected_attrs = []
db_bdm = db.block_device_mapping_get_by_instance_and_volume_id(context, volume_id, instance_uuid, _expected_cols(expected_attrs))
if (not db_bdm):
raise exception.VolumeBDMNotFound(volume_id=volume_id)
return cls._from_db_object(context, cls(), db_bdm, expected_attrs=expected_attrs)
@base.remotable_classmethod
def get_by_volume(cls, context, volume_id, expected_attrs=None):
if (expected_attrs is None):
expected_attrs = []
db_bdms = db.block_device_mapping_get_all_by_volume_id(context, volume_id, _expected_cols(expected_attrs))
if (not db_bdms):
raise exception.VolumeBDMNotFound(volume_id=volume_id)
if (len(db_bdms) > 1):
raise exception.VolumeBDMIsMultiAttach(volume_id=volume_id)
return cls._from_db_object(context, cls(), db_bdms[0], expected_attrs=expected_attrs)
@property
def is_root(self):
return (self.boot_index == 0)
@property
def is_volume(self):
return (self.destination_type == fields.BlockDeviceDestinationType.VOLUME)
@property
def is_image(self):
return (self.source_type == fields.BlockDeviceSourceType.IMAGE)
def get_image_mapping(self):
return block_device.BlockDeviceDict(self).get_image_mapping()
def obj_load_attr(self, attrname):
if (attrname not in BLOCK_DEVICE_OPTIONAL_ATTRS):
raise exception.ObjectActionError(action='obj_load_attr', reason=('attribute %s not lazy-loadable' % attrname))
if (not self._context):
raise exception.OrphanedObjectError(method='obj_load_attr', objtype=self.obj_name())
LOG.debug("Lazy-loading '%(attr)s' on %(name)s using uuid %(uuid)s", {'attr': attrname, 'name': self.obj_name(), 'uuid': self.instance_uuid})
self.instance = objects.Instance.get_by_uuid(self._context, self.instance_uuid)
self.obj_reset_changes(fields=['instance'])
@base.NovaObjectRegistry.register
class BlockDeviceMappingList(base.ObjectListBase, base.NovaObject, ):
VERSION = '1.17'
fields = {'objects': fields.ListOfObjectsField('BlockDeviceMapping')}
@property
def instance_uuids(self):
return set((bdm.instance_uuid for bdm in self if bdm.obj_attr_is_set('instance_uuid')))
@classmethod
def bdms_by_instance_uuid(cls, context, instance_uuids):
bdms = cls.get_by_instance_uuids(context, instance_uuids)
return base.obj_make_dict_of_lists(context, cls, bdms, 'instance_uuid')
@staticmethod
@db.select_db_reader_mode
def _db_block_device_mapping_get_all_by_instance_uuids(context, instance_uuids, use_slave=False):
return db.block_device_mapping_get_all_by_instance_uuids(context, instance_uuids)
@base.remotable_classmethod
def get_by_instance_uuids(cls, context, instance_uuids, use_slave=False):
db_bdms = cls._db_block_device_mapping_get_all_by_instance_uuids(context, instance_uuids, use_slave=use_slave)
return base.obj_make_list(context, cls(), objects.BlockDeviceMapping, (db_bdms or []))
@staticmethod
@db.select_db_reader_mode
def _db_block_device_mapping_get_all_by_instance(context, instance_uuid, use_slave=False):
return db.block_device_mapping_get_all_by_instance(context, instance_uuid)
@base.remotable_classmethod
def get_by_instance_uuid(cls, context, instance_uuid, use_slave=False):
db_bdms = cls._db_block_device_mapping_get_all_by_instance(context, instance_uuid, use_slave=use_slave)
return base.obj_make_list(context, cls(), objects.BlockDeviceMapping, (db_bdms or []))
def root_bdm(self):
'It only makes sense to call this method when the\n BlockDeviceMappingList contains BlockDeviceMappings from\n exactly one instance rather than BlockDeviceMappings from\n multiple instances.\n\n For example, you should not call this method from a\n BlockDeviceMappingList created by get_by_instance_uuids(),\n but you may call this method from a BlockDeviceMappingList\n created by get_by_instance_uuid().\n '
if (len(self.instance_uuids) > 1):
raise exception.UndefinedRootBDM()
try:
return next((bdm_obj for bdm_obj in self if bdm_obj.is_root))
except StopIteration:
return
def block_device_make_list(context, db_list, **extra_args):
return base.obj_make_list(context, objects.BlockDeviceMappingList(context), objects.BlockDeviceMapping, db_list, **extra_args)
def block_device_make_list_from_dicts(context, bdm_dicts_list):
bdm_objects = [objects.BlockDeviceMapping(context=context, **bdm) for bdm in bdm_dicts_list]
return BlockDeviceMappingList(objects=bdm_objects)

Xet Storage Details

Size:
11.9 kB
·
Xet hash:
daf2bb74980513aabca4941dcca63ca5fd94b4ffc802c11fdcf299cbc4865afe

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.