def test_pick_disk_driver_name_xen(self, mock_execute, mock_xend_probe):
def execute_side_effect(*args, **kwargs):
if args == ('tap-ctl', 'check'):
if mock_execute.blktap is True:
return ('ok\n', '')
elif mock_execute.blktap is False:
return ('some error\n', '')
else:
raise OSError(2, "No such file or directory")
raise Exception('Unexpected call')
mock_execute.side_effect = execute_side_effect
def xend_probe_side_effect():
if mock_execute.xend is True:
return ('', '')
elif mock_execute.xend is False:
raise processutils.ProcessExecutionError("error")
else:
raise OSError(2, "No such file or directory")
mock_xend_probe.side_effect = xend_probe_side_effect
self.flags(virt_type="xen", group='libvirt')
versions = [4000000, 4001000, 4002000, 4003000, 4005000]
for version in versions:
# block dev
result = libvirt_utils.pick_disk_driver_name(version, True)
self.assertEqual(result, "phy")
self.assertFalse(mock_execute.called)
mock_execute.reset_mock()
# file dev
for blktap in True, False, None:
mock_execute.blktap = blktap
for xend in True, False, None:
mock_execute.xend = xend
result = libvirt_utils.pick_disk_driver_name(
version, False)
# qemu backend supported only by libxl which is
# production since xen 4.2. libvirt use libxl if
# xend service not started.
if version >= 4002000 and xend is not True:
self.assertEqual(result, 'qemu')
elif blktap:
if version == 4000000:
self.assertEqual(result, 'tap')
else:
self.assertEqual(result, 'tap2')
else:
self.assertEqual(result, 'file')
# default is_block_dev False
self.assertEqual(
result, libvirt_utils.pick_disk_driver_name(version))
mock_execute.reset_mock()
def test_pick_disk_driver_name_xen(self, mock_execute, mock_xend_probe):
def execute_side_effect(*args, **kwargs):
if args == ('tap-ctl', 'check'):
if mock_execute.blktap is True:
return ('ok\n', '')
elif mock_execute.blktap is False:
return ('some error\n', '')
else:
raise OSError(2, "No such file or directory")
raise Exception('Unexpected call')
mock_execute.side_effect = execute_side_effect
def xend_probe_side_effect():
if mock_execute.xend is True:
return ('', '')
elif mock_execute.xend is False:
raise processutils.ProcessExecutionError("error")
else:
raise OSError(2, "No such file or directory")
mock_xend_probe.side_effect = xend_probe_side_effect
self.flags(virt_type="xen", group='libvirt')
versions = [4000000, 4001000, 4002000, 4003000, 4005000]
for version in versions:
# block dev
result = libvirt_utils.pick_disk_driver_name(version, True)
self.assertEqual(result, "phy")
self.assertFalse(mock_execute.called)
mock_execute.reset_mock()
# file dev
for blktap in True, False, None:
mock_execute.blktap = blktap
for xend in True, False, None:
mock_execute.xend = xend
result = libvirt_utils.pick_disk_driver_name(version,
False)
# qemu backend supported only by libxl which is
# production since xen 4.2. libvirt use libxl if
# xend service not started.
if version >= 4002000 and xend is not True:
self.assertEqual(result, 'qemu')
elif blktap:
if version == 4000000:
self.assertEqual(result, 'tap')
else:
self.assertEqual(result, 'tap2')
else:
self.assertEqual(result, 'file')
# default is_block_dev False
self.assertEqual(result,
libvirt_utils.pick_disk_driver_name(version))
mock_execute.reset_mock()
def test_pick_disk_driver_name_xen(self, mock_execute):
def side_effect(*args, **kwargs):
if args == ("tap-ctl", "check"):
if mock_execute.blktap is True:
return ("ok\n", "")
elif mock_execute.blktap is False:
return ("some error\n", "")
else:
raise OSError(2, "No such file or directory")
elif args == ("xend", "status"):
if mock_execute.xend is True:
return ("", "")
elif mock_execute.xend is False:
raise processutils.ProcessExecutionError("error")
else:
raise OSError(2, "No such file or directory")
raise Exception("Unexpected call")
mock_execute.side_effect = side_effect
self.flags(virt_type="xen", group="libvirt")
versions = [4000000, 4001000, 4002000, 4003000, 4005000]
for version in versions:
# block dev
result = libvirt_utils.pick_disk_driver_name(version, True)
self.assertEqual(result, "phy")
self.assertFalse(mock_execute.called)
mock_execute.reset_mock()
# file dev
for blktap in True, False, None:
mock_execute.blktap = blktap
for xend in True, False, None:
mock_execute.xend = xend
result = libvirt_utils.pick_disk_driver_name(version, False)
# qemu backend supported only by libxl which is
# production since xen 4.2. libvirt use libxl if
# xend service not started.
if version >= 4002000 and xend is not True:
self.assertEqual(result, "qemu")
elif blktap:
if version == 4000000:
self.assertEqual(result, "tap")
else:
self.assertEqual(result, "tap2")
else:
self.assertEqual(result, "file")
# default is_block_dev False
self.assertEqual(result, libvirt_utils.pick_disk_driver_name(version))
mock_execute.reset_mock()
def connect_volume(self, connection_info, mount_device):
conf = vconfig.LibvirtConfigGuestDisk()
conf.source_type = "network"
conf.driver_name = virtutils.pick_disk_driver_name(is_block_dev=False)
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.source_protocol = connection_info['driver_volume_type']
conf.source_host = connection_info['data']['name']
conf.target_dev = mount_device
conf.target_bus = "virtio"
conf.serial = connection_info.get('serial')
netdisk_properties = connection_info['data']
auth_enabled = netdisk_properties.get('auth_enabled')
if (conf.source_protocol == 'rbd' and
CONF.rbd_secret_uuid):
conf.auth_secret_uuid = CONF.rbd_secret_uuid
auth_enabled = True # Force authentication locally
if CONF.rbd_user:
conf.auth_username = CONF.rbd_user
if auth_enabled:
conf.auth_username = (conf.auth_username or
netdisk_properties['auth_username'])
conf.auth_secret_type = netdisk_properties['secret_type']
conf.auth_secret_uuid = (conf.auth_secret_uuid or
netdisk_properties['secret_uuid'])
return conf
def libvirt_info(self, disk_bus, disk_dev, device_type, cache_mode,
extra_specs):
"""Get `LibvirtConfigGuestDisk` filled for this image.
:disk_dev: Disk bus device name
:disk_bus: Disk bus type
:device_type: Device type for this image.
:cache_mode: Caching mode for this image
:extra_specs: Instance type extra specs dict.
"""
info = vconfig.LibvirtConfigGuestDisk()
info.source_type = self.source_type
info.source_device = device_type
info.target_bus = disk_bus
info.target_dev = disk_dev
info.driver_cache = cache_mode
info.driver_format = self.driver_format
driver_name = libvirt_utils.pick_disk_driver_name(self.is_block_dev)
info.driver_name = driver_name
info.source_path = self.path
tune_items = [
'disk_read_bytes_sec', 'disk_read_iops_sec',
'disk_write_bytes_sec', 'disk_write_iops_sec',
'disk_total_bytes_sec', 'disk_total_iops_sec'
]
# Note(yaguang): Currently, the only tuning available is Block I/O
# throttling for qemu.
if self.source_type in ['file', 'block']:
for key, value in extra_specs.iteritems():
if key in tune_items:
setattr(info, key, value)
return info
def libvirt_info(self, disk_info, cache_mode,
extra_specs, hypervisor_version, boot_order=None,
disk_unit=None):
"""Get `LibvirtConfigGuestDisk` filled for this image.
:disk_info: Metadata generated by libvirt.blockinfo.get_disk_mapping
:cache_mode: Caching mode for this image
:extra_specs: Instance type extra specs dict.
:hypervisor_version: the hypervisor version
:boot_order: Disk device boot order
"""
disk_bus = disk_info['bus']
info = vconfig.LibvirtConfigGuestDisk()
info.source_type = self.source_type
info.source_device = disk_info['type']
info.target_bus = disk_bus
info.target_dev = disk_info['dev']
info.driver_cache = cache_mode
info.driver_discard = self.discard_mode
info.driver_io = self.driver_io
info.driver_format = self.driver_format
driver_name = libvirt_utils.pick_disk_driver_name(hypervisor_version,
self.is_block_dev)
info.driver_name = driver_name
info.source_path = self.path
info.boot_order = boot_order
if disk_bus == 'scsi':
self.disk_scsi(info, disk_unit)
self.disk_qos(info, extra_specs)
return info
def libvirt_info(self, disk_info, cache_mode,
extra_specs, hypervisor_version, boot_order=None,
disk_unit=None):
"""Get `LibvirtConfigGuestDisk` filled for this image.
:disk_info: Metadata generated by libvirt.blockinfo.get_disk_mapping
:cache_mode: Caching mode for this image
:extra_specs: Instance type extra specs dict.
:hypervisor_version: the hypervisor version
:boot_order: Disk device boot order
"""
disk_bus = disk_info['bus']
info = vconfig.LibvirtConfigGuestDisk()
info.source_type = self.source_type
info.source_device = disk_info['type']
info.target_bus = disk_bus
info.target_dev = disk_info['dev']
info.driver_cache = cache_mode
info.driver_discard = self.discard_mode
info.driver_io = self.driver_io
info.driver_format = self.driver_format
driver_name = libvirt_utils.pick_disk_driver_name(hypervisor_version,
self.is_block_dev)
info.driver_name = driver_name
info.source_path = self.path
info.boot_order = boot_order
if disk_bus == 'scsi':
self.disk_scsi(info, disk_unit)
self.disk_qos(info, extra_specs)
return info
def libvirt_info(self, disk_bus, disk_dev, device_type, cache_mode,
extra_specs, hypervisor_version):
"""Get `LibvirtConfigGuestDisk` filled for this image.
:disk_dev: Disk bus device name
:disk_bus: Disk bus type
:device_type: Device type for this image.
:cache_mode: Caching mode for this image
:extra_specs: Instance type extra specs dict.
:hypervisor_version: the hypervisor version
"""
info = vconfig.LibvirtConfigGuestDisk()
info.source_type = self.source_type
info.source_device = device_type
info.target_bus = disk_bus
info.target_dev = disk_dev
info.driver_cache = cache_mode
info.driver_discard = self.discard_mode
info.driver_io = self.driver_io
info.driver_format = self.driver_format
driver_name = libvirt_utils.pick_disk_driver_name(hypervisor_version,
self.is_block_dev)
info.driver_name = driver_name
info.source_path = self.path
self.disk_qos(info, extra_specs)
return info
def libvirt_info(self, disk_bus, disk_dev, device_type, cache_mode,
extra_specs, hypervisor_version):
"""Get `LibvirtConfigGuestDisk` filled for this image.
:disk_dev: Disk bus device name
:disk_bus: Disk bus type
:device_type: Device type for this image.
:cache_mode: Caching mode for this image
:extra_specs: Instance type extra specs dict.
:hypervisor_version: the hypervisor version
"""
info = vconfig.LibvirtConfigGuestDisk()
info.source_type = self.source_type
info.source_device = device_type
info.target_bus = disk_bus
info.target_dev = disk_dev
info.driver_cache = cache_mode
info.driver_discard = self.discard_mode
info.driver_format = self.driver_format
driver_name = libvirt_utils.pick_disk_driver_name(
hypervisor_version, self.is_block_dev)
info.driver_name = driver_name
info.source_path = self.path
self.disk_qos(info, extra_specs)
return info
def libvirt_info(self, disk_bus, disk_dev, device_type, cache_mode, extra_specs, hypervisor_version):
"""Get `LibvirtConfigGuestDisk` filled for this image.
:disk_dev: Disk bus device name
:disk_bus: Disk bus type
:device_type: Device type for this image.
:cache_mode: Caching mode for this image
:extra_specs: Instance type extra specs dict.
"""
info = vconfig.LibvirtConfigGuestDisk()
info.source_type = self.source_type
info.source_device = device_type
info.target_bus = disk_bus
info.target_dev = disk_dev
info.driver_cache = cache_mode
info.driver_discard = self.discard_mode
info.driver_format = self.driver_format
driver_name = libvirt_utils.pick_disk_driver_name(hypervisor_version, self.is_block_dev)
info.driver_name = driver_name
info.source_path = self.path
tune_items = [
"disk_read_bytes_sec",
"disk_read_iops_sec",
"disk_write_bytes_sec",
"disk_write_iops_sec",
"disk_total_bytes_sec",
"disk_total_iops_sec",
]
for key, value in extra_specs.iteritems():
scope = key.split(":")
if len(scope) > 1 and scope[0] == "quota":
if scope[1] in tune_items:
setattr(info, scope[1], value)
return info
def connect_volume(self, connection_info, mount_device):
conf = vconfig.LibvirtConfigGuestDisk()
conf.source_type = "network"
conf.driver_name = virtutils.pick_disk_driver_name(is_block_dev=False)
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.source_protocol = connection_info['driver_volume_type']
conf.source_host = connection_info['data']['name']
conf.target_dev = mount_device
conf.target_bus = "virtio"
conf.serial = connection_info.get('serial')
netdisk_properties = connection_info['data']
auth_enabled = netdisk_properties.get('auth_enabled')
if (conf.source_protocol == 'rbd' and CONF.rbd_secret_uuid):
conf.auth_secret_uuid = CONF.rbd_secret_uuid
auth_enabled = True # Force authentication locally
if CONF.rbd_user:
conf.auth_username = CONF.rbd_user
if auth_enabled:
conf.auth_username = (conf.auth_username
or netdisk_properties['auth_username'])
conf.auth_secret_type = netdisk_properties['secret_type']
conf.auth_secret_uuid = (conf.auth_secret_uuid
or netdisk_properties['secret_uuid'])
return conf
def libvirt_info(self, disk_bus, disk_dev, device_type, cache_mode,
extra_specs, hypervisor_version):
"""Get `LibvirtConfigGuestDisk` filled for this image.
:disk_dev: Disk bus device name
:disk_bus: Disk bus type
:device_type: Device type for this image.
:cache_mode: Caching mode for this image
:extra_specs: Instance type extra specs dict.
"""
info = vconfig.LibvirtConfigGuestDisk()
info.source_type = self.source_type
info.source_device = device_type
info.target_bus = disk_bus
info.target_dev = disk_dev
info.driver_cache = cache_mode
info.driver_format = self.driver_format
driver_name = libvirt_utils.pick_disk_driver_name(hypervisor_version,
self.is_block_dev)
info.driver_name = driver_name
info.source_path = self.path
tune_items = ['disk_read_bytes_sec', 'disk_read_iops_sec',
'disk_write_bytes_sec', 'disk_write_iops_sec',
'disk_total_bytes_sec', 'disk_total_iops_sec']
# Note(yaguang): Currently, the only tuning available is Block I/O
# throttling for qemu.
if self.source_type in ['file', 'block']:
for key, value in extra_specs.iteritems():
scope = key.split(':')
if len(scope) > 1 and scope[0] == 'quota':
if scope[1] in tune_items:
setattr(info, scope[1], value)
return info
def libvirt_info(self, disk_bus, disk_dev, device_type, cache_mode,
extra_specs, hypervisor_version):
"""Get `LibvirtConfigGuestDisk` filled for this image.
:disk_dev: Disk bus device name
:disk_bus: Disk bus type
:device_type: Device type for this image.
:cache_mode: Caching mode for this image
:extra_specs: Instance type extra specs dict.
"""
info = vconfig.LibvirtConfigGuestDisk()
info.source_type = self.source_type
info.source_device = device_type
info.target_bus = disk_bus
info.target_dev = disk_dev
info.driver_cache = cache_mode
info.driver_discard = self.discard_mode
info.driver_format = self.driver_format
driver_name = libvirt_utils.pick_disk_driver_name(hypervisor_version,
self.is_block_dev)
info.driver_name = driver_name
info.source_path = self.path
tune_items = ['disk_read_bytes_sec', 'disk_read_iops_sec',
'disk_write_bytes_sec', 'disk_write_iops_sec',
'disk_total_bytes_sec', 'disk_total_iops_sec']
for key, value in extra_specs.iteritems():
scope = key.split(':')
if len(scope) > 1 and scope[0] == 'quota':
if scope[1] in tune_items:
setattr(info, scope[1], value)
return info
def test_pick_disk_driver_name_xen(self):
version_map = ((4000000, "tap"),
(4001000, "tap2"),
(4002000, "qemu"))
self.flags(virt_type="xen", group='libvirt')
for ver, drv in version_map:
result = libvirt_utils.pick_disk_driver_name(ver, False)
self.assertEqual(drv, result)
def get_config(self, connection_info, disk_info):
"""Returns xml for libvirt."""
conf = vconfig.LibvirtConfigGuestDisk()
conf.driver_name = libvirt_utils.pick_disk_driver_name(
self.connection._host.get_version(), self.is_block_dev)
conf.source_device = disk_info['type']
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.target_dev = disk_info['dev']
conf.target_bus = disk_info['bus']
conf.serial = connection_info.get('serial')
# Support for block size tuning
data = {}
if 'data' in connection_info:
data = connection_info['data']
if 'logical_block_size' in data:
conf.logical_block_size = data['logical_block_size']
if 'physical_block_size' in data:
conf.physical_block_size = data['physical_block_size']
# Extract rate_limit control parameters
if 'qos_specs' in data and data['qos_specs']:
tune_opts = [
'total_bytes_sec', 'read_bytes_sec', 'write_bytes_sec',
'total_iops_sec', 'read_iops_sec', 'write_iops_sec'
]
specs = data['qos_specs']
if isinstance(specs, dict):
for k, v in six.iteritems(specs):
if k in tune_opts:
new_key = 'disk_' + k
setattr(conf, new_key, v)
else:
LOG.warn(
_LW('Unknown content in connection_info/'
'qos_specs: %s'), specs)
# TODO(jahei): Maybe we should add a shareable flag to
# the volume. But I am not sure whether we need it. In
# my test, it is ok without this flag. Let's get back to
# this part when something goes wrong.
# Extract access_mode control parameters
if 'access_mode' in data and data['access_mode']:
access_mode = data['access_mode']
if access_mode in ('ro', 'rw'):
conf.readonly = access_mode == 'ro'
else:
LOG.error(
_LE('Unknown content in '
'connection_info/access_mode: %s'), access_mode)
raise exception.InvalidVolumeAccessMode(
access_mode=access_mode)
return conf
def get_config(self, connection_info, disk_info):
"""Returns xml for libvirt."""
conf = vconfig.LibvirtConfigGuestDisk()
conf.driver_name = libvirt_utils.pick_disk_driver_name(
self.host.get_version(), self.is_block_dev)
conf.source_device = disk_info['type']
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.target_dev = disk_info['dev']
conf.target_bus = disk_info['bus']
conf.serial = connection_info.get('serial')
# Support for block size tuning
data = {}
if 'data' in connection_info:
data = connection_info['data']
if 'logical_block_size' in data:
conf.logical_block_size = data['logical_block_size']
if 'physical_block_size' in data:
conf.physical_block_size = data['physical_block_size']
# Extract rate_limit control parameters
if 'qos_specs' in data and data['qos_specs']:
tune_opts = [
'total_bytes_sec', 'read_bytes_sec', 'write_bytes_sec',
'total_iops_sec', 'read_iops_sec', 'write_iops_sec'
]
specs = data['qos_specs']
if isinstance(specs, dict):
for k, v in specs.items():
if k in tune_opts:
new_key = 'disk_' + k
setattr(conf, new_key, v)
else:
LOG.warning(
_LW('Unknown content in connection_info/'
'qos_specs: %s'), specs)
# Extract access_mode control parameters
if 'access_mode' in data and data['access_mode']:
access_mode = data['access_mode']
if access_mode in ('ro', 'rw'):
conf.readonly = access_mode == 'ro'
else:
LOG.error(
_LE('Unknown content in '
'connection_info/access_mode: %s'), access_mode)
raise exception.InvalidVolumeAccessMode(
access_mode=access_mode)
# Configure usage of discard
if data.get('discard', False) is True:
conf.driver_discard = 'unmap'
return conf
def get_config(self, connection_info, disk_info):
"""Returns xml for libvirt."""
conf = vconfig.LibvirtConfigGuestDisk()
conf.driver_name = libvirt_utils.pick_disk_driver_name(
self.host.get_version(),
self.is_block_dev
)
conf.source_device = disk_info['type']
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.target_dev = disk_info['dev']
conf.target_bus = disk_info['bus']
conf.serial = connection_info.get('serial')
# Support for block size tuning
data = {}
if 'data' in connection_info:
data = connection_info['data']
if 'logical_block_size' in data:
conf.logical_block_size = data['logical_block_size']
if 'physical_block_size' in data:
conf.physical_block_size = data['physical_block_size']
# Extract rate_limit control parameters
if 'qos_specs' in data and data['qos_specs']:
tune_opts = ['total_bytes_sec', 'read_bytes_sec',
'write_bytes_sec', 'total_iops_sec',
'read_iops_sec', 'write_iops_sec']
specs = data['qos_specs']
if isinstance(specs, dict):
for k, v in specs.items():
if k in tune_opts:
new_key = 'disk_' + k
setattr(conf, new_key, v)
else:
LOG.warning(_LW('Unknown content in connection_info/'
'qos_specs: %s'), specs)
# Extract access_mode control parameters
if 'access_mode' in data and data['access_mode']:
access_mode = data['access_mode']
if access_mode in ('ro', 'rw'):
conf.readonly = access_mode == 'ro'
else:
LOG.error(_LE('Unknown content in '
'connection_info/access_mode: %s'),
access_mode)
raise exception.InvalidVolumeAccessMode(
access_mode=access_mode)
# Configure usage of discard
if data.get('discard', False) is True:
conf.driver_discard = 'unmap'
return conf
def connect_volume(self, connection_info, mount_device):
"""Connect the volume. Returns xml for libvirt."""
conf = config.LibvirtConfigGuestDisk()
conf.source_type = "block"
conf.driver_name = virtutils.pick_disk_driver_name(is_block_dev=True)
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.source_path = connection_info['data']['device_path']
conf.target_dev = mount_device
conf.target_bus = "virtio"
return conf
def connect_volume(self, connection_info, mount_device):
"""Connect the volume. Returns xml for libvirt."""
conf = vconfig.LibvirtConfigGuestDisk()
conf.driver_name = virtutils.pick_disk_driver_name(self.is_block_dev)
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.target_dev = mount_device
conf.target_bus = "virtio"
conf.serial = connection_info.get('serial')
return conf
def connect_volume(self, connection_info, mount_device):
"""Connect the volume. Returns xml for libvirt."""
conf = config.LibvirtConfigGuestDisk()
conf.source_type = "block"
conf.driver_name = virtutils.pick_disk_driver_name(is_block_dev=True)
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.source_path = connection_info["data"]["device_path"]
conf.target_dev = mount_device
conf.target_bus = "virtio"
return conf
def connect_volume(self, connection_info, disk_info):
"""Connect the volume. Returns xml for libvirt."""
conf = vconfig.LibvirtConfigGuestDisk()
conf.driver_name = virtutils.pick_disk_driver_name(self.is_block_dev)
conf.device_type = disk_info['type']
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.target_dev = disk_info['dev']
conf.target_bus = disk_info['bus']
conf.serial = connection_info.get('serial')
return conf
def connect_volume(self, connection_info, disk_info):
"""Connect the volume. Returns xml for libvirt."""
conf = vconfig.LibvirtConfigGuestDisk()
conf.driver_name = libvirt_utils.pick_disk_driver_name(
self.connection._get_hypervisor_version(), self.is_block_dev
)
conf.source_device = disk_info["type"]
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.target_dev = disk_info["dev"]
conf.target_bus = disk_info["bus"]
conf.serial = connection_info.get("serial")
# Support for block size tuning
data = {}
if "data" in connection_info:
data = connection_info["data"]
if "logical_block_size" in data:
conf.logical_block_size = data["logical_block_size"]
if "physical_block_size" in data:
conf.physical_block_size = data["physical_block_size"]
# Extract rate_limit control parameters
if "qos_specs" in data and data["qos_specs"]:
tune_opts = [
"total_bytes_sec",
"read_bytes_sec",
"write_bytes_sec",
"total_iops_sec",
"read_iops_sec",
"write_iops_sec",
]
specs = data["qos_specs"]
if isinstance(specs, dict):
for k, v in specs.iteritems():
if k in tune_opts:
new_key = "disk_" + k
setattr(conf, new_key, v)
else:
LOG.warn(_LW("Unknown content in connection_info/" "qos_specs: %s"), specs)
# Extract access_mode control parameters
if "access_mode" in data and data["access_mode"]:
access_mode = data["access_mode"]
if access_mode in ("ro", "rw"):
conf.readonly = access_mode == "ro"
else:
LOG.error(_LE("Unknown content in " "connection_info/access_mode: %s"), access_mode)
raise exception.InvalidVolumeAccessMode(access_mode=access_mode)
return conf
def connect_volume(self, connection_info, mount_device):
"""Connect the volume. Returns xml for libvirt."""
conf = vconfig.LibvirtConfigGuestDisk()
conf.driver_name = virtutils.pick_disk_driver_name(self.is_block_dev)
conf.driver_format = "raw"
conf.target_dev = mount_device['dev']
conf.target_bus = mount_device['bus']
conf.serial = connection_info.get('serial')
path = self._ensure_mounted(connection_info['data']['export'])
path = os.path.join(path, connection_info['data']['name'])
conf.source_type = 'file'
conf.source_path = path
return conf
def test_pick_disk_driver_name(self):
type_map = {'kvm': ([True, 'qemu'], [False, 'qemu'], [None, 'qemu']),
'qemu': ([True, 'qemu'], [False, 'qemu'], [None, 'qemu']),
'lxc': ([True, None], [False, None], [None, None])}
# NOTE(aloga): Xen is tested in test_pick_disk_driver_name_xen
version = 1005001
for (virt_type, checks) in type_map.items():
self.flags(virt_type=virt_type, group='libvirt')
for (is_block_dev, expected_result) in checks:
result = libvirt_utils.pick_disk_driver_name(version,
is_block_dev)
self.assertEqual(result, expected_result)
def test_pick_disk_driver_name(self):
type_map = {'kvm': ([True, 'qemu'], [False, 'qemu'], [None, 'qemu']),
'qemu': ([True, 'qemu'], [False, 'qemu'], [None, 'qemu']),
'uml': ([True, None], [False, None], [None, None]),
'lxc': ([True, None], [False, None], [None, None])}
# NOTE(aloga): Xen is tested in test_pick_disk_driver_name_xen
version = 1005001
for (virt_type, checks) in type_map.iteritems():
self.flags(virt_type=virt_type, group='libvirt')
for (is_block_dev, expected_result) in checks:
result = libvirt_utils.pick_disk_driver_name(version,
is_block_dev)
self.assertEqual(result, expected_result)
def connect_volume(self, connection_info, disk_info):
"""Connect the volume. Returns xml for libvirt."""
conf = vconfig.LibvirtConfigGuestDisk()
conf.driver_name = virtutils.pick_disk_driver_name(
self.connection.get_hypervisor_version(),
self.is_block_dev
)
conf.device_type = disk_info['type']
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.target_dev = disk_info['dev']
conf.target_bus = disk_info['bus']
conf.serial = connection_info.get('serial')
return conf
def test_pick_disk_driver_name(self):
type_map = {
"kvm": ([True, "qemu"], [False, "qemu"], [None, "qemu"]),
"qemu": ([True, "qemu"], [False, "qemu"], [None, "qemu"]),
"uml": ([True, None], [False, None], [None, None]),
"lxc": ([True, None], [False, None], [None, None]),
}
# NOTE(aloga): Xen is tested in test_pick_disk_driver_name_xen
version = 1005001
for (virt_type, checks) in six.iteritems(type_map):
self.flags(virt_type=virt_type, group="libvirt")
for (is_block_dev, expected_result) in checks:
result = libvirt_utils.pick_disk_driver_name(version, is_block_dev)
self.assertEqual(result, expected_result)
def connect_volume(self, connection_info, mount_device):
conf = config.LibvirtConfigGuestDisk()
conf.source_type = "network"
conf.driver_name = virtutils.pick_disk_driver_name(is_block_dev=False)
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.source_protocol = connection_info["driver_volume_type"]
conf.source_host = connection_info["data"]["name"]
conf.target_dev = mount_device
conf.target_bus = "virtio"
netdisk_properties = connection_info["data"]
if netdisk_properties.get("auth_enabled"):
conf.auth_username = netdisk_properties["auth_username"]
conf.auth_secret_type = netdisk_properties["secret_type"]
conf.auth_secret_uuid = netdisk_properties["secret_uuid"]
return conf
def connect_volume(self, connection_info, mount_device):
conf = config.LibvirtConfigGuestDisk()
conf.source_type = "network"
conf.driver_name = virtutils.pick_disk_driver_name(is_block_dev=False)
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.source_protocol = connection_info['driver_volume_type']
conf.source_host = connection_info['data']['name']
conf.target_dev = mount_device
conf.target_bus = "virtio"
netdisk_properties = connection_info['data']
if netdisk_properties.get('auth_enabled'):
conf.auth_username = netdisk_properties['auth_username']
conf.auth_secret_type = netdisk_properties['secret_type']
conf.auth_secret_uuid = netdisk_properties['secret_uuid']
return conf
def connect_volume(self, connection_info, mount_device):
conf = config.LibvirtConfigGuestDisk()
conf.source_type = "network"
conf.driver_name = virtutils.pick_disk_driver_name(is_block_dev=False)
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.source_protocol = connection_info['driver_volume_type']
conf.source_host = connection_info['data']['name']
conf.target_dev = mount_device
conf.target_bus = "virtio"
conf.serial = connection_info.get('serial')
netdisk_properties = connection_info['data']
if netdisk_properties.get('auth_enabled'):
conf.auth_username = netdisk_properties['auth_username']
conf.auth_secret_type = netdisk_properties['secret_type']
conf.auth_secret_uuid = netdisk_properties['secret_uuid']
return conf
def test_pick_disk_driver_name(self):
type_map = {'kvm': ([True, 'qemu'], [False, 'qemu'], [None, 'qemu']),
'qemu': ([True, 'qemu'], [False, 'qemu'], [None, 'qemu']),
'xen': ([True, 'phy'], [False, 'tap2'], [None, 'tap2']),
'uml': ([True, None], [False, None], [None, None]),
'lxc': ([True, None], [False, None], [None, None])}
for (virt_type, checks) in type_map.iteritems():
if virt_type == "xen":
version = 4001000
else:
version = 1005001
self.flags(virt_type=virt_type, group='libvirt')
for (is_block_dev, expected_result) in checks:
result = libvirt_utils.pick_disk_driver_name(version,
is_block_dev)
self.assertEqual(result, expected_result)
def libvirt_info(self, disk_bus, disk_dev, device_type, cache_mode):
"""Get `LibvirtConfigGuestDisk` filled for this image.
:disk_dev: Disk bus device name
:disk_bus: Disk bus type
:device_type: Device type for this image.
:cache_mode: Caching mode for this image
"""
info = vconfig.LibvirtConfigGuestDisk()
info.source_type = self.source_type
info.source_device = device_type
info.target_bus = disk_bus
info.target_dev = disk_dev
info.driver_cache = cache_mode
info.driver_format = self.driver_format
driver_name = libvirt_utils.pick_disk_driver_name(self.is_block_dev)
info.driver_name = driver_name
info.source_path = self.path
return info
def libvirt_info(self, disk_bus, disk_dev, device_type, cache_mode):
"""Get `LibvirtConfigGuestDisk` filled for this image.
:disk_dev: Disk bus device name
:disk_bus: Disk bus type
:device_type: Device type for this image.
:cache_mode: Caching mode for this image
"""
info = vconfig.LibvirtConfigGuestDisk()
info.source_type = self.source_type
info.source_device = device_type
info.target_bus = disk_bus
info.target_dev = disk_dev
info.driver_cache = cache_mode
info.driver_format = self.driver_format
driver_name = libvirt_utils.pick_disk_driver_name(self.is_block_dev)
info.driver_name = driver_name
info.source_path = self.path
return info
def test_pick_disk_driver_name(self):
type_map = {
"kvm": ([True, "qemu"], [False, "qemu"], [None, "qemu"]),
"qemu": ([True, "qemu"], [False, "qemu"], [None, "qemu"]),
"xen": ([True, "phy"], [False, "tap2"], [None, "tap2"]),
"uml": ([True, None], [False, None], [None, None]),
"lxc": ([True, None], [False, None], [None, None]),
}
for (virt_type, checks) in type_map.iteritems():
if virt_type == "xen":
version = 4001000
else:
version = 1005001
self.flags(virt_type=virt_type, group="libvirt")
for (is_block_dev, expected_result) in checks:
result = libvirt_utils.pick_disk_driver_name(version, is_block_dev)
self.assertEqual(result, expected_result)
def test_pick_disk_driver_name(self):
type_map = {
'kvm': ([True, 'qemu'], [False, 'qemu'], [None, 'qemu']),
'qemu': ([True, 'qemu'], [False, 'qemu'], [None, 'qemu']),
'xen': ([True, 'phy'], [False, 'tap2'], [None, 'tap2']),
'uml': ([True, None], [False, None], [None, None]),
'lxc': ([True, None], [False, None], [None, None])
}
for (virt_type, checks) in type_map.iteritems():
if virt_type == "xen":
version = 4001000
else:
version = 1005001
self.flags(virt_type=virt_type, group='libvirt')
for (is_block_dev, expected_result) in checks:
result = libvirt_utils.pick_disk_driver_name(
version, is_block_dev)
self.assertEqual(result, expected_result)
def connect_volume(self, connection_info, disk_info):
"""Connect the volume. Returns xml for libvirt."""
conf = vconfig.LibvirtConfigGuestDisk()
conf.driver_name = virtutils.pick_disk_driver_name(
self.connection.get_hypervisor_version(), self.is_block_dev)
conf.source_device = disk_info['type']
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.target_dev = disk_info['dev']
conf.target_bus = disk_info['bus']
conf.serial = connection_info.get('serial')
# Support for block size tuning
data = {}
if 'data' in connection_info:
data = connection_info['data']
if 'logical_block_size' in data:
conf.logical_block_size = data['logical_block_size']
if 'physical_block_size' in data:
conf.physical_block_size = data['physical_block_size']
# Extract rate_limit control parameters
if 'qos_specs' in data and data['qos_specs']:
tune_opts = [
'total_bytes_sec', 'read_bytes_sec', 'write_bytes_sec',
'total_iops_sec', 'read_iops_sec', 'write_iops_sec'
]
specs = data['qos_specs']
if isinstance(specs, dict):
for k, v in specs.iteritems():
if k in tune_opts:
new_key = 'disk_' + k
setattr(conf, new_key, v)
else:
LOG.warn(
_('Unknown content in connection_info/'
'qos_specs: %s') % specs)
return conf
def connect_volume(self, connection_info, disk_info):
"""Connect the volume. Returns xml for libvirt."""
conf = vconfig.LibvirtConfigGuestDisk()
conf.driver_name = virtutils.pick_disk_driver_name(
self.connection.get_hypervisor_version(),
self.is_block_dev
)
conf.source_device = disk_info['type']
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.target_dev = disk_info['dev']
conf.target_bus = disk_info['bus']
conf.serial = connection_info.get('serial')
# Support for block size tuning
data = {}
if 'data' in connection_info:
data = connection_info['data']
if 'logical_block_size' in data:
conf.logical_block_size = data['logical_block_size']
if 'physical_block_size' in data:
conf.physical_block_size = data['physical_block_size']
# Extract rate_limit control parameters
if 'qos_specs' in data and data['qos_specs']:
tune_opts = ['total_bytes_sec', 'read_bytes_sec',
'write_bytes_sec', 'total_iops_sec',
'read_iops_sec', 'write_iops_sec']
specs = data['qos_specs']
if isinstance(specs, dict):
for k, v in specs.iteritems():
if k in tune_opts:
new_key = 'disk_' + k
setattr(conf, new_key, v)
else:
LOG.warn(_('Unknown content in connection_info/'
'qos_specs: %s') % specs)
return conf
def get_config(self, connection_info, disk_info):
"""Returns xml for libvirt."""
conf = vconfig.LibvirtConfigOpenvStorageEdgeGuestDisk()
conf.driver_name = libvirt_utils.pick_disk_driver_name(self.connection._host.get_version(),
self.is_block_dev)
source_path = connection_info['data']['device_path']
#u'device_path': u'openvstorage+tcp:10.130.11.202:26203/volimage3'
ovs_proto, host, port_volume = source_path.split(':')
port, name = port_volume.split('/')
_, transport = ovs_proto.split('+')
conf.source_name = name
conf.source_host_name = host
conf.source_host_port = port
conf.source_host_transport = transport
conf.target_dev = disk_info['dev']
conf.target_bus = disk_info['bus']
conf.serial = connection_info.get('serial')
return conf
def connect_volume(self, connection_info, disk_info):
"""Connect the volume. Returns xml for libvirt."""
conf = vconfig.LibvirtConfigGuestDisk()
conf.driver_name = virtutils.pick_disk_driver_name(
self.connection.get_hypervisor_version(), self.is_block_dev)
conf.device_type = disk_info['type']
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.target_dev = disk_info['dev']
conf.target_bus = disk_info['bus']
conf.serial = connection_info.get('serial')
# Support for block size tuning
data = {}
if 'data' in connection_info:
data = connection_info['data']
if 'logical_block_size' in data:
conf.logical_block_size = data['logical_block_size']
if 'physical_block_size' in data:
conf.physical_block_size = data['physical_block_size']
return conf
def connect_volume(self, connection_info, mount_device):
conf = vconfig.LibvirtConfigGuestDisk()
conf.source_type = "network"
conf.driver_name = virtutils.pick_disk_driver_name(is_block_dev=False)
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.source_protocol = connection_info["driver_volume_type"]
conf.source_host = connection_info["data"]["name"]
conf.target_dev = mount_device
conf.target_bus = "virtio"
conf.serial = connection_info.get("serial")
netdisk_properties = connection_info["data"]
auth_enabled = netdisk_properties.get("auth_enabled")
if conf.source_protocol == "rbd" and CONF.rbd_secret_uuid:
conf.auth_secret_uuid = CONF.rbd_secret_uuid
auth_enabled = True # Force authentication locally
if CONF.rbd_user:
conf.auth_username = CONF.rbd_user
if auth_enabled:
conf.auth_username = conf.auth_username or netdisk_properties["auth_username"]
conf.auth_secret_type = netdisk_properties["secret_type"]
conf.auth_secret_uuid = conf.auth_secret_uuid or netdisk_properties["secret_uuid"]
return conf
def connect_volume(self, connection_info, disk_info):
"""Connect the volume. Returns xml for libvirt."""
conf = vconfig.LibvirtConfigGuestDisk()
conf.driver_name = virtutils.pick_disk_driver_name(
self.connection.get_hypervisor_version(),
self.is_block_dev
)
conf.device_type = disk_info['type']
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.target_dev = disk_info['dev']
conf.target_bus = disk_info['bus']
conf.serial = connection_info.get('serial')
# Support for block size tuning
data = {}
if 'data' in connection_info:
data = connection_info['data']
if 'logical_block_size' in data:
conf.logical_block_size = data['logical_block_size']
if 'physical_block_size' in data:
conf.physical_block_size = data['physical_block_size']
return conf
def get_config(self, connection_info, disk_info):
"""Returns xml for libvirt."""
conf = vconfig.LibvirtConfigGuestDisk()
conf.driver_name = libvirt_utils.pick_disk_driver_name(
self.connection._host.get_version(),
self.is_block_dev
)
conf.source_device = disk_info['type']
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.target_dev = disk_info['dev']
conf.target_bus = disk_info['bus']
conf.serial = connection_info.get('serial')
# Support for block size tuning
data = {}
if 'data' in connection_info:
data = connection_info['data']
if 'logical_block_size' in data:
conf.logical_block_size = data['logical_block_size']
if 'physical_block_size' in data:
conf.physical_block_size = data['physical_block_size']
# Extract rate_limit control parameters
if 'qos_specs' in data and data['qos_specs']:
tune_opts = ['total_bytes_sec', 'read_bytes_sec',
'write_bytes_sec', 'total_iops_sec',
'read_iops_sec', 'write_iops_sec']
specs = data['qos_specs']
if isinstance(specs, dict):
for k, v in six.iteritems(specs):
if k in tune_opts:
new_key = 'disk_' + k
setattr(conf, new_key, v)
else:
LOG.warn(_LW('Unknown content in connection_info/'
'qos_specs: %s'), specs)
# Extract access_mode control parameters
if 'access_mode' in data and data['access_mode']:
access_mode = data['access_mode']
if access_mode in ('ro', 'rw'):
conf.readonly = access_mode == 'ro'
else:
LOG.error(_LE('Unknown content in '
'connection_info/access_mode: %s'),
access_mode)
raise exception.InvalidVolumeAccessMode(
access_mode=access_mode)
# Configure usage of discard
if data.get('discard', False) is True:
min_qemu = nova.virt.libvirt.driver.MIN_QEMU_DISCARD_VERSION
min_libvirt = nova.virt.libvirt.driver.MIN_LIBVIRT_DISCARD_VERSION
if self.connection._host.has_min_version(min_libvirt,
min_qemu,
host.HV_DRIVER_QEMU):
conf.driver_discard = 'unmap'
else:
global SHOULD_LOG_DISCARD_WARNING
if SHOULD_LOG_DISCARD_WARNING:
SHOULD_LOG_DISCARD_WARNING = False
LOG.warning(_LW('Unable to attach %(type)s volume '
'%(serial)s with discard enabled: qemu '
'%(qemu)s and libvirt %(libvirt)s or '
'later are required.'),
{
'qemu': min_qemu,
'libvirt': min_libvirt,
'serial': conf.serial,
'type': connection_info['driver_volume_type']
})
return conf
def test_pick_disk_driver_name_xen_4_0_0(self):
self.flags(virt_type="xen", group='libvirt')
result = libvirt_utils.pick_disk_driver_name(4000000, False)
self.assertEqual(result, "tap")
def get_config(self, connection_info, disk_info):
"""Returns xml for libvirt."""
conf = vconfig.LibvirtConfigGuestDisk()
conf.driver_name = libvirt_utils.pick_disk_driver_name(
self.host.get_version(), self.is_block_dev)
conf.source_device = disk_info['type']
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.target_dev = disk_info['dev']
conf.target_bus = disk_info['bus']
conf.serial = connection_info.get('serial')
# Support for block size tuning
data = {}
if 'data' in connection_info:
data = connection_info['data']
if 'logical_block_size' in data:
conf.logical_block_size = data['logical_block_size']
if 'physical_block_size' in data:
conf.physical_block_size = data['physical_block_size']
# Extract rate_limit control parameters
if 'qos_specs' in data and data['qos_specs']:
tune_opts = [
'total_bytes_sec', 'read_bytes_sec', 'write_bytes_sec',
'total_iops_sec', 'read_iops_sec', 'write_iops_sec'
]
specs = data['qos_specs']
if isinstance(specs, dict):
for k, v in specs.items():
if k in tune_opts:
new_key = 'disk_' + k
setattr(conf, new_key, v)
else:
LOG.warning(
'Unknown content in connection_info/'
'qos_specs: %s', specs)
# Extract access_mode control parameters
if 'access_mode' in data and data['access_mode']:
access_mode = data['access_mode']
if access_mode in ('ro', 'rw'):
conf.readonly = access_mode == 'ro'
else:
LOG.error(
'Unknown content in '
'connection_info/access_mode: %s', access_mode)
raise exception.InvalidVolumeAccessMode(
access_mode=access_mode)
# Configure usage of discard
if data.get('discard', False) is True:
conf.driver_discard = 'unmap'
if disk_info['bus'] == 'scsi':
# The driver is responsible to create the SCSI controller
# at index 0.
conf.device_addr = vconfig.LibvirtConfigGuestDeviceAddressDrive()
conf.device_addr.controller = 0
if 'unit' in disk_info:
# In order to allow up to 256 disks handled by one
# virtio-scsi controller, the device addr should be
# specified.
conf.device_addr.unit = disk_info['unit']
if connection_info.get('multiattach', False):
# Note that driver_cache should be disabled (none) when using
# a shareable disk.
conf.shareable = True
volume_id = connection_info.get('data', {}).get('volume_id')
volume_secret = None
if volume_id:
volume_secret = self.host.find_secret('volume', volume_id)
if volume_secret:
conf.encryption = vconfig.LibvirtConfigGuestDiskEncryption()
secret = vconfig.LibvirtConfigGuestDiskEncryptionSecret()
secret.type = 'passphrase'
secret.uuid = volume_secret.UUIDString()
conf.encryption.format = 'luks'
conf.encryption.secret = secret
return conf
def get_config(self, connection_info, disk_info):
"""Returns xml for libvirt."""
conf = vconfig.LibvirtConfigGuestDisk()
conf.driver_name = libvirt_utils.pick_disk_driver_name(
self.host.get_version(),
self.is_block_dev
)
conf.source_device = disk_info['type']
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.target_dev = disk_info['dev']
conf.target_bus = disk_info['bus']
conf.serial = connection_info.get('serial')
# Support for block size tuning
data = {}
if 'data' in connection_info:
data = connection_info['data']
if 'logical_block_size' in data:
conf.logical_block_size = data['logical_block_size']
if 'physical_block_size' in data:
conf.physical_block_size = data['physical_block_size']
# Extract rate_limit control parameters
if 'qos_specs' in data and data['qos_specs']:
tune_opts = ['total_bytes_sec', 'read_bytes_sec',
'write_bytes_sec', 'total_iops_sec',
'read_iops_sec', 'write_iops_sec',
'read_bytes_sec_max', 'read_iops_sec_max',
'write_bytes_sec_max', 'write_iops_sec_max',
'total_bytes_sec_max', 'total_iops_sec_max',
'size_iops_sec']
specs = data['qos_specs']
if isinstance(specs, dict):
for k, v in specs.items():
if k in tune_opts:
new_key = 'disk_' + k
setattr(conf, new_key, v)
else:
LOG.warning('Unknown content in connection_info/'
'qos_specs: %s', specs)
# Extract access_mode control parameters
if 'access_mode' in data and data['access_mode']:
access_mode = data['access_mode']
if access_mode in ('ro', 'rw'):
conf.readonly = access_mode == 'ro'
else:
LOG.error('Unknown content in '
'connection_info/access_mode: %s',
access_mode)
raise exception.InvalidVolumeAccessMode(
access_mode=access_mode)
# Configure usage of discard
if data.get('discard', False) is True:
conf.driver_discard = 'unmap'
if disk_info['bus'] == 'scsi':
# The driver is responsible to create the SCSI controller
# at index 0.
conf.device_addr = vconfig.LibvirtConfigGuestDeviceAddressDrive()
conf.device_addr.controller = 0
if 'unit' in disk_info:
# In order to allow up to 256 disks handled by one
# virtio-scsi controller, the device addr should be
# specified.
conf.device_addr.unit = disk_info['unit']
if connection_info.get('multiattach', False):
# Note that driver_cache should be disabled (none) when using
# a shareable disk.
conf.shareable = True
volume_id = driver_block_device.get_volume_id(connection_info)
volume_secret = None
if volume_id:
volume_secret = self.host.find_secret('volume', volume_id)
if volume_secret:
conf.encryption = vconfig.LibvirtConfigGuestDiskEncryption()
secret = vconfig.LibvirtConfigGuestDiskEncryptionSecret()
secret.type = 'passphrase'
secret.uuid = volume_secret.UUIDString()
conf.encryption.format = 'luks'
conf.encryption.secret = secret
return conf
def test_pick_disk_driver_name_xen_4_0_0(self):
self.flags(virt_type="xen", group='libvirt')
result = libvirt_utils.pick_disk_driver_name(4000000, False)
self.assertEqual(result, "tap")
def get_config(self, connection_info, disk_info):
"""Returns xml for libvirt."""
conf = vconfig.LibvirtConfigGuestDisk()
conf.driver_name = libvirt_utils.pick_disk_driver_name(
self.connection._host.get_version(), self.is_block_dev)
conf.source_device = disk_info['type']
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.target_dev = disk_info['dev']
conf.target_bus = disk_info['bus']
conf.serial = connection_info.get('serial')
# Support for block size tuning
data = {}
if 'data' in connection_info:
data = connection_info['data']
if 'logical_block_size' in data:
conf.logical_block_size = data['logical_block_size']
if 'physical_block_size' in data:
conf.physical_block_size = data['physical_block_size']
# Extract rate_limit control parameters
if 'qos_specs' in data and data['qos_specs']:
tune_opts = [
'total_bytes_sec', 'read_bytes_sec', 'write_bytes_sec',
'total_iops_sec', 'read_iops_sec', 'write_iops_sec'
]
specs = data['qos_specs']
if isinstance(specs, dict):
for k, v in six.iteritems(specs):
if k in tune_opts:
new_key = 'disk_' + k
setattr(conf, new_key, v)
else:
LOG.warning(
_LW('Unknown content in connection_info/'
'qos_specs: %s'), specs)
# Extract access_mode control parameters
if 'access_mode' in data and data['access_mode']:
access_mode = data['access_mode']
if access_mode in ('ro', 'rw'):
conf.readonly = access_mode == 'ro'
else:
LOG.error(
_LE('Unknown content in '
'connection_info/access_mode: %s'), access_mode)
raise exception.InvalidVolumeAccessMode(
access_mode=access_mode)
# Configure usage of discard
if data.get('discard', False) is True:
min_qemu = nova.virt.libvirt.driver.MIN_QEMU_DISCARD_VERSION
min_libvirt = nova.virt.libvirt.driver.MIN_LIBVIRT_DISCARD_VERSION
if self.connection._host.has_min_version(min_libvirt, min_qemu,
host.HV_DRIVER_QEMU):
conf.driver_discard = 'unmap'
else:
global SHOULD_LOG_DISCARD_WARNING
if SHOULD_LOG_DISCARD_WARNING:
SHOULD_LOG_DISCARD_WARNING = False
LOG.warning(
_LW('Unable to attach %(type)s volume '
'%(serial)s with discard enabled: qemu '
'%(qemu)s and libvirt %(libvirt)s or '
'later are required.'), {
'qemu': min_qemu,
'libvirt': min_libvirt,
'serial': conf.serial,
'type': connection_info['driver_volume_type']
})
return conf
def get_config(self, connection_info, disk_info):
"""Returns xml for libvirt."""
conf = vconfig.LibvirtConfigGuestDisk()
conf.driver_name = libvirt_utils.pick_disk_driver_name(self.connection._host.get_version(), self.is_block_dev)
conf.source_device = disk_info["type"]
conf.driver_format = "raw"
conf.driver_cache = "none"
conf.target_dev = disk_info["dev"]
conf.target_bus = disk_info["bus"]
conf.serial = connection_info.get("serial")
# Support for block size tuning
data = {}
if "data" in connection_info:
data = connection_info["data"]
if "logical_block_size" in data:
conf.logical_block_size = data["logical_block_size"]
if "physical_block_size" in data:
conf.physical_block_size = data["physical_block_size"]
# Extract rate_limit control parameters
if "qos_specs" in data and data["qos_specs"]:
tune_opts = [
"total_bytes_sec",
"read_bytes_sec",
"write_bytes_sec",
"total_iops_sec",
"read_iops_sec",
"write_iops_sec",
]
specs = data["qos_specs"]
if isinstance(specs, dict):
for k, v in six.iteritems(specs):
if k in tune_opts:
new_key = "disk_" + k
setattr(conf, new_key, v)
else:
LOG.warning(_LW("Unknown content in connection_info/" "qos_specs: %s"), specs)
# Extract access_mode control parameters
if "access_mode" in data and data["access_mode"]:
access_mode = data["access_mode"]
if access_mode in ("ro", "rw"):
conf.readonly = access_mode == "ro"
else:
LOG.error(_LE("Unknown content in " "connection_info/access_mode: %s"), access_mode)
raise exception.InvalidVolumeAccessMode(access_mode=access_mode)
# Configure usage of discard
if data.get("discard", False) is True:
min_qemu = nova.virt.libvirt.driver.MIN_QEMU_DISCARD_VERSION
min_libvirt = nova.virt.libvirt.driver.MIN_LIBVIRT_DISCARD_VERSION
if self.connection._host.has_min_version(min_libvirt, min_qemu, host.HV_DRIVER_QEMU):
conf.driver_discard = "unmap"
else:
global SHOULD_LOG_DISCARD_WARNING
if SHOULD_LOG_DISCARD_WARNING:
SHOULD_LOG_DISCARD_WARNING = False
LOG.warning(
_LW(
"Unable to attach %(type)s volume "
"%(serial)s with discard enabled: qemu "
"%(qemu)s and libvirt %(libvirt)s or "
"later are required."
),
{
"qemu": min_qemu,
"libvirt": min_libvirt,
"serial": conf.serial,
"type": connection_info["driver_volume_type"],
},
)
return conf
