def run(test, params, env): """ Test migration of multi vms. """ vm_names = params.get("vms").split() if len(vm_names) < 2: raise error.TestNAError("No multi vms provided.") # Prepare parameters method = params.get("virsh_migrate_method") simultaneous = "yes" == params.get("simultaneous_migration", "no") jobabort = "yes" == params.get("virsh_migrate_jobabort", "no") options = params.get("virsh_migrate_options", "") status_error = "yes" == params.get("status_error", "no") #remote_migration = "yes" == params.get("remote_migration", "no") remote_host = params.get("remote_host", "DEST_HOSTNAME.EXAMPLE.COM") local_host = params.get("local_host", "SOURCE_HOSTNAME.EXAMPLE.COM") host_user = params.get("host_user", "root") host_passwd = params.get("host_password", "PASSWORD") desturi = libvirt_vm.get_uri_with_transport(transport="ssh", dest_ip=remote_host) srcuri = libvirt_vm.get_uri_with_transport(transport="ssh", dest_ip=local_host) # Don't allow the defaults. if srcuri.count('///') or srcuri.count('EXAMPLE'): raise error.TestNAError("The srcuri '%s' is invalid", srcuri) if desturi.count('///') or desturi.count('EXAMPLE'): raise error.TestNAError("The desturi '%s' is invalid", desturi) # Config ssh autologin for remote host ssh_key.setup_ssh_key(remote_host, host_user, host_passwd, port=22) # Prepare MigrationHelper instance helpers = [] for vm_name in vm_names: helper = MigrationHelper(vm_name, test, params, env) helper.set_virsh_instance() helper.set_migration_cmd(options, method, desturi) helpers.append(helper) for helper in helpers: vm = helper.vm if vm.is_dead(): vm.start() vm.wait_for_login() try: multi_migration(helpers, simultaneous=False, jobabort=False) finally: for helper in helpers: helper.virsh_instance.close_session() helper.cleanup_vm(srcuri, desturi) if not ret_migration: if not status_error: raise error.TestFail("Migration test failed.") if not ret_jobabort: if not status_error: raise error.TestFail("Abort migration failed.")
def setup_ssh(self): if self.password: try: self.ssh_ping() except error.AutoservSshPingHostError: ssh_key.setup_ssh_key(self.hostname, self.user, self.password, self.port)
def env_setup(ip): logging.debug("Setup env for %s" % ip) ssh_key.setup_ssh_key(hostname=ip, user=username, port=shell_port, password=password) ssh_cmd(ip, "service iptables stop") ssh_cmd(ip, "echo 1 > /proc/sys/net/ipv4/conf/all/arp_ignore") netperf_dir = os.path.join(os.environ["AUTODIR"], "tests/netperf2") for i in params.get("netperf_files").split(): remote.scp_to_remote(ip, shell_port, username, password, "%s/%s" % (netperf_dir, i), "/tmp/") ssh_cmd(ip, params.get("setup_cmd"))
def env_setup(ip): logging.debug("Setup env for %s" % ip) ssh_key.setup_ssh_key(hostname=ip, user=username, port=shell_port, password=password) ssh_cmd(ip, "service iptables stop") ssh_cmd(ip, "echo 1 > /proc/sys/net/ipv4/conf/all/arp_ignore") netperf_dir = os.path.join(os.environ['AUTODIR'], "tests/netperf2") for i in params.get("netperf_files").split(): remote.scp_to_remote(ip, shell_port, username, password, "%s/%s" % (netperf_dir, i), "/tmp/") ssh_cmd(ip, params.get("setup_cmd"))
def run(test, params, env): """ Test convert vm to ovirt """ args_dict = get_args_dict(params) hypervisor = args_dict.get('hypervisor') xen_ip = args_dict.get('xen_ip') xen_pwd = args_dict.get('xen_pwd') remote_node_user = args_dict.get('remote_node_user', 'root') vpx_pwd = args_dict.get('vpx_pwd') vpx_pwd_file = args_dict.get('vpx_pwd_file') address_cache = env.get('address_cache') if hypervisor == 'xen': # Set up ssh access using ssh-agent and authorized_keys ssh_key.setup_ssh_key(xen_ip, user=remote_node_user, port=22, password=xen_pwd) try: utils_misc.add_identities_into_ssh_agent() except: utils.run("ssh-agent -k") raise error.TestError("Failed to start 'ssh-agent'") if hypervisor == 'esx': fp = open(vpx_pwd_file, 'w') fp.write(vpx_pwd) fp.close() try: # Set libguestfs environment variable os.environ['LIBGUESTFS_BACKEND'] = 'direct' # Run virt-v2v command ret = utils_v2v.v2v_cmd(args_dict) logging.debug("virt-v2v verbose messages:\n%s", ret) if ret.exit_status != 0: raise error.TestFail("Convert VM failed") # Import the VM to oVirt Data Center from export domain if not utils_v2v.import_to_ovirt(params, address_cache): raise error.TestFail("Import VM failed") finally: if hypervisor == "xen": utils.run("ssh-agent -k") if hypervisor == "esx": utils.run("rm -rf %s" % vpx_pwd_file)
def v2v_cmd(params): """ Append cmd to 'virt-v2v' and execute, optionally return full results. :param params: A dictionary includes all of required parameters such as 'target', 'hypervisor' and 'hostname', etc. :return: stdout of command """ if V2V_EXEC is None: raise ValueError('Missing command: virt-v2v') target = params.get('target') hypervisor = params.get('hypervisor') hostname = params.get('hostname') username = params.get('username') password = params.get('password') uri_obj = Uri(hypervisor) # Return actual 'uri' according to 'hostname' and 'hypervisor' uri = uri_obj.get_uri(hostname) tgt_obj = Target(target, uri) # Return virt-v2v command line options based on 'target' and 'hypervisor' options = tgt_obj.get_cmd_options(params) # Convert a existing VM without or with connection authorization. if hypervisor == 'esx': build_esx_no_verify(params) elif hypervisor == 'xen' or hypervisor == 'kvm': # Setup ssh key for build connection without password. ssh_key.setup_ssh_key(hostname, user=username, port=22, password=password) else: pass # Construct a final virt-v2v command cmd = '%s %s' % (V2V_EXEC, options) logging.debug('%s' % cmd) cmd_result = utils.run(cmd, verbose=DEBUG) return cmd_result
def v2v_cmd(params): """ Append cmd to 'virt-v2v' and execute, optionally return full results. @param: params: A dictionary includes all of required parameters such as 'target', 'hypervisor' and 'hostname', etc. @return: stdout of command """ if V2V_EXEC is None: raise ValueError('Missing command: virt-v2v') target = params.get('target') hypervisor = params.get('hypervisor') hostname = params.get('hostname') username = params.get('username') password = params.get('password') uri_obj = v2v_utils.Uri(hypervisor) # Return actual 'uri' according to 'hostname' and 'hypervisor' uri = uri_obj.get_uri(hostname) tgt_obj = v2v_utils.Target(target, uri) # Return virt-v2v command line options based on 'target' and 'hypervisor' options = tgt_obj.get_cmd_options(params) # Convert a existing VM without or with connection authorization. if hypervisor == 'esx': v2v_utils.build_esx_no_verify(params) elif hypervisor == 'xen' or hypervisor == 'kvm': # Setup ssh key for build connection without password. ssh_key.setup_ssh_key(hostname, user=username, port=22, password=password) else: pass # Construct a final virt-v2v command cmd = '%s %s' % (V2V_EXEC, options) logging.debug('%s' % cmd) cmd_result = utils.run(cmd, verbose=DEBUG) return cmd_result
def mount_guestfs_with_sshfs(vms): """ Mount the guest filesystem with sshfs. """ guestmount_path = os.path.join(data_dir.get_tmp_dir(), "guestmount") if not (os.path.isdir(guestmount_path)): os.makedirs(guestmount_path) sshfs_cmd = "sshfs -o allow_other,direct_io " for vm in vms: specific_path = os.path.join(guestmount_path, str(vm.get_pid())) if not os.path.isdir(specific_path): os.makedirs(specific_path) ssh_key.setup_ssh_key(hostname=vm.get_address(), user=vm.params.get("username", ""), password=vm.params.get("password", ""), port=22) cmd = "%s %s:/ %s" % (sshfs_cmd, vm.get_address(), specific_path) result = utils.run(cmd, ignore_status=True) if result.exit_status: raise error.TestFail("Failed to use sshfs for guestmount.\n" "Detail:%s." % result) return guestmount_path
def run_convert_remote_vm(test, params, env): """ Convert a remote vm to local libvirt(KVM). """ # VM info vm_name = params.get("v2v_vm") # Remote host parameters remote_hostname = params.get("remote_hostname") username = params.get("username", "root") password = params.get("password") remote_hypervisor = params.get("remote_hypervisor") # Local pool parameters pool_type = params.get("pool_type", "dir") pool_name = params.get("pool_name", "v2v_test") target_path = params.get("target_path", "pool_path") block_device = params.get("block_device") vg_name = params.get("volume_group_name", "vg_v2v") # If target_path is not an abs path, join it to test.tmpdir if os.path.dirname(target_path) is "": target_path = os.path.join(test.tmpdir, target_path) # dir pool need an exist path if pool_type == "dir": if not os.path.exists(target_path): os.mkdir(target_path) # V2V parameters input = params.get("input_method") files = params.get("config_files") network = params.get("network", "default") # Result check about ignore_virtio = "yes" == params.get("ignore_virtio", "no") # Create remote uri for remote host # Remote virt-v2v uri's instance ruri = utils_v2v.Uri(remote_hypervisor) remote_uri = ruri.get_uri(remote_hostname) ssh_key.setup_ssh_key(remote_hostname, user=username, port=22, password=password) # Check remote vms remote_vm = libvirt_vm.VM(vm_name, params, test.bindir, env.get("address_cache")) remote_vm.connect_uri = remote_uri if not remote_vm.exists(): raise error.TestFail("Couldn't find vm '%s' to be converted " "on remote uri '%s'." % (vm_name, remote_uri)) # Remote storage pool's instance rsp = libvirt_storage.StoragePool(remote_uri) # Put remote vm's disk into a directory storage pool prepare_remote_sp(rsp, remote_vm, pool_name) # Local storage pool's instance lsp = libvirt_storage.StoragePool() try: # Create storage pool for test if pool_type == "dir": if not create_dir_pool(lsp, pool_name, target_path): raise error.TestFail("Prepare directory storage pool for " "virt-v2v failed.") elif pool_type == "partition": if not create_partition_pool(lsp, pool_name, block_device, target_path): raise error.TestFail("Prepare partition storage pool for " "virt-v2v failed.") elif pool_type == "lvm": if not create_lvm_pool(lsp, pool_name, block_device, vg_name, target_path): raise error.TestFail("Preapre lvm storage pool for " "virt-v2v failed.") # Maintain a single params for v2v to avoid duplicate parameters v2v_params = {"hostname": remote_hostname, "username": username, "password": password, "hypervisor": remote_hypervisor, "storage": pool_name, "network": network, "target": "libvirt", "vms": vm_name, "input": input, "files": files} try: result = utils_v2v.v2v_cmd(v2v_params) except error.CmdError: raise error.TestFail("Virt v2v failed.") # v2v may be successful, but devices' driver may be not virtio error_info = [] # Check v2v vm on local host # Update parameters for local hypervisor and vm params['vms'] = vm_name params['target'] = "libvirt" vm_check = utils_v2v.LinuxVMCheck(test, params, env) if not vm_check.is_disk_virtio(): error_info.append("Error:disk type was not converted to virtio.") if not vm_check.is_net_virtio(): error_info.append("Error:nic type was not converted to virtio.") # Close vm for cleanup if vm_check.vm is not None and vm_check.vm.is_alive(): vm_check.vm.destroy() if not ignore_virtio and len(error_info): raise error.TestFail(error_info) finally: cleanup_vm(vm_name) lsp.delete_pool(pool_name) rsp.delete_pool(pool_name)
def run(test, params, env): """ Test command: migrate-compcache <domain> [--size <number>] 1) Run migrate-compcache command and check return code. """ vm_ref = params.get("vm_ref", "name") vm_name = params.get('main_vm') start_vm = 'yes' == params.get('start_vm', 'yes') pause_vm = 'yes' == params.get('pause_after_start_vm', 'no') expect_succeed = 'yes' == params.get('expect_succeed', 'yes') size_option = params.get('size_option', 'valid') action = params.get('compcache_action', 'get') vm = env.get_vm(vm_name) # Check if the virsh command migrate-compcache is available if not virsh.has_help_command('migrate-compcache'): raise error.TestNAError("This version of libvirt does not support " "virsh command migrate-compcache") # Prepare the VM state if it's not correct. if start_vm and not vm.is_alive(): vm.start() elif not start_vm and vm.is_alive(): vm.destroy() if pause_vm and not vm.is_paused(): vm.pause() # Setup domain reference if vm_ref == 'domname': vm_ref = vm_name # Setup size according to size_option: # minimal: Same as memory page size # maximal: Same as guest memory # empty: An empty string # small: One byte less than page size # large: Larger than guest memory # huge : Largest int64 page_size = get_page_size() if size_option == 'minimal': size = str(page_size) elif size_option == 'maximal': size = str(vm.get_max_mem() * 1024) elif size_option == 'empty': size = '""' elif size_option == 'small': size = str(page_size - 1) elif size_option == 'large': # Guest memory is larger than the max mem set, # add 50MB to ensure size exceeds guest memory. size = str(vm.get_max_mem() * 1024 + 50000000) elif size_option == 'huge': size = str(2**64 - 1) else: size = size_option # If we need to get, just omit the size option if action == 'get': size = None # Run testing command result = virsh.migrate_compcache(vm_ref, size=size) logging.debug(result) remote_uri = params.get("jobabort_remote_uri") remote_host = params.get("migrate_dest_host") remote_user = params.get("migrate_dest_user", "root") remote_pwd = params.get("migrate_dest_pwd") check_job_compcache = False if not remote_host.count( "EXAMPLE") and size is not None and expect_succeed: # Config ssh autologin for remote host ssh_key.setup_ssh_key(remote_host, remote_user, remote_pwd, port=22) if vm.is_dead(): vm.start() if vm.is_paused(): vm.resume() vm.wait_for_login() # Do actual migration to verify compression cache of migrate jobs command = "virsh migrate %s %s --compressed" % (vm_name, remote_uri) p = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) # Give enough time for starting job t = 0 while t < 5: jobtype = vm.get_job_type() if "None" == jobtype: t += 1 time.sleep(1) continue elif jobtype is False: logging.error("Get job type failed.") break else: logging.debug("Job started: %s", jobtype) break jobinfo = virsh.domjobinfo(vm_ref, debug=True, ignore_status=True).stdout check_job_compcache = True if p.poll(): try: p.kill() except OSError: pass # Cleanup in case of successful migration utlv.MigrationTest().cleanup_dest_vm(vm, None, remote_uri) # Shut down the VM to make sure the compcache setting cleared if vm.is_alive(): vm.destroy() # Check test result if expect_succeed: if result.exit_status != 0: raise error.TestFail( 'Expected succeed, but failed with result:\n%s' % result) if check_job_compcache: for line in jobinfo.splitlines(): detail = line.split(":") if detail[0].count("Compression cache"): value = detail[-1].split()[0].strip() value = int(float(value)) unit = detail[-1].split()[-1].strip() if unit == "KiB": size = int(int(size) / 1024) elif unit == "MiB": size = int(int(size) / 1048576) elif unit == "GiB": size = int(int(size) / 1073741824) if value != size: raise error.TestFail("Compression cache is not match" " with setted") else: return raise error.TestFail("Get compression cahce in job failed.") elif not expect_succeed: if result.exit_status == 0: raise error.TestFail( 'Expected fail, but succeed with result:\n%s' % result)
def run(test, params, env): """ Convert a remote vm to local libvirt(KVM). """ # VM info xen_vm_name = params.get("v2v_xen_vm") vmware_vm_name = params.get("v2v_vmware_vm") # Remote host parameters xen_ip = params.get("remote_xen_ip", "XEN.EXAMPLE") vmware_ip = params.get("remote_vmware_ip", "VMWARE.EXAMPLE") username = params.get("username", "root") xen_pwd = params.get("remote_xen_pwd", "PWD.EXAMPLE") vmware_pwd = params.get("remote_vmware_pwd", "PWD.EXAMPLE") # To decide which type test it is remote_hypervisor = params.get("remote_hypervisor") # Local pool parameters pool_type = params.get("pool_type", "dir") pool_name = params.get("pool_name", "v2v_test") target_path = params.get("target_path", "pool_path") emulated_img = params.get("emulated_image_path", "v2v_emulated.img") emulated_size = params.get("emulated_image_size", "10G") # If target_path is not an abs path, join it to data_dir.tmpdir if os.path.dirname(target_path) is "": target_path = os.path.join(data_dir.get_tmp_dir(), target_path) # V2V parameters input = params.get("input_method") files = params.get("config_files") network = params.get("network") bridge = params.get("bridge") # Result check about ignore_virtio = "yes" == params.get("ignore_virtio", "no") # Create autologin to remote host esx_netrc = params.get("esx_netrc") % (vmware_ip, username, vmware_pwd) params['netrc'] = esx_netrc if remote_hypervisor == "esx": remote_ip = vmware_ip remote_pwd = vmware_pwd vm_name = vmware_vm_name if remote_ip.count("EXAMPLE") or remote_pwd.count("EXAMPLE"): raise error.TestNAError("Please provide host or password for " "vmware test.") utils_v2v.build_esx_no_verify(params) else: remote_ip = xen_ip remote_pwd = xen_pwd vm_name = xen_vm_name if remote_ip.count("EXAMPLE") or remote_pwd.count("EXAMPLE"): raise error.TestNAError("Please provide host or password for " "xen test.") ssh_key.setup_ssh_key(xen_ip, user=username, port=22, password=xen_pwd) # Create remote uri for remote host # Remote virt-v2v uri's instance ruri = utils_v2v.Uri(remote_hypervisor) remote_uri = ruri.get_uri(remote_ip) # Check remote vms rvirsh_dargs = { 'uri': remote_uri, 'remote_ip': remote_ip, 'remote_user': username, 'remote_pwd': remote_pwd } rvirsh = virsh.VirshPersistent(**rvirsh_dargs) if not rvirsh.domain_exists(vm_name): rvirsh.close_session() raise error.TestFail("Couldn't find vm '%s' to be converted " "on remote uri '%s'." % (vm_name, remote_uri)) if remote_hypervisor != "esx": remote_vm = libvirt_vm.VM(vm_name, params, test.bindir, env.get("address_cache")) remote_vm.connect_uri = remote_uri # Remote storage pool's instance rsp = libvirt_storage.StoragePool(rvirsh) # Put remote vm's disk into a directory storage pool prepare_remote_sp(rsp, remote_vm, pool_name) # Prepare local libvirt storage pool pvt = utlv.PoolVolumeTest(test, params) # Local storage pool's instance lsp = libvirt_storage.StoragePool() try: # Create storage pool for test pvt.pre_pool(pool_name, pool_type, target_path, emulated_img, emulated_size) logging.debug(lsp.pool_info(pool_name)) # Maintain a single params for v2v to avoid duplicate parameters v2v_params = { "hostname": remote_ip, "username": username, "password": remote_pwd, "hypervisor": remote_hypervisor, "storage": pool_name, "network": network, "bridge": bridge, "target": "libvirt", "vms": vm_name, "netrc": esx_netrc, "input": input, "files": files } try: result = utils_v2v.v2v_cmd(v2v_params) logging.debug(result) except error.CmdError, detail: raise error.TestFail("Virt v2v failed:\n%s" % str(detail)) # v2v may be successful, but devices' driver may be not virtio error_info = [] # Check v2v vm on local host # Update parameters for local hypervisor and vm logging.debug("XML info:\n%s", virsh.dumpxml(vm_name)) params['vms'] = vm_name params['target'] = "libvirt" vm_check = utils_v2v.LinuxVMCheck(test, params, env) try: if not vm_check.is_disk_virtio(): error_info.append("Error:disk type was not converted to " "virtio.") if not vm_check.is_net_virtio(): error_info.append("Error:nic type was not converted to " "virtio.") except (remote.LoginError, virt_vm.VMError), detail: error_info.append(str(detail))
# Connection to remote, init here for cleanup runner = None # Identify easy config. mistakes early warning_text = ("Migration VM %s URI %s appears problematic " "this may lead to migration problems. " "Consider specifying vm.connect_uri using " "fully-qualified network-based style.") if srcuri.count('///') or srcuri.count('EXAMPLE'): raise error.TestNAError(warning_text % ('source', srcuri)) if dsturi.count('///') or dsturi.count('EXAMPLE'): raise error.TestNAError(warning_text % ('destination', dsturi)) # Config auto-login to remote host for migration ssh_key.setup_ssh_key(remote_ip, username, host_pwd) sys_image = vm.get_first_disk_devices() sys_image_source = sys_image["source"] sys_image_info = utils_misc.get_image_info(sys_image_source) logging.debug("System image information:\n%s", sys_image_info) sys_image_fmt = sys_image_info["format"] created_img_path = os.path.join(os.path.dirname(sys_image_source), "vsmimages") migrate_in_advance = "yes" == params.get("migrate_in_advance", "no") status_error = "yes" == params.get("status_error", "no") if source_type == "file" and device_type == "lun": status_error = True
def run(test, params, env): """ Test command: migrate-compcache <domain> [--size <number>] 1) Run migrate-compcache command and check return code. """ vm_ref = params.get("vm_ref", "name") vm_name = params.get("migrate_main_vm") start_vm = "yes" == params.get("start_vm", "yes") pause_vm = "yes" == params.get("pause_after_start_vm", "no") expect_succeed = "yes" == params.get("expect_succeed", "yes") size_option = params.get("size_option", "valid") action = params.get("compcache_action", "get") vm = env.get_vm(vm_name) # Check if the virsh command migrate-compcache is available if not virsh.has_help_command("migrate-compcache"): raise error.TestNAError("This version of libvirt does not support " "virsh command migrate-compcache") # Prepare the VM state if it's not correct. if start_vm and not vm.is_alive(): vm.start() elif not start_vm and vm.is_alive(): vm.destroy() if pause_vm and not vm.is_paused(): vm.pause() # Setup domain reference if vm_ref == "domname": vm_ref = vm_name # Setup size according to size_option: # minimal: Same as memory page size # maximal: Same as guest memory # empty: An empty string # small: One byte less than page size # large: Larger than guest memory # huge : Largest int64 page_size = get_page_size() if size_option == "minimal": size = str(page_size) elif size_option == "maximal": size = str(vm.get_max_mem() * 1024) elif size_option == "empty": size = '""' elif size_option == "small": size = str(page_size - 1) elif size_option == "large": # Guest memory is larger than the max mem set, # add 50MB to ensure size exceeds guest memory. size = str(vm.get_max_mem() * 1024 + 50000000) elif size_option == "huge": size = str(2 ** 64 - 1) else: size = size_option # If we need to get, just omit the size option if action == "get": size = None # Run testing command result = virsh.migrate_compcache(vm_ref, size=size) logging.debug(result) remote_uri = params.get("compcache_remote_uri") remote_host = params.get("migrate_dest_host") remote_user = params.get("migrate_dest_user", "root") remote_pwd = params.get("migrate_dest_pwd") check_job_compcache = False compressed_size = None if not remote_host.count("EXAMPLE") and size is not None and expect_succeed: # Config ssh autologin for remote host ssh_key.setup_ssh_key(remote_host, remote_user, remote_pwd, port=22) if vm.is_dead(): vm.start() if vm.is_paused(): vm.resume() vm.wait_for_login() # Do actual migration to verify compression cache of migrate jobs command = "virsh migrate %s %s --compressed --unsafe --verbose" % (vm_name, remote_uri) logging.debug("Start migrating: %s", command) p = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) # Give enough time for starting job t = 0 while t < 5: jobinfo = virsh.domjobinfo(vm_ref, debug=True, ignore_status=True).stdout jobtype = "None" for line in jobinfo.splitlines(): key = line.split(":")[0] if key.count("type"): jobtype = line.split(":")[-1].strip() elif key.strip() == "Compression cache": compressed_size = line.split(":")[-1].strip() if "None" == jobtype or compressed_size is None: t += 1 time.sleep(1) continue else: check_job_compcache = True logging.debug("Job started: %s", jobtype) break if p.poll(): try: p.kill() except OSError: pass # Cleanup in case of successful migration utlv.MigrationTest().cleanup_dest_vm(vm, None, remote_uri) # Shut down the VM to make sure the compcache setting cleared if vm.is_alive(): vm.destroy() # Check test result if expect_succeed: if result.exit_status != 0: raise error.TestFail("Expected succeed, but failed with result:\n%s" % result) if check_job_compcache: value = compressed_size.split()[0].strip() unit = compressed_size.split()[-1].strip() value = int(float(value)) if unit == "KiB": size = int(int(size) / 1024) elif unit == "MiB": size = int(int(size) / 1048576) elif unit == "GiB": size = int(int(size) / 1073741824) if value != size: raise error.TestFail("Compression cache is not match" " with setted") else: return raise error.TestFail("Get compression cache in job failed.") else: logging.warn("The compressed size wasn't been verified " "during migration.") elif not expect_succeed: if result.exit_status == 0: raise error.TestFail("Expected fail, but succeed with result:\n%s" % result)
def run(test, params, env): """ Test various options of virt-v2v. """ if utils_v2v.V2V_EXEC is None: raise ValueError('Missing command: virt-v2v') vm_name = params.get("main_vm", "EXAMPLE") new_vm_name = params.get("new_vm_name") input_mode = params.get("input_mode") v2v_options = params.get("v2v_options", "EXAMPLE") hypervisor = params.get("hypervisor", "kvm") remote_host = params.get("remote_host", "EXAMPLE") vpx_dc = params.get("vpx_dc", "EXAMPLE") esx_ip = params.get("esx_ip", "EXAMPLE") vpx_passwd = params.get("vpx_passwd", "EXAMPLE") ovirt_engine_url = params.get("ovirt_engine_url", "EXAMPLE") ovirt_engine_user = params.get("ovirt_engine_user", "EXAMPLE") ovirt_engine_passwd = params.get("ovirt_engine_password", "EXAMPLE") output_mode = params.get("output_mode") output_storage = params.get("output_storage", "default") export_name = params.get("export_name", "EXAMPLE") storage_name = params.get("storage_name", "EXAMPLE") disk_img = params.get("input_disk_image") nfs_storage = params.get("nfs_storage") mnt_point = params.get("mount_point") export_domain_uuid = params.get("export_domain_uuid", "") fake_domain_uuid = params.get("fake_domain_uuid") vdsm_image_uuid = params.get("vdsm_image_uuid") vdsm_vol_uuid = params.get("vdsm_vol_uuid") vdsm_vm_uuid = params.get("vdsm_vm_uuid") vdsm_ovf_output = params.get("vdsm_ovf_output") v2v_user = params.get("unprivileged_user", "") v2v_timeout = int(params.get("v2v_timeout", 1200)) status_error = "yes" == params.get("status_error", "no") address_cache = env.get('address_cache') for param in [vm_name, remote_host, esx_ip, vpx_dc, ovirt_engine_url, ovirt_engine_user, ovirt_engine_passwd, output_storage, export_name, storage_name, disk_img, export_domain_uuid, v2v_user]: if "EXAMPLE" in param: raise error.TestNAError("Please replace %s with real value" % param) su_cmd = "su - %s -c " % v2v_user output_uri = params.get("oc_uri", "") pool_name = params.get("pool_name", "v2v_test") pool_type = params.get("pool_type", "dir") pool_target = params.get("pool_target_path", "v2v_pool") emulated_img = params.get("emulated_image_path", "v2v-emulated-img") pvt = utlv.PoolVolumeTest(test, params) global vm_imported vm_imported = False new_v2v_user = False restore_image_owner = False def create_pool(): """ Create libvirt pool as the output storage """ if output_uri == "qemu:///session": target_path = os.path.join("/home", v2v_user, pool_target) cmd = su_cmd + "'mkdir %s'" % target_path utils.system(cmd, verbose=True) cmd = su_cmd + "'virsh pool-create-as %s dir" % pool_name cmd += " --target %s'" % target_path utils.system(cmd, verbose=True) else: pvt.pre_pool(pool_name, pool_type, pool_target, emulated_img) def cleanup_pool(): """ Clean up libvirt pool """ if output_uri == "qemu:///session": cmd = su_cmd + "'virsh pool-destroy %s'" % pool_name utils.system(cmd, verbose=True) target_path = os.path.join("/home", v2v_user, pool_target) cmd = su_cmd + "'rm -rf %s'" % target_path utils.system(cmd, verbose=True) else: pvt.cleanup_pool(pool_name, pool_type, pool_target, emulated_img) def get_all_uuids(output): """ Get export domain uuid, image uuid and vol uuid from command output. """ tmp_target = re.findall(r"qemu-img\sconvert\s.+\s'(\S+)'\n", output) if len(tmp_target) != 1: raise error.TestError("Fail to find tmp target file name when" " converting vm disk image") targets = tmp_target[0].split('/') return (targets[3], targets[5], targets[6]) def get_ovf_content(output): """ Find and read ovf file. """ export_domain_uuid, _, vol_uuid = get_all_uuids(output) export_vm_dir = os.path.join(mnt_point, export_domain_uuid, 'master/vms') ovf_content = "" if os.path.isdir(export_vm_dir): ovf_id = "ovf:id='%s'" % vol_uuid ret = utils.system_output("grep -R \"%s\" %s" % (ovf_id, export_vm_dir)) ovf_file = ret.split(":")[0] if os.path.isfile(ovf_file): ovf_f = open(ovf_file, "r") ovf_content = ovf_f.read() ovf_f.close() else: logging.error("Can't find ovf file to read") return ovf_content def get_img_path(output): """ Get the full path of the converted image. """ img_path = "" img_name = vm_name + "-sda" if output_mode == "libvirt": img_path = virsh.vol_path(img_name, output_storage).stdout.strip() elif output_mode == "local": img_path = os.path.join(output_storage, img_name) elif output_mode in ["rhev", "vdsm"]: export_domain_uuid, image_uuid, vol_uuid = get_all_uuids(output) img_path = os.path.join(mnt_point, export_domain_uuid, 'images', image_uuid, vol_uuid) return img_path def check_vmtype(ovf, expected_vmtype): """ Verify vmtype in ovf file. """ if output_mode != "rhev": return if expected_vmtype == "server": vmtype_int = 1 elif expected_vmtype == "desktop": vmtype_int = 0 else: return if "<VmType>%s</VmType>" % vmtype_int in ovf: logging.info("Find VmType=%s in ovf file", expected_vmtype) else: raise error.TestFail("VmType check failed") def check_image(output, check_point, expected_value): """ Verify converted image file allocation mode and format """ img_path = get_img_path(output) if not img_path or not os.path.isfile(img_path): logging.error("Fail to get image path: %s", img_path) return img_info = utils_misc.get_image_info(img_path) logging.info("Image info after converted: %s", img_info) if check_point == "allocation": if expected_value == "sparse": if img_info['vsize'] > img_info['dsize']: logging.info("Image file is sparse") else: raise error.TestFail("Image allocation check fail") elif expected_value == "preallocated": if img_info['vsize'] <= img_info['dsize']: logging.info("Image file is preallocated") else: raise error.TestFail("Image allocation check fail") if check_point == "format": if expected_value == img_info['format']: logging.info("Image file format is %s", expected_value) else: raise error.TestFail("Image format check fail") def check_new_name(output, expected_name): """ Verify guest name changed to the new name. """ found = False if output_mode == "libvirt": found = virsh.domain_exists(expected_name) if output_mode == "local": found = os.path.isfile(os.path.join(output_storage, expected_name + "-sda")) if output_mode in ["rhev", "vdsm"]: ovf = get_ovf_content(output) found = "<Name>%s</Name>" % expected_name in ovf else: return if found: logging.info("Guest name renamed when converting it") else: raise error.TestFail("Rename guest failed") def check_nocopy(output): """ Verify no image created if convert command use --no-copy option """ img_path = get_img_path(output) if not os.path.isfile(img_path): logging.info("No image created with --no-copy option") else: raise error.TestFail("Find %s" % img_path) def check_connection(output, expected_uri): """ Check output connection uri used when converting guest """ init_msg = "Initializing the target -o libvirt -oc %s" % expected_uri if init_msg in output: logging.info("Find message: %s", init_msg) else: raise error.TestFail("Not find message: %s" % init_msg) def check_result(cmd, result, status_error): """ Check virt-v2v command result """ utlv.check_exit_status(result, status_error) output = result.stdout + result.stderr if not status_error: if output_mode == "rhev": ovf = get_ovf_content(output) logging.debug("ovf content: %s", ovf) if '--vmtype' in cmd: expected_vmtype = re.findall(r"--vmtype\s(\w+)", cmd)[0] check_vmtype(ovf, expected_vmtype) if '-oa' in cmd and '--no-copy' not in cmd: expected_mode = re.findall(r"-oa\s(\w+)", cmd)[0] check_image(output, "allocation", expected_mode) if '-of' in cmd and '--no-copy' not in cmd: expected_format = re.findall(r"-of\s(\w+)", cmd)[0] check_image(output, "format", expected_format) if '-on' in cmd: expected_name = re.findall(r"-on\s(\w+)", cmd)[0] check_new_name(output, expected_name) if '--no-copy' in cmd: check_nocopy(output) if '-oc' in cmd: expected_uri = re.findall(r"-oc\s(\S+)", cmd)[0] check_connection(output, expected_uri) global vm_imported if output_mode == "rhev": if not utils_v2v.import_vm_to_ovirt(params, address_cache): raise error.TestFail("Import VM failed") else: vm_imported = True if output_mode == "libvirt": if "qemu:///session" not in v2v_options: virsh.start(vm_name, debug=True, ignore_status=False) try: # Build input options input_option = "" if input_mode is None: pass elif input_mode == "libvirt": uri_obj = utils_v2v.Uri(hypervisor) ic_uri = uri_obj.get_uri(remote_host, vpx_dc, esx_ip) input_option = "-i %s -ic %s %s" % (input_mode, ic_uri, vm_name) # Build network/bridge option v2v_options += " -b %s -n %s" % (params.get("output_bridge"), params.get("output_network")) elif input_mode == "disk": input_option += "-i %s %s" % (input_mode, disk_img) elif input_mode in ['libvirtxml', 'ova']: raise error.TestNAError("Unsupported input mode: %s" % input_mode) else: raise error.TestError("Unknown input mode %s" % input_mode) # Build output options output_option = "" if output_mode: output_option = "-o %s -os %s" % (output_mode, output_storage) # Build vdsm related options vdsm_domain_dir, vdsm_image_dir, vdsm_vm_dir = ("", "", "") if output_mode in ['vdsm', 'rhev']: if not os.path.isdir(mnt_point): os.mkdir(mnt_point) if not utils_misc.mount(nfs_storage, mnt_point, "nfs"): raise error.TestError("Mount NFS Failed") if output_mode == 'vdsm': v2v_options += " --vdsm-image-uuid %s" % vdsm_image_uuid v2v_options += " --vdsm-vol-uuid %s" % vdsm_vol_uuid v2v_options += " --vdsm-vm-uuid %s" % vdsm_vm_uuid v2v_options += " --vdsm-ovf-output %s" % vdsm_ovf_output vdsm_domain_dir = os.path.join(mnt_point, fake_domain_uuid) vdsm_image_dir = os.path.join(mnt_point, export_domain_uuid, "images", vdsm_image_uuid) vdsm_vm_dir = os.path.join(mnt_point, export_domain_uuid, "master/vms", vdsm_vm_uuid) # For vdsm_domain_dir, just create a dir to test BZ#1176591 os.mkdir(vdsm_domain_dir) os.mkdir(vdsm_image_dir) os.mkdir(vdsm_vm_dir) # Output more messages v2v_options += " -v -x" # Prepare for libvirt unprivileged user session connection if "qemu:///session" in v2v_options: try: pwd.getpwnam(v2v_user) except KeyError: # create new user utils.system("useradd %s" % v2v_user, ignore_status=True) new_v2v_user = True user_info = pwd.getpwnam(v2v_user) logging.info("Convert to qemu:///session by user '%s'", v2v_user) if input_mode == "disk": # Change the image owner and group ori_owner = os.stat(disk_img).st_uid ori_group = os.stat(disk_img).st_uid os.chown(disk_img, user_info.pw_uid, user_info.pw_gid) restore_image_owner = True else: raise error.TestNAError("Only support convert local disk") # Setup ssh-agent access to xen hypervisor if hypervisor == 'xen': os.environ['LIBGUESTFS_BACKEND'] = 'direct' user = params.get("xen_host_user", "root") passwd = params.get("xen_host_passwd", "redhat") logging.info("set up ssh-agent access ") ssh_key.setup_ssh_key(remote_host, user=user, port=22, password=passwd) utils_misc.add_identities_into_ssh_agent() # If the input format is not define, we need to either define # the original format in the source metadata(xml) or use '-of' # to force the output format, see BZ#1141723 for detail. if '-of' not in v2v_options: v2v_options += ' -of %s' % params.get("default_output_format", "qcow2") # Create password file for access to ESX hypervisor if hypervisor == 'esx': vpx_passwd = params.get("vpx_passwd") vpx_passwd_file = os.path.join(test.tmpdir, "vpx_passwd") logging.info("Building ESX no password interactive verification.") pwd_f = open(vpx_passwd_file, 'w') pwd_f.write(vpx_passwd) pwd_f.close() output_option += " --password-file %s" % vpx_passwd_file # Create libvirt dir pool if output_mode == "libvirt": create_pool() # Running virt-v2v command cmd = "%s %s %s %s" % (utils_v2v.V2V_EXEC, input_option, output_option, v2v_options) if v2v_user: cmd = su_cmd + "'%s'" % cmd cmd_result = utils.run(cmd, timeout=v2v_timeout, verbose=True, ignore_status=True) if new_vm_name: vm_name = new_vm_name params['main_vm'] = new_vm_name check_result(cmd, cmd_result, status_error) finally: if hypervisor == "xen": utils.run("ssh-agent -k") if hypervisor == "esx": utils.run("rm -rf %s" % vpx_passwd_file) for vdsm_dir in [vdsm_domain_dir, vdsm_image_dir, vdsm_vm_dir]: if os.path.exists(vdsm_dir): shutil.rmtree(vdsm_dir) if os.path.exists(mnt_point): utils_misc.umount(nfs_storage, mnt_point, "nfs") os.rmdir(mnt_point) if output_mode == "local": image_name = vm_name + "-sda" img_file = os.path.join(output_storage, image_name) xml_file = img_file + ".xml" for local_file in [img_file, xml_file]: if os.path.exists(local_file): os.remove(local_file) if output_mode == "libvirt": if "qemu:///session" in v2v_options: cmd = su_cmd + "'virsh undefine %s'" % vm_name utils.system(cmd) else: virsh.remove_domain(vm_name) cleanup_pool() if output_mode == "rhev" and vm_imported: vm_c = utils_v2v.VMCheck(test, params, env) vm_c.cleanup() if new_v2v_user: utils.system("userdel -f %s" % v2v_user) if restore_image_owner: os.chown(disk_img, ori_owner, ori_group)
def run(test, params, env): """ Convert a local vm disk to local libvirt(KVM). """ # VM info vm_name = params.get("v2v_vm") # Remote host parameters remote_hostname = params.get("remote_hostname", "XEN.EXAMPLE") username = params.get("remote_username", "root") password = params.get("remote_passwd", "XEN.PASSWORD") remote_hypervisor = params.get("remote_hypervisor") if remote_hostname.count("EXAMPLE") or password.count("EXAMPLE"): raise error.TestNAError("Please provide XEN host first.") # Local pool parameters pool_type = params.get("pool_type", "dir") pool_name = params.get("pool_name", "v2v_test") target_path = params.get("target_path", "pool_path") emulated_img = params.get("emulated_image_path", "v2v_emulated.img") emulated_size = params.get("emulated_image_size", "10G") local_tmp_path = params.get("local_tmp_path", data_dir.get_tmp_dir()) # If target_path is not an abs path, join it to data_dir.TMPDIR if os.path.dirname(target_path) is "": target_path = os.path.join(data_dir.get_tmp_dir(), target_path) # V2V parameters input = params.get("input_method") files = params.get("config_files") network = params.get("network") bridge = params.get("bridge") # Result check about ignore_virtio = "yes" == params.get("ignore_virtio", "no") # Create remote uri for remote host # Remote virt-v2v uri's instance ruri = utils_v2v.Uri(remote_hypervisor) remote_uri = ruri.get_uri(remote_hostname) ssh_key.setup_ssh_key(remote_hostname, user=username, port=22, password=password) # Check remote vms remote_vm = libvirt_vm.VM(vm_name, params, test.bindir, env.get("address_cache")) remote_vm.connect_uri = remote_uri if not remote_vm.exists(): raise error.TestFail("Couldn't find vm '%s' to be converted " "on remote uri '%s'." % (vm_name, remote_uri)) # Prepare local libvirt storage pool pvt = utlv.PoolVolumeTest(test, params) # Local storage pool's instance lsp = libvirt_storage.StoragePool() try: # Create storage pool for test pvt.pre_pool(pool_name, pool_type, target_path, emulated_img, emulated_size) logging.debug(lsp.pool_info(pool_name)) # Copy remote vm's disk to local and create xml file for it tmp_xml_file = copy_remote_vm(remote_vm, local_tmp_path, remote_hostname, username, password) # Maintain a single params for v2v to avoid duplicate parameters v2v_params = {"hostname": remote_hostname, "username": username, "password": password, "hypervisor": remote_hypervisor, "storage": pool_name, "network": network, "bridge": bridge, "target": "libvirtxml", "vms": tmp_xml_file, "input": input, "files": files} try: result = utils_v2v.v2v_cmd(v2v_params) logging.debug(result) except error.CmdError, detail: raise error.TestFail("Virt v2v failed:\n%s" % str(detail)) # v2v may be successful, but devices' driver may be not virtio error_info = [] # Check v2v vm on local host # Update parameters for local hypervisor and vm params['vms'] = vm_name params['target'] = "libvirt" vm_check = utils_v2v.LinuxVMCheck(test, params, env) try: if not vm_check.is_disk_virtio(): error_info.append("Error:disk type was not converted to " "virtio.") if not vm_check.is_net_virtio(): error_info.append("Error:nic type was not converted to " "virtio.") except (remote.LoginError, virt_vm.VMError), detail: error_info.append(str(detail))
def run(test, params, env): """ Test migration under stress. """ vm_names = params.get("migration_vms").split() if len(vm_names) < 2: raise error.TestNAError("Provide enough vms for migration first.") src_uri = params.get("migrate_src_uri", "qemu+ssh://EXAMPLE/system") if src_uri.count('///') or src_uri.count('EXAMPLE'): raise error.TestNAError("The src_uri '%s' is invalid", src_uri) dest_uri = params.get("migrate_dest_uri", "qemu+ssh://EXAMPLE/system") if dest_uri.count('///') or dest_uri.count('EXAMPLE'): raise error.TestNAError("The dest_uri '%s' is invalid", dest_uri) # Migrated vms' instance vms = [] for vm_name in vm_names: vms.append( libvirt_vm.VM(vm_name, params, test.bindir, env.get("address_cache"))) load_vm_names = params.get("load_vms").split() # vms for load load_vms = [] for vm_name in load_vm_names: load_vms.append( libvirt_vm.VM(vm_name, params, test.bindir, env.get("address_cache"))) params['load_vms'] = load_vms cpu = int(params.get("smp", 1)) memory = int(params.get("mem")) * 1024 stress_type = params.get("migration_stress_type") vm_bytes = params.get("stress_vm_bytes") stress_args = params.get("stress_args") migration_type = params.get("migration_type") start_migration_vms = "yes" == params.get("start_migration_vms", "yes") thread_timeout = int(params.get("thread_timeout", 120)) remote_host = params.get("migrate_dest_host") username = params.get("migrate_dest_user", "root") password = params.get("migrate_dest_pwd") prompt = params.get("shell_prompt", r"[\#\$]") # Set vm_bytes for start_cmd mem_total = utils_memory.memtotal() vm_reserved = len(vms) * memory if vm_bytes == "half": vm_bytes = (mem_total - vm_reserved) / 2 elif vm_bytes == "shortage": vm_bytes = mem_total - vm_reserved + 524288 if vm_bytes is not None: params["stress_args"] = stress_args % vm_bytes for vm in vms: # Keep vm dead for edit if vm.is_alive(): vm.destroy() set_cpu_memory(vm.name, cpu, memory) try: vm_ipaddr = {} if start_migration_vms: for vm in vms: vm.start() vm.wait_for_login() vm_ipaddr[vm.name] = vm.get_address() # TODO: recover vm if start failed? # Config ssh autologin for remote host ssh_key.setup_ssh_key(remote_host, username, password, port=22) do_stress_migration(vms, src_uri, dest_uri, stress_type, migration_type, params, thread_timeout) # Check network of vms on destination if start_migration_vms and migration_type != "cross": for vm in vms: check_dest_vm_network(vm, vm_ipaddr[vm.name], remote_host, username, password, prompt) finally: logging.debug("Cleanup vms...") for vm_name in vm_names: vm = libvirt_vm.VM(vm_name, params, test.bindir, env.get("address_cache")) utlv.MigrationTest().cleanup_dest_vm(vm, None, dest_uri) if vm.is_alive(): vm.destroy(gracefully=False) env.clean_objects()
def run(test, params, env): """ Test virsh migrate-setmaxdowntime command. 1) Prepare migration environment 2) Start migration and set migrate-maxdowntime 3) Cleanup environment(migrated vm on destination) 4) Check result """ vm_ref = params.get("setmmdt_vm_ref", "domname") dest_uri = params.get( "virsh_migrate_dest_uri", "qemu+ssh://EXAMPLE/system") src_uri = params.get( "virsh_migrate_src_uri", "qemu+ssh://EXAMPLE/system") pre_vm_state = params.get("pre_vm_state", "running") status_error = "yes" == params.get("status_error", "no") do_migrate = "yes" == params.get("do_migrate", "yes") downtime = params.get("migrate_maxdowntime", 1000) extra = params.get("setmmdt_extra") # A delay between threads delay_time = int(params.get("delay_time", 1)) # timeout of threads thread_timeout = 180 vm_name = params.get("migrate_main_vm") vm = env.get_vm(vm_name) domuuid = vm.get_uuid() # Confirm vm is running if not vm.is_alive(): vm.start() vm.wait_for_login() domid = vm.get_id() if dest_uri.count('///') or dest_uri.count('EXAMPLE'): raise error.TestNAError("Set your destination uri first.") if src_uri.count('///') or src_uri.count('EXAMPLE'): raise error.TestNAError("Set your source uri first.") if src_uri == dest_uri: raise error.TestNAError("You should not set dest uri same as local.") remote_host = params.get("migrate_dest_host") username = params.get("migrate_dest_user", "root") password = params.get("migrate_dest_pwd") # Config ssh autologin for remote host ssh_key.setup_ssh_key(remote_host, username, password, port=22) setmmdt_dargs = {'debug': True, 'ignore_status': True, 'uri': src_uri} migrate_dargs = {'debug': True, 'ignore_status': True} # Confirm how to reference a VM. if vm_ref == "domname": vm_ref = vm_name elif vm_ref == "domid": vm_ref = domid elif vm_ref == "domuuid": vm_ref = domuuid # Prepare vm state if pre_vm_state == "paused": vm.pause() elif pre_vm_state == "shutoff": vm.destroy() try: # Set max migration downtime must be during migration # Using threads for synchronization threads = [] if do_migrate: threads.append(threading.Thread(target=thread_func_live_migration, args=(vm, dest_uri, migrate_dargs))) threads.append(threading.Thread(target=thread_func_setmmdt, args=(vm_ref, downtime, extra, setmmdt_dargs))) for thread in threads: thread.start() # Migration must be executing before setting maxdowntime time.sleep(delay_time) # Wait until thread is over for thread in threads: thread.join(thread_timeout) finally: # Clean up. if do_migrate: cleanup_dest(vm, src_uri, dest_uri) if vm.is_paused(): vm.resume() # Check results. if status_error: if ret_setmmdt: if not do_migrate and libvirt_version.version_compare(1, 2, 9): # https://bugzilla.redhat.com/show_bug.cgi?id=1146618 # Commit fe808d9 fix it and allow setting migration # max downtime any time since libvirt-1.2.9 logging.info("Libvirt version is newer than 1.2.9," "Allow set maxdowntime while VM isn't migrating") else: raise error.TestFail("virsh migrate-setmaxdowntime succeed " "but not expected.") else: if do_migrate and not ret_migration: raise error.TestFail("Migration failed.") if not ret_setmmdt: raise error.TestFail("virsh migrate-setmaxdowntime failed.")
def run(test, params, env): """ Test qemu-monitor-command blockjobs by migrating with option --copy-storage-all or --copy-storage-inc. """ if not libvirt_version.version_compare(1, 0, 1): raise error.TestNAError("Blockjob functions - " "complete,pause,resume are" "not supported in current libvirt version.") vm = env.get_vm(params.get("main_vm")) cpu_size = int(params.get("cpu_size", "1")) memory_size = int(params.get("memory_size", "1048576")) primary_target = vm.get_first_disk_devices()["target"] file_path, file_size = vm.get_device_size(primary_target) # Convert to Gib file_size = int(file_size) / 1073741824 image_format = utils_test.get_image_info(file_path)["format"] remote_host = params.get("migrate_dest_host", "REMOTE.EXAMPLE") remote_user = params.get("remote_user", "root") remote_passwd = params.get("migrate_dest_pwd", "PASSWORD.EXAMPLE") if remote_host.count("EXAMPLE"): raise error.TestNAError("Config remote or local host first.") # Config ssh autologin for it ssh_key.setup_ssh_key(remote_host, remote_user, remote_passwd, port=22) # Define a new vm with modified cpu/memory new_vm_name = "%s_blockjob" % vm.name if vm.is_alive(): vm.destroy() utlv.define_new_vm(vm.name, new_vm_name) try: set_cpu_memory(new_vm_name, cpu_size, memory_size) vm = libvirt_vm.VM(new_vm_name, vm.params, vm.root_dir, vm.address_cache) except: # Make sure created vm is cleaned up virsh.remove_domain(new_vm_name) raise rdm_params = { "remote_ip": remote_host, "remote_user": remote_user, "remote_pwd": remote_passwd } rdm = utils_test.RemoteDiskManager(rdm_params) try: vm = libvirt_vm.VM(new_vm_name, vm.params, vm.root_dir, vm.address_cache) vm.start() rdm.create_image("file", file_path, file_size, None, None, img_frmt=image_format) logging.debug("Start migration...") copied_migration(vm, params, params.get("qmp_blockjob_type"), primary_target) finally: # Recover created vm if vm.is_alive(): vm.destroy() if vm.name == new_vm_name: vm.undefine() rdm.remove_path("file", file_path) rdm.runner.session.close()
def run_convert_remote_vm(test, params, env): """ Convert a remote vm to local libvirt(KVM). """ # VM info vm_name = params.get("v2v_vm") # Remote host parameters remote_hostname = params.get("remote_hostname") username = params.get("username", "root") password = params.get("password") remote_hypervisor = params.get("remote_hypervisor") # Local pool parameters pool_type = params.get("pool_type", "dir") pool_name = params.get("pool_name", "v2v_test") target_path = params.get("target_path", "pool_path") block_device = params.get("block_device", "/dev/BLOCK/EXAMPLE") vg_name = params.get("volume_group_name", "vg_v2v") # Confirm parameters have been set correctly. if (pool_type in ['partition', 'lvm'] and re.search("EXAMPLE", block_device)): raise error.TestNAError("Please set correct block device.") # If target_path is not an abs path, join it to data_dir.tmpdir if os.path.dirname(target_path) is "": target_path = os.path.join(data_dir.get_tmp_dir(), target_path) # dir pool need an exist path if pool_type == "dir": if not os.path.exists(target_path): os.mkdir(target_path) # V2V parameters input = params.get("input_method") files = params.get("config_files") network = params.get("network", "default") # Result check about ignore_virtio = "yes" == params.get("ignore_virtio", "no") # Create autologin to remote host esx_netrc = params.get("esx_netrc") % (remote_hostname, username, password) params['netrc'] = esx_netrc if remote_hypervisor == "esx": utils_v2v.build_esx_no_verify(params) else: ssh_key.setup_ssh_key(remote_hostname, user=username, port=22, password=password) # Create remote uri for remote host # Remote virt-v2v uri's instance ruri = utils_v2v.Uri(remote_hypervisor) remote_uri = ruri.get_uri(remote_hostname) # Check remote vms rvirsh_dargs = { 'uri': remote_uri, 'remote_ip': remote_hostname, 'remote_user': username, 'remote_pwd': password } rvirsh = virsh.VirshPersistent(**rvirsh_dargs) if not rvirsh.domain_exists(vm_name): rvirsh.close_session() raise error.TestFail("Couldn't find vm '%s' to be converted " "on remote uri '%s'." % (vm_name, remote_uri)) if remote_hypervisor != "esx": remote_vm = libvirt_vm.VM(vm_name, params, test.bindir, env.get("address_cache")) remote_vm.connect_uri = remote_uri # Remote storage pool's instance rsp = libvirt_storage.StoragePool(rvirsh) # Put remote vm's disk into a directory storage pool prepare_remote_sp(rsp, remote_vm, pool_name) # Local storage pool's instance lsp = libvirt_storage.StoragePool() try: # Create storage pool for test if pool_type == "dir": if not create_dir_pool(lsp, pool_name, target_path): raise error.TestFail("Prepare directory storage pool for " "virt-v2v failed.") elif pool_type == "partition": if not create_partition_pool(lsp, pool_name, block_device, target_path): raise error.TestFail("Prepare partition storage pool for " "virt-v2v failed.") elif pool_type == "lvm": if not create_lvm_pool(lsp, pool_name, block_device, vg_name, target_path): raise error.TestFail("Preapre lvm storage pool for " "virt-v2v failed.") # Maintain a single params for v2v to avoid duplicate parameters v2v_params = { "hostname": remote_hostname, "username": username, "password": password, "hypervisor": remote_hypervisor, "storage": pool_name, "network": network, "target": "libvirt", "vms": vm_name, "netrc": esx_netrc, "input": input, "files": files } try: result = utils_v2v.v2v_cmd(v2v_params) logging.debug(result) except error.CmdError, detail: raise error.TestFail("Virt v2v failed:\n%s" % str(detail)) # v2v may be successful, but devices' driver may be not virtio error_info = [] # Check v2v vm on local host # Update parameters for local hypervisor and vm params['vms'] = vm_name params['target'] = "libvirt" vm_check = utils_v2v.LinuxVMCheck(test, params, env) try: if not vm_check.is_disk_virtio(): error_info.append("Error:disk type was not converted to " "virtio.") if not vm_check.is_net_virtio(): error_info.append("Error:nic type was not converted to " "virtio.") except (remote.LoginError, virt_vm.VMError), detail: error_info.append(str(detail))
def run(test, params, env): """ Test various options of virt-v2v. """ if utils_v2v.V2V_EXEC is None: raise ValueError('Missing command: virt-v2v') vm_name = params.get("main_vm", "EXAMPLE") new_vm_name = params.get("new_vm_name") input_mode = params.get("input_mode") v2v_options = params.get("v2v_options", "") hypervisor = params.get("hypervisor", "kvm") remote_host = params.get("remote_host", "EXAMPLE") vpx_dc = params.get("vpx_dc", "EXAMPLE") esx_ip = params.get("esx_ip", "EXAMPLE") vpx_passwd = params.get("vpx_passwd", "EXAMPLE") ovirt_engine_url = params.get("ovirt_engine_url", "EXAMPLE") ovirt_engine_user = params.get("ovirt_engine_user", "EXAMPLE") ovirt_engine_passwd = params.get("ovirt_engine_password", "EXAMPLE") output_mode = params.get("output_mode") output_storage = params.get("output_storage", "default") export_name = params.get("export_name", "EXAMPLE") storage_name = params.get("storage_name", "EXAMPLE") disk_img = params.get("input_disk_image", "") nfs_storage = params.get("nfs_storage") mnt_point = params.get("mount_point") export_domain_uuid = params.get("export_domain_uuid", "") fake_domain_uuid = params.get("fake_domain_uuid") vdsm_image_uuid = params.get("vdsm_image_uuid") vdsm_vol_uuid = params.get("vdsm_vol_uuid") vdsm_vm_uuid = params.get("vdsm_vm_uuid") vdsm_ovf_output = params.get("vdsm_ovf_output") v2v_user = params.get("unprivileged_user", "") v2v_timeout = int(params.get("v2v_timeout", 1200)) status_error = "yes" == params.get("status_error", "no") for param in [ vm_name, remote_host, esx_ip, vpx_dc, ovirt_engine_url, ovirt_engine_user, ovirt_engine_passwd, output_storage, export_name, storage_name, disk_img, export_domain_uuid, v2v_user ]: if "EXAMPLE" in param: raise error.TestNAError("Please replace %s with real value" % param) su_cmd = "su - %s -c " % v2v_user output_uri = params.get("oc_uri", "") pool_name = params.get("pool_name", "v2v_test") pool_type = params.get("pool_type", "dir") pool_target = params.get("pool_target_path", "v2v_pool") emulated_img = params.get("emulated_image_path", "v2v-emulated-img") pvt = utlv.PoolVolumeTest(test, params) new_v2v_user = False restore_image_owner = False address_cache = env.get('address_cache') params['vmcheck'] = None def create_pool(): """ Create libvirt pool as the output storage """ if output_uri == "qemu:///session": target_path = os.path.join("/home", v2v_user, pool_target) cmd = su_cmd + "'mkdir %s'" % target_path utils.system(cmd, verbose=True) cmd = su_cmd + "'virsh pool-create-as %s dir" % pool_name cmd += " --target %s'" % target_path utils.system(cmd, verbose=True) else: pvt.pre_pool(pool_name, pool_type, pool_target, emulated_img) def cleanup_pool(): """ Clean up libvirt pool """ if output_uri == "qemu:///session": cmd = su_cmd + "'virsh pool-destroy %s'" % pool_name utils.system(cmd, verbose=True) target_path = os.path.join("/home", v2v_user, pool_target) cmd = su_cmd + "'rm -rf %s'" % target_path utils.system(cmd, verbose=True) else: pvt.cleanup_pool(pool_name, pool_type, pool_target, emulated_img) def get_all_uuids(output): """ Get export domain uuid, image uuid and vol uuid from command output. """ tmp_target = re.findall(r"qemu-img\sconvert\s.+\s'(\S+)'\n", output) if len(tmp_target) < 1: raise error.TestError("Fail to find tmp target file name when" " converting vm disk image") targets = tmp_target[0].split('/') return (targets[3], targets[5], targets[6]) def get_ovf_content(output): """ Find and read ovf file. """ export_domain_uuid, _, vol_uuid = get_all_uuids(output) export_vm_dir = os.path.join(mnt_point, export_domain_uuid, 'master/vms') ovf_content = "" if os.path.isdir(export_vm_dir): ovf_id = "ovf:id='%s'" % vol_uuid ret = utils.system_output("grep -R \"%s\" %s" % (ovf_id, export_vm_dir)) ovf_file = ret.split(":")[0] if os.path.isfile(ovf_file): ovf_f = open(ovf_file, "r") ovf_content = ovf_f.read() ovf_f.close() else: logging.error("Can't find ovf file to read") return ovf_content def get_img_path(output): """ Get the full path of the converted image. """ img_path = "" img_name = vm_name + "-sda" if output_mode == "libvirt": img_path = virsh.vol_path(img_name, output_storage).stdout.strip() elif output_mode == "local": img_path = os.path.join(output_storage, img_name) elif output_mode in ["rhev", "vdsm"]: export_domain_uuid, image_uuid, vol_uuid = get_all_uuids(output) img_path = os.path.join(mnt_point, export_domain_uuid, 'images', image_uuid, vol_uuid) if not img_path or not os.path.isfile(img_path): raise error.TestError("Get image path: '%s' is invalid", img_path) return img_path def check_vmtype(ovf, expected_vmtype): """ Verify vmtype in ovf file. """ if output_mode != "rhev": return if expected_vmtype == "server": vmtype_int = 1 elif expected_vmtype == "desktop": vmtype_int = 0 else: return if "<VmType>%s</VmType>" % vmtype_int in ovf: logging.info("Find VmType=%s in ovf file", expected_vmtype) else: raise error.TestFail("VmType check failed") def check_image(img_path, check_point, expected_value): """ Verify image file allocation mode and format """ img_info = utils_misc.get_image_info(img_path) logging.debug("Image info: %s", img_info) if check_point == "allocation": if expected_value == "sparse": if img_info['vsize'] > img_info['dsize']: logging.info("%s is a sparse image", img_path) else: raise error.TestFail("%s is not a sparse image" % img_path) elif expected_value == "preallocated": if img_info['vsize'] <= img_info['dsize']: logging.info("%s is a preallocated image", img_path) else: raise error.TestFail("%s is not a preallocated image" % img_path) if check_point == "format": if expected_value == img_info['format']: logging.info("%s format is %s", img_path, expected_value) else: raise error.TestFail("%s format is not %s" % (img_path, expected_value)) def check_new_name(output, expected_name): """ Verify guest name changed to the new name. """ found = False if output_mode == "libvirt": found = virsh.domain_exists(expected_name) if output_mode == "local": found = os.path.isfile( os.path.join(output_storage, expected_name + "-sda")) if output_mode in ["rhev", "vdsm"]: ovf = get_ovf_content(output) found = "<Name>%s</Name>" % expected_name in ovf else: return if found: logging.info("Guest name renamed when converting it") else: raise error.TestFail("Rename guest failed") def check_nocopy(output): """ Verify no image created if convert command use --no-copy option """ img_path = get_img_path(output) if not os.path.isfile(img_path): logging.info("No image created with --no-copy option") else: raise error.TestFail("Find %s" % img_path) def check_connection(output, expected_uri): """ Check output connection uri used when converting guest """ init_msg = "Initializing the target -o libvirt -oc %s" % expected_uri if init_msg in output: logging.info("Find message: %s", init_msg) else: raise error.TestFail("Not find message: %s" % init_msg) def check_disks(ori_disks): """ Check disk counts inside the VM """ vmcheck = params.get("vmcheck") if vmcheck is None: raise error.TestError("VM check object is None") # Initialize windows boot up os_type = params.get("os_type", "linux") if os_type == "windows": virsh_session = utils_sasl.VirshSessionSASL(params) virsh_session_id = virsh_session.get_id() vmcheck.virsh_session_id = virsh_session_id vmcheck.init_windows() virsh_session.close() # Creatge VM session vmcheck.create_session() expected_disks = int(params.get("added_disks_count", "1")) - ori_disks logging.debug("Expect %s disks im VM after convert", expected_disks) # Get disk counts disks = 0 if os_type == "linux": cmd = "lsblk |grep disk |wc -l" disks = int(vmcheck.session.cmd(cmd).strip()) else: cmd = r"echo list disk > C:\list_disk.txt" vmcheck.session.cmd(cmd) cmd = r"diskpart /s C:\list_disk.txt" output = vmcheck.session.cmd(cmd).strip() logging.debug("Disks in VM: %s", output) disks = len(output.splitlines()) - 6 logging.debug("Find %s disks in VM after convert", disks) vmcheck.session.close() if disks == expected_disks: logging.info("Disk counts is expected") else: raise error.TestFail("Disk counts is wrong") def check_result(cmd, result, status_error): """ Check virt-v2v command result """ utlv.check_exit_status(result, status_error) output = result.stdout + result.stderr if not status_error: if output_mode == "rhev": ovf = get_ovf_content(output) logging.debug("ovf content: %s", ovf) if '--vmtype' in cmd: expected_vmtype = re.findall(r"--vmtype\s(\w+)", cmd)[0] check_vmtype(ovf, expected_vmtype) if '-oa' in cmd and '--no-copy' not in cmd: expected_mode = re.findall(r"-oa\s(\w+)", cmd)[0] img_path = get_img_path(output) check_image(img_path, "allocation", expected_mode) if '-of' in cmd and '--no-copy' not in cmd: expected_format = re.findall(r"-of\s(\w+)", cmd)[0] img_path = get_img_path(output) check_image(img_path, "format", expected_format) if '-on' in cmd: expected_name = re.findall(r"-on\s(\w+)", cmd)[0] check_new_name(output, expected_name) if '--no-copy' in cmd: check_nocopy(output) if '-oc' in cmd: expected_uri = re.findall(r"-oc\s(\S+)", cmd)[0] check_connection(output, expected_uri) if output_mode == "rhev": if not utils_v2v.import_vm_to_ovirt(params, address_cache): raise error.TestFail("Import VM failed") else: params['vmcheck'] = utils_v2v.VMCheck(test, params, env) if attach_disks: check_disks(params.get("ori_disks")) if output_mode == "libvirt": if "qemu:///session" not in v2v_options: virsh.start(vm_name, debug=True, ignore_status=False) backup_xml = None attach_disks = "yes" == params.get("attach_disk_config", "no") attach_disk_path = os.path.join(test.tmpdir, "attach_disks") vdsm_domain_dir, vdsm_image_dir, vdsm_vm_dir = ("", "", "") try: # Build input options input_option = "" if input_mode is None: pass elif input_mode == "libvirt": uri_obj = utils_v2v.Uri(hypervisor) ic_uri = uri_obj.get_uri(remote_host, vpx_dc, esx_ip) input_option = "-i %s -ic %s %s" % (input_mode, ic_uri, vm_name) # Build network&bridge option to avoid network error v2v_options += " -b %s -n %s" % (params.get("output_bridge"), params.get("output_network")) # Multiple disks testing if attach_disks: backup_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name) # Get original vm disk counts params['ori_disks'] = backup_xml.get_disk_count(vm_name) utlv.attach_disks(env.get_vm(vm_name), attach_disk_path, None, params) elif input_mode == "disk": input_option += "-i %s %s" % (input_mode, disk_img) elif input_mode in ['libvirtxml', 'ova']: raise error.TestNAError("Unsupported input mode: %s" % input_mode) else: raise error.TestError("Unknown input mode %s" % input_mode) input_format = params.get("input_format") input_allo_mode = params.get("input_allo_mode") if input_format: input_option += " -if %s" % input_format if not status_error: logging.info("Check image before convert") check_image(disk_img, "format", input_format) if input_allo_mode: check_image(disk_img, "allocation", input_allo_mode) # Build output options output_option = "" if output_mode: output_option = "-o %s -os %s" % (output_mode, output_storage) output_format = params.get("output_format") if output_format: output_option += " -of %s" % output_format output_allo_mode = params.get("output_allo_mode") if output_allo_mode: output_option += " -oa %s" % output_allo_mode # Build vdsm related options if output_mode in ['vdsm', 'rhev']: if not os.path.isdir(mnt_point): os.mkdir(mnt_point) if not utils_misc.mount(nfs_storage, mnt_point, "nfs"): raise error.TestError("Mount NFS Failed") if output_mode == 'vdsm': v2v_options += " --vdsm-image-uuid %s" % vdsm_image_uuid v2v_options += " --vdsm-vol-uuid %s" % vdsm_vol_uuid v2v_options += " --vdsm-vm-uuid %s" % vdsm_vm_uuid v2v_options += " --vdsm-ovf-output %s" % vdsm_ovf_output vdsm_domain_dir = os.path.join(mnt_point, fake_domain_uuid) vdsm_image_dir = os.path.join(mnt_point, export_domain_uuid, "images", vdsm_image_uuid) vdsm_vm_dir = os.path.join(mnt_point, export_domain_uuid, "master/vms", vdsm_vm_uuid) # For vdsm_domain_dir, just create a dir to test BZ#1176591 os.mkdir(vdsm_domain_dir) os.mkdir(vdsm_image_dir) os.mkdir(vdsm_vm_dir) # Output more messages v2v_options += " -v -x" # Prepare for libvirt unprivileged user session connection if "qemu:///session" in v2v_options: try: pwd.getpwnam(v2v_user) except KeyError: # create new user utils.system("useradd %s" % v2v_user, ignore_status=True) new_v2v_user = True user_info = pwd.getpwnam(v2v_user) logging.info("Convert to qemu:///session by user '%s'", v2v_user) if input_mode == "disk": # Change the image owner and group ori_owner = os.stat(disk_img).st_uid ori_group = os.stat(disk_img).st_uid os.chown(disk_img, user_info.pw_uid, user_info.pw_gid) restore_image_owner = True else: raise error.TestNAError("Only support convert local disk") # Setup ssh-agent access to xen hypervisor if hypervisor == 'xen': os.environ['LIBGUESTFS_BACKEND'] = 'direct' user = params.get("xen_host_user", "root") passwd = params.get("xen_host_passwd", "redhat") logging.info("set up ssh-agent access ") ssh_key.setup_ssh_key(remote_host, user=user, port=22, password=passwd) utils_misc.add_identities_into_ssh_agent() # If the input format is not define, we need to either define # the original format in the source metadata(xml) or use '-of' # to force the output format, see BZ#1141723 for detail. if '-of' not in v2v_options: v2v_options += ' -of %s' % params.get("default_output_format", "qcow2") # Create password file for access to ESX hypervisor if hypervisor == 'esx': vpx_passwd = params.get("vpx_passwd") vpx_passwd_file = os.path.join(test.tmpdir, "vpx_passwd") logging.info("Building ESX no password interactive verification.") pwd_f = open(vpx_passwd_file, 'w') pwd_f.write(vpx_passwd) pwd_f.close() output_option += " --password-file %s" % vpx_passwd_file # Create libvirt dir pool if output_mode == "libvirt": create_pool() # Running virt-v2v command cmd = "%s %s %s %s" % (utils_v2v.V2V_EXEC, input_option, output_option, v2v_options) if v2v_user: cmd = su_cmd + "'%s'" % cmd cmd_result = utils.run(cmd, timeout=v2v_timeout, verbose=True, ignore_status=True) if new_vm_name: vm_name = new_vm_name params['main_vm'] = new_vm_name check_result(cmd, cmd_result, status_error) finally: if hypervisor == "xen": utils.run("ssh-agent -k") if hypervisor == "esx": utils.run("rm -rf %s" % vpx_passwd_file) for vdsm_dir in [vdsm_domain_dir, vdsm_image_dir, vdsm_vm_dir]: if os.path.exists(vdsm_dir): shutil.rmtree(vdsm_dir) if os.path.exists(mnt_point): utils_misc.umount(nfs_storage, mnt_point, "nfs") os.rmdir(mnt_point) if output_mode == "local": image_name = vm_name + "-sda" img_file = os.path.join(output_storage, image_name) xml_file = img_file + ".xml" for local_file in [img_file, xml_file]: if os.path.exists(local_file): os.remove(local_file) if output_mode == "libvirt": if "qemu:///session" in v2v_options: cmd = su_cmd + "'virsh undefine %s'" % vm_name utils.system(cmd) else: virsh.remove_domain(vm_name) cleanup_pool() vmcheck = params.get("vmcheck") if vmcheck: vmcheck.cleanup() if new_v2v_user: utils.system("userdel -f %s" % v2v_user) if restore_image_owner: os.chown(disk_img, ori_owner, ori_group) if backup_xml: backup_xml.sync() if os.path.exists(attach_disk_path): shutil.rmtree(attach_disk_path)
def run(test, params, env): """ Test of virt-edit. 1) Get and init parameters for test. 2) Prepare environment. 3) Run virt-edit command and get result. 5) Recover environment. 6) Check result. """ vm_name = params.get("main_vm") vm = env.get_vm(vm_name) remote_host = params.get("virt_edit_remote_host", "HOST.EXAMPLE") remote_user = params.get("virt_edit_remote_user", "root") remote_passwd = params.get("virt_edit_remote_passwd", "PASSWD.EXAMPLE") connect_uri = params.get("virt_edit_connect_uri") if connect_uri is not None: uri = "qemu+ssh://%s@%s/system" % (remote_user, remote_host) if uri.count("EXAMPLE"): raise error.TestNAError("Please config host and passwd first.") # Config ssh autologin for it ssh_key.setup_ssh_key(remote_host, remote_user, remote_passwd, port=22) else: uri = libvirt_vm.normalize_connect_uri(params.get("connect_uri", "default")) start_vm = params.get("start_vm", "no") vm_ref = params.get("virt_edit_vm_ref", vm_name) file_ref = params.get("virt_edit_file_ref", "/etc/hosts") created_img = params.get("virt_edit_created_img", "/tmp/foo.img") foo_line = params.get("foo_line", "") options = params.get("virt_edit_options") options_suffix = params.get("virt_edit_options_suffix") status_error = params.get("status_error", "no") backup_extension = params.get("virt_edit_backup_extension") test_format = params.get("virt_edit_format") # virt-edit should not be used when vm is running. # (for normal test) if vm.is_alive() and start_vm == "no": vm.destroy(gracefully=True) dom_disk_dict = vm.get_disk_devices() # TODO dom_uuid = vm.get_uuid() # Disk format: raw or qcow2 disk_format = None # If object is a disk file path is_disk = False if vm_ref == "domdisk": if len(dom_disk_dict) != 1: raise error.TestError("Only one disk device should exist on " "%s:\n%s." % (vm_name, dom_disk_dict)) disk_detail = dom_disk_dict.values()[0] vm_ref = disk_detail['source'] logging.info("disk to be edit:%s", vm_ref) if test_format: # Get format:raw or qcow2 info = utils.run("qemu-img info %s" % vm_ref).stdout for line in info.splitlines(): comps = line.split(':') if comps[0].count("format"): disk_format = comps[-1].strip() break if disk_format is None: raise error.TestError("Cannot get disk format:%s" % info) options = "--format=%s" % disk_format is_disk = True elif vm_ref == "domname": vm_ref = vm_name elif vm_ref == "domuuid": vm_ref = dom_uuid elif vm_ref == "createdimg": vm_ref = created_img utils.run("dd if=/dev/zero of=%s bs=256M count=1" % created_img) is_disk = True # Decide whether pass a exprt for virt-edit command. if foo_line != "": expr = "s/$/%s/" % foo_line else: expr = "" if backup_extension is not None: if options is None: options = "" options += " -b %s" % backup_extension # Stop libvirtd if test need. libvirtd = params.get("libvirtd", "on") if libvirtd == "off": utils_libvirtd.libvirtd_stop() # Run test result = lgf.virt_edit_cmd(vm_ref, file_ref, is_disk, options, options_suffix, expr, uri, debug=True) status = result.exit_status # Recover libvirtd. if libvirtd == "off": utils_libvirtd.libvirtd_start() utils.run("rm -f %s" % created_img) # Remove backup file in vm if it exists if backup_extension is not None: backup_file = file_ref + backup_extension cleanup_file_in_vm(vm, backup_file) status_error = (status_error == "yes") if status != 0: if not status_error: raise error.TestFail("Command executed failed.") else: if (expr != "" and (not login_to_check_foo_line(vm, file_ref, foo_line))): raise error.TestFail("Virt-edit to add %s in %s failed." "Test failed." % (foo_line, file_ref))
def run_convert_remote_vm(test, params, env): """ Convert a remote vm to local libvirt(KVM). """ # VM info vm_name = params.get("v2v_vm") # Remote host parameters remote_hostname = params.get("remote_hostname") username = params.get("username", "root") password = params.get("password") remote_hypervisor = params.get("remote_hypervisor") # Local pool parameters pool_type = params.get("pool_type", "dir") pool_name = params.get("pool_name", "v2v_test") target_path = params.get("target_path", "pool_path") block_device = params.get("block_device", "/dev/BLOCK/EXAMPLE") vg_name = params.get("volume_group_name", "vg_v2v") # Confirm parameters have been set correctly. if (pool_type in ['partition', 'lvm'] and re.search("EXAMPLE", block_device)): raise error.TestNAError("Please set correct block device.") # If target_path is not an abs path, join it to data_dir.tmpdir if os.path.dirname(target_path) is "": target_path = os.path.join(data_dir.get_tmp_dir(), target_path) # dir pool need an exist path if pool_type == "dir": if not os.path.exists(target_path): os.mkdir(target_path) # V2V parameters input = params.get("input_method") files = params.get("config_files") network = params.get("network", "default") # Result check about ignore_virtio = "yes" == params.get("ignore_virtio", "no") # Create autologin to remote host esx_netrc = params.get("esx_netrc") % (remote_hostname, username, password) params['netrc'] = esx_netrc if remote_hypervisor == "esx": utils_v2v.build_esx_no_verify(params) else: ssh_key.setup_ssh_key(remote_hostname, user=username, port=22, password=password) # Create remote uri for remote host # Remote virt-v2v uri's instance ruri = utils_v2v.Uri(remote_hypervisor) remote_uri = ruri.get_uri(remote_hostname) # Check remote vms rvirsh_dargs = {'uri': remote_uri, 'remote_ip': remote_hostname, 'remote_user': username, 'remote_pwd': password} rvirsh = virsh.VirshPersistent(**rvirsh_dargs) if not rvirsh.domain_exists(vm_name): rvirsh.close_session() raise error.TestFail("Couldn't find vm '%s' to be converted " "on remote uri '%s'." % (vm_name, remote_uri)) if remote_hypervisor != "esx": remote_vm = libvirt_vm.VM(vm_name, params, test.bindir, env.get("address_cache")) remote_vm.connect_uri = remote_uri # Remote storage pool's instance rsp = libvirt_storage.StoragePool(rvirsh) # Put remote vm's disk into a directory storage pool prepare_remote_sp(rsp, remote_vm, pool_name) # Local storage pool's instance lsp = libvirt_storage.StoragePool() try: # Create storage pool for test if pool_type == "dir": if not create_dir_pool(lsp, pool_name, target_path): raise error.TestFail("Prepare directory storage pool for " "virt-v2v failed.") elif pool_type == "partition": if not create_partition_pool(lsp, pool_name, block_device, target_path): raise error.TestFail("Prepare partition storage pool for " "virt-v2v failed.") elif pool_type == "lvm": if not create_lvm_pool(lsp, pool_name, block_device, vg_name, target_path): raise error.TestFail("Preapre lvm storage pool for " "virt-v2v failed.") # Maintain a single params for v2v to avoid duplicate parameters v2v_params = {"hostname": remote_hostname, "username": username, "password": password, "hypervisor": remote_hypervisor, "storage": pool_name, "network": network, "target": "libvirt", "vms": vm_name, "netrc": esx_netrc, "input": input, "files": files} try: result = utils_v2v.v2v_cmd(v2v_params) logging.debug(result) except error.CmdError, detail: raise error.TestFail("Virt v2v failed:\n%s" % str(detail)) # v2v may be successful, but devices' driver may be not virtio error_info = [] # Check v2v vm on local host # Update parameters for local hypervisor and vm params['vms'] = vm_name params['target'] = "libvirt" vm_check = utils_v2v.LinuxVMCheck(test, params, env) try: if not vm_check.is_disk_virtio(): error_info.append("Error:disk type was not converted to " "virtio.") if not vm_check.is_net_virtio(): error_info.append("Error:nic type was not converted to " "virtio.") except (remote.LoginError, virt_vm.VMError), detail: error_info.append(str(detail))
def run(test, params, env): """ Test command: virsh domjobabort. The command can abort the currently running domain job. 1.Prepare test environment,destroy or suspend a VM. 2.Do action to get a subprocess(dump, save, managedsave). 3.Perform virsh domjobabort operation to abort VM's job. 4.Recover the VM's status and wait for the subprocess over. 5.Confirm the test result. """ vm_name = params.get("main_vm", "vm1") vm = env.get_vm(vm_name) start_vm = params.get("start_vm") pre_vm_state = params.get("pre_vm_state", "start") if start_vm == "no" and vm.is_alive(): vm.destroy() # Instead of "paused_after_start_vm", use "pre_vm_state". # After start the VM, wait for some time to make sure the job # can be created on this domain. if start_vm == "yes": vm.wait_for_login() if params.get("pre_vm_state") == "suspend": vm.pause() domid = vm.get_id() domuuid = vm.get_uuid() original_speed = virsh.migrate_getspeed(vm_name).stdout.strip() def get_subprocess(action, vm_name, file, remote_uri=None): """ Execute background virsh command, return subprocess w/o waiting for exit() :param cmd : virsh command. :param guest_name : VM's name :param file_source : virsh command's file option. """ if action == "managedsave": file = "" elif action == "migrate": # Slow down migration for domjobabort virsh.migrate_setspeed(vm_name, "1") file = remote_uri command = "virsh %s %s %s --unsafe" % (action, vm_name, file) logging.debug("Action: %s", command) p = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) return p action = params.get("jobabort_action", "dump") status_error = params.get("status_error", "no") job = params.get("jobabort_job", "yes") tmp_file = os.path.join(test.tmpdir, "domjobabort.tmp") tmp_pipe = os.path.join(test.tmpdir, "domjobabort.fifo") vm_ref = params.get("jobabort_vm_ref") remote_uri = params.get("jobabort_remote_uri") remote_host = params.get("migrate_dest_host") remote_user = params.get("migrate_dest_user", "root") remote_pwd = params.get("migrate_dest_pwd") saved_data = None if action == "managedsave": tmp_pipe = '/var/lib/libvirt/qemu/save/%s.save' % vm.name if action == "restore": virsh.save(vm_name, tmp_file, ignore_status=True) if action == "migrate": if remote_host.count("EXAMPLE"): raise error.TestNAError("Remote host should be configured " "for migrate.") else: # Config ssh autologin for remote host ssh_key.setup_ssh_key(remote_host, remote_user, remote_pwd, port=22) if vm_ref == "id": vm_ref = domid elif vm_ref == "hex_id": vm_ref = hex(int(domid)) elif vm_ref == "uuid": vm_ref = domuuid elif vm_ref.find("invalid") != -1: vm_ref = params.get(vm_ref) elif vm_ref == "name": vm_ref = vm_name # Get the subprocess of VM. # The command's effect is to abort the currently running domain job. # So before do "domjobabort" action, we must create a job on the domain. process = None if job == "yes" and start_vm == "yes" and status_error == "no": if os.path.exists(tmp_pipe): os.unlink(tmp_pipe) os.mkfifo(tmp_pipe) process = get_subprocess(action, vm_name, tmp_pipe, remote_uri) saved_data = None if action == "restore": saved_data = file(tmp_file, 'r').read(10 * 1024 * 1024) f = open(tmp_pipe, 'w') f.write(saved_data[:1024 * 1024]) elif action == "migrate": f = None else: f = open(tmp_pipe, 'r') dummy = f.read(1024 * 1024) # Give enough time for starting job t = 0 while t < 5: jobtype = vm.get_job_type() if "None" == jobtype: t += 1 time.sleep(1) continue elif jobtype is False: logging.error("Get job type failed.") break else: logging.debug("Job started: %s", jobtype) break ret = virsh.domjobabort(vm_ref, ignore_status=True, debug=True) status = ret.exit_status if process and f: if saved_data: f.write(saved_data[1024 * 1024:]) else: dummy = f.read() f.close() if os.path.exists(tmp_pipe): os.unlink(tmp_pipe) if os.path.exists(tmp_file): os.unlink(tmp_file) # Recover the environment. if pre_vm_state == "suspend": vm.resume() if process: if process.poll(): try: process.kill() except OSError: pass if action == "migrate": # Recover migration speed virsh.migrate_setspeed(vm_name, original_speed) utlv.MigrationTest().cleanup_dest_vm(vm, None, remote_uri) # check status_error if status_error == "yes": if status == 0: raise error.TestFail("Run successfully with wrong command!") elif status_error == "no": if status != 0: raise error.TestFail("Run failed with right command")
def run(test, params, env): """ Convert a local vm disk to local libvirt(KVM). """ # VM info vm_name = params.get("v2v_vm") # Remote host parameters remote_hostname = params.get("remote_hostname") username = params.get("remote_username", "root") password = params.get("remote_passwd") remote_hypervisor = params.get("remote_hypervisor") # Local pool parameters pool_type = params.get("pool_type", "dir") block_device = params.get("block_device", "/dev/BLOCK/EXAMPLE") if pool_type in ['disk', 'partition', 'lvm'] and \ re.search("EXAMPLE", block_device): raise error.TestNAError("Please set correct block device.") pool_name = params.get("pool_name", "v2v_test") target_path = params.get("target_path", "pool_path") vg_name = params.get("volume_group_name", "vg_v2v") local_tmp_path = params.get("local_tmp_path", data_dir.get_tmp_dir()) # If target_path is not an abs path, join it to data_dir.TMPDIR if os.path.dirname(target_path) is "": target_path = os.path.join(data_dir.get_tmp_dir(), target_path) # dir pool need an exist path if pool_type == "dir": if not os.path.exists(target_path): os.mkdir(target_path) # V2V parameters input = params.get("input_method") files = params.get("config_files") network = params.get("network", "default") # Result check about ignore_virtio = "yes" == params.get("ignore_virtio", "no") # Create remote uri for remote host # Remote virt-v2v uri's instance ruri = utils_v2v.Uri(remote_hypervisor) remote_uri = ruri.get_uri(remote_hostname) ssh_key.setup_ssh_key(remote_hostname, user=username, port=22, password=password) # Check remote vms remote_vm = libvirt_vm.VM(vm_name, params, test.bindir, env.get("address_cache")) remote_vm.connect_uri = remote_uri if not remote_vm.exists(): raise error.TestFail("Couldn't find vm '%s' to be converted " "on remote uri '%s'." % (vm_name, remote_uri)) # Copy remote vm's disk to local and create xml file for it tmp_xml_file = copy_remote_vm(remote_vm, local_tmp_path, remote_hostname, username, password) # Local storage pool's instance lsp = libvirt_storage.StoragePool() try: # Create storage pool for test if pool_type == "dir": if not create_dir_pool(lsp, pool_name, target_path): raise error.TestFail("Prepare directory storage pool for " "virt-v2v failed.") elif pool_type == "partition": if not create_partition_pool(lsp, pool_name, block_device, target_path): raise error.TestFail("Prepare partition storage pool for " "virt-v2v failed.") elif pool_type == "lvm": if not create_lvm_pool(lsp, pool_name, block_device, vg_name, target_path): raise error.TestFail("Prepare lvm storage pool for " "virt-v2v failed.") elif pool_type == "disk": if not create_disk_pool(lsp, pool_name, block_device, target_path): raise error.TestFail("Prepare disk storage pool for " "virt-v2v failed.") # Maintain a single params for v2v to avoid duplicate parameters v2v_params = { "hostname": remote_hostname, "username": username, "password": password, "hypervisor": remote_hypervisor, "storage": pool_name, "network": network, "target": "libvirtxml", "vms": tmp_xml_file, "input": input, "files": files } try: result = utils_v2v.v2v_cmd(v2v_params) logging.debug(result) except error.CmdError, detail: raise error.TestFail("Virt v2v failed:\n%s" % str(detail)) # v2v may be successful, but devices' driver may be not virtio error_info = [] # Check v2v vm on local host # Update parameters for local hypervisor and vm params['vms'] = vm_name params['target'] = "libvirt" vm_check = utils_v2v.LinuxVMCheck(test, params, env) try: if not vm_check.is_disk_virtio(): error_info.append("Error:disk type was not converted to " "virtio.") if not vm_check.is_net_virtio(): error_info.append("Error:nic type was not converted to " "virtio.") except (remote.LoginError, virt_vm.VMError), detail: error_info.append(str(detail))
def verify_migration_speed(test, params, env): """ Check if migration speed is effective with twice migration. """ vms = env.get_all_vms() src_uri = params.get("migrate_src_uri", "qemu+ssh://EXAMPLE/system") dest_uri = params.get("migrate_dest_uri", "qemu+ssh://EXAMPLE/system") if not len(vms): raise error.TestNAError("Please provide migrate_vms for test.") if src_uri.count('///') or src_uri.count('EXAMPLE'): raise error.TestNAError("The src_uri '%s' is invalid" % src_uri) if dest_uri.count('///') or dest_uri.count('EXAMPLE'): raise error.TestNAError("The dest_uri '%s' is invalid" % dest_uri) remote_host = params.get("migrate_dest_host") username = params.get("migrate_dest_user", "root") password = params.get("migrate_dest_pwd") # Config ssh autologin for remote host ssh_key.setup_ssh_key(remote_host, username, password, port=22) # Check migrated vms' state for vm in vms: if vm.is_dead(): vm.start() load_vm_names = params.get("load_vms").split() # vms for load load_vms = [] for vm_name in load_vm_names: load_vms.append( libvirt_vm.VM(vm_name, params, test.bindir, env.get("address_cache"))) params["load_vms"] = load_vms bandwidth = int(params.get("bandwidth", "4")) stress_type = params.get("stress_type", "load_vms_booting") migration_type = params.get("migration_type", "orderly") thread_timeout = int(params.get("thread_timeout", "60")) delta = float(params.get("allowed_delta", "0.1")) virsh_migrate_timeout = int(params.get("virsh_migrate_timeout", "60")) # virsh migrate options virsh_migrate_options = "--live --unsafe --timeout %s" % virsh_migrate_timeout # Migrate vms to remote host mig_first = utlv.MigrationTest() virsh_dargs = {"debug": True} for vm in vms: set_get_speed(vm.name, bandwidth, virsh_dargs=virsh_dargs) vm.wait_for_login() utils_test.load_stress(stress_type, vms, params) mig_first.do_migration(vms, src_uri, dest_uri, migration_type, options=virsh_migrate_options, thread_timeout=thread_timeout) for vm in vms: mig_first.cleanup_dest_vm(vm, None, dest_uri) # Keep it clean for second migration if vm.is_alive(): vm.destroy() # Migrate vms again with new bandwidth second_bandwidth = params.get("second_bandwidth", "times") if second_bandwidth == "half": second_bandwidth = bandwidth / 2 speed_times = 2 elif second_bandwidth == "times": second_bandwidth = bandwidth * 2 speed_times = 0.5 elif second_bandwidth == "same": second_bandwidth = bandwidth speed_times = 1 # Migrate again for vm in vms: if vm.is_dead(): vm.start() vm.wait_for_login() set_get_speed(vm.name, second_bandwidth, virsh_dargs=virsh_dargs) utils_test.load_stress(stress_type, vms, params) mig_second = utlv.MigrationTest() mig_second.do_migration(vms, src_uri, dest_uri, migration_type, options=virsh_migrate_options, thread_timeout=thread_timeout) for vm in vms: mig_second.cleanup_dest_vm(vm, None, dest_uri) fail_info = [] # Check whether migration failed if len(fail_info): raise error.TestFail(fail_info) for vm in vms: first_time = mig_first.mig_time[vm.name] second_time = mig_second.mig_time[vm.name] logging.debug( "Migration time for %s:\n" "Time with Bandwidth '%s' first: %s\n" "Time with Bandwidth '%s' second: %s", vm.name, bandwidth, first_time, second_bandwidth, second_time) shift = float(abs(first_time * speed_times - second_time)) / float(second_time) logging.debug("Shift:%s", shift) if delta < shift: fail_info.append( "Spent time for migrating %s is intolerable." % vm.name) # Check again for speed result if len(fail_info): raise error.TestFail(fail_info)
def run(test, params, env): """ Convert a remote vm to local libvirt(KVM). """ # VM info vm_name = params.get("main_vm") # Remote host parameters username = params.get("username", "root") xen_ip = params.get("xen_ip", "XEN.EXAMPLE") xen_pwd = params.get("xen_pwd", "PWD.EXAMPLE") vpx_ip = params.get("vpx_ip", "ESX.EXAMPLE") vpx_pwd = params.get("vpx_pwd", "PWD.EXAMPLE") vpx_pwd_file = params.get("vpx_passwd_file") vpx_dc = params.get("vpx_dc", "VPX.DC.EXAMPLE") esx_ip = params.get("esx_ip", "ESX.EXAMPLE") # To decide which type test it is hypervisor = params.get("hypervisor") # Local pool parameters pool_type = params.get("pool_type", "dir") pool_name = params.get("pool_name", "v2v_test") target_path = params.get("target_path", "pool_path") emulated_img = params.get("emulated_image_path", "v2v_emulated.img") emulated_size = params.get("emulated_image_size", "10G") # If target_path is not an abs path, join it to data_dir.tmpdir if not os.path.dirname(target_path): target_path = os.path.join(data_dir.get_tmp_dir(), target_path) # V2V parameters input = params.get("input_method") files = params.get("config_files") network = params.get("network") bridge = params.get("bridge") # Set libguestfs environment os.environ['LIBGUESTFS_BACKEND'] = 'direct' # Extra v2v command options, default to None v2v_opts = params.get("v2v_opts") if hypervisor == "esx": remote_ip = vpx_ip remote_pwd = vpx_pwd if remote_ip.count("EXAMPLE") or remote_pwd.count("EXAMPLE"): raise error.TestNAError("Please provide host or password for " "ESX test.") logging.info("Building ESX no password interactive verification.") fp = open(vpx_pwd_file, 'w') fp.write(vpx_pwd) fp.close() if hypervisor == "xen": # or hypervisor == 'kvm': remote_ip = xen_ip remote_pwd = xen_pwd if remote_ip.count("EXAMPLE") or remote_pwd.count("EXAMPLE"): raise error.TestNAError("Please provide host or password for " "xen test.") ssh_key.setup_ssh_key(remote_ip, user=username, port=22, password=remote_pwd) # Note that password-interactive and Kerberos access are not supported. # You have to set up ssh access using ssh-agent and authorized_keys. try: utils_misc.add_identities_into_ssh_agent() except: utils.run("ssh-agent -k") raise error.TestFail("Failed to start 'ssh-agent'") # Create remote uri for remote host # Remote virt-v2v uri's instance ruri = utils_v2v.Uri(hypervisor) remote_uri = ruri.get_uri(remote_ip, vpx_dc, esx_ip) logging.debug("The current virsh uri: %s", remote_uri) # Check remote vms rvirsh_dargs = {'uri': remote_uri, 'remote_ip': remote_ip, 'remote_user': username, 'remote_pwd': remote_pwd} rvirsh = virsh.VirshPersistent(**rvirsh_dargs) if not rvirsh.domain_exists(vm_name): rvirsh.close_session() raise error.TestFail("Couldn't find vm '%s' to be converted " "on remote uri '%s'." % (vm_name, remote_uri)) remote_vm = libvirt_vm.VM(vm_name, params, test.bindir, env.get("address_cache")) remote_vm.connect_uri = remote_uri # Remote storage pool's instance rsp = libvirt_storage.StoragePool(rvirsh) # Prepare local libvirt storage pool pvt = utlv.PoolVolumeTest(test, params) # Local storage pool's instance lsp = libvirt_storage.StoragePool() # Maintain a single params for v2v to avoid duplicate parameters v2v_params = {"hostname": remote_ip, "username": username, "password": remote_pwd, "hypervisor": hypervisor, "storage": pool_name, "network": network, "bridge": bridge, "target": "libvirt", "main_vm": vm_name, "input": input, "files": files} if vpx_dc: v2v_params.update({"vpx_dc": vpx_dc}) if esx_ip: v2v_params.update({"esx_ip": esx_ip}) if v2v_opts: v2v_params.update({"v2v_opts": v2v_opts}) try: # Create storage pool for test pvt.pre_pool(pool_name, pool_type, target_path, emulated_img, image_size=emulated_size) logging.debug(lsp.pool_info(pool_name)) ret = utils_v2v.v2v_cmd(v2v_params) logging.debug("virt-v2 verbose messages:\n%s", ret) if ret.exit_status != 0: if "Input/output error" in ret.stderr: raise error.TestFail("Encounter BZ#1146007") raise error.TestFail("Convert VM failed") # Update parameters for local hypervisor and vm logging.debug("XML info:\n%s", virsh.dumpxml(vm_name)) params['main_vm'] = vm_name params['target'] = "libvirt" # Start VM vm = env.create_vm("libvirt", "libvirt", vm_name, params, test.bindir) vm.start() finally: if hypervisor != "esx": if hypervisor == "xen": utils.run("ssh-agent -k") rsp.delete_pool(pool_name) if rvirsh: rvirsh.close_session()
def run_convert_remote_vm(test, params, env): """ Convert a remote vm to local libvirt(KVM). """ # VM info vm_name = params.get("v2v_vm") # Remote host parameters remote_hostname = params.get("remote_hostname") username = params.get("username", "root") password = params.get("password") remote_hypervisor = params.get("remote_hypervisor") # Local pool parameters pool_type = params.get("pool_type", "dir") pool_name = params.get("pool_name", "v2v_test") target_path = params.get("target_path", "pool_path") block_device = params.get("block_device") vg_name = params.get("volume_group_name", "vg_v2v") # If target_path is not an abs path, join it to test.tmpdir if os.path.dirname(target_path) is "": target_path = os.path.join(test.tmpdir, target_path) # dir pool need an exist path if pool_type == "dir": if not os.path.exists(target_path): os.mkdir(target_path) # V2V parameters input = params.get("input_method") files = params.get("config_files") network = params.get("network", "default") # Result check about ignore_virtio = "yes" == params.get("ignore_virtio", "no") # Create remote uri for remote host # Remote virt-v2v uri's instance ruri = utils_v2v.Uri(remote_hypervisor) remote_uri = ruri.get_uri(remote_hostname) ssh_key.setup_ssh_key(remote_hostname, user=username, port=22, password=password) # Check remote vms remote_vm = libvirt_vm.VM(vm_name, params, test.bindir, env.get("address_cache")) remote_vm.connect_uri = remote_uri if not remote_vm.exists(): raise error.TestFail("Couldn't find vm '%s' to be converted " "on remote uri '%s'." % (vm_name, remote_uri)) # Remote storage pool's instance rsp = libvirt_storage.StoragePool(remote_uri) # Put remote vm's disk into a directory storage pool prepare_remote_sp(rsp, remote_vm, pool_name) # Local storage pool's instance lsp = libvirt_storage.StoragePool() try: # Create storage pool for test if pool_type == "dir": if not create_dir_pool(lsp, pool_name, target_path): raise error.TestFail("Prepare directory storage pool for " "virt-v2v failed.") elif pool_type == "partition": if not create_partition_pool(lsp, pool_name, block_device, target_path): raise error.TestFail("Prepare partition storage pool for " "virt-v2v failed.") elif pool_type == "lvm": if not create_lvm_pool(lsp, pool_name, block_device, vg_name, target_path): raise error.TestFail("Preapre lvm storage pool for " "virt-v2v failed.") # Maintain a single params for v2v to avoid duplicate parameters v2v_params = { "hostname": remote_hostname, "username": username, "password": password, "hypervisor": remote_hypervisor, "storage": pool_name, "network": network, "target": "libvirt", "vms": vm_name, "input": input, "files": files } try: result = utils_v2v.v2v_cmd(v2v_params) except error.CmdError: raise error.TestFail("Virt v2v failed.") # v2v may be successful, but devices' driver may be not virtio error_info = [] # Check v2v vm on local host # Update parameters for local hypervisor and vm params['vms'] = vm_name params['target'] = "libvirt" vm_check = utils_v2v.LinuxVMCheck(test, params, env) if not vm_check.is_disk_virtio(): error_info.append("Error:disk type was not converted to virtio.") if not vm_check.is_net_virtio(): error_info.append("Error:nic type was not converted to virtio.") # Close vm for cleanup if vm_check.vm is not None and vm_check.vm.is_alive(): vm_check.vm.destroy() if not ignore_virtio and len(error_info): raise error.TestFail(error_info) finally: cleanup_vm(vm_name) lsp.delete_pool(pool_name) rsp.delete_pool(pool_name)
def run(test, params, env): """ Convert a local vm disk to local libvirt(KVM). """ # VM info vm_name = params.get("v2v_vm") # Remote host parameters remote_hostname = params.get("remote_hostname") username = params.get("remote_username", "root") password = params.get("remote_passwd") remote_hypervisor = params.get("remote_hypervisor") # Local pool parameters pool_type = params.get("pool_type", "dir") block_device = params.get("block_device", "/dev/BLOCK/EXAMPLE") if pool_type in ['disk', 'partition', 'lvm'] and \ re.search("EXAMPLE", block_device): raise error.TestNAError("Please set correct block device.") pool_name = params.get("pool_name", "v2v_test") target_path = params.get("target_path", "pool_path") vg_name = params.get("volume_group_name", "vg_v2v") local_tmp_path = params.get("local_tmp_path", data_dir.get_tmp_dir()) # If target_path is not an abs path, join it to data_dir.TMPDIR if os.path.dirname(target_path) is "": target_path = os.path.join(data_dir.get_tmp_dir(), target_path) # dir pool need an exist path if pool_type == "dir": if not os.path.exists(target_path): os.mkdir(target_path) # V2V parameters input = params.get("input_method") files = params.get("config_files") network = params.get("network", "default") # Result check about ignore_virtio = "yes" == params.get("ignore_virtio", "no") # Create remote uri for remote host # Remote virt-v2v uri's instance ruri = utils_v2v.Uri(remote_hypervisor) remote_uri = ruri.get_uri(remote_hostname) ssh_key.setup_ssh_key(remote_hostname, user=username, port=22, password=password) # Check remote vms remote_vm = libvirt_vm.VM(vm_name, params, test.bindir, env.get("address_cache")) remote_vm.connect_uri = remote_uri if not remote_vm.exists(): raise error.TestFail("Couldn't find vm '%s' to be converted " "on remote uri '%s'." % (vm_name, remote_uri)) # Copy remote vm's disk to local and create xml file for it tmp_xml_file = copy_remote_vm(remote_vm, local_tmp_path, remote_hostname, username, password) # Local storage pool's instance lsp = libvirt_storage.StoragePool() try: # Create storage pool for test if pool_type == "dir": if not create_dir_pool(lsp, pool_name, target_path): raise error.TestFail("Prepare directory storage pool for " "virt-v2v failed.") elif pool_type == "partition": if not create_partition_pool(lsp, pool_name, block_device, target_path): raise error.TestFail("Prepare partition storage pool for " "virt-v2v failed.") elif pool_type == "lvm": if not create_lvm_pool(lsp, pool_name, block_device, vg_name, target_path): raise error.TestFail("Prepare lvm storage pool for " "virt-v2v failed.") elif pool_type == "disk": if not create_disk_pool(lsp, pool_name, block_device, target_path): raise error.TestFail("Prepare disk storage pool for " "virt-v2v failed.") # Maintain a single params for v2v to avoid duplicate parameters v2v_params = {"hostname": remote_hostname, "username": username, "password": password, "hypervisor": remote_hypervisor, "storage": pool_name, "network": network, "target": "libvirtxml", "vms": tmp_xml_file, "input": input, "files": files} try: result = utils_v2v.v2v_cmd(v2v_params) logging.debug(result) except error.CmdError, detail: raise error.TestFail("Virt v2v failed:\n%s" % str(detail)) # v2v may be successful, but devices' driver may be not virtio error_info = [] # Check v2v vm on local host # Update parameters for local hypervisor and vm params['vms'] = vm_name params['target'] = "libvirt" vm_check = utils_v2v.LinuxVMCheck(test, params, env) try: if not vm_check.is_disk_virtio(): error_info.append("Error:disk type was not converted to " "virtio.") if not vm_check.is_net_virtio(): error_info.append("Error:nic type was not converted to " "virtio.") except (remote.LoginError, virt_vm.VMError), detail: error_info.append(str(detail))
def run(test, params, env): """ Test migration with option --copy-storage-all or --copy-storage-inc. """ vm = env.get_vm(params.get("main_vm")) disk_type = params.get("copy_storage_type", "file") if disk_type == "file": params['added_disk_type'] = "file" else: params['added_disk_type'] = "block" primary_target = vm.get_first_disk_devices()["target"] file_path, file_size = vm.get_device_size(primary_target) # Convert to Gib file_size = int(file_size) / 1073741824 remote_host = params.get("remote_ip", "REMOTE.EXAMPLE") local_host = params.get("local_ip", "LOCAL.EXAMPLE") remote_user = params.get("remote_user", "root") remote_passwd = params.get("remote_pwd", "PASSWORD.EXAMPLE") if remote_host.count("EXAMPLE") or local_host.count("EXAMPLE"): raise error.TestNAError("Config remote or local host first.") # Config ssh autologin for it ssh_key.setup_ssh_key(remote_host, remote_user, remote_passwd, port=22) # Attach additional disks to vm if disk count big than 1 disks_count = int(params.get("added_disks_count", 1)) - 1 if disks_count: new_vm_name = "%s_smtest" % vm.name if vm.is_alive(): vm.destroy() utlv.define_new_vm(vm.name, new_vm_name) vm = libvirt_vm.VM(new_vm_name, vm.params, vm.root_dir, vm.address_cache) vms = [vm] if vm.is_dead(): vm.start() # Abnormal parameters migrate_again = "yes" == params.get("migrate_again", "no") abnormal_type = params.get("abnormal_type") try: rdm = utils_test.RemoteDiskManager(params) vgname = params.get("sm_vg_name", "SMTEST") added_disks_list = [] if disk_type == "lvm": target1 = target2 = "" # For cleanup # Create volume group with iscsi # For local, target is a device name target1 = utlv.setup_or_cleanup_iscsi(is_setup=True, is_login=True, emulated_image="emulated_iscsi1") lv_utils.vg_create(vgname, target1) logging.debug("Created VG %s", vgname) # For remote, target is real target name target2 = utlv.setup_or_cleanup_iscsi(is_setup=True, is_login=False, emulated_image="emulated_iscsi2") logging.debug("Created target: %s", target2) # Login on remote host remote_device = rdm.iscsi_login_setup(local_host, target2) if not rdm.create_vg(vgname, remote_device): raise error.TestError("Create VG %s on %s failed." % (vgname, remote_host)) all_disks = utlv.attach_disks(vm, file_path, vgname, params) # Reserve for cleanup added_disks_list = all_disks.keys() all_disks[file_path] = file_size logging.debug("All disks need to be migrated:%s", all_disks) if abnormal_type == "occupied_disk": occupied_path = rdm.occupy_space(disk_type, file_size, file_path, vgname, timeout=600) if not abnormal_type == "not_exist_file": for disk, size in all_disks.items(): if disk == file_path: rdm.create_image("file", disk, size, None, None) else: rdm.create_image(disk_type, disk, size, vgname, os.path.basename(disk)) fail_flag = False try: logging.debug("Start migration...") copied_migration(vms, params) if migrate_again: fail_flag = True raise error.TestFail("Migration succeed, but not expected!") else: return except error.TestFail: if not migrate_again: raise if abnormal_type == "occupied_disk": rdm.remove_path(disk_type, occupied_path) elif abnormal_type == "not_exist_file": for disk, size in all_disks.items(): if disk == file_path: rdm.create_image("file", disk, size, None, None) else: rdm.create_image(disk_type, disk, size, vgname, os.path.basename(disk)) elif abnormal_type == "migration_interupted": params["thread_timeout"] = 120 # Raise after cleanup if fail_flag: raise # Migrate it again to confirm failed reason copied_migration(vms, params) finally: # Recover created vm if vm.is_alive(): vm.destroy() if disks_count and vm.name == new_vm_name: vm.undefine() for disk in added_disks_list: utlv.delete_local_disk(disk_type, disk) rdm.remove_path(disk_type, disk) rdm.remove_path("file", file_path) if disk_type == "lvm": rdm.remove_vg(vgname) rdm.iscsi_login_setup(local_host, target2, is_login=False) try: lv_utils.vg_remove(vgname) except: pass # let it go to confirm cleanup iscsi device utlv.setup_or_cleanup_iscsi(is_setup=False, emulated_image="emulated_iscsi1") utlv.setup_or_cleanup_iscsi(is_setup=False, emulated_image="emulated_iscsi2")
def run(test, params, env): """ Convert a remote vm to local libvirt(KVM). """ vm_name = params.get("main_vm") # Remote host parameters username = params.get("username", "root") xen_ip = params.get("xen_ip", "XEN.EXAMPLE") xen_pwd = params.get("xen_pwd", "PWD.EXAMPLE") vpx_ip = params.get("vpx_ip", "ESX.EXAMPLE") vpx_pwd = params.get("vpx_pwd", "PWD.EXAMPLE") vpx_pwd_file = params.get("vpx_passwd_file") vpx_dc = params.get("vpx_dc", "VPX.DC.EXAMPLE") esx_ip = params.get("esx_ip", "ESX.EXAMPLE") for param in [vm_name, xen_ip, xen_pwd, vpx_ip, vpx_pwd, vpx_dc, esx_ip]: if "EXAMPLE" in param: raise error.TestNAError("Please replace %s with real value" % param) hypervisor = params.get("hypervisor") pool_type = params.get("pool_type", "dir") pool_name = params.get("pool_name", "v2v_test") target_path = params.get("target_path", "pool_path") emulated_img = params.get("emulated_image_path", "v2v-emulated-img") emulated_size = params.get("emulated_image_size", "10G") # If target_path is not an abs path, join it to data_dir.tmpdir if not os.path.dirname(target_path): target_path = os.path.join(data_dir.get_tmp_dir(), target_path) # V2V parameters input_mode = params.get("input_mode") network = params.get("network") bridge = params.get("bridge") # Set libguestfs environment os.environ['LIBGUESTFS_BACKEND'] = 'direct' # Extra v2v command options, default to None v2v_opts = params.get("v2v_opts") if hypervisor == "esx": # Create password file to access ESX hypervisor remote_ip = vpx_ip remote_pwd = vpx_pwd fp = open(vpx_pwd_file, 'w') fp.write(vpx_pwd) fp.close() if hypervisor == "xen": # Set up ssh access using ssh-agent and authorized_keys remote_ip = xen_ip remote_pwd = xen_pwd ssh_key.setup_ssh_key(remote_ip, user=username, port=22, password=remote_pwd) try: utils_misc.add_identities_into_ssh_agent() except: utils.run("ssh-agent -k") raise error.TestError("Failed to start 'ssh-agent'") # Create remote uri for remote host ruri = utils_v2v.Uri(hypervisor) remote_uri = ruri.get_uri(remote_ip, vpx_dc, esx_ip) logging.debug("The current virsh uri: %s", remote_uri) # Check remote vms rvirsh_dargs = { 'uri': remote_uri, 'remote_ip': remote_ip, 'remote_user': username, 'remote_pwd': remote_pwd } rvirsh = virsh.VirshPersistent(**rvirsh_dargs) if not rvirsh.domain_exists(vm_name): rvirsh.close_session() raise error.TestError("Couldn't find vm '%s' to convert on " "remote uri '%s'." % (vm_name, remote_uri)) remote_vm = libvirt_vm.VM(vm_name, params, test.bindir, env.get("address_cache")) remote_vm.connect_uri = remote_uri # Prepare local libvirt storage pool rsp = libvirt_storage.StoragePool(rvirsh) pvt = utlv.PoolVolumeTest(test, params) lsp = libvirt_storage.StoragePool() # Maintain a single params for v2v to avoid duplicate parameters v2v_params = { "hostname": remote_ip, "username": username, "password": remote_pwd, "hypervisor": hypervisor, "storage": pool_name, "network": network, "bridge": bridge, "target": "libvirt", "main_vm": vm_name, "input_mode": input_mode } if vpx_dc: v2v_params.update({"vpx_dc": vpx_dc}) if esx_ip: v2v_params.update({"esx_ip": esx_ip}) if v2v_opts: v2v_params.update({"v2v_opts": v2v_opts}) try: # Create storage pool for test pvt.pre_pool(pool_name, pool_type, target_path, emulated_img, image_size=emulated_size) logging.debug(lsp.pool_info(pool_name)) ret = utils_v2v.v2v_cmd(v2v_params) logging.debug("virt-v2v verbose messages:\n%s", ret) if ret.exit_status != 0: if "Input/output error" in ret.stderr: raise error.TestFail("Encounter BZ#1146007") raise error.TestFail("Convert VM failed") # Update parameters for local hypervisor and vm, then start vm logging.debug("XML info:\n%s", virsh.dumpxml(vm_name)) params['main_vm'] = vm_name params['target'] = "libvirt" vm = env.create_vm("libvirt", "libvirt", vm_name, params, test.bindir) vm.start() finally: if hypervisor == "esx": utils.run("rm -rf %s" % vpx_pwd_file) else: if hypervisor == "xen": utils.run("ssh-agent -k") rsp.delete_pool(pool_name) if rvirsh: rvirsh.close_session()
def run(test, params, env): """ Test of virt-edit. 1) Get and init parameters for test. 2) Prepare environment. 3) Run virt-edit command and get result. 5) Recover environment. 6) Check result. """ vm_name = params.get("main_vm") vm = env.get_vm(vm_name) remote_host = params.get("virt_edit_remote_host", "HOST.EXAMPLE") remote_user = params.get("virt_edit_remote_user", "root") remote_passwd = params.get("virt_edit_remote_passwd", "PASSWD.EXAMPLE") connect_uri = params.get("virt_edit_connect_uri") if connect_uri is not None: uri = "qemu+ssh://%s@%s/system" % (remote_user, remote_host) if uri.count("EXAMPLE"): raise error.TestNAError("Please config host and passwd first.") # Config ssh autologin for it ssh_key.setup_ssh_key(remote_host, remote_user, remote_passwd, port=22) else: uri = libvirt_vm.normalize_connect_uri( params.get("connect_uri", "default")) start_vm = params.get("start_vm", "no") vm_ref = params.get("virt_edit_vm_ref", vm_name) file_ref = params.get("virt_edit_file_ref", "/etc/hosts") created_img = params.get("virt_edit_created_img", "/tmp/foo.img") foo_line = params.get("foo_line", "") options = params.get("virt_edit_options") options_suffix = params.get("virt_edit_options_suffix") status_error = params.get("status_error", "no") backup_extension = params.get("virt_edit_backup_extension") test_format = params.get("virt_edit_format") # virt-edit should not be used when vm is running. # (for normal test) if vm.is_alive() and start_vm == "no": vm.destroy(gracefully=True) dom_disk_dict = vm.get_disk_devices() # TODO dom_uuid = vm.get_uuid() # Disk format: raw or qcow2 disk_format = None # If object is a disk file path is_disk = False if vm_ref == "domdisk": if len(dom_disk_dict) != 1: raise error.TestError("Only one disk device should exist on " "%s:\n%s." % (vm_name, dom_disk_dict)) disk_detail = dom_disk_dict.values()[0] vm_ref = disk_detail['source'] logging.info("disk to be edit:%s", vm_ref) if test_format: # Get format:raw or qcow2 info = utils.run("qemu-img info %s" % vm_ref).stdout for line in info.splitlines(): comps = line.split(':') if comps[0].count("format"): disk_format = comps[-1].strip() break if disk_format is None: raise error.TestError("Cannot get disk format:%s" % info) is_disk = True elif vm_ref == "domname": vm_ref = vm_name elif vm_ref == "domuuid": vm_ref = dom_uuid elif vm_ref == "createdimg": vm_ref = created_img utils.run("dd if=/dev/zero of=%s bs=256M count=1" % created_img) is_disk = True # Decide whether pass a exprt for virt-edit command. if foo_line != "": expr = "s/$/%s/" % foo_line else: expr = "" if backup_extension is not None: if options is None: options = "" options += " -b %s" % backup_extension # Stop libvirtd if test need. libvirtd = params.get("libvirtd", "on") if libvirtd == "off": utils_libvirtd.libvirtd_stop() # Run test result = lgf.virt_edit_cmd(vm_ref, file_ref, is_disk=is_disk, disk_format=disk_format, options=options, extra=options_suffix, expr=expr, connect_uri=uri, debug=True) status = result.exit_status # Recover libvirtd. if libvirtd == "off": utils_libvirtd.libvirtd_start() utils.run("rm -f %s" % created_img) # Remove backup file in vm if it exists if backup_extension is not None: backup_file = file_ref + backup_extension cleanup_file_in_vm(vm, backup_file) status_error = (status_error == "yes") if status != 0: if not status_error: raise error.TestFail("Command executed failed.") else: if (expr != "" and (not login_to_check_foo_line(vm, file_ref, foo_line))): raise error.TestFail("Virt-edit to add %s in %s failed." "Test failed." % (foo_line, file_ref))
def run(test, params, env): """ Test command: virsh domjobabort. The command can abort the currently running domain job. 1.Prepare test environment,destroy or suspend a VM. 2.Do action to get a subprocess(dump, save, managedsave). 3.Perform virsh domjobabort operation to abort VM's job. 4.Recover the VM's status and wait for the subprocess over. 5.Confirm the test result. """ vm_name = params.get("main_vm", "vm1") vm = env.get_vm(vm_name) start_vm = params.get("start_vm") pre_vm_state = params.get("pre_vm_state", "start") if start_vm == "no" and vm.is_alive(): vm.destroy() # Instead of "paused_after_start_vm", use "pre_vm_state". # After start the VM, wait for some time to make sure the job # can be created on this domain. if start_vm == "yes": vm.wait_for_login() if params.get("pre_vm_state") == "suspend": vm.pause() domid = vm.get_id() domuuid = vm.get_uuid() original_speed = virsh.migrate_getspeed(vm_name).stdout.strip() def get_subprocess(action, vm_name, file, remote_uri=None): """ Execute background virsh command, return subprocess w/o waiting for exit() :param cmd : virsh command. :param guest_name : VM's name :param file_source : virsh command's file option. """ args = "" if action == "managedsave": file = "" elif action == "migrate": # Slow down migration for domjobabort virsh.migrate_setspeed(vm_name, "1") file = remote_uri args = "--unsafe" command = "virsh %s %s %s %s" % (action, vm_name, file, args) logging.debug("Action: %s", command) p = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) return p action = params.get("jobabort_action", "dump") status_error = params.get("status_error", "no") job = params.get("jobabort_job", "yes") tmp_file = os.path.join(test.tmpdir, "domjobabort.tmp") tmp_pipe = os.path.join(test.tmpdir, "domjobabort.fifo") vm_ref = params.get("jobabort_vm_ref") remote_uri = params.get("jobabort_remote_uri") remote_host = params.get("migrate_dest_host") remote_user = params.get("migrate_dest_user", "root") remote_pwd = params.get("migrate_dest_pwd") saved_data = None if action == "managedsave": tmp_pipe = '/var/lib/libvirt/qemu/save/%s.save' % vm.name if action == "restore": virsh.save(vm_name, tmp_file, ignore_status=True) if action == "migrate": if remote_host.count("EXAMPLE"): raise error.TestNAError("Remote host should be configured " "for migrate.") else: # Config ssh autologin for remote host ssh_key.setup_ssh_key(remote_host, remote_user, remote_pwd, port=22) if vm_ref == "id": vm_ref = domid elif vm_ref == "hex_id": vm_ref = hex(int(domid)) elif vm_ref == "uuid": vm_ref = domuuid elif vm_ref.find("invalid") != -1: vm_ref = params.get(vm_ref) elif vm_ref == "name": vm_ref = vm_name # Get the subprocess of VM. # The command's effect is to abort the currently running domain job. # So before do "domjobabort" action, we must create a job on the domain. process = None if job == "yes" and start_vm == "yes" and status_error == "no": if os.path.exists(tmp_pipe): os.unlink(tmp_pipe) os.mkfifo(tmp_pipe) process = get_subprocess(action, vm_name, tmp_pipe, remote_uri) saved_data = None if action == "restore": saved_data = file(tmp_file, 'r').read(10 * 1024 * 1024) f = open(tmp_pipe, 'w') f.write(saved_data[:1024 * 1024]) elif action == "migrate": f = None else: f = open(tmp_pipe, 'r') dummy = f.read(1024 * 1024) # Give enough time for starting job t = 0 while t < 5: jobtype = vm.get_job_type() if "None" == jobtype: t += 1 time.sleep(1) continue elif jobtype is False: logging.error("Get job type failed.") break else: logging.debug("Job started: %s", jobtype) break ret = virsh.domjobabort(vm_ref, ignore_status=True, debug=True) status = ret.exit_status if process and f: if saved_data: f.write(saved_data[1024 * 1024:]) else: dummy = f.read() f.close() if os.path.exists(tmp_pipe): os.unlink(tmp_pipe) if os.path.exists(tmp_file): os.unlink(tmp_file) # Recover the environment. if pre_vm_state == "suspend": vm.resume() if process: if process.poll(): try: process.kill() except OSError: pass if action == "migrate": # Recover migration speed virsh.migrate_setspeed(vm_name, original_speed) utlv.MigrationTest().cleanup_dest_vm(vm, None, remote_uri) # check status_error if status_error == "yes": if status == 0: raise error.TestFail("Run successfully with wrong command!") elif status_error == "no": if status != 0: raise error.TestFail("Run failed with right command")
def run(test, params, env): """ Test qemu-monitor-command blockjobs by migrating with option --copy-storage-all or --copy-storage-inc. """ if not libvirt_version.version_compare(1, 0, 1): raise error.TestNAError("Blockjob functions - " "complete,pause,resume are" "not supported in current libvirt version.") vm = env.get_vm(params.get("main_vm")) cpu_size = int(params.get("cpu_size", "1")) memory_size = int(params.get("memory_size", "1048576")) primary_target = vm.get_first_disk_devices()["target"] file_path, file_size = vm.get_device_size(primary_target) # Convert to Gib file_size = int(file_size) / 1073741824 image_format = utils_test.get_image_info(file_path)["format"] remote_host = params.get("migrate_dest_host", "REMOTE.EXAMPLE") remote_user = params.get("remote_user", "root") remote_passwd = params.get("migrate_dest_pwd", "PASSWORD.EXAMPLE") if remote_host.count("EXAMPLE"): raise error.TestNAError("Config remote or local host first.") # Config ssh autologin for it ssh_key.setup_ssh_key(remote_host, remote_user, remote_passwd, port=22) # Define a new vm with modified cpu/memory new_vm_name = "%s_blockjob" % vm.name if vm.is_alive(): vm.destroy() utlv.define_new_vm(vm.name, new_vm_name) try: set_cpu_memory(new_vm_name, cpu_size, memory_size) vm = libvirt_vm.VM(new_vm_name, vm.params, vm.root_dir, vm.address_cache) except: # Make sure created vm is cleaned up virsh.remove_domain(new_vm_name) raise rdm_params = {"remote_ip": remote_host, "remote_user": remote_user, "remote_pwd": remote_passwd} rdm = utils_test.RemoteDiskManager(rdm_params) try: vm = libvirt_vm.VM(new_vm_name, vm.params, vm.root_dir, vm.address_cache) vm.start() rdm.create_image("file", file_path, file_size, None, None, img_frmt=image_format) logging.debug("Start migration...") copied_migration(vm, params, params.get("qmp_blockjob_type"), primary_target) finally: # Recover created vm if vm.is_alive(): vm.destroy() if vm.name == new_vm_name: vm.undefine() rdm.remove_path("file", file_path) rdm.runner.session.close()
def run(test, params, env): """ Test migration under stress. """ vm_names = params.get("migration_vms").split() if len(vm_names) < 2: raise error.TestNAError("Provide enough vms for migration first.") src_uri = params.get("migrate_src_uri", "qemu+ssh://EXAMPLE/system") if src_uri.count('///') or src_uri.count('EXAMPLE'): raise error.TestNAError("The src_uri '%s' is invalid", src_uri) dest_uri = params.get("migrate_dest_uri", "qemu+ssh://EXAMPLE/system") if dest_uri.count('///') or dest_uri.count('EXAMPLE'): raise error.TestNAError("The dest_uri '%s' is invalid", dest_uri) # Migrated vms' instance vms = [] for vm_name in vm_names: vms.append(libvirt_vm.VM(vm_name, params, test.bindir, env.get("address_cache"))) load_vm_names = params.get("load_vms").split() # vms for load load_vms = [] for vm_name in load_vm_names: load_vms.append(libvirt_vm.VM(vm_name, params, test.bindir, env.get("address_cache"))) params['load_vms'] = load_vms cpu = int(params.get("smp", 1)) memory = int(params.get("mem")) * 1024 stress_type = params.get("migration_stress_type") vm_bytes = params.get("stress_vm_bytes") stress_args = params.get("stress_args") migration_type = params.get("migration_type") start_migration_vms = "yes" == params.get("start_migration_vms", "yes") thread_timeout = int(params.get("thread_timeout", 120)) remote_host = params.get("migrate_dest_host") username = params.get("migrate_dest_user", "root") password = params.get("migrate_dest_pwd") prompt = params.get("shell_prompt", r"[\#\$]") # Set vm_bytes for start_cmd mem_total = utils_memory.memtotal() vm_reserved = len(vms) * memory if vm_bytes == "half": vm_bytes = (mem_total - vm_reserved) / 2 elif vm_bytes == "shortage": vm_bytes = mem_total - vm_reserved + 524288 if vm_bytes is not None: params["stress_args"] = stress_args % vm_bytes for vm in vms: # Keep vm dead for edit if vm.is_alive(): vm.destroy() set_cpu_memory(vm.name, cpu, memory) try: vm_ipaddr = {} if start_migration_vms: for vm in vms: vm.start() vm.wait_for_login() vm_ipaddr[vm.name] = vm.get_address() # TODO: recover vm if start failed? # Config ssh autologin for remote host ssh_key.setup_ssh_key(remote_host, username, password, port=22) do_stress_migration(vms, src_uri, dest_uri, stress_type, migration_type, params, thread_timeout) # Check network of vms on destination if start_migration_vms and migration_type != "cross": for vm in vms: check_dest_vm_network(vm, vm_ipaddr[vm.name], remote_host, username, password, prompt) finally: logging.debug("Cleanup vms...") for vm_name in vm_names: vm = libvirt_vm.VM(vm_name, params, test.bindir, env.get("address_cache")) utlv.MigrationTest().cleanup_dest_vm(vm, None, dest_uri) if vm.is_alive(): vm.destroy(gracefully=False) env.clean_objects()
def verify_migration_speed(test, params, env): """ Check if migration speed is effective with twice migration. """ vms = env.get_all_vms() src_uri = params.get("migrate_src_uri", "qemu+ssh://EXAMPLE/system") dest_uri = params.get("migrate_dest_uri", "qemu+ssh://EXAMPLE/system") if src_uri.count('///') or src_uri.count('EXAMPLE'): raise error.TestNAError("The src_uri '%s' is invalid", src_uri) if dest_uri.count('///') or dest_uri.count('EXAMPLE'): raise error.TestNAError("The dest_uri '%s' is invalid", dest_uri) remote_host = params.get("migrate_dest_host") username = params.get("migrate_dest_user", "root") password = params.get("migrate_dest_pwd") # Config ssh autologin for remote host ssh_key.setup_ssh_key(remote_host, username, password, port=22) # Check migrated vms' state for vm in vms: if vm.is_dead(): vm.start() load_vm_names = params.get("load_vms").split() # vms for load load_vms = [] for vm_name in load_vm_names: load_vms.append(libvirt_vm.VM(vm_name, params, test.bindir, env.get("address_cache"))) bandwidth = int(params.get("bandwidth", "4")) stress_type = params.get("stress_type", "load_vms_booting") migration_type = params.get("migration_type", "orderly") thread_timeout = int(params.get("thread_timeout", "60")) delta = float(params.get("allowed_delta", "0.1")) virsh_migrate_timeout = int(params.get("virsh_migrate_timeout", 60)) # virsh migrate options virsh_migrate_options = "--live --timeout %s", virsh_migrate_timeout # Migrate vms to remote host mig_first = utlv.MigrationTest() virsh_dargs = {"debug": True} for vm in vms: set_get_speed(vm.name, bandwidth, virsh_dargs=virsh_dargs) vm.wait_for_login() utils_test.load_stress(stress_type, vms, params) mig_first.do_migration(vms, src_uri, dest_uri, migration_type, options=virsh_migrate_options, thread_timeout=thread_timeout) for vm in vms: mig_first.cleanup_dest_vm(vm, None, dest_uri) # Keep it clean for second migration if vm.is_alive(): vm.destroy() # Migrate vms again with new bandwidth second_bandwidth = params.get("second_bandwidth", "times") if second_bandwidth == "half": second_bandwidth = bandwidth / 2 speed_times = 2 elif second_bandwidth == "times": second_bandwidth = bandwidth * 2 speed_times = 0.5 elif second_bandwidth == "same": second_bandwidth = bandwidth speed_times = 1 # Migrate again for vm in vms: if vm.is_dead(): vm.start() vm.wait_for_login() set_get_speed(vm.name, second_bandwidth, virsh_dargs=virsh_dargs) utils_test.load_stress(stress_type, vms, params) mig_second = utlv.MigrationTest() mig_second.do_migration(vms, src_uri, dest_uri, migration_type, options="--live", thread_timeout=thread_timeout) for vm in vms: mig_second.cleanup_dest_vm(vm, None, dest_uri) fail_info = [] # Check whether migration failed if len(fail_info): raise error.TestFail(fail_info) for vm in vms: first_time = mig_first.mig_time[vm.name] second_time = mig_second.mig_time[vm.name] logging.debug("Migration time for %s:\n" "Time with Bandwidth '%s' first: %s\n" "Time with Bandwidth '%s' second: %s", vm.name, bandwidth, first_time, second_bandwidth, second_time) shift = float(abs(first_time * speed_times - second_time)) / float(second_time) logging.debug("Shift:%s", shift) if delta < shift: fail_info.append("Spent time for migrating %s is intolerable." % vm.name) # Check again for speed result if len(fail_info): raise error.TestFail(fail_info)
def run(test, params, env): """ Convert a remote vm to local libvirt(KVM). """ # VM info xen_vm_name = params.get("v2v_xen_vm") vmware_vm_name = params.get("v2v_vmware_vm") # Remote host parameters xen_ip = params.get("remote_xen_ip", "XEN.EXAMPLE") vmware_ip = params.get("remote_vmware_ip", "VMWARE.EXAMPLE") username = params.get("username", "root") xen_pwd = params.get("remote_xen_pwd", "PWD.EXAMPLE") vmware_pwd = params.get("remote_vmware_pwd", "PWD.EXAMPLE") # To decide which type test it is remote_hypervisor = params.get("remote_hypervisor") # Local pool parameters pool_type = params.get("pool_type", "dir") pool_name = params.get("pool_name", "v2v_test") target_path = params.get("target_path", "pool_path") emulated_img = params.get("emulated_image_path", "v2v_emulated.img") emulated_size = params.get("emulated_image_size", "10G") # If target_path is not an abs path, join it to data_dir.tmpdir if os.path.dirname(target_path) is "": target_path = os.path.join(data_dir.get_tmp_dir(), target_path) # V2V parameters input = params.get("input_method") files = params.get("config_files") network = params.get("network") bridge = params.get("bridge") # Result check about ignore_virtio = "yes" == params.get("ignore_virtio", "no") # Create autologin to remote host esx_netrc = params.get("esx_netrc") % (vmware_ip, username, vmware_pwd) params['netrc'] = esx_netrc if remote_hypervisor == "esx": remote_ip = vmware_ip remote_pwd = vmware_pwd vm_name = vmware_vm_name if remote_ip.count("EXAMPLE") or remote_pwd.count("EXAMPLE"): raise error.TestNAError("Please provide host or password for " "vmware test.") utils_v2v.build_esx_no_verify(params) else: remote_ip = xen_ip remote_pwd = xen_pwd vm_name = xen_vm_name if remote_ip.count("EXAMPLE") or remote_pwd.count("EXAMPLE"): raise error.TestNAError("Please provide host or password for " "xen test.") ssh_key.setup_ssh_key(xen_ip, user=username, port=22, password=xen_pwd) # Create remote uri for remote host # Remote virt-v2v uri's instance ruri = utils_v2v.Uri(remote_hypervisor) remote_uri = ruri.get_uri(remote_ip) # Check remote vms rvirsh_dargs = {'uri': remote_uri, 'remote_ip': remote_ip, 'remote_user': username, 'remote_pwd': remote_pwd} rvirsh = virsh.VirshPersistent(**rvirsh_dargs) if not rvirsh.domain_exists(vm_name): rvirsh.close_session() raise error.TestFail("Couldn't find vm '%s' to be converted " "on remote uri '%s'." % (vm_name, remote_uri)) if remote_hypervisor != "esx": remote_vm = libvirt_vm.VM(vm_name, params, test.bindir, env.get("address_cache")) remote_vm.connect_uri = remote_uri # Remote storage pool's instance rsp = libvirt_storage.StoragePool(rvirsh) # Put remote vm's disk into a directory storage pool prepare_remote_sp(rsp, remote_vm, pool_name) # Prepare local libvirt storage pool pvt = utlv.PoolVolumeTest(test, params) # Local storage pool's instance lsp = libvirt_storage.StoragePool() try: # Create storage pool for test pvt.pre_pool(pool_name, pool_type, target_path, emulated_img, emulated_size) logging.debug(lsp.pool_info(pool_name)) # Maintain a single params for v2v to avoid duplicate parameters v2v_params = {"hostname": remote_ip, "username": username, "password": remote_pwd, "hypervisor": remote_hypervisor, "storage": pool_name, "network": network, "bridge": bridge, "target": "libvirt", "vms": vm_name, "netrc": esx_netrc, "input": input, "files": files} try: result = utils_v2v.v2v_cmd(v2v_params) logging.debug(result) except error.CmdError, detail: raise error.TestFail("Virt v2v failed:\n%s" % str(detail)) # v2v may be successful, but devices' driver may be not virtio error_info = [] # Check v2v vm on local host # Update parameters for local hypervisor and vm logging.debug("XML info:\n%s", virsh.dumpxml(vm_name)) params['vms'] = vm_name params['target'] = "libvirt" vm_check = utils_v2v.LinuxVMCheck(test, params, env) try: if not vm_check.is_disk_virtio(): error_info.append("Error:disk type was not converted to " "virtio.") if not vm_check.is_net_virtio(): error_info.append("Error:nic type was not converted to " "virtio.") except (remote.LoginError, virt_vm.VMError), detail: error_info.append(str(detail))