def nfs_disconnected(params):
"""
Drop nfs connection by iptables
"""
service_mgr = avocado_service.ServiceManager()
service_mgr.start('iptables')
Iptables.setup_or_cleanup_iptables_rules([params.get("iptable_rule")])
def _scylla_service_is_up(self):
srv_manager = service.ServiceManager()
try:
journalctl_cmd = path.find_command('journalctl')
timestamp = '--since "%s"' % self.start_time if self.start_time else ''
result = process.run('sudo %s --no-tail '
'-u scylla-io-setup.service '
'-u scylla-server.service '
'-u scylla-ami-setup.service '
'-u scylla-housekeeping-daily.service '
'-u scylla-housekeeping-restart.service '
'-u scylla-jmx.service '
'%s' % (journalctl_cmd, timestamp),
ignore_status=True)
except path.CmdNotFoundError:
result = process.run('cat /var/log/syslog | grep scylla',
shell=True,
ignore_status=True)
error_list = [
'I/O Scheduler is not properly configured!',
'Failed to start Scylla Server', 'failed to write into /proc/irq'
]
for err in error_list:
if err in result.stdout:
raise StartServiceError(
'Fail to start scylla-server, err: %s' % err)
for srv in self.services:
srv_manager.status(srv)
return not network.is_port_free(9042, 'localhost')
def setUp(self):
super(self.__class__, self).setUp()
service_manager = service.ServiceManager()
service_manager.start('docker')
self.runHost('docker pull docker.io/httpd')
self.runHost(
'docker run --name http_name_8000 -d -p 8000:80 docker.io/httpd')
self.runHost(
'docker run --name http_name_8001 -d -p 8001:80 docker.io/httpd')
def setup_firewalld():
"""
Setup firewalld service for test
"""
firewalld = 'firewalld'
service_mgr = service.ServiceManager()
status = service_mgr.status(firewalld)
logging.debug('Service status is %s', status)
if not status:
service_mgr.start(firewalld)
def __stop_service(self):
"""
Internal method, do not use it anyhow
:return: None
"""
if os.path.exists('/var/run/docker.sock'):
core.print_info("Stopping Docker")
service_manager = service.ServiceManager()
service_manager.stop('docker')
def restart_services(self):
srv_manager = service.ServiceManager()
for srv in self.services:
srv_manager.restart(srv)
for srv in self.services:
if not srv_manager.status(srv):
if service.get_name_of_init() == 'systemd':
process.run('journalctl -xe', ignore_status=True, verbose=True)
e_msg = ('Failed to restart service %s '
'(see logs for details)' % srv)
raise RestartServiceError(e_msg)
def stop_services(self):
srv_manager = service.ServiceManager()
for srv in reversed(self.services):
srv_manager.stop(srv)
for srv in self.services:
if srv_manager.status(srv):
if service.get_name_of_init() == 'systemd':
process.run('journalctl -xe', ignore_status=True, verbose=True)
e_msg = ('Failed to stop service %s '
'(see logs for details)' % srv)
raise StopServiceError(e_msg)
def start_or_stop_qemu_pr_helper(is_start=True, path_to_sock="/var/run/qemu-pr-helper.sock"):
"""
Start or stop qemu-pr-helper daemon
:param is_start: Set True to start, False to stop.
"""
service_mgr = service.ServiceManager()
if is_start:
service_mgr.start('qemu-pr-helper')
time.sleep(2)
shutil.chown(path_to_sock, "qemu", "qemu")
else:
service_mgr.stop('qemu-pr-helper')
def start_services(self):
self.start_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
srv_manager = service.ServiceManager()
for srv in self.services:
srv_manager.start(srv)
for srv in self.services:
if not srv_manager.status(srv):
if service.get_name_of_init() == 'systemd':
process.run('journalctl -xe',
ignore_status=True,
verbose=True)
e_msg = ('Failed to start service %s '
'(see logs for details)' % srv)
raise StartServiceError(e_msg)
def __init__(self, test, params, ip="localhost"):
self.nfs_dir = os.path.join(test.tmpdir, "nfs_dir")
self.mnt_dir = os.path.join(test.tmpdir, "mnt_dir")
self.chk_re = params.get("nfs_stat_chk_re", "running")
self.nfs_ip = ip
self.required_size = params.object_params("stg").get("image_size")
self.iptables_template = self.iptables_template.format(ip=self.nfs_ip)
self.service_manager = service.ServiceManager()
for name in ["nfs", "nfs-server"]:
if self.service_manager.status(name) is not None:
self.service_name = name
break
else:
msg = ("Fail to set up NFS for this host, service "
"with name 'nfs' and 'nfs-server' not exist.")
raise NFSCorruptError(msg)
for attrname in ["start", "stop", "restart", "status"]:
setattr(
self, attrname,
partial(getattr(self.service_manager, attrname),
self.service_name))
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')
vm_name = params.get('main_vm', 'EXAMPLE')
target = params.get('target')
remote_host = params.get('remote_host', 'EXAMPLE')
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')
ntp_server = params.get('ntp_server')
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_timeout = int(params.get('v2v_timeout', 1200))
skip_check = 'yes' == params.get('skip_check', 'no')
status_error = 'yes' == params.get('status_error', 'no')
checkpoint = params.get('checkpoint', '')
debug_kernel = 'debug_kernel' == checkpoint
multi_kernel_list = ['multi_kernel', 'debug_kernel']
backup_list = [
'virtio_on', 'virtio_off', 'floppy', 'floppy_devmap', 'fstab_cdrom',
'fstab_virtio', 'multi_disks', 'sata_disk', 'network_virtio',
'network_rtl8139', 'network_e1000', 'multi_netcards', 'spice',
'spice_encrypt', 'spice_qxl', 'spice_cirrus', 'vnc_qxl', 'vnc_cirrus',
'blank_2nd_disk', 'listen_none', 'listen_socket', 'only_net', 'only_br'
]
error_list = []
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('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")
@vm_shell
def check_vmlinuz_initramfs(v2v_result):
"""
Check if vmlinuz matches initramfs on multi-kernel case
"""
logging.info('Checking if vmlinuz matches initramfs')
kernels = re.search(
'kernel packages in this guest:.*?(\(kernel.*?\).*?){2,}',
v2v_result, re.DOTALL)
try:
lines = kernels.group(0)
kernel_list = re.findall('\((.*?)\)', lines)
for kernel in kernel_list:
vmlinuz = re.search(r'/boot/vmlinuz-(.*?),', kernel).group(1)
initramfs = \
re.search(r'/boot/initramfs-(.*?)\.img', kernel).group(1)
logging.debug('vmlinuz version is: %s' % vmlinuz)
logging.debug('initramfs version is: %s' % initramfs)
if vmlinuz != initramfs:
log_fail('vmlinuz not match with initramfs')
except Exception as e:
test.error('Error on find kernel info \n %s' % str(e))
def check_boot_kernel(vmcheck):
"""
Check if converted vm use the latest kernel
"""
current_kernel = vmcheck.session.cmd('uname -r').strip()
logging.debug('Current kernel: %s' % current_kernel)
if current_kernel == '3.10.0-799.el7.x86_64':
logging.debug('The kernel is the latest kernel')
else:
log_fail('VM should choose lastest kernel not %s' % current_kernel)
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, virsh_instance):
"""
Check if number and type of network cards meet expectation
"""
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(
vm_name, virsh_instance=virsh_instance)
iflist = vmxml.get_iface_all()
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', 'virtio', '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', 'virtio': '/vd'}
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 virtio device
elif type == 'virtio':
entry = session.cmd('cat /etc/fstab|grep /boot').strip()
# Get the ID (no matter what, usually UUID)
origin = entry.split()[0]
key = origin.split('=')[1]
blkinfo = session.cmd('blkid|grep %s' % key).strip()
# Replace with virtio disk path
replace = blkinfo.split()[0].strip(':')
# 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']
firewalld_status = session.cmd(
'systemctl status firewalld.service|grep Active:',
ok_status=[0, 3]).strip()
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()
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)
status, output = session.cmd_status_output(cmd)
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('ntpdate -q %s' % ntp_server)
logging.debug(output)
drift = abs(float(output.split()[-2]))
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 + result.stderr
if skip_check:
logging.info('Skip checking vm after conversion')
elif 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_check') != 'yes':
ret = vmchecker.run()
if len(ret) == 0:
logging.info("All common checkpoints passed")
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(
vm_name, virsh_instance=vmchecker.virsh_instance)
logging.debug(vmxml)
if checkpoint == 'multi_kernel':
check_boot_kernel(vmchecker.checker)
if checkpoint == 'floppy':
check_floppy_exist(vmchecker.checker)
if checkpoint == 'multi_disks':
check_disks(vmchecker.checker)
if checkpoint == 'multi_netcards':
check_multi_netcards(params['mac_address'],
vmchecker.virsh_instance)
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 = vmxml.get_devices('video')[0].model_type
if video_type.lower() != 'qxl':
log_fail('Video expect QXL, actual %s' % video_type)
if checkpoint.startswith('listen'):
listen_type = vmxml.get_devices('graphics')[0].listen_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 == '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_params = {
'hostname': remote_host,
'hypervisor': 'kvm',
'v2v_opts': '-v -x',
'storage': output_storage,
'network': network,
'bridge': bridge,
'target': target,
'main_vm': vm_name,
'input_mode': 'libvirt',
'new_name': vm_name + '_' + utils_misc.generate_random_string(3)
}
if output_format:
v2v_params.update({'output_format': 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)
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'
backup_xml = None
if checkpoint in backup_list:
backup_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
if checkpoint == 'multi_disks':
attach_disk_path = os.path.join(data_dir.get_tmp_dir(),
'attach_disks')
utlv.attach_disks(env.get_vm(vm_name), attach_disk_path, None,
params)
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
disk_count = 0
for disk in list(new_xml.get_disk_all().values()):
if disk.get('device') == 'disk':
disk_count += 1
params['ori_disks'] = disk_count
if checkpoint == 'virtio_on':
change_disk_bus('virtio')
if checkpoint == 'virtio_off':
change_disk_bus('ide')
if checkpoint == 'sata_disk':
change_disk_bus('sata')
if checkpoint.startswith('floppy'):
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')
if checkpoint == 'fstab_virtio':
change_disk_bus('virtio')
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':
attach_network_card('virtio')
attach_network_card('e1000')
params['mac_address'] = []
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
network_list = vmxml.get_iface_all()
for mac in network_list:
if network_list[mac].get('type') == '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)
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 ntpd on')
cmd = ['yum -y install ntp', 'systemctl start ntpd']
vm_cmd(cmd)
if checkpoint == 'sync_ntp':
logging.info('Sync time with %s', ntp_server)
cmd = ['yum -y install ntpdate', 'ntpdate %s' % ntp_server]
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')
virsh.dumpxml(vm_name, debug=True)
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 params.get('vmchecker'):
params['vmchecker'].cleanup()
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)
def _scylla_service_is_up(self):
srv_manager = service.ServiceManager()
for srv in self.services:
srv_manager.status(srv)
return not network.is_port_free(9042, 'localhost')
video.set('type', video_type)
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 ntpd on')
cmd = ['yum -y install ntp', 'systemctl start ntpd']
def run(test, params, env):
"""
Test the tpm virtual devices
1. prepare a guest with different tpm devices
2. check whether the guest can be started
3. check the xml and qemu cmd line
4. check tpm usage in guest os
"""
# Tpm passthrough supported since libvirt 1.0.5.
if not libvirt_version.version_compare(1, 0, 5):
test.cancel("Tpm device is not supported "
"on current libvirt version.")
# Tpm passthrough supported since qemu 2.12.0-49.
if not utils_misc.compare_qemu_version(2, 9, 0, is_rhev=False):
test.cancel("Tpm device is not supported "
"on current qemu version.")
status_error = ("yes" == params.get("status_error", "no"))
tpm_model = params.get("tpm_model")
backend_type = params.get("backend_type")
backend_version = params.get("backend_version")
device_path = params.get("device_path")
tpm_num = int(params.get("tpm_num", 1))
multi_vms = ("yes" == params.get("multi_vms", "no"))
# Check tpm chip on host for passthrough testing
if backend_type == "passthrough":
dmesg_info = process.getoutput("dmesg|grep tpm -wi", shell=True)
logging.debug("dmesg info about tpm:\n %s", dmesg_info)
dmesg_error = re.search("No TPM chip found|TPM is disabled", dmesg_info)
if dmesg_error:
test.cancel(dmesg_error.group())
else:
# Try to check host tpm chip version
tpm_v = None
if re.search("2.0 TPM", dmesg_info):
tpm_v = "2.0"
if not utils_package.package_install("tpm2-tools"):
# package_install() return 'True' if succeed
test.error("Failed to install tpm2-tools on host")
else:
if re.search("1.2 TPM", dmesg_info):
tpm_v = "1.2"
# If "1.2 TPM" or no version info in dmesg, try to test a tpm1.2 at first
if not utils_package.package_install("tpm-tools"):
test.error("Failed to install tpm-tools on host")
vm_names = params.get("vms").split()
vm_name = vm_names[0]
vm = env.get_vm(vm_name)
vm_xml = VMXML.new_from_inactive_dumpxml(vm_name)
vm_xml_backup = vm_xml.copy()
if vm.is_alive():
vm.destroy()
vm2 = None
if multi_vms:
if len(vm_names) > 1:
vm2_name = vm_names[1]
vm2 = env.get_vm(vm2_name)
vm2_xml = VMXML.new_from_inactive_dumpxml(vm2_name)
vm2_xml_backup = vm2_xml.copy()
else:
# Clone additional vms if needed
try:
utils_path.find_command("virt-clone")
except utils_path.CmdNotFoundError:
if not utils_package.package_install(["virt-install"]):
test.cancel("Failed to install virt-install on host")
vm2_name = "vm2_" + utils_misc.generate_random_string(5)
ret_clone = utils_libguestfs.virt_clone_cmd(vm_name, vm2_name,
True, timeout=360, debug=True)
if ret_clone.exit_status:
test.error("Need more than one domains, but error occured when virt-clone.")
vm2 = vm.clone(vm2_name)
vm2_xml = VMXML.new_from_inactive_dumpxml(vm2_name)
if vm2.is_alive():
vm2.destroy()
service_mgr = service.ServiceManager()
def check_dumpxml():
"""
Check whether the added devices are shown in the guest xml
"""
logging.info("------Checking guest dumpxml------")
if tpm_model:
pattern = '<tpm model="%s">' % tpm_model
else:
# The default tpm model is "tpm-tis"
pattern = '<tpm model="tpm-tis">'
# Check tpm model
xml_after_adding_device = VMXML.new_from_dumpxml(vm_name)
logging.debug("xml after add tpm dev is %s", xml_after_adding_device)
if pattern not in str(xml_after_adding_device):
test.fail("Can not find the %s tpm device xml "
"in the guest xml file." % tpm_model)
# Check backend type
pattern = '<backend type="%s"' % backend_type
if pattern not in str(xml_after_adding_device):
test.fail("Can not find the %s backend type xml for tpm dev "
"in the guest xml file." % backend_type)
# Check backend version
if backend_version:
pattern = "\'emulator\' version=\"%s\"" % backend_version
if pattern not in str(xml_after_adding_device):
test.fail("Can not find the %s backend version xml for tpm dev "
"in the guest xml file." % backend_version)
# Check device path
if backend_type == "passthrough":
pattern = '<device path="/dev/tpm0"'
if pattern not in str(xml_after_adding_device):
test.fail("Can not find the %s device path xml for tpm dev "
"in the guest xml file." % device_path)
logging.info('------PASS on guest dumpxml check------')
def check_qemu_cmd_line():
"""
Check whether the added devices are shown in the qemu cmd line
"""
logging.info("------Checking qemu cmd line------")
if not vm.get_pid():
test.fail('VM pid file missing.')
with open('/proc/%s/cmdline' % vm.get_pid()) as cmdline_file:
cmdline = cmdline_file.read()
logging.debug("Qemu cmd line info:\n %s", cmdline)
# Check tpm model
pattern = "-device.%s" % tpm_model
if not re.search(pattern, cmdline):
test.fail("Can not find the %s tpm device "
"in qemu cmd line." % tpm_model)
# Check backend type
if backend_type == "passthrough":
pattern_list = ["-tpmdev.passthrough"]
dev_num = re.search(r"\d+", device_path).group()
pattern_list.append("id=tpm-tpm%s" % dev_num)
for pattern in pattern_list:
if not re.search(pattern, cmdline):
test.fail("Can not find the %s tpm device "
"in qemu cmd line." % pattern)
logging.info("------PASS on qemu cmd line check------")
def get_host_tpm_bef(tpm_v):
"""
Test host tpm function and identify its real version before passthrough
Since sometimes dmesg info doesn't include tpm msg, need use tpm-tool or
tpm2-tools to try the function.
:param tpm_v: host tpm version get from dmesg info
:return: host tpm version
"""
logging.info("------Checking host tpm device before passthrough------")
# Try tcsd tool for suspected tpm1.2 chip on host
if tpm_v != "2.0":
if not service_mgr.start('tcsd'):
# service_mgr.start() return 'True' if succeed
if tpm_v == "1.2":
test.fail("Host tcsd.serivce start failed")
else:
# Means tpm_v got nothing from dmesg, log failure here and
# go to 'elif' to try tpm2.0 tools.
logging.info("Host tcsd.serivce start failed")
else:
tpm_real_v = "1.2"
logging.info("Host tpm version info:")
result = process.run("tpm_version", ignore_status=False)
logging.debug("[host]# tpm_version\n %s", result.stdout)
time.sleep(2)
service_mgr.stop('tcsd')
elif tpm_v != "1.2":
# Try tpm2.0 tools
if not utils_package.package_install("tpm2-tools"):
test.error("Failed to install tpm2-tools on host")
if process.run("tpm2_getrandom 5", ignore_status=True).exit_status:
test.cancel("Both tcsd and tpm2-tools can not work, "
"pls check your host tpm version and test env.")
else:
tpm_real_v = "2.0"
logging.info("------PASS on host tpm device check------")
return tpm_real_v
def test_host_tpm_aft(tpm_real_v):
"""
Test host tpm function after passthrough
:param tpm_real_v: host tpm real version indentified from testing
"""
logging.info("------Checking host tpm device after passthrough------")
if tpm_real_v == "1.2":
if service_mgr.start('tcsd'):
time.sleep(2)
service_mgr.stop('tcsd')
test.fail("Host tpm should not work after passthrough to guest.")
else:
logging.info("Expected failure: Tpm is being used by guest.")
elif tpm_real_v == "2.0":
if not process.run("tpm2_getrandom 7", ignore_status=True).exit_status:
test.fail("Host tpm should not work after passthrough to guest.")
else:
logging.info("Expected failure: Tpm is being used by guest.")
logging.info("------PASS on host tpm device check------")
def test_guest_tpm(expect_version, session, expect_fail):
"""
Test tpm function in guest
:param expect_version: guest tpm version, as host version, or emulator specified
:param session: Guest session to be tested
:param expect_fail: guest tpm is expectedly fail to work
"""
logging.info("------Checking guest tpm device work------")
if expect_version == "1.2":
# Install tpm-tools and test by tcsd method
if not utils_package.package_install(["tpm-tools"], session, 360):
test.error("Failed to install tpm-tools package in guest")
else:
status, output = session.cmd_status_output("systemctl start tcsd")
logging.debug(output)
if status:
if expect_fail:
test.cancel("tpm-crb passthrough only works with host tpm2.0, "
"but your host tpm version is 1.2")
else:
test.fail("Failed to start tcsd.service in guest")
else:
status, output = session.cmd_status_output("tpm_version")
logging.debug(output)
if status:
test.fail("Guest tpm can not work")
else:
# If expect_version is tpm2.0, install and test by tpm2-tools
if not utils_package.package_install(["tpm2-tools"], session, 360):
test.error("Failed to install tpm2-tools package in guest")
else:
status, output = session.cmd_status_output("tpm2_getrandom 11")
logging.debug(output)
if status:
test.fail("Guest tpm can not work")
logging.info("------PASS on guest tpm device work check------")
def reuse_by_vm2(tpm_dev):
"""
Try to passthrough tpm to a second guest, when it's being used by one guest.
:param tpm_dev: tpm device to be added into guest xml
"""
logging.info("------Trying to passthrough tpm to a second domain------")
vm2_xml.remove_all_device_by_type('tpm')
vm2_xml.add_device(tpm_dev)
vm2_xml.sync()
ret = virsh.start(vm2_name, ignore_status=True, debug=True)
if ret:
logging.info("Expected failure when try to passthrough a tpm"
" that being used by another guest")
return
else:
test.fail("Reuse a passthroughed tpm should not succeed.")
try:
tpm_real_v = None
if backend_type == "passthrough":
tpm_real_v = get_host_tpm_bef(tpm_v)
logging.debug("The host tpm real version is %s", tpm_real_v)
vm_xml.remove_all_device_by_type('tpm')
tpm_dev = Tpm()
if tpm_model:
tpm_dev.tpm_model = tpm_model
backend = tpm_dev.Backend()
backend.backend_type = backend_type
if device_path:
backend.device_path = device_path
tpm_dev.backend = backend
logging.debug("tpm dev xml to add is %s", tpm_dev)
for num in range(tpm_num):
vm_xml.add_device(tpm_dev, True)
try:
vm_xml.sync()
except LibvirtXMLError as e:
if tpm_num > 1 and backend_type == "passthrough":
logging.info("Expected failure when define a guest with multi tpm passthrough"
" configured in xml.")
# Stop test when get expected failure
return
else:
test.fail("Test failed in vmxml.sync(), detail:%s." % e)
if tpm_num > 1 and backend_type == "passthrough":
test.fail("Passthrough multi tpm should not succeed.")
check_dumpxml()
# For default model, no need start guest to test
if tpm_model:
expect_fail = False
virsh.start(vm_name, ignore_status=False, debug=True)
check_qemu_cmd_line()
session = vm.wait_for_login()
if backend_type == "passthrough":
if tpm_real_v == "1.2" and tpm_model == "tpm-crb":
expect_fail = True
test_guest_tpm(tpm_real_v, session, expect_fail)
if multi_vms:
reuse_by_vm2(tpm_dev)
# Stop test when get expected failure
return
test_host_tpm_aft(tpm_real_v)
else:
# emulator backend
test_guest_tpm(backend_version, session, expect_fail)
session.close()
finally:
vm_xml_backup.sync()
if vm2:
if len(vm_names) > 1:
vm2_xml_backup.sync()
else:
virsh.remove_domain(vm2_name, "--remove-all-storage", debug=True)
def run(test, params, env):
"""
Test the tpm virtual devices
1. prepare a guest with different tpm devices
2. check whether the guest can be started
3. check the xml and qemu cmd line, even swtpm for vtpm
4. check tpm usage in guest os
"""
# Tpm passthrough supported since libvirt 1.0.5.
if not libvirt_version.version_compare(1, 0, 5):
test.cancel("Tpm device is not supported "
"on current libvirt version.")
# Tpm passthrough supported since qemu 2.12.0-49.
if not utils_misc.compare_qemu_version(2, 9, 0, is_rhev=False):
test.cancel("Tpm device is not supported "
"on current qemu version.")
tpm_model = params.get("tpm_model")
backend_type = params.get("backend_type")
backend_version = params.get("backend_version")
device_path = params.get("device_path")
tpm_num = int(params.get("tpm_num", 1))
# After first start of vm with vtpm, do operations, check it still works
vm_operate = params.get("vm_operate")
# Sub-operation(e.g.domrename) under vm_operate(e.g.restart)
vm_oprt = params.get("vm_oprt")
secret_uuid = params.get("secret_uuid")
secret_value = params.get("secret_value")
# Change encryption state: from plain to encrypted, or reverse.
encrypt_change = params.get("encrypt_change")
secret_uuid = params.get("secret_uuid")
prepare_secret = ("yes" == params.get("prepare_secret", "no"))
remove_dev = ("yes" == params.get("remove_dev", "no"))
multi_vms = ("yes" == params.get("multi_vms", "no"))
# Remove swtpm state file
rm_statefile = ("yes" == params.get("rm_statefile", "no"))
test_suite = ("yes" == params.get("test_suite", "no"))
restart_libvirtd = ("yes" == params.get("restart_libvirtd", "no"))
no_backend = ("yes" == params.get("no_backend", "no"))
status_error = ("yes" == params.get("status_error", "no"))
err_msg = params.get("xml_errmsg", "")
loader = params.get("loader", "")
nvram = params.get("nvram", "")
uefi_disk_url = params.get("uefi_disk_url", "")
download_file_path = os.path.join(data_dir.get_tmp_dir(), "uefi_disk.qcow2")
# Check tpm chip on host for passthrough testing
if backend_type == "passthrough":
dmesg_info = process.getoutput("dmesg|grep tpm -wi", shell=True)
logging.debug("dmesg info about tpm:\n %s", dmesg_info)
dmesg_error = re.search("No TPM chip found|TPM is disabled", dmesg_info)
if dmesg_error:
test.cancel(dmesg_error.group())
else:
# Try to check host tpm chip version
tpm_v = None
if re.search("2.0 TPM", dmesg_info):
tpm_v = "2.0"
if not utils_package.package_install("tpm2-tools"):
# package_install() return 'True' if succeed
test.error("Failed to install tpm2-tools on host")
else:
if re.search("1.2 TPM", dmesg_info):
tpm_v = "1.2"
# If "1.2 TPM" or no version info in dmesg, try to test a tpm1.2 at first
if not utils_package.package_install("tpm-tools"):
test.error("Failed to install tpm-tools on host")
# Check host env for vtpm testing
elif backend_type == "emulator":
if not utils_misc.compare_qemu_version(4, 0, 0, is_rhev=False):
test.cancel("vtpm(emulator backend) is not supported "
"on current qemu version.")
# Install swtpm pkgs on host for vtpm emulation
if not utils_package.package_install("swtpm*"):
test.error("Failed to install swtpm swtpm-tools on host")
def replace_os_disk(vm_xml, vm_name, nvram):
"""
Replace os(nvram) and disk(uefi) for x86 vtpm test
:param vm_xml: current vm's xml
:param vm_name: current vm name
:param nvram: nvram file path of vm
"""
# Add loader, nvram in <os>
nvram = nvram.replace("<VM_NAME>", vm_name)
dict_os_attrs = {"loader_readonly": "yes",
"secure": "yes",
"loader_type": "pflash",
"loader": loader,
"nvram": nvram}
vm_xml.set_os_attrs(**dict_os_attrs)
logging.debug("Set smm=on in VMFeaturesXML")
# Add smm in <features>
features_xml = vm_xml.features
features_xml.smm = "on"
vm_xml.features = features_xml
vm_xml.sync()
# Replace disk with an uefi image
if not utils_package.package_install("wget"):
test.error("Failed to install wget on host")
if uefi_disk_url.count("EXAMPLE"):
test.error("Please provide the URL %s" % uefi_disk_url)
else:
download_cmd = ("wget %s -O %s" % (uefi_disk_url, download_file_path))
process.system(download_cmd, verbose=False, shell=True)
vm = env.get_vm(vm_name)
uefi_disk = {'disk_source_name': download_file_path}
libvirt.set_vm_disk(vm, uefi_disk)
vm_names = params.get("vms").split()
vm_name = vm_names[0]
vm = env.get_vm(vm_name)
vm_xml = VMXML.new_from_inactive_dumpxml(vm_name)
vm_xml_backup = vm_xml.copy()
os_xml = getattr(vm_xml, "os")
host_arch = platform.machine()
if backend_type == "emulator" and host_arch == 'x86_64':
if not utils_package.package_install("OVMF"):
test.error("Failed to install OVMF or edk2-ovmf pkgs on host")
if os_xml.xmltreefile.find('nvram') is None:
replace_os_disk(vm_xml, vm_name, nvram)
vm_xml = VMXML.new_from_inactive_dumpxml(vm_name)
if vm.is_alive():
vm.destroy()
vm2 = None
if multi_vms:
if len(vm_names) > 1:
vm2_name = vm_names[1]
vm2 = env.get_vm(vm2_name)
vm2_xml = VMXML.new_from_inactive_dumpxml(vm2_name)
vm2_xml_backup = vm2_xml.copy()
else:
# Clone additional vms if needed
try:
utils_path.find_command("virt-clone")
except utils_path.CmdNotFoundError:
if not utils_package.package_install(["virt-install"]):
test.cancel("Failed to install virt-install on host")
vm2_name = "vm2_" + utils_misc.generate_random_string(5)
ret_clone = utils_libguestfs.virt_clone_cmd(vm_name, vm2_name,
True, timeout=360, debug=True)
if ret_clone.exit_status:
test.error("Need more than one domains, but error occured when virt-clone.")
vm2 = vm.clone(vm2_name)
vm2_xml = VMXML.new_from_inactive_dumpxml(vm2_name)
if vm2.is_alive():
vm2.destroy()
service_mgr = service.ServiceManager()
def check_dumpxml(vm_name):
"""
Check whether the added devices are shown in the guest xml
:param vm_name: current vm name
"""
logging.info("------Checking guest dumpxml------")
if tpm_model:
pattern = '<tpm model="%s">' % tpm_model
else:
# The default tpm model is "tpm-tis"
pattern = '<tpm model="tpm-tis">'
# Check tpm model
xml_after_adding_device = VMXML.new_from_dumpxml(vm_name)
logging.debug("xml after add tpm dev is %s", xml_after_adding_device)
if pattern not in astring.to_text(xml_after_adding_device):
test.fail("Can not find the %s tpm device xml "
"in the guest xml file." % tpm_model)
# Check backend type
pattern = '<backend type="%s"' % backend_type
if pattern not in astring.to_text(xml_after_adding_device):
test.fail("Can not find the %s backend type xml for tpm dev "
"in the guest xml file." % backend_type)
# Check backend version
if backend_version:
check_ver = backend_version if backend_version != 'none' else '2.0'
pattern = '"emulator" version="%s"' % check_ver
if pattern not in astring.to_text(xml_after_adding_device):
test.fail("Can not find the %s backend version xml for tpm dev "
"in the guest xml file." % check_ver)
# Check device path
if backend_type == "passthrough":
pattern = '<device path="/dev/tpm0"'
if pattern not in astring.to_text(xml_after_adding_device):
test.fail("Can not find the %s device path xml for tpm dev "
"in the guest xml file." % device_path)
# Check encryption secret
if prepare_secret:
pattern = '<encryption secret="%s" />' % encryption_uuid
if pattern not in astring.to_text(xml_after_adding_device):
test.fail("Can not find the %s secret uuid xml for tpm dev "
"in the guest xml file." % encryption_uuid)
logging.info('------PASS on guest dumpxml check------')
def check_qemu_cmd_line(vm, vm_name, domid):
"""
Check whether the added devices are shown in the qemu cmd line
:param vm: current vm
:param vm_name: current vm name
:param domid: domain id for checking vtpm socket file
"""
logging.info("------Checking qemu cmd line------")
if not vm.get_pid():
test.fail('VM pid file missing.')
with open('/proc/%s/cmdline' % vm.get_pid()) as cmdline_file:
cmdline = cmdline_file.read()
logging.debug("Qemu cmd line info:\n %s", cmdline)
# Check tpm model
pattern_list = ["-device.%s" % tpm_model]
# Check backend type
if backend_type == "passthrough":
dev_num = re.search(r"\d+", device_path).group()
backend_segment = "id=tpm-tpm%s" % dev_num
else:
# emulator backend
backend_segment = "id=tpm-tpm0,chardev=chrtpm"
pattern_list.append("-tpmdev.%s,%s" % (backend_type, backend_segment))
# Check chardev socket for vtpm
if backend_type == "emulator":
pattern_list.append("-chardev.socket,id=chrtpm,"
"path=.*/run/libvirt/qemu/swtpm/%s-%s-swtpm.sock" % (domid, vm_name))
for pattern in pattern_list:
if not re.search(pattern, cmdline):
if not remove_dev:
test.fail("Can not find the %s for tpm device "
"in qemu cmd line." % pattern)
elif remove_dev:
test.fail("%s still exists after remove vtpm and restart" % pattern)
logging.info("------PASS on qemu cmd line check------")
def check_swtpm(domid, domuuid, vm_name):
"""
Check swtpm cmdline and files for vtpm.
:param domid: domain id for checking vtpm files
:param domuuid: domain uuid for checking vtpm state file
:param vm_name: current vm name
"""
logging.info("------Checking swtpm cmdline and files------")
# Check swtpm cmdline
swtpm_pid = utils_misc.get_pid("%s-swtpm.pid" % vm_name)
if not swtpm_pid:
if not remove_dev:
test.fail('swtpm pid file missing.')
else:
return
elif remove_dev:
test.fail('swtpm pid file still exists after remove vtpm and restart')
with open('/proc/%s/cmdline' % swtpm_pid) as cmdline_file:
cmdline = cmdline_file.read()
logging.debug("Swtpm cmd line info:\n %s", cmdline)
pattern_list = ["--daemon", "--ctrl", "--tpmstate", "--log", "--tpm2", "--pid"]
if prepare_secret:
pattern_list.extend(["--key", "--migration-key"])
for pattern in pattern_list:
if not re.search(pattern, cmdline):
test.fail("Can not find the %s for tpm device "
"in swtpm cmd line." % pattern)
# Check swtpm files
file_list = ["/var/run/libvirt/qemu/swtpm/%s-%s-swtpm.sock" % (domid, vm_name)]
file_list.append("/var/lib/libvirt/swtpm/%s/tpm2" % domuuid)
file_list.append("/var/log/swtpm/libvirt/qemu/%s-swtpm.log" % vm_name)
file_list.append("/var/run/libvirt/qemu/swtpm/%s-%s-swtpm.pid" % (domid, vm_name))
for swtpm_file in file_list:
if not os.path.exists(swtpm_file):
test.fail("Swtpm file: %s does not exist" % swtpm_file)
logging.info("------PASS on Swtpm cmdline and files check------")
def get_tpm2_tools_cmd(session=None):
"""
Get tpm2-tools pkg version and return corresponding getrandom cmd
:session: guest console session
:return: tpm2_getrandom cmd usage
"""
cmd = 'rpm -q tpm2-tools'
get_v_tools = session.cmd(cmd) if session else process.run(cmd).stdout_text
v_tools_list = get_v_tools.strip().split('-')
if session:
logging.debug("The tpm2-tools version is %s", v_tools_list[2])
v_tools = int(v_tools_list[2].split('.')[0])
return "tpm2_getrandom 8" if v_tools < 4 else "tpm2_getrandom -T device:/dev/tpm0 8 --hex"
def get_host_tpm_bef(tpm_v):
"""
Test host tpm function and identify its real version before passthrough
Since sometimes dmesg info doesn't include tpm msg, need use tpm-tool or
tpm2-tools to try the function.
:param tpm_v: host tpm version get from dmesg info
:return: host tpm version
"""
logging.info("------Checking host tpm device before passthrough------")
# Try tcsd tool for suspected tpm1.2 chip on host
tpm_real_v = tpm_v
if tpm_v != "2.0":
if not service_mgr.start('tcsd'):
# service_mgr.start() return 'True' if succeed
if tpm_v == "1.2":
test.fail("Host tcsd.serivce start failed")
else:
# Means tpm_v got nothing from dmesg, log failure here and
# go to next 'if' to try tpm2.0 tools.
logging.info("Host tcsd.serivce start failed")
else:
tpm_real_v = "1.2"
logging.info("Host tpm version info:")
result = process.run("tpm_version", ignore_status=False)
logging.debug("[host]# tpm_version\n %s", result.stdout)
time.sleep(2)
service_mgr.stop('tcsd')
if tpm_v != "1.2":
# Try tpm2.0 tools
if not utils_package.package_install("tpm2-tools"):
test.error("Failed to install tpm2-tools on host")
tpm2_getrandom_cmd = get_tpm2_tools_cmd()
if process.run(tpm2_getrandom_cmd, ignore_status=True).exit_status:
test.cancel("Both tcsd and tpm2-tools can not work, "
"pls check your host tpm version and test env.")
else:
tpm_real_v = "2.0"
logging.info("------PASS on host tpm device check------")
return tpm_real_v
def test_host_tpm_aft(tpm_real_v):
"""
Test host tpm function after passthrough
:param tpm_real_v: host tpm real version indentified from testing
"""
logging.info("------Checking host tpm device after passthrough------")
if tpm_real_v == "1.2":
if service_mgr.start('tcsd'):
time.sleep(2)
service_mgr.stop('tcsd')
test.fail("Host tpm should not work after passthrough to guest.")
else:
logging.info("Expected failure: Tpm is being used by guest.")
elif tpm_real_v == "2.0":
tpm2_getrandom_cmd = get_tpm2_tools_cmd()
if not process.run(tpm2_getrandom_cmd, ignore_status=True).exit_status:
test.fail("Host tpm should not work after passthrough to guest.")
else:
logging.info("Expected failure: Tpm is being used by guest.")
logging.info("------PASS on host tpm device check------")
def test_guest_tpm(expect_version, session, expect_fail):
"""
Test tpm function in guest
:param expect_version: guest tpm version, as host version, or emulator specified
:param session: Guest session to be tested
:param expect_fail: guest tpm is expectedly fail to work
"""
logging.info("------Checking guest tpm device work------")
if expect_version == "1.2":
# Install tpm-tools and test by tcsd method
if not utils_package.package_install(["tpm-tools"], session, 360):
test.error("Failed to install tpm-tools package in guest")
else:
status, output = session.cmd_status_output("systemctl start tcsd")
logging.debug("Command output: %s", output)
if status:
if expect_fail:
test.cancel("tpm-crb passthrough only works with host tpm2.0, "
"but your host tpm version is 1.2")
else:
test.fail("Failed to start tcsd.service in guest")
else:
dev_output = session.cmd_output("ls /dev/|grep tpm")
logging.debug("Command output: %s", dev_output)
status, output = session.cmd_status_output("tpm_version")
logging.debug("Command output: %s", output)
if status:
test.fail("Guest tpm can not work")
else:
# If expect_version is tpm2.0, install and test by tpm2-tools
if not utils_package.package_install(["tpm2-tools"], session, 360):
test.error("Failed to install tpm2-tools package in guest")
else:
tpm2_getrandom_cmd = get_tpm2_tools_cmd(session)
status1, output1 = session.cmd_status_output("ls /dev/|grep tpm")
logging.debug("Command output: %s", output1)
status2, output2 = session.cmd_status_output(tpm2_getrandom_cmd)
logging.debug("Command output: %s", output2)
if status1 or status2:
if not expect_fail:
test.fail("Guest tpm can not work")
else:
d_status, d_output = session.cmd_status_output("date")
if d_status:
test.fail("Guest OS doesn't work well")
logging.debug("Command output: %s", d_output)
elif expect_fail:
test.fail("Expect fail but guest tpm still works")
logging.info("------PASS on guest tpm device work check------")
def run_test_suite_in_guest(session):
"""
Run kernel test suite for guest tpm.
:param session: Guest session to be tested
"""
logging.info("------Checking kernel test suite for guest tpm------")
boot_info = session.cmd('uname -r').strip().split('.')
kernel_version = '.'.join(boot_info[:2])
# Download test suite per current guest kernel version
parent_path = "https://cdn.kernel.org/pub/linux/kernel"
if float(kernel_version) < 5.3:
major_version = "5"
file_version = "5.3"
else:
major_version = boot_info[0]
file_version = kernel_version
src_url = "%s/v%s.x/linux-%s.tar.xz" % (parent_path, major_version, file_version)
download_cmd = "wget %s -O %s" % (src_url, "/root/linux.tar.xz")
output = session.cmd_output(download_cmd, timeout=480)
logging.debug("Command output: %s", output)
# Install neccessary pkgs to build test suite
if not utils_package.package_install(["tar", "make", "gcc", "rsync", "python2"], session, 360):
test.fail("Failed to install specified pkgs in guest OS.")
# Unzip the downloaded test suite
status, output = session.cmd_status_output("tar xvJf /root/linux.tar.xz -C /root")
if status:
test.fail("Uzip failed: %s" % output)
# Specify using python2 to run the test suite per supporting
test_path = "/root/linux-%s/tools/testing/selftests" % file_version
sed_cmd = "sed -i 's/python -m unittest/python2 -m unittest/g' %s/tpm2/test_*.sh" % test_path
output = session.cmd_output(sed_cmd)
logging.debug("Command output: %s", output)
# Build and and run the .sh files of test suite
status, output = session.cmd_status_output("make -C %s TARGETS=tpm2 run_tests" % test_path, timeout=360)
logging.debug("Command output: %s", output)
if status:
test.fail("Failed to run test suite in guest OS.")
for test_sh in ["test_smoke.sh", "test_space.sh"]:
pattern = "ok .* selftests: tpm2: %s" % test_sh
if not re.search(pattern, output) or ("not ok" in output):
test.fail("test suite check failed.")
logging.info("------PASS on kernel test suite check------")
def reuse_by_vm2(tpm_dev):
"""
Try to add same tpm to a second guest, when it's being used by one guest.
:param tpm_dev: tpm device to be added into guest xml
"""
logging.info("------Trying to add same tpm to a second domain------")
vm2_xml.remove_all_device_by_type('tpm')
vm2_xml.add_device(tpm_dev)
vm2_xml.sync()
ret = virsh.start(vm2_name, ignore_status=True, debug=True)
if backend_type == "passthrough":
if ret.exit_status:
logging.info("Expected failure when try to passthrough a tpm"
" that being used by another guest")
return
test.fail("Reuse a passthroughed tpm should not succeed.")
elif ret.exit_status:
# emulator backend
test.fail("Vtpm for each guest should not interfere with each other")
try:
tpm_real_v = None
sec_uuids = []
new_name = ""
virsh_dargs = {"debug": True, "ignore_status": False}
vm_xml.remove_all_device_by_type('tpm')
tpm_dev = Tpm()
if tpm_model:
tpm_dev.tpm_model = tpm_model
if not no_backend:
backend = tpm_dev.Backend()
if backend_type != 'none':
backend.backend_type = backend_type
if backend_type == "passthrough":
tpm_real_v = get_host_tpm_bef(tpm_v)
logging.debug("The host tpm real version is %s", tpm_real_v)
if device_path:
backend.device_path = device_path
if backend_type == "emulator":
if backend_version != 'none':
backend.backend_version = backend_version
if prepare_secret:
auth_sec_dict = {"sec_ephemeral": "no",
"sec_private": "yes",
"sec_desc": "sample vTPM secret",
"sec_usage": "vtpm",
"sec_name": "VTPM_example"}
encryption_uuid = libvirt.create_secret(auth_sec_dict)
if secret_value != 'none':
virsh.secret_set_value(encryption_uuid, "open sesame", encode=True, debug=True)
sec_uuids.append(encryption_uuid)
if encrypt_change != 'encrpt':
# plain_to_encrypt will not add encryption on first start
if secret_uuid == 'invalid':
encryption_uuid = encryption_uuid[:-1]
backend.encryption_secret = encryption_uuid
if secret_uuid == "change":
auth_sec_dict["sec_desc"] = "sample2 vTPM secret"
auth_sec_dict["sec_name"] = "VTPM_example2"
new_encryption_uuid = libvirt.create_secret(auth_sec_dict)
virsh.secret_set_value(new_encryption_uuid, "open sesame", encode=True, debug=True)
sec_uuids.append(new_encryption_uuid)
if secret_uuid == 'nonexist':
backend.encryption_secret = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
tpm_dev.backend = backend
logging.debug("tpm dev xml to add is:\n %s", tpm_dev)
for num in range(tpm_num):
vm_xml.add_device(tpm_dev, True)
ret = virsh.define(vm_xml.xml, ignore_status=True, debug=True)
expected_match = ""
if not err_msg:
expected_match = "Domain .*%s.* defined from %s" % (vm_name, vm_xml.xml)
libvirt.check_result(ret, err_msg, "", False, expected_match)
if err_msg:
# Stop test when get expected failure
return
if vm_operate != "restart":
check_dumpxml(vm_name)
# For default model, no need start guest to test
if tpm_model:
expect_fail = False
try:
vm.start()
except VMStartError as detail:
if secret_value == 'none' or secret_uuid == 'nonexist':
logging.debug("Expected failure: %s", detail)
return
else:
test.fail(detail)
domuuid = vm.get_uuid()
if vm_operate or restart_libvirtd:
# Make sure OS works before vm operate or restart libvirtd
session = vm.wait_for_login()
test_guest_tpm("2.0", session, False)
session.close()
if restart_libvirtd:
utils_libvirtd.libvirtd_restart()
swtpm_statedir = "/var/lib/libvirt/swtpm/%s" % domuuid
if vm_operate == "resume":
virsh.suspend(vm_name, **virsh_dargs)
time.sleep(3)
virsh.resume(vm_name, **virsh_dargs)
elif vm_operate == "snapshot":
virsh.snapshot_create_as(vm_name, "sp1 --memspec file=/tmp/testvm_sp1", **virsh_dargs)
elif vm_operate in ["restart", "create"]:
vm.destroy()
if vm_operate == "create":
virsh.undefine(vm_name, options="--nvram", **virsh_dargs)
if os.path.exists(swtpm_statedir):
test.fail("Swtpm state dir: %s still exist after vm undefine" % swtpm_statedir)
virsh.create(vm_xml.xml, **virsh_dargs)
else:
if vm_oprt == "domrename":
new_name = "vm_" + utils_misc.generate_random_string(5)
virsh.domrename(vm_name, new_name, **virsh_dargs)
new_vm = libvirt_vm.VM(new_name, vm.params, vm.root_dir, vm.address_cache)
vm = new_vm
vm_name = new_name
elif secret_value == 'change':
logging.info("Changing secret value...")
virsh.secret_set_value(encryption_uuid, "new sesame", encode=True, debug=True)
elif not restart_libvirtd:
# remove_dev or do other vm operations during restart
vm_xml.remove_all_device_by_type('tpm')
if secret_uuid == "change" or encrypt_change:
# Change secret uuid, or change encrytion state:from plain to encrypted, or on the contrary
if encrypt_change == 'plain':
# Change from encrypted state to plain：redefine a tpm dev without encryption
tpm_dev = Tpm()
tpm_dev.tpm_model = tpm_model
backend = tpm_dev.Backend()
backend.backend_type = backend_type
backend.backend_version = backend_version
else:
# Use a new secret's uuid
if secret_uuid == "change":
encryption_uuid = new_encryption_uuid
backend.encryption_secret = encryption_uuid
tpm_dev.backend = backend
logging.debug("The new tpm dev xml to add for restart vm is:\n %s", tpm_dev)
vm_xml.add_device(tpm_dev, True)
if encrypt_change in ['encrpt', 'plain']:
# Avoid sync() undefine removing the state file
vm_xml.define()
else:
vm_xml.sync()
if rm_statefile:
swtpm_statefile = "%s/tpm2/tpm2-00.permall" % swtpm_statedir
logging.debug("Removing state file: %s", swtpm_statefile)
os.remove(swtpm_statefile)
ret = virsh.start(vm_name, ignore_status=True, debug=True)
libvirt.check_exit_status(ret, status_error)
if status_error and ret.exit_status != 0:
return
if not remove_dev:
check_dumpxml(vm_name)
elif vm_operate == 'managedsave':
virsh.managedsave(vm_name, **virsh_dargs)
time.sleep(5)
if secret_value == 'change':
logging.info("Changing secret value...")
virsh.secret_set_value(encryption_uuid, "new sesame", encode=True, debug=True)
if rm_statefile:
swtpm_statefile = "%s/tpm2/tpm2-00.permall" % swtpm_statedir
logging.debug("Removing state file: %s", swtpm_statefile)
os.remove(swtpm_statefile)
ret = virsh.start(vm_name, ignore_status=True, debug=True)
libvirt.check_exit_status(ret, status_error)
if status_error and ret.exit_status != 0:
return
domid = vm.get_id()
check_qemu_cmd_line(vm, vm_name, domid)
if backend_type == "passthrough":
if tpm_real_v == "1.2" and tpm_model == "tpm-crb":
expect_fail = True
expect_version = tpm_real_v
test_host_tpm_aft(tpm_real_v)
else:
# emulator backend
if remove_dev:
expect_fail = True
expect_version = backend_version
check_swtpm(domid, domuuid, vm_name)
session = vm.wait_for_login()
if test_suite:
run_test_suite_in_guest(session)
else:
test_guest_tpm(expect_version, session, expect_fail)
session.close()
if multi_vms:
reuse_by_vm2(tpm_dev)
if backend_type != "passthrough":
#emulator backend
check_dumpxml(vm2_name)
domid = vm2.get_id()
domuuid = vm2.get_uuid()
check_qemu_cmd_line(vm2, vm2_name, domid)
check_swtpm(domid, domuuid, vm2_name)
session = vm2.wait_for_login()
test_guest_tpm(backend_version, session, expect_fail)
session.close()
finally:
# Remove renamed domain if it exists
if new_name:
virsh.remove_domain(new_name, "--nvram", debug=True)
if os.path.exists("/var/log/swtpm/libvirt/qemu/%s-swtpm.log" % new_name):
os.remove("/var/log/swtpm/libvirt/qemu/%s-swtpm.log" % new_name)
# Remove snapshot if exists
if vm_operate == "snapshot":
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")
if os.path.exists("/tmp/testvm_sp1"):
os.remove("/tmp/testvm_sp1")
# Clear guest os
if test_suite:
session = vm.wait_for_login()
logging.info("Removing dir /root/linux-*")
output = session.cmd_output("rm -rf /root/linux-*")
logging.debug("Command output:\n %s", output)
session.close()
if vm_operate == "create":
vm.define(vm_xml.xml)
vm_xml_backup.sync(options="--nvram --managed-save")
# Remove swtpm log file in case of impact on later runs
if os.path.exists("/var/log/swtpm/libvirt/qemu/%s-swtpm.log" % vm.name):
os.remove("/var/log/swtpm/libvirt/qemu/%s-swtpm.log" % vm.name)
for sec_uuid in set(sec_uuids):
virsh.secret_undefine(sec_uuid, ignore_status=True, debug=True)
if vm2:
if len(vm_names) > 1:
vm2_xml_backup.sync(options="--nvram")
else:
virsh.remove_domain(vm2_name, "--nvram --remove-all-storage", debug=True)
if os.path.exists("/var/log/swtpm/libvirt/qemu/%s-swtpm.log" % vm2.name):
os.remove("/var/log/swtpm/libvirt/qemu/%s-swtpm.log" % vm2.name)
def run(test, params, env):
"""
Check the timedrift on all the guests when attached all guests to CPUs
1) boot the multi guests, e.g., boot 4 vms
2) pin every guest process to one physical CPU
3) reboot one of the guests, or change the time of one guest
4) check the timedrift on all the guests
:param test: QEMU test object.
:param params: Dictionary with test parameters.
:param env: Dictionary with the test environment.
"""
def verify_guest_clock_source(session, expected):
"""
:param session: VM session
:param expected: expected clocksource
"""
if expected not in session.cmd(clocksource_cmd):
test.fail("Guest doesn't use '%s' clocksource" % expected)
ntp_cmd = params["ntp_cmd"]
ntp_stop_cmd = params["ntp_stop_cmd"]
ntp_query_cmd = params["ntp_query_cmd"]
ntp_service = params["ntp_service"]
clocksource = params.get("clocksource", "kvm-clock")
clocksource_cmd = params["clocksource_cmd"]
expected_time_drift = params["expected_time_drift"]
same_cpu = params["same_cpu"]
error_context.context("Sync host time with ntp server", logging.info)
service_manager = service.ServiceManager()
service_manager.stop(ntp_service)
process.system(ntp_cmd, shell=True)
error_context.context("Boot four guests", logging.info)
params["start_vm"] = "yes"
vms = params.get("vms").split()
vm_obj = []
sessions = []
host_cpu_list = cpu.online_list()
if same_cpu == "no":
if len(host_cpu_list) < len(vms):
test.cancel("There aren't enough physical cpus to pin all guests")
for vm_name in vms:
env_process.preprocess_vm(test, params, env, vm_name)
vm = env.get_vm(vm_name)
vm.verify_alive()
vm_obj.append(vm)
sessions.append(vm.wait_for_login())
error_context.context("Pin guest to physical cpu", logging.info)
for vmid, se in enumerate(sessions):
# Get the respective vm object
cpu_id = vmid if same_cpu == "no" else 0
process.system("taskset -cp %s %s" %
(host_cpu_list[cpu_id], vm_obj[vmid].get_pid()),
shell=True)
error_context.context("Check the current clocksource", logging.info)
currentsource = se.cmd_output_safe(clocksource_cmd)
if clocksource not in currentsource:
error_context.context(
"Update guest kernel cli to %s" % clocksource, logging.info)
utils_time.update_clksrc(vm_obj[vmid], clksrc=clocksource)
verify_guest_clock_source(se, clocksource)
error_context.context("Stop ntp service in guest", logging.info)
status, output = se.cmd_status_output(ntp_stop_cmd)
vmid_test = random.randint(0, len(vms) - 1)
vm = vm_obj[vmid_test]
se = sessions[vmid_test]
if same_cpu == "no":
error_context.context("Reboot one of the guests", logging.info)
se = vm.reboot(se)
status, output = se.cmd_status_output(ntp_stop_cmd)
sessions[vmid_test] = se
else:
error_context.context("Change time in one of the guests", logging.info)
change_time_cmd = params["change_time_cmd"]
se.cmd_output_safe(change_time_cmd)
error_context.context("Check the timedrift on all the guests",
logging.info)
fail_offset = []
for vmid, se in enumerate(sessions):
if same_cpu == "yes" and vmid == vmid_test:
continue
output = se.cmd_output_safe(ntp_query_cmd)
offset = float(re.findall(r"[+-]?(\d+\.\d+)", output, re.M)[-1])
logging.info("The time drift of guest %s is %ss.", vmid, offset)
if offset > float(expected_time_drift):
fail_offset.append((vmid, offset))
if fail_offset:
test.fail("The time drift of following guests %s are larger than 5s." %
fail_offset)
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')
enable_legacy_policy = params_get(params, "enable_legacy_policy") == 'yes'
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")
os_pool = 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 enable_legacy_policy:
update_crypto_policy("LEGACY")
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("Unsupported hypervisor: %s" % hypervisor)
# Create libvirt URI
v2v_uri = utils_v2v.Uri(hypervisor)
remote_uri = v2v_uri.get_uri(source_ip, vpx_dc, esx_ip)
LOG.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)
LOG.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
"""
LOG.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():
LOG.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"))
LOG.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()
LOG.debug("Disks in VM: %s", output)
disks = len(re.findall(r'Disk\s\d', output))
LOG.debug("Find %s disks in VM after convert", disks)
if disks == expected_disks:
LOG.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
"""
LOG.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
LOG.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)
LOG.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(
)
LOG.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 conversion
"""
blk = vmcheck.session.cmd('lsblk')
LOG.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)))
LOG.info('Change disk bus to %s' % dest)
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
disks = vmxml.get_disk_all_by_expr('device==disk')
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'
LOG.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
LOG.debug('MAC list before v2v: %s' % mac_list)
LOG.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'
LOG.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'}
LOG.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')
LOG.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_guestfish = "guestfish get-cachedir"
tmp_dir = session.cmd_output(cmd_guestfish).split()[-1]
LOG.debug('Command output of tmp_dir: %s', tmp_dir)
cmd_df = "df -m %s --output=avail" % tmp_dir
df_output = session.cmd(cmd_df).strip()
LOG.debug('Command output: %s', df_output)
avail = int(df_output.strip().split('\n')[-1])
LOG.info('Available space: %dM' % avail)
if avail <= left_space - 1:
return None
if not os.path.exists(tmp_dir):
os.mkdir(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)
newAvail = int(session.cmd(cmd_df).strip().split('\n')[-1])
LOG.info('New Available space: %sM' % newAvail)
return large_file
@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()
LOG.debug('Current selinux status: %s', current_stat)
if current_stat != value:
cmd = "sed -E -i 's/(^SELINUX=).*?/\\1%s/' /etc/selinux/config" % value
LOG.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()
LOG.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()
LOG.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):
"""
Execute a list of commands on guest.
"""
session = kwargs['session']
for cmd in cmd_list:
LOG.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)
LOG.debug('Command output:\n%s', output)
if status != 0:
test.error('Command "%s" failed' % cmd)
LOG.info('All commands executed')
def check_time_keep(vmcheck):
"""
Check time drift after conversion.
"""
LOG.info('Check time drift')
output = vmcheck.session.cmd('chronyc tracking')
LOG.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))
LOG.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()
LOG.info('Booting up %s' % vm_name)
vm.start()
vm.wait_for_login()
vm.shutdown()
LOG.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 == 'json' and not check_json_output(params):
test.fail('check json output failed')
if output_mode == 'local' and not check_local_output(params):
test.fail('check local output failed')
if output_mode in ['null', 'json', 'local']:
return
vmchecker = VMChecker(test, params, env)
params['vmchecker'] = vmchecker
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 conversion
if params.get('skip_vm_check') != 'yes':
ret = vmchecker.run()
if len(ret) == 0:
LOG.info("All common checkpoints passed")
LOG.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 removable 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 utils_v2v.multiple_versions_compare(
V2V_ADAPTE_SPICE_REMOVAL_VER):
expect_video_type = 'vga'
else:
expect_video_type = 'qxl'
if video_type.lower() != expect_video_type:
log_fail('Video expect %s, actual %s' %
(expect_video_type, video_type))
if checkpoint.startswith('listen'):
listen_type = vmchecker.xmltree.find(
'./devices/graphics/listen').get('type')
LOG.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()
LOG.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,
'os_storage': storage,
'os_pool': os_pool,
'hostname': source_ip,
'password': source_pwd,
'v2v_opts': v2v_opts,
'new_name': vm_name + utils_misc.generate_random_string(3),
'output_method': output_method,
'os_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({'of_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)
})
LOG.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)
LOG.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['os_directory'] = data_dir.get_tmp_dir()
if output_mode == 'libvirt':
pvt.pre_pool(pool_name, pool_type, pool_target, '')
# Set libguestfs environment variable
utils_v2v.set_libguestfs_backend(params)
# 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 = len(new_xml.get_disk_all_by_expr('device==disk'))
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)
LOG.info('VM state: %s' % virsh.domstate(vm_name).stdout.strip())
if checkpoint == 'paused':
virsh.start(vm_name, '--paused')
LOG.info('VM state: %s' % virsh.domstate(vm_name).stdout.strip())
if checkpoint == 'serial_terminal':
grub_serial_terminal()
check_boot()
if checkpoint.startswith('host_no_space'):
session = aexpect.ShellSession('sh')
large_file = create_large_file(session, 800)
if checkpoint == 'host_no_space_setcache':
LOG.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')
LOG.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]
LOG.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]
LOG.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()
LOG.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':
LOG.info('Remove /etc/securetty file from guest')
cmd = ['rm -f /etc/securetty']
vm_cmd(cmd)
if checkpoint == 'ntpd_on':
LOG.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':
LOG.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')
LOG.info('Create blank disk %s', disk_path)
process.run('truncate -s 1G %s' % disk_path)
LOG.info('Attach blank disk to vm')
attach_removable_media('disk', disk_path, 'vdc')
LOG.debug(virsh.dumpxml(vm_name))
if checkpoint in ['only_net', 'only_br']:
LOG.info('Detatch all networks')
virsh.detach_interface(vm_name, 'network --current', debug=True)
LOG.info('Detatch all bridges')
virsh.detach_interface(vm_name, 'bridge --current', debug=True)
if checkpoint == 'only_net':
LOG.info('Attach network')
virsh.attach_interface(vm_name,
'network default --current',
debug=True)
if checkpoint == 'only_br':
LOG.info('Attatch bridge')
virsh.attach_interface(vm_name,
'bridge virbr0 --current',
debug=True)
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()
LOG.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:
LOG.debug('virsh session %s is closing', v2v_virsh)
v2v_virsh.close_session()
if params.get('vmchecker'):
params['vmchecker'].cleanup()
if enable_legacy_policy:
update_crypto_policy()
if hypervisor == "xen":
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()
LOG.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'):
if large_file and os.path.isfile(large_file):
os.remove(large_file)
# Cleanup constant files
utils_v2v.cleanup_constant_files(params)
def run(test, params, env):
"""
This case check error messages in libvirtd logging.
Implemented test cases:
with_iptables: Start libvirtd when using iptables service as firewall.
with_firewalld: Start libvirtd when using firewalld service as firewall.
no_firewall: Start libvirtd With both firewall services shut off.
"""
def _error_handler(line, errors):
"""
A callback function called when new error lines appears in libvirtd
log, then this line is appended to list 'errors'
:param errors: A list to contain all error lines.
:param line: Newly found error line in libvirtd log.
"""
errors.append(line)
def _check_errors():
"""
Check for unexpected error messages in libvirtd log.
"""
logging.info('Checking errors in libvirtd log')
accepted_error_patterns = [
'Cannot access storage file',
'Failed to autostart storage pool',
'cannot open directory',
]
if (not iptables_service and not firewalld_service
and 'virt_t' not in libvirt_context):
logging.info("virt_t is not in libvirtd process context. "
"Failures for setting iptables rules will be ignored")
# libvirtd process started without virt_t will failed to set
# iptables rules which is expected here
accepted_error_patterns.append(
'/sbin/iptables .* unexpected exit status 1')
logging.debug("Accepted errors are: %s", accepted_error_patterns)
if errors:
logging.debug("Found errors in libvirt log:")
for line in errors:
logging.debug(line)
unexpected_errors = []
for line in errors:
if any([re.search(p, line) for p in accepted_error_patterns]):
logging.debug('Error "%s" is acceptable', line)
else:
unexpected_errors.append(line)
if unexpected_errors:
raise exceptions.TestFail(
"Found unexpected errors in libvirt log:\n%s" %
'\n'.join(unexpected_errors))
iptables_service = params.get('iptables_service', 'off') == 'on'
firewalld_service = params.get('firewalld_service', 'off') == 'on'
# In RHEL7 iptables service is provided by a separated package
# In RHEL6 iptables-services and firewalld is not supported
# So try to install all required packages but ignore failures
logging.info('Preparing firewall related packages')
software_mgr = software_manager.SoftwareManager()
for pkg in ['iptables', 'iptables-services', 'firewalld']:
if not software_mgr.check_installed(pkg):
software_mgr.install(pkg)
# Backup services status
service_mgr = service.ServiceManager()
logging.info('Backing up firewall services status')
backup_iptables_status = service_mgr.status('iptables')
backup_firewalld_status = service_mgr.status('firewalld')
# iptables-service got deprecated in newer distros
if iptables_service and backup_iptables_status is None:
raise exceptions.TestSkipError('iptables service not found')
# firewalld service could not exists on many distros
if firewalld_service and backup_firewalld_status is None:
raise exceptions.TestSkipError('firewalld service not found')
try:
if iptables_service and firewalld_service:
raise exceptions.TestError(
'iptables service and firewalld service can not be started at '
'the same time')
# We should stop services first then start the other after.
# Directly start one service will force the other service stop,
# which will not be easy to handle.
# Backup status should be compared with None to make sure that
# service exists before action.
logging.info('Changing firewall services status')
if not iptables_service and backup_iptables_status is not None:
process.run('iptables-save > /tmp/iptables.save', shell=True)
service_mgr.stop('iptables')
if not firewalld_service and backup_firewalld_status is not None:
service_mgr.stop('firewalld')
if iptables_service and backup_iptables_status is not None:
service_mgr.start('iptables')
if firewalld_service and backup_firewalld_status is not None:
service_mgr.start('firewalld')
errors = []
# Run libvirt session and collect errors in log.
libvirtd_session = utils_libvirtd.LibvirtdSession(
service_name="virtnetworkd",
logging_handler=_error_handler,
logging_params=(errors, ),
logging_pattern=r'[-\d]+ [.:+\d]+ [:\d]+ error :',
)
try:
logging.info('Starting libvirtd session')
libvirtd_session.start()
time.sleep(3)
libvirt_pid = libvirtd_session.tail.get_pid()
sestatus = utils_selinux.get_status()
if sestatus == "disabled":
raise exceptions.TestSkipError("SELinux is in Disabled mode."
"It must be in enforcing mode "
"for test execution")
libvirt_context = utils_selinux.get_context_of_process(libvirt_pid)
logging.debug("The libvirtd process context is: %s",
libvirt_context)
finally:
libvirtd_session.exit()
_check_errors()
finally:
logging.info('Recovering services status')
#Restart socket service after starting process at foreground
utils_libvirtd.Libvirtd("virtnetworkd.socket").restart()
# If service do not exists, then backup status and current status
# will all be none and nothing will be done
if service_mgr.status('iptables') != backup_iptables_status:
if backup_iptables_status:
service_mgr.start('iptables')
process.run('iptables-restore < /tmp/iptables.save',
shell=True)
else:
service_mgr.stop('iptables')
if service_mgr.status('firewalld') != backup_firewalld_status:
if backup_firewalld_status:
service_mgr.start('firewalld')
else:
service_mgr.stop('firewalld')
logging.info('Removing backup iptables')
if os.path.exists("/tmp/iptables.save"):
os.remove("/tmp/iptables.save")
