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_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 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 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 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