def run(test, params, env):
"""
Run nvdimm cases:
1) Boot guest with two nvdimm devices
2) Change the two nvdimm devices to dax mode inside guest
3) Check if both devices are dax mode
:param test: QEMU test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
session = vm.wait_for_login()
if not utils_package.package_install("ndctl", session):
test.cancel("Please install ndctl inside guest to proceed")
create_dax_cmd = params["create_dax_cmd"]
nvdimm_number = len(params["mem_devs"].split())
try:
for i in range(nvdimm_number):
session.cmd(create_dax_cmd % i)
output = session.cmd_output(params["ndctl_check_cmd"])
output = eval(output)
for item in output:
if item['mode'] != 'devdax':
test.fail("Change both nvdimm to dax mode failed")
finally:
utils_package.package_remove("ndctl", session)
session.close()
vm.destroy()
def run_guest_libvirt(session):
"""
Check guest libvirt network
"""
# Try to install required packages
if not utils_package.package_install(['libvirt'], session):
raise error.TestError("Failed ot install libvirt"
" package on guest")
result = True
# Try to load tun module first
session.cmd("lsmod | grep tun || modprobe tun")
# Check network state on guest
cmd = ("service libvirtd restart; virsh net-info default"
" | grep 'Active:.*no'")
if session.cmd_status(cmd):
result = False
logging.error("Default network isn't in inactive state")
# Try to start default network on guest, check error messages
if result:
cmd = "virsh net-start default"
status, output = session.cmd_status_output(cmd)
logging.debug("Run command on guest exit %s, output %s" %
(status, output))
if not status or not output.count("already in use"):
result = False
logging.error("Failed to see network messges on guest")
if not utils_package.package_remove("libvirt*", session):
logging.error("Failed to remove libvirt packages on guest")
if not result:
raise error.TestFail("Check libvirt network on guest failed")
def run_guest_libvirt(session):
"""
Check guest libvirt network
"""
# Try to install required packages
if "ubuntu" in vm.get_distro().lower():
pkg = "libvirt-bin"
else:
pkg = "libvirt"
if not utils_package.package_install(pkg, session):
test.error("Failed to install libvirt package on guest")
# Try to load tun module first
session.cmd("lsmod | grep tun || modprobe tun")
# Check network state on guest
cmd = ("service libvirtd restart; virsh net-info default"
" | grep 'Active:.*yes'")
if session.cmd_status(cmd):
test.fail("'default' network isn't in active state")
# Try to destroy&start default network on guest
for opt in ['net-destroy', 'net-start']:
cmd = "virsh %s default" % opt
status, output = session.cmd_status_output(cmd)
logging.debug("Run %s on guest exit %s, output %s"
% (cmd, status, output))
if status:
test.fail(output)
if not utils_package.package_remove("libvirt*", session):
test.error("Failed to remove libvirt packages on guest")
def run_guest_libvirt(session):
"""
Check guest libvirt network
"""
# Try to install required packages
if "ubuntu" in vm.get_distro().lower():
pkg = "libvirt-bin"
else:
pkg = "libvirt"
if not utils_package.package_install(pkg, session):
test.error("Failed to install libvirt package on guest")
# Try to load tun module first
session.cmd("lsmod | grep tun || modprobe tun")
# Check network state on guest
cmd = ("service libvirtd restart; virsh net-info default"
" | grep 'Active:.*yes'")
if session.cmd_status(cmd):
test.fail("'default' network isn't in active state")
# Try to destroy&start default network on guest
for opt in ['net-destroy', 'net-start']:
cmd = "virsh %s default" % opt
status, output = session.cmd_status_output(cmd)
logging.debug("Run %s on guest exit %s, output %s"
% (cmd, status, output))
if status:
test.fail(output)
if not utils_package.package_remove("libvirt*", session):
test.error("Failed to remove libvirt packages on guest")
def run(test, params, env):
"""
Test migration under stress.
"""
vm_names = params.get("vms").split()
if len(vm_names) < 2:
test.cancel("Provide enough vms for migration")
src_uri = "qemu:///system"
dest_uri = libvirt_vm.complete_uri(params.get("migrate_dest_host",
"EXAMPLE"))
if dest_uri.count('///') or dest_uri.count('EXAMPLE'):
test.cancel("The dest_uri '%s' is invalid" % dest_uri)
# Migrated vms' instance
vms = env.get_all_vms()
params["load_vms"] = list(vms)
cpu = int(params.get("smp", 1))
memory = int(params.get("mem")) * 1024
stress_tool = params.get("stress_tool", "")
remote_stress = params.get("migration_stress_remote", "no") == "yes"
host_stress = params.get("migration_stress_host", "no") == "yes"
vms_stress = params.get("migration_stress_vms", "no") == "yes"
vm_bytes = params.get("stress_vm_bytes", "128M")
stress_args = params.get("%s_args" % stress_tool)
migration_type = params.get("migration_type")
start_migration_vms = params.get("start_migration_vms", "yes") == "yes"
thread_timeout = int(params.get("thread_timeout", 120))
ubuntu_dep = ['build-essential', 'git']
hstress = rstress = None
vstress = {}
# Set vm_bytes for start_cmd
mem_total = utils_memory.memtotal()
vm_reserved = len(vms) * memory
if vm_bytes == "half":
vm_bytes = (mem_total - vm_reserved) / 2
elif vm_bytes == "shortage":
vm_bytes = mem_total - vm_reserved + 524288
if "vm-bytes" in stress_args:
params["%s_args" % stress_tool] = stress_args % vm_bytes
# Ensure stress tool is available in host
if host_stress:
# remove package manager installed tool to avoid conflict
if not utils_package.package_remove(stress_tool):
logging.error("Existing %s is not removed")
if "stress-ng" in stress_tool and 'Ubuntu' in utils_misc.get_distro():
params['stress-ng_dependency_packages_list'] = ubuntu_dep
try:
hstress = utils_test.HostStress(stress_tool, params)
hstress.load_stress_tool()
except utils_test.StressError, info:
test.error(info)
def run(test, params, env):
"""
Test migration under stress.
"""
vm_names = params.get("vms").split()
if len(vm_names) < 2:
test.cancel("Provide enough vms for migration")
src_uri = "qemu:///system"
dest_uri = libvirt_vm.complete_uri(params.get("migrate_dest_host",
"EXAMPLE"))
if dest_uri.count('///') or dest_uri.count('EXAMPLE'):
test.cancel("The dest_uri '%s' is invalid" % dest_uri)
# Migrated vms' instance
vms = env.get_all_vms()
params["load_vms"] = list(vms)
cpu = int(params.get("smp", 1))
memory = int(params.get("mem")) * 1024
stress_tool = params.get("stress_tool", "")
remote_stress = params.get("migration_stress_remote", "no") == "yes"
host_stress = params.get("migration_stress_host", "no") == "yes"
vms_stress = params.get("migration_stress_vms", "no") == "yes"
vm_bytes = params.get("stress_vm_bytes", "128M")
stress_args = params.get("%s_args" % stress_tool)
migration_type = params.get("migration_type")
start_migration_vms = params.get("start_migration_vms", "yes") == "yes"
thread_timeout = int(params.get("thread_timeout", 120))
ubuntu_dep = ['build-essential', 'git']
hstress = rstress = None
vstress = {}
# Set vm_bytes for start_cmd
mem_total = utils_memory.memtotal()
vm_reserved = len(vms) * memory
if vm_bytes == "half":
vm_bytes = (mem_total - vm_reserved) / 2
elif vm_bytes == "shortage":
vm_bytes = mem_total - vm_reserved + 524288
if "vm-bytes" in stress_args:
params["%s_args" % stress_tool] = stress_args % vm_bytes
# Ensure stress tool is available in host
if host_stress:
# remove package manager installed tool to avoid conflict
if not utils_package.package_remove(stress_tool):
logging.error("Existing %s is not removed")
if "stress-ng" in stress_tool and 'Ubuntu' in utils_misc.get_distro():
params['stress-ng_dependency_packages_list'] = ubuntu_dep
try:
hstress = utils_test.HostStress(stress_tool, params)
hstress.load_stress_tool()
except utils_test.StressError, info:
test.error(info)
def run(test, params, env):
"""
Check libvirt daemons are removed after removing libvirt pkgs.
"""
daemons = params.get('daemons', "").split()
require_modular_daemon = params.get('require_modular_daemon', "no") == "yes"
utils_split_daemons.daemon_mode_check(require_modular_daemon)
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
try:
vm_name = params.get("main_vm")
vm = env.get_vm(vm_name)
if not vm.is_alive():
vm.start()
session = vm.wait_for_login()
if not utils_package.package_install("libvirt*", session):
test.error("Failed to install libvirt package on guest")
virsh.reboot(vm)
if session is None:
session = vm.wait_for_login()
#Destroy default network, otherwise network daemon will not be removed after removed libvirt pkgs
cmd = "virsh net-destroy default"
session.cmd(cmd, ignore_all_errors=True)
runner = remote.RemoteRunner(session=session).run
service.Factory.create_service('virtlogd', run=runner).start()
if not utils_package.package_remove("libvirt*", session):
test.error("Failed to remove libvirt packages on guest")
for daemon in daemons:
cmd = "systemctl -a | grep %s" % daemon
if not session.cmd_status(cmd):
test.fail("%s still exists after removing libvirt pkgs" % daemon)
finally:
if session is not None:
session.close()
if vm.is_alive():
vm.destroy()
def run(test, params, env):
"""
Convert specific xen guest
"""
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.cancel('Missing command: virt-v2v')
vm_name = params.get('main_vm')
new_vm_name = params.get('new_vm_name')
xen_host = params.get('xen_hostname')
xen_host_user = params.get('xen_host_user', 'root')
xen_host_passwd = params.get('xen_host_passwd', 'redhat')
output_mode = params.get('output_mode')
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')
skip_reason = params.get('skip_reason')
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)
address_cache = env.get('address_cache')
checkpoint = params.get('checkpoint', '')
bk_list = ['vnc_autoport', 'vnc_encrypt', 'vnc_encrypt_warning']
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")
def log_fail(msg):
"""
Log error and update error list
"""
logging.error(msg)
error_list.append(msg)
def set_graphics(virsh_instance, param):
"""
Set graphics attributes of vm xml
"""
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(
vm_name, virsh_instance=virsh_instance)
graphic = vmxml.xmltreefile.find('devices').find('graphics')
for key in param:
logging.debug('Set %s=\'%s\'' % (key, param[key]))
graphic.set(key, param[key])
vmxml.sync(virsh_instance=virsh_instance)
def check_grub_file(vmcheck, check):
"""
Check grub file content
"""
logging.info('Checking grub file')
grub_file = utils_misc.get_bootloader_cfg(session=vmcheck.session)
if not grub_file:
test.error('Not found grub file')
content = vmcheck.session.cmd('cat %s' % grub_file)
if check == 'console_xvc0':
if 'console=xvc0' in content:
log_fail('"console=xvc0" still exists')
def check_kernel(vmcheck):
"""
Check content of /etc/sysconfig/kernel
"""
logging.info('Checking /etc/sysconfig/kernel file')
content = vmcheck.session.cmd('cat /etc/sysconfig/kernel')
logging.debug(content)
if 'DEFAULTKERNEL=kernel' not in content:
log_fail('Not find "DEFAULTKERNEL=kernel"')
elif 'DEFAULTKERNEL=kernel-xen' in content:
log_fail('DEFAULTKERNEL is "kernel-xen"')
def check_sound_card(vmcheck, check):
"""
Check sound status of vm from xml
"""
xml = virsh.dumpxml(vm_name,
session_id=vmcheck.virsh_session_id).stdout
logging.debug(xml)
if check == 'sound' and '<sound model' in xml:
log_fail('Sound card should be removed')
if check == 'pcspk' and output_mode == 'libvirt' and "<sound model='pcspk'" not in xml:
log_fail('Sound card should be "pcspk"')
def check_rhsrvany_md5(vmcheck):
"""
Check if MD5 and SHA1 of rhsrvany.exe are correct
"""
logging.info('Check md5 and sha1 of rhsrvany.exe')
val_md5, val_sha1 = params.get('val_md5'), params.get('val_sha1')
logging.info('Expect MD5=%s, SHA1=%s', val_md5, val_sha1)
if not val_md5 or not val_sha1:
test.error('No MD5 or SHA1 value provided')
cmd_sha1 = params.get('cmd_sha1')
cmd_md5 = cmd_sha1 + ' MD5'
sha1 = vmcheck.session.cmd_output(
cmd_sha1, safe=True).strip().split('\n')[1].replace(' ', '')
md5 = vmcheck.session.cmd_output(
cmd_md5, safe=True).strip().split('\n')[1].replace(' ', '')
logging.info('Actual MD5=%s, SHA1=%s', md5, sha1)
if sha1 == val_sha1 and md5 == val_md5:
logging.info('MD5 and SHA1 are correct')
else:
log_fail('MD5 or SHA1 of rhsrvany.exe not correct')
def check_disk(vmcheck, count):
"""
Check if number of disks meets expectation
"""
logging.info('Expect number of disks: %d', count)
actual = vmcheck.session.cmd('lsblk |grep disk |wc -l').strip()
logging.info('Actual number of disks: %s', actual)
if int(actual) != count:
log_fail('Number of disks is wrong')
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 and checkpoint != 'vdsm':
if output_mode == 'rhev':
if not utils_v2v.import_vm_to_ovirt(
params, address_cache, timeout=v2v_timeout):
test.fail('Import VM failed')
elif 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
logging.info('Checking common checkpoints for v2v')
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")
else:
logging.info('Skip checking vm after conversion: %s' %
skip_reason)
# Check specific checkpoints
if checkpoint == 'console_xvc0':
check_grub_file(vmchecker.checker, 'console_xvc0')
if checkpoint in ('vnc_autoport', 'vnc_encrypt'):
vmchecker.check_graphics(params[checkpoint])
if checkpoint == 'sdl':
if output_mode == 'libvirt':
vmchecker.check_graphics({'type': 'vnc'})
elif output_mode == 'rhev':
vmchecker.check_graphics({'type': 'spice'})
if checkpoint == 'pv_with_regular_kernel':
check_kernel(vmchecker.checker)
if checkpoint in ['sound', 'pcspk']:
check_sound_card(vmchecker.checker, checkpoint)
if checkpoint == 'rhsrvany_md5':
check_rhsrvany_md5(vmchecker.checker)
if checkpoint == 'multidisk':
check_disk(vmchecker.checker, params['disk_count'])
log_check = utils_v2v.check_log(params, output)
if log_check:
log_fail(log_check)
# Merge 2 error lists
if params.get('vmchecker'):
error_list.extend(params['vmchecker'].errors)
# Virtio drivers will not be installed without virtio-win setup
if checkpoint == 'virtio_win_unset':
missing_list = params.get('missing').split(',')
expect_errors = ['Not find driver: ' + x for x in missing_list]
logging.debug('Expect errors: %s' % expect_errors)
logging.debug('Actual errors: %s' % error_list)
if set(error_list) == set(expect_errors):
error_list[:] = []
else:
logging.error('Virtio drivers not meet expectation')
if len(error_list):
test.fail('%d checkpoints failed: %s' %
(len(error_list), error_list))
try:
v2v_params = {
'hostname': xen_host,
'hypervisor': 'xen',
'main_vm': vm_name,
'v2v_opts': '-v -x',
'input_mode': 'libvirt',
'new_name': new_vm_name,
'password': xen_host_passwd,
'storage': params.get('output_storage', 'default'),
'network': params.get('network'),
'bridge': params.get('bridge'),
'target': params.get('target'),
'output_method': output_method,
'storage_name': storage_name,
'rhv_upload_opts': rhv_upload_opts
}
bk_xml = None
os.environ['LIBGUESTFS_BACKEND'] = 'direct'
# Setup ssh-agent access to xen hypervisor
logging.info('set up ssh-agent access ')
ssh_key.setup_ssh_key(xen_host,
user=xen_host_user,
port=22,
password=xen_host_passwd)
utils_misc.add_identities_into_ssh_agent()
if params.get('output_format'):
v2v_params.update({'output_format': params.get('output_format')})
# Build rhev related options
if output_mode == 'rhev':
# To RHV doesn't support 'qcow2' right now
v2v_params['output_format'] = 'raw'
# 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)
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)
# Create libvirt dir pool
if output_mode == 'libvirt':
pvt.pre_pool(pool_name, pool_type, pool_target, '')
uri = utils_v2v.Uri('xen').get_uri(xen_host)
# Check if xen guest exists
if not virsh.domain_exists(vm_name, uri=uri):
logging.error('VM %s not exists', vm_name)
virsh_instance = virsh.VirshPersistent()
virsh_instance.set_uri(uri)
if checkpoint in bk_list:
bk_xml = vm_xml.VMXML.new_from_inactive_dumpxml(
vm_name, virsh_instance=virsh_instance)
if checkpoint == 'guest_uuid':
uuid = virsh.domuuid(vm_name, uri=uri).stdout.strip()
v2v_params['main_vm'] = uuid
if checkpoint in ['format_convert', 'xvda_disk']:
# Get remote disk image path
blklist = virsh.domblklist(vm_name, uri=uri).stdout.split('\n')
logging.debug('domblklist %s:\n%s', vm_name, blklist)
for line in blklist:
if line.strip().startswith(('hda', 'vda', 'sda', 'xvda')):
params['remote_disk_image'] = line.split()[-1]
break
# Local path of disk image
params['img_path'] = data_dir.get_tmp_dir() + '/%s.img' % vm_name
if checkpoint == 'xvda_disk':
v2v_params['input_mode'] = 'disk'
v2v_params['hypervisor'] = 'kvm'
v2v_params.update({'input_file': params['img_path']})
# Copy remote image to local with scp
remote.scp_from_remote(xen_host, 22, xen_host_user,
xen_host_passwd,
params['remote_disk_image'],
params['img_path'])
if checkpoint == 'pool_uuid':
virsh.pool_start(pool_name)
pooluuid = virsh.pool_uuid(pool_name).stdout.strip()
v2v_params['storage'] = pooluuid
if checkpoint.startswith('vnc'):
vm_xml.VMXML.set_graphics_attr(vm_name, {'type': 'vnc'},
virsh_instance=virsh_instance)
if checkpoint == 'vnc_autoport':
params[checkpoint] = {'autoport': 'yes'}
vm_xml.VMXML.set_graphics_attr(vm_name,
params[checkpoint],
virsh_instance=virsh_instance)
elif checkpoint in ['vnc_encrypt', 'vnc_encrypt_warning']:
params[checkpoint] = {
'passwd': params.get('vnc_passwd', 'redhat')
}
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(
vm_name, virsh_instance=virsh_instance)
vm_xml.VMXML.add_security_info(vmxml,
params[checkpoint]['passwd'],
virsh_instance=virsh_instance)
logging.debug(
virsh_instance.dumpxml(vm_name, extra='--security-info'))
if checkpoint.startswith('libguestfs_backend'):
value = checkpoint[19:]
if value == 'empty':
value = ''
logging.info('Set LIBGUESTFS_BACKEND to "%s"', value)
os.environ['LIBGUESTFS_BACKEND'] = value
if checkpoint == 'same_name':
logging.info('Convert guest and rename to %s', new_vm_name)
v2v_params.update({'new_name': new_vm_name})
if checkpoint == 'no_passwordless_SSH':
logging.info('Unset $SSH_AUTH_SOCK')
os.unsetenv('SSH_AUTH_SOCK')
if checkpoint in ['xml_without_image', 'format_convert']:
xml_file = os.path.join(data_dir.get_tmp_dir(), '%s.xml' % vm_name)
virsh.dumpxml(vm_name, to_file=xml_file, uri=uri)
v2v_params['hypervisor'] = 'kvm'
v2v_params['input_mode'] = 'libvirtxml'
v2v_params.update({'input_file': xml_file})
if params.get('img_path'):
cmd = "sed -i 's|%s|%s|' %s" % (params['remote_disk_image'],
params['img_path'], xml_file)
process.run(cmd)
logging.debug(process.run('cat %s' % xml_file).stdout_text)
if checkpoint == 'ssh_banner':
session = remote.remote_login("ssh", xen_host, "22", "root",
xen_host_passwd, "#")
ssh_banner_content = r'"# no default banner path\n' \
r'#Banner /path/banner file\n' \
r'Banner /etc/ssh/ssh_banner"'
logging.info('Create ssh_banner file')
session.cmd('echo -e %s > /etc/ssh/ssh_banner' %
ssh_banner_content)
logging.info('Content of ssh_banner file:')
logging.info(session.cmd_output('cat /etc/ssh/ssh_banner'))
logging.info('Restart sshd service on xen host')
session.cmd('service sshd restart')
if checkpoint.startswith('virtio_win'):
src_dir = params.get('virtio_win_dir')
dest_dir = os.path.join(data_dir.get_tmp_dir(), 'virtio-win')
iso_path = os.path.join(dest_dir, 'virtio-win.iso')
if not os.path.exists(dest_dir):
shutil.copytree(src_dir, dest_dir)
virtio_win_env = params.get('virtio_win_env', 'VIRTIO_WIN')
process.run('rpm -e virtio-win')
if process.run('rpm -q virtio-win',
ignore_status=True).exit_status == 0:
test.error('not removed')
if checkpoint.endswith('unset'):
logging.info('Unset env %s' % virtio_win_env)
os.unsetenv(virtio_win_env)
if checkpoint.endswith('custom'):
logging.info('Set env %s=%s' % (virtio_win_env, dest_dir))
os.environ[virtio_win_env] = dest_dir
if checkpoint.endswith('iso_mount'):
logging.info('Mount iso to /opt')
process.run('mount %s /opt' % iso_path)
os.environ[virtio_win_env] = '/opt'
if checkpoint.endswith('iso_file'):
logging.info('Set env %s=%s' % (virtio_win_env, iso_path))
os.environ[virtio_win_env] = iso_path
if checkpoint == 'cdrom':
xml = vm_xml.VMXML.new_from_inactive_dumpxml(
vm_name, virsh_instance=virsh_instance)
logging.debug(xml.xmltreefile)
disks = xml.get_disk_all()
logging.debug('Disks: %r', disks)
for disk in list(disks.values()):
# Check if vm has cdrom attached
if disk.get(
'device') == 'cdrom' and disk.find('source') is None:
test.error('No CDROM image attached')
if checkpoint == 'vdsm':
extra_pkg = params.get('extra_pkg')
logging.info('Install %s', extra_pkg)
utils_package.package_install(extra_pkg.split(','))
# Backup conf file for recovery
for conf in params['bk_conf'].strip().split(','):
logging.debug('Back up %s', conf)
shutil.copyfile(conf, conf + '.bk')
logging.info('Configure libvirt for vdsm')
process.run('vdsm-tool configure --force')
logging.info('Start vdsm service')
service_manager = service.Factory.create_generic_service()
service_manager.start('vdsmd')
# Setup user and password
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 = 'localhost'
v2v_sasl.server_user = params.get('sasl_server_user', 'root')
v2v_sasl.server_pwd = params.get('sasl_server_passwd')
v2v_sasl.setup()
v2v_params['sasl_user'] = params.get("sasl_user")
v2v_params['sasl_pwd'] = params.get("sasl_pwd")
if checkpoint == 'multidisk':
params['disk_count'] = 0
blklist = virsh.domblklist(vm_name, uri=uri).stdout.split('\n')
logging.info(blklist)
for line in blklist:
if '/' in line:
params['disk_count'] += 1
logging.info('Total disks: %d', params['disk_count'])
# Check if xen guest exists again
if not virsh.domain_exists(vm_name, uri=uri):
logging.error('VM %s not exists', vm_name)
# Execute virt-v2v
v2v_result = utils_v2v.v2v_cmd(v2v_params)
if new_vm_name:
vm_name = new_vm_name
params['main_vm'] = new_vm_name
check_result(v2v_result, status_error)
finally:
# Cleanup constant files
utils_v2v.cleanup_constant_files(params)
process.run('ssh-agent -k')
if checkpoint == 'vdsm':
logging.info('Stop vdsmd')
service_manager = service.Factory.create_generic_service()
service_manager.stop('vdsmd')
if params.get('extra_pkg'):
utils_package.package_remove(params['extra_pkg'].split(','))
for conf in params['bk_conf'].strip().split(','):
if os.path.exists(conf + '.bk'):
logging.debug('Recover %s', conf)
os.remove(conf)
shutil.move(conf + '.bk', conf)
logging.info('Restart libvirtd')
libvirtd = utils_libvirtd.Libvirtd()
libvirtd.restart()
logging.info('Start network "default"')
virsh.net_start('default')
virsh.undefine(vm_name)
if params.get('vmchecker'):
params['vmchecker'].cleanup()
if output_mode == 'libvirt':
pvt.cleanup_pool(pool_name, pool_type, pool_target, '')
if bk_xml:
bk_xml.sync(virsh_instance=virsh_instance)
virsh_instance.close_session()
if checkpoint == 'ssh_banner':
logging.info('Remove ssh_banner file')
session = remote.remote_login("ssh", xen_host, "22", "root",
xen_host_passwd, "#")
session.cmd('rm -f /etc/ssh/ssh_banner')
session.cmd('service sshd restart')
if checkpoint.startswith('virtio_win'):
utils_package.package_install(['virtio-win'])
def run(test, params, env):
"""
Test mtu feature from virtual network
"""
vm_name = params.get('main_vm')
vm = env.get_vm(vm_name)
mtu_type = params.get('mtu_type')
mtu_size = params.get('mtu_size', '')
net = params.get('net', DEFAULT_NET)
net_type = params.get('net_type', '')
with_iface = 'yes' == params.get('with_iface', 'no')
with_net = 'yes' == params.get('with_net', 'no')
status_error = 'yes' == params.get('status_error', 'no')
check = params.get('check', '')
error_msg = params.get('error_msg', '')
bridge_name = 'br_mtu' + utils_misc.generate_random_string(3)
add_pkg = params.get('add_pkg', '')
model = params.get('model', 'virtio')
def set_network(size, net='default'):
"""
Set mtu size to a certain network
"""
logging.info('Set mtu size of network "%s" to %s', net, size)
default_xml = NetworkXML.new_from_net_dumpxml(net)
default_xml.mtu = size
default_xml.sync()
logging.debug(virsh.net_dumpxml(net))
def set_interface(mtu_size='',
source_network='default',
iface_type='network',
iface_model='virtio'):
"""
Set mtu size to a certain interface
"""
interface_type = 'bridge' if iface_type in (
'bridge', 'openvswitch') else iface_type
iface_dict = {
'type': interface_type,
'source': "{'%s': '%s'}" % (interface_type, source_network),
'model': iface_model
}
if iface_type == 'openvswitch':
iface_dict.update({'virtualport_type': 'openvswitch'})
if mtu_size:
iface_dict.update({'mtu': "{'size': %s}" % mtu_size})
libvirt.modify_vm_iface(vm_name, 'update_iface', iface_dict)
logging.debug(virsh.dumpxml(vm_name).stdout)
def get_default_if():
"""
Get default interface that is using by vm
"""
ifaces = utils_net.get_sorted_net_if()
logging.debug('Interfaces on host: %s', ifaces)
for iface in ifaces[0]:
if 'Link detected: yes' in process.run('ethtool %s' %
iface).stdout_text:
logging.debug('Found host interface "%s"', iface)
return iface
def create_bridge():
"""
Create a bridge on host for test
"""
cmd_create_br = 'nmcli con add type bridge con-name %s ifname %s'
con_name = 'con_' + utils_misc.generate_random_string(3)
bridge_name = 'br_' + utils_misc.generate_random_string(3)
process.run(cmd_create_br % (con_name, bridge_name), verbose=True)
return con_name, bridge_name
def create_network_xml(name, network_type, base_if='', **kwargs):
"""
Create a network xml to be defined
"""
m_net = NetworkXML(name)
m_net.forward = {'mode': 'bridge'}
if network_type in ('bridge', 'openvswitch'):
m_net.bridge = {'name': kwargs['bridge_name']}
elif network_type == 'macvtap':
if base_if:
m_net.forward_interface = [{'dev': base_if}]
if network_type == 'openvswitch':
m_net.virtualport_type = 'openvswitch'
if 'mtu' in kwargs:
m_net.mtu = kwargs['mtu']
logging.debug(m_net)
return m_net.xml
def create_iface(iface_type, **kwargs):
"""
Create a interface to be attached to vm
"""
m_iface = Interface(iface_type)
m_iface.mac_address = utils_net.generate_mac_address_simple()
if 'base_if' in kwargs:
m_iface.source = {'dev': kwargs['base_if'], 'mode': 'vepa'}
if 'source_net' in kwargs:
m_iface.source = {'network': kwargs['source_net']}
if 'mtu' in kwargs:
m_iface.mtu = {'size': kwargs['mtu']}
if 'model_net' in kwargs:
m_iface.model = kwargs['model_net']
logging.debug(m_iface.get_xml())
logging.debug(m_iface)
return m_iface
def check_mtu(mtu_size, qemu=False):
"""
Check if mtu meets expectation on host
"""
error = ''
live_vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
iface_xml = live_vmxml.get_devices('interface')[0]
logging.debug(iface_xml.target)
dev = iface_xml.target['dev']
ifconfig_info = process.run('ifconfig|grep mtu|grep %s' % dev,
shell=True,
verbose=True).stdout_text
if 'mtu %s' % mtu_size in ifconfig_info:
logging.info('PASS on ifconfig check for vnet.')
else:
error += 'Fail on ifconfig check for vnet.'
if qemu:
qemu_mtu_info = process.run('ps aux|grep qemu-kvm',
shell=True,
verbose=True).stdout_text
if 'host_mtu=%s' % mtu_size in qemu_mtu_info:
logging.info('PASS on qemu cmd line check.')
else:
error += 'Fail on qemu cmd line check.'
if error:
test.fail(error)
def check_mtu_in_vm(fn_login, mtu_size):
"""
Check if mtu meets expectations in vm
"""
session = fn_login()
check_cmd = 'ifconfig'
output = session.cmd(check_cmd)
session.close()
logging.debug(output)
if 'mtu %s' % mtu_size not in output:
test.fail('MTU check inside vm failed.')
else:
logging.debug("MTU check inside vm passed.")
try:
bk_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
bk_netxml = NetworkXML.new_from_net_dumpxml(DEFAULT_NET)
if add_pkg:
add_pkg = add_pkg.split()
if 'openvswitch' in add_pkg and shutil.which('ovs-vsctl'):
new_pkg = add_pkg.copy()
new_pkg.remove('openvswitch')
utils_package.package_install(new_pkg)
if 'openvswitch' in add_pkg:
br = 'ovsbr0' + utils_misc.generate_random_string(3)
process.run('systemctl start openvswitch.service',
shell=True,
verbose=True)
process.run('ovs-vsctl add-br %s' % br, shell=True, verbose=True)
process.run('ovs-vsctl show', shell=True, verbose=True)
if not check or check in ['save', 'managedsave', 'hotplug_save']:
# Create bridge or network and set mtu
iface_type = 'network'
if net_type in ('bridge', 'openvswitch'):
if net_type == 'bridge':
params['con_name'], br = create_bridge()
if mtu_type == 'network':
test_net = create_network_xml(bridge_name,
net_type,
bridge_name=br)
virsh.net_create(test_net, debug=True)
virsh.net_dumpxml(bridge_name, debug=True)
if mtu_type == 'interface':
iface_type = net_type
bridge_name = br
elif net_type == 'network':
if mtu_type == 'network':
set_network(mtu_size)
iface_mtu = 0
if mtu_type == 'interface':
iface_mtu = mtu_size
if mtu_type == 'network' and with_iface:
mtu_size = str(int(mtu_size) // 2)
iface_mtu = mtu_size
source_net = bridge_name if net_type in (
'bridge', 'openvswitch') else 'default'
# set mtu in vm interface
set_interface(iface_mtu,
source_network=source_net,
iface_type=iface_type,
iface_model=model)
vm.start()
vm_login = vm.wait_for_serial_login if net_type in (
'bridge', 'openvswitch') else vm.wait_for_login
vm_login().close()
check_qemu = True if mtu_type == 'interface' else False
# Test mtu after save vm
if check in ('save', 'hotplug_save'):
if check == 'hotplug_save':
iface = create_iface('network',
source_net='default',
mtu=mtu_size,
model_net=model)
params['mac'] = iface.mac_address
virsh.attach_device(vm_name, iface.xml, debug=True)
virsh.dumpxml(vm_name, debug=True)
dom_xml = vm_xml.VMXML.new_from_dumpxml(vm_name)
if params['mac'] not in str(dom_xml):
test.fail('Failed to attach interface with mtu')
save_path = os.path.join(data_dir.get_tmp_dir(),
vm_name + '.save')
virsh.save(vm_name, save_path, debug=True)
virsh.restore(save_path, debug=True)
if check == 'managedsave':
virsh.managedsave(vm_name, debug=True)
virsh.start(vm_name, debug=True)
# Check in both host and vm
check_mtu(mtu_size, check_qemu)
if mtu_type == 'interface' or with_iface:
check_mtu_in_vm(vm_login, mtu_size)
vm_login(timeout=60).close()
if check == 'hotplug_save':
virsh.detach_interface(vm_name,
'network %s' % params['mac'],
debug=True)
time.sleep(5)
dom_xml = vm_xml.VMXML.new_from_dumpxml(vm_name)
if params['mac'] in str(dom_xml):
test.fail(
'Failed to detach interface with mtu after save-restore'
)
else:
hotplug = 'yes' == params.get('hotplug', 'False')
if check == 'net_update':
result = virsh.net_update(DEFAULT_NET,
'modify',
'mtu',
'''"<mtu size='%s'/>"''' % mtu_size,
debug=True)
if check in ('macvtap', 'bridge_net', 'ovswitch_net'):
base_if = get_default_if()
macv_name = 'direct-macvtap' + utils_misc.generate_random_string(
3)
# Test mtu in different type of network
if mtu_type == 'network':
if check == 'macvtap':
test_net = create_network_xml(macv_name,
'macvtap',
base_if,
mtu=mtu_size)
if check == 'bridge_net':
params['con_name'], br = create_bridge()
test_net = create_network_xml(bridge_name,
'bridge',
mtu=mtu_size,
bridge_name=br)
if check == 'ovswitch_net':
test_net = create_network_xml(bridge_name,
'openvswitch',
mtu=mtu_size,
bridge_name=br)
if 'net_create' in params['id']:
result = virsh.net_create(test_net, debug=True)
if 'net_define' in params['id']:
result = virsh.net_define(test_net, debug=True)
# Test mtu with or without a binding network
elif mtu_type == 'interface':
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
if with_net:
test_net = create_network_xml(macv_name, 'macvtap',
base_if)
virsh.net_create(test_net, debug=True)
iface = create_iface('network',
source_net=macv_name,
mtu=mtu_size,
model_net=model)
if hotplug:
result = virsh.attach_device(vm_name,
iface.xml,
debug=True)
else:
vmxml.add_device(iface)
vmxml.sync()
result = virsh.start(vm_name)
else:
iface = create_iface('direct',
base_if=base_if,
mtu=mtu_size,
model_net=model)
if hotplug:
result = virsh.attach_device(vm_name,
iface.xml,
debug=True)
else:
vmxml.add_device(iface)
result = virsh.define(vmxml.xml, debug=True)
if check == 'invalid_val':
iface = create_iface('network',
source_net='default',
mtu=mtu_size,
model_net=model)
result = virsh.attach_device(vm_name, iface.xml, debug=True)
# Check result
libvirt.check_exit_status(result, status_error)
libvirt.check_result(result, [error_msg])
finally:
bk_xml.sync()
bk_netxml.sync()
if 'test_net' in locals():
virsh.net_destroy(bridge_name, debug=True)
if params.get('con_name'):
process.run('nmcli con del %s' % params['con_name'], verbose=True)
if add_pkg:
process.run("ovs-vsctl del-br %s" % br, verbose=True)
utils_package.package_remove(add_pkg)
def run(test, params, env):
"""
Test migration under stress.
"""
vm_names = params.get("vms").split()
if len(vm_names) < 2:
test.cancel("Provide enough vms for migration")
src_uri = "qemu:///system"
dest_uri = libvirt_vm.complete_uri(
params.get("migrate_dest_host", "EXAMPLE"))
if dest_uri.count('///') or dest_uri.count('EXAMPLE'):
test.cancel("The dest_uri '%s' is invalid" % dest_uri)
# Migrated vms' instance
vms = env.get_all_vms()
params["load_vms"] = list(vms)
cpu = int(params.get("smp", 1))
memory = int(params.get("mem")) * 1024
stress_tool = params.get("stress_tool", "")
remote_stress = params.get("migration_stress_remote", "no") == "yes"
host_stress = params.get("migration_stress_host", "no") == "yes"
vms_stress = params.get("migration_stress_vms", "no") == "yes"
vm_bytes = params.get("stress_vm_bytes", "128M")
stress_args = params.get("%s_args" % stress_tool)
migration_type = params.get("migration_type")
start_migration_vms = params.get("start_migration_vms", "yes") == "yes"
thread_timeout = int(params.get("thread_timeout", 120))
ubuntu_dep = ['build-essential', 'git']
hstress = rstress = None
vstress = {}
# Set vm_bytes for start_cmd
mem_total = utils_memory.memtotal()
vm_reserved = len(vms) * memory
if vm_bytes == "half":
vm_bytes = (mem_total - vm_reserved) / 2
elif vm_bytes == "shortage":
vm_bytes = mem_total - vm_reserved + 524288
if "vm-bytes" in stress_args:
params["%s_args" % stress_tool] = stress_args % vm_bytes
# Ensure stress tool is available in host
if host_stress:
# remove package manager installed tool to avoid conflict
if not utils_package.package_remove(stress_tool):
logging.error("Existing %s is not removed")
if "stress-ng" in stress_tool and 'Ubuntu' in utils_misc.get_distro():
params['stress-ng_dependency_packages_list'] = ubuntu_dep
try:
hstress = utils_test.HostStress(stress_tool, params)
hstress.load_stress_tool()
except utils_test.StressError as info:
test.error(info)
if remote_stress:
try:
server_ip = params['remote_ip']
server_pwd = params['remote_pwd']
server_user = params.get('remote_user', 'root')
remote_session = remote.wait_for_login('ssh', server_ip, '22',
server_user, server_pwd,
r"[\#\$]\s*$")
# remove package manager installed tool to avoid conflict
if not utils_package.package_remove(stress_tool,
session=remote_session):
logging.error("Existing %s is not removed")
if ("stess-ng" in stress_tool and 'Ubuntu'
in utils_misc.get_distro(session=remote_session)):
params['stress-ng_dependency_packages_list'] = ubuntu_dep
rstress = utils_test.HostStress(stress_tool,
params,
remote_server=True)
rstress.load_stress_tool()
remote_session.close()
except utils_test.StressError as info:
remote_session.close()
test.error(info)
for vm in vms:
# Keep vm dead for edit
if vm.is_alive():
vm.destroy()
set_cpu_memory(vm.name, cpu, memory)
try:
if start_migration_vms:
for vm in vms:
vm.start()
session = vm.wait_for_login()
# remove package manager installed tool to avoid conflict
if not utils_package.package_remove(stress_tool,
session=session):
logging.error("Existing %s is not removed")
# configure stress in VM
if vms_stress:
if ("stress-ng" in stress_tool and 'Ubuntu'
in utils_misc.get_distro(session=session)):
params[
'stress-ng_dependency_packages_list'] = ubuntu_dep
try:
vstress[vm.name] = utils_test.VMStress(
vm, stress_tool, params)
vstress[vm.name].load_stress_tool()
except utils_test.StressError as info:
session.close()
test.error(info)
session.close()
do_stress_migration(vms, src_uri, dest_uri, migration_type, test,
params, thread_timeout)
finally:
logging.debug("Cleanup vms...")
for vm in vms:
utils_test.libvirt.MigrationTest().cleanup_dest_vm(
vm, None, dest_uri)
# Try to start vms in source once vms in destination are
# cleaned up
if not vm.is_alive():
vm.start()
vm.wait_for_login()
try:
if vstress[vm.name]:
vstress[vm.name].unload_stress()
except KeyError:
continue
if rstress:
rstress.unload_stress()
if hstress:
hstress.unload_stress()
params['stress-ng_dependency_packages_list'] = ubuntu_dep
try:
hstress = utils_test.HostStress(stress_tool, params)
hstress.load_stress_tool()
except utils_test.StressError, info:
test.error(info)
if remote_stress:
try:
server_ip = params['remote_ip']
server_pwd = params['remote_pwd']
server_user = params.get('remote_user', 'root')
remote_session = remote.wait_for_login('ssh', server_ip, '22', server_user,
server_pwd, r"[\#\$]\s*$")
# remove package manager installed tool to avoid conflict
if not utils_package.package_remove(stress_tool, session=remote_session):
logging.error("Existing %s is not removed")
if("stess-ng" in stress_tool and
'Ubuntu' in utils_misc.get_distro(session=remote_session)):
params['stress-ng_dependency_packages_list'] = ubuntu_dep
rstress = utils_test.HostStress(stress_tool, params, remote_server=True)
rstress.load_stress_tool()
remote_session.close()
except utils_test.StressError, info:
remote_session.close()
test.error(info)
for vm in vms:
# Keep vm dead for edit
if vm.is_alive():
# Execute virt-v2v
v2v_result = utils_v2v.v2v_cmd(v2v_params)
if new_vm_name:
vm_name = new_vm_name
params['main_vm'] = new_vm_name
check_result(v2v_result, status_error)
finally:
process.run('ssh-agent -k')
if checkpoint == 'vdsm':
logging.info('Stop vdsmd')
service_manager = service.Factory.create_generic_service()
service_manager.stop('vdsmd')
if params.get('extra_pkg'):
utils_package.package_remove(params['extra_pkg'].split(','))
for conf in params['bk_conf'].strip().split(','):
if os.path.exists(conf + '.bk'):
logging.debug('Recover %s', conf)
os.remove(conf)
shutil.move(conf + '.bk', conf)
logging.info('Restart libvirtd')
libvirtd = utils_libvirtd.Libvirtd()
libvirtd.restart()
logging.info('Start network "default"')
virsh.net_start('default')
virsh.undefine(vm_name)
if params.get('vmchecker'):
params['vmchecker'].cleanup()
if output_mode == 'libvirt':
pvt.cleanup_pool(pool_name, pool_type, pool_target, '')
# Execute virt-v2v
v2v_result = utils_v2v.v2v_cmd(v2v_params)
if new_vm_name:
vm_name = new_vm_name
params['main_vm'] = new_vm_name
check_result(v2v_result, status_error)
finally:
process.run('ssh-agent -k')
if checkpoint == 'vdsm':
logging.info('Stop vdsmd')
service_manager = service.Factory.create_generic_service()
service_manager.stop('vdsmd')
if params.get('extra_pkg'):
utils_package.package_remove(params['extra_pkg'].split(','))
for conf in params['bk_conf'].strip().split(','):
if os.path.exists(conf + '.bk'):
logging.debug('Recover %s', conf)
os.remove(conf)
shutil.move(conf + '.bk', conf)
logging.info('Restart libvirtd')
libvirtd = utils_libvirtd.Libvirtd()
libvirtd.restart()
logging.info('Start network "default"')
virsh.net_start('default')
virsh.undefine(vm_name)
if params.get('vmchecker'):
params['vmchecker'].cleanup()
if output_mode == 'libvirt':
pvt.cleanup_pool(pool_name, pool_type, pool_target, '')
def run(test, params, env):
"""
Convert specific xen guest
"""
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.cancel('Missing command: virt-v2v')
vm_name = params.get('main_vm')
new_vm_name = params.get('new_vm_name')
xen_host = params.get('xen_hostname')
xen_host_user = params.get('xen_host_user', 'root')
xen_host_passwd = params.get('xen_host_passwd', 'redhat')
output_mode = params.get('output_mode')
v2v_timeout = int(params.get('v2v_timeout', 1200))
status_error = 'yes' == params.get('status_error', '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)
address_cache = env.get('address_cache')
checkpoint = params.get('checkpoint', '')
bk_list = ['vnc_autoport', 'vnc_encrypt', 'vnc_encrypt_warning']
error_list = []
def log_fail(msg):
"""
Log error and update error list
"""
logging.error(msg)
error_list.append(msg)
def set_graphics(virsh_instance, param):
"""
Set graphics attributes of vm xml
"""
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name, virsh_instance=virsh_instance)
graphic = vmxml.xmltreefile.find('devices').find('graphics')
for key in param:
logging.debug('Set %s=\'%s\'' % (key, param[key]))
graphic.set(key, param[key])
vmxml.sync(virsh_instance=virsh_instance)
def check_rhev_file_exist(vmcheck):
"""
Check if rhev files exist
"""
file_path = {
'rhev-apt.exe': r'C:\rhev-apt.exe',
'rhsrvany.exe': r'"C:\program files\redhat\rhev\apt\rhsrvany.exe"'
}
fail = False
for key in file_path:
status = vmcheck.session.cmd_status('dir %s' % file_path[key])
if not status:
logging.error('%s exists' % key)
fail = True
if fail:
log_fail('RHEV file exists after convert to kvm')
def check_grub_file(vmcheck, check):
"""
Check grub file content
"""
logging.info('Checking grub file')
grub_file = utils_misc.get_bootloader_cfg(session=vmcheck.session)
if not grub_file:
test.error('Not found grub file')
content = vmcheck.session.cmd('cat %s' % grub_file)
if check == 'console_xvc0':
if 'console=xvc0' in content:
log_fail('"console=xvc0" still exists')
def check_kernel(vmcheck):
"""
Check content of /etc/sysconfig/kernel
"""
logging.info('Checking /etc/sysconfig/kernel file')
content = vmcheck.session.cmd('cat /etc/sysconfig/kernel')
logging.debug(content)
if 'DEFAULTKERNEL=kernel' not in content:
log_fail('Not find "DEFAULTKERNEL=kernel"')
elif 'DEFAULTKERNEL=kernel-xen' in content:
log_fail('DEFAULTKERNEL is "kernel-xen"')
def check_sound_card(vmcheck, check):
"""
Check sound status of vm from xml
"""
xml = virsh.dumpxml(vm_name, session_id=vmcheck.virsh_session_id).stdout
logging.debug(xml)
if check == 'sound' and '<sound model' in xml:
log_fail('Sound card should be removed')
if check == 'pcspk' and "<sound model='pcspk'" not in xml:
log_fail('Sound card should be "pcspk"')
def check_rhsrvany_md5(vmcheck):
"""
Check if MD5 and SHA1 of rhsrvany.exe are correct
"""
logging.info('Check md5 and sha1 of rhsrvany.exe')
val_md5, val_sha1 = params.get('val_md5'), params.get('val_sha1')
logging.info('Expect MD5=%s, SHA1=%s', val_md5, val_sha1)
if not val_md5 or not val_sha1:
test.error('No MD5 or SHA1 value provided')
cmd_sha1 = params.get('cmd_sha1')
cmd_md5 = cmd_sha1 + ' MD5'
sha1 = vmcheck.session.cmd_output(cmd_sha1, safe=True).strip().split('\n')[1].replace(' ', '')
md5 = vmcheck.session.cmd_output(cmd_md5, safe=True).strip().split('\n')[1].replace(' ', '')
logging.info('Actual MD5=%s, SHA1=%s', md5, sha1)
if sha1 == val_sha1 and md5 == val_md5:
logging.info('MD5 and SHA1 are correct')
else:
log_fail('MD5 or SHA1 of rhsrvany.exe not correct')
def check_disk(vmcheck, count):
"""
Check if number of disks meets expectation
"""
logging.info('Expect number of disks: %d', count)
actual = vmcheck.session.cmd('lsblk |grep disk |wc -l').strip()
logging.info('Actual number of disks: %s', actual)
if int(actual) != count:
log_fail('Number of disks is wrong')
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 and checkpoint != 'vdsm':
if output_mode == 'rhev':
if not utils_v2v.import_vm_to_ovirt(params, address_cache,
timeout=v2v_timeout):
test.fail('Import VM failed')
elif 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
logging.info('Checking common checkpoints for v2v')
vmchecker = VMChecker(test, params, env)
params['vmchecker'] = vmchecker
ret = vmchecker.run()
if len(ret) == 0:
logging.info("All common checkpoints passed")
# Check specific checkpoints
if checkpoint == 'rhev_file':
check_rhev_file_exist(vmchecker.checker)
if checkpoint == 'console_xvc0':
check_grub_file(vmchecker.checker, 'console_xvc0')
if checkpoint in ('vnc_autoport', 'vnc_encrypt'):
vmchecker.check_graphics(params[checkpoint])
if checkpoint == 'sdl':
if output_mode == 'libvirt':
vmchecker.check_graphics({'type': 'vnc'})
elif output_mode == 'rhev':
vmchecker.check_graphics({'type': 'spice'})
if checkpoint == 'pv_with_regular_kernel':
check_kernel(vmchecker.checker)
if checkpoint in ['sound', 'pcspk']:
check_sound_card(vmchecker.checker, checkpoint)
if checkpoint == 'rhsrvany_md5':
check_rhsrvany_md5(vmchecker.checker)
if checkpoint == 'multidisk':
check_disk(vmchecker.checker, params['disk_count'])
log_check = utils_v2v.check_log(params, output)
if log_check:
log_fail(log_check)
# Merge 2 error lists
if params.get('vmchecker'):
error_list.extend(params['vmchecker'].errors)
# Virtio drivers will not be installed without virtio-win setup
if checkpoint == 'virtio_win_unset':
missing_list = params.get('missing').split(',')
expect_errors = ['Not find driver: ' + x for x in missing_list]
logging.debug('Expect errors: %s' % expect_errors)
logging.debug('Actual errors: %s' % error_list)
if set(error_list) == set(expect_errors):
error_list[:] = []
else:
logging.error('Virtio drivers not meet expectation')
if len(error_list):
test.fail('%d checkpoints failed: %s' % (len(error_list), error_list))
try:
v2v_params = {
'hostname': xen_host, 'hypervisor': 'xen', 'main_vm': vm_name,
'v2v_opts': '-v -x', 'input_mode': 'libvirt',
'new_name': new_vm_name,
'storage': params.get('output_storage', 'default'),
'network': params.get('network'),
'bridge': params.get('bridge'),
'target': params.get('target')
}
bk_xml = None
os.environ['LIBGUESTFS_BACKEND'] = 'direct'
# Setup ssh-agent access to xen hypervisor
logging.info('set up ssh-agent access ')
ssh_key.setup_ssh_key(xen_host, user=xen_host_user,
port=22, password=xen_host_passwd)
utils_misc.add_identities_into_ssh_agent()
if params.get('output_format'):
v2v_params.update({'output_format': params.get('output_format')})
# 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)
# Create libvirt dir pool
if output_mode == 'libvirt':
pvt.pre_pool(pool_name, pool_type, pool_target, '')
uri = utils_v2v.Uri('xen').get_uri(xen_host)
# Check if xen guest exists
if not virsh.domain_exists(vm_name, uri=uri):
logging.error('VM %s not exists', vm_name)
virsh_instance = virsh.VirshPersistent()
virsh_instance.set_uri(uri)
if checkpoint in bk_list:
bk_xml = vm_xml.VMXML.new_from_inactive_dumpxml(
vm_name, virsh_instance=virsh_instance)
if checkpoint == 'guest_uuid':
uuid = virsh.domuuid(vm_name, uri=uri).stdout.strip()
v2v_params['main_vm'] = uuid
if checkpoint in ['format_convert', 'xvda_disk']:
# Get remote disk image path
blklist = virsh.domblklist(vm_name, uri=uri).stdout.split('\n')
logging.debug('domblklist %s:\n%s', vm_name, blklist)
for line in blklist:
if line.startswith(('hda', 'vda', 'sda')):
params['remote_disk_image'] = line.split()[-1]
break
# Local path of disk image
params['img_path'] = data_dir.get_tmp_dir() + '/%s.img' % vm_name
if checkpoint == 'xvda_disk':
v2v_params['input_mode'] = 'disk'
v2v_params.update({'input_file': params['img_path']})
# Copy remote image to local with scp
remote.scp_from_remote(xen_host, 22, xen_host_user,
xen_host_passwd,
params['remote_disk_image'],
params['img_path'])
if checkpoint == 'pool_uuid':
virsh.pool_start(pool_name)
pooluuid = virsh.pool_uuid(pool_name).stdout.strip()
v2v_params['storage'] = pooluuid
if checkpoint.startswith('vnc'):
vm_xml.VMXML.set_graphics_attr(vm_name, {'type': 'vnc'},
virsh_instance=virsh_instance)
if checkpoint == 'vnc_autoport':
params[checkpoint] = {'autoport': 'yes'}
vm_xml.VMXML.set_graphics_attr(vm_name, params[checkpoint],
virsh_instance=virsh_instance)
elif checkpoint in ['vnc_encrypt', 'vnc_encrypt_warning']:
params[checkpoint] = {'passwd': params.get('vnc_passwd', 'redhat')}
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(
vm_name, virsh_instance=virsh_instance)
vm_xml.VMXML.add_security_info(
vmxml, params[checkpoint]['passwd'],
virsh_instance=virsh_instance)
logging.debug(virsh_instance.dumpxml(vm_name, extra='--security-info'))
if checkpoint.startswith('libguestfs_backend'):
value = checkpoint[19:]
if value == 'empty':
value = ''
logging.info('Set LIBGUESTFS_BACKEND to "%s"', value)
os.environ['LIBGUESTFS_BACKEND'] = value
if checkpoint == 'same_name':
logging.info('Convert guest and rename to %s', new_vm_name)
v2v_params.update({'new_name': new_vm_name})
if checkpoint == 'no_passwordless_SSH':
logging.info('Unset $SSH_AUTH_SOCK')
os.unsetenv('SSH_AUTH_SOCK')
if checkpoint in ['xml_without_image', 'format_convert']:
xml_file = os.path.join(data_dir.get_tmp_dir(), '%s.xml' % vm_name)
virsh.dumpxml(vm_name, to_file=xml_file, uri=uri)
v2v_params['hypervisor'] = 'kvm'
v2v_params['input_mode'] = 'libvirtxml'
v2v_params.update({'input_file': xml_file})
if params.get('img_path'):
cmd = "sed -i 's|%s|%s|' %s" % (params['remote_disk_image'],
params['img_path'], xml_file)
process.run(cmd)
logging.debug(process.run('cat %s' % xml_file).stdout_text)
if checkpoint == 'format_convert':
v2v_params['output_format'] = 'qcow2'
if checkpoint == 'ssh_banner':
session = remote.remote_login("ssh", xen_host, "22", "root",
xen_host_passwd, "#")
ssh_banner_content = r'"# no default banner path\n' \
r'#Banner /path/banner file\n' \
r'Banner /etc/ssh/ssh_banner"'
logging.info('Create ssh_banner file')
session.cmd('echo -e %s > /etc/ssh/ssh_banner' % ssh_banner_content)
logging.info('Content of ssh_banner file:')
logging.info(session.cmd_output('cat /etc/ssh/ssh_banner'))
logging.info('Restart sshd service on xen host')
session.cmd('service sshd restart')
if checkpoint.startswith('virtio_win'):
src_dir = params.get('virtio_win_dir')
dest_dir = os.path.join(data_dir.get_tmp_dir(), 'virtio-win')
iso_path = os.path.join(dest_dir, 'virtio-win.iso')
if not os.path.exists(dest_dir):
shutil.copytree(src_dir, dest_dir)
virtio_win_env = params.get('virtio_win_env', 'VIRTIO_WIN')
process.run('rpm -e virtio-win')
if process.run('rpm -q virtio-win', ignore_status=True).exit_status == 0:
test.error('not removed')
if checkpoint.endswith('unset'):
logging.info('Unset env %s' % virtio_win_env)
os.unsetenv(virtio_win_env)
if checkpoint.endswith('custom'):
logging.info('Set env %s=%s' % (virtio_win_env, dest_dir))
os.environ[virtio_win_env] = dest_dir
if checkpoint.endswith('iso_mount'):
logging.info('Mount iso to /opt')
process.run('mount %s /opt' % iso_path)
os.environ[virtio_win_env] = '/opt'
if checkpoint.endswith('iso_file'):
logging.info('Set env %s=%s' % (virtio_win_env, iso_path))
os.environ[virtio_win_env] = iso_path
if checkpoint == 'cdrom':
xml = vm_xml.VMXML.new_from_inactive_dumpxml(
vm_name, virsh_instance=virsh_instance)
logging.debug(xml.xmltreefile)
disks = xml.get_disk_all()
logging.debug('Disks: %r', disks)
for disk in list(disks.values()):
# Check if vm has cdrom attached
if disk.get('device') == 'cdrom' and disk.find('source') is None:
test.error('No CDROM image attached')
if checkpoint == 'vdsm':
extra_pkg = params.get('extra_pkg')
logging.info('Install %s', extra_pkg)
utils_package.package_install(extra_pkg.split(','))
# Backup conf file for recovery
for conf in params['bk_conf'].strip().split(','):
logging.debug('Back up %s', conf)
shutil.copyfile(conf, conf + '.bk')
logging.info('Configure libvirt for vdsm')
process.run('vdsm-tool configure --force')
logging.info('Start vdsm service')
service_manager = service.Factory.create_generic_service()
service_manager.start('vdsmd')
# Setup user and password
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 = 'localhost'
v2v_sasl.server_user = params.get('sasl_server_user', 'root')
v2v_sasl.server_pwd = params.get('sasl_server_passwd')
v2v_sasl.setup()
v2v_params['sasl_user'] = params.get("sasl_user")
v2v_params['sasl_pwd'] = params.get("sasl_pwd")
if checkpoint == 'multidisk':
params['disk_count'] = 0
blklist = virsh.domblklist(vm_name, uri=uri).stdout.split('\n')
logging.info(blklist)
for line in blklist:
if '/' in line:
params['disk_count'] += 1
logging.info('Total disks: %d', params['disk_count'])
# Check if xen guest exists again
if not virsh.domain_exists(vm_name, uri=uri):
logging.error('VM %s not exists', vm_name)
# Execute virt-v2v
v2v_result = utils_v2v.v2v_cmd(v2v_params)
if new_vm_name:
vm_name = new_vm_name
params['main_vm'] = new_vm_name
check_result(v2v_result, status_error)
finally:
process.run('ssh-agent -k')
if checkpoint == 'vdsm':
logging.info('Stop vdsmd')
service_manager = service.Factory.create_generic_service()
service_manager.stop('vdsmd')
if params.get('extra_pkg'):
utils_package.package_remove(params['extra_pkg'].split(','))
for conf in params['bk_conf'].strip().split(','):
if os.path.exists(conf + '.bk'):
logging.debug('Recover %s', conf)
os.remove(conf)
shutil.move(conf + '.bk', conf)
logging.info('Restart libvirtd')
libvirtd = utils_libvirtd.Libvirtd()
libvirtd.restart()
logging.info('Start network "default"')
virsh.net_start('default')
virsh.undefine(vm_name)
if params.get('vmchecker'):
params['vmchecker'].cleanup()
if output_mode == 'libvirt':
pvt.cleanup_pool(pool_name, pool_type, pool_target, '')
if bk_xml:
bk_xml.sync(virsh_instance=virsh_instance)
virsh_instance.close_session()
if checkpoint == 'ssh_banner':
logging.info('Remove ssh_banner file')
session = remote.remote_login("ssh", xen_host, "22", "root",
xen_host_passwd, "#")
session.cmd('rm -f /etc/ssh/ssh_banner')
session.cmd('service sshd restart')
if checkpoint.startswith('virtio_win'):
utils_package.package_install(['virtio-win'])
def run(test, params, env):
"""
Test send-key command, include all types of codeset and sysrq
For normal sendkey test, we create a file to check the command
execute by send-key. For sysrq test, check the /var/log/messages
in RHEL or /var/log/syslog in Ubuntu and guest status
"""
if not virsh.has_help_command('send-key'):
test.cancel("This version of libvirt does not support the send-key "
"test")
vm_name = params.get("main_vm", "avocado-vt-vm1")
status_error = ("yes" == params.get("status_error", "no"))
keystrokes = params.get("sendkey", "")
codeset = params.get("codeset", "")
holdtime = params.get("holdtime", "")
hold_timeout = eval(params.get("hold_timeout", "1"))
sysrq_test = ("yes" == params.get("sendkey_sysrq", "no"))
sleep_time = int(params.get("sendkey_sleeptime", 5))
readonly = params.get("readonly", False)
username = params.get("username")
password = params.get("password")
create_file = params.get("create_file_name")
uri = params.get("virsh_uri")
simultaneous = params.get("sendkey_simultaneous", "yes") == "yes"
unprivileged_user = params.get('unprivileged_user')
is_crash = ("yes" == params.get("is_crash", "no"))
add_panic_device = ("yes" == params.get("add_panic_device", "yes"))
need_keyboard_device = ("yes" == params.get("need_keyboard_device", "yes"))
panic_model = params.get('panic_model', 'isa')
force_vm_boot_text_mode = ("yes" == params.get("force_vm_boot_text_mode",
"yes"))
crash_dir = "/var/crash"
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 send_line(send_str):
"""
send string to guest with send-key and end with Enter
"""
for send_ch in list(send_str):
virsh.sendkey(vm_name,
"KEY_%s" % send_ch.upper(),
ignore_status=False)
virsh.sendkey(vm_name, "KEY_ENTER", ignore_status=False)
def add_keyboard_device(vm_name):
"""
Add keyboard to guest if guest doesn't have
:params: vm_name: the guest name
"""
inputs = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)\
.get_devices(device_type="input")
for input_device in inputs:
if input_device.type_name == "keyboard":
logging.debug("Guest already has a keyboard device")
return
kbd = Input("keyboard")
kbd.input_bus = "virtio"
logging.debug("Add keyboard device %s" % kbd)
result = virsh.attach_device(vm_name, kbd.xml)
if result.exit_status:
test.error("Failed to add keyboard device")
vm = env.get_vm(vm_name)
# Part of sysrq tests need keyboard device otherwise the sysrq cmd doesn't
# work. Refer to BZ#1526862
if need_keyboard_device:
add_keyboard_device(vm_name)
vmxml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
vm.wait_for_login().close()
if force_vm_boot_text_mode:
# Boot the guest in text only mode so that send-key commands would succeed
# in creating a file
try:
utils_test.update_boot_option(
vm, args_added="3", guest_arch_name=params.get('vm_arch_name'))
except Exception as info:
test.error(info)
session = vm.wait_for_login()
if sysrq_test:
# In postprocess of previous testcase would pause and resume the VM
# that would change the domstate to running (unpaused) and cause
# sysrq reboot testcase to fail as the domstate persist across reboot
# so it is better to destroy and start VM before the test starts
if "KEY_B" in keystrokes:
cmd_result = virsh.domstate(vm_name,
'--reason',
ignore_status=True)
if "unpaused" in cmd_result.stdout.strip():
vm.destroy()
vm.start()
session = vm.wait_for_login()
if is_crash:
session.cmd("rm -rf {0}; mkdir {0}".format(crash_dir))
libvirt.update_on_crash(vm_name, "destroy")
if add_panic_device:
libvirt.add_panic_device(vm_name, model=panic_model)
if not vm.is_alive():
vm.start()
session = vm.wait_for_login()
LOG_FILE = "/var/log/messages"
if "ubuntu" in vm.get_distro().lower():
LOG_FILE = "/var/log/syslog"
# Is 'rsyslog' installed on guest? It'll be what writes out
# to LOG_FILE
if not utils_package.package_install("rsyslog", session):
test.fail("Fail to install rsyslog, make sure that you have "
"usable repo in guest")
# clear messages, restart rsyslog, and make sure it's running
session.cmd("echo '' > %s" % LOG_FILE)
# check the result of restart rsyslog
status, output = session.cmd_status_output("service rsyslog restart")
if status:
# To avoid 'Exec format error'
utils_package.package_remove("rsyslog", session)
utils_package.package_install("rsyslog", session)
# if rsyslog.service is masked, need to unmask rsyslog
if "Unit rsyslog.service is masked" in output:
session.cmd("systemctl unmask rsyslog")
session.cmd("echo '' > %s" % LOG_FILE)
session.cmd("service rsyslog restart")
ps_stat = session.cmd_status("ps aux |grep rsyslog")
if ps_stat != 0:
test.fail("rsyslog is not running in guest")
# enable sysrq
session.cmd("echo 1 > /proc/sys/kernel/sysrq")
# make sure the environment is clear
if create_file is not None:
session.cmd("rm -rf %s" % create_file)
try:
# wait for tty started
tty_stat = "ps aux|grep tty"
timeout = 60
while timeout >= 0 and \
session.get_command_status(tty_stat) != 0:
time.sleep(1)
timeout = timeout - 1
if timeout < 0:
test.fail("Can not wait for tty started in 60s")
# send user and passwd to guest to login
send_line(username)
time.sleep(2)
send_line(password)
time.sleep(2)
if sysrq_test or simultaneous:
output = virsh.sendkey(vm_name,
keystrokes,
codeset=codeset,
holdtime=holdtime,
readonly=readonly,
unprivileged_user=unprivileged_user,
uri=uri)
else:
# If multiple keycodes are specified, they are all sent
# simultaneously to the guest, and they may be received
# in random order. If you need distinct keypresses, you
# must use multiple send-key invocations.
for keystroke in keystrokes.split():
output = virsh.sendkey(vm_name,
keystroke,
codeset=codeset,
holdtime=holdtime,
readonly=readonly,
unprivileged_user=unprivileged_user,
uri=uri)
if output.exit_status:
test.fail("Failed to send key %s to guest: %s" %
(keystroke, output.stderr))
time.sleep(sleep_time)
if output.exit_status != 0:
if status_error:
logging.info(
"Failed to sendkey to guest as expected, Error:"
"%s.", output.stderr)
return
else:
test.fail("Failed to send key to guest, Error:%s." %
output.stderr)
elif status_error:
test.fail("Expect fail, but succeed indeed.")
if create_file is not None:
# check if created file exist
cmd_ls = "ls %s" % create_file
if not wait.wait_for(
lambda: session.get_command_status_output(cmd_ls),
hold_timeout,
step=5):
test.fail("Fail to create file with send key")
logging.info("Succeed to create file with send key")
elif sysrq_test:
# check LOG_FILE info according to different key
# Since there's no guarantee when messages will be written
# we'll do a check and wait loop for up to 60 seconds
timeout = 60
while timeout >= 0:
if "KEY_H" in keystrokes:
cmd = "cat %s | grep -i 'SysRq.*HELP'" % LOG_FILE
get_status = session.cmd_status(cmd)
elif "KEY_M" in keystrokes:
cmd = "cat %s | grep -i 'SysRq.*Show Memory'" % LOG_FILE
get_status = session.cmd_status(cmd)
elif "KEY_T" in keystrokes:
cmd = "cat %s | grep -i 'SysRq.*Show State'" % LOG_FILE
get_status = session.cmd_status(cmd)
# Sometimes SysRq.*Show State string missed in LOG_FILE
# as a fall back check for runnable tasks logged
if get_status != 0:
cmd = "cat %s | grep 'runnable tasks:'" % LOG_FILE
get_status = session.cmd_status(cmd)
elif "KEY_B" in keystrokes:
session = vm.wait_for_login()
result = virsh.domstate(vm_name,
'--reason',
ignore_status=True)
output = result.stdout.strip()
logging.debug("The guest state: %s", output)
if not output.count("booted"):
get_status = 1
else:
get_status = 0
session.close()
# crash
elif is_crash:
dom_state = virsh.domstate(vm_name,
"--reason").stdout.strip()
logging.debug("domain state is %s" % dom_state)
if "crashed" in dom_state:
get_status = 0
else:
get_status = 1
if get_status == 0:
timeout = -1
else:
if not is_crash:
session.cmd("echo \"virsh sendkey waiting\" >> %s" %
LOG_FILE)
time.sleep(1)
timeout = timeout - 1
if get_status != 0:
test.fail("SysRq does not take effect in guest, keystrokes is "
"%s" % keystrokes)
else:
logging.info("Succeed to send SysRq command")
else:
test.fail("Test cfg file invalid: either sysrq_params or "
"create_file_name must be defined")
finally:
if create_file is not None:
session = vm.wait_for_login()
session.cmd("rm -rf %s" % create_file)
session.close()
vmxml_backup.sync()
def run(test, params, env):
"""
Test mtu feature from virtual network
"""
vm_name = params.get('main_vm')
vm = env.get_vm(vm_name)
mtu_type = params.get('mtu_type')
mtu_size = params.get('mtu_size', '')
net = params.get('net', DEFAULT_NET)
net_type = params.get('net_type', '')
with_iface = 'yes' == params.get('with_iface', 'no')
with_net = 'yes' == params.get('with_net', 'no')
status_error = 'yes' == params.get('status_error', 'no')
check = params.get('check', '')
error_msg = params.get('error_msg', '')
bridge_name = 'br_mtu' + utils_misc.generate_random_string(3)
add_pkg = params.get('add_pkg', '')
model = params.get('model', 'virtio')
def set_network(size, net='default'):
"""
Set mtu size to a certain network
"""
logging.info('Set mtu size of network "%s" to %s', net, size)
default_xml = NetworkXML.new_from_net_dumpxml(net)
default_xml.mtu = size
default_xml.sync()
logging.debug(virsh.net_dumpxml(net))
def set_interface(mtu_size='', source_network='default',
iface_type='network', iface_model='virtio'):
"""
Set mtu size to a certain interface
"""
interface_type = 'bridge' if iface_type in ('bridge', 'openvswitch') else iface_type
iface_dict = {
'type': interface_type,
'source': "{'%s': '%s'}" % (interface_type, source_network),
'model': iface_model
}
if iface_type == 'openvswitch':
iface_dict.update({'virtualport_type': 'openvswitch'})
if mtu_size:
iface_dict.update({'mtu': "{'size': %s}" % mtu_size})
libvirt.modify_vm_iface(vm_name, 'update_iface', iface_dict)
logging.debug(virsh.dumpxml(vm_name).stdout)
def get_default_if():
"""
Get default interface that is using by vm
"""
ifaces = utils_net.get_sorted_net_if()
logging.debug('Interfaces on host: %s', ifaces)
for iface in ifaces[0]:
if 'Link detected: yes' in process.run('ethtool %s' % iface).stdout_text:
logging.debug('Found host interface "%s"', iface)
return iface
def create_bridge():
"""
Create a bridge on host for test
"""
cmd_create_br = 'nmcli con add type bridge con-name %s ifname %s'
con_name = 'con_' + utils_misc.generate_random_string(3)
bridge_name = 'br_' + utils_misc.generate_random_string(3)
process.run(cmd_create_br % (con_name, bridge_name), verbose=True)
return con_name, bridge_name
def create_network_xml(name, network_type, base_if='', **kwargs):
"""
Create a network xml to be defined
"""
m_net = NetworkXML(name)
m_net.forward = {'mode': 'bridge'}
if network_type in ('bridge', 'openvswitch'):
m_net.bridge = {'name': kwargs['bridge_name']}
elif network_type == 'macvtap':
if base_if:
m_net.forward_interface = [{'dev': base_if}]
if network_type == 'openvswitch':
m_net.virtualport_type = 'openvswitch'
if 'mtu' in kwargs:
m_net.mtu = kwargs['mtu']
logging.debug(m_net)
return m_net.xml
def create_iface(iface_type, **kwargs):
"""
Create a interface to be attached to vm
"""
m_iface = Interface(iface_type)
m_iface.mac_address = utils_net.generate_mac_address_simple()
if 'base_if' in kwargs:
m_iface.source = {'dev': kwargs['base_if'],
'mode': 'vepa'}
if 'source_net' in kwargs:
m_iface.source = {'network': kwargs['source_net']}
if 'mtu' in kwargs:
m_iface.mtu = {'size': kwargs['mtu']}
if 'model_net' in kwargs:
m_iface.model = kwargs['model_net']
logging.debug(m_iface.get_xml())
logging.debug(m_iface)
return m_iface
def check_mtu(mtu_size, qemu=False):
"""
Check if mtu meets expectation on host
"""
error = ''
live_vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
iface_xml = live_vmxml.get_devices('interface')[0]
logging.debug(iface_xml.target)
dev = iface_xml.target['dev']
ifconfig_info = process.run('ifconfig|grep mtu|grep %s' % dev,
shell=True, verbose=True).stdout_text
if 'mtu %s' % mtu_size in ifconfig_info:
logging.info('PASS on ifconfig check for vnet.')
else:
error += 'Fail on ifconfig check for vnet.'
if qemu:
qemu_mtu_info = process.run('ps aux|grep qemu-kvm',
shell=True, verbose=True).stdout_text
if 'host_mtu=%s' % mtu_size in qemu_mtu_info:
logging.info('PASS on qemu cmd line check.')
else:
error += 'Fail on qemu cmd line check.'
if error:
test.fail(error)
def check_mtu_in_vm(fn_login, mtu_size):
"""
Check if mtu meets expectations in vm
"""
session = fn_login()
check_cmd = 'ifconfig'
output = session.cmd(check_cmd)
session.close()
logging.debug(output)
if 'mtu %s' % mtu_size not in output:
test.fail('MTU check inside vm failed.')
else:
logging.debug("MTU check inside vm passed.")
try:
bk_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
bk_netxml = NetworkXML.new_from_net_dumpxml(DEFAULT_NET)
if add_pkg:
add_pkg = add_pkg.split()
utils_package.package_install(add_pkg)
if 'openvswitch' in add_pkg:
br = 'ovsbr0' + utils_misc.generate_random_string(3)
process.run('systemctl start openvswitch.service', shell=True, verbose=True)
process.run('ovs-vsctl add-br %s' % br, shell=True, verbose=True)
process.run('ovs-vsctl show', shell=True, verbose=True)
if not check or check in ['save', 'managedsave', 'hotplug_save']:
# Create bridge or network and set mtu
iface_type = 'network'
if net_type in ('bridge', 'openvswitch'):
if net_type == 'bridge':
params['con_name'], br = create_bridge()
if mtu_type == 'network':
test_net = create_network_xml(
bridge_name, net_type,
bridge_name=br
)
virsh.net_create(test_net, debug=True)
virsh.net_dumpxml(bridge_name, debug=True)
if mtu_type == 'interface':
iface_type = net_type
bridge_name = br
elif net_type == 'network':
if mtu_type == 'network':
set_network(mtu_size)
iface_mtu = 0
if mtu_type == 'interface':
iface_mtu = mtu_size
if mtu_type == 'network' and with_iface:
mtu_size = str(int(mtu_size)//2)
iface_mtu = mtu_size
source_net = bridge_name if net_type in ('bridge', 'openvswitch') else 'default'
# set mtu in vm interface
set_interface(iface_mtu, source_network=source_net, iface_type=iface_type, iface_model=model)
vm.start()
vm_login = vm.wait_for_serial_login if net_type in ('bridge', 'openvswitch') else vm.wait_for_login
vm_login().close()
check_qemu = True if mtu_type == 'interface' else False
# Test mtu after save vm
if check in ('save', 'hotplug_save'):
if check == 'hotplug_save':
iface = create_iface('network', source_net='default',
mtu=mtu_size, model_net=model)
params['mac'] = iface.mac_address
virsh.attach_device(vm_name, iface.xml, debug=True)
virsh.dumpxml(vm_name, debug=True)
dom_xml = vm_xml.VMXML.new_from_dumpxml(vm_name)
if params['mac'] not in str(dom_xml):
test.fail('Failed to attach interface with mtu')
save_path = os.path.join(data_dir.get_tmp_dir(), vm_name + '.save')
virsh.save(vm_name, save_path, debug=True)
virsh.restore(save_path, debug=True)
if check == 'managedsave':
virsh.managedsave(vm_name, debug=True)
virsh.start(vm_name, debug=True)
# Check in both host and vm
check_mtu(mtu_size, check_qemu)
check_mtu_in_vm(vm_login, mtu_size)
vm_login(timeout=60).close()
if check == 'hotplug_save':
virsh.detach_interface(vm_name, 'network %s' % params['mac'], debug=True)
time.sleep(5)
dom_xml = vm_xml.VMXML.new_from_dumpxml(vm_name)
if params['mac'] in str(dom_xml):
test.fail('Failed to detach interface with mtu after save-restore')
else:
hotplug = 'yes' == params.get('hotplug', 'False')
if check == 'net_update':
result = virsh.net_update(
DEFAULT_NET, 'modify', 'mtu',
'''"<mtu size='%s'/>"''' % mtu_size,
debug=True
)
if check in ('macvtap', 'bridge_net', 'ovswitch_net'):
base_if = get_default_if()
macv_name = 'direct-macvtap' + utils_misc.generate_random_string(3)
# Test mtu in different type of network
if mtu_type == 'network':
if check == 'macvtap':
test_net = create_network_xml(macv_name, 'macvtap',
base_if, mtu=mtu_size)
if check == 'bridge_net':
params['con_name'], br = create_bridge()
test_net = create_network_xml(
bridge_name, 'bridge', mtu=mtu_size,
bridge_name=br
)
if check == 'ovswitch_net':
test_net = create_network_xml(
bridge_name, 'openvswitch', mtu=mtu_size,
bridge_name=br
)
if 'net_create' in params['id']:
result = virsh.net_create(test_net, debug=True)
if 'net_define' in params['id']:
result = virsh.net_define(test_net, debug=True)
# Test mtu with or without a binding network
elif mtu_type == 'interface':
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
if with_net:
test_net = create_network_xml(macv_name, 'macvtap', base_if)
virsh.net_create(test_net, debug=True)
iface = create_iface('network', source_net=macv_name, mtu=mtu_size)
if hotplug:
result = virsh.attach_device(vm_name, iface.xml, debug=True)
else:
vmxml.add_device(iface)
vmxml.sync()
result = virsh.start(vm_name)
else:
iface = create_iface('direct', base_if=base_if, mtu=mtu_size)
if hotplug:
result = virsh.attach_device(vm_name, iface.xml, debug=True)
else:
vmxml.add_device(iface)
result = virsh.define(vmxml.xml, debug=True)
if check == 'invalid_val':
iface = create_iface('network', source_net='default', mtu=mtu_size)
result = virsh.attach_device(vm_name, iface.xml, debug=True)
# Check result
libvirt.check_exit_status(result, status_error)
libvirt.check_result(result, [error_msg])
finally:
bk_xml.sync()
bk_netxml.sync()
if 'test_net' in locals():
virsh.net_destroy(bridge_name, debug=True)
if params.get('con_name'):
process.run('nmcli con del %s' % params['con_name'], verbose=True)
if add_pkg:
process.run("ovs-vsctl del-br %s" % br, verbose=True)
utils_package.package_remove(add_pkg)
params['stress-ng_dependency_packages_list'] = ubuntu_dep
try:
hstress = utils_test.HostStress(stress_tool, params)
hstress.load_stress_tool()
except utils_test.StressError, info:
test.error(info)
if remote_stress:
try:
server_ip = params['remote_ip']
server_pwd = params['remote_pwd']
server_user = params.get('remote_user', 'root')
remote_session = remote.wait_for_login('ssh', server_ip, '22', server_user,
server_pwd, r"[\#\$]\s*$")
# remove package manager installed tool to avoid conflict
if not utils_package.package_remove(stress_tool, session=remote_session):
logging.error("Existing %s is not removed")
if("stess-ng" in stress_tool and
'Ubuntu' in utils_misc.get_distro(session=remote_session)):
params['stress-ng_dependency_packages_list'] = ubuntu_dep
rstress = utils_test.HostStress(stress_tool, params, remote_server=True)
rstress.load_stress_tool()
remote_session.close()
except utils_test.StressError, info:
remote_session.close()
test.error(info)
for vm in vms:
# Keep vm dead for edit
if vm.is_alive():
