150 lines
4.4 KiB
Python
150 lines
4.4 KiB
Python
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
|
|
|
# Copyright 2011 Isaku Yamahata <yamahata@valinux co jp>
|
|
# All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
import re
|
|
|
|
from nova import config
|
|
from nova.openstack.common import cfg
|
|
|
|
CONF = cfg.CONF
|
|
|
|
DEFAULT_ROOT_DEV_NAME = '/dev/sda1'
|
|
_DEFAULT_MAPPINGS = {'ami': 'sda1',
|
|
'ephemeral0': 'sda2',
|
|
'root': DEFAULT_ROOT_DEV_NAME,
|
|
'swap': 'sda3'}
|
|
|
|
|
|
def properties_root_device_name(properties):
|
|
"""get root device name from image meta data.
|
|
If it isn't specified, return None.
|
|
"""
|
|
root_device_name = None
|
|
|
|
# NOTE(yamahata): see image_service.s3.s3create()
|
|
for bdm in properties.get('mappings', []):
|
|
if bdm['virtual'] == 'root':
|
|
root_device_name = bdm['device']
|
|
|
|
# NOTE(yamahata): register_image's command line can override
|
|
# <machine>.manifest.xml
|
|
if 'root_device_name' in properties:
|
|
root_device_name = properties['root_device_name']
|
|
|
|
return root_device_name
|
|
|
|
|
|
_ephemeral = re.compile('^ephemeral(\d|[1-9]\d+)$')
|
|
|
|
|
|
def is_ephemeral(device_name):
|
|
return _ephemeral.match(device_name)
|
|
|
|
|
|
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 == 'swap' or is_ephemeral(device_name)
|
|
|
|
|
|
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
|
|
|
|
|
|
_pref = re.compile('^((x?v|s)d)')
|
|
|
|
|
|
def strip_prefix(device_name):
|
|
""" remove both leading /dev/ and xvd or sd or vd """
|
|
device_name = strip_dev(device_name)
|
|
return _pref.sub('', device_name)
|
|
|
|
|
|
def instance_block_mapping(instance, bdms):
|
|
root_device_name = instance['root_device_name']
|
|
# NOTE(clayg): remove this when xenapi is setting default_root_device
|
|
if root_device_name is None:
|
|
if CONF.compute_driver.endswith('xenapi.XenAPIDriver'):
|
|
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 = []
|
|
|
|
# 'ephemeralN', 'swap' and ebs
|
|
for bdm in bdms:
|
|
if bdm['no_device']:
|
|
continue
|
|
|
|
# ebs volume case
|
|
if (bdm['volume_id'] or bdm['snapshot_id']):
|
|
ebs_devices.append(bdm['device_name'])
|
|
continue
|
|
|
|
virtual_name = bdm['virtual_name']
|
|
if not virtual_name:
|
|
continue
|
|
|
|
if is_swap_or_ephemeral(virtual_name):
|
|
mappings[virtual_name] = bdm['device_name']
|
|
|
|
# NOTE(yamahata): I'm not sure how ebs device should be numbered.
|
|
# Right now sort by device name for deterministic
|
|
# result.
|
|
if ebs_devices:
|
|
nebs = 0
|
|
ebs_devices.sort()
|
|
for ebs in ebs_devices:
|
|
mappings['ebs%d' % nebs] = ebs
|
|
nebs += 1
|
|
|
|
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()
|