def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
incoming_port = params.get('incoming_port')
share_images_dir = params.get('share_images_dir')
test = CreateTest(case_id='rhel7_10040', params=params)
id = test.get_id()
src_host_session = HostSession(id, params)
test.main_step_log('1. Boot guest with a system disk, a block data disk '
'and a scsi data disk.')
test.sub_step_log('1.1 Create two images on src host')
d0 = 'd0'
d1 = 'd1'
qcow2 = 'qcow2'
create_disk(host_session=src_host_session,
disk_dir=share_images_dir,
disk_name=d0,
disk_format=qcow2,
disk_size=1024)
create_disk(host_session=src_host_session,
disk_dir=share_images_dir,
disk_name=d1,
disk_format=qcow2,
disk_size=1024)
test.sub_step_log('1.2 Boot a guest')
params.vm_base_cmd_add(
'drive', 'file=%s/d0.qcow2,format=qcow2,if=none,'
'id=drive-virtio-blk0,werror=stop,'
'rerror=stop' % share_images_dir)
params.vm_base_cmd_add(
'device', 'virtio-blk-pci,drive=drive-virtio-blk0,'
'id=virtio-blk0,bus=pci.0,addr=10,'
'bootindex=10')
params.vm_base_cmd_add(
'drive', 'file=%s/d1.qcow2,if=none,id=drive_r4,'
'format=qcow2,cache=none,aio=native,'
'werror=stop,rerror=stop' % share_images_dir)
params.vm_base_cmd_add(
'device', 'scsi-hd,drive=drive_r4,id=r4,'
'bus=virtio_scsi_pci0.0,channel=0,'
'scsi-id=0,lun=1')
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
test.sub_step_log('1.3 Connecting to src serial')
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
src_guest_ip = src_serial.serial_login()
test.main_step_log('2. In HMP, hot remove the block data disk '
'and scsi data disk.')
src_remote_qmp.qmp_cmd_output(
'{"execute":"device_del","arguments":'
'{"id":"virtio-blk0"}}',
recv_timeout=5)
src_remote_qmp.qmp_cmd_output(
'{"execute":"device_del","arguments":'
'{"id":"r4"}}', recv_timeout=5)
test.sub_step_log('Check guest disk again')
time.sleep(3)
output = src_remote_qmp.qmp_cmd_output('{"execute":"query-block"}',
recv_timeout=5)
if re.findall(r'virtio-blk0', output) or re.findall(r'r4', output):
src_remote_qmp.test_error('Failed to hot remove two data disks.')
test.main_step_log('3. Boot guest with \'-incoming\' on des host '
'with only system disk.')
params.vm_base_cmd_del(
'drive', 'file=%s/d0.qcow2,format=qcow2,if=none,'
'id=drive-virtio-blk0,werror=stop,'
'rerror=stop' % share_images_dir)
params.vm_base_cmd_del(
'device', 'virtio-blk-pci,drive=drive-virtio-blk0,'
'id=virtio-blk0,bus=pci.0,addr=10,'
'bootindex=10')
params.vm_base_cmd_del(
'drive', 'file=%s/d1.qcow2,if=none,id=drive_r4,'
'format=qcow2,cache=none,aio=native,'
'werror=stop,rerror=stop' % share_images_dir)
params.vm_base_cmd_del(
'device', 'scsi-hd,drive=drive_r4,id=r4,'
'bus=virtio_scsi_pci0.0,channel=0,'
'scsi-id=0,lun=1')
incoming_val = 'tcp:0:%s' % incoming_port
params.vm_base_cmd_add('incoming', incoming_val)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(cmd=dst_qemu_cmd,
ip=dst_host_ip,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
output = dst_remote_qmp.qmp_cmd_output('{"execute":"query-block"}',
recv_timeout=10)
if re.findall('virtio-blk0', output) or re.findall('r4', output):
dst_remote_qmp.test_error('Destination guest boot error')
test.main_step_log('4. Start live migration from src host')
flag = do_migration(remote_qmp=src_remote_qmp,
migrate_port=incoming_port,
dst_ip=dst_host_ip)
if (flag == False):
test.test_error('Migration timeout')
test.main_step_log('5. Check guest status. Reboot guest , guest has '
'1 system disk and keeps working well.')
dst_serial = RemoteSerialMonitor(id, params, dst_host_ip, serial_port)
cmd = 'dmesg'
output = dst_serial.serial_cmd_output(cmd=cmd)
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace')
test.sub_step_log('5.1 Reboot dst guest')
dst_serial.serial_cmd(cmd='reboot')
dst_guest_ip = dst_serial.serial_login()
test.sub_step_log('5.2 Check if guest only has 1 system disk')
output = dst_remote_qmp.qmp_cmd_output('{"execute":"query-block"}',
recv_timeout=5)
if re.findall('drive-virtio-blk0', output) or re.findall('r4', output):
dst_remote_qmp.test_error('Destination guest has other disk '
'except 1 system disk')
dst_guest_session = GuestSession(case_id=id,
params=params,
ip=dst_guest_ip)
output = dst_guest_session.guest_cmd_output(cmd='fdisk -l', timeout=60)
if re.findall(r'/dev/sda', output):
dst_guest_session.test_print('The system disk is in disk')
test.sub_step_log('5.3 Can access guest from external host')
dst_guest_session.guest_ping_test('www.redhat.com', 10)
test.sub_step_log('5.4 quit qemu on src end and shutdown vm on dst end')
dst_serial.serial_shutdown_vm()
output = src_remote_qmp.qmp_cmd_output('{"execute":"quit"}',
recv_timeout=3)
if output:
src_remote_qmp.test_error('Failed to quit qemu on src host')
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
incoming_port = params.get('incoming_port')
test = CreateTest(case_id='rhel7_49062', params=params)
id = test.get_id()
src_host_session = HostSession(id, params)
val_M = '2000'
val_s = '10000'
test.main_step_log('1. Launch guest on source host')
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
src_guest_ip = src_serial.serial_login()
src_guest_session = GuestSession(case_id=id,
params=params,
ip=src_guest_ip)
test.sub_step_log('2. stress guest(migration could finish for scenario1/'
'could never finish for scenario 2)')
utils_migration.stressapptest(guest_session=src_guest_session,
val_M=val_M,
val_s=val_s)
test.main_step_log('3. Launch guest on destination host')
incoming_val = 'tcp:0:%s' % incoming_port
params.vm_base_cmd_add('incoming', incoming_val)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(cmd=dst_qemu_cmd,
ip=dst_host_ip,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
test.main_step_log('4. On source qemu & dst qemu, set postcopy mode on')
test.sub_step_log('set src host postcopy-ram on')
utils_migration.set_migration_capabilities(remote_qmp=src_remote_qmp,
capabilities='postcopy-ram',
state='true')
test.sub_step_log('set dst host postcopy-ram on')
utils_migration.set_migration_capabilities(remote_qmp=dst_remote_qmp,
capabilities='postcopy-ram',
state='true')
test.main_step_log('5. migrate guest to destination')
cmd = '{"execute":"migrate", "arguments": { "uri": "tcp:%s:%s" }}' \
% (dst_host_ip, incoming_port)
src_remote_qmp.qmp_cmd_output(cmd=cmd)
test.sub_step_log('6. Change into postcopy mode')
output = utils_migration.query_migration(remote_qmp=src_remote_qmp,
chk_timeout=300)
if (output == False):
test.test_print('Migration can not finish without postcopy')
cmd = '{"execute":"migrate-start-postcopy"}'
src_remote_qmp.qmp_cmd_output(cmd=cmd)
info = utils_migration.query_migration(remote_qmp=src_remote_qmp)
if (info == False):
test.test_error('Migration timeout with postcopy')
else:
test.test_print('Migration finished without postcopy')
test.main_step_log(
'7. Check guest status before and after migration finished')
dst_serial = RemoteSerialMonitor(id, params, dst_host_ip, serial_port)
output = dst_serial.serial_cmd_output('dmesg')
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace after migration')
dst_serial.serial_cmd(cmd='reboot')
dst_guest_ip = dst_serial.serial_login()
dst_guest_session = GuestSession(case_id=id,
params=params,
ip=dst_guest_ip)
dst_guest_session.guest_ping_test(dst_ip='www.redhat.com', count=10)
test.main_step_log('8. Check postcopy statistics')
cmd = '{"execute":"query-migrate"}'
output = src_remote_qmp.qmp_cmd_output(cmd=cmd)
if re.findall(r'"postcopy-requests": 0', output):
test.test_error('the value postcopy-requests is zero')
else:
test.test_print('the value postcopy-requests is not zero')
test.main_step_log(
'9.repeat step2~8 to migrate guest back to source host.')
test.sub_step_log('9.1 quit src qemu')
src_remote_qmp.qmp_cmd_output(cmd='{"execute":"quit"}')
src_host_session.check_guest_process(src_ip=src_host_ip)
test.sub_step_log('9.2 boot src guest again')
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
test.sub_step_log('9.3 stress guest')
utils_migration.stressapptest(guest_session=dst_guest_session,
val_M=val_M,
val_s=val_s)
test.sub_step_log('9.4 set src and dst postcopy-ram on')
test.sub_step_log('set src host postcopy-ram on')
utils_migration.set_migration_capabilities(remote_qmp=src_remote_qmp,
capabilities='postcopy-ram',
state='true')
test.sub_step_log('set dst host postcopy-ram on')
utils_migration.set_migration_capabilities(remote_qmp=dst_remote_qmp,
capabilities='postcopy-ram',
state='true')
test.sub_step_log('9.5 migrate guest to source')
cmd = '{"execute":"migrate", "arguments": { "uri": "tcp:%s:%s" }}' \
% (src_host_ip, incoming_port)
dst_remote_qmp.qmp_cmd_output(cmd=cmd)
test.sub_step_log('9.6. Change into postcopy mode')
output = utils_migration.query_migration(remote_qmp=dst_remote_qmp,
chk_timeout=300)
if (output == False):
test.test_print('Migration can not finish without postcopy')
cmd = '{"execute":"migrate-start-postcopy"}'
dst_remote_qmp.qmp_cmd_output(cmd=cmd)
info = utils_migration.query_migration(remote_qmp=dst_remote_qmp)
if (info == False):
test.test_error('Migration timeout with postcopy')
else:
test.test_print('Migration finished without postcopy')
test.main_step_log(
'9.7. Check guest status before and after migration finished')
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
output = src_serial.serial_cmd_output('dmesg')
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace after migration')
src_serial.serial_cmd(cmd='reboot')
src_guest_ip = src_serial.serial_login()
src_guest_session = GuestSession(case_id=id,
params=params,
ip=src_guest_ip)
src_guest_session.guest_ping_test(dst_ip='www.redhat.com', count=10)
test.main_step_log('9.8. Check postcopy statistics')
cmd = '{"execute":"query-migrate"}'
output = dst_remote_qmp.qmp_cmd_output(cmd=cmd)
if re.findall(r'"postcopy-requests": 0', output):
test.test_error('the value postcopy-requests is zero')
else:
test.test_print('the value postcopy-requests is not zero')
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
incoming_port = params.get('incoming_port')
test = CreateTest(case_id='rhel7_10035', params=params)
id = test.get_id()
src_host_session = HostSession(id, params)
downtime = 10000
speed = 52428800
speed_m = speed / 1024 / 1024
stress_time = 120
gap_speed = 5
gap_downtime = 5000
test.main_step_log('1.Boot up a guest on source host')
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
test.sub_step_log('1.1 Connecting to src serial')
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
src_guest_ip = src_serial.serial_login()
src_guest_session = GuestSession(case_id=id,
params=params,
ip=src_guest_ip)
test.main_step_log('2. Running some application inside guest')
chk_cmd = 'yum list installed | grep stress.`arch`'
output = src_guest_session.guest_cmd_output(cmd=chk_cmd)
if not output:
install_cmd = 'yum install -y stress.`arch`'
install_info = src_guest_session.guest_cmd_output(cmd=install_cmd)
if re.findall('Complete', install_info):
test.test_print('Guest install stress pkg successfully')
else:
test.test_error('Guest failed to install stress pkg')
stress_cmd = 'stress --cpu 4 --vm 4 --vm-bytes 256M --timeout %d' \
% stress_time
thread = threading.Thread(target=src_guest_session.guest_cmd_output,
args=(stress_cmd, 1200))
thread.name = 'stress'
thread.daemon = True
thread.start()
time.sleep(10)
output = src_guest_session.guest_cmd_output('pgrep -x stress')
if not output:
test.test_error('Stress is not running in guest')
test.main_step_log('3. Boot up the guest on destination host')
incoming_val = 'tcp:0:%s' % incoming_port
params.vm_base_cmd_add('incoming', incoming_val)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(cmd=dst_qemu_cmd,
ip=dst_host_ip,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
dst_serial = RemoteSerialMonitor(id, params, dst_host_ip, serial_port)
test.main_step_log('4.Set the migration speed and downtime')
downtime_cmd = '{"execute":"migrate-set-parameters","arguments":' \
'{"downtime-limit": %d}}' % downtime
src_remote_qmp.qmp_cmd_output(cmd=downtime_cmd)
speed_cmd = '{"execute":"migrate-set-parameters","arguments":' \
'{"max-bandwidth": %d}}' % speed
src_remote_qmp.qmp_cmd_output(cmd=speed_cmd)
paras_chk_cmd = '{"execute":"query-migrate-parameters"}'
output = src_remote_qmp.qmp_cmd_output(cmd=paras_chk_cmd)
if re.findall(r'"downtime-limit": %d' % downtime, output) \
and re.findall(r'"max-bandwidth": %d' % speed, output):
test.test_print('Change downtime and speed successfully')
else:
test.test_error('Failed to change downtime and speed')
test.main_step_log('5. Migrate guest from source host to destination host')
check_info = do_migration(remote_qmp=src_remote_qmp,
migrate_port=incoming_port,
dst_ip=dst_host_ip)
if (check_info == False):
test.test_error('Migration timeout')
test.main_step_log('6.After migration finished,check migration statistics')
cmd = '{"execute":"query-migrate"}'
output = eval(src_remote_qmp.qmp_cmd_output(cmd=cmd))
transferred_ram = int(output.get('return').get('ram').get('transferred'))
transferred_ram_cal = transferred_ram / 1024 / 1024
total_time = int(output.get('return').get('total-time'))
total_time_cal = total_time / 1000
speed_cal = transferred_ram_cal / total_time_cal
gap_cal = abs(speed_cal - speed_m)
if (gap_cal >= gap_speed):
test.test_error('The real migration speed and expected speed '
'have a gap more than %d M/s' % gap_speed)
else:
test.test_print('The real migration speed is not more or less than '
'expected speed by %d M/s' % gap_speed)
real_downtime = int(output.get('return').get('downtime'))
gap_cal = real_downtime - downtime
if (gap_cal > gap_downtime):
test.test_error('The real migration downtime and expected downtime '
'have a gap more than %d milliseconds' % gap_downtime)
else:
test.test_print('The real migration downtime is not more or less than '
'expected downtime by %d milliseconds' % gap_downtime)
test.main_step_log('7.After migration finished, check the status of guest')
test.sub_step_log('7.1 Reboot guest')
test.sub_step_log('check dmesg info')
cmd = 'dmesg'
output = dst_serial.serial_cmd_output(cmd=cmd)
if re.findall(r'Call Trace:', output) or not output:
test.test_error('Guest hit call trace')
dst_serial.serial_cmd(cmd='reboot')
dst_guest_ip = dst_serial.serial_login()
test.sub_step_log('7.2 DD a file inside guest')
dst_guest_session = GuestSession(case_id=id,
params=params,
ip=dst_guest_ip)
cmd_dd = 'dd if=/dev/zero of=file1 bs=100M count=10 oflag=direct'
output = dst_guest_session.guest_cmd_output(cmd=cmd_dd, timeout=600)
if not output or re.findall('error', output):
test.test_error('Failed to dd a file in guest')
test.sub_step_log('7.3 Shutdown guest')
dst_serial.serial_shutdown_vm()
output = src_remote_qmp.qmp_cmd_output('{"execute":"quit"}',
recv_timeout=3)
if output:
src_remote_qmp.test_error('Failed to quit qemu on src end')
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
incoming_port = params.get('incoming_port')
test = CreateTest(case_id='rhel7_10056', params=params)
id = test.get_id()
src_host_session = HostSession(id, params)
speed = '1073741824'
active_timeout = 300
test.main_step_log('1. Start VM with high load, with each method is ok')
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
test.sub_step_log('1.1 Connecting to src serial')
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
src_guest_ip = src_serial.serial_login()
src_guest_session = GuestSession(case_id=id,
params=params,
ip=src_guest_ip)
test.sub_step_log('1.2 Running stress in src guest')
utils_migration.stress_test(guest_session=src_guest_session)
test.main_step_log('2. Start listening mode on dst host and '
'on src host do migration')
test.sub_step_log('2.1 Start listening mode on dst host')
incoming_val = 'tcp:0:%s' % incoming_port
params.vm_base_cmd_add('incoming', incoming_val)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(cmd=dst_qemu_cmd,
ip=dst_host_ip,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
test.sub_step_log('2.2. Do live migration from src to dst')
cmd = '{"execute":"migrate", "arguments": {"uri": "tcp:%s:%s"}}' % \
(dst_host_ip, incoming_port)
src_remote_qmp.qmp_cmd_output(cmd)
test.main_step_log('3.Enlarge migration speed')
flag_active = utils_migration.query_status(remote_qmp=src_remote_qmp,
status='active')
if (flag_active == False):
src_remote_qmp.test_error('Migration could not be active within %d' %
active_timeout)
utils_migration.change_speed(remote_qmp=src_remote_qmp, speed_val=speed)
test.sub_step_log('3.2 Check migration status again')
flag_1 = utils_migration.query_migration(remote_qmp=src_remote_qmp)
if (flag_1 == False):
test.test_error('Migration timeout after changing speed')
test.main_step_log('4. After migration, check if guest works well.')
test.sub_step_log('4.1 Guest mouse and keyboard')
test.sub_step_log('4.2. Reboot guest')
dst_serial = RemoteSerialMonitor(id, params, dst_host_ip, serial_port)
cmd = 'dmesg'
output = dst_serial.serial_cmd_output(cmd=cmd)
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace')
dst_serial.serial_cmd(cmd='reboot')
dst_guest_ip = dst_serial.serial_login()
test.sub_step_log('4.3 Ping external host')
dst_guest_session = GuestSession(case_id=id,
params=params,
ip=dst_guest_ip)
dst_guest_session.guest_ping_test(dst_ip='www.redhat.com', count=10)
test.sub_step_log('4.4 dd a file inside guest')
cmd_dd = 'dd if=/dev/zero of=file1 bs=100M count=10 oflag=direct'
output = dst_guest_session.guest_cmd_output(cmd=cmd_dd, timeout=600)
if not output or re.findall('error', output):
test.test_error('Failed to dd a file in guest')
test.sub_step_log('4.5 Shutdown guest successfully')
dst_serial.serial_shutdown_vm()
output = src_remote_qmp.qmp_cmd_output('{"execute":"quit"}',
recv_timeout=3)
if output:
src_remote_qmp.test_error('Failed to quit qemu on src end')
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
incoming_port = str(params.get('incoming_port'))
serial_port = int(params.get('serial_port'))
qmp_port = int(params.get('qmp_port'))
test = CreateTest(case_id='rhel7_10057', params=params)
id = test.get_id()
guest_passwd = params.get('guest_passwd')
downtime = '30000'
script = 'migration_dirtypage_1.c'
query_timeout = 2400
active_timeout = 300
running_timeout = 300
src_host_session = HostSession(id, params)
src_qemu_cmd = params.create_qemu_cmd()
test.main_step_log('1. Start VM in src host ')
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
test.sub_step_log('Connecting to src serial')
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
src_guest_ip = src_serial.serial_login()
src_guest_session = GuestSession(case_id=id,
params=params,
ip=src_guest_ip)
test.sub_step_log('Check dmesg info ')
cmd = 'dmesg'
output = src_guest_session.guest_cmd_output(cmd)
if re.findall(r'Call Trace:', output):
src_guest_session.test_error('Guest hit call trace')
test.main_step_log('2. Start listening mode in dst host ')
incoming_val = 'tcp:0:%s' % (incoming_port)
params.vm_base_cmd_add('incoming', incoming_val)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(ip=dst_host_ip,
cmd=dst_qemu_cmd,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
test.main_step_log('3. src guest have '
'programme running to generate dirty page')
test.sub_step_log('run dirty page script')
test.test_print('scp %s to guest' % script)
src_guest_session.guest_cmd_output('cd /home;rm -f %s' % script)
src_host_session.host_cmd_scp_put(local_path='%s/c_scripts/%s' %
(BASE_DIR, script),
remote_path='/home/%s' % script,
passwd=guest_passwd,
remote_ip=src_guest_ip,
timeout=300)
chk_cmd = 'ls /home | grep -w "%s"' % script
output = src_guest_session.guest_cmd_output(cmd=chk_cmd)
if not output:
test.test_error('Failed to get %s' % script)
arch = src_guest_session.guest_cmd_output('arch')
gcc_cmd = 'yum list installed | grep -w "gcc.%s"' % arch
output = src_guest_session.guest_cmd_output(cmd=gcc_cmd)
if not re.findall(r'gcc.%s' % arch, output):
install_cmd = 'yum install -y gcc'
install_info = src_guest_session.guest_cmd_output(install_cmd)
if re.findall('Complete', install_info):
test.test_print('Guest install gcc pkg successfully')
else:
test.test_error('Guest failed to install gcc pkg')
compile_cmd = 'cd /home;gcc %s -o dirty1' % script
src_guest_session.guest_cmd_output(cmd=compile_cmd)
output = src_guest_session.guest_cmd_output('ls /home | grep -w "dirty1"')
if not output:
test.test_error('Failed to compile %s' % script)
dirty_cmd = 'cd /home;./dirty1'
thread = threading.Thread(target=src_guest_session.guest_cmd_output,
args=(dirty_cmd, 4800))
thread.name = 'dirty1'
thread.daemon = True
thread.start()
time.sleep(10)
output = src_guest_session.guest_cmd_output('pgrep -x dirty1')
if not output:
test.test_error('Dirty1 is not running in guest')
test.main_step_log('4. Migrate to the destination')
cmd = '{"execute":"migrate", "arguments": {"uri": "tcp:%s:%s"}}' % \
(dst_host_ip, incoming_port)
src_remote_qmp.qmp_cmd_output(cmd)
test.main_step_log('5.set downtime for migration')
flag_active = False
cmd = '{"execute":"query-migrate"}'
end_time = time.time() + active_timeout
while time.time() < end_time:
output = src_remote_qmp.qmp_cmd_output(cmd)
if re.findall(r'"status": "active"', output):
flag_active = True
break
elif re.findall(r'"status": "failed"', output):
src_remote_qmp.qmp_cmd_output('Migration failed')
if (flag_active == False):
src_remote_qmp.qmp_cmd_output(
'Migration could not be active within %d' % active_timeout)
downtime_cmd = '{"execute":"migrate-set-parameters",' \
'"arguments":{"downtime-limit": %s}}' % downtime
src_remote_qmp.qmp_cmd_output(cmd=downtime_cmd)
paras_chk_cmd = '{"execute":"query-migrate-parameters"}'
output = src_remote_qmp.qmp_cmd_output(cmd=paras_chk_cmd)
if re.findall(r'"downtime-limit": %s' % downtime, output):
test.test_print('Set migration downtime successfully')
else:
test.test_error('Failed to change downtime')
test.sub_step_log('Check the status of migration')
flag = False
cmd = '{"execute":"query-migrate"}'
end_time = time.time() + query_timeout
while time.time() < end_time:
output = src_remote_qmp.qmp_cmd_output(cmd=cmd)
if re.findall(r'"remaining": 0', output):
flag = True
break
elif re.findall(r'"status": "failed"', output):
src_remote_qmp.test_error('migration failed')
if (flag == False):
test.test_error('Migration timeout in %d' % query_timeout)
test.main_step_log('6.Check status of guest in des host')
cmd = '{"execute":"query-status"}'
flag_running = False
end_time = time.time() + running_timeout
while time.time() < end_time:
output = dst_remote_qmp.qmp_cmd_output(cmd=cmd, recv_timeout=3)
if re.findall(r'"status": "running"', output):
flag_running = True
break
if (flag_running == False):
test.test_error('Dst guest is not running after migration finished %d '
'seconds' % running_timeout)
test.sub_step_log('Check dmesg info ')
cmd = 'dmesg'
output = src_guest_session.guest_cmd_output(cmd)
if re.findall(r'Call Trace:', output):
src_guest_session.test_error('Guest hit call trace')
dst_serial = RemoteSerialMonitor(case_id=id,
params=params,
ip=dst_host_ip,
port=serial_port)
cmd = 'dmesg'
output = dst_serial.serial_cmd_output(cmd=cmd)
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace')
dst_serial.serial_cmd(cmd='reboot')
dst_guest_ip = dst_serial.serial_login()
external_host_ip = dst_host_ip
dst_guest_session = GuestSession(case_id=id,
params=params,
ip=dst_guest_ip)
cmd_ping = 'ping %s -c 10' % external_host_ip
output = dst_guest_session.guest_cmd_output(cmd=cmd_ping)
if re.findall(r'100% packet loss', output):
dst_guest_session.test_error('Ping failed')
test.sub_step_log('quit qemu on src end and shutdown vm on dst end')
output = src_remote_qmp.qmp_cmd_output('{"execute":"quit"}',
recv_timeout=3)
if output:
src_remote_qmp.test_error('Failed to quit qemu on src host')
dst_serial.serial_shutdown_vm()
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
incoming_port = params.get('incoming_port')
test = CreateTest(case_id='rhel7_10067', params=params)
id = test.get_id()
src_host_session = HostSession(id, params)
downtime = '10000'
query_migration_time = 1200
test.main_step_log('1. Start VM with high load, with each method is ok')
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
test.sub_step_log('1.1 Connecting to src serial')
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
src_guest_ip = src_serial.serial_login()
src_guest_session = GuestSession(case_id=id, params=params, ip=src_guest_ip)
test.sub_step_log('1.2 Running iozone in src guest')
utils_migration.iozone_test(guest_session=src_guest_session)
test.main_step_log('2. Start listening mode')
incoming_val = 'tcp:0:%s' % incoming_port
params.vm_base_cmd_add('incoming', incoming_val)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(cmd=dst_qemu_cmd, ip=dst_host_ip,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
test.main_step_log('3. Set a reasonable downtime value for migration')
downtime_cmd = '{"execute":"migrate-set-parameters","arguments":' \
'{"downtime-limit": %s}}' % downtime
src_remote_qmp.qmp_cmd_output(cmd=downtime_cmd)
paras_chk_cmd = '{"execute":"query-migrate-parameters"}'
output = src_remote_qmp.qmp_cmd_output(cmd=paras_chk_cmd)
if re.findall(r'"downtime-limit": %s' % downtime, output):
test.test_print('Change downtime successfully')
else:
test.test_error('Failed to change downtime')
test.main_step_log('4.Do live migration')
check_info = utils_migration.do_migration(remote_qmp=src_remote_qmp,
migrate_port=incoming_port,
dst_ip=dst_host_ip,
chk_timeout_2=query_migration_time)
if (check_info == False):
test.test_error('Migration timeout after changing downtime')
test.main_step_log('5. Check the status of guest on dst host')
test.sub_step_log('5.1. Reboot guest')
dst_serial = RemoteSerialMonitor(id, params, dst_host_ip, serial_port)
cmd = 'dmesg'
output = dst_serial.serial_cmd_output(cmd)
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace')
dst_serial.serial_cmd(cmd='reboot')
dst_guest_ip = dst_serial.serial_login()
test.sub_step_log('5.2 Ping external host')
dst_guest_session = GuestSession(case_id=id, params=params,
ip=dst_guest_ip)
dst_guest_session.guest_ping_test('www.redhat.com', 10)
test.sub_step_log('5.3 DD a file inside guest')
cmd_dd = 'dd if=/dev/zero of=file1 bs=1M count=100 oflag=direct'
output = dst_guest_session.guest_cmd_output(cmd=cmd_dd, timeout=600)
if not output or re.findall('error', output):
test.test_error('Failed to dd a file in guest')
test.sub_step_log('5.4 Shutdown guest successfully')
dst_serial.serial_shutdown_vm()
output = src_remote_qmp.qmp_cmd_output('{"execute":"quit"}')
if output:
src_remote_qmp.test_error('Failed to quit qemu on src end')
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
incoming_port = params.get('incoming_port')
paused_timeout = 60
test = CreateTest(case_id='rhel7_10064', params=params)
id = test.get_id()
src_host_session = HostSession(id, params)
src_qemu_cmd = params.create_qemu_cmd()
test.main_step_log('1. Start VM in src host')
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
test.sub_step_log('Connecting to src serial')
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
src_guest_ip = src_serial.serial_login()
src_guest_session = GuestSession(case_id=id,
params=params,
ip=src_guest_ip)
test.sub_step_log('Check dmesg info ')
cmd = 'dmesg'
output = src_guest_session.guest_cmd_output(cmd)
if re.findall(r'Call Trace:', output):
src_guest_session.test_error('Guest hit call trace')
test.main_step_log('2. Start listening mode in dst host ')
incoming_val = 'tcp:0:%s' % (incoming_port)
params.vm_base_cmd_add('incoming', incoming_val)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(cmd=dst_qemu_cmd,
ip=dst_host_ip,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
test.main_step_log('3. Do I/O operations load(iozone) in the guest')
test.sub_step_log('run iozone -a')
utils_migration.iozone_test(guest_session=src_guest_session)
test.main_step_log('4. Stop guest on src guest before migration')
cmd = '{"execute":"stop"}'
src_remote_qmp.qmp_cmd_output(cmd)
flag_paused = False
end_time = time.time() + paused_timeout
while time.time() < end_time:
output = src_remote_qmp.qmp_cmd_output('{"execute":"query-status"}',
recv_timeout=3)
if re.findall(r'"status": "paused"', output):
flag_paused = True
break
if (flag_paused == False):
test.test_error('Guest could not become to paused within %d' %
paused_timeout)
test.main_step_log('5. Start migration from src to dst host')
flag = utils_migration.do_migration(src_remote_qmp, incoming_port,
dst_host_ip)
if (flag == False):
test.test_error('migration timeout')
test.main_step_log('6.After migration finished ,check guests status.')
flag_paused = False
end_time = time.time() + paused_timeout
while time.time() < end_time:
output = dst_remote_qmp.qmp_cmd_output('{"execute":"query-status"}')
if re.findall(r'"status": "paused"', output):
flag_paused = True
break
if (flag_paused == False):
test.test_error('Guest is not paused on dst side '
'after migration finished')
dst_remote_qmp.qmp_cmd_output('{"execute":"cont"}')
output = dst_remote_qmp.qmp_cmd_output('{"execute":"query-status"}')
if not re.findall(r'"status": "running"', output):
dst_remote_qmp.test_error('migration status Error')
test.main_step_log('7. Check if guest works well.')
test.sub_step_log('7.1 Guest mouse and keyboard.')
test.sub_step_log('7.2 Check dmesg info ')
dst_serial = RemoteSerialMonitor(case_id=id,
params=params,
ip=dst_host_ip,
port=serial_port)
cmd = 'dmesg'
output = dst_serial.serial_cmd_output(cmd)
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace')
test.sub_step_log('8. Reboot and then shutdown guest.')
dst_serial.serial_cmd(cmd='reboot')
dst_guest_ip = dst_serial.serial_login()
guest_session = GuestSession(case_id=id, params=params, ip=dst_guest_ip)
test.sub_step_log(' Can access guest from external host')
guest_session.guest_ping_test('www.redhat.com', 10)
test.sub_step_log('quit qemu on src end and shutdown vm on dst end')
output = src_remote_qmp.qmp_cmd_output('{"execute":"quit"}',
recv_timeout=3)
if output:
src_remote_qmp.test_error('Failed to quit qemu on src host')
dst_serial.serial_shutdown_vm()
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
src_qemu_cmd = params.create_qemu_cmd()
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
share_images_dir = params.get('share_images_dir')
incoming_port = params.get('incoming_port')
test = CreateTest(case_id='rhel7_10039', params=params)
id = test.get_id()
src_host_session = HostSession(id, params)
test.main_step_log('1. Boot guest with one system disk.')
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
test.sub_step_log('Check guest disk')
output = src_remote_qmp.qmp_cmd_output('{"execute":"query-block"}',
recv_timeout=5)
if not re.findall(r'drive_image1', output):
src_remote_qmp.test_error('No found system disk')
test.sub_step_log('Connecting to src serial')
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
src_guest_ip = src_serial.serial_login()
dst_guest_ip = src_guest_ip
src_guest_session = GuestSession(case_id=id, params=params, ip=src_guest_ip)
test.sub_step_log('Check dmesg info ')
cmd = 'dmesg'
output = src_guest_session.guest_cmd_output(cmd)
if re.findall(r'Call Trace:', output):
src_guest_session.test_error('Guest hit call trace')
test.main_step_log('2. Hot add two disk(should also in shared storage).')
test.sub_step_log('2.1 Create two image on src host')
src_host_session.host_cmd_output('qemu-img create '
'-f qcow2 %s/data-disk0.qcow2 10G'
% share_images_dir)
src_host_session.host_cmd_output('qemu-img create '
'-f qcow2 %s/data-disk1.qcow2 20G'
% share_images_dir)
test.sub_step_log('2.2 Hot plug the above disks')
src_remote_qmp.qmp_cmd_output('{"execute":"__com.redhat_drive_add", "arguments":'
'{"file":"/%s/data-disk0.qcow2",'
'"format":"qcow2","id":"drive-virtio-blk0"}}'
% share_images_dir, recv_timeout=5)
src_remote_qmp.qmp_cmd_output('{"execute":"device_add",'
'"arguments":'
'{"driver":"virtio-blk-pci",'
'"drive":"drive-virtio-blk0",'
'"id":"virtio-blk0",'
'"bus":"pci.0","addr":"10"}}',
recv_timeout=5)
src_remote_qmp.qmp_cmd_output('{"execute":"__com.redhat_drive_add", '
'"arguments":'
'{"file":"/%s/data-disk1.qcow2",'
'"format":"qcow2","id":"drive_r4"}}'
% share_images_dir, recv_timeout=5)
src_remote_qmp.qmp_cmd_output('{"execute":"device_add",'
'"arguments":'
'{"driver":"scsi-hd",'
'"drive":"drive_r4","id":"r4",'
'"bus":"virtio_scsi_pci0.0",'
'"channel":"0","scsi-id":"0","lun":"1"}}',
recv_timeout=5)
test.sub_step_log('Check the hot plug disk on src guest')
output = src_remote_qmp.qmp_cmd_output('{"execute":"query-block"}',
recv_timeout=5)
if not re.findall(r'drive-virtio-blk0', output) \
or not re.findall(r'drive_r4', output):
src_remote_qmp.test_error('Hot plug disk failed on src')
test.main_step_log('3. Boot \'-incoming\' guest '
'with disk added in step2 on des host. ')
params.vm_base_cmd_add('drive', 'file=/%s/data-disk0.qcow2,'
'format=qcow2,if=none,id=drive-virtio-blk0,'
'werror=stop,rerror=stop'
%share_images_dir)
params.vm_base_cmd_add('device',
'virtio-blk-pci,drive=drive-virtio-blk0,'
'id=virtio-blk0,bus=pci.0,addr=10,bootindex=10')
params.vm_base_cmd_add('drive', 'file=/%s/data-disk1.qcow2,'
'if=none,id=drive_r4,format=qcow2,'
'cache=none,aio=native,'
'werror=stop,rerror=stop'
%share_images_dir)
params.vm_base_cmd_add('device',
'scsi-hd,drive=drive_r4,id=r4,'
'bus=virtio_scsi_pci0.0,channel=0,scsi-id=0,lun=1')
params.vm_base_cmd_add('incoming', 'tcp:0:%s' %incoming_port)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(cmd=dst_qemu_cmd, ip=dst_host_ip,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
test.main_step_log('4. Start live migration from src host')
check_info = do_migration(src_remote_qmp, incoming_port, dst_host_ip)
if (check_info == False):
test.test_error('Migration timeout')
test.sub_step_log('Login dst guest')
test.sub_step_log('Connecting to dst serial')
dst_serial = RemoteSerialMonitor(id, params, dst_host_ip, serial_port)
test.sub_step_log('Check disk on dst guest')
output = dst_remote_qmp.qmp_cmd_output('{"execute":"query-block"}',
recv_timeout=5)
if not re.findall(r'drive-virtio-blk0', output) \
or not re.findall(r'drive_r4', output):
src_remote_qmp.test_error('Hot plug disk failed on dst')
cmd = 'dmesg'
output = dst_serial.serial_cmd_output(cmd=cmd)
if re.findall(r'Call Trace:', output) or not output:
test.test_error('Guest hit call trace')
test.sub_step_log('Reboot guest')
dst_serial.serial_cmd('reboot')
dst_guest_ip = dst_serial.serial_login()
test.sub_step_log('Shut down dst guest and quit src qemu')
dst_serial.serial_shutdown_vm()
output = src_remote_qmp.qmp_cmd_output('{"execute":"quit"}')
if output:
src_remote_qmp.test_error('Failed to quit qemu on src end')
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
incoming_port = params.get('incoming_port')
test = CreateTest(case_id='rhel7_10061', params=params)
id = test.get_id()
guest_name = test.guest_name
src_host_session = HostSession(id, params)
downtime = '20000'
speed = '1073741824'
chk_time_1 = 20
chk_time_2 = 1200
test.main_step_log('1. Start VM in the src host, guest running stress')
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
test.sub_step_log('1.1 Connecting to src serial')
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
src_guest_ip = src_serial.serial_login()
src_guest_session = GuestSession(case_id=id,
params=params,
ip=src_guest_ip)
test.sub_step_log('1.2 Running stress in src guest')
chk_cmd = 'yum list installed | grep stress.`arch`'
output = src_guest_session.guest_cmd_output(cmd=chk_cmd)
if not output:
install_cmd = 'yum install -y stress.`arch`'
install_info = src_guest_session.guest_cmd_output(cmd=install_cmd)
if re.findall('Complete', install_info):
test.test_print('Guest install stress pkg successfully')
else:
test.test_error('Guest failed to install stress pkg')
stress_cmd = 'stress --cpu 4 --vm 4 --vm-bytes 256M'
thread = threading.Thread(target=src_guest_session.guest_cmd_output,
args=(stress_cmd, 1200))
thread.name = 'stress'
thread.daemon = True
thread.start()
time.sleep(10)
output = src_guest_session.guest_cmd_output('pgrep -x stress')
if not output:
test.test_error('Stress is not running in guest')
test.main_step_log('2. Start listening mode in the dst host.')
incoming_val = 'tcp:0:%s' % incoming_port
params.vm_base_cmd_add('incoming', incoming_val)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(cmd=dst_qemu_cmd,
ip=dst_host_ip,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
test.main_step_log('3. Do live migration')
cmd = '{"execute":"migrate", "arguments": {"uri": "tcp:%s:%s"}}' % (
dst_host_ip, incoming_port)
src_remote_qmp.qmp_cmd_output(cmd=cmd)
test.sub_step_log('Check the status of migration')
flag_active = False
cmd = '{"execute":"query-migrate"}'
end_time = time.time() + chk_time_1
while time.time() < end_time:
output = src_remote_qmp.qmp_cmd_output(cmd=cmd)
if re.findall('"status": "active"', output):
flag_active = True
break
elif re.findall(r'"status": "failed"', output):
src_remote_qmp.test_error('migration failed')
if (flag_active == False):
test.test_error('Migration is not active within %d' % chk_time_1)
test.main_step_log('4. During migration in progress, cancel migration')
cmd = '{"execute":"migrate_cancel"}'
src_remote_qmp.qmp_cmd_output(cmd=cmd, recv_timeout=3)
output = src_remote_qmp.qmp_cmd_output('{"execute":"query-migrate"}',
recv_timeout=3)
if re.findall(r'"status": "cancelled"', output):
src_remote_qmp.test_print('Src cancel migration successfully')
else:
src_remote_qmp.test_error('Failed to cancel migration')
test.main_step_log('5. Start listening mode againg in the dst host')
test.sub_step_log('5.1 Check if the dst qemu quit automatically')
dst_chk_cmd = 'ssh root@%s ps -axu | grep %s | grep -v grep' \
% (dst_host_ip, guest_name)
output = src_host_session.host_cmd_output(cmd=dst_chk_cmd)
if not output:
src_host_session.test_print('DST QEMU quit automatically after '
'src cancelling migration')
else:
src_host_session.test_error('DST QEMU does not quit automatically '
'after src cancelling migration')
test.sub_step_log('5.2 Start listening mode again in dst host')
src_host_session.boot_remote_guest(cmd=dst_qemu_cmd,
ip=dst_host_ip,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
test.main_step_log('6. Do live migration again')
output = do_migration(remote_qmp=src_remote_qmp,
migrate_port=incoming_port,
dst_ip=dst_host_ip)
if (output == False):
test.test_error('Migration timeout')
test.main_step_log('7. After migration succeed, '
'checking the status of guest on the dst host')
test.sub_step_log('7.1 Guest keyboard and mouse work normally.')
test.sub_step_log('7.2 Reboot guest')
dst_serial = RemoteSerialMonitor(id, params, dst_host_ip, serial_port)
cmd = 'dmesg'
output = dst_serial.serial_cmd_output(cmd=cmd)
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace')
dst_serial.serial_cmd(cmd='reboot')
dst_guest_ip = dst_serial.serial_login()
test.sub_step_log(
'7.3 Ping external host/copy file between guest and host')
dst_guest_session = GuestSession(case_id=id,
params=params,
ip=dst_guest_ip)
dst_guest_session.guest_ping_test('www.redhat.com', 10)
test.sub_step_log('7.4 DD a file inside guest')
cmd_dd = 'dd if=/dev/zero of=file1 bs=1M count=100 oflag=direct'
output = dst_guest_session.guest_cmd_output(cmd=cmd_dd, timeout=600)
if not output or re.findall('error', output):
test.test_error('Failed to dd a file in guest')
test.sub_step_log('7.5 Shutdown guest successfully')
dst_serial.serial_shutdown_vm()
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
incoming_port = params.get('incoming_port')
test = CreateTest(case_id='rhel7_10055', params=params)
id = test.get_id()
src_host_session = HostSession(id, params)
src_qemu_cmd = params.create_qemu_cmd()
test.main_step_log('1. Start VM in src host ')
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
test.sub_step_log('Connecting to src serial')
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
src_guest_ip = src_serial.serial_login()
src_guest_session = GuestSession(case_id=id, params=params,
ip=src_guest_ip)
test.sub_step_log('Check dmesg info ')
cmd = 'dmesg'
output = src_guest_session.guest_cmd_output(cmd)
if re.findall(r'Call Trace:', output):
src_guest_session.test_error('Guest hit call trace')
test.main_step_log('2. Start listening mode in dst host ')
incoming_val = 'tcp:0:%s' % (incoming_port)
params.vm_base_cmd_add('incoming', incoming_val)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(ip=dst_host_ip, cmd=dst_qemu_cmd,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
test.main_step_log('3. Log in to the src guest and '
' Do I/O operations load(iozone) in the guest')
test.sub_step_log('run iozone -a')
cmd='yum list installed | grep ^gcc.`arch`'
output = src_guest_session.guest_cmd_output(cmd=cmd)
if not output:
output=src_guest_session.guest_cmd_output('yum install -y gcc')
if not re.findall(r'Complete!', output):
src_guest_session.test_error('gcc install Error')
output = src_guest_session.guest_cmd_output('cd /home/iozone3_471;cd src; '
'cd current;ls |grep -w iozone')
if re.findall(r'No such file or directory', output):
cmd = 'cd /home;wget http://www.iozone.org/src/current/iozone3_471.tar'
src_guest_session.guest_cmd_output(cmd=cmd)
time.sleep(10)
src_guest_session.guest_cmd_output('cd /home;tar -xvf iozone3_471.tar')
output = src_guest_session.guest_cmd_output('arch')
if re.findall(r'ppc64le', output):
cmd = 'cd /home/iozone3_471/src/current/;make linux-powerpc64'
src_guest_session.guest_cmd_output(cmd=cmd)
elif re.findall(r'x86_64', output):
cmd = 'cd /home/iozone3_471/src/current/;make linux-AMD64 '
src_guest_session.guest_cmd_output(cmd=cmd)
else:
cmd = 'cd /home/iozone3_471/src/current/;make linux-S390X '
src_guest_session.guest_cmd_output(cmd=cmd)
cmd = 'cd /home/iozone3_471/src/current/;./iozone -a'
thread = threading.Thread(target=src_guest_session.guest_cmd_output,
args=(cmd,1200,))
thread.name = 'iozone'
thread.daemon = True
thread.start()
time.sleep(5)
pid =src_guest_session.guest_cmd_output('pgrep -x iozone')
if not pid:
src_guest_session.test_error('iozone excute or install Error')
test.main_step_log('4. Migrate to the destination')
cmd = '{"execute":"migrate", "arguments": {"uri": "tcp:%s:%s"}}' % \
(dst_host_ip, incoming_port)
src_remote_qmp.qmp_cmd_output(cmd)
test.main_step_log('5.Stop guest during migration')
cmd = '{"execute":"query-migrate"}'
while True:
output = src_remote_qmp.qmp_cmd_output(cmd)
if re.findall(r'"status": "active"', output):
break
cmd = '{"execute":"stop"}'
src_remote_qmp.qmp_cmd_output(cmd)
test.sub_step_log('Check the status of migration')
flag = query_migration(src_remote_qmp)
if (flag == False):
src_remote_qmp.test_error('migration timeout')
test.main_step_log('6.Check status of guest in des host, should be paused')
cmd = '{"execute":"query-status"}'
while True:
output = dst_remote_qmp.qmp_cmd_output(cmd=cmd)
if re.findall(r'"status": "paused"', output):
break
time.sleep(5)
test.sub_step_log('Login dst guest')
test.sub_step_log('Connecting to dst serial')
test.sub_step_log('check dmesg info')
dst_remote_qmp.qmp_cmd_output('{"execute":"cont"}')
dst_remote_qmp.qmp_cmd_output('{"execute":"query-status"}')
dst_serial = RemoteSerialMonitor(case_id=id, params=params, ip=dst_host_ip,
port=serial_port)
cmd = 'dmesg'
output = dst_serial.serial_cmd_output(cmd=cmd)
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace')
dst_serial.serial_cmd(cmd='reboot')
dst_guest_ip = dst_serial.serial_login()
guest_session = GuestSession(case_id=id, params=params, ip=dst_guest_ip)
test.sub_step_log('quit qemu on src end and shutdown vm on dst end')
output = src_remote_qmp.qmp_cmd_output('{"execute":"quit"}',
recv_timeout=3)
if output:
src_remote_qmp.test_error('Failed to quit qemu on src host')
dst_serial.serial_shutdown_vm()
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
incoming_port = params.get('incoming_port')
test = CreateTest(case_id='rhel7_10068', params=params)
id = test.get_id()
guest_pwd = params.get('guest_passwd')
test.main_step_log('1.Start VM in src host')
params.vm_base_cmd_add('S', 'None')
params.vm_base_cmd_add('monitor', 'tcp:0:5555,server,nowait')
src_host_session = HostSession(id, params)
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
test.sub_step_log('Check the status of src guest')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
test.main_step_log('2. Start listening mode in dst host ')
params.vm_base_cmd_del('S', 'None')
params.vm_base_cmd_del('monitor', 'tcp:0:5555,server,nowait')
incoming_val = 'tcp:0:%s' % (incoming_port)
params.vm_base_cmd_add('incoming', incoming_val)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(cmd=dst_qemu_cmd,
ip=dst_host_ip,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
dst_serial = RemoteSerialMonitor(case_id=id,
params=params,
ip=dst_host_ip,
port=serial_port)
test.main_step_log('3. Start live migration with '
'running below script on src host')
cmd='echo c | nc localhost 5555; sleep 0.6; ' \
'echo migrate tcp:%s:%s | nc localhost 5555' % \
(dst_host_ip, incoming_port)
src_host_session.host_cmd(cmd=cmd)
test.main_step_log('4.Check guest on des, guest should work well')
migration_flag = query_migration(src_remote_qmp)
if (migration_flag == False):
src_remote_qmp.test_error('migration timeout')
output = dst_remote_qmp.qmp_cmd_output('{"execute":"query-status"}')
if not re.findall(r'"status": "running"', output):
dst_remote_qmp.test_error('migration status error')
test.main_step_log('5.Reboot guest, guest should work well.')
timeout = 600
endtime = time.time() + timeout
bootup = False
while time.time() < endtime:
cmd = 'root'
dst_serial.send_cmd(cmd)
output = dst_serial.rec_data(recv_timeout=8)
dst_serial.test_print(info=output, serial_debug=True)
if re.findall(r'Password', output):
dst_serial.send_cmd(guest_pwd)
dst_serial.test_print(guest_pwd, serial_debug=True)
output = dst_serial.rec_data(recv_timeout=8)
dst_serial.test_print(info=output, serial_debug=True)
if re.search(r"login:"******"login:"******"execute":"quit"}',
recv_timeout=3)
if output:
src_remote_qmp.test_error('Failed to quit qemu on src host')
dst_serial.serial_shutdown_vm()
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
incoming_port = params.get('incoming_port')
test = CreateTest(case_id='rhel7_85702', params=params)
id = test.get_id()
src_host_session = HostSession(id, params)
script = 'migration_dirtypage_2.c'
test.main_step_log('1.Boot a vm in src host with qemu cli:')
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
src_guest_ip = src_serial.serial_login()
src_guest_session = GuestSession(case_id=id, params=params,
ip=src_guest_ip)
test.main_step_log('2.Boot a vm in dst host')
incoming_val = 'tcp:0:%s' % incoming_port
params.vm_base_cmd_add('incoming', incoming_val)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(cmd=dst_qemu_cmd, ip=dst_host_ip,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
test.main_step_log('3.In the guest, execute the below program '
'to generate dirty pages')
utils_migration.dirty_page_test(host_session=src_host_session,
guest_session=src_guest_session,
guest_ip=src_guest_ip, script=script)
test.main_step_log('4. Set migration configuration in HMP and do migration')
test.sub_step_log('set src host xbzrle and postcopy-ram on')
utils_migration.set_migration_capabilities(remote_qmp=src_remote_qmp,
capabilities='xbzrle',
state='true')
utils_migration.set_migration_capabilities(remote_qmp=src_remote_qmp,
capabilities='postcopy-ram',
state='true')
test.sub_step_log('set dst host xbzrle and postcopy-ram on')
utils_migration.set_migration_capabilities(remote_qmp=dst_remote_qmp,
capabilities='xbzrle',
state='true')
utils_migration.set_migration_capabilities(remote_qmp=dst_remote_qmp,
capabilities='postcopy-ram',
state='true')
test.sub_step_log('start to do migration')
cmd = '{"execute":"migrate", "arguments": { "uri": "tcp:%s:%s" }}' \
% (dst_host_ip, incoming_port)
src_remote_qmp.qmp_cmd_output(cmd=cmd)
test.main_step_log('5. Check migration status, after producing dirty pages'
' switch to post-copy.')
utils_migration.switch_to_postcopy(remote_qmp=src_remote_qmp)
chk_info = utils_migration.query_migration(remote_qmp=src_remote_qmp)
if chk_info == False:
test.test_error('Migration timeout')
test.sub_step_log('Check guest status after migration finished')
dst_serial = RemoteSerialMonitor(id, params, dst_host_ip, serial_port)
output = dst_serial.serial_cmd_output('dmesg')
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace after migration')
dst_serial.serial_cmd(cmd='reboot')
dst_guest_ip = dst_serial.serial_login()
dst_guest_session = GuestSession(case_id=id, params=params,
ip=dst_guest_ip)
dst_guest_session.guest_ping_test(dst_ip='www.redhat.com', count=10)
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
incoming_port = params.get('incoming_port')
test = CreateTest(case_id='rhel7_10067', params=params)
id = test.get_id()
src_host_session = HostSession(id, params)
iozone_url = 'http://www.iozone.org/src/current/iozone3_471.tar'
iozone_ver = 'iozone3_471'
downtime = '10000'
query_migration_time = 1200
test.main_step_log('1. Start VM with high load, with each method is ok')
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
test.sub_step_log('1.1 Connecting to src serial')
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
src_guest_ip = src_serial.serial_login()
src_guest_session = GuestSession(case_id=id,
params=params,
ip=src_guest_ip)
test.sub_step_log('1.2 Running iozone in src guest')
cmd = 'yum list installed | grep ^gcc.`arch`'
output = src_guest_session.guest_cmd_output(cmd=cmd)
if not output:
output = src_guest_session.guest_cmd_output('yum install -y gcc')
if not re.findall(r'Complete!', output):
src_guest_session.test_error('gcc install Error')
src_guest_session.guest_cmd_output('rm -rf /home/iozone*')
src_guest_session.guest_cmd_output('cd /home;wget %s' % iozone_url)
output = src_guest_session.guest_cmd_output('ls /home | grep %s.tar' %
iozone_ver)
if not output:
test.test_error('Failed to get iozone file')
time.sleep(10)
src_guest_session.guest_cmd_output('cd /home; tar -xvf %s.tar' %
iozone_ver)
arch = src_guest_session.guest_cmd_output('arch')
if re.findall(r'ppc64le', arch):
cmd = 'cd /home/%s/src/current/;make linux-powerpc64' % iozone_ver
src_guest_session.guest_cmd_output(cmd=cmd)
elif re.findall(r'x86_64', arch):
cmd = 'cd /home/%s/src/current/;make linux-AMD64' % iozone_ver
src_guest_session.guest_cmd_output(cmd=cmd)
elif re.findall(r'S390X', arch):
cmd = 'cd /home/%s/src/current/;make linux-S390X' % iozone_ver
src_guest_session.guest_cmd_output(cmd=cmd)
time.sleep(5)
iozone_cmd = 'cd /home/%s/src/current/;./iozone -a' % iozone_ver
thread = threading.Thread(target=src_guest_session.guest_cmd_output,
args=(iozone_cmd, 1200))
thread.name = 'iozone'
thread.daemon = True
thread.start()
time.sleep(10)
pid = src_guest_session.guest_cmd_output('pgrep -x iozone')
if pid:
src_guest_session.test_print('iozone is running in guest')
else:
src_guest_session.test_error('iozone is not running in guest')
test.main_step_log('2. Start listening mode')
incoming_val = 'tcp:0:%s' % incoming_port
params.vm_base_cmd_add('incoming', incoming_val)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(cmd=dst_qemu_cmd,
ip=dst_host_ip,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
test.main_step_log('3. Set a reasonable downtime value for migration')
downtime_cmd = '{"execute":"migrate-set-parameters","arguments":' \
'{"downtime-limit": %s}}' % downtime
src_remote_qmp.qmp_cmd_output(cmd=downtime_cmd)
paras_chk_cmd = '{"execute":"query-migrate-parameters"}'
output = src_remote_qmp.qmp_cmd_output(cmd=paras_chk_cmd)
if re.findall(r'"downtime-limit": %s' % downtime, output):
test.test_print('Change downtime successfully')
else:
test.test_error('Failed to change downtime')
test.main_step_log('4.Do live migration')
check_info = do_migration(remote_qmp=src_remote_qmp,
migrate_port=incoming_port,
dst_ip=dst_host_ip,
chk_timeout_2=query_migration_time)
if (check_info == False):
test.test_error('Migration timeout after changing downtime')
test.main_step_log('5. Check the status of guest on dst host')
test.sub_step_log('5.1. Reboot guest')
dst_serial = RemoteSerialMonitor(id, params, dst_host_ip, serial_port)
cmd = 'dmesg'
output = dst_serial.serial_cmd_output(cmd)
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace')
dst_serial.serial_cmd(cmd='reboot')
dst_guest_ip = dst_serial.serial_login()
test.sub_step_log('5.2 Ping external host')
dst_guest_session = GuestSession(case_id=id,
params=params,
ip=dst_guest_ip)
dst_guest_session.guest_ping_test('www.redhat.com', 10)
test.sub_step_log('5.3 DD a file inside guest')
cmd_dd = 'dd if=/dev/zero of=file1 bs=1M count=100 oflag=direct'
output = dst_guest_session.guest_cmd_output(cmd=cmd_dd, timeout=600)
if not output or re.findall('error', output):
test.test_error('Failed to dd a file in guest')
test.sub_step_log('5.4 Shutdown guest successfully')
dst_serial.serial_shutdown_vm()
output = src_remote_qmp.qmp_cmd_output('{"execute":"quit"}')
if output:
src_remote_qmp.test_error('Failed to quit qemu on src end')
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = src_host_ip
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
vnc_port = int(params.get('vnc_port'))
share_images_dir = params.get('share_images_dir')
test = CreateTest(case_id='rhel7_10075', params=params)
id = test.get_id()
src_host_session = HostSession(id, params)
query_timeout = 1200
test.main_step_log('1. Boot a guest on source host.')
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
test.sub_step_log('1.1 Connecting to src serial')
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
src_guest_ip = src_serial.serial_login()
test.main_step_log('2. start listening port in the same host')
vnc_port_new = int(vnc_port + 1)
params.vm_base_cmd_update('vnc', ':%d' % vnc_port, ':%d' % vnc_port_new)
qmp_port_new = int(qmp_port + 1)
params.vm_base_cmd_update('qmp', 'tcp:0:%d,server,nowait' % qmp_port,
'tcp:0:%d,server,nowait' % qmp_port_new)
serial_port_new = int(serial_port + 1)
params.vm_base_cmd_update('serial', 'tcp:0:%d,server,nowait' % serial_port,
'tcp:0:%d,server,nowait' % serial_port_new)
output = src_host_session.host_cmd_output('rm -f %s/unix' %
share_images_dir)
if output:
test.test_error('Failed to delete the existed unix socket')
incoming_val = 'unix:%s/unix' % share_images_dir
params.vm_base_cmd_add('incoming', incoming_val)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=dst_qemu_cmd, vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port_new)
test.main_step_log('3. do live migration')
test.sub_step_log('3.1 Check whether the socket exists')
output = src_host_session.host_cmd_output('ls %s | grep unix' %
share_images_dir)
if re.findall(r'unix', output):
test.test_print('unix socket exists')
else:
test.test_error('Unix socket does not exist')
test.sub_step_log('3.2 Begin to do migration')
cmd = '{"execute":"migrate","arguments":{"uri":"unix:%s/unix"}}' \
% share_images_dir
src_remote_qmp.qmp_cmd_output(cmd=cmd, recv_timeout=6)
test.sub_step_log('Check the status of migration')
flag = query_migration(remote_qmp=src_remote_qmp,
chk_timeout=query_timeout)
if (flag == False):
test.test_error('Migration timeout in %d' % query_timeout)
test.main_step_log('4. After migration, check if guest works well.')
test.sub_step_log('4.1 Reboot guest')
dst_serial = RemoteSerialMonitor(id, params, dst_host_ip, serial_port_new)
cmd = 'dmesg'
output = dst_serial.serial_cmd_output(cmd)
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace')
dst_serial.serial_cmd(cmd='reboot')
dst_guest_ip = dst_serial.serial_login()
test.sub_step_log(
'4.2. Ping external host/copy file between guest and host')
external_host_ip = 'www.redhat.com'
cmd_ping = 'ping %s -c 10' % external_host_ip
dst_guest_session = GuestSession(case_id=id,
params=params,
ip=dst_guest_ip)
output = dst_guest_session.guest_cmd_output(cmd=cmd_ping)
if re.findall(r'100% packet loss', output):
dst_guest_session.test_error('Ping failed')
test.sub_step_log('4.3 DD a file inside guest.')
cmd_dd = 'dd if=/dev/zero of=file1 bs=10M count=10 oflag=direct'
output = dst_guest_session.guest_cmd_output(cmd=cmd_dd, timeout=600)
if not output or re.findall('error', output):
test.test_error('Failed to dd a file in guest')
test.sub_step_log('4.4. Shutdown guest.')
dst_serial.serial_shutdown_vm()
output = src_remote_qmp.qmp_cmd_output('{"execute":"quit"}',
recv_timeout=3)
if output:
src_remote_qmp.test_error('Failed to quit qemu on src end')
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
incoming_port = params.get('incoming_port')
test = CreateTest(case_id='rhel7_93722', params=params)
id = test.get_id()
src_host_session = HostSession(id, params)
size = '2147483648'
test.main_step_log('1.configure hugepage(both src and dst)')
output = src_host_session.host_cmd_output(cmd='lscpu')
if re.findall(r'POWER8', output):
matrix = 'P8_P8'
elif re.findall(r'POWER9', output):
matrix = 'P9_P9'
utils_stable_abi_ppc.configure_host_hugepage(
host_session=src_host_session,
matrix=matrix,
dst_ip=dst_host_ip,
mount_point='/mnt/kvm_hugepage')
test.main_step_log(
'2.Boot a guest with hugepage memdev and numa on src host')
params.vm_base_cmd_add(
'object', 'memory-backend-file,id=ram-node0,prealloc=yes,'
'mem-path=/dev/hugepages,size=%s' % size)
params.vm_base_cmd_add('numa', 'node,nodeid=0,cpus=0-1,memdev=ram-node0')
params.vm_base_cmd_add(
'object', 'memory-backend-file,id=ram-node1,prealloc=yes,'
'mem-path=/dev/hugepages,size=%s' % size)
params.vm_base_cmd_add('numa', 'node,nodeid=1,cpus=2-3,memdev=ram-node1')
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
src_serial.serial_login()
test.main_step_log('3. Boot a guest on dst host')
incoming_val = 'tcp:0:%s' % incoming_port
params.vm_base_cmd_add('incoming', incoming_val)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(cmd=dst_qemu_cmd,
ip=dst_host_ip,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
test.main_step_log('4.On src host and dst host, '
'enable postcopy and do migration')
test.sub_step_log('set src host postcopy-ram on')
utils_migration.set_migration_capabilities(remote_qmp=src_remote_qmp,
capabilities='postcopy-ram',
state='true')
test.sub_step_log('set dst host postcopy-ram on')
utils_migration.set_migration_capabilities(remote_qmp=dst_remote_qmp,
capabilities='postcopy-ram',
state='true')
test.sub_step_log('start to do migration')
cmd = '{"execute":"migrate", "arguments": { "uri": "tcp:%s:%s" }}' \
% (dst_host_ip, incoming_port)
src_remote_qmp.qmp_cmd_output(cmd=cmd)
utils_migration.switch_to_postcopy(remote_qmp=src_remote_qmp,
dirty_count_threshold=0)
chk_info = utils_migration.query_migration(remote_qmp=src_remote_qmp)
if chk_info == False:
test.test_error('Migration timeout')
test.sub_step_log('Check guest status after migration finished')
dst_serial = RemoteSerialMonitor(id, params, dst_host_ip, serial_port)
output = dst_serial.serial_cmd_output('dmesg')
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace after migration')
dst_serial.serial_cmd(cmd='reboot')
dst_guest_ip = dst_serial.serial_login()
dst_guest_session = GuestSession(case_id=id,
params=params,
ip=dst_guest_ip)
dst_guest_session.guest_ping_test(dst_ip='www.redhat.com', count=10)
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
incoming_port = params.get('incoming_port')
guest_arch = params.get('guest_arch')
test = CreateTest(case_id='rhel7_10026', params=params)
id = test.get_id()
guest_pwd = params.get('guest_passwd')
src_host_session = HostSession(id, params)
login_timeout = 1200
test.main_step_log('1. Start vm on src host')
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
src_guest_ip = src_serial.serial_login()
test.main_step_log('2. Start listening mode on dst host')
incoming_val = 'tcp:0:%s' % incoming_port
params.vm_base_cmd_add('incoming', incoming_val)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(cmd=dst_qemu_cmd,
ip=dst_host_ip,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
dst_serial = RemoteSerialMonitor(id, params, dst_host_ip, serial_port)
test.main_step_log('3. keep reboot vm with system_reset, let guest '
'in bios stage, before kernel loading')
src_remote_qmp.qmp_cmd_output('{"execute":"system_reset"}')
if 'ppc64' in guest_arch:
keyword = 'SLOF'
elif 'x86_64' in guest_arch:
keyword = '[ 0.000000]'
while 1:
serial_output = src_serial.serial_output(max_recv_data=128,
search_str=keyword)
test.test_print(serial_output)
if re.findall(r'Found the searched keyword', serial_output):
break
if re.findall(r'login', serial_output):
test.test_error('Failed to catch migration point')
test.main_step_log('4. implement migrate during vm reboot')
chk_info = do_migration(src_remote_qmp, incoming_port, dst_host_ip)
if (chk_info == True):
test.test_print('Migration succeed')
elif (chk_info == False):
test.test_error('Migration timeout')
test.main_step_log('5. After migration, check if guest works well')
timeout = 600
endtime = time.time() + timeout
bootup = False
while time.time() < endtime:
cmd = 'root'
dst_serial.send_cmd(cmd)
output = dst_serial.rec_data(recv_timeout=8)
dst_serial.test_print(info=output, serial_debug=True)
if re.findall(r'Password', output):
dst_serial.send_cmd(guest_pwd)
dst_serial.test_print(guest_pwd, serial_debug=True)
output = dst_serial.rec_data(recv_timeout=8)
dst_serial.test_print(info=output, serial_debug=True)
if re.search(r"login:"******"login:"******"execute":"quit"}')
if output:
src_remote_qmp.test_error('Failed to quit qemu on src end')
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
incoming_port = params.get('incoming_port')
test = CreateTest(case_id='rhel7_59369', params=params)
id = test.get_id()
src_host_session = HostSession(id, params)
test.main_step_log('1. Boot guest with specified SMP configuration')
params.vm_base_cmd_update('smp', '4,maxcpus=4,cores=2,threads=1,sockets=2',
'2,maxcpus=4,cores=2,threads=2,sockets=1')
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
test.sub_step_log('1.1 Connecting to src serial')
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
src_guest_ip = src_serial.serial_login()
test.main_step_log('2. Check hot-pluggable CPU information')
cmd = '{"execute": "query-hotpluggable-cpus"}'
output = src_remote_qmp.qmp_cmd_output(cmd=cmd, recv_timeout=5)
if re.findall(r'"qom-path": "/machine/peripheral/core1"', output):
src_remote_qmp.test_error('The info of hot-pluggable cpu is wrong')
else:
src_remote_qmp.test_print('The info of hot-pluggable cpu is right')
test.main_step_log('3. Hot-plug the CPU core')
cmd = '{"execute": "device_add", "arguments": ' \
'{"driver":"host-spapr-cpu-core","core-id": 2,"id":"core1"}}'
output = src_remote_qmp.qmp_cmd_output(cmd=cmd, recv_timeout=5)
if re.findall('error', output):
test.test_error('Failed to execute cpu hotplug command')
else:
test.test_print('Cpu hotpulg command is executed successfully')
test.main_step_log('4. Verify the core has been hot-plugged to the guest')
test.sub_step_log('4.1 Check cpu info inside guest')
cmd = "lscpu | sed -n '3p' | awk '{print $2}'"
output = src_serial.serial_cmd_output(cmd=cmd)
if not re.findall(r'4', output):
test.test_error('The guest cpus info checked inside guest is wrong')
test.sub_step_log('4.2 Check cpu info in src host')
cmd = '{"execute": "query-hotpluggable-cpus"}'
output = src_remote_qmp.qmp_cmd_output(cmd=cmd, recv_timeout=5)
if re.findall(r'"qom-path": "/machine/peripheral/core1"', output):
src_remote_qmp.test_print('The guest cpus info checked in src host '
'is right')
else:
src_remote_qmp.test_print('The guest cpus info checked in src host '
'is wrong')
test.main_step_log('5. Boot the destination guest '
'(with the hot-plugged core)')
cpu_val = 'host-spapr-cpu-core,core-id=2,id=core1'
params.vm_base_cmd_add('device', cpu_val)
incoming_val = 'tcp:0:%s' % incoming_port
params.vm_base_cmd_add('incoming', incoming_val)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(cmd=dst_qemu_cmd,
ip=dst_host_ip,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
cmd = '{"execute": "query-hotpluggable-cpus"}'
output = dst_remote_qmp.qmp_cmd_output(cmd=cmd, recv_timeout=5)
if re.findall(r'"qom-path": "/machine/peripheral/core1"', output):
src_remote_qmp.test_print('The guest cpus info of dst host is right')
else:
src_remote_qmp.test_print('The guest cpus info of dst host is wrong')
test.main_step_log('6. Migrate guest from source to destination and '
'wait until it finishes,quit qemu of src host')
flag = do_migration(remote_qmp=src_remote_qmp,
migrate_port=incoming_port,
dst_ip=dst_host_ip)
if (flag == False):
test.test_error('Migration timeout')
output = src_remote_qmp.qmp_cmd_output('{"execute":"quit"}',
recv_timeout=5)
if output:
src_remote_qmp.test_error('Failed to quit qemu on src host')
test.main_step_log('7. Run some command onto the hot-plugged core')
dst_serial = RemoteSerialMonitor(id, params, dst_host_ip, serial_port)
time.sleep(10)
cmd = 'taskset -c 2,3 dd if=/dev/urandom of=/dev/null bs=64K count=1000'
output = dst_serial.serial_cmd_output(cmd=cmd, recv_timeout=5)
if re.findall('Failed', output) or re.findall('Error', output):
test.test_error('Failed to execute taskset inside guest')
else:
test.test_print('Succeed to execute taskset inside guest')
test.main_step_log('8. Reboot and then shutdown guest')
cmd = 'dmesg'
output = dst_serial.serial_cmd_output(cmd)
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace')
dst_serial.serial_cmd(cmd='reboot')
dst_serial.serial_login()
cmd = "lscpu | sed -n '3p' | awk '{print $2}'"
output = dst_serial.serial_cmd_output(cmd=cmd)
if re.findall(r'4', output):
test.test_print('After reboot, the guest cpus info is right')
else:
test.test_error('After reboot, the guest cpus info is wrong')
dst_serial.serial_shutdown_vm()
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
incoming_port = params.get('incoming_port')
test = CreateTest(case_id='rhel7_10055', params=params)
id = test.get_id()
src_host_session = HostSession(id, params)
src_qemu_cmd = params.create_qemu_cmd()
test.main_step_log('1. Start VM in src host ')
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
test.sub_step_log('Connecting to src serial')
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
src_guest_ip = src_serial.serial_login()
src_guest_session = GuestSession(case_id=id, params=params,
ip=src_guest_ip)
test.sub_step_log('Check dmesg info ')
cmd = 'dmesg'
output = src_guest_session.guest_cmd_output(cmd)
if re.findall(r'Call Trace:', output):
src_guest_session.test_error('Guest hit call trace')
test.main_step_log('2. Start listening mode in dst host ')
incoming_val = 'tcp:0:%s' % (incoming_port)
params.vm_base_cmd_add('incoming', incoming_val)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(ip=dst_host_ip, cmd=dst_qemu_cmd,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
test.main_step_log('3. Log in to the src guest and '
' Do I/O operations load(iozone) in the guest')
test.sub_step_log('run iozone -a')
utils_migration.iozone_test(guest_session=src_guest_session)
test.main_step_log('4. Migrate to the destination')
cmd = '{"execute":"migrate", "arguments": {"uri": "tcp:%s:%s"}}' % \
(dst_host_ip, incoming_port)
src_remote_qmp.qmp_cmd_output(cmd)
test.main_step_log('5.Stop guest during migration')
cmd = '{"execute":"query-migrate"}'
while True:
output = src_remote_qmp.qmp_cmd_output(cmd)
if re.findall(r'"status": "active"', output):
break
cmd = '{"execute":"stop"}'
src_remote_qmp.qmp_cmd_output(cmd)
test.sub_step_log('Check the status of migration')
flag = utils_migration.query_migration(src_remote_qmp)
if (flag == False):
src_remote_qmp.test_error('migration timeout')
test.main_step_log('6.Check status of guest in des host, should be paused')
cmd = '{"execute":"query-status"}'
while True:
output = dst_remote_qmp.qmp_cmd_output(cmd=cmd)
if re.findall(r'"status": "paused"', output):
break
time.sleep(5)
test.sub_step_log('Login dst guest')
test.sub_step_log('Connecting to dst serial')
test.sub_step_log('check dmesg info')
dst_remote_qmp.qmp_cmd_output('{"execute":"cont"}')
dst_remote_qmp.qmp_cmd_output('{"execute":"query-status"}')
dst_serial = RemoteSerialMonitor(case_id=id, params=params, ip=dst_host_ip,
port=serial_port)
cmd = 'dmesg'
output = dst_serial.serial_cmd_output(cmd=cmd)
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace')
dst_serial.serial_cmd(cmd='reboot')
dst_guest_ip = dst_serial.serial_login()
guest_session = GuestSession(case_id=id, params=params, ip=dst_guest_ip)
test.sub_step_log('quit qemu on src end and shutdown vm on dst end')
output = src_remote_qmp.qmp_cmd_output('{"execute":"quit"}',
recv_timeout=3)
if output:
src_remote_qmp.test_error('Failed to quit qemu on src host')
dst_serial.serial_shutdown_vm()
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
incoming_port = params.get('incoming_port')
share_images_dir = params.get('share_images_dir')
matrix = params.get('matrix')
disk1_name = params.get('disk1_name').split('.')[0]
disk1_format = params.get('disk1_name').split('.')[1]
disk2_name = params.get('disk2_name').split('.')[0]
disk2_format = params.get('disk2_name').split('.')[1]
disk3_name = params.get('disk3_name').split('.')[0]
disk3_format = params.get('disk3_name').split('.')[1]
disk4_name = params.get('disk4_name').split('.')[0]
disk4_format = params.get('disk4_name').split('.')[1]
disk5_name = params.get('disk5_name').split('.')[0]
disk5_format = params.get('disk5_name').split('.')[1]
iso = params.get('cdrom1_name')
test = CreateTest(case_id='rhel_135046', params=params)
id = test.get_id()
src_host_session = HostSession(id, params)
test.test_print('=======Create test environment=======')
test.sub_step_log('~~~~1. Create 5 data disks~~~~')
utils_migration.create_disk(host_session=src_host_session,
disk_dir=share_images_dir,
disk_name=disk1_name,
disk_format=disk1_format,
disk_size=2048)
utils_migration.create_disk(host_session=src_host_session,
disk_dir=share_images_dir,
disk_name=disk2_name,
disk_format=disk2_format,
disk_size=2048)
utils_migration.create_disk(host_session=src_host_session,
disk_dir=share_images_dir,
disk_name=disk3_name,
disk_format=disk3_format,
disk_size=2048)
utils_migration.create_disk(host_session=src_host_session,
disk_dir=share_images_dir,
disk_name=disk4_name,
disk_format=disk4_format,
disk_size=2048)
utils_migration.create_disk(host_session=src_host_session,
disk_dir=share_images_dir,
disk_name=disk5_name,
disk_format=disk5_format,
disk_size=2048)
test.sub_step_log('~~~~2. Create 1 iso~~~~')
utils_stable_abi_ppc.create_iso(host_session=src_host_session,
disk_dir=share_images_dir,
iso=iso)
test.sub_step_log('~~~~3. Configure host hugepage~~~~')
utils_stable_abi_ppc.configure_host_hugepage(
host_session=src_host_session,
matrix=matrix,
dst_ip=dst_host_ip,
mount_point='/mnt/kvm_hugepage')
test.sub_step_log('~~~~4. Check matrix~~~~')
flag = utils_stable_abi_ppc.check_matrix(host_session=src_host_session,
dst_ip=dst_host_ip,
matrix=matrix)
test.main_step_log('1. start guest on Source Host host must have '
'following devices')
if (flag == 'p9_to_p8'):
params.vm_base_cmd_update(
'machine', 'pseries',
'pseries-rhel7.3.0-sxxm,max-cpu-compat=power8')
else:
params.vm_base_cmd_update('machine', 'pseries',
'pseries-rhel7.3.0-sxxm')
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
test.sub_step_log('1.1 Connecting to src serial')
src_remote_qmp = RemoteQMPMonitor(id,
params,
ip=src_host_ip,
port=qmp_port)
src_serial = RemoteSerialMonitor(id,
params,
ip=src_host_ip,
port=serial_port)
src_guest_ip = src_serial.serial_login()
test.sub_step_log('2 Start guest on Destination Host host with same '
'qemu cli as step1 but appending')
if (flag == 'p8_to_p9'):
params.vm_base_cmd_update(
'machine', 'pseries-rhel7.3.0-sxxm',
'pseries-rhel7.3.0-sxxm,max-cpu-compat=power8')
elif (flag == 'p9_to_p8'):
params.vm_base_cmd_update(
'machine', 'pseries-rhel7.3.0-sxxm,max-cpu-compat=power8',
'pseries-rhel7.3.0-sxxm')
incoming_val = 'tcp:0:%s' % incoming_port
params.vm_base_cmd_add('incoming', incoming_val)
params.vm_base_cmd_update(
'chardev', 'socket,id=serial_id_serial0,host=%s,'
'port=%s,server,nowait' % (src_host_ip, serial_port),
'socket,id=serial_id_serial0,host=%s,port=%s,'
'server,nowait' % (dst_host_ip, serial_port))
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(cmd=dst_qemu_cmd,
ip=dst_host_ip,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id,
params,
ip=dst_host_ip,
port=qmp_port)
test.main_step_log(
'3.In guest, execute the program to generate dirty pages')
src_guest_session = GuestSession(case_id=id,
params=params,
ip=src_guest_ip)
utils_migration.dirty_page_test(host_session=src_host_session,
guest_session=src_guest_session,
guest_ip=src_guest_ip,
script='migration_dirtypage_2.c')
test.main_step_log('4.Enable postcopy on both sides and do migration')
utils_migration.set_migration_capabilities(remote_qmp=src_remote_qmp,
capabilities='postcopy-ram',
state='true')
utils_migration.set_migration_capabilities(remote_qmp=dst_remote_qmp,
capabilities='postcopy-ram',
state='true')
cmd = '{"execute":"migrate", "arguments": { "uri": "tcp:%s:%s" }}'\
% (dst_host_ip, incoming_port)
src_remote_qmp.qmp_cmd_output(cmd=cmd)
test.main_step_log('5.check the migration status, after generating dirty '
'pages, change to postcopy mode')
utils_migration.switch_to_postcopy(remote_qmp=src_remote_qmp)
chk_info = utils_migration.query_migration(remote_qmp=src_remote_qmp)
if chk_info == False:
test.test_error('Migration timeout')
test.main_step_log('6.Check devices function one by one')
dst_serial = RemoteSerialMonitor(id,
params,
ip=dst_host_ip,
port=serial_port)
output = dst_serial.serial_cmd_output('dmesg')
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace after migration')
dst_remote_qmp.qmp_cmd_output('{"execute":"system_reset"}')
dst_guest_ip = dst_serial.serial_login()
dst_guest_session = GuestSession(case_id=id,
params=params,
ip=dst_guest_ip)
test.sub_step_log('a.Check networking')
dst_guest_session.guest_ping_test('www.redhat.com', 10)
test.sub_step_log('b.Check block by the following methods')
utils_migration.filebench_test(dst_guest_session)
test.sub_step_log('c.Check VNC console and check keyboard by input keys')
time.sleep(3)
test.main_step_log('7.Migrate the guest back to src host and please '
'refer to step 4 and step 5')
src_remote_qmp.qmp_cmd_output('{"execute":"quit"}')
time.sleep(3)
src_host_session.check_guest_process(src_ip=src_host_ip)
if (flag == 'p8_to_p9'):
params.vm_base_cmd_update(
'machine', 'pseries-rhel7.3.0-sxxm,max-cpu-compat=power8',
'pseries-rhel7.3.0-sxxm')
elif (flag == 'p9_to_p8'):
params.vm_base_cmd_update(
'machine', 'pseries-rhel7.3.0-sxxm',
'pseries-rhel7.3.0-sxxm,max-cpu-compat=power8')
params.vm_base_cmd_update(
'chardev', 'socket,id=serial_id_serial0,host=%s,'
'port=%s,server,nowait' % (dst_host_ip, serial_port),
'socket,id=serial_id_serial0,host=%s,port=%s,'
'server,nowait' % (src_host_ip, serial_port))
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id,
params,
ip=src_host_ip,
port=qmp_port)
utils_migration.dirty_page_test(host_session=src_host_session,
guest_session=dst_guest_session,
guest_ip=dst_guest_ip,
script='migration_dirtypage_2.c')
utils_migration.set_migration_capabilities(remote_qmp=dst_remote_qmp,
capabilities='postcopy-ram',
state='true')
utils_migration.set_migration_capabilities(remote_qmp=src_remote_qmp,
capabilities='postcopy-ram',
state='true')
cmd = '{"execute":"migrate", "arguments": { "uri": "tcp:%s:%s" }}'\
% (src_host_ip, incoming_port)
dst_remote_qmp.qmp_cmd_output(cmd=cmd)
utils_migration.switch_to_postcopy(remote_qmp=dst_remote_qmp)
chk_info = utils_migration.query_migration(remote_qmp=dst_remote_qmp)
if chk_info == False:
test.test_error('Migration timeout')
test.main_step_log('8.Repeat step6')
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
output = src_serial.serial_cmd_output('dmesg')
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace after migration')
src_remote_qmp.qmp_cmd_output('{"execute":"system_reset"}')
src_guest_ip = src_serial.serial_login()
src_guest_session = GuestSession(case_id=id,
params=params,
ip=src_guest_ip)
test.sub_step_log('a.Check networking')
src_guest_session.guest_ping_test('www.redhat.com', 10)
test.sub_step_log('b.Check block by the following methods')
utils_migration.filebench_test(src_guest_session)
test.sub_step_log('c.Check VNC console and check keyboard by input keys')
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
incoming_port = params.get('incoming_port')
test = CreateTest(case_id='rhel7_10047', params=params)
id = test.get_id()
guest_arch = params.get('guest_arch')
src_host_session = HostSession(id, params)
mem_size_base = params.get('mem_size')
test.main_step_log('1. Boot guest with N vcpu and M (GB) memory on the src'
' host. (N=host physical cpu number, '
'M=host physical memory number)')
mem_cmd = 'free -g | grep Mem'
mem_cmd_remote = "ssh root@%s %s" % (dst_host_ip, mem_cmd)
if (guest_arch == 'ppc64le'):
cpu_cmd = "lscpu | sed -n '3p'"
elif (guest_arch == 'x86_64'):
# Just a workaround it with cpu_src.strip(':')[-1]
# and shell command "lscpu | sed -n '4p'"
# since no any output with
# host_cmd_output(lscpu | sed -n '4p' | awk '{print $2}').
cpu_cmd = "lscpu | sed -n '4p'"
cpu_cmd_remote = "ssh root@%s %s" % (dst_host_ip, cpu_cmd)
mem_src = src_host_session.host_cmd_output(cmd=mem_cmd)
mem_dst = src_host_session.host_cmd_output(cmd=mem_cmd_remote)
cpu_src = src_host_session.host_cmd_output(cmd=cpu_cmd)
cpu_dst = src_host_session.host_cmd_output(cmd=cpu_cmd_remote)
cpu_src = cpu_src.split(':')[-1]
cpu_dst = cpu_dst.split(':')[-1]
mem_src = int(re.split(' +', mem_src)[3])
mem_dst = int(re.split(' +', mem_dst)[3])
cpu_src = int(cpu_src)
cpu_dst = int(cpu_dst)
mem_guest = str(min(mem_src, mem_dst))
cpu_guest = str(min(cpu_src, cpu_dst))
params.vm_base_cmd_update('m', mem_size_base, '%sG' % mem_guest)
params.vm_base_cmd_update('smp', '4,maxcpus=4,cores=2,threads=1,sockets=2',
cpu_guest)
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
test.sub_step_log('1.1 Connecting to src serial')
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
src_guest_ip = src_serial.serial_login()
test.main_step_log('2. Boot guest with N vcpu and M (GB) memory '
'on the dst host')
incoming_val = 'tcp:0:%s' % incoming_port
params.vm_base_cmd_add('incoming', incoming_val)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(cmd=dst_qemu_cmd,
ip=dst_host_ip,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
test.main_step_log('3. Do ping-pong live migration for 5 times')
ping_pong_migration(params,
id,
src_host_session,
src_remote_qmp,
dst_remote_qmp,
times=5)
test.main_step_log('4. After migration, check if guest works well')
test.sub_step_log('4.1 Guest mouse and keyboard')
test.sub_step_log('4.2 Reboot guest')
dst_serial = RemoteSerialMonitor(id, params, dst_host_ip, serial_port)
cmd = 'dmesg'
output = dst_serial.serial_cmd_output(cmd=cmd)
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace')
dst_serial.serial_cmd(cmd='reboot')
dst_guest_ip = dst_serial.serial_login()
test.sub_step_log(
'4.3 Ping external host/copy file between guest and host')
dst_guest_session = GuestSession(case_id=id,
params=params,
ip=dst_guest_ip)
external_host_ip = 'www.redhat.com'
cmd_ping = 'ping %s -c 10' % external_host_ip
output = dst_guest_session.guest_cmd_output(cmd=cmd_ping)
if re.findall(r'100% packet loss', output):
dst_serial.test_error('Ping failed')
test.sub_step_log('4.4 DD a file inside guest')
cmd_dd = 'dd if=/dev/zero of=file1 bs=1M count=100 oflag=direct'
output = dst_guest_session.guest_cmd_output(cmd=cmd_dd, timeout=600)
if not output or re.findall('error', output):
dst_serial.test_error('Failed to dd a file in guest')
test.sub_step_log('4.5 Shutdown guest')
dst_serial.serial_shutdown_vm()
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
incoming_port = params.get('incoming_port')
test = CreateTest(case_id='rhel7_10059', params=params)
id = test.get_id()
src_host_session = HostSession(id, params)
test.main_step_log('1. Start source vm')
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(src_qemu_cmd, vm_alias='src')
test.sub_step_log('Connecting to src serial')
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
src_guest_ip = src_serial.serial_login()
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
src_guest_session = GuestSession(case_id=id, params=params, ip=src_guest_ip)
test.main_step_log('2. Create a file in host')
src_host_session.host_cmd(cmd='rm -rf /home/file_host')
src_host_session.host_cmd(cmd='rm -rf /home/file_host2')
cmd = 'dd if=/dev/urandom of=/home/file_host bs=1M count=5000 oflag=direct'
src_host_session.host_cmd_output(cmd, timeout=600)
test.main_step_log('3. Start des vm in migration-listen mode: "-incoming tcp:0:****"')
params.vm_base_cmd_add('incoming', 'tcp:0:%s' %incoming_port)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(ip=dst_host_ip, cmd=dst_qemu_cmd, vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
test.main_step_log('4. Transfer file from host to guest')
src_guest_session.guest_cmd_output(cmd='rm -rf /home/file_guest')
thread = threading.Thread(target=scp_thread_put,
args=(src_host_session,
'/home/file_host',
'/home/file_guest',
params.get('guest_passwd'),
src_guest_ip, 600))
thread.name = 'scp_thread_put'
thread.daemon = True
thread.start()
test.main_step_log('5. Start migration')
do_migration(src_remote_qmp, incoming_port, dst_host_ip)
test.main_step_log('6. Ping-pong migrate until file transfer finished')
src_remote_qmp, dst_remote_qmp = ping_pong_migration(params,
id,
src_host_session,
src_remote_qmp,
dst_remote_qmp,
times=10,
query_thread='pgrep -x scp')
test.sub_step_log('Login dst guest after ping-pong migration')
dst_serial = RemoteSerialMonitor(id, params, dst_host_ip, serial_port)
test.sub_step_log('Check dmesg info ')
cmd = 'dmesg'
output = dst_serial.serial_cmd_output(cmd)
if re.findall(r'Call Trace:', output):
dst_serial.test_error('Guest hit call trace')
dst_serial.serial_cmd('reboot')
dst_guest_ip = dst_serial.serial_login()
dst_guest_session = GuestSession(case_id=id, params=params,
ip=dst_guest_ip)
cmd = "md5sum /home/file_host | awk '{print $1}'"
file_src_host_md5 = src_host_session.host_cmd_output(cmd)
cmd = "md5sum /home/file_guest | awk '{print $1}'"
file_guest_md5 = dst_guest_session.guest_cmd_output(cmd)
if file_src_host_md5 != file_guest_md5:
test.test_error('Value of md5sum error!')
test.main_step_log('7. Transfer file from guest to host')
thread = threading.Thread(target=scp_thread_get,
args=(src_host_session,
'/home/file_host2',
'/home/file_guest',
params.get('guest_passwd'),
dst_guest_ip, 600))
thread.name = 'scp_thread_get'
thread.daemon = True
thread.start()
test.main_step_log('8. Ping-Pong migration until file transfer finished.')
ping_pong_migration(params, id, src_host_session, src_remote_qmp,
dst_remote_qmp, times=10, query_thread='pgrep -x scp')
test.main_step_log('9. Check md5sum after file transfer')
cmd = "md5sum /home/file_host | awk '{print $1}'"
file_src_host_md5 = src_host_session.host_cmd_output(cmd)
cmd = "md5sum /home/file_host2 | awk '{print $1}'"
file_src_host2_md5 = src_host_session.host_cmd_output(cmd)
if file_src_host_md5 != file_src_host2_md5:
test.test_error('Value of md5sum error!')
test.sub_step_log('Check dmesg info ')
dst_serial = RemoteSerialMonitor(id, params, dst_host_ip, serial_port)
cmd = 'dmesg'
output = dst_serial.serial_cmd_output(cmd)
if re.findall(r'Call Trace:', output):
dst_serial.test_error('Guest hit call trace')
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
incoming_port = params.get('incoming_port')
test = CreateTest(case_id='rhel7_10052', params=params)
id = test.get_id()
src_host_session = HostSession(id, params)
speed = 52428800
speed_m = speed / 1024 / 1024
downtime = 300
gap_speed = 5
test.main_step_log('1. Start a VM on source host')
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
test.sub_step_log('1.1 Connecting to src serial')
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
src_guest_ip = src_serial.serial_login()
test.main_step_log('2. Start guest on dst host with listening mode '
'"incoming tcp:0:5800"')
incoming_val = 'tcp:0:%s' % incoming_port
params.vm_base_cmd_add('incoming', incoming_val)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(cmd=dst_qemu_cmd,
ip=dst_host_ip,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
test.main_step_log('3. On source host, set migration speed(max-bandwidth)')
speed_cmd = '{"execute":"migrate-set-parameters","arguments":' \
'{"max-bandwidth": %d}}' % speed
src_remote_qmp.qmp_cmd_output(cmd=speed_cmd)
paras_chk_cmd = '{"execute":"query-migrate-parameters"}'
output = src_remote_qmp.qmp_cmd_output(cmd=paras_chk_cmd)
if re.findall(r'"max-bandwidth": %d' % speed, output):
test.test_print('Set migration speed successfully')
else:
test.test_error('Failed to change speed')
test.main_step_log('4. On source host, check the migration status')
check_info = do_migration(remote_qmp=src_remote_qmp,
migrate_port=incoming_port,
dst_ip=dst_host_ip,
downtime_val=downtime,
speed_val=speed)
if (check_info == False):
test.test_error('Migration timeout')
test.main_step_log('5. After migration completed, check migration speed')
output = eval(src_remote_qmp.qmp_cmd_output('{"execute":"query-migrate"}'))
transferred_ram = int(output.get('return').get('ram').get('transferred'))
src_remote_qmp.test_print('The transferred ram is: %d' % transferred_ram)
transferred_ram_cal = transferred_ram / 1024 / 1024
total_time = int(output.get('return').get('total-time'))
src_remote_qmp.test_print('The total time is: %d' % total_time)
total_time_cal = total_time / 1000
speed_cal = transferred_ram_cal / total_time_cal
gap_cal = abs(speed_cal - speed_m)
if (gap_cal >= gap_speed):
test.test_error('The real migration speed and expected speed have '
'a gap more than %d M/s' % gap_speed)
else:
test.test_print('The real migration speed is not more or less than '
'expected speed by %d M/s' % gap_speed)
test.main_step_log('6 Check the status of guest')
test.sub_step_log('6.1. Reboot guest')
dst_serial = RemoteSerialMonitor(id, params, dst_host_ip, serial_port)
cmd = 'dmesg'
output = dst_serial.serial_cmd_output(cmd=cmd)
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace')
dst_serial.serial_cmd(cmd='reboot')
dst_guest_ip = dst_serial.serial_login()
test.sub_step_log('6.2 Ping external host')
external_host_ip = 'www.redhat.com'
cmd_ping = 'ping %s -c 10' % external_host_ip
dst_guest_session = GuestSession(case_id=id,
params=params,
ip=dst_guest_ip)
output = dst_guest_session.guest_cmd_output(cmd=cmd_ping)
if re.findall(r'100% packet loss', output):
dst_guest_session.test_error('Ping failed')
test.sub_step_log('6.3 Shutdown guest successfully')
dst_serial.serial_shutdown_vm()
output = src_remote_qmp.qmp_cmd_output('{"execute":"quit"}',
recv_timeout=3)
if output:
src_remote_qmp.test_error('Failed to quit qemu on src end')
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
incoming_port = params.get('incoming_port')
share_images_dir = params.get('share_images_dir')
matrix = params.get('matrix')
disk1_name = params.get('disk1_name').split('.')[0]
disk1_format = params.get('disk1_name').split('.')[1]
disk2_name = params.get('disk2_name').split('.')[0]
disk2_format = params.get('disk2_name').split('.')[1]
disk3_name = params.get('disk3_name').split('.')[0]
disk3_format = params.get('disk3_name').split('.')[1]
disk4_name = params.get('disk4_name').split('.')[0]
disk4_format = params.get('disk4_name').split('.')[1]
disk5_name = params.get('disk5_name').split('.')[0]
disk5_format = params.get('disk5_name').split('.')[1]
iso = params.get('cdrom1_name')
test = CreateTest(case_id='rhel7_120633', params=params)
id = test.get_id()
src_host_session = HostSession(id, params)
test.test_print('=======Create test environment=======')
test.sub_step_log('~~~~1. Create 5 data disks~~~~')
utils_migration.create_disk(host_session=src_host_session,
disk_dir=share_images_dir,
disk_name=disk1_name,
disk_format=disk1_format,
disk_size=2048)
utils_migration.create_disk(host_session=src_host_session,
disk_dir=share_images_dir,
disk_name=disk2_name,
disk_format=disk2_format,
disk_size=2048)
utils_migration.create_disk(host_session=src_host_session,
disk_dir=share_images_dir,
disk_name=disk3_name,
disk_format=disk3_format,
disk_size=2048)
utils_migration.create_disk(host_session=src_host_session,
disk_dir=share_images_dir,
disk_name=disk4_name,
disk_format=disk4_format,
disk_size=2048)
utils_migration.create_disk(host_session=src_host_session,
disk_dir=share_images_dir,
disk_name=disk5_name,
disk_format=disk5_format,
disk_size=2048)
test.sub_step_log('~~~~2. Create 1 iso~~~~')
utils_stable_abi_ppc.create_iso(host_session=src_host_session,
disk_dir=share_images_dir,
iso=iso)
test.sub_step_log('~~~~3. Configure host hugepage~~~~')
utils_stable_abi_ppc.configure_host_hugepage(
host_session=src_host_session,
matrix=matrix,
dst_ip=dst_host_ip,
mount_point='/mnt/kvm_hugepage')
test.sub_step_log('~~~~4. Check matrix~~~~')
flag = utils_stable_abi_ppc.check_matrix(host_session=src_host_session,
dst_ip=dst_host_ip,
matrix=matrix)
test.main_step_log('1. start guest on Source Host host must have '
'following devices')
if (flag == 'p9_to_p8'):
params.vm_base_cmd_update('machine', 'pseries',
'pseries-rhel7.3.0,max-cpu-compat=power8')
else:
params.vm_base_cmd_update('machine', 'pseries', 'pseries-rhel7.3.0')
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
test.sub_step_log('1.1 Connecting to src serial')
src_serial = RemoteSerialMonitor(id,
params,
ip=src_host_ip,
port=serial_port)
src_serial.serial_login()
src_remote_qmp = RemoteQMPMonitor(id,
params,
ip=src_host_ip,
port=qmp_port)
test.sub_step_log('2 Start guest on Destination Host host with same '
'qemu cli as step1 but appending')
if (flag == 'p8_to_p9'):
params.vm_base_cmd_update('machine', 'pseries-rhel7.3.0',
'pseries-rhel7.3.0,max-cpu-compat=power8')
elif (flag == 'p9_to_p8'):
params.vm_base_cmd_update('machine',
'pseries-rhel7.3.0,max-cpu-compat=power8',
'pseries-rhel7.3.0')
incoming_val = 'tcp:0:%s' % incoming_port
params.vm_base_cmd_add('incoming', incoming_val)
params.vm_base_cmd_update(
'chardev',
'socket,id=serial_id_serial0,host=%s,port=%s,server,nowait' %
(src_host_ip, serial_port),
'socket,id=serial_id_serial0,host=%s,port=%s,server,nowait' %
(dst_host_ip, serial_port))
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(cmd=dst_qemu_cmd,
ip=dst_host_ip,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id,
params,
ip=dst_host_ip,
port=qmp_port)
test.main_step_log('3. Migrate guest from Source Host host to Destination'
' Host host')
check_info = utils_migration.do_migration(remote_qmp=src_remote_qmp,
migrate_port=incoming_port,
dst_ip=dst_host_ip)
if (check_info == False):
test.test_error('Migration timeout')
test.main_step_log('4.Check devices function one by one')
dst_serial = RemoteSerialMonitor(id,
params,
ip=dst_host_ip,
port=serial_port)
output = dst_serial.serial_cmd_output('dmesg')
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace after migration')
dst_remote_qmp.qmp_cmd_output('{"execute":"system_reset"}')
dst_guest_ip = dst_serial.serial_login()
dst_guest_session = GuestSession(case_id=id,
params=params,
ip=dst_guest_ip)
test.sub_step_log('a.Check networking')
dst_guest_session.guest_ping_test('www.redhat.com', 10)
test.sub_step_log('b.Check block by the following methods')
utils_migration.filebench_test(dst_guest_session)
test.sub_step_log('c.Check VNC console and check keyboard by input keys')
time.sleep(3)
test.main_step_log('5.Migrate the guest back to Source Host host and '
'please refer to step 3')
src_remote_qmp.qmp_cmd_output('{"execute":"quit"}', recv_timeout=3)
time.sleep(3)
src_host_session.check_guest_process(src_ip=src_host_ip)
if (flag == 'p8_to_p9'):
params.vm_base_cmd_update('machine',
'pseries-rhel7.3.0,max-cpu-compat=power8',
'pseries-rhel7.3.0')
elif (flag == 'p9_to_p8'):
params.vm_base_cmd_update('machine', 'pseries-rhel7.3.0',
'pseries-rhel7.3.0,max-cpu-compat=power8')
params.vm_base_cmd_update(
'chardev',
'socket,id=serial_id_serial0,host=%s,port=%s,server,nowait' %
(dst_host_ip, serial_port),
'socket,id=serial_id_serial0,host=%s,port=%s,server,nowait' %
(src_host_ip, serial_port))
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id,
params,
ip=src_host_ip,
port=qmp_port)
check_info = utils_migration.do_migration(remote_qmp=dst_remote_qmp,
migrate_port=incoming_port,
dst_ip=src_host_ip)
if (check_info == False):
test.test_error('Migration timeout')
test.main_step_log('6.Repeat step 4')
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
output = src_serial.serial_cmd_output('dmesg')
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace after migration')
src_remote_qmp.qmp_cmd_output('{"execute":"system_reset"}')
src_guest_ip = src_serial.serial_login()
src_guest_session = GuestSession(case_id=id,
params=params,
ip=src_guest_ip)
test.sub_step_log('a.Check networking')
src_guest_session.guest_ping_test('www.redhat.com', 10)
test.sub_step_log('b.Check block by the following methods')
utils_migration.filebench_test(src_guest_session)
test.sub_step_log('c.Check VNC console and check keyboard by input keys')
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
guest_passwd = params.get('guest_passwd')
incoming_port = params.get('incoming_port')
test = CreateTest(case_id='rhel7_10027', params=params)
id = test.get_id()
src_host_session = HostSession(id, params)
test.main_step_log('1. start vm on src host with \"-S\" in qemu cli')
params.vm_base_cmd_add('S', 'None')
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
test.sub_step_log('Check the status of src guest')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
test.main_step_log('2. start listening mode on the dst host '
'with \"-incoming tcp:0:5800\" '
'but without \"-S\" in qemu cli')
params.vm_base_cmd_add('incoming', 'tcp:0:%s' % incoming_port)
params.vm_base_cmd_del('S', 'None')
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(ip=dst_host_ip,
cmd=dst_qemu_cmd,
vm_alias='dst')
test.sub_step_log('Check the status of dst guest')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
test.main_step_log('3. "cont" gust, after kernel start to load, '
'implement migration during vm boot ')
src_remote_qmp.qmp_cmd_output('{ "execute": "cont" }')
test.sub_step_log('Connecting to src serial')
src_serial = RemoteSerialMonitor(case_id=id,
params=params,
ip=src_host_ip,
port=serial_port)
search_str = '[ 0.000000]'
while 1:
output = src_serial.serial_output(max_recv_data=128,
search_str=search_str)
if re.findall(r'Found the searched keyword', output):
test.test_print(output)
do_migration(src_remote_qmp, incoming_port, dst_host_ip)
break
else:
test.test_print(output)
if re.findall(r'login:'******'Failed to find the keyword: %s' % search_str)
test.main_step_log('4. After finish migration and guest boot up, '
'check if guest works well')
dst_serial = RemoteSerialMonitor(case_id=id,
params=params,
ip=dst_host_ip,
port=serial_port)
timeout = 600
endtime = time.time() + timeout
bootup = False
while time.time() < endtime:
cmd = 'root'
dst_serial.send_cmd(cmd)
output = dst_serial.rec_data(recv_timeout=8)
dst_serial.test_print(info=output, serial_debug=True)
if re.findall(r'Password', output):
dst_serial.send_cmd(guest_passwd)
dst_serial.test_print(guest_passwd, serial_debug=True)
output = dst_serial.rec_data(recv_timeout=8)
dst_serial.test_print(info=output, serial_debug=True)
if re.search(r"login:"******"login:"******"execute":"quit"}')
if output:
src_remote_qmp.test_error('Failed to quit qemu on src end')
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
incoming_port = str(params.get('incoming_port'))
serial_port = int(params.get('serial_port'))
qmp_port = int(params.get('qmp_port'))
test = CreateTest(case_id='rhel7_10057', params=params)
id = test.get_id()
downtime = '30000'
script = 'migration_dirtypage_1.c'
query_timeout = 2400
active_timeout = 300
running_timeout = 300
src_host_session = HostSession(id, params)
src_qemu_cmd = params.create_qemu_cmd()
test.main_step_log('1. Start VM in src host ')
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
test.sub_step_log('Connecting to src serial')
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
src_guest_ip = src_serial.serial_login()
src_guest_session = GuestSession(case_id=id,
params=params,
ip=src_guest_ip)
test.sub_step_log('Check dmesg info ')
cmd = 'dmesg'
output = src_guest_session.guest_cmd_output(cmd)
if re.findall(r'Call Trace:', output):
src_guest_session.test_error('Guest hit call trace')
test.main_step_log('2. Start listening mode in dst host ')
incoming_val = 'tcp:0:%s' % (incoming_port)
params.vm_base_cmd_add('incoming', incoming_val)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(ip=dst_host_ip,
cmd=dst_qemu_cmd,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
test.main_step_log('3. src guest have '
'programme running to generate dirty page')
test.sub_step_log('run dirty page script')
utils_migration.dirty_page_test(host_session=src_host_session,
guest_session=src_guest_session,
guest_ip=src_guest_ip,
script=script)
test.main_step_log('4. Migrate to the destination')
cmd = '{"execute":"migrate", "arguments": {"uri": "tcp:%s:%s"}}' % \
(dst_host_ip, incoming_port)
src_remote_qmp.qmp_cmd_output(cmd)
test.main_step_log('5.set downtime for migration')
flag_active = False
cmd = '{"execute":"query-migrate"}'
end_time = time.time() + active_timeout
while time.time() < end_time:
output = src_remote_qmp.qmp_cmd_output(cmd)
if re.findall(r'"status": "active"', output):
flag_active = True
break
elif re.findall(r'"status": "failed"', output):
src_remote_qmp.test_error('Migration failed')
if (flag_active == False):
src_remote_qmp.test_error('Migration could not be active within %d' %
active_timeout)
downtime_cmd = '{"execute":"migrate-set-parameters",' \
'"arguments":{"downtime-limit": %s}}' % downtime
src_remote_qmp.qmp_cmd_output(cmd=downtime_cmd)
paras_chk_cmd = '{"execute":"query-migrate-parameters"}'
output = src_remote_qmp.qmp_cmd_output(cmd=paras_chk_cmd)
if re.findall(r'"downtime-limit": %s' % downtime, output):
test.test_print('Set migration downtime successfully')
else:
test.test_error('Failed to change downtime')
test.sub_step_log('Check the status of migration')
flag = False
cmd = '{"execute":"query-migrate"}'
end_time = time.time() + query_timeout
while time.time() < end_time:
output = src_remote_qmp.qmp_cmd_output(cmd=cmd)
if re.findall(r'"remaining": 0', output):
flag = True
break
elif re.findall(r'"status": "failed"', output):
src_remote_qmp.test_error('migration failed')
if (flag == False):
test.test_error('Migration timeout in %d' % query_timeout)
test.main_step_log('6.Check status of guest in dst host')
cmd = '{"execute":"query-status"}'
flag_running = False
end_time = time.time() + running_timeout
while time.time() < end_time:
output = dst_remote_qmp.qmp_cmd_output(cmd=cmd, recv_timeout=3)
if re.findall(r'"status": "running"', output):
flag_running = True
break
if (flag_running == False):
test.test_error('Dst guest is not running after migration finished %d '
'seconds' % running_timeout)
test.sub_step_log('Check dmesg info ')
cmd = 'dmesg'
output = src_guest_session.guest_cmd_output(cmd)
if re.findall(r'Call Trace:', output):
src_guest_session.test_error('Guest hit call trace')
dst_serial = RemoteSerialMonitor(case_id=id,
params=params,
ip=dst_host_ip,
port=serial_port)
cmd = 'dmesg'
output = dst_serial.serial_cmd_output(cmd=cmd)
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace')
dst_serial.serial_cmd(cmd='reboot')
dst_guest_ip = dst_serial.serial_login()
external_host_ip = dst_host_ip
dst_guest_session = GuestSession(case_id=id,
params=params,
ip=dst_guest_ip)
cmd_ping = 'ping %s -c 10' % external_host_ip
output = dst_guest_session.guest_cmd_output(cmd=cmd_ping)
if re.findall(r'100% packet loss', output):
dst_guest_session.test_error('Ping failed')
test.sub_step_log('quit qemu on src end and shutdown vm on dst end')
output = src_remote_qmp.qmp_cmd_output('{"execute":"quit"}',
recv_timeout=3)
if output:
src_remote_qmp.test_error('Failed to quit qemu on src host')
dst_serial.serial_shutdown_vm()
def run_case(params):
src_host_ip = params.get('src_host_ip')
dst_host_ip = params.get('dst_host_ip')
qmp_port = int(params.get('qmp_port'))
serial_port = int(params.get('serial_port'))
incoming_port = params.get('incoming_port')
test = CreateTest(case_id='rhel7_10061', params=params)
id = test.get_id()
guest_name = test.guest_name
src_host_session = HostSession(id, params)
test.main_step_log('1. Start VM in the src host, guest running stress')
src_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_guest(cmd=src_qemu_cmd, vm_alias='src')
src_remote_qmp = RemoteQMPMonitor(id, params, src_host_ip, qmp_port)
test.sub_step_log('1.1 Connecting to src serial')
src_serial = RemoteSerialMonitor(id, params, src_host_ip, serial_port)
src_guest_ip = src_serial.serial_login()
src_guest_session = GuestSession(case_id=id,
params=params,
ip=src_guest_ip)
test.sub_step_log('1.2 Running stress in src guest')
utils_migration.stress_test(guest_session=src_guest_session)
test.main_step_log('2. Start listening mode in the dst host.')
incoming_val = 'tcp:0:%s' % incoming_port
params.vm_base_cmd_add('incoming', incoming_val)
dst_qemu_cmd = params.create_qemu_cmd()
src_host_session.boot_remote_guest(cmd=dst_qemu_cmd,
ip=dst_host_ip,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
test.main_step_log('3. Do live migration')
cmd = '{"execute":"migrate", "arguments": {"uri": "tcp:%s:%s"}}' % (
dst_host_ip, incoming_port)
src_remote_qmp.qmp_cmd_output(cmd=cmd)
test.sub_step_log('Check the status of migration')
flag_active = utils_migration.query_status(remote_qmp=src_remote_qmp,
status='active')
if (flag_active == False):
test.test_error('Migration is not active')
test.main_step_log('4. During migration in progress, cancel migration')
cmd = '{"execute":"migrate_cancel"}'
src_remote_qmp.qmp_cmd_output(cmd=cmd, recv_timeout=3)
output = src_remote_qmp.qmp_cmd_output('{"execute":"query-migrate"}',
recv_timeout=3)
if re.findall(r'"status": "cancelled"', output):
src_remote_qmp.test_print('Src cancel migration successfully')
else:
src_remote_qmp.test_error('Failed to cancel migration')
test.main_step_log('5. Start listening mode againg in the dst host')
test.sub_step_log('5.1 Check if the dst qemu quit automatically')
dst_chk_cmd = 'ssh root@%s ps -axu | grep %s | grep -v grep' \
% (dst_host_ip, guest_name)
output = src_host_session.host_cmd_output(cmd=dst_chk_cmd)
if not output:
src_host_session.test_print('DST QEMU quit automatically after '
'src cancelling migration')
else:
src_host_session.test_error('DST QEMU does not quit automatically '
'after src cancelling migration')
test.sub_step_log('5.2 Start listening mode again in dst host')
src_host_session.boot_remote_guest(cmd=dst_qemu_cmd,
ip=dst_host_ip,
vm_alias='dst')
dst_remote_qmp = RemoteQMPMonitor(id, params, dst_host_ip, qmp_port)
test.main_step_log('6. Do live migration again')
output = utils_migration.do_migration(remote_qmp=src_remote_qmp,
migrate_port=incoming_port,
dst_ip=dst_host_ip)
if (output == False):
test.test_error('Migration timeout')
test.main_step_log('7. After migration succeed, '
'checking the status of guest on the dst host')
test.sub_step_log('7.1 Guest keyboard and mouse work normally.')
test.sub_step_log('7.2 Reboot guest')
dst_serial = RemoteSerialMonitor(id, params, dst_host_ip, serial_port)
cmd = 'dmesg'
output = dst_serial.serial_cmd_output(cmd=cmd)
if re.findall(r'Call Trace:', output):
test.test_error('Guest hit call trace')
dst_serial.serial_cmd(cmd='reboot')
dst_guest_ip = dst_serial.serial_login()
test.sub_step_log(
'7.3 Ping external host/copy file between guest and host')
dst_guest_session = GuestSession(case_id=id,
params=params,
ip=dst_guest_ip)
dst_guest_session.guest_ping_test('www.redhat.com', 10)
test.sub_step_log('7.4 DD a file inside guest')
cmd_dd = 'dd if=/dev/zero of=file1 bs=1M count=100 oflag=direct'
output = dst_guest_session.guest_cmd_output(cmd=cmd_dd, timeout=600)
if not output or re.findall('error', output):
test.test_error('Failed to dd a file in guest')
test.sub_step_log('7.5 Shutdown guest successfully')
dst_serial.serial_shutdown_vm()