Cesar77RR's picture
download
raw
16.6 kB
import re
from oslo_log import log as logging
from oslo_utils import strutils
import nova.conf
from nova import exception
from nova.i18n import _
from nova import utils
from nova.virt import driver
CONF = nova.conf.CONF
LOG = logging.getLogger(__name__)
DEFAULT_ROOT_DEV_NAME = '/dev/sda1'
_DEFAULT_MAPPINGS = {'ami': 'sda1', 'ephemeral0': 'sda2', 'root': DEFAULT_ROOT_DEV_NAME, 'swap': 'sda3'}
bdm_legacy_fields = set(['device_name', 'delete_on_termination', 'virtual_name', 'snapshot_id', 'volume_id', 'volume_size', 'no_device', 'connection_info'])
bdm_new_fields = set(['source_type', 'destination_type', 'guest_format', 'device_type', 'disk_bus', 'boot_index', 'device_name', 'delete_on_termination', 'snapshot_id', 'volume_id', 'volume_size', 'image_id', 'no_device', 'connection_info', 'tag'])
bdm_db_only_fields = set(['id', 'instance_uuid', 'attachment_id'])
bdm_db_inherited_fields = set(['created_at', 'updated_at', 'deleted_at', 'deleted'])
bdm_new_non_api_fields = set(['volume_id', 'snapshot_id', 'image_id', 'connection_info'])
bdm_new_api_only_fields = set(['uuid'])
bdm_new_api_fields = ((bdm_new_fields - bdm_new_non_api_fields) | bdm_new_api_only_fields)
class BlockDeviceDict(dict, ):
'Represents a Block Device Mapping in Nova.'
_fields = bdm_new_fields
_db_only_fields = (bdm_db_only_fields | bdm_db_inherited_fields)
_required_fields = set(['source_type'])
def __init__(self, bdm_dict=None, do_not_default=None, **kwargs):
super(BlockDeviceDict, self).__init__()
bdm_dict = (bdm_dict or {})
bdm_dict.update(kwargs)
do_not_default = (do_not_default or set())
self._validate(bdm_dict)
if bdm_dict.get('device_name'):
bdm_dict['device_name'] = prepend_dev(bdm_dict['device_name'])
bdm_dict['delete_on_termination'] = bool(bdm_dict.get('delete_on_termination'))
self.update({field: None for field in (self._fields - do_not_default)})
self.update(bdm_dict.items())
def _validate(self, bdm_dict):
'Basic data format validations.'
dict_fields = set((key for (key, _) in bdm_dict.items()))
if (not (dict_fields <= (self._fields | self._db_only_fields))):
raise exception.InvalidBDMFormat(details=_('Some fields are invalid.'))
if bdm_dict.get('no_device'):
return
if (self._required_fields and (not ((dict_fields & self._required_fields) == self._required_fields))):
raise exception.InvalidBDMFormat(details=_('Some required fields are missing'))
if ('delete_on_termination' in bdm_dict):
bdm_dict['delete_on_termination'] = strutils.bool_from_string(bdm_dict['delete_on_termination'])
if (bdm_dict.get('device_name') is not None):
validate_device_name(bdm_dict['device_name'])
validate_and_default_volume_size(bdm_dict)
if bdm_dict.get('boot_index'):
try:
bdm_dict['boot_index'] = int(bdm_dict['boot_index'])
except ValueError:
raise exception.InvalidBDMFormat(details=_('Boot index is invalid.'))
@classmethod
def from_legacy(cls, legacy_bdm):
copy_over_fields = (bdm_legacy_fields & bdm_new_fields)
copy_over_fields |= (bdm_db_only_fields | bdm_db_inherited_fields)
non_computable_fields = set(['boot_index', 'disk_bus', 'guest_format', 'device_type'])
new_bdm = {fld: val for (fld, val) in legacy_bdm.items() if (fld in copy_over_fields)}
virt_name = legacy_bdm.get('virtual_name')
if is_swap_or_ephemeral(virt_name):
new_bdm['source_type'] = 'blank'
new_bdm['delete_on_termination'] = True
new_bdm['destination_type'] = 'local'
if (virt_name == 'swap'):
new_bdm['guest_format'] = 'swap'
else:
new_bdm['guest_format'] = CONF.default_ephemeral_format
elif legacy_bdm.get('snapshot_id'):
new_bdm['source_type'] = 'snapshot'
new_bdm['destination_type'] = 'volume'
elif legacy_bdm.get('volume_id'):
new_bdm['source_type'] = 'volume'
new_bdm['destination_type'] = 'volume'
elif legacy_bdm.get('no_device'):
pass
else:
raise exception.InvalidBDMFormat(details=_('Unrecognized legacy format.'))
return cls(new_bdm, non_computable_fields)
@classmethod
def from_api(cls, api_dict, image_uuid_specified):
'Transform the API format of data to the internally used one.\n\n Only validate if the source_type field makes sense.\n '
if (not api_dict.get('no_device')):
source_type = api_dict.get('source_type')
device_uuid = api_dict.get('uuid')
destination_type = api_dict.get('destination_type')
if ((source_type == 'blank') and device_uuid):
raise exception.InvalidBDMFormat(details=_('Invalid device UUID.'))
elif (source_type != 'blank'):
if (not device_uuid):
raise exception.InvalidBDMFormat(details=_('Missing device UUID.'))
api_dict[(source_type + '_id')] = device_uuid
if ((source_type == 'image') and (destination_type == 'local')):
boot_index = api_dict.get('boot_index', (-1))
if (boot_index is None):
boot_index = (-1)
boot_index = int(boot_index)
if (not (image_uuid_specified and (boot_index == 0))):
raise exception.InvalidBDMFormat(details=_('Mapping image to local is not supported.'))
api_dict.pop('uuid', None)
return cls(api_dict)
def legacy(self):
copy_over_fields = (bdm_legacy_fields - set(['virtual_name']))
copy_over_fields |= (bdm_db_only_fields | bdm_db_inherited_fields)
legacy_block_device = {field: self.get(field) for field in copy_over_fields if (field in self)}
source_type = self.get('source_type')
destination_type = self.get('destination_type')
no_device = self.get('no_device')
if (source_type == 'blank'):
if (self['guest_format'] == 'swap'):
legacy_block_device['virtual_name'] = 'swap'
else:
legacy_block_device['virtual_name'] = 'ephemeral0'
elif ((source_type in ('volume', 'snapshot')) or no_device):
legacy_block_device['virtual_name'] = None
elif (source_type == 'image'):
if (destination_type != 'volume'):
raise exception.InvalidBDMForLegacy()
legacy_block_device['virtual_name'] = None
return legacy_block_device
def get_image_mapping(self):
drop_fields = (set(['connection_info']) | self._db_only_fields)
mapping_dict = dict(self)
for fld in drop_fields:
mapping_dict.pop(fld, None)
return mapping_dict
def is_safe_for_update(block_device_dict):
'Determine if passed dict is a safe subset for update.\n\n Safe subset in this case means a safe subset of both legacy\n and new versions of data, that can be passed to an UPDATE query\n without any transformation.\n '
fields = set(block_device_dict.keys())
return (fields <= ((bdm_new_fields | bdm_db_inherited_fields) | bdm_db_only_fields))
def create_image_bdm(image_ref, boot_index=0):
'Create a block device dict based on the image_ref.\n\n This is useful in the API layer to keep the compatibility\n with having an image_ref as a field in the instance requests\n '
return BlockDeviceDict({'source_type': 'image', 'image_id': image_ref, 'delete_on_termination': True, 'boot_index': boot_index, 'device_type': 'disk', 'destination_type': 'local'})
def create_blank_bdm(size, guest_format=None):
return BlockDeviceDict({'source_type': 'blank', 'delete_on_termination': True, 'device_type': 'disk', 'boot_index': (-1), 'destination_type': 'local', 'guest_format': guest_format, 'volume_size': size})
def snapshot_from_bdm(snapshot_id, template):
'Create a basic volume snapshot BDM from a given template bdm.'
copy_from_template = ('disk_bus', 'device_type', 'boot_index', 'delete_on_termination', 'volume_size', 'device_name')
snapshot_dict = {'source_type': 'snapshot', 'destination_type': 'volume', 'snapshot_id': snapshot_id}
for key in copy_from_template:
snapshot_dict[key] = template.get(key)
return BlockDeviceDict(snapshot_dict)
def legacy_mapping(block_device_mapping):
'Transform a list of block devices of an instance back to the\n legacy data format.\n '
legacy_block_device_mapping = []
for bdm in block_device_mapping:
try:
legacy_block_device = BlockDeviceDict(bdm).legacy()
except exception.InvalidBDMForLegacy:
continue
legacy_block_device_mapping.append(legacy_block_device)
for (i, dev) in enumerate((dev for dev in legacy_block_device_mapping if (dev['virtual_name'] and is_ephemeral(dev['virtual_name'])))):
dev['virtual_name'] = (dev['virtual_name'][:(-1)] + str(i))
return legacy_block_device_mapping
def from_legacy_mapping(legacy_block_device_mapping, image_uuid='', root_device_name=None, no_root=False):
'Transform a legacy list of block devices to the new data format.'
new_bdms = [BlockDeviceDict.from_legacy(legacy_bdm) for legacy_bdm in legacy_block_device_mapping]
if no_root:
for bdm in new_bdms:
bdm['boot_index'] = (-1)
return new_bdms
image_bdm = None
volume_backed = False
if ((not root_device_name) and (not image_uuid)):
non_blank = [bdm for bdm in new_bdms if (bdm['source_type'] != 'blank')]
if non_blank:
non_blank[0]['boot_index'] = 0
else:
for bdm in new_bdms:
if ((bdm['source_type'] in ('volume', 'snapshot', 'image')) and (root_device_name is not None) and (strip_dev(bdm.get('device_name')) == strip_dev(root_device_name))):
bdm['boot_index'] = 0
volume_backed = True
elif (not bdm['no_device']):
bdm['boot_index'] = (-1)
else:
bdm['boot_index'] = None
if ((not volume_backed) and image_uuid):
image_bdm = create_image_bdm(image_uuid, boot_index=0)
return (([image_bdm] if image_bdm else []) + new_bdms)
def properties_root_device_name(properties):
"Get root device name from image meta data.\n If it isn't specified, return None.\n "
root_device_name = None
for bdm in properties.get('mappings', []):
if (bdm['virtual'] == 'root'):
root_device_name = bdm['device']
if ('root_device_name' in properties):
root_device_name = properties['root_device_name']
return root_device_name
def validate_device_name(value):
try:
utils.check_string_length(value, 'Device name', min_length=1, max_length=255)
except exception.InvalidInput:
raise exception.InvalidBDMFormat(details=_('Device name empty or too long.'))
if (' ' in value):
raise exception.InvalidBDMFormat(details=_('Device name contains spaces.'))
def validate_and_default_volume_size(bdm):
if bdm.get('volume_size'):
try:
bdm['volume_size'] = utils.validate_integer(bdm['volume_size'], 'volume_size', min_value=0)
except exception.InvalidInput:
raise exception.InvalidBDMFormat(details=_('Invalid volume_size.'))
_ephemeral = re.compile('^ephemeral(\\d|[1-9]\\d+)$')
def is_ephemeral(device_name):
return (_ephemeral.match(device_name) is not None)
def ephemeral_num(ephemeral_name):
assert is_ephemeral(ephemeral_name)
return int(_ephemeral.sub('\\1', ephemeral_name))
def is_swap_or_ephemeral(device_name):
return (device_name and ((device_name == 'swap') or is_ephemeral(device_name)))
def new_format_is_swap(bdm):
if ((bdm.get('source_type') == 'blank') and (bdm.get('destination_type') == 'local') and (bdm.get('guest_format') == 'swap')):
return True
return False
def new_format_is_ephemeral(bdm):
if ((bdm.get('source_type') == 'blank') and (bdm.get('destination_type') == 'local') and (bdm.get('guest_format') != 'swap')):
return True
return False
def get_root_bdm(bdms):
try:
return next((bdm for bdm in bdms if (bdm.get('boot_index', (-1)) == 0)))
except StopIteration:
return None
def get_bdms_to_connect(bdms, exclude_root_mapping=False):
'Will return non-root mappings, when exclude_root_mapping is true.\n Otherwise all mappings will be returned.\n '
return (bdm for bdm in bdms if ((bdm.get('boot_index', (-1)) != 0) or (not exclude_root_mapping)))
def mappings_prepend_dev(mappings):
"Prepend '/dev/' to 'device' entry of swap/ephemeral virtual type."
for m in mappings:
virtual = m['virtual']
if (is_swap_or_ephemeral(virtual) and (not m['device'].startswith('/'))):
m['device'] = ('/dev/' + m['device'])
return mappings
_dev = re.compile('^/dev/')
def strip_dev(device_name):
"remove leading '/dev/'."
return (_dev.sub('', device_name) if device_name else device_name)
def prepend_dev(device_name):
"Make sure there is a leading '/dev/'."
return (device_name and ('/dev/' + strip_dev(device_name)))
_pref = re.compile('^((x?v|s|h)d)')
def strip_prefix(device_name):
'remove both leading /dev/ and xvd or sd or vd or hd.'
device_name = strip_dev(device_name)
return (_pref.sub('', device_name) if device_name else device_name)
_nums = re.compile('\\d+')
def get_device_letter(device_name):
letter = strip_prefix(device_name)
return (_nums.sub('', letter) if device_name else device_name)
def instance_block_mapping(instance, bdms):
root_device_name = instance['root_device_name']
if (root_device_name is None):
if driver.is_xenapi():
root_device_name = '/dev/xvda'
else:
return _DEFAULT_MAPPINGS
mappings = {}
mappings['ami'] = strip_dev(root_device_name)
mappings['root'] = root_device_name
default_ephemeral_device = instance.get('default_ephemeral_device')
if default_ephemeral_device:
mappings['ephemeral0'] = default_ephemeral_device
default_swap_device = instance.get('default_swap_device')
if default_swap_device:
mappings['swap'] = default_swap_device
ebs_devices = []
blanks = []
for bdm in bdms:
if (bdm.destination_type == 'volume'):
ebs_devices.append(bdm.device_name)
continue
if (bdm.source_type == 'blank'):
blanks.append(bdm)
if ebs_devices:
ebs_devices = sorted(ebs_devices, key=(lambda x: ((x is not None), x)))
for (nebs, ebs) in enumerate(ebs_devices):
mappings[('ebs%d' % nebs)] = ebs
swap = [bdm for bdm in blanks if (bdm.guest_format == 'swap')]
if swap:
mappings['swap'] = swap.pop().device_name
ephemerals = [bdm for bdm in blanks if (bdm.guest_format != 'swap')]
if ephemerals:
for (num, eph) in enumerate(ephemerals):
mappings[('ephemeral%d' % num)] = eph.device_name
return mappings
def match_device(device):
'Matches device name and returns prefix, suffix.'
match = re.match('(^/dev/x{0,1}[a-z]{0,1}d{0,1})([a-z]+)[0-9]*$', device)
if (not match):
return None
return match.groups()
def volume_in_mapping(mount_device, block_device_info):
block_device_list = [strip_dev(vol['mount_device']) for vol in driver.block_device_info_get_mapping(block_device_info)]
swap = driver.block_device_info_get_swap(block_device_info)
if driver.swap_is_usable(swap):
block_device_list.append(strip_dev(swap['device_name']))
block_device_list += [strip_dev(ephemeral['device_name']) for ephemeral in driver.block_device_info_get_ephemerals(block_device_info)]
LOG.debug('block_device_list %s', sorted(filter(None, block_device_list)))
return (strip_dev(mount_device) in block_device_list)
def get_bdm_ephemeral_disk_size(block_device_mappings):
return sum((bdm.get('volume_size', 0) for bdm in block_device_mappings if new_format_is_ephemeral(bdm)))
def get_bdm_swap_list(block_device_mappings):
return [bdm for bdm in block_device_mappings if new_format_is_swap(bdm)]
def get_bdm_local_disk_num(block_device_mappings):
return len([bdm for bdm in block_device_mappings if (bdm.get('destination_type') == 'local')])

Xet Storage Details

Size:
16.6 kB
·
Xet hash:
7fd3ae044837b82d9b5505b7d852426d88233d09ec462c8b86140b1c420bed8c

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