def compose_disk_options(test, params, opt_names):
"""
Compose the {disk,mem}spec options
The diskspec file need to add suitable dir with the name which is configed
individually, The 'value' after 'file=' is a parameter which also need to
get from cfg
:params: test & params: system parameters
:params: opt_names: params get from cfg of {disk,mem}spec options
"""
if "snapshot=no" in opt_names:
return opt_names
if opt_names.find("file=") >= 0:
opt_disk = opt_names.split("file=")
opt_list = opt_disk[1].split(",")
if len(opt_list) > 1:
left_opt = opt_list[1]
else:
left_opt = ""
if params.get("bad_disk") is not None or \
params.get("reuse_external") == "yes":
spec_disk = os.path.join(data_dir.get_tmp_dir(), params.get(opt_list[0]))
else:
spec_disk = os.path.join(data_dir.get_tmp_dir(), opt_list[0])
return opt_disk[0] + "file=" + spec_disk + left_opt
def file_exists(params, filename_path):
sg_uri = create_gluster_uri(params, stripped=True)
g_uri = create_gluster_uri(params, stripped=False)
# Using directly /tmp dir because directory should be really temporary and
# should be deleted immediately when no longer needed and
# created directory don't file tmp dir by any data.
tmpdir = "gmount-%s" % (utils_misc.generate_random_string(6))
tmpdir_path = os.path.join(data_dir.get_tmp_dir(), tmpdir)
while os.path.exists(tmpdir_path):
tmpdir = "gmount-%s" % (utils_misc.generate_random_string(6))
tmpdir_path = os.path.join(data_dir.get_tmp_dir(), tmpdir)
ret = False
try:
try:
os.mkdir(tmpdir_path)
glusterfs_mount(sg_uri, tmpdir_path)
mount_filename_path = os.path.join(tmpdir_path,
filename_path[len(g_uri):])
if os.path.exists(mount_filename_path):
ret = True
except Exception as e:
logging.error("Failed to mount gluster volume %s to"
" mount dir %s: %s" % (sg_uri, tmpdir_path, e))
finally:
if utils_misc.umount(sg_uri, tmpdir_path, "glusterfs", False,
"fuse.glusterfs"):
try:
os.rmdir(tmpdir_path)
except OSError:
pass
else:
logging.warning("Unable to unmount tmp directory %s with glusterfs"
" mount.", tmpdir_path)
return ret
def get_kernel_file(vm):
"""
Get the kernel info file from guest.
"""
guestkallsyms = os.path.join(data_dir.get_tmp_dir(), "kallsyms")
guestmodules = os.path.join(data_dir.get_tmp_dir(), "modules")
# scp will miss the content of /proc/kallsysm.
session = vm.wait_for_login()
session.cmd("cat /proc/kallsyms > /root/kallsyms")
session.cmd("cat /proc/modules > /root/modules")
vm.copy_files_from("/root/kallsyms", guestkallsyms)
vm.copy_files_from("/root/modules", guestmodules)
return (guestkallsyms, guestmodules)
def test_upload_offset(test, vm, params):
"""
Test command upload_offset
"""
add_ref = params.get("gf_add_ref", "disk")
readonly = "yes" == params.get("gf_add_readonly")
gf = utils_test.libguestfs.GuestfishTools(params)
if add_ref == "disk":
image_path = params.get("image_path")
gf.add_drive_opts(image_path, readonly=readonly)
elif add_ref == "domain":
vm_name = params.get("main_vm")
gf.add_domain(vm_name, readonly=readonly)
gf.run()
gf.do_mount("/")
filename = "%s/src.txt" % data_dir.get_tmp_dir()
string = "Hello World"
process.getoutput("echo %s > %s" % (string, filename))
gf.upload_offset(filename, "/dest.txt", 0)
content = gf.cat("/dest.txt").stdout.strip()
gf.close_session()
process.getoutput("rm %s" % filename)
if content != string:
test.fail("Content is not correct")
def config_control(control_path):
"""
Edit the control file to adapt the current environment.
Replace CLIENTIP with guestip, and replace SERVERIP with hostip.
:return: Path of a temp file which contains the result of replacing.
"""
pattern2repl_dict = {r'CLIENTIP': vm.get_address(),
r'SERVERIP': utils_net.get_host_ip_address(params)}
control_file = open(control_path)
lines = control_file.readlines()
control_file.close()
for pattern, repl in pattern2repl_dict.items():
for index in range(len(lines)):
line = lines[index]
lines[index] = re.sub(pattern, repl, line)
fd, temp_control_path = tempfile.mkstemp(prefix="control",
dir=data_dir.get_tmp_dir())
os.close(fd)
temp_control = open(temp_control_path, "w")
temp_control.writelines(lines)
temp_control.close()
return temp_control_path
def attach_additional_device(vm_name, disksize, targetdev, params):
"""
Create a disk with disksize, then attach it to given vm.
@param vm: Libvirt VM name.
@param disksize: size of attached disk
@param targetdev: target of disk device
"""
logging.info("Attaching disk...")
disk_path = os.path.join(data_dir.get_tmp_dir(), targetdev)
cmd = "qemu-img create %s %s" % (disk_path, disksize)
status, output = commands.getstatusoutput(cmd)
if status:
return (False, output)
# Update params for source file
params['source_file'] = disk_path
params['target_dev'] = targetdev
# Create a file of device
xmlfile = create_disk_xml(params)
# To confirm attached device do not exist.
virsh.detach_disk(vm_name, targetdev, extra="--config")
return virsh.attach_device(domain_opt=vm_name, file_opt=xmlfile,
flagstr="--config", debug=True)
def test_virt_tar_out(test, vm, params):
"""
1) Write a tempfile to guest
2) Copy file to host with tar-out
3) Delete created file
"""
content = "This is file for test of virt-tar-out."
path = params.get("vt_temp_file", "/tmp/test_virt_tar_out")
file_dir = os.path.dirname(path)
path_on_host = os.path.join(data_dir.get_tmp_dir(),
"test_virt_tar_out.tar")
vt = utils_test.libguestfs.VirtTools(vm, params)
mountpoint = params.get("vt_mountpoint")
if mountpoint is None:
tmpdir = "gmount-%s" % (utils_misc.generate_random_string(6))
mountpoint = "/tmp/%s" % tmpdir
if not os.path.exists(mountpoint):
os.mkdir(mountpoint)
writes, writeo = vt.write_file_with_guestmount(mountpoint, path, content,
cleanup=False)
if utils_misc.umount("", mountpoint, "") is False:
logging.error("Umount vm's filesytem failed.")
if writes is False:
test.fail("Write file to mounted filesystem failed.")
logging.info("Create %s successfully.", path)
# Copy file to host
tar_out_result = vt.tar_out(file_dir, path_on_host)
logging.debug(tar_out_result)
if tar_out_result.exit_status:
test.fail("Tar out failed.")
logging.info("Tar out successfully.")
# uncompress file and check file in it.
uc_result = process.run("cd %s && tar xf %s" % (file_dir, path_on_host),
shell=True)
logging.debug(uc_result)
try:
os.remove(path_on_host)
except IOError as detail:
test.fail(str(detail))
if uc_result.exit_status:
test.fail("uncompress file on host failed.")
logging.info("uncompress file on host successfully.")
# Check file
cat_result = process.run("cat %s" % path, ignore_status=True, shell=True)
logging.debug(cat_result)
try:
os.remove(path)
except IOError as detail:
logging.error(detail)
if cat_result.exit_status:
test.fail("Cat file failed.")
else:
if not re.search(content, cat_result.stdout_text):
test.fail("Catted file do not match.")
def wait_for_match(self, images, similar_degree=0.98, timeout=300):
"""
Compare VM screenshot with given images, if any image in the list
matched, then return the image index, or return -1.
"""
end_time = time.time() + timeout
image_matched = False
cropped_image = os.path.join(data_dir.get_tmp_dir(), "croped.ppm")
while time.time() < end_time:
vm_screenshot = self.get_screenshot()
ppm_utils.image_crop_save(vm_screenshot, vm_screenshot)
img_index = 0
for image in images:
logging.debug("Compare vm screenshot with image %s", image)
ppm_utils.image_crop_save(image, cropped_image)
h_degree = ppm_utils.image_histogram_compare(cropped_image,
vm_screenshot)
if h_degree >= similar_degree:
logging.debug("Image %s matched", image)
image_matched = True
break
img_index += 1
if image_matched:
break
time.sleep(1)
if os.path.exists(cropped_image):
os.unlink(cropped_image)
if os.path.exists(vm_screenshot):
os.unlink(vm_screenshot)
if image_matched:
return img_index
else:
return -1
def test_download_offset(test, vm, params):
"""
Test command download-offset
"""
add_ref = params.get("gf_add_ref", "disk")
readonly = "yes" == params.get("gf_add_readonly")
gf = utils_test.libguestfs.GuestfishTools(params)
if add_ref == "disk":
image_path = params.get("image_path")
gf.add_drive_opts(image_path, readonly=readonly)
elif add_ref == "domain":
vm_name = params.get("main_vm")
gf.add_domain(vm_name, readonly=readonly)
gf.run()
gf.do_mount("/")
string = "Hello World"
gf.write("/src.txt", string)
src_size = gf.filesize("/src.txt").stdout.strip()
dest = "%s/dest.txt" % data_dir.get_tmp_dir()
gf.download_offset("/src.txt", "%s" % dest, 0, len(string))
gf.close_session()
content = process.getoutput("cat %s" % dest)
process.system("rm %s" % dest)
if content != "Hello World":
test.fail("Content or filesize is not match")
def run(test, params, env):
"""
Test for virt-xml-validate
"""
# Get the full path of virt-xml-validate command.
VIRT_XML_VALIDATE = os_dep.command("virt-xml-validate")
vm_name = params.get("main_vm", "virt-tests-vm1")
vm = env.get_vm(vm_name)
schema = params.get("schema", "domain")
output = params.get("output_file", "output")
output_path = os.path.join(data_dir.get_tmp_dir(), output)
if schema == "domain":
virsh.dumpxml(vm_name, to_file=output_path)
# TODO Add more case for other schema.
cmd = "%s %s %s" % (VIRT_XML_VALIDATE, output_path, schema)
cmd_result = utils.run(cmd, ignore_status=True)
if cmd_result.exit_status:
raise error.TestFail("virt-xml-validate command failed.\n"
"Detail: %s." % cmd_result)
if cmd_result.stdout.count("fail"):
raise error.TestFail("xml fails to validate\n"
"Detail: %s." % cmd_result)
def __init__(self, test, params):
self.vm_name = params.get("main_vm", "avocado-vt-vm1")
self.env = params.get("env")
self.vm = self.env.get_vm(self.vm_name)
self.operation_timeout = int(params.get("operation_timeout"))
self.nfs_no_response_sign = params.get("nfs_no_response_sign")
self.export_options = params.get("export_options")
self.mount_options = params.get("mount_options")
self.operation = params.get("operation")
self.operation_option = params.get("operation_option")
self.sav_filename = params.get("sav_filename")
self.iptable_rule = params.get("iptable_rule")
self.vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(
self.vm_name)
self.disk_tgt = self.vmxml_backup.get_disk_all().keys()[0]
def setup_nfs_disk(vm_name):
"""
Setup disk on nfs storage
"""
vmxml = vm_xml.VMXML.new_from_dumpxml(self.vm_name)
disk_xml = vmxml.get_devices(device_type="disk")[0]
source_image_path = disk_xml.source.attrs['file']
logging.debug("VM origin image path: %s", source_image_path)
seLinuxBool = SELinuxBoolean(params)
seLinuxBool.setup()
nfs_res = utils_test.libvirt.setup_or_cleanup_nfs(
is_setup=True,
is_mount=True,
export_options=self.export_options,
mount_options=self.mount_options)
logging.debug('NFS is setup ~~~~~~~~~~')
cp_cmd = process.run("cp %s %s" % (
source_image_path, nfs_res['mount_dir']))
time.sleep(3)
logging.debug("cp command: %s", cp_cmd.command)
vmxml.del_device(disk_xml)
nfs_image_path = os.path.join(
nfs_res['mount_dir'], os.path.basename(source_image_path))
logging.debug("VM new image path %s", nfs_image_path)
disk_dict = {'attrs': {'file': nfs_image_path}}
disk_xml.source = disk_xml.new_disk_source(**disk_dict)
logging.debug("VM new disk xml:\n%s", disk_xml)
vmxml.add_device(disk_xml)
vmxml.sync()
return nfs_res
def operations():
"""
Do save | domstats | blkdeviotune operations
"""
if self.operation == "save":
virsh.save(self.vm_name, self.save_file, debug=True, timeout=self.operation_timeout)
if self.operation == "domstats":
virsh.domstats(self.vm_name, opertions=self.operation_option, debug=True, timeout=self.operation_timeout)
if self.operation == "blkdeviotune":
virsh.blkdeviotune(self.vm_name, self.disk_tgt, debug=True, timeout=self.operation_timeout)
self.nfs_res = setup_nfs_disk(self.vm_name)
self.save_file = os.path.join(data_dir.get_tmp_dir(), self.sav_filename)
self.td = threading.Thread(target=operations)
def test_tar_in(test, vm, params):
"""
1) Fall into guestfish session w/ inspector
2) Write a tempfile on host
3) Copy file to guest with tar-in
4) Delete created file
5) Check file on guest
"""
content = "This is file for test of tar-in."
path = params.get("gf_temp_file", "/tmp/test_tar_in")
path_on_host = os.path.join(data_dir.get_tmp_dir(), "test_tar_in.tar")
# Create a file on host
try:
with open(path, 'w') as fd:
fd.write(content)
except IOError as detail:
test.cancel("Prepare file on host failed:%s" % detail)
try:
tar = tarfile.open(path_on_host, "w")
tar.add(path)
tar.close()
except tarfile.TarError as detail:
test.cancel("Prepare tar file on host failed:%s" % detail)
params['libvirt_domain'] = vm.name
params['gf_inspector'] = True
gf = utils_test.libguestfs.GuestfishTools(params)
# Copy file to guest
tar_in_result = gf.tar_in(path_on_host, "/")
logging.debug(tar_in_result)
# Delete file on host
try:
os.remove(path)
os.remove(path_on_host)
except OSError as detail:
# Let it go because file maybe not exist
logging.warning(detail)
if tar_in_result.exit_status:
gf.close_session()
test.fail("Tar in failed.")
logging.info("Tar in successfully.")
# Cat file on guest
cat_result = gf.cat(path)
rm_result = gf.rm(path)
gf.close_session()
logging.debug(cat_result)
logging.debug(rm_result)
if cat_result.exit_status:
test.fail("Cat file failed.")
else:
if not re.search(content, cat_result.stdout):
test.fail("Catted file do not match")
if rm_result.exit_status:
test.fail("Rm file failed.")
logging.info("Rm %s successfully.", path)
def execute(self):
super(GitRepoParamHelper, self).execute()
cwd = os.path.curdir
os.chdir(self.destination_dir)
process.system('git remote add origin %s' %
self.uri, ignore_status=True)
if self.recursive == 'yes':
process.system('git submodule init')
process.system('git submodule update')
if self.tag:
process.system('git checkout %s' % self.tag)
if self.key_file is not None:
try:
gnupg_home = os.path.join(data_dir.get_tmp_dir(),
'gnupg')
if not os.path.isdir(gnupg_home):
os.makedirs(gnupg_home)
os.environ['GNUPGHOME'] = gnupg_home
process.system('gpg --import %s' % self.key_file)
logging.debug('Verifying if tag is actually signed with '
'GPG key ID %s' % self.key_file)
process.system('git tag -v %s' % self.tag)
except process.CmdError:
raise exceptions.TestError("GPG signature check for git repo "
"%s failed" % self.name)
# Log the top commit message, good for quick reference
process.system('git log -1')
os.chdir(cwd)
def make_image_file_path(self, index):
"""Create backing file for test disk device"""
return os.path.join(data_dir.get_tmp_dir(),
'disk_%s_%s_%d.raw'
% (self.__class__.__name__,
self.identifier,
index))
def test_download_offset(vm, params):
"""
Test command download-offset
"""
add_ref = params.get("gf_add_ref", "disk")
readonly = params.get("gf_add_readonly", "no")
gf = utils_test.libguestfs.GuestfishTools(params)
image_path = params.get("image_path")
gf.add_drive_opts(image_path, readonly=readonly)
gf.run()
gf.do_mount("/")
string = "Hello World"
gf.write("/src.txt", string)
src_size = gf.filesize("/src.txt").stdout.strip()
dest = "%s/dest.txt" % data_dir.get_tmp_dir()
gf.download_offset("/src.txt", "%s" % dest, 0, len(string))
gf.close_session()
content = commands.getoutput("cat %s" % dest)
commands.getstatus("rm %s" % dest)
if content != "Hello World":
raise error.TestFail("Content or filesize is not match")
def test_upload_offset(vm, params):
"""
Test command upload_offset
"""
add_ref = params.get("gf_add_ref", "disk")
readonly = params.get("gf_add_readonly", "no")
gf = utils_test.libguestfs.GuestfishTools(params)
image_path = params.get("image_path")
gf.add_drive_opts(image_path, readonly=readonly)
gf.run()
gf.do_mount("/")
filename = "%s/src.txt" % data_dir.get_tmp_dir()
string = "Hello World"
commands.getoutput("echo %s > %s" % (string, filename))
gf.upload_offset(filename, "/dest.txt", 0)
content = gf.cat("/dest.txt").stdout.strip()
gf.close_session()
commands.getoutput("rm %s" % filename)
if content != string:
raise error.TestFail("Content is not correct")
def setup_ceph_auth():
disk_path = ("rbd:%s:mon_host=%s" % (ceph_disk_name, ceph_mon_ip))
disk_path += (":id=%s:key=%s" % (ceph_auth_user, ceph_auth_key))
if not utils_package.package_install(["ceph-common"]):
test.error("Failed to install ceph-common")
with open(key_file, 'w') as f:
f.write("[%s]\n\tkey = %s\n" %
(ceph_client_name, ceph_client_key))
# Delete the disk if it exists
cmd = ("rbd -m {0} {1} info {2} && rbd -m {0} {1} rm "
"{2}".format(ceph_mon_ip, key_opt, ceph_disk_name))
process.run(cmd, ignore_status=True, shell=True)
# Create an local image and make FS on it.
img_file = os.path.join(data_dir.get_tmp_dir(), "test.img")
disk_cmd = ("qemu-img create -f raw {0} 10M && mkfs.ext4 -F {0}"
.format(img_file))
process.run(disk_cmd, ignore_status=False, shell=True)
# Convert the image to remote storage
# Ceph can only support raw format
disk_cmd = ("qemu-img convert -O %s %s %s"
% ("raw", img_file, disk_path))
process.run(disk_cmd, ignore_status=False, shell=True)
def run(test, params, env):
"""
Test command: virsh dump.
This command can dump the core of a domain to a file for analysis.
1. Positive testing
1.1 Dump domain with valid options.
1.2 Avoid file system cache when dumping.
1.3 Compress the dump images to valid/invalid formats.
2. Negative testing
2.1 Dump domain to a non-exist directory.
2.2 Dump domain with invalid option.
2.3 Dump a shut-off domain.
"""
vm_name = params.get("main_vm", "vm1")
vm = env.get_vm(vm_name)
options = params.get("dump_options")
dump_file = params.get("dump_file", "vm.core")
dump_dir = params.get("dump_dir", data_dir.get_tmp_dir())
if os.path.dirname(dump_file) is "":
dump_file = os.path.join(dump_dir, dump_file)
dump_image_format = params.get("dump_image_format")
start_vm = params.get("start_vm") == "yes"
paused_after_start_vm = params.get("paused_after_start_vm") == "yes"
status_error = params.get("status_error", "no") == "yes"
timeout = int(params.get("check_pid_timeout", "5"))
memory_dump_format = params.get("memory_dump_format", "")
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user')
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
if not libvirt_version.version_compare(1, 1, 1):
if params.get('setup_libvirt_polkit') == 'yes':
test.cancel("API acl test not supported in current"
" libvirt version.")
def wait_pid_active(pid, timeout=5):
"""
Wait for pid in running status
:param: pid: Desired pid
:param: timeout: Max time we can wait
"""
cmd = ("cat /proc/%d/stat | awk '{print $3}'" % pid)
try:
while (True):
timeout = timeout - 1
if not timeout:
test.cancel("Time out for waiting pid!")
pid_status = process.run(cmd, ignore_status=False, shell=True).stdout.strip()
if pid_status != "R":
time.sleep(1)
continue
else:
break
except Exception, detail:
test.fail(detail)
def post_restart_save_restore(params, libvirtd, vm):
"""
Cleanup for test restart_save_restore
"""
save_path = os.path.join(data_dir.get_tmp_dir(), 'tmp.save')
if os.path.exists(save_path):
os.remove(save_path)
def post_pm_test(params, libvirtd, vm):
"""
Cleanup for pm_test.
"""
save_path = os.path.join(data_dir.get_tmp_dir(), 'tmp.save')
if os.path.exists(save_path):
os.remove(save_path)
def secret_validate(file=None, **virsh_dargs):
"""
Test for schema secret
"""
tmp_dir = data_dir.get_tmp_dir()
volume_path = os.path.join(tmp_dir, "secret_volume")
ephemeral = "no"
private = "no"
secret_xml_obj = SecretXML(ephemeral, private)
status, uuid = commands.getstatusoutput("uuidgen")
if status:
raise error.TestNAError("Failed to generate valid uuid")
secret_xml_obj.uuid = uuid
secret_xml_obj.volume = volume_path
secret_xml_obj.usage = "volume"
secret_obj_xmlfile = os.path.join(SECRET_DIR, uuid + ".xml")
cmd_result = virsh.secret_define(secret_xml_obj.xml, debug=True)
cmd_result = virsh.secret_list(**virsh_dargs)
libvirt.check_exit_status(cmd_result)
try:
uuid = re.findall(r"(\S+)\ +(\S+)[\ +\n]", str(cmd_result.stdout))[1][0]
except IndexError:
raise error.TestError("Fail to get secret uuid")
if uuid:
try:
virsh.secret_dumpxml(uuid, to_file=file, **virsh_dargs)
except error.CmdError, e:
raise error.TestError(str(e))
def test_alloc(vm, params):
"""
Test command alloc:
"""
add_ref = params.get("gf_add_ref", "disk")
readonly = "yes" == params.get("gf_add_readonly")
gf = utils_test.libguestfs.GuestfishTools(params)
img_dir = params.get("img_dir", data_dir.get_tmp_dir())
test_img_normal = img_dir + '/alloc_test_normal.img'
test_img_error = img_dir + '/alloc_test_error.img'
os.system('rm -f %s' % test_img_normal)
os.system('rm -f %s' % test_img_error)
gf.alloc(test_img_normal, '100M')
if not os.path.exists(test_img_normal):
gf.close_session()
os.system('rm -f %s' % test_img_normal)
raise error.TestFail("test_alloc failed, file not allocated correctly")
temp, avil_size = commands.getstatusoutput("df -P -B 1G %s | awk 'NR==2{print $4}'" % img_dir)
gf_result = gf.alloc(test_img_error, str(int(avil_size) + 10) + 'G')
if gf_result.exit_status == 0 or os.path.exists(test_img_error):
gf.close_session()
logging.error(gf_result)
os.system('rm -f %s' % test_img_error)
raise error.TestFail("test_alloc failed, alloc doesn't fail without enough space")
gf.close_session()
os.system('rm -f %s' % test_img_normal)
os.system('rm -f %s' % test_img_error)
def test_download(vm, params):
"""
Test command download
"""
add_ref = params.get("gf_add_ref", "disk")
readonly = "yes" == params.get("gf_add_readonly")
gf = utils_test.libguestfs.GuestfishTools(params)
if add_ref == "disk":
image_path = params.get("image_path")
gf.add_drive_opts(image_path, readonly=readonly)
elif add_ref == "domain":
vm_name = params.get("main_vm")
gf.add_domain(vm_name, readonly=readonly)
gf.run()
gf.do_mount("/")
gf.write("/src.txt", "Hello World")
src_size = gf.filesize("/src.txt").stdout.strip()
dest = "%s/dest.txt" % data_dir.get_tmp_dir()
gf.download("/src.txt", "%s" % dest)
gf.close_session()
content = commands.getoutput("cat %s" % dest)
commands.getstatus("rm %s" % dest)
if content != "Hello World":
raise error.TestFail("Content or filesize is not match")
def test_upload(vm, params):
"""
Test command upload
"""
add_ref = params.get("gf_add_ref", "disk")
readonly = "yes" == params.get("gf_add_readonly")
gf = utils_test.libguestfs.GuestfishTools(params)
if add_ref == "disk":
image_path = params.get("image_path")
gf.add_drive_opts(image_path, readonly=readonly)
elif add_ref == "domain":
vm_name = params.get("main_vm")
gf.add_domain(vm_name, readonly=readonly)
gf.run()
gf.do_mount("/")
filename = "%s/src.txt" % data_dir.get_tmp_dir()
fd = open(filename, "w+")
fd.write("Hello World")
fd.close()
gf.upload(filename, "/dest.txt")
content = gf.cat("/dest.txt").stdout.strip()
gf.close_session()
commands.getoutput("rm %s" % filename)
if content != "Hello World":
raise error.TestFail("Content is not correct")
def setUp(self):
# Make all virsh commands fail the test unconditionally
for symbol in dir(virsh):
if symbol not in virsh.NOCLOSE:
# Exceptions are callable
setattr(virsh, symbol, self.bogusVirshFailureException)
# cause any called virsh commands to fail testing unless a mock declared
# necessary so virsh module doesn't complain about missing virsh command
# and to catch any libvirt_xml interface which calls virsh functions
# unexpectidly.
self.dummy_virsh = virsh.Virsh(virsh_exec='/bin/false',
uri='qemu:///system',
debug=True,
ignore_status=True)
# make a tmp_dir to store informations.
LibvirtXMLTestBase.__doms_dir__ = os.path.join(data_dir.get_tmp_dir(),
'domains')
if not os.path.isdir(LibvirtXMLTestBase.__doms_dir__):
os.makedirs(LibvirtXMLTestBase.__doms_dir__)
# Normally not kosher to call super_set, but required here for testing
self.dummy_virsh.__super_set__('capabilities', self._capabilities)
self.dummy_virsh.__super_set__('dumpxml', self._dumpxml)
self.dummy_virsh.__super_set__('domuuid', self._domuuid)
self.dummy_virsh.__super_set__('define', self._define)
self.dummy_virsh.__super_set__('nodedev_dumpxml', self._nodedev_dumpxml)
def test_disk_format(vm, params):
"""
Test command disk-format
"""
add_ref = params.get("gf_add_ref", "disk")
readonly = params.get("gf_add_readonly", "no")
gf = utils_test.libguestfs.GuestfishTools(params)
image_path = params.get("image_path")
gf.add_drive_opts(image_path, readonly=readonly)
gf.run()
image_dir = params.get("img_dir", data_dir.get_tmp_dir())
image_name = params.get('image_name')
image_format = params["image_format"]
params['image_name'] = 'test'
support_format = ['raw', 'cow', 'qcow', 'qcow2', 'vdi', 'vmdk', 'vpc']
for i in support_format:
params['image_format'] = i
image = qemu_storage.QemuImg(params, image_dir, '')
image_path, _ = image.create(params)
result = gf.disk_format(image_path).stdout.strip()
os.remove(image_path)
if result != i:
gf.close_session()
raise error.TestFail("Format is %s, expected is %s" % (result, i))
gf.close_session()
params['image_name'] = image_name
params["image_format"] = image_format
def create_iSCSI(params, root_dir=data_dir.get_tmp_dir()):
iscsi_instance = None
ubuntu = distro.detect().name == 'Ubuntu'
# check and install iscsi initiator packages
if ubuntu:
iscsi_package = ["open-iscsi"]
else:
iscsi_package = ["iscsi-initiator-utils"]
if not utils_package.package_install(iscsi_package):
raise exceptions.TestError("Failed to install iscsi initiator"
" packages")
# Install linux iscsi target software targetcli
iscsi_package = ["targetcli"]
if not utils_package.package_install(iscsi_package):
logging.error("Failed to install targetcli trying with scsi-"
"target-utils or tgt package")
# try with scsi target utils if targetcli is not available
if ubuntu:
iscsi_package = ["tgt"]
else:
iscsi_package = ["scsi-target-utils"]
if not utils_package.package_install(iscsi_package):
raise exceptions.TestError("Failed to install iscsi target and"
" initiator packages")
iscsi_instance = IscsiTGT(params, root_dir)
else:
iscsi_instance = IscsiLIO(params, root_dir)
return iscsi_instance
def run(test, params, env):
"""
Test steps:
1) Get the params from params.
2) Run netperf on guest.
3) Dump each VM and check result.
3) Clean up.
"""
vms = env.get_all_vms()
netperf_control_file = params.get("netperf_controle_file",
"netperf.control")
# Run netperf on guest.
guest_netperf_bts = []
params["test_control_file"] = netperf_control_file
# Fork a new process to run netperf on each guest.
for vm in vms:
params["main_vm"] = vm.name
control_path = os.path.join(test.virtdir, "control",
netperf_control_file)
session = vm.wait_for_login()
bt = utils_test.BackgroundTest(utils_test.run_autotest,
[vm, session, control_path,
None, None, params])
bt.start()
guest_netperf_bts.append(bt)
for vm in vms:
session = vm.wait_for_login()
def _is_netperf_running():
return (not session.cmd_status(
"cat /usr/local/autotest/results/default/debug/client.DEBUG|"
"grep \"seconds remaining\""))
if not utils_misc.wait_for(_is_netperf_running, timeout=120):
test.cancel("Failed to run netperf in guest.\n"
"Since we need to run a autotest of netperf "
"in guest, so please make sure there are some "
"necessary packages in guest, such as gcc, tar, bzip2")
logging.debug("Netperf is already running in VMs.")
try:
dump_path = os.path.join(data_dir.get_tmp_dir(), "dump_file")
for vm in vms:
vm.dump(dump_path)
# Check the status after vm.dump()
if not vm.is_alive():
test.fail("VM is shutoff after dump.")
if vm.wait_for_shutdown():
test.fail("VM is going to shutdown after dump.")
# Check VM is running normally.
vm.wait_for_login()
finally:
# Destroy VM.
for vm in vms:
vm.destroy()
for bt in guest_netperf_bts:
bt.join(ignore_status=True)
def run(test, params, env):
"""
Test command: secret-dumpxml <secret>
Output attributes of a secret as an XML dump to stdout.
"""
# MAIN TEST CODE ###
# Process cartesian parameters
status_error = ("yes" == params.get("status_error", "no"))
secret_ref = params.get("secret_ref")
if secret_ref == "secret_valid_uuid":
# Generate valid uuid
cmd = "uuidgen"
status, uuid = commands.getstatusoutput(cmd)
if status:
raise error.TestNAError("Failed to generate valid uuid")
# Get a full path of tmpfile, the tmpfile need not exist
tmp_dir = data_dir.get_tmp_dir()
volume_path = os.path.join(tmp_dir, "secret_volume")
secret_xml = """
<secret ephemeral='no' private='yes'>
<uuid>%s</uuid>
<usage type='volume'>
<volume>%s</volume>
</usage>
</secret>
""" % (uuid, volume_path)
# Write secret xml into a tmpfile
tmp_file = tempfile.NamedTemporaryFile(prefix=("secret_xml_"),
dir=tmp_dir)
xmlfile = tmp_file.name
tmp_file.close()
fd = open(xmlfile, 'w')
fd.write(secret_xml)
fd.close()
try:
virsh.secret_define(xmlfile, debug=True)
cmd_result = virsh.secret_dumpxml(uuid, debug=True)
output = cmd_result.stdout.strip()
if not status_error and cmd_result.exit_status:
raise error.TestFail("Dumping the xml of secret object failed")
match_string = "<uuid>%s</uuid>" % uuid
if not re.search(match_string, output):
raise error.TestFail("The secret xml is not valid")
finally:
#Cleanup
virsh.secret_undefine(uuid, debug=True)
if os.path.exists(xmlfile):
os.remove(xmlfile)
def run_restart_save_restore(params, libvirtd, vm):
"""
Save and restore a domain after restart daemon.
"""
libvirtd.restart()
save_path = os.path.join(data_dir.get_tmp_dir(), 'tmp.save')
virsh.save(vm.name, save_path)
virsh.restore(save_path)
def run(test, params, env):
"""
Do virsh snapshot-parent and virsh snapshot-current test
with all parameters in readonly/readwrite mode
"""
vm_name = params.get("main_vm")
pstatus_error = params.get("snapshot_parent_status_error", "no")
cstatus_error = params.get("snapshot_current_status_error", "no")
snap_parent_opt = params.get("snapshot_parent_option")
snap_cur_opt = params.get("snapshot_current_option")
passwd = params.get("snapshot_current_passwd")
snap_num = int(params.get("snapshot_num"))
readonly = ("yes" == params.get("readonly", "no"))
without_snapshot = "yes" == params.get("without_snapshot", "no")
snap_opt = []
for i in range(1, snap_num + 1):
screate_opt = params.get("screate_opt%s" % i)
if "SNAPSHOT_TMPFILE" in screate_opt:
tmp_file = os.path.join(data_dir.get_tmp_dir(), "tmpfile")
screate_opt = re.sub("SNAPSHOT_TMPFILE", tmp_file, screate_opt)
snap_opt.append(screate_opt)
# Do xml backup for final recovery
vmxml_backup = vm_xml.VMXML.new_from_dumpxml(vm_name)
# Add passwd for snapshot-current --security-info testing
if snap_cur_opt is not None and "security-info" in snap_cur_opt:
vm = env.get_vm(vm_name)
if vm.is_alive():
vm.destroy()
vm_xml.VMXML.add_security_info(vmxml_backup.copy(), passwd)
vm.start()
def current_snapshot_test():
"""
Do current snapshot test and xml check
"""
output = virsh.snapshot_current(vm_name,
snap_cur_opt,
ignore_status=True,
debug=True,
readonly=readonly)
# If run fail with cstatus_error = no, then error will raise in command
if cstatus_error == "yes":
if output.exit_status == 0:
test.fail("Unexpected snapshot-current success")
else:
logging.info("Failed to run snapshot-current as expected:%s",
output.stderr)
return
# Check if snapshot xml have security info
if "--security-info" in snap_cur_opt and \
"--name" not in snap_cur_opt:
devices = vm_xml.VMXML.new_from_dumpxml(vm_name,
"--security-info").devices
first_graphic = devices.by_device_tag('graphics')[0]
try:
if passwd == first_graphic.passwd:
logging.info("Success to check current snapshot with"
" security info")
else:
test.fail("Passwd is not same as set")
except KeyError:
test.fail("Can not find passwd in snapshot xml")
# Check if --snapshotname may change current snapshot
if "--snapshotname" in snap_cur_opt:
cmd_result = virsh.snapshot_current(vm_name,
ignore_status=True,
debug=True,
readonly=readonly)
current_snap = cmd_result.stdout.strip()
if current_snap == snap_cur_opt.split()[1]:
logging.info("Success to check current snapshot changed to %s",
current_snap)
else:
test.fail("Failed to change current snapshot to %s,"
"current is %s" %
(snap_cur_opt.split()[1], current_snap))
def parent_snapshot_check(snap_parent):
"""
Do parent snapshot check
:params: snap_parent: parent snapshot name that need to check
"""
# get snapshot name which is parent snapshot's child
if "--current" in snap_parent_opt:
cmd_result = virsh.snapshot_current(vm_name)
snap_name = cmd_result.stdout.strip()
else:
snap_name = snap_parent_opt.split()[-1]
# check parent snapshot in snapshot-list
output = virsh.command("snapshot-list %s --parent" % vm_name).stdout
for i in range(2, snap_num + 3):
if output.splitlines()[i].split()[0] == snap_name:
expect_name = output.split('\n')[i].split()[-1]
break
if snap_parent == expect_name:
logging.info("Success to check parent snapshot")
else:
test.fail("Failed to check parent "
"snapshot, expect %s, get %s" %
(expect_name, snap_parent))
def parent_snapshot_test():
"""
Do parent snapshot test
"""
cmd_result = virsh.snapshot_parent(vm_name,
snap_parent_opt,
debug=True,
readonly=readonly)
# check status
if pstatus_error == "yes":
if cmd_result.exit_status == 0:
test.fail("Unexpected success")
else:
logging.info("Run failed as expected:%s", cmd_result.stderr)
elif cmd_result.exit_status != 0:
test.fail("Run failed with right command:%s" % cmd_result.stderr)
else:
parent_snapshot_check(cmd_result.stdout.strip())
try:
if not without_snapshot:
# Create disk snapshot before all to make the origin image clean
ret = virsh.snapshot_create_as(vm_name,
"snap-temp --disk-only",
timeout=300)
if ret.exit_status != 0:
test.fail("Fail to create temp snap, Error: %s" %
ret.stderr.strip())
# Create snapshots
for opt in snap_opt:
result = virsh.snapshot_create_as(vm_name, opt, timeout=300)
if result.exit_status:
test.fail("Failed to create snapshot. Error:%s." %
result.stderr.strip())
time.sleep(1)
# Do parent snapshot test
if snap_parent_opt is not None:
parent_snapshot_test()
# Do current snapshot test
if snap_cur_opt is not None:
current_snapshot_test()
finally:
if not without_snapshot:
utils_test.libvirt.clean_up_snapshots(vm_name)
vmxml_backup.sync("--snapshots-metadata")
try:
os.remove(tmp_file)
except (OSError, NameError): # tmp_file defined inside conditional
pass
def run(test, params, env):
"""
Test disk encryption option.
1.Prepare test environment, destroy or suspend a VM.
2.Prepare tgtd and secret config.
3.Edit disks xml and start the domain.
4.Perform test operation.
5.Recover test environment.
6.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
virsh_dargs = {'debug': True, 'ignore_status': True}
def check_save_restore(save_file):
"""
Test domain save and restore.
"""
# Save the domain.
ret = virsh.save(vm_name, save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
# Restore the domain.
ret = virsh.restore(save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
def check_snapshot():
"""
Test domain snapshot operation.
"""
snapshot1 = "s1"
snapshot2 = "s2"
ret = virsh.snapshot_create_as(vm_name, snapshot1)
libvirt.check_exit_status(ret)
ret = virsh.snapshot_create_as(
vm_name, "%s --disk-only --diskspec vda,"
"file=/tmp/testvm-snap1" % snapshot2)
libvirt.check_exit_status(ret, True)
ret = virsh.snapshot_create_as(
vm_name, "%s --memspec file=%s,snapshot=external"
" --diskspec vda,file=/tmp/testvm-snap2" % (snapshot2, snapshot2))
libvirt.check_exit_status(ret, True)
def check_in_vm(target, old_parts):
"""
Check mount/read/write disk in VM.
:param vm. VM guest.
:param target. Disk dev in VM.
:return: True if check successfully.
"""
try:
session = vm.wait_for_login()
new_parts = utils_disk.get_parts_list(session)
added_parts = list(set(new_parts).difference(set(old_parts)))
logging.info("Added parts:%s", added_parts)
if len(added_parts) != 1:
logging.error("The number of new partitions is invalid in VM")
return False
added_part = None
if target.startswith("vd"):
if added_parts[0].startswith("vd"):
added_part = added_parts[0]
elif target.startswith("hd"):
if added_parts[0].startswith("sd"):
added_part = added_parts[0]
elif target.startswith("sd"):
added_part = added_parts[0]
if not added_part:
logging.error("Cann't see added partition in VM")
return False
utils_disk.linux_disk_check(session, added_part)
session.close()
return True
except (remote.LoginError, virt_vm.VMError, aexpect.ShellError) as e:
logging.error(str(e))
return False
def check_qemu_cmd():
"""
Check qemu-kvm command line options
"""
cmd = ("ps -ef | grep %s | grep -v grep " % vm_name)
if driver_iothread:
cmd += " | grep iothread=iothread%s" % driver_iothread
if process.system(cmd, ignore_status=True, shell=True):
test.fail("Can't see disk option '%s' " "in command line" % cmd)
def check_auth_plaintext(vm_name, password):
"""
Check if libvirt passed the plaintext of the chap authentication
password to qemu.
:param vm_name: The name of vm to be checked.
:param password: The plaintext of password used for chap authentication.
:return: True if using plaintext, False if not.
"""
cmd = ("ps -ef | grep -v grep | grep qemu-kvm | grep %s | grep %s" %
(vm_name, password))
return process.system(cmd, ignore_status=True, shell=True) == 0
# Disk specific attributes.
device = params.get("virt_disk_device", "disk")
device_target = params.get("virt_disk_device_target", "vdd")
device_format = params.get("virt_disk_device_format", "raw")
device_type = params.get("virt_disk_device_type", "file")
device_bus = params.get("virt_disk_device_bus", "virtio")
# Controller specific attributes.
cntlr_type = params.get('controller_type', None)
cntlr_model = params.get('controller_model', None)
cntlr_index = params.get('controller_index', None)
controller_addr_options = params.get('controller_addr_options', None)
driver_iothread = params.get("driver_iothread")
# iscsi options.
iscsi_target = params.get("iscsi_target")
iscsi_host = params.get("iscsi_host")
iscsi_port = params.get("iscsi_port")
emulated_size = params.get("iscsi_image_size", "1")
uuid = params.get("uuid", "")
auth_uuid = "yes" == params.get("auth_uuid", "")
auth_usage = "yes" == params.get("auth_usage", "")
status_error = "yes" == params.get("status_error")
define_error = "yes" == params.get("define_error", "no")
test_save_snapshot = "yes" == params.get("test_save_snapshot", "no")
test_qemu_cmd = "yes" == params.get("test_qemu_cmd", "no")
check_partitions = "yes" == params.get("virt_disk_check_partitions", "yes")
secret_uuid = ""
# Start vm and get all partions in vm.
if device == "lun":
if vm.is_dead():
vm.start()
session = vm.wait_for_login()
old_parts = utils_disk.get_parts_list(session)
session.close()
vm.destroy(gracefully=False)
# Back up xml file.
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
chap_user = ""
chap_passwd = ""
if auth_uuid or auth_usage:
auth_place_in_location = params.get("auth_place_in_location")
if 'source' in auth_place_in_location and not libvirt_version.version_compare(
3, 9, 0):
test.cancel(
"place auth in source is not supported in current libvirt version"
)
auth_type = params.get("auth_type")
secret_usage_target = params.get("secret_usage_target")
secret_usage_type = params.get("secret_usage_type")
chap_user = params.get("iscsi_user")
chap_passwd = params.get("iscsi_password")
sec_xml = secret_xml.SecretXML("no", "yes")
sec_xml.description = "iSCSI secret"
sec_xml.auth_type = auth_type
sec_xml.auth_username = chap_user
sec_xml.usage = secret_usage_type
sec_xml.target = secret_usage_target
sec_xml.xmltreefile.write()
ret = virsh.secret_define(sec_xml.xml)
libvirt.check_exit_status(ret)
secret_uuid = re.findall(r".+\S+(\ +\S+)\ +.+\S+",
ret.stdout.strip())[0].lstrip()
logging.debug("Secret uuid %s", secret_uuid)
if secret_uuid == "":
test.error("Failed to get secret uuid")
# Set secret value
encoding = locale.getpreferredencoding()
secret_string = base64.b64encode(
chap_passwd.encode(encoding)).decode(encoding)
ret = virsh.secret_set_value(secret_uuid, secret_string,
**virsh_dargs)
libvirt.check_exit_status(ret)
# Setup iscsi target
iscsi_target, lun_num = libvirt.setup_or_cleanup_iscsi(
is_setup=True,
is_login=False,
image_size=emulated_size,
chap_user=chap_user,
chap_passwd=chap_passwd,
portal_ip=iscsi_host)
# If we use qcow2 disk format, should format iscsi disk first.
if device_format == "qcow2":
cmd = (
"qemu-img create -f qcow2 iscsi://%s:%s/%s/%s %s" %
(iscsi_host, iscsi_port, iscsi_target, lun_num, emulated_size))
process.run(cmd, shell=True)
# Add disk xml.
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
disk_xml = Disk(type_name=device_type)
disk_xml.device = device
disk_xml.target = {"dev": device_target, "bus": device_bus}
driver_dict = {"name": "qemu", "type": device_format}
# For lun type device, iothread attribute need to be set in controller.
if driver_iothread and device != "lun":
driver_dict.update({"iothread": driver_iothread})
vmxml.iothreads = int(driver_iothread)
elif driver_iothread:
vmxml.iothreads = int(driver_iothread)
disk_xml.driver = driver_dict
# Check if we want to use a faked uuid.
if not uuid:
uuid = secret_uuid
auth_dict = {}
if auth_uuid:
auth_dict = {
"auth_user": chap_user,
"secret_type": secret_usage_type,
"secret_uuid": uuid
}
elif auth_usage:
auth_dict = {
"auth_user": chap_user,
"secret_type": secret_usage_type,
"secret_usage": secret_usage_target
}
disk_source = disk_xml.new_disk_source(
**{
"attrs": {
"protocol": "iscsi",
"name": "%s/%s" % (iscsi_target, lun_num)
},
"hosts": [{
"name": iscsi_host,
"port": iscsi_port
}]
})
if auth_dict:
disk_auth = disk_xml.new_auth(**auth_dict)
if 'source' in auth_place_in_location:
disk_source.auth = disk_auth
if 'disk' in auth_place_in_location:
disk_xml.auth = disk_auth
disk_xml.source = disk_source
if device != "lun":
device_str = "serial_" + device_target
disk_xml.serial = device_str
# Sync VM xml.
vmxml.add_device(disk_xml)
# After virtio 1.0 is enabled, lun type device need use virtio-scsi
# instead of virtio, so additional controller is needed.
# Add controller.
if device == "lun":
ctrl = Controller(type_name=cntlr_type)
if cntlr_model is not None:
ctrl.model = cntlr_model
if cntlr_index is not None:
ctrl.index = cntlr_index
ctrl_addr_dict = {}
for addr_option in controller_addr_options.split(','):
if addr_option != "":
addr_part = addr_option.split('=')
ctrl_addr_dict.update(
{addr_part[0].strip(): addr_part[1].strip()})
ctrl.address = ctrl.new_controller_address(attrs=ctrl_addr_dict)
# If driver_iothread is true, need add iothread attribute in controller.
if driver_iothread:
ctrl_driver_dict = {}
ctrl_driver_dict.update({"iothread": driver_iothread})
ctrl.driver = ctrl_driver_dict
logging.debug("Controller XML is:%s", ctrl)
if cntlr_type:
vmxml.del_controller(cntlr_type)
else:
vmxml.del_controller("scsi")
vmxml.add_device(ctrl)
try:
# Start the VM and check status.
vmxml.sync()
vm.start()
if status_error:
test.fail("VM started unexpectedly.")
# Check Qemu command line
if test_qemu_cmd:
check_qemu_cmd()
except virt_vm.VMStartError as e:
if status_error:
if re.search(uuid, str(e)):
pass
else:
test.fail("VM failed to start." "Error: %s" % str(e))
except xcepts.LibvirtXMLError as xml_error:
if not define_error:
test.fail("Failed to define VM:\n%s" % xml_error)
else:
# Check partitions in VM.
if check_partitions:
if device == "lun":
if not check_in_vm(device_target, old_parts):
test.fail("Check disk partitions in VM failed")
else:
session = vm.wait_for_login()
added_part = utils_disk.get_disk_by_serial(device_str,
session=session)
if not added_part:
test.fail("Unable to get disk with serial {}".format(
device_str))
utils_disk.linux_disk_check(session, added_part)
session.close()
# Test domain save/restore/snapshot.
if test_save_snapshot:
save_file = os.path.join(data_dir.get_tmp_dir(),
"%.save" % vm_name)
check_save_restore(save_file)
check_snapshot()
if os.path.exists(save_file):
os.remove(save_file)
# Test libvirt doesn't pass the plaintext of chap password to qemu,
# this function is implemented in libvirt 4.3.0-1.
if (libvirt_version.version_compare(4, 3, 0)
and (auth_uuid or auth_usage) and chap_passwd):
if (check_auth_plaintext(vm_name, chap_passwd)):
test.fail("Libvirt should not pass plaintext of chap "
"password to qemu-kvm.")
finally:
# Close session.
if 'session' in locals():
session.close()
# Delete snapshots.
libvirt.clean_up_snapshots(vm_name, domxml=vmxml_backup)
# Recover VM.
if vm.is_alive():
vm.destroy(gracefully=False)
vmxml_backup.sync("--snapshots-metadata")
# Delete the tmp files.
libvirt.setup_or_cleanup_iscsi(is_setup=False)
# Clean up secret
if secret_uuid:
virsh.secret_undefine(secret_uuid)
def run(test, params, env):
"""
Different cpu compat mode scenario tests
:param test: QEMU test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def check_feature(vm, feature="", vcpu=0):
"""
Checks the given feature is present
:param vm: VM Name
:param feature: feature to be verified
:param vcpu: vcpu number to pin guest test
:return: true on success, test fail on failure
"""
session = vm.wait_for_login()
if 'power8' in feature:
cmd = 'lscpu|grep -i "Model name:.*power8"'
elif 'xive' in feature:
# remove -v once guest xive support is available
# right now power9 guest supports only xics
cmd = "grep -v xive /sys/firmware/devicetree/base/interrupt-*/compatible"
elif 'xics' in feature:
cmd = "grep -v xive /sys/firmware/devicetree/base/interrupt-*/compatible"
elif 'power9' in feature:
cmd = 'lscpu|grep -i "Model name:.*power9"'
elif 'hpt' in feature:
cmd = 'grep "MMU.*: Hash" /proc/cpuinfo'
elif 'rpt' in feature:
cmd = 'grep "MMU.*: Radix" /proc/cpuinfo'
elif 'isa' in feature:
utils_package.package_install('gcc', session)
cmd = "echo 'int main(){asm volatile (\".long 0x7c0005e6\");"
cmd += "return 0;}' > ~/a.c;cc ~/a.c;taskset -c %s ./a.out" % vcpu
status, output = session.cmd_status_output(cmd)
logging.debug(output)
session.close()
if feature != "isa2.7":
if status != 0:
test.fail("Feature: %s check failed inside "
"%s guest on %s host" %
(feature, guest_version, host_version))
else:
if status == 0:
test.fail("isa3.0 instruction succeeds in "
"%s guest on %s host" %
(guest_version, host_version))
return True
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
pin_vcpu = 0
host_version = params.get("host_version")
guest_version = params.get("guest_version")
max_vcpu = params.get("cpucompat_vcpu_max", "")
cur_vcpu = int(params.get("cpucompat_vcpu_cur", "1"))
cores = int(params.get("topology_cores", '1'))
sockets = int(params.get("topology_sockets", '1'))
threads = int(params.get("topology_threads", '1'))
status_error = "yes" == params.get("status_error", "no")
condn = params.get("condn", "")
guest_features = params.get("guest_features", "")
if guest_features:
guest_features = guest_features.split(',')
if guest_version:
guest_features.append(guest_version)
if host_version not in cpu_util.get_cpu_arch():
test.cancel("Unsupported Host cpu version")
vmxml = libvirt_xml.VMXML.new_from_inactive_dumpxml(vm_name)
org_xml = vmxml.copy()
# Destroy the vm
vm.destroy()
try:
# Set cpu model
if max_vcpu:
pin_vcpu = int(max_vcpu) - 1
libvirt_xml.VMXML.set_vm_vcpus(vm_name,
int(max_vcpu),
cur_vcpu,
sockets=sockets,
cores=cores,
threads=threads,
add_topology=True)
libvirt_xml.VMXML.set_cpu_mode(vm_name, model=guest_version)
logging.debug(virsh.dumpxml(vm_name))
try:
vm.start()
except virt_vm.VMStartError as detail:
if not status_error:
test.fail("%s" % detail)
else:
pass
if max_vcpu:
virsh.setvcpus(vm_name,
int(max_vcpu),
"--live",
ignore_status=False,
debug=True)
if not cpu.check_if_vm_vcpu_match(int(max_vcpu), vm):
test.fail("Vcpu hotplug failed")
if not status_error:
for feature in guest_features:
check_feature(vm, feature, vcpu=pin_vcpu)
if condn == "filetrans":
utils_test.run_file_transfer(test, params, env)
elif condn == "stress":
bt = utils_test.run_avocado_bg(vm, params, test)
if not bt:
test.cancel("guest stress failed to start")
elif condn == "save":
save_file = os.path.join(data_dir.get_tmp_dir(), vm_name + ".save")
result = virsh.save(vm_name,
save_file,
ignore_status=True,
debug=True)
utils_test.libvirt.check_exit_status(result)
# Just sleep few secs before guest recovery
time.sleep(2)
if os.path.exists(save_file):
result = virsh.restore(save_file,
ignore_status=True,
debug=True)
utils_test.libvirt.check_exit_status(result)
os.remove(save_file)
elif condn == "suspend":
result = virsh.suspend(vm_name, ignore_status=True, debug=True)
utils_test.libvirt.check_exit_status(result)
# Just sleep few secs before guest recovery
time.sleep(2)
result = virsh.resume(vm_name, ignore_status=True, debug=True)
utils_test.libvirt.check_exit_status(result)
else:
pass
finally:
org_xml.sync()
def run(test, params, env):
"""
convert specific kvm guest to rhev
"""
for v in list(params.values()):
if "V2V_EXAMPLE" in v:
test.cancel("Please set real value for %s" % v)
if utils_v2v.V2V_EXEC is None:
raise ValueError('Missing command: virt-v2v')
hypervisor = params.get("hypervisor")
vm_name = params.get('main_vm', 'EXAMPLE')
target = params.get('target')
remote_host = params.get('remote_host', 'EXAMPLE')
input_mode = params.get("input_mode")
output_mode = params.get('output_mode')
output_format = params.get('output_format')
source_user = params.get("username", "root")
storage = params.get('output_storage')
bridge = params.get('bridge')
network = params.get('network')
ntp_server = params.get('ntp_server')
vpx_dc = params.get("vpx_dc")
esx_ip = params.get("esx_hostname")
address_cache = env.get('address_cache')
pool_name = params.get('pool_name', 'v2v_test')
pool_type = params.get('pool_type', 'dir')
pool_target = params.get('pool_target_path', 'v2v_pool')
pvt = utlv.PoolVolumeTest(test, params)
v2v_opts = '-v -x' if params.get('v2v_debug', 'on') in ['on', 'force_on'
] else ''
if params.get("v2v_opts"):
# Add a blank by force
v2v_opts += ' ' + params.get("v2v_opts")
v2v_timeout = int(params.get('v2v_timeout', 3600))
skip_vm_check = params.get('skip_vm_check', 'no')
status_error = 'yes' == params.get('status_error', 'no')
checkpoint = params.get('checkpoint', '')
debug_kernel = 'debug_kernel' == checkpoint
backup_list = [
'floppy', 'floppy_devmap', 'fstab_cdrom', 'sata_disk',
'network_rtl8139', 'network_e1000', 'spice', 'spice_encrypt',
'spice_qxl', 'spice_cirrus', 'vnc_qxl', 'vnc_cirrus', 'blank_2nd_disk',
'listen_none', 'listen_socket', 'only_net', 'only_br'
]
error_list = []
# For construct rhv-upload option in v2v cmd
output_method = params.get("output_method")
rhv_upload_opts = params.get("rhv_upload_opts")
storage_name = params.get('storage_name')
# for get ca.crt file from ovirt engine
rhv_passwd = params.get("rhv_upload_passwd")
rhv_passwd_file = params.get("rhv_upload_passwd_file")
ovirt_engine_passwd = params.get("ovirt_engine_password")
ovirt_hostname = params.get("ovirt_engine_url").split(
'/')[2] if params.get("ovirt_engine_url") else None
ovirt_ca_file_path = params.get("ovirt_ca_file_path")
local_ca_file_path = params.get("local_ca_file_path")
# For VDDK
input_transport = params.get("input_transport")
vddk_libdir = params.get('vddk_libdir')
# nfs mount source
vddk_libdir_src = params.get('vddk_libdir_src')
vddk_thumbprint = params.get('vddk_thumbprint')
# Prepare step for different hypervisor
if hypervisor == "xen":
# See man virt-v2v-input-xen(1)
process.run('update-crypto-policies --set LEGACY',
verbose=True,
ignore_status=True,
shell=True)
if hypervisor == "esx":
source_ip = params.get("vpx_hostname")
source_pwd = params.get("vpx_password")
vpx_passwd_file = params.get("vpx_passwd_file")
# Create password file to access ESX hypervisor
with open(vpx_passwd_file, 'w') as f:
f.write(source_pwd)
elif hypervisor == "xen":
source_ip = params.get("xen_hostname")
source_pwd = params.get("xen_host_passwd")
# Set up ssh access using ssh-agent and authorized_keys
xen_pubkey, xen_session = utils_v2v.v2v_setup_ssh_key(source_ip,
source_user,
source_pwd,
auto_close=False)
try:
utils_misc.add_identities_into_ssh_agent()
except Exception as e:
process.run("ssh-agent -k")
test.error("Fail to setup ssh-agent \n %s" % str(e))
elif hypervisor == "kvm":
source_ip = None
source_pwd = None
else:
test.cancel("Unspported hypervisor: %s" % hypervisor)
# Create libvirt URI
v2v_uri = utils_v2v.Uri(hypervisor)
remote_uri = v2v_uri.get_uri(source_ip, vpx_dc, esx_ip)
logging.debug("libvirt URI for converting: %s", remote_uri)
# Make sure the VM exist before convert
v2v_virsh = None
close_virsh = False
if hypervisor == 'kvm':
v2v_virsh = virsh
else:
virsh_dargs = {
'uri': remote_uri,
'remote_ip': source_ip,
'remote_user': source_user,
'remote_pwd': source_pwd,
'auto_close': True,
'debug': True
}
v2v_virsh = virsh.VirshPersistent(**virsh_dargs)
logging.debug('a new virsh session %s was created', v2v_virsh)
close_virsh = True
if not v2v_virsh.domain_exists(vm_name):
test.error("VM '%s' not exist" % vm_name)
def log_fail(msg):
"""
Log error and update error list
"""
logging.error(msg)
error_list.append(msg)
def vm_shell(func):
"""
Decorator of shell session to vm
"""
def wrapper(*args, **kwargs):
vm = libvirt_vm.VM(vm_name, params, test.bindir,
env.get('address_cache'))
if vm.is_dead():
logging.info('VM is down. Starting it now.')
vm.start()
session = vm.wait_for_login()
kwargs['session'] = session
kwargs['vm'] = vm
func(*args, **kwargs)
if session:
session.close()
vm.shutdown()
return wrapper
def check_disks(vmcheck):
"""
Check disk counts inside the VM
"""
# Initialize windows boot up
os_type = params.get("os_type", "linux")
expected_disks = int(params.get("ori_disks", "1"))
logging.debug("Expect %s disks im VM after convert", expected_disks)
# Get disk counts
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(re.findall(r'Disk\s\d', output))
logging.debug("Find %s disks in VM after convert", disks)
if disks == expected_disks:
logging.info("Disk counts is expected")
else:
log_fail("Disk counts is wrong")
def check_vmlinuz_initramfs(v2v_output):
"""
Check if vmlinuz matches initramfs on multi-kernel case
"""
logging.debug('Checking if vmlinuz matches initramfs')
kernel_strs = re.findall(r'(\* kernel.*?\/boot\/config){1,}',
v2v_output, re.DOTALL)
if len(kernel_strs) == 0:
test.error("Not find kernel information")
# Remove duplicate items by set
logging.debug('Boots and kernel info: %s' % set(kernel_strs))
for str_i in set(kernel_strs):
# Fine all versions
kernel_vers = re.findall(r'((?:\d+\.){1,}\d+-(?:\d+\.){1,}\w+)',
str_i)
logging.debug('kernel related versions: %s' % kernel_vers)
# kernel_vers = [kernel, vmlinuz, initramfs] and they should be
# same
if len(kernel_vers) < 3 or len(set(kernel_vers)) != 1:
log_fail("kernel versions does not match: %s" % kernel_vers)
def check_boot_kernel(vmcheck):
"""
Check if converted vm use the latest kernel
"""
_, current_kernel = vmcheck.run_cmd('uname -r')
if 'debug' in current_kernel:
log_fail('Current kernel is a debug kernel: %s' % current_kernel)
# 'sort -V' can satisfy our testing, even though it's not strictly perfect.
# The last one is always the latest kernel version
kernel_normal_list = vmcheck.run_cmd(
'rpm -q kernel | sort -V')[1].strip().splitlines()
status, kernel_debug = vmcheck.run_cmd('rpm -q kernel-debug')
if status != 0:
test.error('Not found kernel-debug package')
all_kernel_list = kernel_normal_list + kernel_debug.strip().splitlines(
)
logging.debug('All kernels: %s' % all_kernel_list)
if len(all_kernel_list) < 3:
test.error(
'Needs at least 2 normal kernels and 1 debug kernel in VM')
# The latest non-debug kernel must be kernel_normal_list[-1]
if current_kernel.strip() != kernel_normal_list[-1].lstrip('kernel-'):
log_fail('Check boot kernel failed')
def check_floppy_exist(vmcheck):
"""
Check if floppy exists after convertion
"""
blk = vmcheck.session.cmd('lsblk')
logging.info(blk)
if not re.search('fd0', blk):
log_fail('Floppy not found')
def attach_removable_media(type, source, dev):
bus = {'cdrom': 'ide', 'floppy': 'fdc', 'disk': 'virtio'}
args = {
'driver': 'qemu',
'subdriver': 'raw',
'sourcetype': 'file',
'type': type,
'targetbus': bus[type]
}
if type == 'cdrom':
args.update({'mode': 'readonly'})
config = ''
# Join all options together to get command line
for key in list(args.keys()):
config += ' --%s %s' % (key, args[key])
config += ' --current'
virsh.attach_disk(vm_name, source, dev, extra=config)
def change_disk_bus(dest):
"""
Change all disks' bus type to $dest
"""
bus_list = ['ide', 'sata', 'virtio']
if dest not in bus_list:
test.error('Bus type not support')
dev_prefix = ['h', 's', 'v']
dev_table = dict(list(zip(bus_list, dev_prefix)))
logging.info('Change disk bus to %s' % dest)
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
disks = vmxml.get_disk_all()
index = 0
for disk in list(disks.values()):
if disk.get('device') != 'disk':
continue
target = disk.find('target')
target.set('bus', dest)
target.set('dev',
dev_table[dest] + 'd' + string.ascii_lowercase[index])
disk.remove(disk.find('address'))
index += 1
vmxml.sync()
def change_network_model(model):
"""
Change network model to $model
"""
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
network_list = vmxml.get_iface_all()
for node in list(network_list.values()):
if node.get('type') == 'network':
node.find('model').set('type', model)
vmxml.sync()
def attach_network_card(model):
"""
Attach network card based on model
"""
if model not in ('e1000', 'virtio', 'rtl8139'):
test.error('Network model not support')
options = {'type': 'network', 'source': 'default', 'model': model}
line = ''
for key in options:
line += ' --' + key + ' ' + options[key]
line += ' --current'
logging.debug(virsh.attach_interface(vm_name, option=line))
def check_multi_netcards(mac_list, vmxml):
"""
Check if number and type of network cards meet expectation
"""
xmltree = xml_utils.XMLTreeFile(vmxml)
iface_nodes = xmltree.find('devices').findall('interface')
iflist = {}
for node in iface_nodes:
mac_addr = node.find('mac').get('address')
iflist[mac_addr] = node
logging.debug('MAC list before v2v: %s' % mac_list)
logging.debug('MAC list after v2v: %s' % list(iflist.keys()))
if set(mac_list).difference(list(iflist.keys())):
log_fail('Missing network interface')
for mac in iflist:
if iflist[mac].find('model').get('type') != 'virtio':
log_fail('Network not convert to virtio')
@vm_shell
def insert_floppy_devicemap(**kwargs):
"""
Add an entry of floppy to device.map
"""
session = kwargs['session']
line = '(fd0) /dev/fd0'
devmap = '/boot/grub/device.map'
if session.cmd_status('ls %s' % devmap):
devmap = '/boot/grub2/device.map'
cmd_exist = 'grep \'(fd0)\' %s' % devmap
cmd_set = 'sed -i \'2i%s\' %s' % (line, devmap)
if session.cmd_status(cmd_exist):
session.cmd(cmd_set)
def make_label(session):
"""
Label a volume, swap or root volume
"""
# swaplabel for rhel7 with xfs, e2label for rhel6 or ext*
cmd_map = {
'root': 'e2label %s ROOT',
'swap': 'swaplabel -L SWAPPER %s'
}
if not session.cmd_status('swaplabel --help'):
blk = 'swap'
elif not session.cmd_status('which e2label'):
blk = 'root'
else:
test.error('No tool to make label')
entry = session.cmd('blkid|grep %s' % blk).strip()
path = entry.split()[0].strip(':')
cmd_label = cmd_map[blk] % path
if 'LABEL' not in entry:
session.cmd(cmd_label)
return blk
@vm_shell
def specify_fstab_entry(type, **kwargs):
"""
Specify entry in fstab file
"""
type_list = ['cdrom', 'uuid', 'label', 'sr0', 'invalid']
if type not in type_list:
test.error('Not support %s in fstab' % type)
session = kwargs['session']
# Specify cdrom device
if type == 'cdrom':
line = '/dev/cdrom /media/CDROM auto exec'
if 'grub2' in utils_misc.get_bootloader_cfg(session):
line += ',nofail'
line += ' 0 0'
logging.debug('fstab entry is "%s"', line)
cmd = [
'mkdir -p /media/CDROM', 'mount /dev/cdrom /media/CDROM',
'echo "%s" >> /etc/fstab' % line
]
for i in range(len(cmd)):
session.cmd(cmd[i])
elif type == 'sr0':
line = params.get('fstab_content')
session.cmd('echo "%s" >> /etc/fstab' % line)
elif type == 'invalid':
line = utils_misc.generate_random_string(6)
session.cmd('echo "%s" >> /etc/fstab' % line)
else:
map = {'uuid': 'UUID', 'label': 'LABEL'}
logging.info(type)
if session.cmd_status('cat /etc/fstab|grep %s' % map[type]):
# Specify device by UUID
if type == 'uuid':
entry = session.cmd(
'blkid -s UUID|grep swap').strip().split()
# Replace path for UUID
origin = entry[0].strip(':')
replace = entry[1].replace('"', '')
# Specify device by label
elif type == 'label':
blk = make_label(session)
entry = session.cmd('blkid|grep %s' % blk).strip()
# Remove " from LABEL="****"
replace = entry.split()[1].strip().replace('"', '')
# Replace the original id/path with label
origin = entry.split()[0].strip(':')
cmd_fstab = "sed -i 's|%s|%s|' /etc/fstab" % (origin, replace)
session.cmd(cmd_fstab)
fstab = session.cmd_output('cat /etc/fstab')
logging.debug('Content of /etc/fstab:\n%s', fstab)
def create_large_file(session, left_space):
"""
Create a large file to make left space of root less than $left_space MB
"""
cmd_df = "df -m / --output=avail"
df_output = session.cmd(cmd_df).strip()
logging.debug('Command output: %s', df_output)
avail = int(df_output.strip().split('\n')[-1])
logging.info('Available space: %dM' % avail)
if avail > left_space - 1:
tmp_dir = data_dir.get_tmp_dir()
if session.cmd_status('ls %s' % tmp_dir) != 0:
session.cmd('mkdir %s' % tmp_dir)
large_file = os.path.join(tmp_dir, 'file.large')
cmd_create = 'dd if=/dev/zero of=%s bs=1M count=%d' % \
(large_file, avail - left_space + 2)
session.cmd(cmd_create, timeout=v2v_timeout)
logging.info('Available space: %sM' % session.cmd(cmd_df).strip())
@vm_shell
def corrupt_rpmdb(**kwargs):
"""
Corrupt rpm db
"""
session = kwargs['session']
# If __db.* exist, remove them, then touch _db.001 to corrupt db.
if not session.cmd_status('ls /var/lib/rpm/__db.001'):
session.cmd('rm -f /var/lib/rpm/__db.*')
session.cmd('touch /var/lib/rpm/__db.001')
if not session.cmd_status('yum update'):
test.error('Corrupt rpmdb failed')
@vm_shell
def grub_serial_terminal(**kwargs):
"""
Edit the serial and terminal lines of grub.conf
"""
session = kwargs['session']
vm = kwargs['vm']
grub_file = utils_misc.get_bootloader_cfg(session)
if 'grub2' in grub_file:
test.cancel('Skip this case on grub2')
cmd = "sed -i '1iserial -unit=0 -speed=115200\\n"
cmd += "terminal -timeout=10 serial console' %s" % grub_file
session.cmd(cmd)
@vm_shell
def set_selinux(value, **kwargs):
"""
Set selinux stat of guest
"""
session = kwargs['session']
current_stat = session.cmd_output('getenforce').strip()
logging.debug('Current selinux status: %s', current_stat)
if current_stat != value:
cmd = "sed -E -i 's/(^SELINUX=).*?/\\1%s/' /etc/selinux/config" % value
logging.info('Set selinux stat with command %s', cmd)
session.cmd(cmd)
@vm_shell
def get_firewalld_status(**kwargs):
"""
Return firewalld service status of vm
"""
session = kwargs['session']
# Example: Active: active (running) since Fri 2019-03-15 01:03:39 CST;
# 3min 48s ago
firewalld_status = session.cmd(
'systemctl status firewalld.service|grep Active:',
ok_status=[0, 3]).strip()
# Exclude the time string because time changes if vm restarts
firewalld_status = re.search(r'Active:\s\w*\s\(\w*\)',
firewalld_status).group()
logging.info('Status of firewalld: %s', firewalld_status)
params[checkpoint] = firewalld_status
def check_firewalld_status(vmcheck, expect_status):
"""
Check if status of firewalld meets expectation
"""
firewalld_status = vmcheck.session.cmd(
'systemctl status '
'firewalld.service|grep Active:',
ok_status=[0, 3]).strip()
# Exclude the time string because time changes if vm restarts
firewalld_status = re.search(r'Active:\s\w*\s\(\w*\)',
firewalld_status).group()
logging.info('Status of firewalld after v2v: %s', firewalld_status)
if firewalld_status != expect_status:
log_fail('Status of firewalld changed after conversion')
@vm_shell
def vm_cmd(cmd_list, **kwargs):
"""
Excecute a list of commands on guest.
"""
session = kwargs['session']
for cmd in cmd_list:
logging.info('Send command "%s"', cmd)
# 'chronyc waitsync' needs more than 2mins to sync clock,
# We set timeout to 300s will not have side-effects for other
# commands.
status, output = session.cmd_status_output(cmd, timeout=300)
logging.debug('Command output:\n%s', output)
if status != 0:
test.error('Command "%s" failed' % cmd)
logging.info('All commands executed')
def check_time_keep(vmcheck):
"""
Check time drift after convertion.
"""
logging.info('Check time drift')
output = vmcheck.session.cmd('chronyc tracking')
logging.debug(output)
if 'Not synchronised' in output:
log_fail('Time not synchronised')
lst_offset = re.search('Last offset *?: *(.*) ', output).group(1)
drift = abs(float(lst_offset))
logging.debug('Time drift is: %f', drift)
if drift > 3:
log_fail('Time drift exceeds 3 sec')
def check_boot():
"""
Check if guest can boot up after configuration
"""
try:
vm = libvirt_vm.VM(vm_name, params, test.bindir,
env.get('address_cache'))
if vm.is_alive():
vm.shutdown()
logging.info('Booting up %s' % vm_name)
vm.start()
vm.wait_for_login()
vm.shutdown()
logging.info('%s is down' % vm_name)
except Exception as e:
test.error('Bootup guest and login failed: %s', str(e))
def check_result(result, status_error):
"""
Check virt-v2v command result
"""
utlv.check_exit_status(result, status_error)
output = result.stdout_text + result.stderr_text
if not status_error:
if output_mode == 'rhev':
if not utils_v2v.import_vm_to_ovirt(
params, address_cache, timeout=v2v_timeout):
test.fail('Import VM failed')
if output_mode == 'libvirt':
try:
virsh.start(vm_name, debug=True, ignore_status=False)
except Exception as e:
test.fail('Start vm failed: %s' % str(e))
# Check guest following the checkpoint document after convertion
vmchecker = VMChecker(test, params, env)
params['vmchecker'] = vmchecker
if params.get('skip_vm_check') != 'yes':
ret = vmchecker.run()
if len(ret) == 0:
logging.info("All common checkpoints passed")
logging.debug(vmchecker.vmxml)
if checkpoint == 'multi_kernel':
check_boot_kernel(vmchecker.checker)
check_vmlinuz_initramfs(output)
if checkpoint == 'floppy':
# Convert to rhv will remove all removeable devices(floppy,
# cdrom)
if output_mode in ['local', 'libvirt']:
check_floppy_exist(vmchecker.checker)
if checkpoint == 'multi_disks':
check_disks(vmchecker.checker)
if checkpoint == 'multi_netcards':
check_multi_netcards(params['mac_address'], vmchecker.vmxml)
if checkpoint.startswith(('spice', 'vnc')):
if checkpoint == 'spice_encrypt':
vmchecker.check_graphics(params[checkpoint])
else:
graph_type = checkpoint.split('_')[0]
vmchecker.check_graphics({'type': graph_type})
video_type = vmchecker.xmltree.find(
'./devices/video/model').get('type')
if video_type.lower() != 'qxl':
log_fail('Video expect QXL, actual %s' % video_type)
if checkpoint.startswith('listen'):
listen_type = vmchecker.xmltree.find(
'./devices/graphics/listen').get('type')
logging.info('listen type is: %s', listen_type)
if listen_type != checkpoint.split('_')[-1]:
log_fail('listen type changed after conversion')
if checkpoint.startswith('selinux'):
status = vmchecker.checker.session.cmd(
'getenforce').strip().lower()
logging.info('Selinux status after v2v:%s', status)
if status != checkpoint[8:]:
log_fail('Selinux status not match')
if checkpoint == 'check_selinuxtype':
expect_output = vmchecker.checker.session.cmd(
'cat /etc/selinux/config')
expect_selinuxtype = re.search(r'^SELINUXTYPE=\s*(\S+)$',
expect_output,
re.MULTILINE).group(1)
actual_output = vmchecker.checker.session.cmd('sestatus')
actual_selinuxtype = re.search(
r'^Loaded policy name:\s*(\S+)$', actual_output,
re.MULTILINE).group(1)
if actual_selinuxtype != expect_selinuxtype:
log_fail('Seliunx type not match')
if checkpoint == 'guest_firewalld_status':
check_firewalld_status(vmchecker.checker, params[checkpoint])
if checkpoint in ['ntpd_on', 'sync_ntp']:
check_time_keep(vmchecker.checker)
# Merge 2 error lists
error_list.extend(vmchecker.errors)
log_check = utils_v2v.check_log(params, output)
if log_check:
log_fail(log_check)
if len(error_list):
test.fail('%d checkpoints failed: %s' %
(len(error_list), error_list))
try:
v2v_sasl = None
v2v_params = {
'target': target,
'hypervisor': hypervisor,
'main_vm': vm_name,
'input_mode': input_mode,
'network': network,
'bridge': bridge,
'storage': storage,
'hostname': source_ip,
'password': source_pwd,
'v2v_opts': v2v_opts,
'new_name': vm_name + utils_misc.generate_random_string(3),
'output_method': output_method,
'storage_name': storage_name,
'rhv_upload_opts': rhv_upload_opts,
'input_transport': input_transport,
'vcenter_host': source_ip,
'vcenter_password': source_pwd,
'vddk_thumbprint': vddk_thumbprint,
'vddk_libdir': vddk_libdir,
'vddk_libdir_src': vddk_libdir_src,
'params': params,
}
if vpx_dc:
v2v_params.update({"vpx_dc": vpx_dc})
if esx_ip:
v2v_params.update({"esx_ip": esx_ip})
output_format = params.get('output_format')
if output_format:
v2v_params.update({'output_format': output_format})
# Build rhev related options
if output_mode == 'rhev':
# Create different sasl_user name for different job
params.update({
'sasl_user':
params.get("sasl_user") + utils_misc.generate_random_string(3)
})
logging.info('sals user name is %s' % params.get("sasl_user"))
# Create SASL user on the ovirt host
user_pwd = "[['%s', '%s']]" % (params.get("sasl_user"),
params.get("sasl_pwd"))
v2v_sasl = utils_sasl.SASL(sasl_user_pwd=user_pwd)
v2v_sasl.server_ip = params.get("remote_ip")
v2v_sasl.server_user = params.get('remote_user')
v2v_sasl.server_pwd = params.get('remote_pwd')
v2v_sasl.setup(remote=True)
logging.debug('A SASL session %s was created', v2v_sasl)
if output_method == 'rhv_upload':
# Create password file for '-o rhv_upload' to connect to ovirt
with open(rhv_passwd_file, 'w') as f:
f.write(rhv_passwd)
# Copy ca file from ovirt to local
remote.scp_from_remote(ovirt_hostname, 22, 'root',
ovirt_engine_passwd, ovirt_ca_file_path,
local_ca_file_path)
if output_mode == 'local':
v2v_params['storage'] = data_dir.get_tmp_dir()
if output_mode == 'libvirt':
pvt.pre_pool(pool_name, pool_type, pool_target, '')
# Set libguestfs environment variable
os.environ['LIBGUESTFS_BACKEND'] = 'direct'
# Save origin graphic type for result checking if source is KVM
if hypervisor == 'kvm':
ori_vm_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
params['ori_graphic'] = ori_vm_xml.xmltreefile.find(
'devices').find('graphics').get('type')
params['vm_machine'] = ori_vm_xml.xmltreefile.find(
'./os/type').get('machine')
backup_xml = None
# Only kvm guest's xml needs to be backup currently
if checkpoint in backup_list and hypervisor == 'kvm':
backup_xml = ori_vm_xml
if checkpoint == 'multi_disks':
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(
vm_name, virsh_instance=v2v_virsh)
disk_count = 0
for disk in list(new_xml.get_disk_all().values()):
if disk.get('device') == 'disk':
disk_count += 1
if disk_count <= 1:
test.error('Not enough disk devices')
params['ori_disks'] = disk_count
if checkpoint == 'sata_disk':
change_disk_bus('sata')
if checkpoint.startswith('floppy'):
if params['vm_machine'] and 'q35' in params['vm_machine'] and int(
re.search(r'pc-q35-rhel(\d+)\.',
params['vm_machine']).group(1)) >= 8:
test.cancel(
'Device isa-fdc is not supported with machine type %s' %
params['vm_machine'])
img_path = data_dir.get_tmp_dir() + '/floppy.img'
utlv.create_local_disk('floppy', img_path)
attach_removable_media('floppy', img_path, 'fda')
if checkpoint == 'floppy_devmap':
insert_floppy_devicemap()
if checkpoint.startswith('fstab'):
if checkpoint == 'fstab_cdrom':
img_path = data_dir.get_tmp_dir() + '/cdrom.iso'
utlv.create_local_disk('iso', img_path)
attach_removable_media('cdrom', img_path, 'hdc')
specify_fstab_entry(checkpoint[6:])
if checkpoint == 'running':
virsh.start(vm_name)
logging.info('VM state: %s' %
virsh.domstate(vm_name).stdout.strip())
if checkpoint == 'paused':
virsh.start(vm_name, '--paused')
logging.info('VM state: %s' %
virsh.domstate(vm_name).stdout.strip())
if checkpoint == 'serial_terminal':
grub_serial_terminal()
check_boot()
if checkpoint == 'no_space':
@vm_shell
def take_space(**kwargs):
create_large_file(kwargs['session'], 20)
take_space()
if checkpoint.startswith('host_no_space'):
session = aexpect.ShellSession('sh')
create_large_file(session, 1000)
if checkpoint == 'host_no_space_setcache':
logging.info('Set LIBGUESTFS_CACHEDIR=/home')
os.environ['LIBGUESTFS_CACHEDIR'] = '/home'
if checkpoint == 'corrupt_rpmdb':
corrupt_rpmdb()
if checkpoint.startswith('network'):
change_network_model(checkpoint[8:])
if checkpoint == 'multi_netcards':
params['mac_address'] = []
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(
vm_name, virsh_instance=v2v_virsh)
network_list = vmxml.get_iface_all()
for mac in network_list:
if network_list[mac].get('type') in ['bridge', 'network']:
params['mac_address'].append(mac)
if len(params['mac_address']) < 2:
test.error('Not enough network interface')
logging.debug('MAC address: %s' % params['mac_address'])
if checkpoint.startswith(('spice', 'vnc')):
if checkpoint == 'spice_encrypt':
spice_passwd = {
'type': 'spice',
'passwd': params.get('spice_passwd', 'redhat')
}
vm_xml.VMXML.set_graphics_attr(vm_name, spice_passwd)
params[checkpoint] = {
'type': 'spice',
'passwdValidTo': '1970-01-01T00:00:01'
}
else:
graphic_video = checkpoint.split('_')
graphic = graphic_video[0]
logging.info('Set graphic type to %s', graphic)
vm_xml.VMXML.set_graphics_attr(vm_name, {'type': graphic})
if len(graphic_video) > 1:
video_type = graphic_video[1]
logging.info('Set video type to %s', video_type)
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
video = vmxml.xmltreefile.find('devices').find(
'video').find('model')
video.set('type', video_type)
# cirrus doesn't support 'ram' and 'vgamem' attribute
if video_type == 'cirrus':
[
video.attrib.pop(attr_i)
for attr_i in ['ram', 'vgamem']
if attr_i in video.attrib
]
vmxml.sync()
if checkpoint.startswith('listen'):
listen_type = checkpoint.split('_')[-1]
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
listen = vmxml.xmltreefile.find('devices').find('graphics').find(
'listen')
listen.set('type', listen_type)
vmxml.sync()
if checkpoint == 'host_selinux_on':
params['selinux_stat'] = utils_selinux.get_status()
utils_selinux.set_status('enforcing')
if checkpoint.startswith('selinux'):
set_selinux(checkpoint[8:])
if checkpoint.startswith('host_firewalld'):
service_mgr = service.ServiceManager()
logging.info('Backing up firewall services status')
params['bk_firewalld_status'] = service_mgr.status('firewalld')
if 'start' in checkpoint:
service_mgr.start('firewalld')
if 'stop' in checkpoint:
service_mgr.stop('firewalld')
if checkpoint == 'guest_firewalld_status':
get_firewalld_status()
if checkpoint == 'remove_securetty':
logging.info('Remove /etc/securetty file from guest')
cmd = ['rm -f /etc/securetty']
vm_cmd(cmd)
if checkpoint == 'ntpd_on':
logging.info('Set service chronyd on')
cmd = [
'yum -y install chrony', 'systemctl start chronyd',
'chronyc add server %s' % ntp_server
]
vm_cmd(cmd)
if checkpoint == 'sync_ntp':
logging.info('Sync time with %s', ntp_server)
cmd = [
'yum -y install chrony', 'systemctl start chronyd',
'chronyc add server %s' % ntp_server, 'chronyc waitsync'
]
vm_cmd(cmd)
if checkpoint == 'blank_2nd_disk':
disk_path = os.path.join(data_dir.get_tmp_dir(), 'blank.img')
logging.info('Create blank disk %s', disk_path)
process.run('truncate -s 1G %s' % disk_path)
logging.info('Attach blank disk to vm')
attach_removable_media('disk', disk_path, 'vdc')
logging.debug(virsh.dumpxml(vm_name))
if checkpoint in ['only_net', 'only_br']:
logging.info('Detatch all networks')
virsh.detach_interface(vm_name, 'network --current', debug=True)
logging.info('Detatch all bridges')
virsh.detach_interface(vm_name, 'bridge --current', debug=True)
if checkpoint == 'only_net':
logging.info('Attach network')
virsh.attach_interface(vm_name,
'network default --current',
debug=True)
v2v_params.pop('bridge')
if checkpoint == 'only_br':
logging.info('Attatch bridge')
virsh.attach_interface(vm_name,
'bridge virbr0 --current',
debug=True)
v2v_params.pop('network')
if checkpoint == 'no_libguestfs_backend':
os.environ.pop('LIBGUESTFS_BACKEND')
if checkpoint == 'file_image':
vm = env.get_vm(vm_name)
disk = vm.get_first_disk_devices()
logging.info('Disk type is %s', disk['type'])
if disk['type'] != 'file':
test.error('Guest is not with file image')
v2v_result = utils_v2v.v2v_cmd(v2v_params)
if v2v_params.get('new_name'):
vm_name = params['main_vm'] = v2v_params['new_name']
check_result(v2v_result, status_error)
finally:
if close_virsh and v2v_virsh:
logging.debug('virsh session %s is closing', v2v_virsh)
v2v_virsh.close_session()
if params.get('vmchecker'):
params['vmchecker'].cleanup()
if hypervisor == "xen":
# Restore crypto-policies to DEFAULT, the setting is impossible to be
# other values by default in testing envrionment.
process.run('update-crypto-policies --set DEFAULT',
verbose=True,
ignore_status=True,
shell=True)
utils_v2v.v2v_setup_ssh_key_cleanup(xen_session, xen_pubkey)
process.run('ssh-agent -k')
if output_mode == 'rhev' and v2v_sasl:
v2v_sasl.cleanup()
logging.debug('SASL session %s is closing', v2v_sasl)
v2v_sasl.close_session()
if output_mode == 'libvirt':
pvt.cleanup_pool(pool_name, pool_type, pool_target, '')
if backup_xml:
backup_xml.sync()
if params.get('selinux_stat') and params['selinux_stat'] != 'disabled':
utils_selinux.set_status(params['selinux_stat'])
if 'bk_firewalld_status' in params:
service_mgr = service.ServiceManager()
if service_mgr.status(
'firewalld') != params['bk_firewalld_status']:
if params['bk_firewalld_status']:
service_mgr.start('firewalld')
else:
service_mgr.stop('firewalld')
if checkpoint.startswith('host_no_space'):
large_file = os.path.join(data_dir.get_tmp_dir(), 'file.large')
if os.path.isfile(large_file):
os.remove(large_file)
# Cleanup constant files
utils_v2v.cleanup_constant_files(params)
def run(test, params, env):
"""
Test vm backingchain, blockcopy
"""
vm_name = params.get('main_vm')
vm = env.get_vm(vm_name)
status_error = 'yes' == params.get('status_error', 'no')
error_msg = params.get('error_msg', '')
case = params.get('case', '')
blockcommand = params.get('blockcommand', '')
blk_top = int(params.get('top', 0))
blk_base = int(params.get('base', 0))
opts = params.get('opts', '--verbose --wait')
check_func = params.get('check_func', '')
disk_type = params.get('disk_type', '')
disk_src = params.get('disk_src', '')
driver_type = params.get('driver_type', 'qcow2')
vol_name = params.get('vol_name', 'vol_blockpull')
pool_name = params.get('pool_name', '')
brick_path = os.path.join(data_dir.get_tmp_dir(), pool_name)
vg_name = params.get('vg_name', 'HostVG')
vol_size = params.get('vol_size', '10M')
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
bkxml = vmxml.copy()
# List to collect paths to delete after test
file_to_del = []
virsh_dargs = {'debug': True, 'ignore_status': False}
try:
all_disks = vmxml.get_disk_source(vm_name)
if not all_disks:
test.error('Not found any disk file in vm.')
image_file = all_disks[0].find('source').get('file')
logging.debug('Image file of vm: %s', image_file)
# Get all dev of virtio disks to calculate the dev of new disk
all_vdisks = [
disk for disk in all_disks
if disk.find('target').get('dev').startswith('vd')
]
disk_dev = all_vdisks[-1].find('target').get('dev')
new_dev = disk_dev[:-1] + chr(ord(disk_dev[-1]) + 1)
# Setup iscsi target
if disk_src == 'iscsi':
disk_target = libvirt.setup_or_cleanup_iscsi(is_setup=True,
is_login=True,
image_size='1G')
logging.debug('ISCSI target: %s', disk_target)
# Setup lvm
elif disk_src == 'lvm':
# Stop multipathd to avoid vgcreate fail
multipathd = service.Factory.create_service("multipathd")
multipathd_status = multipathd.status()
if multipathd_status:
multipathd.stop()
# Setup iscsi target
device_name = libvirt.setup_or_cleanup_iscsi(is_setup=True,
is_login=True,
image_size='1G')
logging.debug('ISCSI target for lvm: %s', device_name)
# Create logical device
logical_device = device_name
lv_utils.vg_create(vg_name, logical_device)
vg_created = True
# Create logical volume as backing store
vol_bk, vol_disk = 'vol1', 'vol2'
lv_utils.lv_create(vg_name, vol_bk, vol_size)
disk_target = '/dev/%s/%s' % (vg_name, vol_bk)
src_vol = '/dev/%s/%s' % (vg_name, vol_disk)
# Setup gluster
elif disk_src == 'gluster':
host_ip = gluster.setup_or_cleanup_gluster(is_setup=True,
vol_name=vol_name,
brick_path=brick_path,
pool_name=pool_name)
logging.debug(host_ip)
gluster_img = 'test.img'
img_create_cmd = "qemu-img create -f raw /mnt/%s 10M" % gluster_img
process.run("mount -t glusterfs %s:%s /mnt; %s; umount /mnt" %
(host_ip, vol_name, img_create_cmd),
shell=True)
disk_target = 'gluster://%s/%s/%s' % (host_ip, vol_name,
gluster_img)
else:
test.error('Wrong disk source, unsupported by this test.')
new_image = os.path.join(os.path.split(image_file)[0], 'test.img')
params['snapshot_list'] = ['s%d' % i for i in range(1, 5)]
if disk_src == 'lvm':
new_image = src_vol
if disk_type == 'block':
new_image = disk_target
for i in range(2, 6):
lv_utils.lv_create(vg_name, 'vol%s' % i, vol_size)
snapshot_image_list = [
'/dev/%s/vol%s' % (vg_name, i) for i in range(2, 6)
]
else:
file_to_del.append(new_image)
snapshot_image_list = [
new_image.replace('img', i) for i in params['snapshot_list']
]
cmd_create_img = 'qemu-img create -f %s -b %s %s -F raw' % (
driver_type, disk_target, new_image)
if disk_type == 'block' and driver_type == 'raw':
pass
else:
process.run(cmd_create_img, verbose=True, shell=True)
info_new = utils_misc.get_image_info(new_image)
logging.debug(info_new)
# Create xml of new disk and add it to vmxml
if disk_type:
new_disk = Disk()
new_disk.xml = libvirt.create_disk_xml({
'type_name': disk_type,
'driver_type': driver_type,
'target_dev': new_dev,
'source_file': new_image
})
logging.debug(new_disk.xml)
vmxml.devices = vmxml.devices.append(new_disk)
vmxml.xmltreefile.write()
logging.debug(vmxml)
vmxml.sync()
vm.start()
logging.debug(virsh.dumpxml(vm_name))
# Create backing chain
for i in range(len(params['snapshot_list'])):
virsh.snapshot_create_as(
vm_name, '%s --disk-only --diskspec %s,file=%s,stype=%s' %
(params['snapshot_list'][i], new_dev, snapshot_image_list[i],
disk_type), **virsh_dargs)
# Get path of each snapshot file
snaps = virsh.domblklist(vm_name, debug=True).stdout.splitlines()
for line in snaps:
if line.lstrip().startswith(('hd', 'sd', 'vd')):
file_to_del.append(line.split()[-1])
qemu_img_cmd = 'qemu-img info --backing-chain %s' % snapshot_image_list[
-1]
if libvirt_storage.check_qemu_image_lock_support():
qemu_img_cmd += " -U"
bc_info = process.run(qemu_img_cmd, verbose=True,
shell=True).stdout_text
if not disk_type == 'block':
bc_chain = snapshot_image_list[::-1] + [new_image, disk_target]
else:
bc_chain = snapshot_image_list[::-1] + [new_image]
bc_result = check_backingchain(bc_chain, bc_info)
if not bc_result:
test.fail(
'qemu-img info output of backing chain is not correct: %s' %
bc_info)
# Generate blockpull/blockcommit options
virsh_blk_cmd = eval('virsh.%s' % blockcommand)
if blockcommand == 'blockpull' and blk_base != 0:
opts += '--base {dev}[{}]'.format(blk_base, dev=new_dev)
elif blockcommand == 'blockcommit':
opt_top = ' --top {dev}[{}]'.format(
blk_top, dev=new_dev) if blk_top != 0 else ''
opt_base = ' --base {dev}[{}]'.format(
blk_base, dev=new_dev) if blk_base != 0 else ''
opts += opt_top + opt_base + ' --active' if blk_top == 0 else ''
# Do blockpull/blockcommit
virsh_blk_cmd(vm_name, new_dev, opts, **virsh_dargs)
if blockcommand == 'blockcommit':
virsh.blockjob(vm_name, new_dev, '--pivot', **virsh_dargs)
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
logging.debug("XML after %s: %s" % (blockcommand, vmxml))
# Check backing chain after blockpull/blockcommit
check_bc_func_name = 'check_bc_%s' % check_func
if check_bc_func_name in globals():
check_bc = eval(check_bc_func_name)
if not callable(check_bc):
logging.warning('Function "%s" is not callable.',
check_bc_func_name)
if not check_bc(blockcommand, vmxml, new_dev, bc_chain):
test.fail('Backing chain check after %s failed' % blockcommand)
else:
logging.warning('Function "%s" is not implemented.',
check_bc_func_name)
virsh.dumpxml(vm_name, debug=True)
# Check whether login is successful
try:
vm.wait_for_login().close()
except Exception as e:
test.fail('Vm login failed')
finally:
logging.info('Start cleaning up.')
for ss in params.get('snapshot_list', []):
virsh.snapshot_delete(vm_name, '%s --metadata' % ss, debug=True)
bkxml.sync()
for path in file_to_del:
logging.debug('Remove %s', path)
if os.path.exists(path):
os.remove(path)
if disk_src == 'iscsi':
libvirt.setup_or_cleanup_iscsi(is_setup=False)
elif disk_src == 'lvm':
process.run('rm -rf /dev/%s/%s' % (vg_name, vol_disk),
ignore_status=True)
if 'vol_bk' in locals():
lv_utils.lv_remove(vg_name, vol_bk)
if 'vg_created' in locals() and vg_created:
lv_utils.vg_remove(vg_name)
cmd = "pvs |grep %s |awk '{print $1}'" % vg_name
pv_name = process.system_output(cmd, shell=True,
verbose=True).strip()
if pv_name:
process.run("pvremove %s" % pv_name,
verbose=True,
ignore_status=True)
libvirt.setup_or_cleanup_iscsi(is_setup=False)
elif disk_src == 'gluster':
gluster.setup_or_cleanup_gluster(is_setup=False,
vol_name=vol_name,
brick_path=brick_path,
pool_name=pool_name)
if 'multipathd_status' in locals() and multipathd_status:
multipathd.start()
def run(test, params, env):
"""
Test command: virsh event and virsh qemu-monitor-event
1. Run virsh event/qemu-monitor-event in a new ShellSession
2. Trigger various events
3. Catch the return of virsh event and qemu-monitor-event, and check it.
"""
vms = []
if params.get("multi_vms") == "yes":
vms = env.get_all_vms()
else:
vm_name = params.get("main_vm")
vms.append(env.get_vm(vm_name))
event_name = params.get("event_name")
event_all_option = "yes" == params.get("event_all_option", "no")
event_list_option = "yes" == params.get("event_list_option", "no")
event_loop = "yes" == params.get("event_loop", "no")
event_timeout = params.get("event_timeout")
event_option = params.get("event_option", "")
status_error = "yes" == params.get("status_error", "no")
qemu_monitor_test = "yes" == params.get("qemu_monitor_test", "no")
signal_name = params.get("signal", None)
panic_model = params.get("panic_model")
addr_type = params.get("addr_type")
addr_iobase = params.get("addr_iobase")
disk_format = params.get("disk_format", "")
event_cmd = "event"
dump_path = '/var/lib/libvirt/qemu/dump'
if qemu_monitor_test:
event_cmd = "qemu-monitor-event"
events_list = params.get("events_list")
if events_list:
events_list = events_list.split(",")
else:
events_list = []
virsh_dargs = {'debug': True, 'ignore_status': True}
virsh_session = aexpect.ShellSession(virsh.VIRSH_EXEC)
for dom in vms:
if dom.is_alive():
dom.destroy()
vmxml_backup = []
for dom in vms:
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(dom.name)
vmxml_backup.append(vmxml.copy())
tmpdir = data_dir.get_tmp_dir()
new_disk = os.path.join(tmpdir, "%s_new_disk.img" % dom.name)
def create_iface_xml():
"""
Create interface xml file
"""
iface = Interface("bridge")
iface.source = eval("{'bridge':'virbr0'}")
iface.model = "virtio"
logging.debug("Create new interface xml: %s", iface)
return iface
def add_disk(vm_name, init_source, target_device, extra_param, format=''):
"""
Add disk/cdrom for test vm
:param vm_name: guest name
:param init_source: source file
:param target_device: target of disk device
:param extra_param: additional arguments to command
:param format: init_source format(qcow2 or raw)
"""
if not os.path.exists(new_disk):
if format == "qcow2":
process.run(
'qemu-img create -f qcow2 %s %s -o preallocation=full' %
(new_disk, '1G'),
shell=True,
verbose=True)
elif format == "raw":
process.run('qemu-img create -f raw %s %s' % (new_disk, '1G'),
shell=True,
verbose=True)
else:
open(new_disk, 'a').close()
if virsh.is_alive(vm_name) and 'cdrom' in extra_param:
virsh.destroy(vm_name)
virsh.attach_disk(vm_name, init_source, target_device, extra_param,
**virsh_dargs)
def wait_for_shutoff(vm):
"""
Wait for the vm to reach state shutoff
:param vm: VM instance
"""
def is_shutoff():
state = vm.state()
logging.debug("Current state: %s", state)
return "shut off" in state
utils_misc.wait_for(is_shutoff,
timeout=90,
first=1,
step=1,
text="Waiting for vm state to be shut off")
def trigger_events(dom, events_list=[]):
"""
Trigger various events in events_list
:param dom: the vm objects corresponding to the domain
:return: the expected output that virsh event command prints out
"""
expected_events_list = []
save_path = os.path.join(tmpdir, "%s_event.save" % dom.name)
print(dom.name)
xmlfile = dom.backup_xml()
try:
for event in events_list:
logging.debug("Current event is: %s", event)
if event in [
'start', 'restore', 'create', 'edit', 'define',
'undefine', 'crash'
]:
if dom.is_alive():
dom.destroy()
if event in ['create', 'define']:
dom.undefine()
else:
if not dom.is_alive():
dom.start()
dom.wait_for_login().close()
if event == "resume":
dom.pause()
if event == "undefine":
virsh.undefine(dom.name, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:"
" Undefined Removed")
elif event == "create":
virsh.create(xmlfile, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:"
" Resumed Unpaused")
expected_events_list.append("'lifecycle' for %s:"
" Started Booted")
elif event == "destroy":
virsh.destroy(dom.name, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:"
" Stopped Destroyed")
elif event == "define":
virsh.define(xmlfile, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:"
" Defined Added")
elif event == "start":
virsh.start(dom.name, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:"
" Resumed Unpaused")
expected_events_list.append("'lifecycle' for %s:"
" Started Booted")
dom.wait_for_login().close()
elif event == "suspend":
virsh.suspend(dom.name, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:"
" Suspended Paused")
if not libvirt_version.version_compare(5, 3, 0):
expected_events_list.append("'lifecycle' for %s:"
" Suspended Paused")
elif event == "resume":
virsh.resume(dom.name, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:"
" Resumed Unpaused")
elif event == "save":
virsh.save(dom.name, save_path, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:"
" Suspended Paused")
expected_events_list.append("'lifecycle' for %s:"
" Stopped Saved")
elif event == "restore":
if not os.path.exists(save_path):
logging.error("%s not exist", save_path)
else:
virsh.restore(save_path, **virsh_dargs)
expected_events_list.append("'lifecycle' for %s:"
" Started Restored")
expected_events_list.append("'lifecycle' for %s:"
" Resumed Snapshot")
elif event == "edit":
#Check whether 'description' element exists.
domxml = virsh.dumpxml(dom.name).stdout.strip()
find_desc = parseString(domxml).getElementsByTagName(
"description")
if find_desc == []:
#If not exists, add one for it.
logging.info("Adding <description> to guest")
virsh.desc(dom.name, "--config",
"Added desc for testvm", **virsh_dargs)
#The edit operation is to delete 'description' element.
edit_cmd = [r":g/<description.*<\/description>/d"]
utlv.exec_virsh_edit(dom.name, edit_cmd)
expected_events_list.append("'lifecycle' for %s:"
" Defined Updated")
elif event == "shutdown":
if signal_name is None:
virsh.shutdown(dom.name, **virsh_dargs)
# Wait a few seconds for shutdown finish
time.sleep(3)
if utils_misc.compare_qemu_version(2, 9, 0):
#Shutdown reason distinguished from qemu_2.9.0-9
expected_events_list.append(
"'lifecycle' for %s:"
" Shutdown Finished after guest request")
else:
os.kill(dom.get_pid(), getattr(signal, signal_name))
if utils_misc.compare_qemu_version(2, 9, 0):
expected_events_list.append(
"'lifecycle' for %s:"
" Shutdown Finished after host request")
if not utils_misc.compare_qemu_version(2, 9, 0):
expected_events_list.append("'lifecycle' for %s:"
" Shutdown Finished")
wait_for_shutoff(dom)
expected_events_list.append("'lifecycle' for %s:"
" Stopped Shutdown")
elif event == "crash":
if not vmxml.xmltreefile.find('devices').findall('panic'):
# Set panic device
panic_dev = Panic()
panic_dev.model = panic_model
panic_dev.addr_type = addr_type
panic_dev.addr_iobase = addr_iobase
vmxml.add_device(panic_dev)
vmxml.on_crash = "coredump-restart"
vmxml.sync()
logging.info("Guest xml now is: %s", vmxml)
dom.start()
session = dom.wait_for_login()
# Stop kdump in the guest
session.cmd("systemctl stop kdump", ignore_all_errors=True)
# Enable sysRq
session.cmd("echo 1 > /proc/sys/kernel/sysrq")
try:
# Crash the guest
session.cmd("echo c > /proc/sysrq-trigger", timeout=90)
except (ShellTimeoutError,
ShellProcessTerminatedError) as details:
logging.info(details)
session.close()
expected_events_list.append("'lifecycle' for %s:"
" Crashed Panicked")
expected_events_list.append("'lifecycle' for %s:"
" Resumed Unpaused")
elif event == "reset":
virsh.reset(dom.name, **virsh_dargs)
expected_events_list.append("'reboot' for %s")
elif event == "vcpupin":
virsh.vcpupin(dom.name, '0', '0', **virsh_dargs)
expected_events_list.append("'tunable' for %s:"
"\n\tcputune.vcpupin0: 0")
elif event == "emulatorpin":
virsh.emulatorpin(dom.name, '0', **virsh_dargs)
expected_events_list.append("'tunable' for %s:"
"\n\tcputune.emulatorpin: 0")
elif event == "setmem":
mem_size = int(params.get("mem_size", 512000))
virsh.setmem(dom.name, mem_size, **virsh_dargs)
expected_events_list.append("'balloon-change' for %s:")
elif event == "device-added-removed":
add_disk(dom.name, new_disk, 'vdb', '')
expected_events_list.append("'device-added' for %s:"
" virtio-disk1")
virsh.detach_disk(dom.name, 'vdb', **virsh_dargs)
expected_events_list.append("'device-removed' for %s:"
" virtio-disk1")
iface_xml_obj = create_iface_xml()
iface_xml_obj.xmltreefile.write()
virsh.detach_device(dom.name, iface_xml_obj.xml,
**virsh_dargs)
expected_events_list.append("'device-removed' for %s:"
" net0")
time.sleep(2)
virsh.attach_device(dom.name, iface_xml_obj.xml,
**virsh_dargs)
expected_events_list.append("'device-added' for %s:"
" net0")
elif event == "block-threshold":
add_disk(dom.name, new_disk, 'vdb', '', format=disk_format)
logging.debug(process.run('qemu-img info %s -U' %
new_disk))
virsh.domblkthreshold(vm_name, 'vdb', '100M')
session = dom.wait_for_login()
session.cmd(
"mkfs.ext4 /dev/vdb && mount /dev/vdb /mnt && ls /mnt && "
"dd if=/dev/urandom of=/mnt/bigfile bs=1M count=300 && sync"
)
time.sleep(5)
session.close()
expected_events_list.append(
"'block-threshold' for %s:"
" dev: vdb(%s) 104857600 29368320")
virsh.detach_disk(dom.name, 'vdb', **virsh_dargs)
elif event == "change-media":
target_device = "hdc"
device_target_bus = params.get("device_target_bus", "ide")
disk_blk = vm_xml.VMXML.get_disk_blk(dom.name)
logging.info("disk_blk %s", disk_blk)
if target_device not in disk_blk:
logging.info("Adding cdrom to guest")
if dom.is_alive():
dom.destroy()
add_disk(
dom.name, "''", target_device,
("--type cdrom --sourcetype file --driver qemu " +
"--config --targetbus %s" % device_target_bus))
dom.start()
all_options = new_disk + " --insert"
virsh.change_media(dom.name, target_device, all_options,
**virsh_dargs)
expected_events_list.append("'tray-change' for %s disk" +
" .*%s.*:" %
device_target_bus + " opened")
expected_events_list.append("'tray-change' for %s disk" +
" .*%s.*:" %
device_target_bus + " closed")
all_options = new_disk + " --eject"
virsh.change_media(dom.name, target_device, all_options,
**virsh_dargs)
expected_events_list.append("'tray-change' for %s disk" +
" .*%s.*:" %
device_target_bus + " opened")
elif event == "hwclock":
session = dom.wait_for_login()
try:
session.cmd("hwclock --systohc", timeout=60)
except (ShellTimeoutError,
ShellProcessTerminatedError) as details:
logging.info(details)
session.close()
expected_events_list.append("'rtc-change' for %s:")
elif event == "metadata_set":
metadata_uri = params.get("metadata_uri")
metadata_key = params.get("metadata_key")
metadata_value = params.get("metadata_value")
virsh.metadata(dom.name,
metadata_uri,
options="",
key=metadata_key,
new_metadata=metadata_value,
**virsh_dargs)
expected_events_list.append("'metadata-change' for %s: "
"element http://app.org/")
elif event == "metadata_edit":
metadata_uri = "http://herp.derp/"
metadata_key = "herp"
metadata_value = "<derp xmlns:foobar='http://foo.bar/'>foo<bar></bar></derp>"
virsh_cmd = r"virsh metadata %s --uri %s --key %s %s"
virsh_cmd = virsh_cmd % (dom.name, metadata_uri,
metadata_key, "--edit")
session = aexpect.ShellSession("sudo -s")
logging.info("Running command: %s", virsh_cmd)
try:
session.sendline(virsh_cmd)
session.sendline(r":insert")
session.sendline(metadata_value)
session.sendline(".")
session.send('ZZ')
remote.handle_prompts(session,
None,
None,
r"[\#\$]\s*$",
debug=True,
timeout=60)
except Exception as e:
test.error("Error occured: %s" % e)
session.close()
# Check metadata after edit
virsh.metadata(dom.name,
metadata_uri,
options="",
key=metadata_key,
**virsh_dargs)
expected_events_list.append("'metadata-change' for %s: "
"element http://app.org/")
elif event == "metadata_remove":
virsh.metadata(dom.name,
metadata_uri,
options="--remove",
key=metadata_key,
**virsh_dargs)
expected_events_list.append("'metadata-change' for %s: "
"element http://app.org/")
else:
test.error("Unsupported event: %s" % event)
# Event may not received immediately
time.sleep(3)
finally:
if os.path.exists(save_path):
os.unlink(save_path)
if os.path.exists(new_disk):
os.unlink(new_disk)
return [(dom.name, event) for event in expected_events_list]
def check_output(output, expected_events_list):
"""
Check received domain event in output.
:param output: The virsh shell output, such as:
Welcome to virsh, the virtualization interactive terminal.
Type: 'help' for help with commands
'quit' to quit
virsh # event 'lifecycle' for domain avocado-vt-vm1: Started Booted
events received: 1
virsh #
:param expected_events_list: A list of expected events
"""
logging.debug("Actual events: %s", output)
event_idx = 0
for dom_name, event in expected_events_list:
if event in expected_events_list[0]:
event_idx = 0
if re.search("block-threshold", event):
event_str = "block-threshold"
else:
event_str = "event " + event % ("domain %s" % dom_name)
logging.info("Expected event: %s", event_str)
match = re.search(event_str, output[event_idx:])
if match:
event_idx = event_idx + match.start(0) + len(match.group(0))
continue
else:
test.fail("Not find expected event:%s. Is your "
"guest too slow to get started in %ss?" %
(event_str, event_timeout))
try:
# Set vcpu placement to static to avoid emulatorpin fail
vmxml.placement = 'static'
# Using a large memeoy(>1048576) to avoid setmem fail
vmxml.max_mem = 2097152
vmxml.current_mem = 2097152
vmxml.sync()
if event_all_option and not qemu_monitor_test:
event_option += " --all"
if event_list_option:
event_option += " --list"
if event_loop:
event_option += " --loop"
if not status_error and not event_list_option:
event_cmd += " %s" % event_option
if event_name and not qemu_monitor_test:
event_cmd += " --event %s" % event_name
if event_timeout:
event_cmd += " --timeout %s" % event_timeout
# Run the command in a new virsh session, then waiting for
# various events
logging.info("Sending '%s' to virsh shell", event_cmd)
virsh_session.sendline(event_cmd)
elif qemu_monitor_test:
result = virsh.qemu_monitor_event(event=event_name,
event_timeout=event_timeout,
options=event_option,
**virsh_dargs)
utlv.check_exit_status(result, status_error)
else:
result = virsh.event(event=event_name,
event_timeout=event_timeout,
options=event_option,
**virsh_dargs)
utlv.check_exit_status(result, status_error)
if not status_error:
if not event_list_option:
expected_events_list = []
virsh_dargs['ignore_status'] = False
for dom in vms:
expected_events_list.extend(
trigger_events(dom, events_list))
if event_timeout:
# Make sure net-event will timeout on time
time.sleep(int(event_timeout))
elif event_loop:
virsh_session.send_ctrl("^C")
time.sleep(5)
ret_output = virsh_session.get_stripped_output()
if qemu_monitor_test:
# Not check for qemu-monitor-event output
expected_events_list = []
check_output(ret_output, expected_events_list)
finally:
for dom in vms:
if dom.is_alive():
dom.destroy()
virsh_session.close()
for xml in vmxml_backup:
xml.sync()
if os.path.exists(dump_path):
shutil.rmtree(dump_path)
os.mkdir(dump_path)
def run(test, params, env):
"""
Test command: virsh setvcpus.
The command can change the number of virtual CPUs in the guest domain.
1.Prepare test environment,destroy or suspend a VM.
2.Perform virsh setvcpus operation.
3.Recover test environment.
4.Confirm the test result.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
pre_vm_state = params.get("setvcpus_pre_vm_state")
command = params.get("setvcpus_command", "setvcpus")
options = params.get("setvcpus_options")
vm_ref = params.get("setvcpus_vm_ref", "name")
status_error = (params.get("status_error", "no") == "yes")
convert_err = "Can't convert {0} to integer type"
try:
current_vcpu = int(params.get("setvcpus_current", "1"))
except ValueError:
test.error(convert_err.format(current_vcpu))
try:
max_vcpu = int(params.get("setvcpus_max", "4"))
except ValueError:
test.error(convert_err.format(max_vcpu))
try:
count = params.get("setvcpus_count", "")
if count:
count = eval(count)
count = int(count)
except ValueError:
# 'count' may not invalid number in negative tests
logging.debug(convert_err.format(count))
extra_param = params.get("setvcpus_extra_param")
count_option = "%s %s" % (count, extra_param)
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
remote_pwd = params.get("remote_pwd", "")
remote_user = params.get("remote_user", "root")
remote_uri = params.get("remote_uri")
tmpxml = os.path.join(data_dir.get_tmp_dir(), 'tmp.xml')
topology_correction = "yes" == params.get("topology_correction", "yes")
with_topology = "yes" == params.get("with_topology", "yes")
result = True
# Early death 1.1
if remote_uri:
if remote_ip.count("EXAMPLE.COM"):
test.cancel("remote ip parameters not set.")
ssh_key.setup_ssh_key(remote_ip, remote_user, remote_pwd)
# Early death 1.2
option_list = options.split(" ")
for item in option_list:
if virsh.has_command_help_match(command, item) is None:
test.cancel("The current libvirt version"
" doesn't support '%s' option" % item)
# Init expect vcpu count values
exp_vcpu = {
'max_config': max_vcpu,
'max_live': max_vcpu,
'cur_config': current_vcpu,
'cur_live': current_vcpu,
'guest_live': current_vcpu
}
def set_expected(vm, options):
"""
Set the expected vcpu numbers
:param vm: vm object
:param options: setvcpus options
"""
if ("config" in options) or ("current" in options and vm.is_dead()):
if "maximum" in options:
exp_vcpu["max_config"] = count
else:
exp_vcpu['cur_config'] = count
if ("live" in options) or ("current" in options and vm.is_alive()):
exp_vcpu['cur_live'] = count
exp_vcpu['guest_live'] = count
if options == '':
# when none given it defaults to live
exp_vcpu['cur_live'] = count
exp_vcpu['guest_live'] = count
# Save original configuration
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
orig_config_xml = vmxml.copy()
# Normal processing of the test is to set the maximum vcpu count to 4,
# and set the current vcpu count to 1, then adjust the 'count' value to
# plug or unplug vcpus.
#
# This is generally fine when the guest is not running; however, the
# hotswap functionality hasn't always worked very well and is under
# going lots of change from using the hmp "cpu_set" command in 1.5
# to a new qmp "cpu-add" added in 1.6 where the "cpu-set" command
# seems to have been deprecated making things very messy.
#
# To further muddy the waters, the "cpu-add" functionality is supported
# for specific machine type versions. For the purposes of this test that
# would be "pc-i440fx-1.5" or "pc-q35-1.5" or later type machines (from
# guest XML "<os> <type ... machine=''/type> </os>"). Depending on which
# version of qemu/kvm was used to initially create/generate the XML for
# the machine this could result in a newer qemu still using 1.4 or earlier
# for the machine type.
#
try:
# Set maximum vcpus, so we can run all kinds of normal tests without
# encounter requested vcpus greater than max allowable vcpus error
topology = vmxml.get_cpu_topology()
if topology and ("config"
and "maximum" in options) and not status_error:
# https://bugzilla.redhat.com/show_bug.cgi?id=1426220
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
del vmxml.cpu
vmxml.sync()
# If topology not existed, create new one.
if not topology and with_topology and status_error:
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
vmcpu_xml = vmxml['cpu']
except xcepts.LibvirtXMLNotFoundError:
logging.debug("Can not find any cpu tag, now create one.")
vmcpu_xml = VMCPUXML()
cores = vmxml['vcpu']
vmcpu_xml['topology'] = {
'sockets': 1,
'cores': cores,
'threads': 1
}
vmxml['cpu'] = vmcpu_xml
vmxml.sync()
vmxml.set_vm_vcpus(vm_name,
max_vcpu,
current_vcpu,
topology_correction=topology_correction)
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
logging.debug("Pre-test xml is %s", vmxml.xmltreefile)
# Get the number of cpus, current value if set, and machine type
cpu_xml_data = utils_hotplug.get_cpu_xmldata(vm, options)
logging.debug(
"Before run setvcpus: cpu_count=%d, cpu_current=%d,"
" mtype=%s", cpu_xml_data['vcpu'], cpu_xml_data['current_vcpu'],
cpu_xml_data['mtype'])
# Restart, unless that's not our test
if not vm.is_alive():
vm.start()
vm.wait_for_login()
if cpu_xml_data['vcpu'] == 1 and count == 1:
logging.debug(
"Original vCPU count is 1, just checking if setvcpus "
"can still set current.")
domid = vm.get_id() # only valid for running
domuuid = vm.get_uuid()
if pre_vm_state == "paused":
vm.pause()
elif pre_vm_state == "shut off" and vm.is_alive():
vm.destroy()
# Run test
if vm_ref == "name":
dom_option = vm_name
elif vm_ref == "id":
dom_option = domid
if params.get("setvcpus_hex_id") is not None:
dom_option = hex(int(domid))
elif params.get("setvcpus_invalid_id") is not None:
dom_option = params.get("setvcpus_invalid_id")
elif vm_ref == "uuid":
dom_option = domuuid
if params.get("setvcpus_invalid_uuid") is not None:
dom_option = params.get("setvcpus_invalid_uuid")
else:
dom_option = vm_ref
if remote_uri:
status = virsh.setvcpus(dom_option,
"1",
"--config",
ignore_status=True,
debug=True,
uri=remote_uri)
else:
status = virsh.setvcpus(dom_option,
count_option,
options,
ignore_status=True,
debug=True)
if not status_error:
set_expected(vm, options)
result = utils_hotplug.check_vcpu_value(vm,
exp_vcpu,
option=options)
setvcpu_exit_status = status.exit_status
setvcpu_exit_stderr = status.stderr.strip()
finally:
cpu_xml_data = utils_hotplug.get_cpu_xmldata(vm, options)
logging.debug(
"After run setvcpus: cpu_count=%d, cpu_current=%d,"
" mtype=%s", cpu_xml_data['vcpu'], cpu_xml_data['current_vcpu'],
cpu_xml_data['mtype'])
# Cleanup
if pre_vm_state == "paused":
virsh.resume(vm_name, ignore_status=True)
orig_config_xml.sync()
if os.path.exists(tmpxml):
os.remove(tmpxml)
# check status_error
if status_error:
if setvcpu_exit_status == 0:
test.fail("Run successfully with wrong command!")
else:
if setvcpu_exit_status != 0:
# setvcpu/hotplug is only available as of qemu 1.5 and it's still
# evolving. In general the addition of vcpu's may use the QMP
# "cpu_set" (qemu 1.5) or "cpu-add" (qemu 1.6 and later) commands.
# The removal of vcpu's may work in qemu 1.5 due to how cpu_set
# can set vcpus online or offline; however, there doesn't appear
# to be a complementary cpu-del feature yet, so we can add, but
# not delete in 1.6.
# A 1.6 qemu will not allow the cpu-add command to be run on
# a configuration using <os> machine property 1.4 or earlier.
# That is the XML <os> element with the <type> property having
# an attribute 'machine' which is a tuple of 3 elements separated
# by a dash, such as "pc-i440fx-1.5" or "pc-q35-1.5".
if re.search("unable to execute QEMU command 'cpu-add'",
setvcpu_exit_stderr):
test.cancel("guest <os> machine property '%s' "
"may be too old to allow hotplug." %
cpu_xml_data['mtype'])
# A qemu older than 1.5 or an unplug for 1.6 will result in
# the following failure. In general, any time libvirt determines
# it cannot support adding or removing a vCPU...
if re.search("cannot change vcpu count of this domain",
setvcpu_exit_stderr):
test.cancel("virsh setvcpu hotplug unsupported, "
" mtype=%s" % cpu_xml_data['mtype'])
# Otherwise, it seems we have a real error
test.fail("Run failed with right command mtype=%s"
" stderr=%s" %
(cpu_xml_data['mtype'], setvcpu_exit_stderr))
else:
if not result:
test.fail("Test Failed")
def run(test, params, env):
"""
Test command: virsh dump.
This command can dump the core of a domain to a file for analysis.
1. Positive testing
1.1 Dump domain with valid options.
1.2 Avoid file system cache when dumping.
1.3 Compress the dump images to valid/invalid formats.
2. Negative testing
2.1 Dump domain to a non-exist directory.
2.2 Dump domain with invalid option.
2.3 Dump a shut-off domain.
"""
vm_name = params.get("main_vm", "vm1")
vm = env.get_vm(vm_name)
options = params.get("dump_options")
dump_file = params.get("dump_file", "vm.core")
dump_dir = params.get("dump_dir", data_dir.get_tmp_dir())
if os.path.dirname(dump_file) is "":
dump_file = os.path.join(dump_dir, dump_file)
dump_image_format = params.get("dump_image_format")
start_vm = params.get("start_vm") == "yes"
paused_after_start_vm = params.get("paused_after_start_vm") == "yes"
status_error = params.get("status_error", "no") == "yes"
check_bypass_timeout = int(params.get("check_bypass_timeout", "120"))
memory_dump_format = params.get("memory_dump_format", "")
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user')
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
document_string = eval(params.get("document_string", "[]"))
if not libvirt_version.version_compare(1, 1, 1):
if params.get('setup_libvirt_polkit') == 'yes':
test.cancel("API acl test not supported in current"
" libvirt version.")
def check_flag(file_flags):
"""
Check if file flag include O_DIRECT.
:param file_flags: The flags of dumped file
Note, O_DIRECT(direct disk access hint) is defined as:
on x86_64:
#define O_DIRECT 00040000
on ppc64le or arch64:
#define O_DIRECT 00200000
"""
arch = platform.machine()
file_flag_check = int('00040000', 16)
if 'ppc64' in arch or 'aarch64' in arch:
file_flag_check = int('00200000', 16)
if int(file_flags, 16) & file_flag_check == file_flag_check:
logging.info("File flags include O_DIRECT")
return True
else:
logging.error("File flags doesn't include O_DIRECT")
return False
def check_bypass(dump_file, result_dict):
"""
Get the file flags of domain core dump file and check it.
"""
error = ''
cmd1 = "lsof -w %s |awk '/libvirt_i/{print $2}'" % dump_file
while True:
if not os.path.exists(dump_file):
time.sleep(0.05)
continue
ret = process.run(cmd1, shell=True)
status, output = ret.exit_status, ret.stdout_text.strip()
if status:
time.sleep(0.05)
continue
cmd2 = "cat /proc/%s/fdinfo/1 |grep flags|awk '{print $NF}'" % output
ret = process.run(cmd2, allow_output_check='combined', shell=True)
status, output = ret.exit_status, ret.stdout_text.strip()
if status:
error = "Fail to get the flags of dumped file"
logging.error(error)
break
if not len(output):
continue
try:
logging.debug("The flag of dumped file: %s", output)
if check_flag(output):
logging.info("Bypass file system cache "
"successfully when dumping")
break
else:
error = "Bypass file system cache fail when dumping"
logging.error(error)
break
except (ValueError, IndexError) as detail:
error = detail
logging.error(error)
break
result_dict['bypass'] = error
def check_domstate(actual, options):
"""
Check the domain status according to dump options.
"""
if options.find('live') >= 0:
domstate = "running"
if options.find('crash') >= 0 or options.find('reset') > 0:
domstate = "running"
if paused_after_start_vm:
domstate = "paused"
elif options.find('crash') >= 0:
domstate = "shut off"
if options.find('reset') >= 0:
domstate = "running"
elif options.find('reset') >= 0:
domstate = "running"
if paused_after_start_vm:
domstate = "paused"
else:
domstate = "running"
if paused_after_start_vm:
domstate = "paused"
if not start_vm:
domstate = "shut off"
logging.debug("Domain should %s after run dump %s", domstate, options)
return (domstate == actual)
def check_dump_format(dump_image_format, dump_file):
"""
Check the format of dumped file.
If 'dump_image_format' is not specified or invalid in qemu.conf, then
the file should be normal raw file, otherwise it should be compress to
specified format, the supported compress format including: lzop, gzip,
bzip2, and xz.
For memory-only dump, the default dump format is ELF, and it can also
specify format by --format option, the result could be 'elf' or 'data'.
"""
valid_format = ["lzop", "gzip", "bzip2", "xz", 'elf', 'data']
if len(dump_image_format) == 0 or dump_image_format not in valid_format:
logging.debug("No need check the dumped file format")
return True
else:
file_cmd = "file %s" % dump_file
ret = process.run(file_cmd, allow_output_check='combined', shell=True)
status, output = ret.exit_status, ret.stdout_text.strip()
if status:
logging.error("Fail to check dumped file %s", dump_file)
return False
logging.debug("Run file %s output: %s", dump_file, output)
actual_format = output.split(" ")[1]
if actual_format.lower() != dump_image_format.lower():
logging.error("Compress dumped file to %s fail: %s" %
(dump_image_format, actual_format))
return False
else:
return True
# Configure dump_image_format in /etc/libvirt/qemu.conf.
qemu_config = utils_config.LibvirtQemuConfig()
libvirtd = utils_libvirtd.Libvirtd()
# Install lsof pkg if not installed
if not utils_package.package_install("lsof"):
test.cancel("Failed to install lsof in host\n")
if len(dump_image_format):
qemu_config.dump_image_format = dump_image_format
libvirtd.restart()
# Deal with memory-only dump format
if len(memory_dump_format):
# Make sure libvirt support this option
if virsh.has_command_help_match("dump", "--format") is None:
test.cancel("Current libvirt version doesn't support"
" --format option for dump command")
# Make sure QEMU support this format
query_cmd = '{"execute":"query-dump-guest-memory-capability"}'
qemu_capa = virsh.qemu_monitor_command(vm_name, query_cmd).stdout
if (memory_dump_format not in qemu_capa) and not status_error:
test.cancel("Unsupported dump format '%s' for"
" this QEMU binary" % memory_dump_format)
options += " --format %s" % memory_dump_format
if memory_dump_format == 'elf':
dump_image_format = 'elf'
if memory_dump_format in ['kdump-zlib', 'kdump-lzo', 'kdump-snappy']:
dump_image_format = 'data'
# Back up xml file
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
# check the explanation of "--memory-only" option in virsh dump man.
if document_string:
logging.info("document string: %s" % document_string)
ret = process.run("man virsh", shell=True)
if ret.exit_status:
test.error("failed to run 'man virsh'.")
man_str = re.sub(r"\s+", " ", ret.stdout_text.strip())
logging.debug("man str: %s" % man_str)
if not all([item in man_str for item in document_string]):
test.fail("failed to check document string in virsh man page.")
logging.info("the document string in virsh man page.")
return
dump_guest_core = params.get("dump_guest_core", "")
if dump_guest_core not in ["", "on", "off"]:
test.error("invalid dumpCore value: %s" % dump_guest_core)
try:
# Set dumpCore in guest xml
if dump_guest_core:
if vm.is_alive():
vm.destroy(gracefully=False)
vmxml.dumpcore = dump_guest_core
vmxml.sync()
vm.start()
# check qemu-kvm cmdline
vm_pid = vm.get_pid()
cmd = "cat /proc/%d/cmdline|xargs -0 echo" % vm_pid
cmd += "|grep dump-guest-core=%s" % dump_guest_core
result = process.run(cmd, ignore_status=True, shell=True)
logging.debug("cmdline: %s" % result.stdout_text)
if result.exit_status:
test.fail("Not find dump-guest-core=%s in qemu cmdline"
% dump_guest_core)
else:
logging.info("Find dump-guest-core=%s in qemum cmdline",
dump_guest_core)
# Deal with bypass-cache option
if options.find('bypass-cache') >= 0:
vm.wait_for_login()
result_dict = multiprocessing.Manager().dict()
child_process = multiprocessing.Process(target=check_bypass,
args=(dump_file, result_dict))
child_process.start()
# Run virsh command
cmd_result = virsh.dump(vm_name, dump_file, options,
unprivileged_user=unprivileged_user,
uri=uri,
ignore_status=True, debug=True)
status = cmd_result.exit_status
if 'child_process' in locals():
child_process.join(timeout=check_bypass_timeout)
params['bypass'] = result_dict['bypass']
logging.info("Start check result")
if not check_domstate(vm.state(), options):
test.fail("Domain status check fail.")
if status_error:
if not status:
test.fail("Expect fail, but run successfully")
else:
if status:
test.fail("Expect succeed, but run fail")
if not os.path.exists(dump_file):
test.fail("Fail to find domain dumped file.")
if check_dump_format(dump_image_format, dump_file):
logging.info("Successfully dump domain to %s", dump_file)
else:
test.fail("The format of dumped file is wrong.")
if params.get('bypass'):
test.fail(params['bypass'])
finally:
backup_xml.sync()
qemu_config.restore()
libvirtd.restart()
if os.path.isfile(dump_file):
os.remove(dump_file)
def remote_commander(client,
host,
port,
username,
password,
prompt,
linesep="\n",
log_filename=None,
timeout=10,
path=None):
"""
Log into a remote host (guest) using SSH/Telnet/Netcat.
:param client: The client to use ('ssh', 'telnet' or 'nc')
:param host: Hostname or IP address
:param port: Port to connect to
:param username: Username (if required)
:param password: Password (if required)
:param prompt: Shell prompt (regular expression)
:param linesep: The line separator to use when sending lines
(e.g. '\\n' or '\\r\\n')
:param log_filename: If specified, log all output to this file
:param timeout: The maximal time duration (in seconds) to wait for
each step of the login procedure (i.e. the "Are you sure" prompt
or the password prompt)
:param path: The path to place where remote_runner.py is placed.
:raise LoginBadClientError: If an unknown client is requested
:raise: Whatever handle_prompts() raises
:return: A ShellSession object.
"""
if path is None:
path = data_dir.get_tmp_dir()
if client == "ssh":
cmd = ("ssh -o UserKnownHostsFile=/dev/null "
"-o PreferredAuthentications=password "
"-p %s %s@%s %s agent_base64" %
(port, username, host, os.path.join(path, "remote_runner.py")))
elif client == "telnet":
cmd = "telnet -l %s %s %s" % (username, host, port)
elif client == "nc":
cmd = "nc %s %s" % (host, port)
else:
raise LoginBadClientError(client)
logging.debug("Login command: '%s'", cmd)
session = aexpect.Expect(cmd, linesep=linesep)
try:
handle_prompts(session, username, password, prompt, timeout)
except Exception:
session.close()
raise
if log_filename:
log_file = utils_logfile.get_log_filename(log_filename)
session.set_output_func(utils_logfile.log_line)
session.set_output_params((log_file, ))
session.set_log_file(os.path.basename(log_file))
session.send_ctrl("raw")
# Wrap io interfaces.
inw = messenger.StdIOWrapperInBase64(session._get_fd("tail"))
outw = AexpectIOWrapperOut(session)
# Create commander
cmd = remote_master.CommanderMaster(inw, outw, False)
return cmd
def run(test, params, env):
"""
Test the virsh pool commands with acl, initiate a pool then do
following operations.
(1) Undefine a given type pool
(2) Define the pool from xml
(3) Build given type pool
(4) Start pool
(5) Destroy pool
(6) Refresh pool after start it
(7) Run vol-list with the pool
(9) Delete pool
For negative cases, redo failed step to make the case run continue.
Run cleanup at last restore env.
"""
# Initialize the variables
pool_name = params.get("pool_name", "temp_pool_1")
pool_type = params.get("pool_type", "dir")
pool_target = params.get("pool_target", "")
# The file for dumped pool xml
pool_xml = os.path.join(data_dir.get_tmp_dir(), "pool.xml.tmp")
if os.path.dirname(pool_target) is "":
pool_target = os.path.join(data_dir.get_tmp_dir(), pool_target)
vol_name = params.get("vol_name", "temp_vol_1")
# Use pool name as VG name
vg_name = pool_name
vol_path = os.path.join(pool_target, vol_name)
define_acl = "yes" == params.get("define_acl", "no")
undefine_acl = "yes" == params.get("undefine_acl", "no")
start_acl = "yes" == params.get("start_acl", "no")
destroy_acl = "yes" == params.get("destroy_acl", "no")
build_acl = "yes" == params.get("build_acl", "no")
delete_acl = "yes" == params.get("delete_acl", "no")
refresh_acl = "yes" == params.get("refresh_acl", "no")
vol_list_acl = "yes" == params.get("vol_list_acl", "no")
list_dumpxml_acl = "yes" == params.get("list_dumpxml_acl", "no")
src_pool_error = "yes" == params.get("src_pool_error", "no")
define_error = "yes" == params.get("define_error", "no")
undefine_error = "yes" == params.get("undefine_error", "no")
start_error = "yes" == params.get("start_error", "no")
destroy_error = "yes" == params.get("destroy_error", "no")
build_error = "yes" == params.get("build_error", "no")
delete_error = "yes" == params.get("delete_error", "no")
refresh_error = "yes" == params.get("refresh_error", "no")
vol_list_error = "yes" == params.get("vol_list_error", "no")
# Clean up flags:
# cleanup_env[0] for nfs, cleanup_env[1] for iscsi, cleanup_env[2] for lvm
# cleanup_env[3] for selinux backup status, cleanup_env[4] for gluster
cleanup_env = [False, False, False, "", False]
# libvirt acl related params
uri = params.get("virsh_uri")
if uri and not utils_split_daemons.is_modular_daemon():
uri = "qemu:///system"
unprivileged_user = params.get('unprivileged_user')
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
if not libvirt_version.version_compare(1, 1, 1):
if params.get('setup_libvirt_polkit') == 'yes':
test.cancel("API acl test not supported in current"
" libvirt version.")
acl_dargs = {
'uri': uri,
'unprivileged_user': unprivileged_user,
'debug': True
}
def check_pool_list(pool_name, option="--all", expect_error=False):
"""
Check pool by running pool-list command with given option.
:param pool_name: Name of the pool
:param option: option for pool-list command
:param expect_error: Boolean value, expect command success or fail
"""
found = False
# Get the list stored in a variable
if list_dumpxml_acl:
result = virsh.pool_list(option, **acl_dargs)
else:
result = virsh.pool_list(option, ignore_status=True)
utlv.check_exit_status(result, False)
output = re.findall(r"(\S+)\ +(\S+)\ +(\S+)",
str(result.stdout.strip()))
for item in output:
if pool_name in item[0]:
found = True
break
if found:
logging.debug("Find pool '%s' in pool list.", pool_name)
else:
logging.debug("Not find pool %s in pool list.", pool_name)
if expect_error and found:
test.fail("Unexpected pool '%s' exist." % pool_name)
if not expect_error and not found:
test.fail("Expect pool '%s' doesn't exist." % pool_name)
# Run Testcase
kwargs = {'source_format': params.get('pool_source_format', 'ext4')}
try:
_pool = libvirt_storage.StoragePool()
# Init a pool for test
result = utlv.define_pool(pool_name, pool_type, pool_target,
cleanup_env, **kwargs)
utlv.check_exit_status(result, src_pool_error)
option = "--inactive --type %s" % pool_type
check_pool_list(pool_name, option)
if list_dumpxml_acl:
xml = virsh.pool_dumpxml(pool_name, to_file=pool_xml, **acl_dargs)
else:
xml = virsh.pool_dumpxml(pool_name, to_file=pool_xml)
logging.debug("Pool '%s' XML:\n%s", pool_name, xml)
# Step (1)
# Undefine pool
if undefine_acl:
result = virsh.pool_undefine(pool_name, **acl_dargs)
else:
result = virsh.pool_undefine(pool_name, ignore_status=True)
utlv.check_exit_status(result, undefine_error)
if undefine_error:
check_pool_list(pool_name, "--all", False)
# Redo under negative case to keep case continue
result = virsh.pool_undefine(pool_name, ignore_status=True)
utlv.check_exit_status(result)
check_pool_list(pool_name, "--all", True)
else:
check_pool_list(pool_name, "--all", True)
# Step (2)
# Define pool from XML file
if define_acl:
result = virsh.pool_define(pool_xml, **acl_dargs)
else:
result = virsh.pool_define(pool_xml)
utlv.check_exit_status(result, define_error)
if define_error:
# Redo under negative case to keep case continue
result = virsh.pool_define(pool_xml)
utlv.check_exit_status(result)
# Step (3)
# '--overwrite/--no-overwrite' just for fs/disk/logiacl type pool
# disk/fs pool: as prepare step already make label and create filesystem
# for the disk, use '--overwrite' is necessary
# logical_pool: build pool will fail if VG already exist, BZ#1373711
if pool_type != "logical":
option = ''
if pool_type in ['disk', 'fs']:
option = '--overwrite'
result = virsh.pool_build(pool_name, option, ignore_status=True)
utlv.check_exit_status(result)
if build_acl:
result = virsh.pool_build(pool_name, option, **acl_dargs)
else:
result = virsh.pool_build(pool_name,
option,
ignore_status=True)
utlv.check_exit_status(result, build_error)
if build_error:
# Redo under negative case to keep case continue
result = virsh.pool_build(pool_name, option, ignore_status=True)
utlv.check_exit_status(result)
# For iSCSI pool, we need discover targets before start the pool
if pool_type == 'iscsi':
cmd = 'iscsiadm -m discovery -t sendtargets -p 127.0.0.1'
process.run(cmd, shell=True)
# Step (4)
# Pool start
if start_acl:
result = virsh.pool_start(pool_name, **acl_dargs)
else:
result = virsh.pool_start(pool_name, ignore_status=True)
utlv.check_exit_status(result, start_error)
if start_error:
# Redo under negative case to keep case continue
result = virsh.pool_start(pool_name, ignore_status=True)
utlv.check_exit_status(result)
option = "--persistent --type %s" % pool_type
check_pool_list(pool_name, option)
# Step (5)
# Pool destroy
if destroy_acl:
result = virsh.pool_destroy(pool_name, **acl_dargs)
else:
result = virsh.pool_destroy(pool_name)
if result:
if destroy_error:
test.fail("Expect fail, but run successfully.")
else:
if not destroy_error:
test.fail("Pool %s destroy failed, not expected." % pool_name)
else:
# Redo under negative case to keep case continue
if virsh.pool_destroy(pool_name):
logging.debug("Pool %s destroyed.", pool_name)
else:
test.fail("Destroy pool % failed." % pool_name)
# Step (6)
# Pool refresh for 'dir' type pool
# Pool start
result = virsh.pool_start(pool_name, ignore_status=True)
utlv.check_exit_status(result)
if pool_type == "dir":
os.mknod(vol_path)
if refresh_acl:
result = virsh.pool_refresh(pool_name, **acl_dargs)
else:
result = virsh.pool_refresh(pool_name)
utlv.check_exit_status(result, refresh_error)
# Step (7)
# Pool vol-list
if vol_list_acl:
result = virsh.vol_list(pool_name, **acl_dargs)
else:
result = virsh.vol_list(pool_name)
utlv.check_exit_status(result, vol_list_error)
# Step (8)
# Pool delete for 'dir' type pool
if virsh.pool_destroy(pool_name):
logging.debug("Pool %s destroyed.", pool_name)
else:
test.fail("Destroy pool % failed." % pool_name)
if pool_type == "dir":
if os.path.exists(vol_path):
os.remove(vol_path)
if delete_acl:
result = virsh.pool_delete(pool_name, **acl_dargs)
else:
result = virsh.pool_delete(pool_name, ignore_status=True)
utlv.check_exit_status(result, delete_error)
option = "--inactive --type %s" % pool_type
check_pool_list(pool_name, option)
if not delete_error:
if os.path.exists(pool_target):
test.fail("The target path '%s' still exist." %
pool_target)
result = virsh.pool_undefine(pool_name, ignore_status=True)
utlv.check_exit_status(result)
check_pool_list(pool_name, "--all", True)
finally:
# Clean up
if os.path.exists(pool_xml):
os.remove(pool_xml)
if not _pool.delete_pool(pool_name):
logging.error("Can't delete pool: %s", pool_name)
if cleanup_env[2]:
cmd = "pvs |grep %s |awk '{print $1}'" % vg_name
pv_name = process.run(cmd, shell=True).stdout_text
lv_utils.vg_remove(vg_name)
process.run("pvremove %s" % pv_name, shell=True)
if cleanup_env[1]:
utlv.setup_or_cleanup_iscsi(False)
if cleanup_env[0]:
utlv.setup_or_cleanup_nfs(False, restore_selinux=cleanup_env[3])
def run(test, params, env):
"""
Test DAC in adding nfs pool disk to VM.
(1).Init variables for test.
(2).Create nfs pool and vol.
(3).Attach the nfs pool vol to VM.
(4).Start VM and check result.
"""
# Get general variables.
status_error = ('yes' == params.get("status_error", 'no'))
host_sestatus = params.get("dac_nfs_disk_host_selinux", "enforcing")
# Get qemu.conf config variables
qemu_user = params.get("qemu_user")
qemu_group = params.get("qemu_group")
dynamic_ownership = "yes" == params.get("dynamic_ownership", "yes")
# Get variables about pool vol
virt_use_nfs = params.get("virt_use_nfs", "off")
nfs_server_dir = params.get("nfs_server_dir", "nfs-server")
pool_name = params.get("pool_name")
pool_type = params.get("pool_type")
pool_target = params.get("pool_target")
export_options = params.get("export_options",
"rw,async,no_root_squash,fsid=0")
emulated_image = params.get("emulated_image")
vol_name = params.get("vol_name")
vol_format = params.get("vol_format")
bk_file_name = params.get("bk_file_name")
# Get pool vol variables
img_tup = ("img_user", "img_group", "img_mode")
img_val = []
for i in img_tup:
try:
img_val.append(int(params.get(i)))
except ValueError:
raise error.TestNAError("%s value '%s' is not a number." %
(i, params.get(i)))
# False positive - img_val was filled in the for loop above.
# pylint: disable=E0632
img_user, img_group, img_mode = img_val
# Get variables about VM and get a VM object and VMXML instance.
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
vmxml = VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
# Backup domain disk label
disks = vm.get_disk_devices()
backup_labels_of_disks = {}
for disk in disks.values():
disk_path = disk['source']
f = os.open(disk_path, 0)
stat_re = os.fstat(f)
backup_labels_of_disks[disk_path] = "%s:%s" % (stat_re.st_uid,
stat_re.st_gid)
os.close(f)
# Backup selinux status of host.
backup_sestatus = utils_selinux.get_status()
pvt = None
snapshot_name = None
disk_snap_path = []
qemu_conf = utils_config.LibvirtQemuConfig()
libvirtd = utils_libvirtd.Libvirtd()
try:
# chown domain disk to qemu:qemu to avoid fail on local disk
for disk in disks.values():
disk_path = disk['source']
if qemu_user == "root":
os.chown(disk_path, 0, 0)
elif qemu_user == "qemu":
os.chown(disk_path, 107, 107)
# Set selinux of host.
utils_selinux.set_status(host_sestatus)
# set qemu conf
qemu_conf.user = qemu_user
qemu_conf.group = qemu_user
if dynamic_ownership:
qemu_conf.dynamic_ownership = 1
else:
qemu_conf.dynamic_ownership = 0
logging.debug("the qemu.conf content is: %s" % qemu_conf)
libvirtd.restart()
# Create dst pool for create attach vol img
logging.debug("export_options is: %s" % export_options)
pvt = utlv.PoolVolumeTest(test, params)
pvt.pre_pool(pool_name, pool_type, pool_target,
emulated_image, image_size="1G",
pre_disk_vol=["20M"],
export_options=export_options)
# set virt_use_nfs
result = process.run("setsebool virt_use_nfs %s" % virt_use_nfs,
shell=True)
if result.exit_status:
raise error.TestNAError("Failed to set virt_use_nfs value")
# Init a QemuImg instance and create img on nfs server dir.
params['image_name'] = vol_name
tmp_dir = data_dir.get_tmp_dir()
nfs_path = os.path.join(tmp_dir, nfs_server_dir)
image = qemu_storage.QemuImg(params, nfs_path, vol_name)
# Create a image.
server_img_path, result = image.create(params)
if params.get("image_name_backing_file"):
params['image_name'] = bk_file_name
params['has_backing_file'] = "yes"
image = qemu_storage.QemuImg(params, nfs_path, bk_file_name)
server_img_path, result = image.create(params)
# Get vol img path
vol_name = server_img_path.split('/')[-1]
virsh.pool_refresh(pool_name, debug=True)
cmd_result = virsh.vol_path(vol_name, pool_name, debug=True)
if cmd_result.exit_status:
raise error.TestNAError("Failed to get volume path from pool.")
img_path = cmd_result.stdout.strip()
# Do the attach action.
extra = "--persistent --subdriver qcow2"
result = virsh.attach_disk(vm_name, source=img_path, target="vdf",
extra=extra, debug=True)
if result.exit_status:
raise error.TestFail("Failed to attach disk %s to VM."
"Detail: %s." % (img_path, result.stderr))
# Change img ownership and mode on nfs server dir
os.chown(server_img_path, img_user, img_group)
os.chmod(server_img_path, img_mode)
img_label_before = check_ownership(server_img_path)
if img_label_before:
logging.debug("attached image ownership on nfs server before "
"start: %s" % img_label_before)
# Start VM to check the VM is able to access the image or not.
try:
vm.start()
# Start VM successfully.
img_label_after = check_ownership(server_img_path)
if img_label_after:
logging.debug("attached image ownership on nfs server after"
" start: %s" % img_label_after)
if status_error:
raise error.TestFail('Test succeeded in negative case.')
except virt_vm.VMStartError, e:
# Starting VM failed.
if not status_error:
raise error.TestFail("Test failed in positive case."
"error: %s" % e)
if params.get("image_name_backing_file"):
options = "--disk-only"
snapshot_result = virsh.snapshot_create(vm_name, options,
debug=True)
if snapshot_result.exit_status:
if not status_error:
raise error.TestFail("Failed to create snapshot. Error:%s."
% snapshot_result.stderr.strip())
snapshot_name = re.search(
"\d+", snapshot_result.stdout.strip()).group(0)
if snapshot_name:
disks_snap = vm.get_disk_devices()
for disk in disks_snap.values():
disk_snap_path.append(disk['source'])
virsh.snapshot_delete(vm_name, snapshot_name, "--metadata",
debug=True)
try:
virsh.detach_disk(vm_name, target="vdf", extra="--persistent",
debug=True)
except process.CmdError:
raise error.TestFail("Detach disk 'vdf' from VM %s failed."
% vm.name)
def run(test, params, env):
"""
Do test for vol-download and vol-upload
Basic steps are
1. Create pool with type defined in cfg
2. Create image with writing data in it
3. Get md5 value before operation
4. Do vol-download/upload with options(offset, length)
5. Check md5 value after operation
"""
pool_type = params.get("vol_download_upload_pool_type")
pool_name = params.get("vol_download_upload_pool_name")
pool_target = params.get("vol_download_upload_pool_target")
if os.path.dirname(pool_target) is "":
pool_target = os.path.join(data_dir.get_tmp_dir(), pool_target)
vol_name = params.get("vol_download_upload_vol_name")
file_name = params.get("vol_download_upload_file_name")
file_path = os.path.join(data_dir.get_tmp_dir(), file_name)
offset = params.get("vol_download_upload_offset")
length = params.get("vol_download_upload_length")
capacity = params.get("vol_download_upload_capacity")
allocation = params.get("vol_download_upload_allocation")
frmt = params.get("vol_download_upload_format")
operation = params.get("vol_download_upload_operation")
create_vol = ("yes" == params.get("vol_download_upload_create_vol", "yes"))
setup_libvirt_polkit = "yes" == params.get("setup_libvirt_polkit")
b_luks_encrypt = "luks" == params.get("encryption_method")
encryption_password = params.get("encryption_password", "redhat")
secret_uuids = []
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
virsh_dargs = {'debug': True, 'ignore_status': True}
sparse_option_support = "yes" == params.get("sparse_option_support", "yes")
with_clusterSize = "yes" == params.get("with_clusterSize")
vol_clusterSize = params.get("vol_clusterSize", "64")
vol_clusterSize_unit = params.get("vol_clusterSize_unit")
vol_format = params.get("vol_format", "qcow2")
libvirt_version.is_libvirt_feature_supported(params)
# libvirt acl polkit related params
uri = params.get("virsh_uri")
if uri and not utils_split_daemons.is_modular_daemon():
uri = "qemu:///system"
unpri_user = params.get('unprivileged_user')
if unpri_user:
if unpri_user.count('EXAMPLE'):
unpri_user = '******'
if not libvirt_version.version_compare(1, 1, 1):
if setup_libvirt_polkit:
test.error("API acl test not supported in current"
" libvirt version.")
# Destroy VM.
if vm.is_alive():
vm.destroy(gracefully=False)
# Back up xml file.
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
pvt = utlv.PoolVolumeTest(test, params)
pvt.pre_pool(pool_name,
pool_type,
pool_target,
"volumetest",
pre_disk_vol=["50M"])
# According to BZ#1138523, we need inpect the right name
# (disk partition) for new volume
if pool_type == "disk":
vol_name = utlv.new_disk_vol_name(pool_name)
if vol_name is None:
test.error("Fail to generate volume name")
# update polkit rule as the volume name changed
if setup_libvirt_polkit:
vol_pat = r"lookup\('vol_name'\) == ('\S+')"
new_value = "lookup('vol_name') == '%s'" % vol_name
utlv.update_polkit_rule(params, vol_pat, new_value)
if create_vol:
if b_luks_encrypt:
if not libvirt_version.version_compare(2, 0, 0):
test.cancel("LUKS format not supported in "
"current libvirt version")
params['sec_volume'] = os.path.join(pool_target, vol_name)
luks_sec_uuid = utlv.create_secret(params)
ret = virsh.secret_set_value(luks_sec_uuid,
encryption_password,
encode=True)
utlv.check_exit_status(ret)
secret_uuids.append(luks_sec_uuid)
vol_arg = {}
vol_arg['name'] = vol_name
vol_arg['capacity'] = int(capacity)
vol_arg['allocation'] = int(allocation)
if with_clusterSize:
vol_arg['format'] = vol_format
vol_arg['clusterSize'] = int(vol_clusterSize)
vol_arg['clusterSize_unit'] = vol_clusterSize_unit
create_luks_vol(pool_name, vol_name, luks_sec_uuid, vol_arg)
else:
pvt.pre_vol(vol_name, frmt, capacity, allocation, pool_name)
virsh.pool_refresh(pool_name, debug=True)
vol_list = virsh.vol_list(pool_name, debug=True).stdout.strip()
# iscsi volume name is different from others
if pool_type == "iscsi":
# Due to BZ 1843791, the volume cannot be obtained sometimes.
if len(vol_list.splitlines()) < 3:
test.fail("Failed to get iscsi type volume.")
vol_name = vol_list.split('\n')[2].split()[0]
vol_path = virsh.vol_path(vol_name, pool_name,
ignore_status=False).stdout.strip()
logging.debug("vol_path is %s", vol_path)
# Add command options
if pool_type is not None:
options = " --pool %s" % pool_name
if offset is not None:
options += " --offset %s" % offset
offset = int(offset)
else:
offset = 0
if length is not None:
options += " --length %s" % length
length = int(length)
else:
length = 0
logging.debug("%s options are %s", operation, options)
if operation == "upload":
# write data to file
write_file(file_path)
# Set length for calculate the offset + length in the following
# func get_pre_post_digest() and digest()
if length == 0:
length = 1048576
def get_pre_post_digest():
"""
Get pre region and post region digest if have offset and length
:return: pre digest and post digest
"""
# Get digest of pre region before offset
if offset != 0:
digest_pre = digest(vol_path, 0, offset)
else:
digest_pre = 0
logging.debug("pre region digest read from %s 0-%s is %s",
vol_path, offset, digest_pre)
# Get digest of post region after offset+length
digest_post = digest(vol_path, offset + length, 0)
logging.debug("post region digest read from %s %s-0 is %s",
vol_path, offset + length, digest_post)
return (digest_pre, digest_post)
# Get pre and post digest before operation for compare
(ori_pre_digest, ori_post_digest) = get_pre_post_digest()
ori_digest = digest(file_path, 0, 0)
logging.debug("ori digest read from %s is %s", file_path,
ori_digest)
if setup_libvirt_polkit:
process.run("chmod 666 %s" % file_path,
ignore_status=True,
shell=True)
# Do volume upload
result = virsh.vol_upload(vol_name,
file_path,
options,
unprivileged_user=unpri_user,
uri=uri,
debug=True)
if result.exit_status == 0:
# Get digest after operation
(aft_pre_digest, aft_post_digest) = get_pre_post_digest()
aft_digest = digest(vol_path, offset, length)
logging.debug("aft digest read from %s is %s", vol_path,
aft_digest)
# Compare the pre and post part before and after
if ori_pre_digest == aft_pre_digest and \
ori_post_digest == aft_post_digest:
logging.info("file pre and aft digest match")
else:
test.fail("file pre or post digests do not"
"match, in %s", operation)
if operation == "download":
# Write data to volume
write_file(vol_path)
# Record the digest value before operation
ori_digest = digest(vol_path, offset, length)
logging.debug("original digest read from %s is %s", vol_path,
ori_digest)
process.run("touch %s" % file_path, ignore_status=True, shell=True)
if setup_libvirt_polkit:
process.run("chmod 666 %s" % file_path,
ignore_status=True,
shell=True)
# Do volume download
result = virsh.vol_download(vol_name,
file_path,
options,
unprivileged_user=unpri_user,
uri=uri,
debug=True)
if result.exit_status == 0:
# Get digest after operation
aft_digest = digest(file_path, 0, 0)
logging.debug("new digest read from %s is %s", file_path,
aft_digest)
if operation != "mix":
if result.exit_status != 0:
test.fail("Fail to %s volume: %s" % (operation, result.stderr))
# Compare the change part on volume and file
if ori_digest == aft_digest:
logging.info("file digests match, volume %s succeed",
operation)
else:
test.fail("file digests do not match, volume %s failed" %
operation)
if operation == "mix":
target = params.get("virt_disk_device_target", "vdb")
disk_file_path = os.path.join(pool_target, file_name)
# Create one disk xml and attach it to VM.
custom_disk_xml = create_disk('file', disk_file_path, 'raw',
'file', 'disk', target, 'virtio')
ret = virsh.attach_device(vm_name,
custom_disk_xml.xml,
flagstr="--config",
debug=True)
libvirt.check_exit_status(ret)
if vm.is_dead():
vm.start()
# Write 100M data into disk.
data_size = 100
write_disk(test, vm, target, data_size)
data_size_in_bytes = data_size * 1024 * 1024
# Refresh directory pool.
virsh.pool_refresh(pool_name, debug=True)
# Download volume to local with sparse option.
download_spare_file = "download-sparse.raw"
download_file_path = os.path.join(data_dir.get_tmp_dir(),
download_spare_file)
options += " --sparse"
result = virsh.vol_download(file_name,
download_file_path,
options,
unprivileged_user=unpri_user,
uri=uri,
debug=True)
libvirt.check_exit_status(result)
#Check download image size.
one_g_in_bytes = 1073741824
download_img_info = utils_misc.get_image_info(download_file_path)
download_disk_size = int(download_img_info['dsize'])
if (download_disk_size < data_size_in_bytes
or download_disk_size >= one_g_in_bytes):
test.fail("download image size:%d is less than the generated "
"data size:%d or greater than or equal to 1G." %
(download_disk_size, data_size_in_bytes))
# Create one upload sparse image file.
upload_sparse_file = "upload-sparse.raw"
upload_file_path = os.path.join(pool_target, upload_sparse_file)
libvirt.create_local_disk('file', upload_file_path, '1', 'raw')
# Refresh directory pool.
virsh.pool_refresh(pool_name, debug=True)
# Do volume upload, upload sparse file which download last time.
result = virsh.vol_upload(upload_sparse_file,
download_file_path,
options,
unprivileged_user=unpri_user,
uri=uri,
debug=True)
upload_img_info = utils_misc.get_image_info(upload_file_path)
upload_disk_size = int(upload_img_info['dsize'])
if (upload_disk_size < data_size_in_bytes
or upload_disk_size >= one_g_in_bytes):
test.fail("upload image size:%d is less than the generated "
"data size:%d or greater than or equal to 1G." %
(upload_disk_size, data_size_in_bytes))
finally:
# Recover VM.
if vm.is_alive():
vm.destroy(gracefully=False)
vmxml_backup.sync()
pvt.cleanup_pool(pool_name, pool_type, pool_target, "volumetest")
for secret_uuid in set(secret_uuids):
virsh.secret_undefine(secret_uuid)
if os.path.isfile(file_path):
os.remove(file_path)
def run(test, params, env):
"""
Test command: virsh change-media.
The command changes the media used by CD or floppy drives.
Test steps:
1. Prepare test environment.
2. Perform virsh change-media operation.
3. Recover test environment.
4. Confirm the test result.
"""
def is_attached(vmxml_devices, disk_type, source_file, target_dev):
"""
Check attached device and disk exist or not.
:param vmxml_devices: VMXMLDevices instance
:param disk_type: disk's device type: cdrom or floppy
:param source_file : disk's source file to check
:param target_dev : target device name
:return: True/False if backing file and device found
"""
disks = vmxml_devices.by_device_tag('disk')
for disk in disks:
if disk.device != disk_type:
continue
if disk.target['dev'] != target_dev:
continue
if disk.xmltreefile.find('source') is not None:
if disk.source.attrs['file'] != source_file:
continue
else:
continue
# All three conditions met
logging.debug("Find %s in given disk XML", source_file)
return True
logging.debug("Not find %s in gievn disk XML", source_file)
return False
def check_result(vm_name,
disk_source,
disk_type,
disk_target,
flags,
vm_state,
attach=True):
"""
Check the test result of attach/detach-device command.
"""
active_vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
active_attached = is_attached(active_vmxml.devices, disk_type,
disk_source, disk_target)
if vm_state != "transient":
inactive_vmxml = vm_xml.VMXML.new_from_dumpxml(
vm_name, options="--inactive")
inactive_attached = is_attached(inactive_vmxml.devices, disk_type,
disk_source, disk_target)
if flags.count("config") and not flags.count("live"):
if vm_state != "transient":
if attach:
if not inactive_attached:
raise exceptions.TestFail(
"Inactive domain XML not updated"
" when --config options used for"
" attachment")
if vm_state != "shutoff":
if active_attached:
raise exceptions.TestFail(
"Active domain XML updated"
" when --config options used"
" for attachment")
else:
if inactive_attached:
raise exceptions.TestFail(
"Inactive domain XML not updated"
" when --config options used for"
" detachment")
if vm_state != "shutoff":
if not active_attached:
raise exceptions.TestFail(
"Active domain XML updated"
" when --config options used"
" for detachment")
elif flags.count("live") and not flags.count("config"):
if attach:
if vm_state in ["paused", "running", "transient"]:
if not active_attached:
raise exceptions.TestFail(
"Active domain XML not updated"
" when --live options used for"
" attachment")
if vm_state in ["paused", "running"]:
if inactive_attached:
raise exceptions.TestFail(
"Inactive domain XML updated"
" when --live options used for"
" attachment")
else:
if vm_state in ["paused", "running", "transient"]:
if active_attached:
raise exceptions.TestFail(
"Active domain XML not updated"
" when --live options used for"
" detachment")
if vm_state in ["paused", "running"]:
if not inactive_attached:
raise exceptions.TestFail(
"Inactive domain XML updated"
" when --live options used for"
" detachment")
elif flags.count("live") and flags.count("config"):
if attach:
if vm_state in ["paused", "running"]:
if not active_attached:
raise exceptions.TestFail(
"Active domain XML not updated"
" when --live --config options"
" used for attachment")
if not inactive_attached:
raise exceptions.TestFail(
"Inactive domain XML not updated"
" when --live --config options "
"used for attachment")
else:
if vm_state in ["paused", "running"]:
if active_attached:
raise exceptions.TestFail(
"Active domain XML not updated "
"when --live --config options "
"used for detachment")
if inactive_attached:
raise exceptions.TestFail(
"Inactive domain XML not updated"
" when --live --config options "
"used for detachment")
elif flags.count("current") or flags == "":
if attach:
if vm_state in ["paused", "running", "transient"]:
if not active_attached:
raise exceptions.TestFail(
"Active domain XML not updated"
" when --current options used "
"for attachment")
if vm_state in ["paused", "running"]:
if inactive_attached:
raise exceptions.TestFail(
"Inactive domain XML updated "
"when --current options used "
"for live attachment")
if vm_state == "shutoff" and not inactive_attached:
raise exceptions.TestFail(
"Inactive domain XML not updated "
"when --current options used for "
"attachment")
else:
if vm_state in ["paused", "running", "transient"]:
if active_attached:
raise exceptions.TestFail(
"Active domain XML not updated"
" when --current options used "
"for detachment")
if vm_state in ["paused", "running"]:
if not inactive_attached:
raise exceptions.TestFail(
"Inactive domain XML updated "
"when --current options used "
"for live detachment")
if vm_state == "shutoff" and inactive_attached:
raise exceptions.TestFail(
"Inactive domain XML not updated "
"when --current options used for "
"detachment")
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
vm_ref = params.get("change_media_vm_ref")
action = params.get("change_media_action")
action_twice = params.get("change_media_action_twice", "")
pre_vm_state = params.get("pre_vm_state")
options = params.get("change_media_options")
options_twice = params.get("change_media_options_twice", "")
device_type = params.get("change_media_device_type", "cdrom")
target_device = params.get("change_media_target_device", "hdc")
init_iso_name = params.get("change_media_init_iso")
old_iso_name = params.get("change_media_old_iso")
new_iso_name = params.get("change_media_new_iso")
virsh_dargs = {"debug": True, "ignore_status": True}
if device_type not in ['cdrom', 'floppy']:
raise exceptions.TestSkipError("Got a invalid device type:/n%s" %
device_type)
# Backup for recovery.
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
old_iso = os.path.join(data_dir.get_tmp_dir(), old_iso_name)
new_iso = os.path.join(data_dir.get_tmp_dir(), new_iso_name)
if vm_ref == "name":
vm_ref = vm_name
if vm.is_alive():
vm.destroy(gracefully=False)
try:
if not init_iso_name:
init_iso = ""
else:
init_iso = os.path.join(data_dir.get_tmp_dir(), init_iso_name)
# Prepare test files.
libvirt.create_local_disk("iso", old_iso)
libvirt.create_local_disk("iso", new_iso)
# Check domain's disk device
disk_blk = vm_xml.VMXML.get_disk_blk(vm_name)
logging.info("disk_blk %s", disk_blk)
if target_device not in disk_blk:
if vm.is_alive():
virsh.destroy(vm_name)
logging.info("Adding device")
libvirt.create_local_disk("iso", init_iso)
disk_params = {
"disk_type": "file",
"device_type": device_type,
"driver_name": "qemu",
"driver_type": "raw",
"target_bus": "ide",
"readonly": "yes"
}
libvirt.attach_additional_device(vm_name, target_device, init_iso,
disk_params)
vmxml_for_test = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Turn VM into certain state.
if pre_vm_state == "running":
logging.info("Starting %s..." % vm_name)
if vm.is_dead():
vm.start()
vm.wait_for_login().close()
elif pre_vm_state == "shutoff":
logging.info("Shuting down %s..." % vm_name)
if vm.is_alive():
vm.destroy(gracefully=False)
elif pre_vm_state == "paused":
logging.info("Pausing %s..." % vm_name)
if vm.is_dead():
vm.start()
vm.wait_for_login().close()
if not vm.pause():
raise exceptions.TestSkipError("Cann't pause the domain")
time.sleep(5)
elif pre_vm_state == "transient":
logging.info("Creating %s..." % vm_name)
vm.undefine()
if virsh.create(vmxml_for_test.xml, **virsh_dargs).exit_status:
vmxml_backup.define()
raise exceptions.TestSkipError("Cann't create the domain")
# Libvirt will ignore --source when action is eject
attach = True
device_source = old_iso
if action == "--eject ":
source = ""
attach = False
else:
source = device_source
all_options = action + options + " " + source
ret = virsh.change_media(vm_ref,
target_device,
all_options,
ignore_status=True,
debug=True)
status_error = False
if pre_vm_state == "shutoff":
if options.count("live"):
status_error = True
elif pre_vm_state == "transient":
if options.count("config"):
status_error = True
if vm.is_paused():
vm.resume()
vm.wait_for_login().close()
# For paused vm, change_media for eject/update operation
# should be executed again for it takes effect
if ret.exit_status:
if not action.count("insert") and not options.count("force"):
ret = virsh.change_media(vm_ref,
target_device,
all_options,
ignore_status=True,
debug=True)
if not status_error and ret.exit_status:
raise exceptions.TestFail("Please check: Bug 1289069 - Ejecting "
"locked cdrom tray using update-device"
" fails but next try succeeds")
libvirt.check_exit_status(ret, status_error)
if not ret.exit_status:
check_result(vm_name, device_source, device_type, target_device,
options, pre_vm_state, attach)
if action_twice:
if pre_vm_state == "paused":
if not vm.pause():
raise exceptions.TestFail("Cann't pause the domain")
time.sleep(5)
attach = True
device_source = new_iso
if action_twice == "--eject ":
#options_twice += " --force "
source = ""
attach = False
else:
source = device_source
all_options = action_twice + options_twice + " " + source
time.sleep(5)
ret = virsh.change_media(vm_ref,
target_device,
all_options,
ignore_status=True,
debug=True)
status_error = False
if pre_vm_state == "shutoff":
if options_twice.count("live"):
status_error = True
elif pre_vm_state == "transient":
if options_twice.count("config"):
status_error = True
if action_twice == "--insert ":
if pre_vm_state in ["running", "paused"]:
if options in ["--force", "--current", "", "--live"]:
if options_twice.count("config"):
status_error = True
elif options == "--config":
if options_twice in ["--force", "--current", ""]:
status_error = True
elif options_twice.count("live"):
status_error = True
elif pre_vm_state == "transient":
if ret.exit_status:
status_error = True
elif pre_vm_state == "shutoff":
if options.count("live"):
status_error = True
if vm.is_paused():
vm.resume()
vm.wait_for_login().close()
# For paused vm, change_media for eject/update operation
# should be executed again for it takes effect
if ret.exit_status and not action_twice.count("insert"):
ret = virsh.change_media(vm_ref,
target_device,
all_options,
ignore_status=True,
debug=True)
if not status_error and ret.exit_status:
raise exceptions.TestFail(
"Please check: Bug 1289069 - Ejecting "
"locked cdrom tray using update-device"
" fails but next try succeeds")
libvirt.check_exit_status(ret, status_error)
if not ret.exit_status:
check_result(vm_name, device_source, device_type,
target_device, options_twice, pre_vm_state,
attach)
# Try to start vm.
if vm.is_dead():
vm.start()
vm.wait_for_login().close()
finally:
if vm.is_alive():
vm.destroy(gracefully=False)
# Recover xml of vm.
vmxml_backup.sync()
# Remove disks
if os.path.exists(init_iso):
os.remove(init_iso)
if os.path.exists(old_iso):
os.remove(old_iso)
if os.path.exists(init_iso):
os.remove(new_iso)
def run(test, params, env):
"""
Test command: virsh domstate.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Perform virsh domstate operation.
4.Recover test environment.
5.Confirm the test result.
"""
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(vm_name)
libvirtd_state = params.get("libvirtd", "on")
vm_ref = params.get("domstate_vm_ref")
status_error = (params.get("status_error", "no") == "yes")
extra = params.get("domstate_extra", "")
vm_action = params.get("domstate_vm_action", "")
vm_oncrash_action = params.get("domstate_vm_oncrash")
reset_action = "yes" == params.get("reset_action", "no")
dump_option = params.get("dump_option", "")
start_action = params.get("start_action", "normal")
kill_action = params.get("kill_action", "normal")
check_libvirtd_log = params.get("check_libvirtd_log", "no")
err_msg = params.get("err_msg", "")
remote_uri = params.get("remote_uri")
domid = vm.get_id()
domuuid = vm.get_uuid()
if vm_ref == "id":
vm_ref = domid
elif vm_ref == "hex_id":
vm_ref = hex(int(domid))
elif vm_ref.find("invalid") != -1:
vm_ref = params.get(vm_ref)
elif vm_ref == "name":
vm_ref = vm_name
elif vm_ref == "uuid":
vm_ref = domuuid
# Back up xml file.
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
# Back up qemu.conf
qemu_conf = utils_config.LibvirtQemuConfig()
libvirtd = utils_libvirtd.Libvirtd()
# Config libvirtd log
if check_libvirtd_log == "yes":
libvirtd_conf = utils_config.LibvirtdConfig()
libvirtd_log_file = os.path.join(data_dir.get_tmp_dir(),
"libvirtd.log")
libvirtd_conf["log_level"] = '1'
libvirtd_conf["log_filters"] = ('"1:json 1:libvirt 1:qemu 1:monitor '
'3:remote 4:event"')
libvirtd_conf["log_outputs"] = '"1:file:%s"' % libvirtd_log_file
logging.debug("the libvirtd config file content is:\n %s" %
libvirtd_conf)
libvirtd.restart()
# Get image file
image_source = vm.get_first_disk_devices()['source']
logging.debug("image source: %s" % image_source)
new_image_source = image_source + '.rename'
dump_path = os.path.join(data_dir.get_tmp_dir(), "dump/")
logging.debug("dump_path: %s", dump_path)
try:
os.mkdir(dump_path)
except OSError:
# If the path already exists then pass
pass
dump_file = ""
try:
# Let's have guest memory less so that dumping core takes
# time which doesn't timeout the testcase
if vm_oncrash_action in ['coredump-destroy', 'coredump-restart']:
memory_value = int(params.get("memory_value", "2097152"))
memory_unit = params.get("memory_unit", "KiB")
vmxml.set_memory(memory_value)
vmxml.set_memory_unit(memory_unit)
logging.debug(vmxml)
vmxml.sync()
if vm_action == "crash":
if vm.is_alive():
vm.destroy(gracefully=False)
vmxml.on_crash = vm_oncrash_action
if not vmxml.xmltreefile.find('devices').findall('panic'):
# Add <panic> device to domain
panic_dev = Panic()
if "ppc" not in platform.machine():
panic_dev.addr_type = "isa"
panic_dev.addr_iobase = "0x505"
vmxml.add_device(panic_dev)
vmxml.sync()
# Config auto_dump_path in qemu.conf
qemu_conf.auto_dump_path = dump_path
libvirtd.restart()
if vm_oncrash_action in ['coredump-destroy', 'coredump-restart']:
dump_file = dump_path + "*" + vm_name[:20] + "-*"
# Start VM and check the panic device
virsh.start(vm_name, ignore_status=False)
vmxml_new = vm_xml.VMXML.new_from_dumpxml(vm_name)
# Skip this test if no panic device find
if not vmxml_new.xmltreefile.find('devices').findall('panic'):
test.cancel("No 'panic' device in the guest. Maybe your "
"libvirt version doesn't support it.")
try:
if vm_action == "suspend":
virsh.suspend(vm_name, ignore_status=False)
elif vm_action == "resume":
virsh.suspend(vm_name, ignore_status=False)
virsh.resume(vm_name, ignore_status=False)
elif vm_action == "destroy":
virsh.destroy(vm_name, ignore_status=False)
elif vm_action == "start":
virsh.destroy(vm_name, ignore_status=False)
if start_action == "rename":
# rename the guest image file to make guest fail to start
os.rename(image_source, new_image_source)
virsh.start(vm_name, ignore_status=True)
else:
virsh.start(vm_name, ignore_status=False)
if start_action == "restart_libvirtd":
libvirtd.restart()
elif vm_action == "kill":
if kill_action == "stop_libvirtd":
libvirtd.stop()
utils_misc.kill_process_by_pattern(vm_name)
libvirtd.restart()
elif kill_action == "reboot_vm":
virsh.reboot(vm_name, ignore_status=False)
utils_misc.kill_process_tree(vm.get_pid(), signal.SIGKILL)
else:
utils_misc.kill_process_tree(vm.get_pid(), signal.SIGKILL)
elif vm_action == "crash":
session = vm.wait_for_login()
session.cmd("service kdump stop", ignore_all_errors=True)
# Enable sysRq
session.cmd("echo 1 > /proc/sys/kernel/sysrq")
# Send key ALT-SysRq-c to crash VM, and command will not
# return as vm crashed, so fail early for 'destroy' and
# 'preserve' action. For 'restart', 'coredump-restart'
# and 'coredump-destroy' actions, they all need more time
# to dump core file or restart OS, so using the default
# session command timeout(60s)
try:
if vm_oncrash_action in ['destroy', 'preserve']:
timeout = 3
else:
timeout = 60
session.cmd("echo c > /proc/sysrq-trigger",
timeout=timeout)
except (ShellTimeoutError, ShellProcessTerminatedError):
pass
session.close()
elif vm_action == "dump":
dump_file = dump_path + "*" + vm_name + "-*"
virsh.dump(vm_name,
dump_file,
dump_option,
ignore_status=False)
except process.CmdError as detail:
test.error("Guest prepare action error: %s" % detail)
if libvirtd_state == "off":
libvirtd.stop()
# Timing issue cause test to check domstate before prior action
# kill gets completed
if vm_action == "kill":
time.sleep(2)
if remote_uri:
remote_ip = params.get("remote_ip", "REMOTE.EXAMPLE.COM")
remote_pwd = params.get("remote_pwd", None)
remote_user = params.get("remote_user", "root")
if remote_ip.count("EXAMPLE.COM"):
test.cancel("Test 'remote' parameters not setup")
ssh_key.setup_ssh_key(remote_ip, remote_user, remote_pwd)
result = virsh.domstate(vm_ref,
extra,
ignore_status=True,
debug=True,
uri=remote_uri)
status = result.exit_status
output = result.stdout.strip()
# check status_error
if status_error:
if not status:
if libvirtd_state == "off" and libvirt_version.version_compare(
5, 6, 0):
logging.info(
"From libvirt version 5.6.0 libvirtd is restarted "
"and command should succeed.")
else:
test.fail("Run successfully with wrong command!")
else:
if status or not output:
test.fail("Run failed with right command")
if extra.count("reason"):
if vm_action == "suspend":
# If not, will cost long time to destroy vm
virsh.destroy(vm_name)
if not output.count("user"):
test.fail(err_msg % vm_action)
elif vm_action == "resume":
if not output.count("unpaused"):
test.fail(err_msg % vm_action)
elif vm_action == "destroy":
if not output.count("destroyed"):
test.fail(err_msg % vm_action)
elif vm_action == "start":
if start_action == "rename":
if not output.count("shut off (failed)"):
test.fail(err_msg % vm_action)
else:
if not output.count("booted"):
test.fail(err_msg % vm_action)
elif vm_action == "kill":
if not output.count("crashed"):
test.fail(err_msg % vm_action)
elif vm_action == "crash":
if not check_crash_state(output, vm_oncrash_action,
vm_name, dump_file):
test.fail(err_msg % vm_action)
# VM will be in preserved state, perform virsh reset
# and check VM reboots and domstate reflects running
# state from crashed state as bug is observed here
if vm_oncrash_action == "preserve" and reset_action:
virsh_dargs = {'debug': True, 'ignore_status': True}
ret = virsh.reset(vm_name, **virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.domstate(vm_name, extra,
**virsh_dargs).stdout.strip()
if "paused (crashed)" not in ret:
test.fail("vm fails to change state from crashed"
" to paused after virsh reset")
# it will be in paused (crashed) state after reset
# and resume is required for the vm to reboot
ret = virsh.resume(vm_name, **virsh_dargs)
libvirt.check_exit_status(ret)
vm.wait_for_login()
cmd_output = virsh.domstate(vm_name,
'--reason').stdout.strip()
if "running" not in cmd_output:
test.fail("guest state failed to get updated")
if vm_oncrash_action in [
'coredump-destroy', 'coredump-restart'
]:
if not find_dump_file:
test.fail("Core dump file is not created in dump "
"path: %s" % dump_path)
# For cover bug 1178652
if (vm_oncrash_action == "rename-restart"
and check_libvirtd_log == "yes"):
libvirtd.restart()
if not os.path.exists(libvirtd_log_file):
test.fail("Expected VM log file: %s not exists" %
libvirtd_log_file)
cmd = ("grep -nr '%s' %s" %
(err_msg, libvirtd_log_file))
if not process.run(cmd, ignore_status=True,
shell=True).exit_status:
test.fail(
"Find error message %s from log file: %s." %
(err_msg, libvirtd_log_file))
elif vm_action == "dump":
if dump_option == "--live":
if not output.count("running (unpaused)"):
test.fail(err_msg % vm_action)
elif dump_option == "--crash":
if not output.count("shut off (crashed)"):
test.fail(err_msg % vm_action)
if vm_ref == "remote":
if not (re.search("running", output) or re.search(
"blocked", output) or re.search("idle", output)):
test.fail("Run failed with right command")
finally:
qemu_conf.restore()
if check_libvirtd_log == "yes":
libvirtd_conf.restore()
if os.path.exists(libvirtd_log_file):
os.remove(libvirtd_log_file)
libvirtd.restart()
if vm_action == "start" and start_action == "rename":
os.rename(new_image_source, image_source)
if vm.is_alive():
vm.destroy(gracefully=False)
backup_xml.sync()
if os.path.exists(dump_path):
shutil.rmtree(dump_path)
def run(test, params, env):
"""
Integration test of backup and backing_chain.
Steps:
1. craete a vm with extra disk vdb
2. create some data on vdb
3. start a pull mode full backup on vdb
4. create some data on vdb
5. start a pull mode incremental backup
6. repeat step 5 to 7
7. before the last round of backup job, do a blockcommit/pull/copy
8. check the full/incremental backup file data
"""
def run_blk_cmd():
"""
Run blockcommit/blockpull/blockcopy command.
"""
def run_blockpull():
"""
Run blockpull command.
"""
if from_to == "mid_to_top":
cmd_option = ("--base {0}[{1}] --wait").format(original_disk_target,
middle_layer1_index)
elif from_to == "base_to_top":
cmd_option = ("--base {0}[{1}] --wait").format(original_disk_target,
base_layer_index)
virsh.blockpull(vm_name, original_disk_target, cmd_option,
debug=True, ignore_status=False)
def run_blockcommit():
"""
Run blockcommit command.
"""
if from_to == "top_to_base":
# Do blockcommit from top layer to base layer
cmd_option = ("--top {0}[{1}] --base {0}[{2}] --active --pivot "
"--wait".format(original_disk_target,
top_layer_index,
base_layer_index)
)
elif from_to == "mid_to_mid":
# Do blockcommit from middle layer to another middle layer
if len(indice) < 4:
test.fail("At lease 4 layers required for the test 'mid_to_mid'")
cmd_option = ("--top {0}[{1}] --base {0}[{2}] "
"--wait".format(original_disk_target,
middle_layer1_index,
middle_layer2_index)
)
elif from_to == "top_to_mid":
# Do blockcommit from top layer to middle layer
cmd_option = ("--top {0}[{1}] --base {0}[{2}] --active --pivot "
"--wait".format(original_disk_target,
top_layer_index,
middle_layer1_index)
)
elif from_to == "mid_to_base":
# Do blockcommit from middle layer to base layer
cmd_option = ("--top {0}[{1}] --base {0}[{2}] "
"--wait".format(original_disk_target,
middle_layer1_index,
base_layer_index)
)
virsh.blockcommit(vm_name, original_disk_target, cmd_option,
debug=True, ignore_stauts=False)
def run_blockcopy():
"""
Run blockcopy command.
"""
copy_dest = os.path.join(tmp_dir, "copy_dest.qcow2")
cmd_option = "--wait --verbose --transient-job --pivot"
if blockcopy_method == "shallow_copy":
cmd_option += " --shallow"
if blockcopy_reuse == "reuse_external":
cmd_option += " --reuse-external"
if blockcopy_method == "shallow_copy":
create_img_cmd = "qemu-img create -f qcow2 -F qcow2 -b %s %s"
create_img_cmd %= (backend_img, copy_dest)
else:
create_img_cmd = "qemu-img create -f qcow2 %s %s"
create_img_cmd %= (copy_dest, original_disk_size)
process.run(create_img_cmd, shell=True, ignore_status=False)
virsh.blockcopy(vm_name, original_disk_target, copy_dest, cmd_option,
debug=True, ignore_status=False)
# Get disk backing store indice info in vm disk xml
cur_vm_xml = vm_xml.VMXML.new_from_dumpxml(vm_name)
cur_disk_xmls = cur_vm_xml.get_devices(device_type="disk")
cur_test_disk_xml = ''
for disk_xml in cur_disk_xmls:
if disk_xml.target['dev'] == original_disk_target:
cur_test_disk_xml = disk_xml
logging.debug("Current disk xml for %s is:\n %s",
original_disk_target, cur_test_disk_xml)
break
indice = re.findall(r".*index=['|\"](\d+)['|\"].*", str(cur_test_disk_xml))
logging.debug("backing store indice for %s is: %s",
original_disk_target, indice)
if len(indice) < 3:
test.fail("At least 3 layers required for the test.")
top_layer_index = indice[0]
middle_layer1_index = indice[1]
middle_layer2_index = indice[-2]
base_layer_index = indice[-1]
logging.debug("Following backing store will be used: %s",
"top:%s; middle_1: %s, middle_2:%s, base: %s"
% (top_layer_index, middle_layer1_index,
middle_layer2_index, base_layer_index)
)
# Start the block command
if blockcommand == "blockpull":
run_blockpull()
if blockcommand == "blockcommit":
run_blockcommit()
if blockcommand == "blockcopy":
run_blockcopy()
def create_shutoff_snapshot(original_img, snapshot_img):
"""
Create shutoff snapshot, which means the disk snapshot is not controlled
by libvirt, but created directly by qemu command.
:param original_img: The image we will take shutoff snapshot for.
:param snapshot_img: The newly created shutoff snapshot image.
"""
cmd = "qemu-img info --output=json -f qcow2 {}".format(original_img)
img_info = process.run(cmd, shell=True, ignore_status=False).stdout_text
json_data = json.loads(img_info)
cmd = "qemu-img create -f qcow2 -F qcow2 -b {0} {1}".format(original_img, snapshot_img)
process.run(cmd, shell=True, ignore_status=False)
try:
bitmaps = json_data['format-specific']['data']['bitmaps']
for bitmap in bitmaps:
bitmap_flags = bitmap['flags']
bitmap_name = bitmap['name']
if 'auto' in bitmap_flags and 'in-use' not in bitmap_flags:
cmd = "qemu-img bitmap -f qcow2 {0} --add {1}".format(snapshot_img, bitmap_name)
process.run(cmd, shell=True, ignore_status=False)
except Exception as bitmap_error:
logging.debug("Cannot add bitmap to new image, skip it: %s",
bitmap_error)
# Cancel the test if libvirt version is too low
if not libvirt_version.version_compare(6, 0, 0):
test.cancel("Current libvirt version doesn't support "
"incremental backup.")
# vm's origianl disk config
original_disk_size = params.get("original_disk_size", "100M")
original_disk_type = params.get("original_disk_type", "local")
original_disk_target = params.get("original_disk_target", "vdb")
# pull mode backup config
scratch_type = params.get("scratch_type", "file")
nbd_protocol = params.get("nbd_protocol", "tcp")
nbd_tcp_port = params.get("nbd_tcp_port", "10809")
# test config
backup_rounds = int(params.get("backup_rounds", 4))
shutoff_snapshot = "yes" == params.get("shutoff_snapshot")
blockcommand = params.get("blockcommand")
from_to = params.get("from_to")
blockcopy_method = params.get("blockcopy_method")
blockcopy_reuse = params.get("blockcopy_reuse")
backup_error = "yes" == params.get("backup_error")
tmp_dir = data_dir.get_tmp_dir()
try:
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
# Backup vm xml
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
vmxml_backup = vmxml.copy()
disks_not_tested = list(vmxml.get_disk_all().keys())
logging.debug("Not tested disks are: %s", disks_not_tested)
# Enable vm incremental backup capability. This is only a workaround
# to make sure incremental backup can work for the vm. Code needs to
# be removded immediately when the function enabled by default, which
# is tracked by bz1799015
tree = ET.parse(vmxml.xml)
root = tree.getroot()
for elem in root.iter('domain'):
elem.set('xmlns:qemu', 'http://libvirt.org/schemas/domain/qemu/1.0')
qemu_cap = ET.Element("qemu:capabilities")
elem.insert(-1, qemu_cap)
incbackup_cap = ET.Element("qemu:add")
incbackup_cap.set('capability', 'incremental-backup')
qemu_cap.insert(1, incbackup_cap)
vmxml.undefine()
tmp_vm_xml = os.path.join(tmp_dir, "tmp_vm.xml")
tree.write(tmp_vm_xml)
virsh.define(tmp_vm_xml)
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
logging.debug("Script insert xml elements to make sure vm can support "
"incremental backup. This should be removded when "
"bz 1799015 fixed.")
# Destroy vm before test
if vm.is_alive():
vm.destroy(gracefully=False)
# Prepare the disk to be backuped.
disk_params = {}
disk_path = ""
if original_disk_type == "local":
image_name = "%s_image.qcow2" % original_disk_target
disk_path = os.path.join(tmp_dir, image_name)
libvirt.create_local_disk("file", disk_path, original_disk_size,
"qcow2")
disk_params = {"device_type": "disk",
"type_name": "file",
"driver_type": "qcow2",
"target_dev": original_disk_target,
"source_file": disk_path}
if original_disk_target:
disk_params["target_dev"] = original_disk_target
else:
logging.cancel("The disk type '%s' not supported in this script.",
original_disk_type)
disk_xml = libvirt.create_disk_xml(disk_params)
virsh.attach_device(vm.name, disk_xml,
flagstr="--config", debug=True)
vm.start()
session = vm.wait_for_login()
new_disks_in_vm = list(utils_disk.get_linux_disks(session).keys())
session.close()
if len(new_disks_in_vm) != 1:
test.fail("Test disk not prepared in vm")
# Use the newly added disk as the test disk
test_disk_in_vm = "/dev/" + new_disks_in_vm[0]
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
vm_disks = list(vmxml.get_disk_all().keys())
checkpoint_list = []
is_incremental = False
backup_file_list = []
snapshot_list = []
cur_disk_xml = disk_xml
cur_disk_path = disk_path
cur_disk_params = disk_params
backend_img = ""
for backup_index in range(backup_rounds):
# Do external snapshot
if shutoff_snapshot:
virsh.detach_disk(vm.name, original_disk_target,
extra="--persistent",
ignore_status=False, debug=True)
if vm.is_alive():
vm.destroy(gracefully=False)
shutoff_snapshot_name = "shutoff_snap_%s" % str(backup_index)
shutoff_snapshot_path = os.path.join(tmp_dir, shutoff_snapshot_name)
create_shutoff_snapshot(cur_disk_path, shutoff_snapshot_path)
cur_disk_params["source_file"] = shutoff_snapshot_path
cur_disk_xml = libvirt.create_disk_xml(cur_disk_params)
virsh.attach_device(vm.name, cur_disk_xml,
flagstr="--config",
ignore_status=False,
debug=True)
vm.start()
vm.wait_for_login().close()
cur_disk_path = shutoff_snapshot_path
else:
snapshot_name = "snap_%s" % str(backup_index)
snapshot_option = ""
snapshot_file_name = os.path.join(tmp_dir, snapshot_name)
for disk_name in disks_not_tested:
snapshot_option += "--diskspec %s,snapshot=no " % disk_name
snapshot_option += "--diskspec %s,file=%s" % (original_disk_target,
snapshot_file_name)
virsh.snapshot_create_as(vm_name,
"%s --disk-only %s" % (snapshot_name,
snapshot_option),
debug=True)
snapshot_list.append(snapshot_name)
# Prepare backup xml
backup_params = {"backup_mode": "pull"}
if backup_index > 0:
is_incremental = True
backup_params["backup_incremental"] = "checkpoint_" + str(backup_index - 1)
# Set libvirt default nbd export name and bitmap name
nbd_export_name = original_disk_target
nbd_bitmap_name = "backup-" + original_disk_target
backup_server_dict = {"name": "localhost",
"port": nbd_tcp_port}
backup_params["backup_server"] = backup_server_dict
backup_disk_xmls = []
for vm_disk in vm_disks:
backup_disk_params = {"disk_name": vm_disk}
if vm_disk != original_disk_target:
backup_disk_params["enable_backup"] = "no"
else:
backup_disk_params["enable_backup"] = "yes"
backup_disk_params["disk_type"] = scratch_type
# Prepare nbd scratch file/dev params
scratch_params = {}
scratch_file_name = "scratch_file_%s" % backup_index
scratch_file_path = os.path.join(tmp_dir, scratch_file_name)
scratch_params["file"] = scratch_file_path
logging.debug("scratch_params: %s", scratch_params)
backup_disk_params["backup_scratch"] = scratch_params
backup_disk_xml = utils_backup.create_backup_disk_xml(
backup_disk_params)
backup_disk_xmls.append(backup_disk_xml)
logging.debug("disk list %s", backup_disk_xmls)
backup_xml = utils_backup.create_backup_xml(backup_params,
backup_disk_xmls)
logging.debug("ROUND_%s Backup Xml: %s", backup_index, backup_xml)
# Prepare checkpoint xml
checkpoint_name = "checkpoint_%s" % backup_index
checkpoint_list.append(checkpoint_name)
cp_params = {"checkpoint_name": checkpoint_name}
cp_params["checkpoint_desc"] = params.get("checkpoint_desc",
"desc of cp_%s" % backup_index)
disk_param_list = []
for vm_disk in vm_disks:
cp_disk_param = {"name": vm_disk}
if vm_disk != original_disk_target:
cp_disk_param["checkpoint"] = "no"
else:
cp_disk_param["checkpoint"] = "bitmap"
cp_disk_bitmap = params.get("cp_disk_bitmap")
if cp_disk_bitmap:
cp_disk_param["bitmap"] = cp_disk_bitmap + str(backup_index)
disk_param_list.append(cp_disk_param)
checkpoint_xml = utils_backup.create_checkpoint_xml(cp_params,
disk_param_list)
logging.debug("ROUND_%s Checkpoint Xml: %s",
backup_index, checkpoint_xml)
# Start backup
backup_options = backup_xml.xml + " " + checkpoint_xml.xml
# Create some data in vdb
dd_count = "1"
dd_seek = str(backup_index * 10 + 10)
dd_bs = "1M"
utils_disk.dd_data_to_vm_disk(vm, test_disk_in_vm, dd_bs,
dd_seek, dd_count)
backup_result = virsh.backup_begin(vm_name, backup_options,
debug=True)
if backup_result.exit_status:
raise utils_backup.BackupBeginError(backup_result.stderr.strip())
backup_file_path = os.path.join(
tmp_dir, "backup_file_%s.qcow2" % str(backup_index))
backup_file_list.append(backup_file_path)
if not is_incremental:
# Do full backup
nbd_export = ("nbd://localhost:%s/%s" %
(nbd_tcp_port, nbd_export_name))
utils_backup.pull_full_backup_to_file(nbd_export,
backup_file_path)
logging.debug("Full backup to: %s", backup_file_path)
else:
# Do incremental backup
nbd_params = {"nbd_protocol": nbd_protocol,
"nbd_export": nbd_export_name,
"nbd_tcp_port": nbd_tcp_port}
utils_backup.pull_incremental_backup_to_file(
nbd_params, backup_file_path, nbd_bitmap_name,
original_disk_size)
virsh.domjobabort(vm_name, debug=True)
# Start to run the blockcommit/blockpull cmd before the last round
# of backup job, this is to test if the block command will keep the
# dirty bitmap data.
if backup_index == backup_rounds - 2:
run_blk_cmd()
cur_disk_path = vm.get_blk_devices()[original_disk_target]['source']
if backup_index == backup_rounds - 3:
backend_img = vm.get_blk_devices()[original_disk_target]['source']
# Get current active image for the test disk
vm_disks = vm.get_blk_devices()
current_active_image = vm_disks[original_disk_target]['source']
logging.debug("The current active image for '%s' is '%s'",
original_disk_target, current_active_image)
for checkpoint_name in checkpoint_list:
virsh.checkpoint_delete(vm_name, checkpoint_name,
debug=True, ignore_status=False)
if vm.is_alive():
vm.destroy(gracefully=False)
# Compare the backup data and original data
original_data_file = os.path.join(tmp_dir, "original_data.qcow2")
cmd = "qemu-img convert -f qcow2 %s -O qcow2 %s" % (current_active_image, original_data_file)
process.run(cmd, shell=True, verbose=True)
for backup_file in backup_file_list:
if not utils_backup.cmp_backup_data(original_data_file, backup_file):
test.fail("Backup and original data are not identical for"
"'%s' and '%s'" % (current_active_image, backup_file))
else:
logging.debug("'%s' contains correct backup data", backup_file)
except utils_backup.BackupBeginError as details:
if backup_error:
logging.debug("Backup failed as expected.")
else:
test.fail(details)
finally:
# Remove checkpoints' metadata again to make sure vm has no checkpoints
if "checkpoint_list" in locals():
for checkpoint_name in checkpoint_list:
virsh.checkpoint_delete(vm_name, checkpoint_name,
options="--metadata")
# Remove snapshots
if "snapshot_list" in locals():
for snapshot_name in snapshot_list:
virsh.snapshot_delete(vm_name, "%s --metadata" % snapshot_name,
debug=True)
if vm.is_alive():
vm.destroy(gracefully=False)
# Restoring vm
vmxml_backup.sync()
for file_name in os.listdir(tmp_dir):
file_path = os.path.join(tmp_dir, file_name)
if 'env' not in file_path:
if os.path.isfile(file_path):
os.remove(file_path)
elif os.path.isdir(file_path):
shutil.rmtree(file_path)
def run(test, params, env):
"""
Test the pull-mode backup function
Steps:
1. craete a vm with extra disk vdb
2. create some data on vdb
3. start a pull mode full backup on vdb
4. create some data on vdb
5. start a pull mode incremental backup
6. repeat step 5 to 7
7. check the full/incremental backup file data
"""
# Basic case config
hotplug_disk = "yes" == params.get("hotplug_disk", "no")
original_disk_size = params.get("original_disk_size", "100M")
original_disk_type = params.get("original_disk_type", "local")
original_disk_target = params.get("original_disk_target", "vdb")
local_hostname = params.get("loal_hostname", "localhost")
local_ip = params.get("local_ip", "127.0.0.1")
local_user_name = params.get("local_user_name", "root")
local_user_password = params.get("local_user_password", "redhat")
tmp_dir = data_dir.get_tmp_dir()
# Backup config
scratch_type = params.get("scratch_type", "file")
reuse_scratch_file = "yes" == params.get("reuse_scratch_file")
prepare_scratch_file = "yes" == params.get("prepare_scratch_file")
scratch_blkdev_path = params.get("scratch_blkdev_path")
scratch_blkdev_size = params.get("scratch_blkdev_size", original_disk_size)
prepare_scratch_blkdev = "yes" == params.get("prepare_scratch_blkdev")
backup_rounds = int(params.get("backup_rounds", 3))
backup_error = "yes" == params.get("backup_error")
expect_backup_canceled = "yes" == params.get("expect_backup_canceled")
# NBD service config
nbd_protocol = params.get("nbd_protocol", "unix")
nbd_socket = params.get("nbd_socket", "/tmp/pull_backup.socket")
nbd_tcp_port = params.get("nbd_tcp_port", "10809")
nbd_hostname = local_hostname
set_exportname = "yes" == params.get("set_exportname")
set_exportbitmap = "yes" == params.get("set_exportbitmap")
# TLS service config
tls_enabled = "yes" == params.get("tls_enabled")
tls_x509_verify = "yes" == params.get("tls_x509_verify")
custom_pki_path = "yes" == params.get("custom_pki_path")
tls_client_ip = tls_server_ip = local_ip
tls_client_cn = tls_server_cn = local_hostname
tls_client_user = tls_server_user = local_user_name
tls_client_pwd = tls_server_pwd = local_user_password
tls_provide_client_cert = "yes" == params.get("tls_provide_client_cert")
tls_error = "yes" == params.get("tls_error")
# LUKS config
scratch_luks_encrypted = "yes" == params.get("scratch_luks_encrypted")
luks_passphrase = params.get("luks_passphrase", "password")
# Cancel the test if libvirt support related functions
if not libvirt_version.version_compare(6, 0, 0):
test.cancel("Current libvirt version doesn't support "
"incremental backup.")
if tls_enabled and not libvirt_version.version_compare(6, 6, 0):
test.cancel("Current libvirt version doesn't support pull mode "
"backup with tls nbd.")
try:
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
# Make sure there is no checkpoint metadata before test
utils_backup.clean_checkpoints(vm_name)
# Backup vm xml
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
vmxml_backup = vmxml.copy()
utils_backup.enable_inc_backup_for_vm(vm)
# Prepare tls env
if tls_enabled:
# Prepare pki
tls_config = {
"qemu_tls": "yes",
"auto_recover": "yes",
"client_ip": tls_client_ip,
"server_ip": tls_server_ip,
"client_cn": tls_client_cn,
"server_cn": tls_server_cn,
"client_user": tls_client_user,
"server_user": tls_server_user,
"client_pwd": tls_client_pwd,
"server_pwd": tls_server_pwd,
}
if custom_pki_path:
pki_path = os.path.join(tmp_dir, "inc_bkup_pki")
else:
pki_path = "/etc/pki/libvirt-backup/"
if tls_x509_verify:
tls_config["client_ip"] = tls_client_ip
tls_config["custom_pki_path"] = pki_path
tls_obj = TLSConnection(tls_config)
tls_obj.conn_setup(True, tls_provide_client_cert)
logging.debug("TLS certs in: %s" % pki_path)
# Set qemu.conf
qemu_config = LibvirtQemuConfig()
if tls_x509_verify:
qemu_config.backup_tls_x509_verify = True
else:
qemu_config.backup_tls_x509_verify = False
if custom_pki_path:
qemu_config.backup_tls_x509_cert_dir = pki_path
utils_libvirtd.Libvirtd().restart()
# Prepare libvirt secret
if scratch_luks_encrypted:
utils_secret.clean_up_secrets()
luks_secret_uuid = libvirt.create_secret(params)
virsh.secret_set_value(luks_secret_uuid,
luks_passphrase,
encode=True,
debug=True)
# Prepare the disk to be backuped.
disk_params = {}
disk_path = ""
if original_disk_type == "local":
image_name = "{}_image.qcow2".format(original_disk_target)
disk_path = os.path.join(tmp_dir, image_name)
libvirt.create_local_disk("file", disk_path, original_disk_size,
"qcow2")
disk_params = {
"device_type": "disk",
"type_name": "file",
"driver_type": "qcow2",
"target_dev": original_disk_target,
"source_file": disk_path
}
if original_disk_target:
disk_params["target_dev"] = original_disk_target
elif original_disk_type == "iscsi":
iscsi_host = '127.0.0.1'
iscsi_target, lun_num = libvirt.setup_or_cleanup_iscsi(
is_setup=True,
is_login=False,
image_size=original_disk_size,
portal_ip=iscsi_host)
disk_path = ("iscsi://[%s]/%s/%s" %
(iscsi_host, iscsi_target, lun_num))
process.run("qemu-img create -f qcow2 %s %s" %
(disk_path, original_disk_size),
shell=True,
verbose=True)
disk_params = {
'device_type': 'disk',
'type_name': 'network',
"driver_type": "qcow2",
'target_dev': original_disk_target
}
disk_params_src = {
'source_protocol': 'iscsi',
'source_name': iscsi_target + "/%s" % lun_num,
'source_host_name': iscsi_host,
'source_host_port': '3260'
}
disk_params.update(disk_params_src)
elif original_disk_type == "gluster":
gluster_vol_name = "gluster_vol"
gluster_pool_name = "gluster_pool"
gluster_img_name = "gluster.qcow2"
gluster_host_ip = gluster.setup_or_cleanup_gluster(
is_setup=True,
vol_name=gluster_vol_name,
pool_name=gluster_pool_name,
**params)
disk_path = 'gluster://%s/%s/%s' % (
gluster_host_ip, gluster_vol_name, gluster_img_name)
process.run("qemu-img create -f qcow2 %s %s" %
(disk_path, original_disk_size),
shell=True,
verbose=True)
disk_params = {
'device_type': 'disk',
'type_name': 'network',
"driver_type": "qcow2",
'target_dev': original_disk_target
}
disk_params_src = {
'source_protocol': 'gluster',
'source_name': gluster_vol_name + "/%s" % gluster_img_name,
'source_host_name': gluster_host_ip,
'source_host_port': '24007'
}
disk_params.update(disk_params_src)
else:
test.error("The disk type '%s' not supported in this script.",
original_disk_type)
if hotplug_disk:
vm.start()
session = vm.wait_for_login().close()
disk_xml = libvirt.create_disk_xml(disk_params)
virsh.attach_device(vm_name, disk_xml, debug=True)
else:
disk_xml = libvirt.create_disk_xml(disk_params)
virsh.attach_device(vm.name,
disk_xml,
flagstr="--config",
debug=True)
vm.start()
session = vm.wait_for_login()
new_disks_in_vm = list(utils_disk.get_linux_disks(session).keys())
session.close()
if len(new_disks_in_vm) != 1:
test.fail("Test disk not prepared in vm")
# Use the newly added disk as the test disk
test_disk_in_vm = "/dev/" + new_disks_in_vm[0]
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
vm_disks = list(vmxml.get_disk_all().keys())
checkpoint_list = []
is_incremental = False
backup_file_list = []
for backup_index in range(backup_rounds):
# Prepare backup xml
backup_params = {"backup_mode": "pull"}
if backup_index > 0:
is_incremental = True
backup_params["backup_incremental"] = "checkpoint_" + str(
backup_index - 1)
# Set libvirt default nbd export name and bitmap name
nbd_export_name = original_disk_target
nbd_bitmap_name = "backup-" + original_disk_target
backup_server_dict = {}
if nbd_protocol == "unix":
backup_server_dict["transport"] = "unix"
backup_server_dict["socket"] = nbd_socket
else:
backup_server_dict["name"] = nbd_hostname
backup_server_dict["port"] = nbd_tcp_port
if tls_enabled:
backup_server_dict["tls"] = "yes"
backup_params["backup_server"] = backup_server_dict
backup_disk_xmls = []
for vm_disk in vm_disks:
backup_disk_params = {"disk_name": vm_disk}
if vm_disk != original_disk_target:
backup_disk_params["enable_backup"] = "no"
else:
backup_disk_params["enable_backup"] = "yes"
backup_disk_params["disk_type"] = scratch_type
# Custom nbd export name and bitmap name if required
if set_exportname:
nbd_export_name = original_disk_target + "_custom_exp"
backup_disk_params["exportname"] = nbd_export_name
if set_exportbitmap:
nbd_bitmap_name = original_disk_target + "_custom_bitmap"
backup_disk_params["exportbitmap"] = nbd_bitmap_name
# Prepare nbd scratch file/dev params
scratch_params = {"attrs": {}}
scratch_path = None
if scratch_type == "file":
scratch_file_name = "scratch_file_%s" % backup_index
scratch_path = os.path.join(tmp_dir, scratch_file_name)
if prepare_scratch_file:
libvirt.create_local_disk("file", scratch_path,
original_disk_size,
"qcow2")
scratch_params["attrs"]["file"] = scratch_path
elif scratch_type == "block":
if prepare_scratch_blkdev:
scratch_path = libvirt.setup_or_cleanup_iscsi(
is_setup=True, image_size=scratch_blkdev_size)
scratch_params["attrs"]["dev"] = scratch_path
else:
test.fail(
"We do not support backup scratch type: '%s'" %
scratch_type)
if scratch_luks_encrypted:
encryption_dict = {
"encryption": "luks",
"secret": {
"type": "passphrase",
"uuid": luks_secret_uuid
}
}
scratch_params["encryption"] = encryption_dict
logging.debug("scratch params: %s", scratch_params)
backup_disk_params["backup_scratch"] = scratch_params
backup_disk_xml = utils_backup.create_backup_disk_xml(
backup_disk_params)
backup_disk_xmls.append(backup_disk_xml)
logging.debug("disk list %s", backup_disk_xmls)
backup_xml = utils_backup.create_backup_xml(
backup_params, backup_disk_xmls)
logging.debug("ROUND_%s Backup Xml: %s", backup_index, backup_xml)
# Prepare checkpoint xml
checkpoint_name = "checkpoint_%s" % backup_index
checkpoint_list.append(checkpoint_name)
cp_params = {"checkpoint_name": checkpoint_name}
cp_params["checkpoint_desc"] = params.get(
"checkpoint_desc", "desc of cp_%s" % backup_index)
disk_param_list = []
for vm_disk in vm_disks:
cp_disk_param = {"name": vm_disk}
if vm_disk != original_disk_target:
cp_disk_param["checkpoint"] = "no"
else:
cp_disk_param["checkpoint"] = "bitmap"
cp_disk_bitmap = params.get("cp_disk_bitmap")
if cp_disk_bitmap:
cp_disk_param["bitmap"] = cp_disk_bitmap + str(
backup_index)
disk_param_list.append(cp_disk_param)
checkpoint_xml = utils_backup.create_checkpoint_xml(
cp_params, disk_param_list)
logging.debug("ROUND_%s Checkpoint Xml: %s", backup_index,
checkpoint_xml)
# Create some data in vdb
dd_count = "1"
dd_seek = str(backup_index * 10 + 10)
dd_bs = "1M"
session = vm.wait_for_login()
utils_disk.dd_data_to_vm_disk(session, test_disk_in_vm, dd_bs,
dd_seek, dd_count)
session.close()
# Start backup
backup_options = backup_xml.xml + " " + checkpoint_xml.xml
if reuse_scratch_file:
backup_options += " --reuse-external"
backup_result = virsh.backup_begin(vm_name,
backup_options,
ignore_status=True,
debug=True)
if backup_result.exit_status:
raise utils_backup.BackupBeginError(
backup_result.stderr.strip())
# If required, do some error operations during backup job
error_operation = params.get("error_operation")
if error_operation:
if "destroy_vm" in error_operation:
vm.destroy(gracefully=False)
if "kill_qemu" in error_operation:
utils_misc.safe_kill(vm.get_pid(), signal.SIGKILL)
if utils_misc.wait_for(
lambda: utils_backup.is_backup_canceled(vm_name),
timeout=5):
raise utils_backup.BackupCanceledError()
elif expect_backup_canceled:
test.fail("Backup job should be canceled but not.")
backup_file_path = os.path.join(
tmp_dir, "backup_file_%s.qcow2" % str(backup_index))
backup_file_list.append(backup_file_path)
nbd_params = {
"nbd_protocol": nbd_protocol,
"nbd_export": nbd_export_name
}
if nbd_protocol == "unix":
nbd_params["nbd_socket"] = nbd_socket
elif nbd_protocol == "tcp":
nbd_params["nbd_hostname"] = nbd_hostname
nbd_params["nbd_tcp_port"] = nbd_tcp_port
if tls_enabled:
nbd_params["tls_dir"] = pki_path
nbd_params["tls_server_ip"] = tls_server_ip
if not is_incremental:
# Do full backup
try:
utils_backup.pull_full_backup_to_file(
nbd_params, backup_file_path)
except Exception as details:
if tls_enabled and tls_error:
raise utils_backup.BackupTLSError(details)
else:
test.fail("Fail to get full backup data: %s" % details)
logging.debug("Full backup to: %s", backup_file_path)
else:
# Do incremental backup
utils_backup.pull_incremental_backup_to_file(
nbd_params, backup_file_path, nbd_bitmap_name,
original_disk_size)
# Check if scratch file encrypted
if scratch_luks_encrypted and scratch_path:
cmd = "qemu-img info -U %s" % scratch_path
result = process.run(cmd, shell=True,
verbose=True).stdout_text.strip()
if (not re.search("format.*luks", result, re.IGNORECASE)
or not re.search("encrypted.*yes", result,
re.IGNORECASE)):
test.fail("scratch file/dev is not encrypted by LUKS")
virsh.domjobabort(vm_name, debug=True)
for checkpoint_name in checkpoint_list:
virsh.checkpoint_delete(vm_name, checkpoint_name, debug=True)
if vm.is_alive():
vm.destroy(gracefully=False)
# Compare the backup data and original data
original_data_file = os.path.join(tmp_dir, "original_data.qcow2")
cmd = "qemu-img convert -f qcow2 %s -O qcow2 %s" % (disk_path,
original_data_file)
process.run(cmd, shell=True, verbose=True)
for backup_file in backup_file_list:
if not utils_backup.cmp_backup_data(original_data_file,
backup_file):
test.fail("Backup and original data are not identical for"
"'%s' and '%s'" % (disk_path, backup_file))
else:
logging.debug("'%s' contains correct backup data", backup_file)
except utils_backup.BackupBeginError as detail:
if backup_error:
logging.debug("Backup failed as expected.")
else:
test.fail("Backup failed to start: %s" % detail)
except utils_backup.BackupTLSError as detail:
if tls_error:
logging.debug("Failed to get backup data as expected.")
else:
test.fail("Failed to get tls backup data: %s" % detail)
except utils_backup.BackupCanceledError as detail:
if expect_backup_canceled:
logging.debug("Backup canceled as expected.")
if not vm.is_alive():
logging.debug("Check if vm can be started again when backup "
"canceled.")
vm.start()
vm.wait_for_login().close()
else:
test.fail("Backup job canceled: %s" % detail)
finally:
# Remove checkpoints
clean_checkpoint_metadata = not vm.is_alive()
if "error_operation" in locals() and "kill_qemu" in error_operation:
clean_checkpoint_metadata = True
utils_backup.clean_checkpoints(
vm_name, clean_metadata=clean_checkpoint_metadata)
if vm.is_alive():
vm.destroy(gracefully=False)
# Restoring vm
vmxml_backup.sync()
# Remove iscsi devices
if original_disk_type == "iscsi" or scratch_type == "block":
libvirt.setup_or_cleanup_iscsi(False)
# Remove gluster devices
if original_disk_type == "gluster":
gluster.setup_or_cleanup_gluster(is_setup=False,
vol_name=gluster_vol_name,
pool_name=gluster_pool_name,
**params)
# Recover qemu.conf
if "qemu_config" in locals():
qemu_config.restore()
# Remove tls object
if "tls_obj" in locals():
del tls_obj
# Remove libvirt secret
if "luks_secret_uuid" in locals():
virsh.secret_undefine(luks_secret_uuid, ignore_status=True)
def run(test, params, env):
"""
Test virtio/virtio-transitional/virtio-non-transitional model of disk
:param test: Test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment
"""
def reboot():
"""
Shutdown and restart guest, then wait for login
"""
vm.destroy()
vm.start()
vm.wait_for_login()
def attach(xml, device_name, plug_method="hot"):
"""
Attach device with xml, for both hot and cold plug
:param xml: Device xml to be attached
:param device_name: Device name to be attached
:param plug_method: hot or cold for plug method
"""
device_before_plug = find_device(vm, params)
with open(xml) as disk_file:
logging.debug("Attach disk by XML: %s", disk_file.read())
file_arg = xml
if plug_method == "cold":
file_arg += ' --config'
s_attach = virsh.attach_device(domainarg=vm_name,
filearg=file_arg,
debug=True)
libvirt.check_exit_status(s_attach)
if plug_method == "cold":
reboot()
detect_time = params.get("detect_disk_time", 20)
plug_disks = utils_misc.wait_for(
lambda: get_new_device(device_before_plug, find_device(vm, params)
), detect_time)
if not plug_disks:
test.fail("Failed to hotplug device %s to guest" % device_name)
def detach(xml, device_name, unplug_method="hot"):
"""
Detach device with xml, for both hot and cold unplug
:param xml: Device xml to be attached
:param device_name: Device name to be attached
:param plug_method: hot or cold for unplug method
"""
with open(xml) as disk_file:
logging.debug("Detach device by XML: %s", disk_file.read())
file_arg = xml
if unplug_method == "cold":
file_arg = xml + ' --config'
s_detach = virsh.detach_device(domainarg=vm_name,
filearg=file_arg,
debug=True)
if unplug_method == "cold":
reboot()
libvirt.check_exit_status(s_detach)
def attach_disk(): # pylint: disable=W0611
"""
Sub test for attach disk, including hot and cold plug/unplug
"""
plug_method = params.get("plug_method", "hot")
device_source_format = params.get("at_disk_source_format", "raw")
device_target = params.get("at_disk_target", "vdb")
device_disk_bus = params.get("at_disk_bus", "virtio")
device_source_name = params.get("at_disk_source", "attach.img")
detect_time = params.get("detect_disk_time", 10)
device_source_path = os.path.join(tmp_dir, device_source_name)
device_source = libvirt.create_local_disk(
"file",
path=device_source_path,
size="1",
disk_format=device_source_format)
def _generate_disk_xml():
"""Generate xml for device hotplug/unplug usage"""
diskxml = devices.disk.Disk("file")
diskxml.device = "disk"
source_params = {"attrs": {'file': device_source}}
diskxml.source = diskxml.new_disk_source(**source_params)
diskxml.target = {'dev': device_target, 'bus': device_disk_bus}
if params.get("disk_model"):
diskxml.model = params.get("disk_model")
if pci_bridge_index and device_disk_bus == 'virtio':
addr = diskxml.new_disk_address('pci')
addr.set_attrs({'bus': pci_bridge_index, 'slot': slot})
diskxml.address = addr
return diskxml.xml
v_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
slot = get_free_slot(pci_bridge_index, v_xml)
disk_xml = _generate_disk_xml()
attach(disk_xml, device_target, plug_method)
if plug_method == "cold":
disk_xml = _generate_disk_xml()
detach(disk_xml, device_target, plug_method)
if not utils_misc.wait_for(
lambda: not libvirt.device_exists(vm, device_target),
detect_time):
test.fail("Detach disk failed.")
def attach_controller(): # pylint: disable=W0611
"""
Sub test for attach controller
"""
v_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
contr_index = len(v_xml.get_controllers('scsi'))
contr_type = params.get("controller_type", 'scsi')
contr_model = params.get("controller_model", "virtio-scsi")
contr_dict = {
'controller_type': contr_type,
'controller_model': contr_model,
'controller_index': contr_index
}
if pci_bridge_index:
slot = get_free_slot(pci_bridge_index, v_xml)
addr = '{"bus": %s, "slot": %s}' % (pci_bridge_index, slot)
contr_dict.update({'controller_addr': addr})
xml = libvirt.create_controller_xml(contr_dict=contr_dict)
attach(xml, params['controller_model'])
xml = libvirt.create_controller_xml(contr_dict=contr_dict)
detach(xml, params['controller_model'])
def snapshot(): # pylint: disable=W0611
"""
Sub test for snapshot
"""
for i in range(1, 4):
ret = virsh.snapshot_create_as(vm_name, "sn%s --disk-only" % i)
libvirt.check_exit_status(ret)
process.system("systemctl restart libvirtd")
save_path = os.path.join(tmp_dir, "test.save")
ret = virsh.save(vm_name, save_path)
libvirt.check_exit_status(ret)
ret = virsh.restore(save_path)
libvirt.check_exit_status(ret)
session = vm.wait_for_login()
session.close()
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(params["main_vm"])
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
backup_xml = vmxml.copy()
add_pcie_to_pci_bridge = params.get("add_pcie_to_pci_bridge")
pci_bridge_index = None
tmp_dir = data_dir.get_tmp_dir()
guest_src_url = params.get("guest_src_url")
if guest_src_url:
def _download():
download_cmd = ("wget %s -O %s" % (guest_src_url, target_path))
if process.system(download_cmd, shell=True):
test.error("Failed to download file")
image_name = params['image_path']
target_path = utils_misc.get_path(data_dir.get_data_dir(), image_name)
if not os.path.exists(target_path):
if utils_package.package_install("wget"):
utils_misc.wait_for(_download, timeout=360)
else:
test.error("Fail to install wget")
params["blk_source_name"] = target_path
if add_pcie_to_pci_bridge:
pci_controllers = vmxml.get_controllers('pci')
for controller in pci_controllers:
if controller.get('model') == 'pcie-to-pci-bridge':
pci_bridge = controller
break
else:
contr_dict = {
'controller_type': 'pci',
'controller_model': 'pcie-to-pci-bridge'
}
pci_bridge = libvirt.create_controller_xml(contr_dict,
"add_controller",
vm_name)
pci_bridge_index = '%0#4x' % int(pci_bridge.get("index"))
try:
if (params["os_variant"] == 'rhel6'
or 'rhel6' in params.get("shortname")):
iface_params = {'model': 'virtio-transitional'}
libvirt.modify_vm_iface(vm_name, "update_iface", iface_params)
libvirt.set_vm_disk(vm, params)
if pci_bridge_index:
v_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
if params.get("disk_target_bus") == "scsi":
scsi_controllers = v_xml.get_controllers('scsi')
for index, controller in enumerate(scsi_controllers):
controller.find('address').set('bus', pci_bridge_index)
controller.find('address').set(
'slot', get_free_slot(pci_bridge_index, v_xml))
else:
disks = v_xml.get_devices(device_type="disk")
for index, disk in enumerate(disks):
args = {
'bus': pci_bridge_index,
'slot': get_free_slot(pci_bridge_index, v_xml)
}
libvirt.set_disk_attr(v_xml, disk.target['dev'], 'address',
args)
v_xml.xmltreefile.write()
v_xml.sync()
if not vm.is_alive():
vm.start()
vm.wait_for_login()
test_step = params.get("sub_test_step")
if test_step:
eval(test_step)()
finally:
vm.destroy()
libvirt.clean_up_snapshots(vm_name)
backup_xml.sync()
def run(test, params, env):
"""
Test virsh snapshot command when disk in all kinds of type.
(1). Init the variables from params.
(2). Create a image by specifice format.
(3). Attach disk to vm.
(4). Snapshot create.
(5). Snapshot revert.
(6). cleanup.
"""
# Init variables.
vm_name = params.get("main_vm", "virt-tests-vm1")
vm = env.get_vm(vm_name)
image_format = params.get("snapshot_image_format", "qcow2")
snapshot_del_test = "yes" == params.get("snapshot_del_test", "no")
status_error = ("yes" == params.get("status_error", "no"))
snapshot_from_xml = ("yes" == params.get("snapshot_from_xml", "no"))
snapshot_current = ("yes" == params.get("snapshot_current", "no"))
snapshot_revert_paused = ("yes" == params.get("snapshot_revert_paused",
"no"))
# Pool variables.
snapshot_with_pool = "yes" == params.get("snapshot_with_pool", "no")
pool_name = params.get("pool_name")
pool_type = params.get("pool_type")
pool_target = params.get("pool_target")
emulated_image = params.get("emulated_image")
vol_name = params.get("vol_name")
vol_format = params.get("vol_format")
lazy_refcounts = "yes" == params.get("lazy_refcounts")
options = params.get("snapshot_options", "")
# Set volume xml attribute dictionary, extract all params start with 'vol_'
# which are for setting volume xml, except 'lazy_refcounts'.
vol_arg = {}
for key in params.keys():
if key.startswith('vol_'):
if key[4:] in ['capacity', 'allocation', 'owner', 'group']:
vol_arg[key[4:]] = int(params[key])
else:
vol_arg[key[4:]] = params[key]
vol_arg['lazy_refcounts'] = lazy_refcounts
supported_pool_list = [
"dir", "fs", "netfs", "logical", "iscsi", "disk", "gluster"
]
if snapshot_with_pool:
if pool_type not in supported_pool_list:
raise error.TestNAError("%s not in support list %s" %
(pool_target, supported_pool_list))
# Do xml backup for final recovery
vmxml_backup = libvirt_xml.VMXML.new_from_inactive_dumpxml(vm_name)
# Some variable for xmlfile of snapshot.
snapshot_memory = params.get("snapshot_memory", "internal")
snapshot_disk = params.get("snapshot_disk", "internal")
# Skip 'qed' cases for libvirt version greater than 1.1.0
if libvirt_version.version_compare(1, 1, 0):
if vol_format == "qed":
raise error.TestNAError("QED support changed, check bug: "
"https://bugzilla.redhat.com/show_bug.cgi"
"?id=731570")
# Init snapshot_name
snapshot_name = None
snapshot_external_disk = []
snapshot_xml_path = None
del_status = None
image = None
pvt = None
# Get a tmp dir
tmp_dir = data_dir.get_tmp_dir()
snap_cfg_path = "/var/lib/libvirt/qemu/snapshot/%s/" % vm_name
try:
if snapshot_with_pool:
# Create dst pool for create attach vol img
pvt = utlv.PoolVolumeTest(test, params)
pvt.pre_pool(pool_name,
pool_type,
pool_target,
emulated_image,
image_size="1G",
pre_disk_vol=["20M"])
if pool_type in ["iscsi", "disk"]:
# iscsi and disk pool did not support create volume in libvirt,
# logical pool could use libvirt to create volume but volume
# format is not supported and will be 'raw' as default.
pv = libvirt_storage.PoolVolume(pool_name)
vols = pv.list_volumes().keys()
if vols:
vol_name = vols[0]
else:
raise error.TestNAError("No volume in pool: %s", pool_name)
else:
# Set volume xml file
volxml = libvirt_xml.VolXML()
newvol = volxml.new_vol(**vol_arg)
vol_xml = newvol['xml']
# Run virsh_vol_create to create vol
logging.debug("create volume from xml: %s" %
newvol.xmltreefile)
cmd_result = virsh.vol_create(pool_name,
vol_xml,
ignore_status=True,
debug=True)
if cmd_result.exit_status:
raise error.TestNAError("Failed to create attach volume.")
cmd_result = virsh.vol_path(vol_name, pool_name, debug=True)
if cmd_result.exit_status:
raise error.TestNAError("Failed to get volume path from pool.")
img_path = cmd_result.stdout.strip()
if pool_type in ["logical", "iscsi", "disk"]:
# Use qemu-img to format logical, iscsi and disk block device
if vol_format != "raw":
cmd = "qemu-img create -f %s %s 10M" % (vol_format,
img_path)
cmd_result = utils.run(cmd, ignore_status=True)
if cmd_result.exit_status:
raise error.TestNAError("Failed to format volume, %s" %
cmd_result.stdout.strip())
extra = "--persistent --subdriver %s" % vol_format
else:
# Create a image.
params['image_name'] = "snapshot_test"
params['image_format'] = image_format
params['image_size'] = "1M"
image = qemu_storage.QemuImg(params, tmp_dir, "snapshot_test")
img_path, _ = image.create(params)
extra = "--persistent --subdriver %s" % image_format
# Do the attach action.
out = utils.run("qemu-img info %s" % img_path)
logging.debug("The img info is:\n%s" % out.stdout.strip())
result = virsh.attach_disk(vm_name,
source=img_path,
target="vdf",
extra=extra,
debug=True)
if result.exit_status:
raise error.TestNAError("Failed to attach disk %s to VM."
"Detail: %s." % (img_path, result.stderr))
# Create snapshot.
if snapshot_from_xml:
snapshot_name = "snapshot_test"
lines = [
"<domainsnapshot>\n",
"<name>%s</name>\n" % snapshot_name,
"<description>Snapshot Test</description>\n"
]
if snapshot_memory == "external":
memory_external = os.path.join(tmp_dir, "snapshot_memory")
snapshot_external_disk.append(memory_external)
lines.append("<memory snapshot=\'%s\' file='%s'/>\n" %
(snapshot_memory, memory_external))
else:
lines.append("<memory snapshot='%s'/>\n" % snapshot_memory)
# Add all disks into xml file.
disks = vm.get_disk_devices().values()
lines.append("<disks>\n")
for disk in disks:
lines.append("<disk name='%s' snapshot='%s'>\n" %
(disk['source'], snapshot_disk))
if snapshot_disk == "external":
snap_path = "%s.snap" % os.path.basename(disk['source'])
disk_external = os.path.join(tmp_dir, snap_path)
snapshot_external_disk.append(disk_external)
lines.append("<source file='%s'/>\n" % disk_external)
lines.append("</disk>\n")
lines.append("</disks>\n")
lines.append("</domainsnapshot>")
snapshot_xml_path = "%s/snapshot_xml" % tmp_dir
snapshot_xml_file = open(snapshot_xml_path, "w")
snapshot_xml_file.writelines(lines)
snapshot_xml_file.close()
logging.debug("The xml content for snapshot create is:")
with open(snapshot_xml_path, 'r') as fin:
logging.debug(fin.read())
options += " --xmlfile %s " % snapshot_xml_path
snapshot_result = virsh.snapshot_create(vm_name,
options,
debug=True)
out_err = snapshot_result.stderr.strip()
if snapshot_result.exit_status:
if status_error:
return
else:
if re.search(
"live disk snapshot not supported with this QEMU binary",
out_err):
raise error.TestNAError(out_err)
if libvirt_version.version_compare(1, 2, 5):
# As commit d2e668e in 1.2.5, internal active snapshot
# without memory state is rejected. Handle it as SKIP
# for now. This could be supportted in future by bug:
# https://bugzilla.redhat.com/show_bug.cgi?id=1103063
if re.search(
"internal snapshot of a running VM" +
" must include the memory state", out_err):
raise error.TestNAError("Check Bug #1083345, %s" %
out_err)
raise error.TestFail(
"Failed to create snapshot. Error:%s." % out_err)
else:
snapshot_result = virsh.snapshot_create(vm_name, options)
if snapshot_result.exit_status:
if status_error:
return
else:
raise error.TestFail(
"Failed to create snapshot. Error:%s." %
snapshot_result.stderr.strip())
snapshot_name = re.search("\d+",
snapshot_result.stdout.strip()).group(0)
if snapshot_current:
lines = [
"<domainsnapshot>\n",
"<description>Snapshot Test</description>\n",
"<state>running</state>\n",
"<creationTime>%s</creationTime>" % snapshot_name,
"</domainsnapshot>"
]
snapshot_xml_path = "%s/snapshot_xml" % tmp_dir
snapshot_xml_file = open(snapshot_xml_path, "w")
snapshot_xml_file.writelines(lines)
snapshot_xml_file.close()
logging.debug("The xml content for snapshot create is:")
with open(snapshot_xml_path, 'r') as fin:
logging.debug(fin.read())
options += "--redefine %s --current" % snapshot_xml_path
if snapshot_result.exit_status:
raise error.TestFail("Failed to create snapshot --current."
"Error:%s." %
snapshot_result.stderr.strip())
if status_error:
if not snapshot_del_test:
raise error.TestFail("Success to create snapshot in negative"
" case\nDetail: %s" % snapshot_result)
# Touch a file in VM.
if vm.is_dead():
vm.start()
session = vm.wait_for_login()
# Init a unique name for tmp_file.
tmp_file = tempfile.NamedTemporaryFile(prefix=("snapshot_test_"),
dir="/tmp")
tmp_file_path = tmp_file.name
tmp_file.close()
echo_cmd = "echo SNAPSHOT_DISK_TEST >> %s" % tmp_file_path
status, output = session.cmd_status_output(echo_cmd)
logging.debug("The echo output in domain is: '%s'", output)
if status:
raise error.TestFail("'%s' run failed with '%s'" %
(tmp_file_path, output))
status, output = session.cmd_status_output("cat %s" % tmp_file_path)
logging.debug("File created with content: '%s'", output)
session.close()
# Destroy vm for snapshot revert.
if not libvirt_version.version_compare(1, 2, 3):
virsh.destroy(vm_name)
# Revert snapshot.
revert_options = ""
if snapshot_revert_paused:
revert_options += " --paused"
revert_result = virsh.snapshot_revert(vm_name,
snapshot_name,
revert_options,
debug=True)
if revert_result.exit_status:
# As commit d410e6f for libvirt 1.2.3, attempts to revert external
# snapshots will FAIL with an error "revert to external snapshot
# not supported yet". Thus, let's check for that and handle as a
# SKIP for now. Check bug:
# https://bugzilla.redhat.com/show_bug.cgi?id=1071264
if libvirt_version.version_compare(1, 2, 3):
if re.search("revert to external snapshot not supported yet",
revert_result.stderr):
raise error.TestNAError(revert_result.stderr.strip())
else:
raise error.TestFail("Revert snapshot failed. %s" %
revert_result.stderr.strip())
if vm.is_dead():
raise error.TestFail("Revert snapshot failed.")
if snapshot_revert_paused:
if vm.is_paused():
vm.resume()
else:
raise error.TestFail("Revert command successed, but VM is not "
"paused after reverting with --paused"
" option.")
# login vm.
session = vm.wait_for_login()
# Check the result of revert.
status, output = session.cmd_status_output("cat %s" % tmp_file_path)
logging.debug("After revert cat file output='%s'", output)
if not status:
raise error.TestFail("Tmp file exists, revert failed.")
# Close the session.
session.close()
# Test delete snapshot without "--metadata", delete external disk
# snapshot will fail for now.
# Only do this when snapshot creat succeed which filtered in cfg file.
if snapshot_del_test:
if snapshot_name:
del_result = virsh.snapshot_delete(vm_name,
snapshot_name,
debug=True,
ignore_status=True)
del_status = del_result.exit_status
snap_xml_path = snap_cfg_path + "%s.xml" % snapshot_name
if del_status:
if not status_error:
raise error.TestFail("Failed to delete snapshot.")
else:
if not os.path.exists(snap_xml_path):
raise error.TestFail(
"Snapshot xml file %s missing" % snap_xml_path)
else:
if status_error:
err_msg = "Snapshot delete succeed but expect fail."
raise error.TestFail(err_msg)
else:
if os.path.exists(snap_xml_path):
raise error.TestFail("Snapshot xml file %s still" %
snap_xml_path + " exist")
finally:
virsh.detach_disk(vm_name, target="vdf", extra="--persistent")
if image:
image.remove()
if del_status and snapshot_name:
virsh.snapshot_delete(vm_name, snapshot_name, "--metadata")
for disk in snapshot_external_disk:
if os.path.exists(disk):
os.remove(disk)
vmxml_backup.sync("--snapshots-metadata")
if snapshot_xml_path:
if os.path.exists(snapshot_xml_path):
os.unlink(snapshot_xml_path)
if pvt:
try:
pvt.cleanup_pool(pool_name, pool_type, pool_target,
emulated_image)
except error.TestFail, detail:
logging.error(str(detail))
def run(test, params, env):
"""
convert specific kvm guest to rhev
"""
for v in list(params.values()):
if "V2V_EXAMPLE" in v:
test.cancel("Please set real value for %s" % v)
if utils_v2v.V2V_EXEC is None:
test.error('Missing command: virt-v2v')
# Guest name might be changed, we need a new variant to save the original
# name
vm_name = params['original_vm_name'] = params.get('main_vm', 'EXAMPLE')
target = params.get('target')
input_mode = params.get('input_mode')
input_file = params.get('input_file')
output_mode = params.get('output_mode')
output_format = params.get('output_format')
output_storage = params.get('output_storage', 'default')
bridge = params.get('bridge')
network = params.get('network')
address_cache = env.get('address_cache')
v2v_timeout = int(params.get('v2v_timeout', 1200))
status_error = 'yes' == params.get('status_error', 'no')
skip_vm_check = params.get('skip_vm_check', 'no')
pool_name = params.get('pool_name', 'v2v_test')
pool_type = params.get('pool_type', 'dir')
pool_target = params.get('pool_target_path', 'v2v_pool')
pvt = libvirt.PoolVolumeTest(test, params)
checkpoint = params.get('checkpoint', '')
datastore = params.get('datastore')
esxi_host = params.get('esx_hostname')
esxi_password = params.get('esxi_password')
hypervisor = params.get("hypervisor")
input_transport = params.get("input_transport")
vmx_nfs_src = params.get("vmx_nfs_src")
# for construct rhv-upload option in v2v cmd
output_method = params.get("output_method")
rhv_upload_opts = params.get("rhv_upload_opts")
storage_name = params.get('storage_name')
# for get ca.crt file from ovirt engine
rhv_passwd = params.get("rhv_upload_passwd")
rhv_passwd_file = params.get("rhv_upload_passwd_file")
ovirt_engine_passwd = params.get("ovirt_engine_password")
ovirt_hostname = params.get("ovirt_engine_url").split(
'/')[2] if params.get("ovirt_engine_url") else None
ovirt_ca_file_path = params.get("ovirt_ca_file_path")
local_ca_file_path = params.get("local_ca_file_path")
vpx_dc = params.get("vpx_dc")
vpx_hostname = params.get("vpx_hostname")
vpx_password = params.get("vpx_password")
src_uri_type = params.get('src_uri_type')
error_list = []
# create different sasl_user name for different job
if output_mode == 'rhev':
params.update({'sasl_user': params.get("sasl_user") +
utils_misc.generate_random_string(3)})
logging.info('sals user name is %s' % params.get("sasl_user"))
if output_method == 'rhv_upload':
# Create password file for '-o rhv_upload' to connect to ovirt
with open(rhv_passwd_file, 'w') as f:
f.write(rhv_passwd)
# Copy ca file from ovirt to local
remote.scp_from_remote(ovirt_hostname, 22, 'root',
ovirt_engine_passwd,
ovirt_ca_file_path,
local_ca_file_path)
def log_fail(msg):
"""
Log error and update error list
"""
logging.error(msg)
error_list.append(msg)
def check_BSOD():
"""
Check if boot up into BSOD
"""
bar = 0.999
match_img = params.get('image_to_match')
screenshot = '%s/BSOD_screenshot.ppm' % data_dir.get_tmp_dir()
if match_img is None:
test.error('No BSOD screenshot to match!')
cmd_man_page = 'man virt-v2v|grep -i "Boot failure: 0x0000007B"'
if process.run(cmd_man_page, shell=True).exit_status != 0:
log_fail('Man page not contain boot failure msg')
for i in range(100):
virsh.screenshot(vm_name, screenshot)
similar = ppm_utils.image_histogram_compare(screenshot, match_img)
if similar > bar:
logging.info('Meet BSOD with similarity %s' % similar)
return
time.sleep(1)
log_fail('No BSOD as expected')
def check_result(result, status_error):
"""
Check virt-v2v command result
"""
libvirt.check_exit_status(result, status_error)
output = result.stdout + result.stderr
if not status_error:
if output_mode == 'rhev':
if not utils_v2v.import_vm_to_ovirt(params, address_cache,
timeout=v2v_timeout):
test.fail('Import VM failed')
# Create vmchecker before virsh.start so that the vm can be undefined
# if started failed.
vmchecker = VMChecker(test, params, env)
params['vmchecker'] = vmchecker
if output_mode == 'libvirt':
try:
virsh.start(vm_name, debug=True, ignore_status=False)
except Exception as e:
test.fail('Start vm failed: %s' % str(e))
# Check guest following the checkpoint document after convertion
if params.get('skip_vm_check') != 'yes':
if checkpoint != 'win2008r2_ostk':
ret = vmchecker.run()
if len(ret) == 0:
logging.info("All common checkpoints passed")
if checkpoint == 'win2008r2_ostk':
check_BSOD()
# Merge 2 error lists
error_list.extend(vmchecker.errors)
log_check = utils_v2v.check_log(params, output)
if log_check:
log_fail(log_check)
if len(error_list):
test.fail(
'%d checkpoints failed: %s' %
(len(error_list), error_list))
try:
v2v_params = {
'main_vm': vm_name, 'target': target, 'v2v_opts': '-v -x',
'storage': output_storage, 'network': network, 'bridge': bridge,
'input_mode': input_mode, 'input_file': input_file,
'new_name': 'ova_vm_' + utils_misc.generate_random_string(3),
'datastore': datastore,
'esxi_host': esxi_host,
'esxi_password': esxi_password,
'input_transport': input_transport,
'vmx_nfs_src': vmx_nfs_src,
'output_method': output_method,
'storage_name': storage_name,
'rhv_upload_opts': rhv_upload_opts
}
if input_mode == 'vmx':
v2v_params.update(
{'new_name': vm_name + utils_misc.generate_random_string(3),
'hypervisor': hypervisor,
'vpx_dc': vpx_dc,
'password': vpx_password if src_uri_type != 'esx' else esxi_password,
'hostname': vpx_hostname})
# copy ova from nfs storage before v2v conversion
if input_mode == 'ova':
src_dir = params.get('ova_dir')
dest_dir = params.get('ova_copy_dir')
logging.info('Copy ova from %s to %s', src_dir, dest_dir)
if not os.path.exists(dest_dir):
shutil.copytree(src_dir, dest_dir)
else:
logging.debug('%s already exists, Skip copying' % dest_dir)
if output_format:
v2v_params.update({'output_format': output_format})
# Create libvirt dir pool
if output_mode == 'libvirt':
pvt.pre_pool(pool_name, pool_type, pool_target, '')
# Build rhev related options
if output_mode == 'rhev':
# Create SASL user on the ovirt host
user_pwd = "[['%s', '%s']]" % (params.get("sasl_user"),
params.get("sasl_pwd"))
v2v_sasl = utils_sasl.SASL(sasl_user_pwd=user_pwd)
v2v_sasl.server_ip = params.get("remote_ip")
v2v_sasl.server_user = params.get('remote_user')
v2v_sasl.server_pwd = params.get('remote_pwd')
v2v_sasl.setup(remote=True)
if output_mode == 'local':
v2v_params['storage'] = data_dir.get_tmp_dir()
if checkpoint == 'ova_relative_path':
logging.debug('Current dir: %s', os.getcwd())
ova_dir = params.get('ova_dir')
logging.info('Change to dir: %s', ova_dir)
os.chdir(ova_dir)
# Set libguestfs environment variable
os.environ['LIBGUESTFS_BACKEND'] = 'direct'
if checkpoint == 'permission':
os.environ['LIBGUESTFS_BACKEND'] = ''
process.run('echo $LIBGUESTFS_BACKEND', shell=True)
v2v_result = utils_v2v.v2v_cmd(v2v_params)
if 'new_name' in v2v_params:
vm_name = params['main_vm'] = v2v_params['new_name']
check_result(v2v_result, status_error)
finally:
# Cleanup constant files
utils_v2v.cleanup_constant_files(params)
if input_mode == 'ova' and os.path.exists(dest_dir):
shutil.rmtree(dest_dir)
if params.get('vmchecker'):
params['vmchecker'].cleanup()
if output_mode == 'rhev' and v2v_sasl:
v2v_sasl.cleanup()
if output_mode == 'libvirt':
pvt.cleanup_pool(pool_name, pool_type, pool_target, '')
if input_mode == 'vmx' and input_transport == 'ssh':
process.run("ssh-agent -k")
def __init__(self, test, params):
self.vm_name = params.get("main_vm", "avocado-vt-vm1")
self.env = params.get("env")
self.vm = self.env.get_vm(self.vm_name)
self.operation_timeout = int(params.get("operation_timeout"))
self.nfs_no_response_sign = params.get("nfs_no_response_sign")
self.export_options = params.get("export_options")
self.mount_options = params.get("mount_options")
self.operation = params.get("operation")
self.operation_option = params.get("operation_option")
self.sav_filename = params.get("sav_filename")
self.iptable_rule = params.get("iptable_rule")
self.vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(
self.vm_name)
self.disk_tgt = self.vmxml_backup.get_disk_all().keys()[0]
def setup_nfs_disk(vm_name):
"""
Setup disk on nfs storage
"""
vmxml = vm_xml.VMXML.new_from_dumpxml(self.vm_name)
disk_xml = vmxml.get_devices(device_type="disk")[0]
source_image_path = disk_xml.source.attrs['file']
logging.debug("VM origin image path: %s", source_image_path)
seLinuxBool = SELinuxBoolean(params)
seLinuxBool.setup()
nfs_res = utils_test.libvirt.setup_or_cleanup_nfs(
is_setup=True,
is_mount=True,
export_options=self.export_options,
mount_options=self.mount_options)
logging.debug('NFS is setup ~~~~~~~~~~')
cp_cmd = process.run("cp %s %s" %
(source_image_path, nfs_res['mount_dir']))
time.sleep(3)
logging.debug("cp command: %s", cp_cmd.command)
vmxml.del_device(disk_xml)
nfs_image_path = os.path.join(nfs_res['mount_dir'],
os.path.basename(source_image_path))
logging.debug("VM new image path %s", nfs_image_path)
disk_dict = {'attrs': {'file': nfs_image_path}}
disk_xml.source = disk_xml.new_disk_source(**disk_dict)
logging.debug("VM new disk xml:\n%s", disk_xml)
vmxml.add_device(disk_xml)
vmxml.sync()
return nfs_res
def operations():
"""
Do save | domstats | blkdeviotune operations
"""
if self.operation == "save":
virsh.save(self.vm_name,
self.save_file,
debug=True,
timeout=self.operation_timeout)
if self.operation == "domstats":
virsh.domstats(self.vm_name,
opertions=self.operation_option,
debug=True,
timeout=self.operation_timeout)
if self.operation == "blkdeviotune":
virsh.blkdeviotune(self.vm_name,
self.disk_tgt,
debug=True,
timeout=self.operation_timeout)
self.nfs_res = setup_nfs_disk(self.vm_name)
self.save_file = os.path.join(data_dir.get_tmp_dir(),
self.sav_filename)
self.td = threading.Thread(target=operations)
def run(test, params, env):
'''
Test the command virsh pool-create-as
(1) Prepare backend storage device
(2) Define secret xml and set secret value
(3) Test pool-create-as or virsh pool-define with authenication
'''
pool_options = params.get('pool_options', '')
pool_name = params.get('pool_name')
pool_type = params.get('pool_type')
pool_target = params.get('pool_target', '')
status_error = params.get('status_error') == "yes"
# iscsi options
emulated_size = params.get("iscsi_image_size", "1")
iscsi_host = params.get("iscsi_host", "127.0.0.1")
chap_user = params.get("iscsi_user")
chap_passwd = params.get("iscsi_password")
# ceph options
ceph_auth_user = params.get("ceph_auth_user")
ceph_auth_key = params.get("ceph_auth_key")
ceph_host_ip = params.get("ceph_host_ip", "EXAMPLE_HOSTS")
ceph_mon_ip = params.get("ceph_mon_ip", "EXAMPLE_MON_HOST")
ceph_disk_name = params.get("ceph_disk_name", "EXAMPLE_SOURCE_NAME")
ceph_client_name = params.get("ceph_client_name")
ceph_client_key = params.get("ceph_client_key")
key_file = os.path.join(data_dir.get_tmp_dir(), "ceph.key")
key_opt = "--keyring %s" % key_file
# auth options
auth_usage = (params.get('auth_usage') == 'yes')
auth_uuid = (params.get('auth_uuid') == 'yes')
sec_ephemeral = params.get("secret_ephemeral", "no")
sec_private = params.get("secret_private", "yes")
sec_desc = params.get("secret_description")
auth_type = params.get("auth_type")
sec_usage = params.get("secret_usage_type")
sec_target = params.get("secret_usage_target")
sec_name = params.get("secret_name")
auth_sec_dict = {
"sec_ephemeral": sec_ephemeral,
"sec_private": sec_private,
"sec_desc": sec_desc,
"sec_usage": sec_usage,
"sec_target": sec_target,
"sec_name": sec_name
}
if sec_usage == "iscsi":
auth_username = chap_user
sec_password = chap_passwd
secret_usage = sec_target
if sec_usage == "ceph":
auth_username = ceph_auth_user
sec_password = ceph_auth_key
secret_usage = sec_name
if pool_target and not os.path.isdir(pool_target):
if os.path.isfile(pool_target):
logging.error('<target> must be a directory')
else:
os.makedirs(pool_target)
def setup_ceph_auth():
disk_path = ("rbd:%s:mon_host=%s" % (ceph_disk_name, ceph_mon_ip))
disk_path += (":id=%s:key=%s" % (ceph_auth_user, ceph_auth_key))
if not utils_package.package_install(["ceph-common"]):
test.error("Failed to install ceph-common")
with open(key_file, 'w') as f:
f.write("[%s]\n\tkey = %s\n" % (ceph_client_name, ceph_client_key))
# Delete the disk if it exists
cmd = ("rbd -m {0} {1} info {2} && rbd -m {0} {1} rm "
"{2}".format(ceph_mon_ip, key_opt, ceph_disk_name))
process.run(cmd, ignore_status=True, shell=True)
# Create an local image and make FS on it.
img_file = os.path.join(data_dir.get_tmp_dir(), "test.img")
disk_cmd = ("qemu-img create -f raw {0} 10M && mkfs.ext4 -F {0}".
format(img_file))
process.run(disk_cmd, ignore_status=False, shell=True)
# Convert the image to remote storage
# Ceph can only support raw format
disk_cmd = ("qemu-img convert -O %s %s %s" %
("raw", img_file, disk_path))
process.run(disk_cmd, ignore_status=False, shell=True)
def setup_iscsi_auth():
iscsi_target, lun_num = libvirt.setup_or_cleanup_iscsi(
is_setup=True,
is_login=False,
image_size=emulated_size,
chap_user=chap_user,
chap_passwd=chap_passwd)
return iscsi_target
def check_auth_in_xml(dparams):
sourcexml = pool_xml.PoolXML.new_from_dumpxml(pool_name).get_source()
with open(sourcexml.xml) as xml_f:
logging.debug("Source XML is: \n%s", xml_f.read())
# Check result
try:
for name, v_expect in dparams.items():
if v_expect != sourcexml[name]:
test.fail("Expect to find %s=%s, but got %s=%s" %
(name, v_expect, name, sourcexml[name]))
except xcepts.LibvirtXMLNotFoundError as details:
if "usage not found" in str(details) and auth_uuid:
pass # Not a auth_usage test
elif "uuid not found" in str(details) and auth_usage:
pass # Not a auth_uuid test
else:
test.fail(details)
def check_result(result, expect_error=False):
# pool-define-as return CmdResult
if isinstance(result, process.CmdResult):
result = (result.exit_status == 0) # True means run success
if expect_error:
if result:
test.fail("Expect to fail but run success")
elif not expect_error:
if not result:
test.fail("Expect to succeed but run failure")
else:
logging.info("It's an expected error")
if not libvirt_version.version_compare(3, 9, 0):
test.cancel("Pool create/define with authentication"
" not support in this libvirt version")
sec_uuid = ""
img_file = ""
# Prepare a blank params to confirm if delete the configure at the end of the test
ceph_cfg = ""
libvirt_pool = libvirt_storage.StoragePool()
try:
# Create secret xml and set value
encode = True
if sec_usage == "ceph":
encode = False # Ceph key already encoded
sec_uuid = libvirt.create_secret(auth_sec_dict)
virsh.secret_set_value(sec_uuid,
sec_password,
encode=encode,
debug=True)
if sec_usage == "iscsi":
iscsi_dev = setup_iscsi_auth()
pool_options += (" --source-host %s --source-dev %s"
" --auth-type %s --auth-username %s" %
(iscsi_host, iscsi_dev, auth_type, auth_username))
if sec_usage == "ceph":
# Create config file if it doesn't exist
ceph_cfg = ceph.create_config_file(ceph_mon_ip)
setup_ceph_auth()
rbd_pool = ceph_disk_name.split('/')[0]
pool_options += (
" --source-host %s --source-name %s"
" --auth-type %s --auth-username %s" %
(ceph_host_ip, rbd_pool, auth_type, auth_username))
if auth_usage:
pool_options += " --secret-usage %s" % secret_usage
if auth_uuid:
pool_options += " --secret-uuid %s" % sec_uuid
# Run test cases
func_name = params.get("test_func", "pool_create_as")
logging.info('Perform test runner: %s', func_name)
if func_name == "pool_create_as":
func = virsh.pool_create_as
if func_name == "pool_define_as":
func = virsh.pool_define_as
result = func(pool_name,
pool_type,
pool_target,
extra=pool_options,
debug=True)
# Check status_error
check_result(result, expect_error=status_error)
if not status_error:
# Check pool status
pool_status = libvirt_pool.pool_state(pool_name)
if ((pool_status == 'inactive' and func_name == "pool_define_as")
or
(pool_status == "active" and func_name == "pool_create_as")):
logging.info("Expected pool status:%s" % pool_status)
else:
test.fail("Not an expected pool status: %s" % pool_status)
# Check pool dumpxml
dict_expect = {
"auth_type": auth_type,
"auth_username": auth_username,
"secret_usage": secret_usage,
"secret_uuid": sec_uuid
}
check_auth_in_xml(dict_expect)
finally:
# Clean up
logging.info("Start to cleanup")
# Remove ceph configure file if created.
if ceph_cfg:
os.remove(ceph_cfg)
if os.path.exists(img_file):
os.remove(img_file)
virsh.secret_undefine(sec_uuid, ignore_status=True)
libvirt.setup_or_cleanup_iscsi(is_setup=False)
if libvirt_pool.pool_exists(pool_name):
libvirt_pool.delete_pool(pool_name)
def run(test, params, env):
"""
Test the pull-mode backup function
Steps:
1. craete a vm with extra disk vdb
2. create some data on vdb
3. start a pull mode full backup on vdb
4. monitor block-threshold event on scratch file/dev
5. create some data on vdb's same postion as step 2 to trigger event
6. check the block-threshold event captured
"""
# Basic case config
hotplug_disk = "yes" == params.get("hotplug_disk", "no")
original_disk_size = params.get("original_disk_size", "100M")
original_disk_type = params.get("original_disk_type", "local")
original_disk_target = params.get("original_disk_target", "vdb")
event_type = params.get("event_type")
usage_threshold = params.get("usage_threshold", "100")
tmp_dir = data_dir.get_tmp_dir()
local_hostname = params.get("loal_hostname", "localhost")
# Backup config
scratch_type = params.get("scratch_type", "file")
reuse_scratch_file = "yes" == params.get("reuse_scratch_file")
scratch_blkdev_size = params.get("scratch_blkdev_size", original_disk_size)
# NBD service config
nbd_protocol = params.get("nbd_protocol", "unix")
nbd_socket = params.get("nbd_socket", "/tmp/pull_backup.socket")
nbd_tcp_port = params.get("nbd_tcp_port", "10809")
nbd_hostname = local_hostname
# LUKS config
scratch_luks_encrypted = "yes" == params.get("scratch_luks_encrypted")
luks_passphrase = params.get("luks_passphrase", "password")
# Open a new virsh session for event monitor
virsh_session = aexpect.ShellSession(virsh.VIRSH_EXEC, auto_close=True)
# Cancel the test if libvirt support related functions
if not libvirt_version.version_compare(7, 0, 0):
test.cancel("Current libvirt version doesn't support "
"event monitor for incremental backup.")
def get_backup_disk_index(vm_name, disk_name):
"""
Get the index of the backup disk to be monitored by the virsh event
:param vm_name: vm name
:param disk_name: virtual disk name, such as 'vdb'
:return: the index of the virtual disk in backup xml
"""
backup_xml = virsh.backup_dumpxml(vm_name).stdout.strip()
logging.debug("%s's current backup xml is: %s" % (vm_name, backup_xml))
backup_xml_dom = xml_utils.XMLTreeFile(backup_xml)
index_xpath = "/disks/disk"
for disk_element in backup_xml_dom.findall(index_xpath):
if disk_element.get("name") == disk_name:
return disk_element.get("index")
def is_event_captured(virsh_session, re_pattern):
"""
Check if event captured
:param virsh_session: the virsh session of the event monitor
:param re_pattern: the re pattern used to represent the event
:return: True means event captured, False means not
"""
ret_output = virsh_session.get_stripped_output()
if (not re.search(re_pattern, ret_output, re.IGNORECASE)):
return False
logging.debug("event monitor output: %s", ret_output)
return True
try:
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
# Make sure thedisk_element.getre is no checkpoint metadata before test
utils_backup.clean_checkpoints(vm_name)
# Backup vm xml
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
vmxml_backup = vmxml.copy()
utils_backup.enable_inc_backup_for_vm(vm)
# Prepare libvirt secret
if scratch_luks_encrypted:
utils_secret.clean_up_secrets()
luks_secret_uuid = libvirt.create_secret(params)
virsh.secret_set_value(luks_secret_uuid, luks_passphrase,
encode=True, debug=True)
# Prepare the disk to be backuped.
disk_params = {}
disk_path = ""
image_name = "{}_image.qcow2".format(original_disk_target)
disk_path = os.path.join(tmp_dir, image_name)
libvirt.create_local_disk("file", disk_path, original_disk_size,
"qcow2")
disk_params = {"device_type": "disk",
"type_name": "file",
"driver_type": "qcow2",
"target_dev": original_disk_target,
"source_file": disk_path}
disk_params["target_dev"] = original_disk_target
disk_xml = libvirt.create_disk_xml(disk_params)
virsh.attach_device(vm.name, disk_xml,
flagstr="--config", debug=True)
vm.start()
session = vm.wait_for_login()
new_disks_in_vm = list(utils_disk.get_linux_disks(session).keys())
session.close()
if len(new_disks_in_vm) != 1:
test.fail("Test disk not prepared in vm")
# Use the newly added disk as the test disk
test_disk_in_vm = "/dev/" + new_disks_in_vm[0]
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
vm_disks = list(vmxml.get_disk_all().keys())
checkpoint_list = []
backup_file_list = []
# Prepare backup xml
backup_params = {"backup_mode": "pull"}
# Set libvirt default nbd export name and bitmap name
nbd_export_name = original_disk_target
nbd_bitmap_name = "backup-" + original_disk_target
backup_server_dict = {}
if nbd_protocol == "unix":
backup_server_dict["transport"] = "unix"
backup_server_dict["socket"] = nbd_socket
else:
backup_server_dict["name"] = nbd_hostname
backup_server_dict["port"] = nbd_tcp_port
backup_params["backup_server"] = backup_server_dict
backup_disk_xmls = []
for vm_disk in vm_disks:
backup_disk_params = {"disk_name": vm_disk}
if vm_disk != original_disk_target:
backup_disk_params["enable_backup"] = "no"
else:
backup_disk_params["enable_backup"] = "yes"
backup_disk_params["disk_type"] = scratch_type
# Prepare nbd scratch file/dev params
scratch_params = {"attrs": {}}
scratch_path = None
if scratch_type == "file":
scratch_file_name = "scratch_file"
scratch_path = os.path.join(tmp_dir, scratch_file_name)
if reuse_scratch_file:
libvirt.create_local_disk("file", scratch_path,
original_disk_size, "qcow2")
scratch_params["attrs"]["file"] = scratch_path
elif scratch_type == "block":
scratch_path = libvirt.setup_or_cleanup_iscsi(
is_setup=True, image_size=scratch_blkdev_size)
scratch_params["attrs"]["dev"] = scratch_path
else:
test.fail("We do not support backup scratch type: '%s'"
% scratch_type)
if scratch_luks_encrypted:
encryption_dict = {"encryption": "luks",
"secret": {"type": "passphrase",
"uuid": luks_secret_uuid}}
scratch_params["encryption"] = encryption_dict
logging.debug("scratch params: %s", scratch_params)
backup_disk_params["backup_scratch"] = scratch_params
backup_disk_xml = utils_backup.create_backup_disk_xml(
backup_disk_params)
backup_disk_xmls.append(backup_disk_xml)
logging.debug("disk list %s", backup_disk_xmls)
backup_xml = utils_backup.create_backup_xml(backup_params,
backup_disk_xmls)
logging.debug("Backup Xml: %s", backup_xml)
# Prepare checkpoint xml
checkpoint_name = "checkpoint"
checkpoint_list.append(checkpoint_name)
cp_params = {"checkpoint_name": checkpoint_name}
cp_params["checkpoint_desc"] = params.get("checkpoint_desc",
"desc of cp")
disk_param_list = []
for vm_disk in vm_disks:
cp_disk_param = {"name": vm_disk}
if vm_disk != original_disk_target:
cp_disk_param["checkpoint"] = "no"
else:
cp_disk_param["checkpoint"] = "bitmap"
cp_disk_bitmap = params.get("cp_disk_bitmap")
if cp_disk_bitmap:
cp_disk_param["bitmap"] = cp_disk_bitmap
disk_param_list.append(cp_disk_param)
checkpoint_xml = utils_backup.create_checkpoint_xml(cp_params,
disk_param_list)
logging.debug("Checkpoint Xml: %s", checkpoint_xml)
# Generate some random data in vm's test disk
def dd_data_to_testdisk():
"""
Generate some data to vm's test disk
"""
dd_count = "1"
dd_seek = "10"
dd_bs = "1M"
session = vm.wait_for_login()
utils_disk.dd_data_to_vm_disk(session, test_disk_in_vm, dd_bs,
dd_seek, dd_count)
session.close()
dd_data_to_testdisk()
# Start backup
backup_options = backup_xml.xml + " " + checkpoint_xml.xml
if reuse_scratch_file:
backup_options += " --reuse-external"
backup_result = virsh.backup_begin(vm_name, backup_options,
debug=True)
# Start to monitor block-threshold of backup disk's scratch file/dev
backup_disk_index = get_backup_disk_index(vm_name, original_disk_target)
if not backup_disk_index:
test.fail("Backup xml has no index for disks.")
backup_disk_obj = original_disk_target + "[%s]" % backup_disk_index
virsh.domblkthreshold(vm_name,
original_disk_target + "[%s]" % backup_disk_index,
usage_threshold)
event_cmd = "event %s %s --loop" % (vm_name, event_type)
virsh_session.sendline(event_cmd)
# Generate some random data to same position of vm's test disk
dd_data_to_testdisk()
# Check if the block-threshold event captured by monitor
if event_type == "block-threshold":
event_pattern = (".*block-threshold.*%s.*%s\[%s\].* %s .*" %
(vm_name, original_disk_target,
backup_disk_index, usage_threshold))
if not utils_misc.wait_for(lambda: is_event_captured(virsh_session, event_pattern), 10):
test.fail("Event not captured by event monitor")
# Abort backup job
virsh.domjobabort(vm_name, debug=True)
finally:
# Remove checkpoints
if "checkpoint_list" in locals() and checkpoint_list:
for checkpoint_name in checkpoint_list:
virsh.checkpoint_delete(vm_name, checkpoint_name)
if vm.is_alive():
vm.destroy(gracefully=False)
# Restoring vm
vmxml_backup.sync()
# Remove libvirt secret
if "luks_secret_uuid" in locals():
virsh.secret_undefine(luks_secret_uuid, ignore_status=True)
# Remove iscsi devices
if scratch_type == "block":
libvirt.setup_or_cleanup_iscsi(False)
# Remove scratch file
if "scratch_path" in locals():
if scratch_type == "file" and os.path.exists(scratch_path):
os.remove(scratch_path)
def run(test, params, env):
"""
Test command: virsh save.
The command can save the RAM state of a running domain.
1.Prepare test environment.
2.When the libvirtd == "off", stop the libvirtd service.
3.Run virsh save command with assigned options.
4.Recover test environment.(If the libvirtd service is stopped ,start
the libvirtd service.)
5.Confirm the test result.
"""
savefile = params.get("save_file", "save.file")
if savefile:
savefile = os.path.join(data_dir.get_tmp_dir(), savefile)
libvirtd = params.get("libvirtd", "on")
extra_param = params.get("save_extra_param")
vm_ref = params.get("save_vm_ref")
progress = ("yes" == params.get("save_progress", "no"))
options = params.get("save_option", "")
status_error = ("yes" == params.get("save_status_error", "yes"))
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(vm_name)
uri = params.get("virsh_uri")
readonly = ("yes" == params.get("save_readonly", "no"))
expect_msg = params.get("save_err_msg", "")
unprivileged_user = params.get('unprivileged_user')
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
if not libvirt_version.version_compare(1, 1, 1):
if params.get('setup_libvirt_polkit') == 'yes':
test.cancel("API acl test not supported in current"
" libvirt version.")
domid = vm.get_id()
domuuid = vm.get_uuid()
# set the option
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.count("invalid"):
vm_ref = params.get(vm_ref)
elif vm_ref.count("name"):
vm_ref = vm_name
vm_ref += (" %s" % extra_param)
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
if progress:
options += " --verbose"
result = virsh.save(vm_ref,
savefile,
options,
ignore_status=True,
unprivileged_user=unprivileged_user,
uri=uri,
debug=True,
readonly=readonly)
status = result.exit_status
err_msg = result.stderr.strip()
# recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
if savefile:
virsh.restore(savefile, debug=True)
# check status_error
try:
if status_error:
if not status:
if libvirtd == "off" and libvirt_version.version_compare(
5, 6, 0):
logging.info(
"From libvirt version 5.6.0 libvirtd is restarted "
"and command should succeed")
else:
test.fail("virsh run succeeded with an "
"incorrect command")
if readonly:
if not re.search(expect_msg, err_msg):
test.fail("Fail to get expect err msg: %s" % expect_msg)
else:
if status:
test.fail("virsh run failed with a " "correct command")
if progress and not err_msg.count("Save:"):
test.fail("No progress information outputed!")
if options.count("running"):
if vm.is_dead() or vm.is_paused():
test.fail("Guest state should be"
" running after restore"
" due to the option --running")
elif options.count("paused"):
if not vm.is_paused():
test.fail("Guest state should be"
" paused after restore"
" due to the option --paused")
else:
if vm.is_dead():
test.fail("Guest state should be"
" alive after restore"
" since no option was specified")
finally:
if vm.is_paused():
virsh.resume(vm_name)
def __init__(self,
address,
client,
username,
password,
port,
remote_path,
limit="",
log_filename=None,
verbose=False,
timeout=600):
"""
Initialization of RemoteFile class.
:param address: Address of remote host(guest)
:param client: Type of transfer client
:param username: Username (if required)
:param password: Password (if required)
:param remote_path: Path of file which we want to edit on remote.
:param limit: Speed limit of file transfer.
:param log_filename: If specified, log all output to this
file(SCP only)
:param verbose: If True, log some stats using logging.debug (RSS only)
:param timeout: The time duration (in seconds) to wait for the
transfer tocomplete.
"""
self.address = address
self.client = client
self.username = username
self.password = password
self.port = port
self.remote_path = remote_path
self.limit = limit
self.log_filename = log_filename
self.verbose = verbose
self.timeout = timeout
# Get a local_path and all actions is taken on it.
filename = os.path.basename(self.remote_path)
# Get a local_path.
tmp_dir = data_dir.get_tmp_dir()
local_file = tempfile.NamedTemporaryFile(prefix=("%s_" % filename),
dir=tmp_dir)
self.local_path = local_file.name
local_file.close()
# Get a backup_path.
backup_file = tempfile.NamedTemporaryFile(prefix=("%s_" % filename),
dir=tmp_dir)
self.backup_path = backup_file.name
backup_file.close()
# Get file from remote.
try:
self._pull_file()
except SCPTransferFailedError:
# Remote file doesn't exist, create empty file on local
self._write_local([])
# Save a backup.
shutil.copy(self.local_path, self.backup_path)
def run(test, params, env):
"""
Test rbd disk device.
1.Prepare test environment,destroy or suspend a VM.
2.Prepare disk image.
3.Edit disks xml and start the domain.
4.Perform test operation.
5.Recover test environment.
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
virsh_dargs = {'debug': True, 'ignore_status': True}
additional_xml_file = os.path.join(data_dir.get_tmp_dir(),
"additional_disk.xml")
def config_ceph():
"""
Write the configs to the file.
"""
src_host = disk_src_host.split()
src_port = disk_src_port.split()
conf_str = "mon_host = "
hosts = []
for host, port in zip(src_host, src_port):
hosts.append("%s:%s" % (host, port))
with open(disk_src_config, 'w') as f:
f.write(conf_str + ','.join(hosts) + '\n')
def create_pool():
"""
Define and start a pool.
"""
sp = libvirt_storage.StoragePool()
if create_by_xml:
p_xml = pool_xml.PoolXML(pool_type=pool_type)
p_xml.name = pool_name
s_xml = pool_xml.SourceXML()
s_xml.vg_name = disk_src_pool
source_host = []
for (host_name, host_port) in zip(disk_src_host.split(),
disk_src_port.split()):
source_host.append({'name': host_name, 'port': host_port})
s_xml.hosts = source_host
if auth_type:
s_xml.auth_type = auth_type
if auth_user:
s_xml.auth_username = auth_user
if auth_usage:
s_xml.secret_usage = auth_usage
p_xml.source = s_xml
logging.debug("Pool xml: %s", p_xml)
p_xml.xmltreefile.write()
ret = virsh.pool_define(p_xml.xml, **virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.pool_build(pool_name, **virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.pool_start(pool_name, **virsh_dargs)
libvirt.check_exit_status(ret)
else:
auth_opt = ""
if client_name and client_key:
auth_opt = (
"--auth-type %s --auth-username %s --secret-usage '%s'" %
(auth_type, auth_user, auth_usage))
if not sp.define_rbd_pool(
pool_name, mon_host, disk_src_pool, extra=auth_opt):
test.fail("Failed to define storage pool")
if not sp.build_pool(pool_name):
test.fail("Failed to build storage pool")
if not sp.start_pool(pool_name):
test.fail("Failed to start storage pool")
# Check pool operation
ret = virsh.pool_refresh(pool_name, **virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.pool_uuid(pool_name, **virsh_dargs)
libvirt.check_exit_status(ret)
# pool-info
pool_info = sp.pool_info(pool_name)
if pool_info["Autostart"] != 'no':
test.fail("Failed to check pool information")
# pool-autostart
if not sp.set_pool_autostart(pool_name):
test.fail("Failed to set pool autostart")
pool_info = sp.pool_info(pool_name)
if pool_info["Autostart"] != 'yes':
test.fail("Failed to check pool information")
# pool-autostart --disable
if not sp.set_pool_autostart(pool_name, "--disable"):
test.fail("Failed to set pool autostart")
# If port is not pre-configured, port value should not be hardcoded in pool information.
if "yes" == params.get("rbd_port", "no"):
if 'port' in virsh.pool_dumpxml(pool_name):
test.fail("port attribute should not be in pool information")
# find-storage-pool-sources-as
if "yes" == params.get("find_storage_pool_sources_as", "no"):
ret = virsh.find_storage_pool_sources_as("rbd", mon_host)
libvirt.check_result(ret, skip_if=unsupported_err)
def create_vol(vol_params):
"""
Create volume.
:param p_name. Pool name.
:param vol_params. Volume parameters dict.
:return: True if create successfully.
"""
pvt = libvirt.PoolVolumeTest(test, params)
if create_by_xml:
pvt.pre_vol_by_xml(pool_name, **vol_params)
else:
pvt.pre_vol(vol_name, None, '2G', None, pool_name)
def check_vol(vol_params):
"""
Check volume information.
"""
pv = libvirt_storage.PoolVolume(pool_name)
# Supported operation
if vol_name not in pv.list_volumes():
test.fail("Volume %s doesn't exist" % vol_name)
ret = virsh.vol_dumpxml(vol_name, pool_name)
libvirt.check_exit_status(ret)
# vol-info
if not pv.volume_info(vol_name):
test.fail("Can't see volume info")
# vol-key
ret = virsh.vol_key(vol_name, pool_name)
libvirt.check_exit_status(ret)
if "%s/%s" % (disk_src_pool, vol_name) not in ret.stdout.strip():
test.fail("Volume key isn't correct")
# vol-path
ret = virsh.vol_path(vol_name, pool_name)
libvirt.check_exit_status(ret)
if "%s/%s" % (disk_src_pool, vol_name) not in ret.stdout.strip():
test.fail("Volume path isn't correct")
# vol-pool
ret = virsh.vol_pool("%s/%s" % (disk_src_pool, vol_name))
libvirt.check_exit_status(ret)
if pool_name not in ret.stdout.strip():
test.fail("Volume pool isn't correct")
# vol-name
ret = virsh.vol_name("%s/%s" % (disk_src_pool, vol_name))
libvirt.check_exit_status(ret)
if vol_name not in ret.stdout.strip():
test.fail("Volume name isn't correct")
# vol-resize
ret = virsh.vol_resize(vol_name, "2G", pool_name)
libvirt.check_exit_status(ret)
# Not supported operation
# vol-clone
ret = virsh.vol_clone(vol_name, cloned_vol_name, pool_name)
libvirt.check_result(ret, skip_if=unsupported_err)
# vol-create-from
volxml = vol_xml.VolXML()
vol_params.update({"name": "%s" % create_from_cloned_volume})
v_xml = volxml.new_vol(**vol_params)
v_xml.xmltreefile.write()
ret = virsh.vol_create_from(pool_name, v_xml.xml, vol_name, pool_name)
libvirt.check_result(ret, skip_if=unsupported_err)
# vol-wipe
ret = virsh.vol_wipe(vol_name, pool_name)
libvirt.check_result(ret, skip_if=unsupported_err)
# vol-upload
ret = virsh.vol_upload(vol_name,
vm.get_first_disk_devices()['source'],
"--pool %s" % pool_name)
libvirt.check_result(ret, skip_if=unsupported_err)
# vol-download
ret = virsh.vol_download(vol_name, cloned_vol_name,
"--pool %s" % pool_name)
libvirt.check_result(ret, skip_if=unsupported_err)
def check_qemu_cmd():
"""
Check qemu command line options.
"""
cmd = ("ps -ef | grep %s | grep -v grep " % vm_name)
process.run(cmd, shell=True)
if disk_src_name:
cmd += " | grep file=rbd:%s:" % disk_src_name
if auth_user and auth_key:
cmd += ('id=%s:auth_supported=cephx' % auth_user)
if disk_src_config:
cmd += " | grep 'conf=%s'" % disk_src_config
elif mon_host:
hosts = '\:6789\;'.join(mon_host.split())
cmd += " | grep 'mon_host=%s'" % hosts
if driver_iothread:
cmd += " | grep iothread%s" % driver_iothread
# Run the command
process.run(cmd, shell=True)
def check_save_restore():
"""
Test save and restore operation
"""
save_file = os.path.join(data_dir.get_tmp_dir(), "%s.save" % vm_name)
ret = virsh.save(vm_name, save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
ret = virsh.restore(save_file, **virsh_dargs)
libvirt.check_exit_status(ret)
if os.path.exists(save_file):
os.remove(save_file)
# Login to check vm status
vm.wait_for_login().close()
def check_snapshot(snap_option, target_dev='vda'):
"""
Test snapshot operation.
"""
snap_name = "s1"
snap_mem = os.path.join(data_dir.get_tmp_dir(), "rbd.mem")
snap_disk = os.path.join(data_dir.get_tmp_dir(), "rbd.disk")
xml_snap_exp = [
"disk name='%s' snapshot='external' type='file'" % target_dev
]
xml_dom_exp = [
"source file='%s'" % snap_disk,
"backingStore type='network' index='1'",
"source protocol='rbd' name='%s'" % disk_src_name
]
if snap_option.count("disk-only"):
options = ("%s --diskspec %s,file=%s --disk-only" %
(snap_name, target_dev, snap_disk))
elif snap_option.count("disk-mem"):
options = ("%s --memspec file=%s --diskspec %s,file="
"%s" % (snap_name, snap_mem, target_dev, snap_disk))
xml_snap_exp.append("memory snapshot='external' file='%s'" %
snap_mem)
else:
options = snap_name
ret = virsh.snapshot_create_as(vm_name, options)
if test_disk_internal_snapshot:
libvirt.check_result(ret, expected_fails=unsupported_err)
elif test_disk_readonly:
if libvirt_version.version_compare(6, 0, 0):
libvirt.check_result(ret)
else:
libvirt.check_result(ret, expected_fails=unsupported_err)
else:
libvirt.check_result(ret, skip_if=unsupported_err)
# check xml file.
if not ret.exit_status:
snap_xml = virsh.snapshot_dumpxml(vm_name, snap_name,
debug=True).stdout.strip()
dom_xml = virsh.dumpxml(vm_name, debug=True).stdout.strip()
# Delete snapshots.
libvirt.clean_up_snapshots(vm_name)
if os.path.exists(snap_mem):
os.remove(snap_mem)
if os.path.exists(snap_disk):
os.remove(snap_disk)
if not all([x in snap_xml for x in xml_snap_exp]):
test.fail("Failed to check snapshot xml")
if not all([x in dom_xml for x in xml_dom_exp]):
test.fail("Failed to check domain xml")
def check_blockcopy(target):
"""
Block copy operation test.
"""
blk_file = os.path.join(data_dir.get_tmp_dir(), "blk.rbd")
if os.path.exists(blk_file):
os.remove(blk_file)
blk_mirror = ("mirror type='file' file='%s' "
"format='raw' job='copy'" % blk_file)
# Do blockcopy
ret = virsh.blockcopy(vm_name, target, blk_file)
libvirt.check_result(ret, skip_if=unsupported_err)
dom_xml = virsh.dumpxml(vm_name, debug=True).stdout.strip()
if not dom_xml.count(blk_mirror):
test.fail("Can't see block job in domain xml")
# Abort
ret = virsh.blockjob(vm_name, target, "--abort")
libvirt.check_exit_status(ret)
dom_xml = virsh.dumpxml(vm_name, debug=True).stdout.strip()
if dom_xml.count(blk_mirror):
test.fail("Failed to abort block job")
if os.path.exists(blk_file):
os.remove(blk_file)
# Sleep for a while after abort operation.
time.sleep(5)
# Do blockcopy again
ret = virsh.blockcopy(vm_name, target, blk_file)
libvirt.check_exit_status(ret)
# Wait for complete
def wait_func():
ret = virsh.blockjob(vm_name, target, "--info")
return ret.stderr.count("Block Copy: [100 %]")
timeout = params.get("blockjob_timeout", 600)
utils_misc.wait_for(wait_func, int(timeout))
# Pivot
ret = virsh.blockjob(vm_name, target, "--pivot")
libvirt.check_exit_status(ret)
dom_xml = virsh.dumpxml(vm_name, debug=True).stdout.strip()
if not dom_xml.count("source file='%s'" % blk_file):
test.fail("Failed to pivot block job")
# Remove the disk file.
if os.path.exists(blk_file):
os.remove(blk_file)
def check_in_vm(vm_obj, target, old_parts, read_only=False):
"""
Check mount/read/write disk in VM.
:param vm. VM guest.
:param target. Disk dev in VM.
:return: True if check successfully.
"""
try:
session = vm_obj.wait_for_login()
new_parts = utils_disk.get_parts_list(session)
added_parts = list(set(new_parts).difference(set(old_parts)))
logging.info("Added parts:%s", added_parts)
if len(added_parts) != 1:
logging.error("The number of new partitions is invalid in VM")
return False
added_part = None
if target.startswith("vd"):
if added_parts[0].startswith("vd"):
added_part = added_parts[0]
elif target.startswith("hd"):
if added_parts[0].startswith("sd"):
added_part = added_parts[0]
if not added_part:
logging.error("Can't see added partition in VM")
return False
cmd = ("mount /dev/{0} /mnt && ls /mnt && (sleep 15;"
" touch /mnt/testfile; umount /mnt)".format(added_part))
s, o = session.cmd_status_output(cmd, timeout=60)
session.close()
logging.info("Check disk operation in VM:\n, %s, %s", s, o)
# Readonly fs, check the error messages.
# The command may return True, read-only
# messges can be found from the command output
if read_only:
if "Read-only file system" not in o:
return False
else:
return True
# Other errors
if s != 0:
return False
return True
except (remote.LoginError, virt_vm.VMError, aexpect.ShellError) as e:
logging.error(str(e))
return False
def clean_up_volume_snapshots():
"""
Get all snapshots for rbd_vol.img volume,unprotect and then clean up them.
"""
cmd = ("rbd -m {0} {1} info {2}"
"".format(mon_host, key_opt,
os.path.join(disk_src_pool, vol_name)))
if process.run(cmd, ignore_status=True, shell=True).exit_status:
return
# Get snapshot list.
cmd = ("rbd -m {0} {1} snap"
" list {2}"
"".format(mon_host, key_opt,
os.path.join(disk_src_pool, vol_name)))
snaps_out = process.run(cmd, ignore_status=True,
shell=True).stdout_text
snap_names = []
if snaps_out:
for line in snaps_out.rsplit("\n"):
if line.startswith("SNAPID") or line == "":
continue
snap_line = line.rsplit()
if len(snap_line) == 4:
snap_names.append(snap_line[1])
logging.debug("Find snapshots: %s", snap_names)
# Unprotect snapshot first,otherwise it will fail to purge volume
for snap_name in snap_names:
cmd = ("rbd -m {0} {1} snap"
" unprotect {2}@{3}"
"".format(mon_host, key_opt,
os.path.join(disk_src_pool, vol_name),
snap_name))
process.run(cmd, ignore_status=True, shell=True)
# Purge volume,and then delete volume.
cmd = ("rbd -m {0} {1} info {2} && rbd -m {0} {1} snap"
" purge {2} && rbd -m {0} {1} rm {2}"
"".format(mon_host, key_opt,
os.path.join(disk_src_pool, vol_name)))
process.run(cmd, ignore_status=True, shell=True)
def make_snapshot():
"""
make external snapshots.
:return external snapshot path list
"""
logging.info("Making snapshot...")
first_disk_source = vm.get_first_disk_devices()['source']
snapshot_path_list = []
snapshot2_file = os.path.join(data_dir.get_tmp_dir(), "mem.s2")
snapshot3_file = os.path.join(data_dir.get_tmp_dir(), "mem.s3")
snapshot4_file = os.path.join(data_dir.get_tmp_dir(), "mem.s4")
snapshot4_disk_file = os.path.join(data_dir.get_tmp_dir(), "disk.s4")
snapshot5_file = os.path.join(data_dir.get_tmp_dir(), "mem.s5")
snapshot5_disk_file = os.path.join(data_dir.get_tmp_dir(), "disk.s5")
# Attempt to take different types of snapshots.
snapshots_param_dict = {
"s1":
"s1 --disk-only --no-metadata",
"s2":
"s2 --memspec %s --no-metadata" % snapshot2_file,
"s3":
"s3 --memspec %s --no-metadata --live" % snapshot3_file,
"s4":
"s4 --memspec %s --diskspec vda,file=%s --no-metadata" %
(snapshot4_file, snapshot4_disk_file),
"s5":
"s5 --memspec %s --diskspec vda,file=%s --live --no-metadata" %
(snapshot5_file, snapshot5_disk_file)
}
for snapshot_name in sorted(snapshots_param_dict.keys()):
ret = virsh.snapshot_create_as(vm_name,
snapshots_param_dict[snapshot_name],
**virsh_dargs)
libvirt.check_exit_status(ret)
if snapshot_name != 's4' and snapshot_name != 's5':
snapshot_path_list.append(
first_disk_source.replace('qcow2', snapshot_name))
return snapshot_path_list
def get_secret_list():
"""
Get secret list.
:return secret list
"""
logging.info("Get secret list ...")
secret_list_result = virsh.secret_list()
secret_list = secret_list_result.stdout_text.strip().splitlines()
# First two lines contain table header followed by entries
# for each secret, such as:
#
# UUID Usage
# --------------------------------------------------------------------------------
# b4e8f6d3-100c-4e71-9f91-069f89742273 ceph client.libvirt secret
secret_list = secret_list[2:]
result = []
# If secret list is empty.
if secret_list:
for line in secret_list:
# Split on whitespace, assume 1 column
linesplit = line.split(None, 1)
result.append(linesplit[0])
return result
mon_host = params.get("mon_host")
disk_src_name = params.get("disk_source_name")
disk_src_config = params.get("disk_source_config")
disk_src_host = params.get("disk_source_host")
disk_src_port = params.get("disk_source_port")
disk_src_pool = params.get("disk_source_pool")
disk_format = params.get("disk_format", "raw")
driver_iothread = params.get("driver_iothread")
snap_name = params.get("disk_snap_name")
attach_device = "yes" == params.get("attach_device", "no")
attach_disk = "yes" == params.get("attach_disk", "no")
test_save_restore = "yes" == params.get("test_save_restore", "no")
test_snapshot = "yes" == params.get("test_snapshot", "no")
test_blockcopy = "yes" == params.get("test_blockcopy", "no")
test_qemu_cmd = "yes" == params.get("test_qemu_cmd", "no")
test_vm_parts = "yes" == params.get("test_vm_parts", "no")
additional_guest = "yes" == params.get("additional_guest", "no")
create_snapshot = "yes" == params.get("create_snapshot", "no")
convert_image = "yes" == params.get("convert_image", "no")
create_volume = "yes" == params.get("create_volume", "no")
rbd_blockcopy = "yes" == params.get("rbd_blockcopy", "no")
enable_slice = "yes" == params.get("enable_slice", "no")
create_by_xml = "yes" == params.get("create_by_xml", "no")
client_key = params.get("client_key")
client_name = params.get("client_name")
auth_key = params.get("auth_key")
auth_user = params.get("auth_user")
auth_type = params.get("auth_type")
auth_usage = params.get("secret_usage")
pool_name = params.get("pool_name")
pool_type = params.get("pool_type")
vol_name = params.get("vol_name")
cloned_vol_name = params.get("cloned_volume", "cloned_test_volume")
create_from_cloned_volume = params.get("create_from_cloned_volume",
"create_from_cloned_test_volume")
vol_cap = params.get("vol_cap")
vol_cap_unit = params.get("vol_cap_unit")
start_vm = "yes" == params.get("start_vm", "no")
test_disk_readonly = "yes" == params.get("test_disk_readonly", "no")
test_disk_internal_snapshot = "yes" == params.get(
"test_disk_internal_snapshot", "no")
test_json_pseudo_protocol = "yes" == params.get("json_pseudo_protocol",
"no")
disk_snapshot_with_sanlock = "yes" == params.get(
"disk_internal_with_sanlock", "no")
auth_place_in_source = params.get("auth_place_in_source")
# Prepare a blank params to confirm if delete the configure at the end of the test
ceph_cfg = ""
# Create config file if it doesn't exist
ceph_cfg = ceph.create_config_file(mon_host)
# After libvirt 3.9.0, auth element can be put into source part.
if auth_place_in_source and not libvirt_version.version_compare(3, 9, 0):
test.cancel(
"place auth in source is not supported in current libvirt version")
# After libvirt 6.0.0, blockcopy rbd backend feature is support.
if rbd_blockcopy and not libvirt_version.version_compare(6, 0, 0):
test.cancel(
"blockcopy rbd backend is not supported in current libvirt version"
)
# Start vm and get all partions in vm.
if vm.is_dead():
vm.start()
session = vm.wait_for_login()
old_parts = utils_disk.get_parts_list(session)
session.close()
vm.destroy(gracefully=False)
if additional_guest:
guest_name = "%s_%s" % (vm_name, '1')
timeout = params.get("clone_timeout", 360)
utils_libguestfs.virt_clone_cmd(vm_name,
guest_name,
True,
timeout=timeout,
ignore_status=False)
additional_vm = vm.clone(guest_name)
if start_vm:
virsh.start(guest_name)
# Back up xml file.
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
key_opt = ""
secret_uuid = None
snapshot_path = None
key_file = os.path.join(data_dir.get_tmp_dir(), "ceph.key")
img_file = os.path.join(data_dir.get_tmp_dir(), "%s_test.img" % vm_name)
front_end_img_file = os.path.join(data_dir.get_tmp_dir(),
"%s_frontend_test.img" % vm_name)
# Construct a unsupported error message list to skip these kind of tests
unsupported_err = []
if driver_iothread:
unsupported_err.append('IOThreads not supported')
if test_snapshot:
unsupported_err.append('live disk snapshot not supported')
if test_disk_readonly:
if not libvirt_version.version_compare(5, 0, 0):
unsupported_err.append('Could not create file: Permission denied')
unsupported_err.append('Permission denied')
else:
unsupported_err.append(
'unsupported configuration: external snapshot ' +
'for readonly disk vdb is not supported')
if test_disk_internal_snapshot:
unsupported_err.append(
'unsupported configuration: internal snapshot for disk ' +
'vdb unsupported for storage type raw')
if test_blockcopy:
unsupported_err.append('block copy is not supported')
if attach_disk:
unsupported_err.append('No such file or directory')
if create_volume:
unsupported_err.append("backing 'volume' disks isn't yet supported")
unsupported_err.append('this function is not supported')
try:
# Clean up dirty secrets in test environments if there have.
dirty_secret_list = get_secret_list()
if dirty_secret_list:
for dirty_secret_uuid in dirty_secret_list:
virsh.secret_undefine(dirty_secret_uuid)
# Prepare test environment.
qemu_config = LibvirtQemuConfig()
if disk_snapshot_with_sanlock:
# Install necessary package:sanlock,libvirt-lock-sanlock
if not utils_package.package_install(["sanlock"]):
test.error("fail to install sanlock")
if not utils_package.package_install(["libvirt-lock-sanlock"]):
test.error("fail to install libvirt-lock-sanlock")
# Set virt_use_sanlock
result = process.run("setsebool -P virt_use_sanlock 1", shell=True)
if result.exit_status:
test.error("Failed to set virt_use_sanlock value")
# Update lock_manager in qemu.conf
qemu_config.lock_manager = 'sanlock'
# Update qemu-sanlock.conf.
san_lock_config = LibvirtSanLockConfig()
san_lock_config.user = '******'
san_lock_config.group = 'sanlock'
san_lock_config.host_id = 1
san_lock_config.auto_disk_leases = True
process.run("mkdir -p /var/lib/libvirt/sanlock", shell=True)
san_lock_config.disk_lease_dir = "/var/lib/libvirt/sanlock"
san_lock_config.require_lease_for_disks = False
# Start sanlock service and restart libvirtd to enforce changes.
result = process.run("systemctl start wdmd", shell=True)
if result.exit_status:
test.error("Failed to start wdmd service")
result = process.run("systemctl start sanlock", shell=True)
if result.exit_status:
test.error("Failed to start sanlock service")
utils_libvirtd.Libvirtd().restart()
# Prepare lockspace and lease file for sanlock in order.
sanlock_cmd_dict = OrderedDict()
sanlock_cmd_dict[
"truncate -s 1M /var/lib/libvirt/sanlock/TEST_LS"] = "Failed to truncate TEST_LS"
sanlock_cmd_dict[
"sanlock direct init -s TEST_LS:0:/var/lib/libvirt/sanlock/TEST_LS:0"] = "Failed to sanlock direct init TEST_LS:0"
sanlock_cmd_dict[
"chown sanlock:sanlock /var/lib/libvirt/sanlock/TEST_LS"] = "Failed to chown sanlock TEST_LS"
sanlock_cmd_dict[
"restorecon -R -v /var/lib/libvirt/sanlock"] = "Failed to restorecon sanlock"
sanlock_cmd_dict[
"truncate -s 1M /var/lib/libvirt/sanlock/test-disk-resource-lock"] = "Failed to truncate test-disk-resource-lock"
sanlock_cmd_dict[
"sanlock direct init -r TEST_LS:test-disk-resource-lock:" +
"/var/lib/libvirt/sanlock/test-disk-resource-lock:0"] = "Failed to sanlock direct init test-disk-resource-lock"
sanlock_cmd_dict[
"chown sanlock:sanlock " +
"/var/lib/libvirt/sanlock/test-disk-resource-lock"] = "Failed to chown test-disk-resource-loc"
sanlock_cmd_dict[
"sanlock client add_lockspace -s TEST_LS:1:" +
"/var/lib/libvirt/sanlock/TEST_LS:0"] = "Failed to client add_lockspace -s TEST_LS:0"
for sanlock_cmd in sanlock_cmd_dict.keys():
result = process.run(sanlock_cmd, shell=True)
if result.exit_status:
test.error(sanlock_cmd_dict[sanlock_cmd])
# Create one lease device and add it to VM.
san_lock_vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
lease_device = Lease()
lease_device.lockspace = 'TEST_LS'
lease_device.key = 'test-disk-resource-lock'
lease_device.target = {
'path': '/var/lib/libvirt/sanlock/test-disk-resource-lock'
}
san_lock_vmxml.add_device(lease_device)
san_lock_vmxml.sync()
# Install ceph-common package which include rbd command
if utils_package.package_install(["ceph-common"]):
if client_name and client_key:
with open(key_file, 'w') as f:
f.write("[%s]\n\tkey = %s\n" % (client_name, client_key))
key_opt = "--keyring %s" % key_file
# Create secret xml
sec_xml = secret_xml.SecretXML("no", "no")
sec_xml.usage = auth_type
sec_xml.usage_name = auth_usage
sec_xml.xmltreefile.write()
logging.debug("Secret xml: %s", sec_xml)
ret = virsh.secret_define(sec_xml.xml)
libvirt.check_exit_status(ret)
secret_uuid = re.findall(r".+\S+(\ +\S+)\ +.+\S+",
ret.stdout.strip())[0].lstrip()
logging.debug("Secret uuid %s", secret_uuid)
if secret_uuid is None:
test.error("Failed to get secret uuid")
# Set secret value
auth_key = params.get("auth_key")
ret = virsh.secret_set_value(secret_uuid, auth_key,
**virsh_dargs)
libvirt.check_exit_status(ret)
# Delete the disk if it exists
cmd = ("rbd -m {0} {1} info {2} && rbd -m {0} {1} rm "
"{2}".format(mon_host, key_opt, disk_src_name))
process.run(cmd, ignore_status=True, shell=True)
else:
test.error("Failed to install ceph-common")
if disk_src_config:
config_ceph()
disk_path = ("rbd:%s:mon_host=%s" % (disk_src_name, mon_host))
if auth_user and auth_key:
disk_path += (":id=%s:key=%s" % (auth_user, auth_key))
targetdev = params.get("disk_target", "vdb")
# To be compatible with create_disk_xml function,
# some parameters need to be updated.
params.update({
"type_name": params.get("disk_type", "network"),
"target_bus": params.get("disk_target_bus"),
"target_dev": targetdev,
"secret_uuid": secret_uuid,
"source_protocol": params.get("disk_source_protocol"),
"source_name": disk_src_name,
"source_host_name": disk_src_host,
"source_host_port": disk_src_port
})
# Prepare disk image
if convert_image:
first_disk = vm.get_first_disk_devices()
blk_source = first_disk['source']
# Convert the image to remote storage
disk_cmd = ("rbd -m %s %s info %s 2> /dev/null|| qemu-img convert"
" -O %s %s %s" % (mon_host, key_opt, disk_src_name,
disk_format, blk_source, disk_path))
process.run(disk_cmd, ignore_status=False, shell=True)
elif create_volume:
vol_params = {
"name": vol_name,
"capacity": int(vol_cap),
"capacity_unit": vol_cap_unit,
"format": disk_format
}
create_pool()
create_vol(vol_params)
check_vol(vol_params)
elif rbd_blockcopy:
# Create one disk to attach to VM as second disk device
second_disk_params = {}
disk_size = params.get("virt_disk_device_size", "50M")
device_source = libvirt.create_local_disk("file",
img_file,
disk_size,
disk_format="qcow2")
second_disk_params.update({"source_file": device_source})
second_disk_params.update({"driver_type": "qcow2"})
second_xml_file = libvirt.create_disk_xml(second_disk_params)
opts = params.get("attach_option", "--config")
ret = virsh.attach_device(vm_name,
second_xml_file,
flagstr=opts,
debug=True)
libvirt.check_result(ret)
else:
# Create an local image and make FS on it.
disk_cmd = ("qemu-img create -f %s %s 10M && mkfs.ext4 -F %s" %
(disk_format, img_file, img_file))
process.run(disk_cmd, ignore_status=False, shell=True)
# Convert the image to remote storage
disk_cmd = (
"rbd -m %s %s info %s 2> /dev/null|| qemu-img convert -O"
" %s %s %s" % (mon_host, key_opt, disk_src_name, disk_format,
img_file, disk_path))
process.run(disk_cmd, ignore_status=False, shell=True)
# Create disk snapshot if needed.
if create_snapshot:
snap_cmd = ("rbd -m %s %s snap create %s@%s" %
(mon_host, key_opt, disk_src_name, snap_name))
process.run(snap_cmd, ignore_status=False, shell=True)
if test_json_pseudo_protocol:
# After block-dev introduced, qemu-img: warning: RBD options encoded in the filename as keyvalue pairs is deprecated
if libvirt_version.version_compare(6, 0, 0):
test.cancel(
"qemu-img: warning: RBD options encoded in the filename as keyvalue pairs in json format is deprecated"
)
# Create one frontend image with the rbd backing file.
json_str = ('json:{"file.driver":"rbd",'
'"file.filename":"rbd:%s:mon_host=%s"}' %
(disk_src_name, mon_host))
# pass different json string according to the auth config
if auth_user and auth_key:
json_str = ('%s:id=%s:key=%s"}' %
(json_str[:-2], auth_user, auth_key))
disk_cmd = ("qemu-img create -f qcow2 -b '%s' %s" %
(json_str, front_end_img_file))
disk_path = front_end_img_file
process.run(disk_cmd, ignore_status=False, shell=True)
# If hot plug, start VM first, and then wait the OS boot.
# Otherwise stop VM if running.
if start_vm:
if vm.is_dead():
vm.start()
vm.wait_for_login().close()
else:
if not vm.is_dead():
vm.destroy()
if attach_device:
if create_volume:
params.update({"source_pool": pool_name})
params.update({"type_name": "volume"})
# No need auth options for volume
if "auth_user" in params:
params.pop("auth_user")
if "auth_type" in params:
params.pop("auth_type")
if "secret_type" in params:
params.pop("secret_type")
if "secret_uuid" in params:
params.pop("secret_uuid")
if "secret_usage" in params:
params.pop("secret_usage")
# After 3.9.0,the auth element can be place in source part.
if auth_place_in_source:
params.update({"auth_in_source": auth_place_in_source})
xml_file = libvirt.create_disk_xml(params)
if additional_guest:
# Copy xml_file for additional guest VM.
shutil.copyfile(xml_file, additional_xml_file)
opts = params.get("attach_option", "")
ret = virsh.attach_device(vm_name,
xml_file,
flagstr=opts,
debug=True)
libvirt.check_result(ret, skip_if=unsupported_err)
if additional_guest:
# Make sure the additional VM is running
if additional_vm.is_dead():
additional_vm.start()
additional_vm.wait_for_login().close()
ret = virsh.attach_device(guest_name,
additional_xml_file,
"",
debug=True)
libvirt.check_result(ret, skip_if=unsupported_err)
elif attach_disk:
opts = params.get("attach_option", "")
ret = virsh.attach_disk(vm_name, disk_path, targetdev, opts)
libvirt.check_result(ret, skip_if=unsupported_err)
elif test_disk_readonly:
params.update({'readonly': "yes"})
xml_file = libvirt.create_disk_xml(params)
opts = params.get("attach_option", "")
ret = virsh.attach_device(vm_name,
xml_file,
flagstr=opts,
debug=True)
libvirt.check_result(ret, skip_if=unsupported_err)
elif test_disk_internal_snapshot:
xml_file = libvirt.create_disk_xml(params)
opts = params.get("attach_option", "")
ret = virsh.attach_device(vm_name,
xml_file,
flagstr=opts,
debug=True)
libvirt.check_result(ret, skip_if=unsupported_err)
elif disk_snapshot_with_sanlock:
if vm.is_dead():
vm.start()
snapshot_path = make_snapshot()
if vm.is_alive():
vm.destroy()
elif rbd_blockcopy:
if enable_slice:
disk_cmd = ("rbd -m %s %s create %s --size 400M 2> /dev/null" %
(mon_host, key_opt, disk_src_name))
process.run(disk_cmd, ignore_status=False, shell=True)
slice_dict = {
"slice_type": "storage",
"slice_offset": "12345",
"slice_size": "105185280"
}
params.update({"disk_slice": slice_dict})
logging.debug(
'create one volume on ceph backend storage for slice testing'
)
# Create one file on VM before doing blockcopy
try:
session = vm.wait_for_login()
cmd = (
"mkfs.ext4 -F /dev/{0} && mount /dev/{0} /mnt && ls /mnt && (sleep 3;"
" touch /mnt/rbd_blockcopyfile; umount /mnt)".format(
targetdev))
s, o = session.cmd_status_output(cmd, timeout=60)
session.close()
logging.info(
"touch one file in new added disk in VM:\n, %s, %s", s, o)
except (remote.LoginError, virt_vm.VMError,
aexpect.ShellError) as e:
logging.error(str(e))
# Create rbd backend xml
rbd_blockcopy_xml_file = libvirt.create_disk_xml(params)
logging.debug("The rbd blockcopy xml is: %s" %
rbd_blockcopy_xml_file)
dest_path = " --xml %s" % rbd_blockcopy_xml_file
options1 = params.get("rbd_pivot_option",
" --wait --verbose --transient-job --pivot")
extra_dict = {'debug': True}
cmd_result = virsh.blockcopy(vm_name, targetdev, dest_path,
options1, **extra_dict)
libvirt.check_exit_status(cmd_result)
elif not create_volume:
libvirt.set_vm_disk(vm, params)
if test_blockcopy:
logging.info("Creating %s...", vm_name)
vmxml_for_test = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
if vm.is_alive():
vm.destroy(gracefully=False)
vm.undefine()
if virsh.create(vmxml_for_test.xml, **virsh_dargs).exit_status:
vmxml_backup.define()
test.fail("Can't create the domain")
elif vm.is_dead():
vm.start()
# Wait for vm is running
vm.wait_for_login(timeout=600).close()
if additional_guest:
if additional_vm.is_dead():
additional_vm.start()
# After block-dev introduced in libvirt 6.0.0 afterwards, file=rbd:* format information is not provided from qemu output
if libvirt_version.version_compare(6, 0, 0):
test_qemu_cmd = False
# Check qemu command line
if test_qemu_cmd:
check_qemu_cmd()
# Check partitions in vm
if test_vm_parts:
if not check_in_vm(
vm, targetdev, old_parts, read_only=create_snapshot):
test.fail("Failed to check vm partitions")
if additional_guest:
if not check_in_vm(additional_vm, targetdev, old_parts):
test.fail("Failed to check vm partitions")
# Save and restore operation
if test_save_restore:
check_save_restore()
if test_snapshot:
snap_option = params.get("snapshot_option", "")
check_snapshot(snap_option)
if test_blockcopy:
check_blockcopy(targetdev)
if test_disk_readonly and not libvirt_version.version_compare(6, 0, 0):
snap_option = params.get("snapshot_option", "")
check_snapshot(snap_option, 'vdb')
if test_disk_internal_snapshot:
snap_option = params.get("snapshot_option", "")
check_snapshot(snap_option, targetdev)
# Check rbd blockcopy inside VM
if rbd_blockcopy:
try:
session = vm.wait_for_login()
cmd = (
"mount /dev/{0} /mnt && ls /mnt/rbd_blockcopyfile && (sleep 3;"
" umount /mnt)".format(targetdev))
s, o = session.cmd_status_output(cmd, timeout=60)
session.close()
logging.info(
"list one file in new rbd backend disk in VM:\n, %s, %s",
s, o)
except (remote.LoginError, virt_vm.VMError,
aexpect.ShellError) as e:
logging.error(str(e))
debug_vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
def _check_slice_in_xml():
"""
Check slice attribute in disk xml.
"""
debug_vmxml = virsh.dumpxml(vm_name, "",
debug=True).stdout.strip()
if 'slices' in debug_vmxml:
return True
else:
return False
if enable_slice:
if not _check_slice_in_xml():
test.fail("Failed to find slice attribute in VM xml")
# Detach the device.
if attach_device:
xml_file = libvirt.create_disk_xml(params)
ret = virsh.detach_device(vm_name, xml_file)
libvirt.check_exit_status(ret)
if additional_guest:
ret = virsh.detach_device(guest_name, xml_file)
libvirt.check_exit_status(ret)
elif attach_disk:
ret = virsh.detach_disk(vm_name, targetdev)
libvirt.check_exit_status(ret)
# Check disk in vm after detachment.
if attach_device or attach_disk:
session = vm.wait_for_login()
new_parts = utils_disk.get_parts_list(session)
if len(new_parts) != len(old_parts):
test.fail("Disk still exists in vm" " after detachment")
session.close()
except virt_vm.VMStartError as details:
for msg in unsupported_err:
if msg in str(details):
test.cancel(str(details))
else:
test.fail("VM failed to start." "Error: %s" % str(details))
finally:
# Remove ceph configure file if created.
if ceph_cfg:
os.remove(ceph_cfg)
# Delete snapshots.
snapshot_lists = virsh.snapshot_list(vm_name)
if len(snapshot_lists) > 0:
libvirt.clean_up_snapshots(vm_name, snapshot_lists)
for snap in snapshot_lists:
virsh.snapshot_delete(vm_name, snap, "--metadata")
# Recover VM.
if vm.is_alive():
vm.destroy(gracefully=False)
if additional_guest:
virsh.remove_domain(guest_name,
"--remove-all-storage",
ignore_stauts=True)
# Remove the snapshot.
if create_snapshot:
cmd = ("rbd -m {0} {1} info {2} && rbd -m {0} {1} snap"
" purge {2} && rbd -m {0} {1} rm {2}"
"".format(mon_host, key_opt, disk_src_name))
process.run(cmd, ignore_status=True, shell=True)
elif create_volume:
cmd = ("rbd -m {0} {1} info {2} && rbd -m {0} {1} rm {2}"
"".format(mon_host, key_opt,
os.path.join(disk_src_pool, cloned_vol_name)))
process.run(cmd, ignore_status=True, shell=True)
cmd = ("rbd -m {0} {1} info {2} && rbd -m {0} {1} rm {2}"
"".format(
mon_host, key_opt,
os.path.join(disk_src_pool, create_from_cloned_volume)))
process.run(cmd, ignore_status=True, shell=True)
clean_up_volume_snapshots()
else:
cmd = ("rbd -m {0} {1} info {2} && rbd -m {0} {1} rm {2}"
"".format(mon_host, key_opt, disk_src_name))
process.run(cmd, ignore_status=True, shell=True)
# Delete tmp files.
if os.path.exists(key_file):
os.remove(key_file)
if os.path.exists(img_file):
os.remove(img_file)
# Clean up volume, pool
if vol_name and vol_name in str(virsh.vol_list(pool_name).stdout):
virsh.vol_delete(vol_name, pool_name)
if pool_name and pool_name in virsh.pool_state_dict():
virsh.pool_destroy(pool_name, **virsh_dargs)
virsh.pool_undefine(pool_name, **virsh_dargs)
# Clean up secret
secret_list = get_secret_list()
if secret_list:
for secret_uuid in secret_list:
virsh.secret_undefine(secret_uuid)
logging.info("Restoring vm...")
vmxml_backup.sync()
if disk_snapshot_with_sanlock:
# Restore virt_use_sanlock setting.
process.run("setsebool -P virt_use_sanlock 0", shell=True)
# Restore qemu config
qemu_config.restore()
utils_libvirtd.Libvirtd().restart()
# Force shutdown sanlock service.
process.run("sanlock client shutdown -f 1", shell=True)
# Clean up lockspace folder
process.run("rm -rf /var/lib/libvirt/sanlock/*", shell=True)
if snapshot_path is not None:
for snapshot in snapshot_path:
if os.path.exists(snapshot):
os.remove(snapshot)
def run(test, params, env):
"""
Test command: virsh secret-define <file>
secret-undefine <secret>
The testcase is to define or modify a secret
from an XML file, then undefine it
"""
# MAIN TEST CODE ###
# Process cartesian parameters
secret_ref = params.get("secret_ref")
ephemeral = params.get("ephemeral_value", "no")
private = params.get("private_value", "no")
modify_volume = ("yes" == params.get("secret_modify_volume", "no"))
remove_uuid = ("yes" == params.get("secret_remove_uuid", "no"))
if secret_ref == "secret_valid_uuid":
# Generate valid uuid
cmd = "uuidgen"
status, uuid = commands.getstatusoutput(cmd)
if status:
raise error.TestNAError("Failed to generate valid uuid")
elif secret_ref == "secret_invalid_uuid":
uuid = params.get(secret_ref)
# libvirt acl related params
uri = params.get("virsh_uri")
unprivileged_user = params.get('unprivileged_user')
define_acl = "yes" == params.get("define_acl", "no")
undefine_acl = "yes" == params.get("undefine_acl", "no")
get_value_acl = "yes" == params.get("get_value_acl", "no")
define_error = "yes" == params.get("define_error", "no")
undefine_error = "yes" == params.get("undefine_error", "no")
get_value_error = "yes" == params.get("get_value_error", "no")
if unprivileged_user:
if unprivileged_user.count('EXAMPLE'):
unprivileged_user = '******'
if not libvirt_version.version_compare(1, 1, 1):
if params.get('setup_libvirt_polkit') == 'yes':
raise error.TestNAError("API acl test not supported in current"
" libvirt version.")
acl_dargs = {
'uri': uri,
'unprivileged_user': unprivileged_user,
'debug': True
}
# Get a full path of tmpfile, the tmpfile need not exist
tmp_dir = data_dir.get_tmp_dir()
volume_path = os.path.join(tmp_dir, "secret_volume")
secret_xml_obj = SecretXML(ephemeral, private)
secret_xml_obj.uuid = uuid
secret_xml_obj.volume = volume_path
secret_xml_obj.usage = "volume"
secret_obj_xmlfile = os.path.join(SECRET_DIR, uuid + ".xml")
def check_exit_status(result, expect_error=False):
"""
Check the exit status of virsh commands.
:param result: Virsh command result object
:param expect_error: Boolean value, expect command success or fail
"""
if expect_error:
if result.exit_status == 0:
raise error.TestFail("Expect fail, but run successfully.")
else:
logging.debug("Command failed as expected.")
else:
if result.exit_status != 0:
raise error.TestFail(result.stderr)
# Run the test
try:
if define_acl:
utils.run("chmod 666 %s" % secret_xml_obj.xml)
cmd_result = virsh.secret_define(secret_xml_obj.xml, **acl_dargs)
else:
cmd_result = virsh.secret_define(secret_xml_obj.xml, debug=True)
check_exit_status(cmd_result, define_error)
if cmd_result.exit_status:
return
# Check ephemeral attribute
exist = os.path.exists(secret_obj_xmlfile)
if (ephemeral == "yes" and exist) or \
(ephemeral == "no" and not exist):
raise error.TestFail("The ephemeral attribute worked not expected")
# Check private attrbute
virsh.secret_set_value(uuid, SECRET_BASE64, debug=True)
if get_value_acl:
cmd_result = virsh.secret_get_value(uuid, **acl_dargs)
else:
cmd_result = virsh.secret_get_value(uuid, debug=True)
check_exit_status(cmd_result, get_value_error)
status = cmd_result.exit_status
err_msg = "The private attribute worked not expected"
if private == "yes" and not status:
raise error.TestFail(err_msg)
if private == "no" and status:
if not get_value_error:
raise error.TestFail(err_msg)
if modify_volume:
volume_path = os.path.join(tmp_dir, "secret_volume_modify")
secret_xml_obj.volume = volume_path
cmd_result = virsh.secret_define(secret_xml_obj.xml, debug=True)
if cmd_result.exit_status == 0:
raise error.TestFail("Expect fail on redefine after modify "
"volume, but success indeed")
if remove_uuid:
secret_xml_obj2 = SecretXML(ephemeral, private)
secret_xml_obj2.volume = volume_path
secret_xml_obj2.usage = "volume"
cmd_result = virsh.secret_define(secret_xml_obj2.xml, debug=True)
if cmd_result.exit_status == 0:
raise error.TestFail("Expect fail on redefine after remove "
"uuid, but success indeed")
if undefine_acl:
cmd_result = virsh.secret_undefine(uuid, **acl_dargs)
else:
cmd_result = virsh.secret_undefine(uuid, debug=True)
check_exit_status(cmd_result, undefine_error)
finally:
# cleanup
virsh.secret_undefine(uuid, ignore_status=True)
if os.path.exists(volume_path):
os.unlink(volume_path)
if os.path.exists(secret_obj_xmlfile):
os.unlink(secret_obj_xmlfile)
def run(test, params, env):
# Get variables.
status_error = ('yes' == params.get("status_error", 'no'))
img_type = ('yes' == params.get("libvirt_scsi_img_type", "no"))
cdrom_type = ('yes' == params.get("libvirt_scsi_cdrom_type", "no"))
partition_type = ('yes' == params.get("libvirt_scsi_partition_type", "no"))
partition = params.get("libvirt_scsi_partition",
"ENTER.YOUR.AVAILABLE.PARTITION")
vm_name = params.get("main_vm", "virt-tests-vm1")
# Init a VM instance and a VMXML instance.
vm = env.get_vm(vm_name)
vmxml = VMXML.new_from_inactive_dumpxml(vm_name)
# Keep a backup of xml to restore it in cleanup.
backup_xml = vmxml.copy()
# Add a scsi controller if there is not.
controller_devices = vmxml.get_devices("controller")
scsi_controllers = []
for device in controller_devices:
if device.type == "scsi":
scsi_controllers.append(device)
if not scsi_controllers:
scsi_controller = Controller("controller")
scsi_controller.type = "scsi"
scsi_controller.index = "0"
scsi_controller.model = "virtio-scsi"
vmxml.add_device(scsi_controller)
# Add disk with bus of scsi into vmxml.
if partition_type:
if partition.count("ENTER.YOUR"):
raise error.TestNAError("Partition for partition test "
"is not configured.")
partition_disk = Disk(type_name="block")
partition_disk.device = "disk"
partition_disk.target = {'dev': "vdg", 'bus': "scsi"}
partition_disk.source = partition_disk.new_disk_source(
**{'attrs': {
'dev': partition
}})
vmxml.add_device(partition_disk)
if img_type:
# Init a QemuImg instance.
img_name = "libvirt_scsi"
params['image_name'] = img_name
image = qemu_storage.QemuImg(params, data_dir.get_tmp_dir(), img_name)
# Create a image.
img_path, _ = image.create(params)
img_disk = Disk(type_name="file")
img_disk.device = "disk"
img_disk.source = img_disk.new_disk_source(
**{'attrs': {
'file': img_path
}})
img_disk.target = {'dev': "vde", 'bus': "scsi"}
vmxml.add_device(img_disk)
if cdrom_type:
# Init a CdromDisk instance.
cdrom_path = os.path.join(data_dir.get_tmp_dir(), "libvirt_scsi")
try:
cdrom = CdromDisk(cdrom_path, data_dir.get_tmp_dir())
cdrom.close()
except error.CmdError, detail:
raise error.TestNAError("Failed to create cdrom disk: %s" % detail)
cdrom_disk = Disk(type_name="file")
cdrom_disk.device = "cdrom"
cdrom_disk.target = {'dev': "vdf", 'bus': "scsi"}
cdrom_disk.source = cdrom_disk.new_disk_source(
**{'attrs': {
'file': cdrom_path
}})
vmxml.add_device(cdrom_disk)
def run(test, params, env):
"""
Test various options of virt-v2v.
"""
if utils_v2v.V2V_EXEC is None:
raise ValueError('Missing command: virt-v2v')
for v in list(params.values()):
if "V2V_EXAMPLE" in v:
test.cancel("Please set real value for %s" % v)
version_requried = params.get("version_requried")
vm_name = params.get("main_vm", "EXAMPLE")
new_vm_name = params.get("new_vm_name")
input_mode = params.get("input_mode")
input_file = params.get("input_file")
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")
source_user = params.get("username", "root")
output_mode = params.get("output_mode")
output_storage = params.get("output_storage", "default")
disk_img = params.get("input_disk_image", "")
nfs_storage = params.get("storage")
no_root = 'yes' == params.get('no_root', 'no')
mnt_point = params.get("mnt_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")
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", "v2v_pool")
emulated_img = params.get("emulated_image_path", "v2v-emulated-img")
pvt = utlv.PoolVolumeTest(test, params)
new_v2v_user = False
address_cache = env.get('address_cache')
params['vmcheck_flag'] = False
checkpoint = params.get('checkpoint', '')
error_flag = 'strict'
estimate_file = ''
def create_pool(user_pool=False,
pool_name=pool_name,
pool_target=pool_target):
"""
Create libvirt pool as the output storage
"""
if output_uri == "qemu:///session" or user_pool:
target_path = os.path.join("/home", v2v_user, pool_target)
cmd = su_cmd + "'mkdir -p %s'" % target_path
process.system(cmd, verbose=True)
# Sometimes pool_creat_as returns sucess, but the pool can
# not be found in user session.
virsh.pool_create_as(pool_name,
'dir',
target_path,
unprivileged_user=v2v_user,
debug=True)
res = virsh.pool_info(pool_name,
unprivileged_user=v2v_user,
debug=True)
if res.exit_status != 0:
return False
else:
pvt.pre_pool(pool_name, pool_type, pool_target, emulated_img)
return True
def cleanup_pool(user_pool=False,
pool_name=pool_name,
pool_target=pool_target):
"""
Clean up libvirt pool
"""
if output_uri == "qemu:///session" or user_pool:
virsh.pool_destroy(pool_name,
unprivileged_user=v2v_user,
debug=True)
target_path = os.path.join("/home", v2v_user, pool_target)
cmd = su_cmd + "'rm -rf %s'" % target_path
process.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\s'convert'\s.+\s'(\S+)'\n", output)
if len(tmp_target) < 1:
test.error("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 = to_text(
process.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_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:
test.fail("VmType check failed")
def check_image(img_path, check_point, expected_value):
"""
Verify image file allocation mode and format
"""
if not img_path or not os.path.isfile(img_path):
test.error("Image path: '%s' is invalid" % img_path)
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:
test.fail("%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:
test.fail("%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:
test.fail("%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:
test.fail("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:
test.fail("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:
test.fail("Not find message: %s" % init_msg)
def check_ovf_snapshot_id(ovf_content):
"""
Check if snapshot id in ovf file consists of '0's
"""
search = re.search("ovf:vm_snapshot_id='(.*?)'", ovf_content)
if search:
snapshot_id = search.group(1)
logging.debug('vm_snapshot_id = %s', snapshot_id)
if snapshot_id.count('0') >= 32:
test.fail('vm_snapshot_id consists with "0"')
else:
test.fail('Fail to find snapshot_id')
def check_source(output):
"""
Check if --print-source option print the correct info
"""
# Parse source info
source = output.split('\n')[2:]
for i in range(len(source)):
if source[i].startswith('\t'):
source[i - 1] += source[i]
source[i] = ''
source_strip = [x.strip() for x in source if x.strip()]
source_info = {}
for line in source_strip:
source_info[line.split(':')[0]] = line.split(':', 1)[1].strip()
logging.debug('Source info to check: %s', source_info)
checklist = [
'nr vCPUs', 'hypervisor type', 'source name', 'memory', 'disks',
'NICs'
]
if hypervisor in ['kvm', 'xen']:
checklist.extend(['display', 'CPU features'])
for key in checklist:
if key not in source_info:
test.fail('%s info missing' % key)
v2v_virsh = None
close_virsh = False
if hypervisor == 'kvm':
v2v_virsh = virsh
else:
virsh_dargs = {
'uri': ic_uri,
'remote_ip': remote_host,
'remote_user': source_user,
'remote_pwd': source_pwd,
'auto_close': True,
'debug': True
}
v2v_virsh = virsh.VirshPersistent(**virsh_dargs)
logging.debug('a new virsh session %s was created', v2v_virsh)
close_virsh = True
# Check single values
fail = []
try:
xml = vm_xml.VMXML.new_from_inactive_dumpxml(
vm_name, virsh_instance=v2v_virsh)
finally:
if close_virsh:
logging.debug('virsh session %s is closing', v2v_virsh)
v2v_virsh.close_session()
check_map = {}
check_map['nr vCPUs'] = xml.vcpu
check_map['hypervisor type'] = xml.hypervisor_type
check_map['source name'] = xml.vm_name
check_map['memory'] = str(int(xml.max_mem) * 1024) + ' (bytes)'
if hypervisor in ['kvm', 'xen']:
check_map['display'] = xml.get_graphics_devices()[0].type_name
logging.info('KEY:\tSOURCE<-> XML')
for key in check_map:
logging.info('%-15s:%18s <-> %s', key, source_info[key],
check_map[key])
if str(check_map[key]) not in source_info[key]:
fail.append(key)
# Check disk info
disk = list(xml.get_disk_all().values())[0]
def _get_disk_subelement_attr_value(obj, attr, subattr):
if obj.find(attr) is not None:
return obj.find(attr).get(subattr)
bus = _get_disk_subelement_attr_value(disk, 'target', 'bus')
driver_type = _get_disk_subelement_attr_value(disk, 'driver', 'type')
path = _get_disk_subelement_attr_value(disk, 'source', 'file')
# For esx, disk output is like "disks: json: { ... } (raw) [scsi]"
# For xen, disk output is like "disks: json: { ... } [ide]"
# For kvm, disk output is like "/rhel8.0-2.qcow2 (qcow2) [virtio-blk]"
if hypervisor == 'kvm':
disks_info_pattern = r"%s \(%s\) \[%s" % (path, driver_type, bus)
elif hypervisor == 'esx':
# replace '.vmdk' with '-flat.vmdk', this is done in v2v
path_pattern1 = path.split()[1].replace('.vmdk', '-flat.vmdk')
# In newer qemu version, '_' is replaced with '%5f'.
path_pattern2 = path_pattern1.replace('_', '%5f')
# nbd:unix:/tmp/v2vnbdkit.u44G6C/nbdkit1.sock:exportname=/ (raw)
# [scsi]
path_pattern_nbd = r'nbd:unix:/.*? \(raw\) \[%s\]' % bus
# For esx, '(raw)' is fixed? Let's see if others will be met.
disks_info_pattern = '|'.join([path_pattern_nbd] + [
r"https://%s/folder/%s\?dcPath=data&dsName=esx.*} \(raw\) \[%s"
% (remote_host, i, bus)
for i in [path_pattern1, path_pattern2]
])
elif hypervisor == 'xen':
disks_info_pattern = "file\.path.*%s.*file\.host.*%s.* \[%s" % (
path, remote_host, bus)
source_disks = source_info['disks'].split()
logging.info('disks:%s<->%s', source_info['disks'], disks_info_pattern)
if not re.search(disks_info_pattern, source_info['disks']):
fail.append('disks')
# Check nic info
nic = list(xml.get_iface_all().values())[0]
type = nic.get('type')
mac = nic.find('mac').get('address')
nic_source = nic.find('source')
name = nic_source.get(type)
nic_info = '%s "%s" mac: %s' % (type, name, mac)
logging.info('NICs:%s<->%s', source_info['NICs'], nic_info)
if nic_info.lower() not in source_info['NICs'].lower():
fail.append('NICs')
# Check cpu features
if hypervisor in ['kvm', 'xen']:
feature_list = xml.features.get_feature_list()
logging.info('CPU features:%s<->%s', source_info['CPU features'],
feature_list)
if sorted(source_info['CPU features'].split(',')) != sorted(
feature_list):
fail.append('CPU features')
if fail:
test.fail('Source info not correct for: %s' % fail)
def check_man_page(in_man, not_in_man):
"""
Check if content of man page or help info meets expectation
"""
man_page = process.run('man virt-v2v',
verbose=False).stdout_text.strip()
if in_man:
logging.info('Checking man page of virt-v2v for "%s"', in_man)
if in_man not in man_page:
test.fail('"%s" not in man page' % in_man)
if not_in_man:
logging.info('Checking man page of virt-v2v for "%s"', not_in_man)
if not_in_man in man_page:
test.fail('"%s" not removed from man page' % not_in_man)
def check_print_estimate(estimate_file):
"""
Check disk size and total size in file of estimate created by v2v
"""
import json
content = None
buf = ''
with open(estimate_file) as fp:
all_content = fp.read()
fp.seek(0)
for line in fp:
buf += line
if '}' not in line:
continue
if 'disks' in buf and 'total' in buf:
content = json.loads(buf)
break
buf = ''
logging.debug('json file content:\n%s' % all_content)
if not content or sum(content['disks']) != content['total']:
test.fail("The disks' size doesn't same as total value")
def check_result(cmd, result, status_error):
"""
Check virt-v2v command result
"""
utils_v2v.check_exit_status(result, status_error, error_flag)
output = to_text(result.stdout + result.stderr, errors=error_flag)
output_stdout = to_text(result.stdout, errors=error_flag)
if status_error:
if checkpoint == 'length_of_error':
log_lines = output.split('\n')
v2v_start = False
for line in log_lines:
if line.startswith('virt-v2v:'):
v2v_start = True
if line.startswith('libvirt:'):
v2v_start = False
# 76 is the max length in v2v
if v2v_start and len(line) > 76:
test.fail('Error log longer than 76 charactors: %s' %
line)
if checkpoint == 'disk_not_exist':
vol_list = virsh.vol_list(pool_name)
logging.info(vol_list)
if vm_name in vol_list.stdout:
test.fail('Disk exists for vm %s' % vm_name)
else:
if output_mode == "rhev" and checkpoint != 'quiet':
ovf = get_ovf_content(output)
logging.debug("ovf content: %s", ovf)
check_ovf_snapshot_id(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)
def check_alloc():
try:
check_image(img_path, "allocation", expected_mode)
return True
except exceptions.TestFail:
pass
if not utils_misc.wait_for(check_alloc, timeout=600,
step=10.0):
test.fail('Allocation check failed.')
if '-of' in cmd and '--no-copy' not in cmd and '--print-source' not in cmd and checkpoint != 'quiet' and not no_root:
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):
test.fail("Import VM failed")
else:
vmchecker = VMChecker(test, params, env)
params['vmchecker'] = vmchecker
params['vmcheck_flag'] = True
if output_mode == "libvirt":
if "qemu:///session" not in v2v_options and not no_root:
virsh.start(vm_name, debug=True, ignore_status=False)
if checkpoint in ['vmx', 'vmx_ssh']:
vmchecker = VMChecker(test, params, env)
params['vmchecker'] = vmchecker
params['vmcheck_flag'] = True
ret = vmchecker.run()
if len(ret) == 0:
logging.info("All common checkpoints passed")
if checkpoint == 'quiet':
if len(output.strip().splitlines()) > 10:
test.fail('Output is not empty in quiet mode')
if checkpoint == 'dependency':
if 'libguestfs-winsupport' not in output:
test.fail('libguestfs-winsupport not in dependency')
if all(pkg_pattern not in output
for pkg_pattern in ['VMF', 'edk2-ovmf']):
test.fail('OVMF/AAVMF not in dependency')
if 'qemu-kvm-rhev' in output:
test.fail('qemu-kvm-rhev is in dependency')
if 'libX11' in output:
test.fail('libX11 is in dependency')
if 'kernel-rt' in output:
test.fail('kernel-rt is in dependency')
win_img = params.get('win_image')
command = 'guestfish -a %s -i'
if process.run(command % win_img,
ignore_status=True).exit_status == 0:
test.fail('Command "%s" success' % command % win_img)
if checkpoint == 'no_dcpath':
if '--dcpath' in output:
test.fail('"--dcpath" is not removed')
if checkpoint == 'debug_overlays':
search = re.search('Overlay saved as(.*)', output)
if not search:
test.fail('Not find log of saving overlays')
overlay_path = search.group(1).strip()
logging.debug('Overlay file location: %s' % overlay_path)
if os.path.isfile(overlay_path):
logging.info('Found overlay file: %s' % overlay_path)
else:
test.fail('Overlay file not saved')
if checkpoint.startswith('empty_nic_source'):
target_str = '%s "eth0" mac: %s' % (params[checkpoint][0],
params[checkpoint][1])
logging.info('Expect log: %s', target_str)
if target_str not in output_stdout.lower():
test.fail('Expect log not found: %s' % target_str)
if checkpoint == 'print_source':
check_source(output_stdout)
if checkpoint == 'machine_readable':
if os.path.exists(params.get('example_file', '')):
# Checking items in example_file exist in latest
# output regardless of the orders and new items.
with open(params['example_file']) as f:
for line in f:
if line.strip() not in output_stdout.strip():
test.fail(
'%s not in --machine-readable output' %
line.strip())
else:
test.error('No content to compare with')
if checkpoint == 'compress':
img_path = get_img_path(output)
logging.info('Image path: %s', img_path)
qemu_img_cmd = 'qemu-img check %s' % img_path
qemu_img_locking_feature_support = libvirt_storage.check_qemu_image_lock_support(
)
if qemu_img_locking_feature_support:
qemu_img_cmd = 'qemu-img check %s -U' % img_path
disk_check = process.run(qemu_img_cmd).stdout_text
logging.info(disk_check)
compress_info = disk_check.split(',')[-1].split('%')[0].strip()
compress_rate = float(compress_info)
logging.info('%s%% compressed', compress_rate)
if compress_rate < 0.1:
test.fail('Disk image NOT compressed')
if checkpoint == 'tail_log':
messages = params['tail'].get_output()
logging.info('Content of /var/log/messages during conversion:')
logging.info(messages)
msg_content = params['msg_content']
if msg_content in messages:
test.fail('Found "%s" in /var/log/messages' % msg_content)
if checkpoint == 'print_estimate_tofile':
check_print_estimate(estimate_file)
log_check = utils_v2v.check_log(params, output)
if log_check:
test.fail(log_check)
check_man_page(params.get('in_man'), params.get('not_in_man'))
backup_xml = None
vdsm_domain_dir, vdsm_image_dir, vdsm_vm_dir = ("", "", "")
try:
if version_requried and not utils_v2v.compare_version(
version_requried):
test.cancel("Testing requries version: %s" % version_requried)
if hypervisor == "xen":
# See man virt-v2v-input-xen(1)
process.run('update-crypto-policies --set LEGACY',
verbose=True,
ignore_status=True,
shell=True)
if checkpoint.startswith('empty_nic_source'):
xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
iface = xml.get_devices('interface')[0]
disks = xml.get_devices('disk')
del iface.source
iface.type_name = checkpoint.split('_')[-1]
iface.source = {iface.type_name: ''}
params[checkpoint] = [iface.type_name, iface.mac_address]
logging.debug(iface.source)
devices = vm_xml.VMXMLDevices()
devices.extend(disks)
devices.append(iface)
xml.set_devices(devices)
logging.info(xml.xmltreefile)
params['input_xml'] = xml.xmltreefile.name
# 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)
if checkpoint == 'with_ic':
ic_uri = 'qemu:///session'
input_option = "-i ova %s -ic %s -of qcow2" % (input_file,
ic_uri)
if checkpoint == 'without_ic':
input_option = "-i ova %s -of raw" % input_file
# Build network&bridge option to avoid network error
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 == 'libvirtxml':
input_xml = params.get('input_xml')
input_option += '-i %s %s' % (input_mode, input_xml)
elif input_mode in ['ova']:
test.cancel("Unsupported input mode: %s" % input_mode)
else:
test.error("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)
if checkpoint == 'rhv':
output_option = output_option.replace('rhev', 'rhv')
if checkpoint in ['with_ic', 'without_ic']:
output_option = output_option.replace('v2v_dir', 'src_pool')
output_format = params.get("output_format")
if output_format and output_format != input_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"):
test.error("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.makedirs(vdsm_domain_dir)
os.makedirs(vdsm_image_dir)
os.makedirs(vdsm_vm_dir)
if output_mode == 'rhev':
# create different sasl_user name for different job
params.update({
'sasl_user':
params.get("sasl_user") +
utils_misc.generate_random_string(3)
})
logging.info('sals user name is %s' % params.get("sasl_user"))
user_pwd = "[['%s', '%s']]" % (params.get("sasl_user"),
params.get("sasl_pwd"))
v2v_sasl = utils_sasl.SASL(sasl_user_pwd=user_pwd)
v2v_sasl.server_ip = params.get("remote_ip")
v2v_sasl.server_user = params.get('remote_user')
v2v_sasl.server_pwd = params.get('remote_pwd')
v2v_sasl.setup(remote=True)
logging.debug('A SASL session %s was created', v2v_sasl)
# Output more messages except quiet mode
if checkpoint == 'quiet':
v2v_options += ' -q'
elif checkpoint not in [
'length_of_error', 'empty_nic_source_network',
'empty_nic_source_bridge', 'machine_readable'
]:
v2v_options += " -v -x"
# Prepare for libvirt unprivileged user session connection
if "qemu:///session" in v2v_options or no_root:
try:
pwd.getpwnam(v2v_user)
except KeyError:
# create new user
process.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":
# Copy image from souce and change the image owner and group
disk_path = os.path.join(data_dir.get_tmp_dir(),
os.path.basename(disk_img))
logging.info('Copy image file %s to %s', disk_img, disk_path)
shutil.copyfile(disk_img, disk_path)
input_option = input_option.replace(disk_img, disk_path)
os.chown(disk_path, user_info.pw_uid, user_info.pw_gid)
elif not no_root:
test.cancel("Only support convert local disk")
# Setup ssh-agent access to xen hypervisor
if hypervisor == 'xen':
user = params.get("xen_host_user", "root")
source_pwd = passwd = params.get("xen_host_passwd", "redhat")
logging.info("set up ssh-agent access ")
xen_pubkey, xen_session = utils_v2v.v2v_setup_ssh_key(
remote_host, user, passwd, auto_close=False)
utils_misc.add_identities_into_ssh_agent()
# Check if xen guest exists
uri = utils_v2v.Uri(hypervisor).get_uri(remote_host)
if not virsh.domain_exists(vm_name, uri=uri):
logging.error('VM %s not exists', vm_name)
# 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 and checkpoint != 'xen_no_output_format':
v2v_options += ' -of %s' % params.get("default_output_format",
"qcow2")
# Create password file for access to ESX hypervisor
if hypervisor == 'esx':
source_pwd = vpx_passwd = params.get("vpx_password")
vpx_passwd_file = os.path.join(data_dir.get_tmp_dir(),
"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 += " -ip %s" % vpx_passwd_file
# rhel8 slow stream doesn't support option 'ip' temporarily
# so use option 'password-file' instead.
if not utils_v2v.v2v_supported_option("-ip <filename>"):
output_option = output_option.replace('-ip', '--password-file',
1)
# if don't specify any output option for virt-v2v, 'default' pool
# will be used.
if output_mode is None:
# Cleanup first to avoid failure if 'default' pool exists.
pvt.cleanup_pool(pool_name, pool_type, pool_target, emulated_img)
pvt.pre_pool(pool_name, pool_type, pool_target, emulated_img)
# Create libvirt dir pool
if output_mode == "libvirt":
utils_misc.wait_for(create_pool, timeout=30, step=3)
# Work around till bug fixed
os.environ['LIBGUESTFS_BACKEND'] = 'direct'
if checkpoint in ['with_ic', 'without_ic']:
new_v2v_user = True
v2v_options += ' -on %s' % new_vm_name
utils_misc.wait_for(
lambda: create_pool(user_pool=True,
pool_name='src_pool',
pool_target='v2v_src_pool'),
timeout=30,
step=3)
if checkpoint == 'vmx':
mount_point = params.get('mount_point')
if not os.path.isdir(mount_point):
os.mkdir(mount_point)
nfs_vmx = params.get('nfs_vmx')
if not utils_misc.mount(nfs_vmx, mount_point, 'nfs', verbose=True):
test.error('Mount nfs for vmx failed')
vmx = params.get('vmx')
input_option = '-i vmx %s' % vmx
v2v_options += " -b %s -n %s" % (params.get("output_bridge"),
params.get("output_network"))
if checkpoint == 'vmx_ssh':
esx_user = params.get("esx_host_user", "root")
esx_pwd = params.get("esx_host_passwd")
vmx = params.get('vmx')
esx_pubkey, esx_session = utils_v2v.v2v_setup_ssh_key(
esx_ip, esx_user, esx_pwd, server_type='esx', auto_close=False)
utils_misc.add_identities_into_ssh_agent()
input_option = '-i vmx -it ssh %s' % vmx
v2v_options += " -b %s -n %s" % (params.get("output_bridge"),
params.get("output_network"))
if checkpoint == 'simulate_nfs':
simulate_images = params.get("simu_images_path")
simulate_vms = params.get("simu_vms_path")
simulate_dom_md = params.get("simu_dom_md_path")
os.makedirs(simulate_images)
os.makedirs(simulate_vms)
process.run('touch %s' % simulate_dom_md)
process.run('chmod -R 777 /tmp/rhv/')
if checkpoint == 'print_estimate_tofile':
estimate_file = utils_misc.generate_tmp_file_name(
'v2v_print_estimate')
v2v_options += " --machine-readable=file:%s" % estimate_file
# Running virt-v2v command
cmd = "%s %s %s %s" % (utils_v2v.V2V_EXEC, input_option, output_option,
v2v_options)
if v2v_user:
cmd_export_env = 'export LIBGUESTFS_BACKEND=direct'
cmd = "%s '%s;%s'" % (su_cmd, cmd_export_env, cmd)
if params.get('cmd_free') == 'yes':
cmd = params.get('check_command')
# only set error to 'ignore' to avoid exception for RHEL7-84978
if "guestfish" in cmd:
error_flag = "replace"
# Set timeout to kill v2v process before conversion succeed
if checkpoint == 'disk_not_exist':
v2v_timeout = 30
# Get tail content of /var/log/messages
if checkpoint == 'tail_log':
params['tail_log'] = os.path.join(data_dir.get_tmp_dir(),
'tail_log')
params['tail'] = aexpect.Tail(command='tail -f /var/log/messages',
output_func=utils_misc.log_line,
output_params=(params['tail_log'], ))
cmd_result = process.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 == "esx":
process.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 or no_root:
cmd = su_cmd + "'virsh undefine %s'" % vm_name
try:
process.system(cmd)
except Exception:
logging.error('Undefine "%s" failed', vm_name)
if no_root:
cleanup_pool(user_pool=True,
pool_name='src_pool',
pool_target='v2v_src_pool')
else:
virsh.remove_domain(vm_name)
cleanup_pool()
if output_mode is None:
pvt.cleanup_pool(pool_name, pool_type, pool_target, emulated_img)
vmcheck_flag = params.get("vmcheck_flag")
if vmcheck_flag and params.get('vmchecker'):
params['vmchecker'].cleanup()
if new_v2v_user:
process.system("userdel -fr %s" % v2v_user)
if backup_xml:
backup_xml.sync()
if output_mode == 'rhev' and v2v_sasl:
v2v_sasl.cleanup()
logging.debug('SASL session %s is closing', v2v_sasl)
v2v_sasl.close_session()
if checkpoint == 'vmx':
utils_misc.umount(params['nfs_vmx'], params['mount_point'], 'nfs')
os.rmdir(params['mount_point'])
if checkpoint == 'vmx_ssh':
utils_v2v.v2v_setup_ssh_key_cleanup(esx_session, esx_pubkey, 'esx')
process.run("ssh-agent -k")
if checkpoint == 'simulate_nfs':
process.run('rm -rf /tmp/rhv/')
if os.path.exists(estimate_file):
os.remove(estimate_file)
if hypervisor == "xen":
# Restore crypto-policies to DEFAULT, the setting is impossible to be
# other values by default in testing envrionment.
process.run('update-crypto-policies --set DEFAULT',
verbose=True,
ignore_status=True,
shell=True)
utils_v2v.v2v_setup_ssh_key_cleanup(xen_session, xen_pubkey)
process.run("ssh-agent -k")
def run(test, params, env):
"""
Test virsh domblkerror in 2 types error
1. unspecified error
2. no space
"""
if not virsh.has_help_command('domblkerror'):
test.cancel("This version of libvirt does not support domblkerror "
"test")
vm_name = params.get("main_vm", "avocado-vt-vm1")
error_type = params.get("domblkerror_error_type")
timeout = params.get("domblkerror_timeout", 240)
mnt_dir = params.get("domblkerror_mnt_dir", "/home/test")
export_file = params.get("nfs_export_file", "/etc/exports")
img_name = params.get("domblkerror_img_name", "libvirt-disk")
img_size = params.get("domblkerror_img_size")
target_dev = params.get("domblkerror_target_dev", "vdb")
pool_name = params.get("domblkerror_pool_name", "fs_pool")
vol_name = params.get("domblkerror_vol_name", "vol1")
ubuntu = distro.detect().name == 'Ubuntu'
rhel = distro.detect().name == 'rhel'
nfs_service_package = params.get("nfs_service_package",
"nfs-kernel-server")
nfs_service = None
selinux_bool = None
session = None
selinux_bak = ""
vm = env.get_vm(vm_name)
if error_type == "unspecified error":
selinux_local = params.get("setup_selinux_local", "yes") == "yes"
if not ubuntu and not rhel:
nfs_service_package = "nfs"
elif rhel:
nfs_service_package = "nfs-server"
if not rhel and not utils_package.package_install(nfs_service_package):
test.cancel("NFS package not available in host to test")
# backup /etc/exports
shutil.copyfile(export_file, "%s.bak" % export_file)
# backup xml
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
try:
# Generate tmp dir
tmp_dir = data_dir.get_tmp_dir()
img_dir = os.path.join(tmp_dir, 'images')
if not os.path.exists(img_dir):
os.mkdir(img_dir)
# Generate attached disk
process.run("qemu-img create %s %s" %
(os.path.join(img_dir, img_name), img_size),
shell=True,
verbose=True)
# Get unspecified error
if error_type == "unspecified error":
# In this situation, guest will attach a disk on nfs, stop nfs
# service will cause guest paused and get unspecified error
nfs_dir = os.path.join(tmp_dir, 'mnt')
if not os.path.exists(nfs_dir):
os.mkdir(nfs_dir)
mount_opt = "rw,no_root_squash,async"
res = libvirt.setup_or_cleanup_nfs(is_setup=True,
mount_dir=nfs_dir,
is_mount=False,
export_options=mount_opt,
export_dir=img_dir)
if not ubuntu:
selinux_bak = res["selinux_status_bak"]
process.run("mount -o nolock,soft,timeo=1,retrans=1,retry=0 "
"127.0.0.1:%s %s" % (img_dir, nfs_dir),
shell=True,
verbose=True)
img_path = os.path.join(nfs_dir, img_name)
nfs_service = Factory.create_service(nfs_service_package)
if not ubuntu and selinux_local:
params['set_sebool_local'] = "yes"
params['local_boolean_varible'] = "virt_use_nfs"
params['local_boolean_value'] = "on"
selinux_bool = utils_misc.SELinuxBoolean(params)
selinux_bool.setup()
elif error_type == "no space":
# Steps to generate no space block error:
# 1. Prepare a iscsi disk and build fs pool with it
# 2. Create vol with larger capacity and 0 allocation
# 3. Attach this disk in guest
# 4. In guest, create large image in the vol, which may cause
# guest paused
_pool_vol = None
pool_target = os.path.join(tmp_dir, pool_name)
_pool_vol = libvirt.PoolVolumeTest(test, params)
_pool_vol.pre_pool(pool_name,
"fs",
pool_target,
img_name,
image_size=img_size)
_pool_vol.pre_vol(vol_name, "raw", "100M", "0", pool_name)
img_path = os.path.join(pool_target, vol_name)
# Generate disk xml
# Guest will attach a disk with cache=none and error_policy=stop
img_disk = Disk(type_name="file")
img_disk.device = "disk"
img_disk.source = img_disk.new_disk_source(
**{'attrs': {
'file': img_path
}})
img_disk.driver = {
'name': "qemu",
'type': "raw",
'cache': "none",
'error_policy': "stop"
}
img_disk.target = {'dev': target_dev, 'bus': "virtio"}
logging.debug("disk xml is %s", img_disk.xml)
# Start guest and get session
if not vm.is_alive():
vm.start()
session = vm.wait_for_login()
# Get disk list before operation
get_disks_cmd = "fdisk -l|grep '^Disk /dev'|cut -d: -f1|cut -d' ' -f2"
bef_list = str(session.cmd_output(get_disks_cmd)).strip().split("\n")
logging.debug("disk_list_debug = %s", bef_list)
# Attach disk to guest
ret = virsh.attach_device(vm_name, img_disk.xml)
if ret.exit_status != 0:
test.fail("Fail to attach device %s" % ret.stderr)
time.sleep(2)
logging.debug("domain xml is %s", virsh.dumpxml(vm_name))
# get disk list after attach
aft_list = str(session.cmd_output(get_disks_cmd)).strip().split("\n")
logging.debug("disk list after attaching - %s", aft_list)
# Find new disk after attach
new_disk = "".join(list(set(bef_list) ^ set(aft_list)))
logging.debug("new disk is %s", new_disk)
def create_large_image():
"""
Create large image in guest
"""
# install dependent packages
pkg_list = ["parted", "e2fsprogs"]
for pkg in pkg_list:
if not utils_package.package_install(pkg, session):
test.error("Failed to install dependent package %s" % pkg)
# create partition and file system
session.cmd("parted -s %s mklabel msdos" % new_disk)
session.cmd("parted -s %s mkpart primary ext4 '0%%' '100%%'" %
new_disk)
# mount disk and write file in it
session.cmd("mkfs.ext4 %s1" % new_disk)
session.cmd("mkdir -p %s && mount %s1 %s" %
(mnt_dir, new_disk, mnt_dir))
# The following step may cause guest paused before it return
try:
session.cmd("dd if=/dev/zero of=%s/big_file bs=1024 "
"count=51200 && sync" % mnt_dir)
except Exception as err:
logging.debug("Expected Fail %s", err)
session.close()
create_large_image()
if error_type == "unspecified error":
# umount nfs to trigger error after create large image
if nfs_service is not None:
nfs_service.stop()
logging.debug("nfs status is %s", nfs_service.status())
# wait and check the guest status with timeout
def _check_state():
"""
Check domain state
"""
return (vm.state() == "paused")
if not utils_misc.wait_for(_check_state, timeout):
# If not paused, perform one more IO operation to the mnt disk
session = vm.wait_for_login()
session.cmd("echo 'one more write to big file' > %s/big_file" %
mnt_dir)
if not utils_misc.wait_for(_check_state, 60):
test.fail("Guest does not paused, it is %s now" % vm.state())
else:
logging.info("Now domain state changed to paused status")
output = virsh.domblkerror(vm_name)
if output.exit_status == 0:
expect_result = "%s: %s" % (img_disk.target['dev'], error_type)
if output.stdout.strip() == expect_result:
logging.info("Get expect result: %s", expect_result)
else:
test.fail("Failed to get expect result, get %s" %
output.stdout.strip())
else:
test.fail("Fail to get domblkerror info:%s" % output.stderr)
finally:
logging.info("Do clean steps")
if session:
session.close()
if error_type == "unspecified error":
if nfs_service is not None:
nfs_service.start()
vm.destroy()
if os.path.isfile("%s.bak" % export_file):
shutil.move("%s.bak" % export_file, export_file)
res = libvirt.setup_or_cleanup_nfs(is_setup=False,
mount_dir=nfs_dir,
export_dir=img_dir,
restore_selinux=selinux_bak)
if selinux_bool:
selinux_bool.cleanup(keep_authorized_keys=True)
elif error_type == "no space":
vm.destroy()
if _pool_vol:
_pool_vol.cleanup_pool(pool_name, "fs", pool_target, img_name)
vmxml_backup.sync()
data_dir.clean_tmp_files()
def run(test, params, env):
"""
Test vcpu hotpluggable item in xml
1. Set the libvirtd log filter/level/file
2. Restart libvirtd
3. Start vm by xml with vcpu hotpluggable
4. Check the qemu command line
5. Check the libvirtd log
6. Restart libvrtd
7. Check the vm xml
"""
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
vcpus_placement = params.get("vcpus_placement", "static")
vcpus_crt = int(params.get("vcpus_current", "4"))
vcpus_max = int(params.get("vcpus_max", "8"))
vcpus_enabled = params.get("vcpus_enabled", "")
vcpus_hotplug = params.get("vcpus_hotpluggable", "")
vcpus_order = params.get("vcpus_order")
err_msg = params.get("err_msg", "")
config_libvirtd = params.get("config_libvirtd", "yes") == "yes"
log_file = params.get("log_file", "libvirtd.log")
live_vcpus = params.get("set_live_vcpus", "")
config_vcpus = params.get("set_config_vcpus", "")
enable_vcpu = params.get("set_enable_vcpu", "")
disable_vcpu = params.get("set_disable_vcpu", "")
start_vm_after_config = params.get('start_vm_after_config', 'yes') == 'yes'
# Install cgroup utils
cgutils = "libcgroup-tools"
if distro.detect().name == 'Ubuntu':
cgutils = "cgroup-tools"
sm = SoftwareManager()
if not sm.check_installed(cgutils) and not sm.install(cgutils):
test.cancel("cgroup utils package install failed")
# Backup domain XML
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
vmxml_backup = vmxml.copy()
libvirtd = utils_libvirtd.Libvirtd()
try:
# Configure libvirtd log
if config_libvirtd:
config_path = os.path.join(data_dir.get_tmp_dir(), log_file)
with open(config_path, 'a') as f:
pass
daemon_conf_dict = {
"log_level": "1",
"log_filters":
"\"1:json 1:libvirt 1:qemu 1:monitor 3:remote 4:event\"",
"log_outputs": "\"1:file:{}\"".format(config_path)
}
daemon_conf = libvirt.customize_libvirt_config(daemon_conf_dict)
# Restart libvirtd to make the changes take effect in libvirt
libvirtd.restart()
# Set vcpu: placement,current,max vcpu
vmxml.placement = vcpus_placement
vmxml.vcpu = vcpus_max
vmxml.current_vcpu = vcpus_crt
del vmxml.cpuset
# Create vcpu xml with vcpu hotpluggable and order
vcpu_list = []
vcpu = {}
en_list = vcpus_enabled.split(",")
hotplug_list = vcpus_hotplug.split(",")
order_dict = ast.literal_eval(vcpus_order)
for vcpu_id in range(vcpus_max):
vcpu['id'] = str(vcpu_id)
if str(vcpu_id) in en_list:
vcpu['enabled'] = 'yes'
if str(vcpu_id) in order_dict:
vcpu['order'] = order_dict[str(vcpu_id)]
else:
vcpu['enabled'] = 'no'
if str(vcpu_id) in hotplug_list:
vcpu['hotpluggable'] = 'yes'
else:
vcpu['hotpluggable'] = 'no'
vcpu_list.append(copy.copy(vcpu))
vcpu = {}
vcpus_xml = vm_xml.VMVCPUSXML()
vcpus_xml.vcpu = vcpu_list
vmxml.vcpus = vcpus_xml
# Remove influence from topology setting
try:
logging.info('Remove influence from topology setting')
cpuxml = vmxml.cpu
del cpuxml.topology
vmxml.cpu = cpuxml
except Exception as e:
pass
vmxml.sync()
logging.debug("Before starting, VM xml:"
"\n%s", vm_xml.VMXML.new_from_inactive_dumpxml(vm_name))
# Start VM
if start_vm_after_config:
logging.info("Start VM with vcpu hotpluggable and order...")
ret = virsh.start(vm_name, ignore_status=True)
if err_msg:
libvirt.check_result(ret, err_msg)
else:
if start_vm_after_config:
# Wait for domain
vm.wait_for_login()
if enable_vcpu:
ret = virsh.setvcpu(vm_name,
enable_vcpu,
"--enable",
ignore_status=False,
debug=True)
vcpus_crt += 1
if disable_vcpu:
ret = virsh.setvcpu(vm_name,
disable_vcpu,
"--disable",
ingnore_status=False,
debug=True)
vcpus_crt -= 1
if live_vcpus:
ret = virsh.setvcpus(vm_name,
live_vcpus,
ignore_status=False,
debug=True)
vcpus_crt = int(live_vcpus)
if config_vcpus:
ret = virsh.setvcpus(vm_name,
config_vcpus,
"--config",
ignore_status=False,
debug=True)
# Check QEMU command line
if start_vm_after_config:
cmd = ("ps -ef| grep %s| grep 'maxcpus=%s'" %
(vm_name, vcpus_max))
ret = process.run(cmd, ignore_status=False, shell=True)
if ret.exit_status != 0:
logging.error("Maxcpus in QEMU command line is wrong!")
# Check libvirtd log
if config_libvirtd and start_vm_after_config:
for vcpu in vcpu_list:
if vcpu['enabled'] == 'yes' and vcpu[
'hotpluggable'] == 'yes':
cmd = (
"cat %s| grep device_add| grep qemuMonitorIOWrite"
"| grep 'vcpu%s'" % (config_path, vcpu['id']))
ret = process.run(cmd, ignore_status=False, shell=True)
if ret.exit_status != 0:
logging.error(
"Failed to find lines about enabled vcpu%s"
"in libvirtd log.", vcpu['id'])
# Dumpxml
dump_xml = virsh.dumpxml(vm_name).stdout.strip()
vcpu_items = re.findall(r"vcpu.*", dump_xml)
# Check guest vcpu count
ret = virsh.vcpucount(vm_name, ignore_status=True, debug=True)
output = ret.stdout.strip()
max_list = re.findall(r"maximum.*[config|live].*%s\n" % vcpus_max,
output)
expect_num = 2 if start_vm_after_config else 1
if len(max_list) != expect_num:
test.fail("vcpucount maximum info is not correct.")
if live_vcpus:
crt_live_list = re.findall(r"current.*live.*%s" % live_vcpus,
output)
logging.info("vcpucount crt_live_list: \n %s", crt_live_list)
if len(crt_live_list) != 1:
test.fail("vcpucount: current live info is not correct.")
elif config_vcpus:
crt_cfg_list = re.findall(
r"current.*config.*%s" % config_vcpus, output)
logging.info("vcpucount crt_cfg_list: \n %s", crt_cfg_list)
if len(crt_cfg_list) != 1:
test.fail("vcpucount: current config info is not correct.")
else:
crt_live_list = re.findall(r"current.*live.*%s" % vcpus_crt,
output)
logging.info("vcpucount crt_live_list: \n %s", crt_live_list)
if len(crt_live_list) != 1:
test.fail("vcpucount: current info is not correct.")
# Check guest vcpu info
ret = virsh.vcpuinfo(vm_name, ignore_status=True, debug=True)
output = ret.stdout.strip()
vcpu_lines = re.findall(r"VCPU:.*\n", output)
logging.info("vcpuinfo vcpu_lines: \n %s", vcpu_lines)
expect_num = vcpus_crt if start_vm_after_config else int(
config_vcpus)
if len(vcpu_lines) != expect_num:
test.fail("vcpuinfo is not correct.")
# Check cpu in guest
if start_vm_after_config and not cpu.check_if_vm_vcpu_match(
vcpus_crt, vm):
test.fail(
"cpu number in VM is not correct, it should be %s cpus" %
vcpus_crt)
# Check VM xml change for cold-plug/cold-unplug
if config_vcpus:
check_vcpu_after_plug_unplug(test, vm_name, config_vcpus)
# Restart libvirtd
libvirtd.restart()
if config_vcpus and not start_vm_after_config:
check_vm_exist(test, vm_name, 'shut off')
# Recheck VM xml
re_dump_xml = virsh.dumpxml(vm_name).stdout.strip()
re_vcpu_items = re.findall(r"vcpu.*", re_dump_xml)
if vcpu_items != re_vcpu_items:
test.fail("After restarting libvirtd,"
"VM xml changed unexpectedly.")
# Check cgroup info
if start_vm_after_config:
en_vcpu_list = re.findall(r"vcpu.*enabled=.yes.*", re_dump_xml)
for vcpu_sn in range(len(en_vcpu_list)):
vcpu_id = en_vcpu_list[vcpu_sn].split(
"=")[1].split()[0].strip('\'')
cg_obj = libvirt_cgroup.CgroupTest(vm.get_pid())
cg_path = cg_obj.get_cgroup_path("cpuset")
if cg_obj.is_cgroup_v2_enabled():
vcpu_path = os.path.join(cg_path, "vcpu%s" % vcpu_id)
else:
vcpu_path = os.path.join(cg_path,
"../vcpu%s" % vcpu_id)
if not os.path.exists(vcpu_path):
test.fail(
"Failed to find the enabled vcpu{} in {}.".format(
vcpu_id, cg_path))
finally:
# Recover libvirtd configuration
if config_libvirtd and 'daemon_conf' in locals():
libvirt.customize_libvirt_config(None,
remote_host=False,
is_recover=True,
config_object=daemon_conf)
if vm.is_alive():
vm.destroy(gracefully=False)
vmxml_backup.sync()
