def create_ccw_addr_disk(params): """ Create one ccw address disk :param params: dict wrapped with params """ type_name = params.get("type_name") disk_device = params.get("device_type") device_target = params.get("target_dev") device_bus = params.get("target_bus") device_format = params.get("target_format") source_file_path = params.get("virt_disk_device_source") disk_src_dict = {"attrs": {"file": source_file_path}} addr_str = params.get("addr_attrs") if source_file_path: libvirt.create_local_disk("file", source_file_path, 1, device_format) ccw_addr_disk = libvirt_disk.create_primitive_disk_xml( type_name, disk_device, device_target, device_bus, device_format, disk_src_dict, None) if addr_str: addr_dict = eval(addr_str) ccw_addr_disk.address = ccw_addr_disk.new_disk_address( **{"attrs": addr_dict}) logging.debug("create_ccw_addr_disk xml: %s", ccw_addr_disk) return ccw_addr_disk
def create_same_pci_slot_disk(params): """ Create disk with existed pci slot :param params: dict wrapped with params """ type_name = params.get("type_name") disk_device = params.get("device_type") device_target = params.get("target_dev") device_bus = params.get("target_bus") device_format = params.get("target_format") source_file_path = params.get("virt_disk_device_source") disk_src_dict = {"attrs": {"file": source_file_path}} vm_name = params.get("main_vm") if source_file_path: libvirt.create_local_disk("file", source_file_path, 1, device_format) pci_slot_addr_disk = libvirt_disk.create_primitive_disk_xml( type_name, disk_device, device_target, device_bus, device_format, disk_src_dict, None) # Get existed disk address addr = vm_xml.VMXML.get_disk_address(vm_name, 'vda') if not addr: raise Exception("Failed to get vda disk address") pci_addr_dict = tr_pci_address_to_dict(addr) pci_slot_addr_disk.address = pci_slot_addr_disk.new_disk_address( **{"attrs": pci_addr_dict}) logging.debug("create_pci_slot_addr_disk xml: %s", pci_slot_addr_disk) return pci_slot_addr_disk
def setup_file_backend_env(params): """ Setup iscsi test environment :param params: one dict to wrap up parameters """ vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name) type_name = params.get("virt_disk_device_type") disk_device = params.get("virt_disk_device") device_target = params.get("virt_disk_device_target") device_bus = params.get("virt_disk_device_bus") device_format = params.get("virt_disk_device_format") blockcopy_image_name = params.get("blockcopy_image_name") emulated_size = int(params.get("emulated_size", "2")) libvirt.create_local_disk("file", blockcopy_image_name, emulated_size, "qcow2") disk_src_dict = {"attrs": {"file": blockcopy_image_name}} file_disk = libvirt_disk.create_primitive_disk_xml( type_name, disk_device, device_target, device_bus, device_format, disk_src_dict, None) logging.debug("guest xml after undefined and recreated:\n%s", file_disk) return file_disk
def setup_file_env(params): """ Setup file test environment :param params: one dict to wrap up parameters """ # If additional_disk is False, it means that there is no need to create additional disk if additional_disk is False: return vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name) backstore_image_target_path = params.get("backstore_image_name") tmp_blkpull_path.append(backstore_image_target_path) libvirt.create_local_disk("file", backstore_image_target_path, "1", "qcow2") backing_chain_list.append(backstore_image_target_path) disk_src_dict = {"attrs": {"file": backstore_image_target_path}} file_disk = libvirt_disk.create_primitive_disk_xml( type_name, disk_device, device_target, device_bus, device_format, disk_src_dict, None) logging.debug("disk xml is:\n%s" % file_disk) # Sync VM xml. vmxml.add_device(file_disk) vmxml.sync() _generate_backstore_attribute(params)
def create_vhostuser_disk(params): """ Create one vhost disk :param params: dict wrapped with params """ type_name = params.get("type_name") disk_device = params.get("device_type") device_target = params.get("target_dev") device_bus = params.get("target_bus") device_format = params.get("target_format") queues = params.get("queues", "1") sock_path = params.get("source_file") disk_src_dict = {"attrs": {"type": "unix", "path": sock_path}} vhostuser_disk = libvirt_disk.create_primitive_disk_xml( type_name, disk_device, device_target, device_bus, device_format, disk_src_dict, None) vhostuser_disk.snapshot = "no" device_model = params.get("model") if device_model: vhostuser_disk.model = device_model driver_dict = {"name": "qemu", "type": device_format, "queues": int(queues)} packed = params.get('packed') ats = params.get('ats') if packed: driver_dict.update({'packed': packed}) if ats: driver_dict.update({'ats': ats}) vhostuser_disk.driver = driver_dict return vhostuser_disk
def create_vhostuser_disk(params): """ Create one vhost disk :param params: dict wrapped with params """ type_name = params.get("type_name") disk_device = params.get("device_type") device_target = params.get("target_dev") device_bus = params.get("target_bus") device_format = params.get("target_format") queues = params.get("queues", "1") sock_path = params.get("source_file") disk_src_dict = {"attrs": {"type": "unix", "path": sock_path}} vhostuser_disk = libvirt_disk.create_primitive_disk_xml( type_name, disk_device, device_target, device_bus, device_format, disk_src_dict, None) vhostuser_disk.snapshot = "no" driver_dict = { "name": "qemu", "type": device_format, "queues": int(queues) } vhostuser_disk.driver = driver_dict return vhostuser_disk
def setup_nbd_env(params): """ Setup nbd test environment :param params: one dict to wrap up parameters """ vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name) # Get server hostname. hostname = process.run('hostname', ignore_status=False, shell=True, verbose=True).stdout_text.strip() # Setup backend storage nbd_server_host = hostname nbd_server_port = params.get("nbd_server_port", "10001") image_path = params.get("emulated_image", "/var/lib/libvirt/images/nbdtest.img") enable_ga_agent = "yes" == params.get("enable_ga_agent", "no") # Create NbdExport object nbd = NbdExport(image_path, image_format=device_format, port=nbd_server_port) nbd.start_nbd_server() # Prepare disk source xml source_attrs_dict = {"protocol": "nbd", "tls": "%s" % "no"} disk_src_dict = {} disk_src_dict.update({"attrs": source_attrs_dict}) disk_src_dict.update( {"hosts": [{ "name": nbd_server_host, "port": nbd_server_port }]}) network_disk = libvirt_disk.create_primitive_disk_xml( type_name, disk_device, device_target, device_bus, device_format, disk_src_dict, None) logging.debug("disk xml is:\n%s" % network_disk) # Sync VM xml. vmxml.add_device(network_disk) vmxml.sync() if enable_ga_agent: vm.prepare_guest_agent() vm.destroy(gracefully=False)
def create_customized_disk(params): """ Create one customized disk with related attributes :param params: dict wrapped with params """ type_name = params.get("type_name") disk_device = params.get("device_type") device_target = params.get("target_dev") device_bus = params.get("target_bus") device_format = params.get("target_format") source_file_path = params.get("virt_disk_device_source") source_dict = {} if source_file_path: cmd = "qemu-img create -f %s %s %s %s" % ( device_format, "-o preallocation=full", source_file_path, "100M") process.run(cmd, shell=True, ignore_status=True) cleanup_files.append(source_file_path) if 'block' in type_name: source_dict.update({"dev": source_file_path}) else: source_dict.update({"file": source_file_path}) disk_src_dict = {"attrs": source_dict} customized_disk = libvirt_disk.create_primitive_disk_xml( type_name, disk_device, device_target, device_bus, device_format, disk_src_dict, None) # Sometimes, slice size can be gotten by command (du -b source_file_path), but here not necessary disk_slice_attrs = params.get('disk_slice_attrs') if disk_slice_attrs: disk_source = customized_disk.source disk_source.slices = customized_disk.new_slices( **eval(disk_slice_attrs)) customized_disk.source = disk_source additional_driver_attrs = params.get("additional_driver_attrs") if additional_driver_attrs: customized_disk.driver = dict(customized_disk.driver, **eval(additional_driver_attrs)) if disk_device == "cdrom": customized_disk.readonly = True LOG.debug("create customized xml: %s", customized_disk) return customized_disk
def create_customized_disk(params): """ Create one customized disk with related attributes :param params: dict wrapped with params """ type_name = params.get("type_name") disk_device = params.get("device_type") device_target = params.get("target_dev") device_bus = params.get("target_bus") device_format = params.get("target_format") source_file_path = params.get("virt_disk_device_source") source_dict = {} if source_file_path: if 'block' in type_name: source_dict.update({"dev": source_file_path}) else: source_dict.update({"file": source_file_path}) startup_policy = params.get("startupPolicy") if startup_policy: source_dict.update({"startupPolicy": startup_policy}) disk_src_dict = {"attrs": source_dict} addr_str = params.get("addr_attrs") customized_disk = libvirt_disk.create_primitive_disk_xml( type_name, disk_device, device_target, device_bus, device_format, disk_src_dict, None) if addr_str: addr_dict = eval(addr_str) customized_disk.address = customized_disk.new_disk_address( **{"attrs": addr_dict}) target_tray = params.get("tray") if target_tray: customized_disk.target = dict(customized_disk.target, **{'tray': target_tray}) copy_on_read = params.get("copy_on_read") if copy_on_read: customized_disk.driver = dict(customized_disk.driver, **{'copy_on_read': copy_on_read}) LOG.debug("create customized xml: %s", customized_disk) return customized_disk
def setup_iscsi_block_env(params): """ Setup iscsi as block test environment :param params: one dict to wrap up parameters """ vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name) libvirt.setup_or_cleanup_iscsi(is_setup=False) emulated_size = params.get("emulated_size", "10G") chap_user = params.get("iscsi_user") chap_passwd = params.get("iscsi_password") auth_sec_usage_type = params.get("secret_usage_type") encoding = locale.getpreferredencoding() secret_string = base64.b64encode( chap_passwd.encode(encoding)).decode(encoding) device_source = libvirt.setup_or_cleanup_iscsi( is_setup=True, is_login=True, image_size=emulated_size, chap_user=chap_user, chap_passwd=chap_passwd, portal_ip="127.0.0.1") auth_sec_uuid = libvirt_ceph_utils._create_secret( auth_sec_usage_type, secret_string) disk_auth_dict = { "auth_user": chap_user, "secret_type": auth_sec_usage_type, "secret_uuid": auth_sec_uuid } disk_src_dict = {'attrs': {'dev': device_source}} iscsi_disk = libvirt_disk.create_primitive_disk_xml( type_name, disk_device, device_target, device_bus, device_format, disk_src_dict, disk_auth_dict) # Add disk xml. logging.debug("disk xml is:\n%s" % iscsi_disk) # Sync VM xml. vmxml.add_device(iscsi_disk) vmxml.sync()
def setup_block_env(params): """ Setup block test environment :param params: one dict to wrap up parameters """ if additional_disk is False: return vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name) device_source = libvirt.setup_or_cleanup_iscsi(is_setup=True) disk_src_dict = {'attrs': {'dev': device_source}} backing_chain_list.append(device_source) file_disk = libvirt_disk.create_primitive_disk_xml( type_name, disk_device, device_target, device_bus, device_format, disk_src_dict, None) logging.debug("disk xml is:\n%s" % file_disk) # Sync VM xml. vmxml.add_device(file_disk) vmxml.sync() _generate_backstore_attribute(params)
def run(test, params, env): """ Test <transient/> disks. 1.Prepare test environment, destroy VMs. 2.Perform 'qemu-img create' operation. 3.Edit disks xml and start the domains. 4.Perform test operation. 5.Recover test environment. 6.Confirm the test result. """ def check_transient_disk_keyword(vm_names): """ Check VM disk with TRANSIENT keyword. :param vm_names. VM names list. """ logging.info("Checking disk with transient keyword...") output0 = "" output1 = "" for i in list(range(2)): ret = virsh.dumpxml(vm_names[i], ignore_status=False) cmd = ("echo \"%s\" | grep '<source file=.*TRANSIENT.*/>'" % ret.stdout_text) if process.system(cmd, ignore_status=False, shell=True): test.fail("Check transident disk on %s failed" % vm_names[i]) if i == 0: output0 = astring.to_text( process.system_output(cmd, ignore_status=False, shell=True)) else: output1 = astring.to_text( process.system_output(cmd, ignore_status=False, shell=True)) if output0 == output1: test.fail("Two vms have same source transident disk %s" % output0) def check_share_transient_disk(vms_list): """ Check share base image of <transient/> disks. :param vms_list. VM object list. """ logging.info("Checking share base image of transient disk...") try: test_str = "teststring" sha_cmd = ("sha1sum /dev/%s" % disk_target) cmd = ("fdisk -l /dev/%s && mkfs.ext4 -F /dev/%s && mount /dev/%s" " /mnt && echo '%s' > /mnt/test && umount /mnt" % (disk_target, disk_target, disk_target, test_str)) # check on vm0. session0 = vms_list[0]['vm'].wait_for_login(timeout=10) s, o = session0.cmd_status_output(cmd) logging.debug("session in vm0 exit %s; output: %s", s, o) if s: session0.close() test.fail("Shared disk on vm0 doesn't work well") vm0_disk_sha1 = session0.cmd_output(sha_cmd) session0.close() vms_list[0]['vm'].destroy(gracefully=False) # check on vm1. session = vms_list[1]['vm'].wait_for_login(timeout=10) vm1_disk_sha1 = session.cmd_output(sha_cmd) if vm0_disk_sha1 == vm1_disk_sha1: session.close() test.fail( "Still can find file created in transient disk of vm0") s, o = session.cmd_status_output(cmd) logging.debug("session in vm1 exit %s; output: %s", s, o) if s: session.close() test.fail("Shared disk on vm1 doesn't work well") session.close() except (remote.LoginError, virt_vm.VMError, aexpect.ShellError) as e: logging.error(str(e)) test.error("Test transient disk shareable: login failed") vm_names = params.get("vms").split() if len(vm_names) < 2: test.cancel("No multi vms provided.") # Disk specific attributes. disk_bus = params.get("virt_disk_bus", "virtio") disk_target = params.get("virt_disk_target", "vdb") disk_type = params.get("virt_disk_type", "file") disk_device = params.get("virt_disk_device", "disk") disk_format = params.get("virt_disk_format", "qcow2") target_format = params.get("virt_target_format", "qcow2") hotplug = "yes" == params.get("virt_disk_vms_hotplug", "no") status_error = params.get("status_error").split() sharebacking = params.get("share_transient").split() on_reboot_destroy = "yes" == params.get("on_reboot_destroy", "no") disk_source_path = data_dir.get_data_dir() disk_path = "" libvirt_version.is_libvirt_feature_supported(params) # Backup vm xml files. vms_backup = [] # We just use 2 VMs for testing. for i in list(range(2)): vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_names[i]) vms_backup.append(vmxml_backup) # Initialize VM list vms_list = [] try: # Create disk images if needed. disks = [] image_size = params.get("image_size", "1G") disk_path = "%s/test.%s" % (disk_source_path, disk_format) disk_source = libvirt.create_local_disk("file", disk_path, image_size, disk_format=disk_format) disk_src_dict = {"attrs": {"file": disk_path}} disks.append({"format": disk_format, "source": disk_source}) # Compose the new domain xml for i in list(range(2)): vm = env.get_vm(vm_names[i]) # Destroy domain first. if vm.is_alive(): vm.destroy(gracefully=False) # Configure vm disk options and define vm vmxml = vm_xml.VMXML.new_from_dumpxml(vm_names[i]) disk_xml = libvirt_disk.create_primitive_disk_xml( disk_type, disk_device, disk_target, disk_bus, target_format, disk_src_dict, None) if sharebacking[i] == "yes": disk_xml.sharebacking = "yes" if on_reboot_destroy: vmxml.on_reboot = "destroy" else: disk_xml.transient = "yes" logging.debug("The disk xml is: %s" % disk_xml.xmltreefile) if not hotplug: # If we are not testing hotplug, # add disks to domain xml and sync. vmxml.add_device(disk_xml) logging.debug("vm xml is {}".format(vmxml)) vmxml.sync() vms_list.append({ "name": vm_names[i], "vm": vm, "status": "yes" == status_error[i], "disk": disk_xml }) logging.debug("vms_list %s" % vms_list) for i in list(range(len(vms_list))): try: # Try to start the domain. vms_list[i]['vm'].start() # Check if VM is started as expected. if not vms_list[i]['status']: test.fail('VM started unexpectedly.') session = vms_list[i]['vm'].wait_for_login() # if we are testing hotplug, it need to start domain and # then run virsh attach-device command. if hotplug: vms_list[i]['disk'].xmltreefile.write() result = virsh.attach_device(vms_list[i]['name'], vms_list[i]['disk'].xml, debug=True).exit_status os.remove(vms_list[i]['disk'].xml) # Check if the return code of attach-device # command is as expected. if 0 != result and vms_list[i]['status']: test.fail('Failed to hotplug disk device') elif 0 == result and not vms_list[i]['status']: test.fail('Hotplug disk device unexpectedly.') if i == 1: check_transient_disk_keyword(vm_names) check_share_transient_disk(vms_list) session.close() except virt_vm.VMStartError as start_error: if vms_list[i]['status']: test.fail("VM failed to start." "Error: %s" % str(start_error)) finally: # Stop VMs. for i in list(range(len(vms_list))): if vms_list[i]['vm'].is_alive(): vms_list[i]['vm'].destroy(gracefully=False) # Recover VMs. for vmxml_backup in vms_backup: vmxml_backup.sync() # Remove disks. for img in disks: if "source" in img: os.remove(img["source"])
def create_or_cleanup_ceph_backend_vm_disk(vm, params, is_setup=True): """ Setup vm ceph disk with given parameters :param vm: the vm object :param params: dict, dict include setup vm disk xml configurations :param is_setup: one parameter indicate whether setup or clean up """ vmxml = vm_xml.VMXML.new_from_dumpxml(vm.name) logging.debug("original xml is: %s", vmxml) # Device related configurations device_format = params.get("virt_disk_device_format", "raw") device_bus = params.get("virt_disk_device_bus", "virtio") device = params.get("virt_disk_device", "disk") device_target = params.get("virt_disk_device_target", "vdb") hotplug = "yes" == params.get("virt_disk_device_hotplug", "no") keep_raw_image_as = "yes" == params.get("keep_raw_image_as", "no") # Ceph related configurations ceph_mon_ip = params.get("ceph_mon_ip", "EXAMPLE_MON_HOST") ceph_host_port = params.get("ceph_host_port", "EXAMPLE_PORTS") ceph_disk_name = params.get("ceph_disk_name", "EXAMPLE_SOURCE_NAME") ceph_client_name = params.get("ceph_client_name") ceph_client_key = params.get("ceph_client_key") ceph_auth_user = params.get("ceph_auth_user") ceph_auth_key = params.get("ceph_auth_key") auth_sec_usage_type = params.get("ceph_auth_sec_usage_type", "ceph") storage_size = params.get("storage_size", "1G") img_file = params.get("ceph_image_file") attach_option = params.get("virt_device_attach_option", "--live") key_file = os.path.join(data_dir.get_tmp_dir(), "ceph.key") key_opt = "" is_local_img_file = True if img_file is None else False rbd_key_file = None # Prepare a blank params to confirm if delete the configure at the end of the test ceph_cfg = "" disk_auth_dict = None auth_sec_uuid = None names = ceph_disk_name.split('/') pool_name = names[0] image_name = names[1] if not utils_package.package_install(["ceph-common"]): raise exceptions.TestError("Failed to install ceph-common") # Create config file if it doesn't exist ceph_cfg = ceph.create_config_file(ceph_mon_ip) # If enable auth, prepare a local file to save key if ceph_client_name and ceph_client_key: with open(key_file, 'w') as f: f.write("[%s]\n\tkey = %s\n" % (ceph_client_name, ceph_client_key)) key_opt = "--keyring %s" % key_file rbd_key_file = key_file if is_setup: # If enable auth, prepare disk auth if ceph_client_name and ceph_client_key: auth_sec_uuid = _create_secret(auth_sec_usage_type, ceph_auth_key) disk_auth_dict = {"auth_user": ceph_auth_user, "secret_type": auth_sec_usage_type, "secret_uuid": auth_sec_uuid} # clean up image file if exists ceph.rbd_image_rm(ceph_mon_ip, pool_name, image_name, keyfile=rbd_key_file) #Create necessary image file if not exists _create_image(device_format, img_file, vm.name, storage_size, ceph_disk_name, ceph_mon_ip, key_opt, ceph_auth_user, ceph_auth_key) # Disk related config disk_src_dict = {"attrs": {"protocol": "rbd", "name": ceph_disk_name}, "hosts": [{"name": ceph_mon_ip, "port": ceph_host_port}]} # Create network disk disk_xml = libvirt_disk.create_primitive_disk_xml("network", device, device_target, device_bus, device_format, disk_src_dict, disk_auth_dict) if not keep_raw_image_as: if hotplug: virsh.attach_device(vm.name, disk_xml.xml, flagstr=attach_option, ignore_status=False, debug=True) else: vmxml = vm_xml.VMXML.new_from_dumpxml(vm.name) vmxml.add_device(disk_xml) vmxml.sync() else: ceph.rbd_image_rm(ceph_mon_ip, pool_name, image_name, keyfile=rbd_key_file) # Remove ceph config and key file if created. for file_path in [ceph_cfg, key_file]: if os.path.exists(file_path): os.remove(file_path) if is_local_img_file and img_file and os.path.exists(img_file): libvirt.delete_local_disk("file", img_file) if auth_sec_uuid: virsh.secret_undefine(auth_sec_uuid, ignore_status=True)