def setup_save_restore_hostdev_iface_with_teaming():
logging.info("Create hostdev network.")
net_hostdev_fwd = params.get("net_hostdev_fwd",
'{"mode": "hostdev", "managed": "yes"}')
net_hostdev_dict = {
"net_name": net_hostdev_name,
"net_forward": net_hostdev_fwd,
"net_forward_pf": '{"dev": "%s"}' % pf_name
}
libvirt_network.create_or_del_network(net_hostdev_dict)
libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface')
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
iface = interface.Interface("network")
iface.xml = create_bridge_iface_xml(vm, mac_addr, params)
vmxml.add_device(iface)
iface.xml = create_hostdev_iface_xml(vm, mac_addr, params)
vmxml.add_device(iface)
vmxml.sync()
logging.debug("VMXML after updating ifaces: %s.",
vm_xml.VMXML.new_from_dumpxml(vm_name))
vm.start()
vm_session = vm.wait_for_serial_login(timeout=240)
ping_ip = get_ping_dest(vm_session, mac_addr)
check_vm_network_accessed(vm_session,
ping_dest=ping_ip,
tcpdump_iface=bridge_name,
tcpdump_status_error=True)
def create_vf_pool():
"""
Create VF pool
"""
net_hostdev_dict = {
"net_name": params.get("net_name"),
"net_forward": params.get("net_forward"),
"vf_list_attrs": "[%s]" % utils_sriov.pci_to_addr(vf_pci)
}
libvirt_network.create_or_del_network(net_hostdev_dict)
def teardown_max_vfs():
"""
Teardown for max_vfs case
1. Disable VFs
2. Clean up networks
"""
pf_id_list = get_pf_id_list(pf_info, driver)
for pf_pci in pf_id_list:
sriov_base.recover_vf(pf_pci, params, timeout=240)
net_info = get_net_dict(pf_info)
for pf_dev in net_info:
libvirt_network.create_or_del_network(
{"net_name": net_info[pf_dev]}, True)
def create_network(net_name, pf_name, params):
"""
Create network
:param net_name: Network name to create
:param pf_name: PF device
:param params: The parameters dict
"""
net_dict = {
"net_name": net_name,
"net_forward": params.get("net_forward"),
"net_forward_pf": '{"dev": "%s"}' % pf_name
}
libvirt_network.create_or_del_network(net_dict)
def create_network(params):
"""
Create VF pool
"""
net_dict = {
"net_name": params.get("net_name"),
"net_forward": params.get("net_forward")
}
net_forward_pf = "yes" == params.get("net_forward_pf")
if net_forward_pf:
net_dict.update(
{"net_forward_pf": '{"dev": "%s"}' % params.get("pf_name")})
else:
net_dict.update({"forward_iface": params.get("vf_iface")})
libvirt_network.create_or_del_network(net_dict)
def setup_hotplug_hostdev_iface_with_teaming():
logging.info("Create hostdev network.")
net_hostdev_fwd = params.get("net_hostdev_fwd",
'{"mode": "hostdev", "managed": "yes"}')
net_hostdev_dict = {
"net_name": net_hostdev_name,
"net_forward": net_hostdev_fwd,
"net_forward_pf": '{"dev": "%s"}' % pf_name
}
libvirt_network.create_or_del_network(net_hostdev_dict)
logging.info("Clear up VM interface.")
libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface')
vm.start()
vm.wait_for_serial_login(timeout=180).close()
def setup_hotplug_hostdev_iface_with_teaming():
logging.info("Create hostdev network.")
net_hostdev_fwd = params.get("net_hostdev_fwd",
'{"mode": "hostdev", "managed": "yes"}')
net_hostdev_dict = {
"net_name": net_hostdev_name,
"net_forward": net_hostdev_fwd,
"net_forward_pf": '{"dev": "%s"}' % pf_name
}
libvirt_network.create_or_del_network(net_hostdev_dict)
logging.info("Clear up VM interface.")
libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface')
iface = interface.Interface("network")
iface.xml = create_bridge_iface_xml(vm, mac_addr, params)
virsh.attach_device(vm_name,
iface.xml,
flagstr='--persistent',
debug=True,
ignore_status=False)
vm.start()
vm.wait_for_serial_login(timeout=180).close()
def run(test, params, env):
"""
Test interfaces attached from network
"""
def test_at_dt():
"""
Test attach-detach interfaces
"""
if not pf_status:
logging.info("Set pf state to down.")
pf_iface_obj = utils_net.Interface(pf_name)
pf_iface_obj.down()
logging.info("Define network - %s.", params.get("net_name"))
create_network(params)
logging.debug("Remove VM's interface devices.")
libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface')
vm.start()
vm_session = vm.wait_for_serial_login(timeout=240)
logging.info("Hotplug an interface to VM.")
iface_dict = {
"model": "virtio",
"source": {
'network': params.get("net_name")
}
}
iface = create_iface(iface_dict)
res = virsh.attach_device(vm_name, iface.xml, debug=True)
libvirt.check_exit_status(res, status_error)
if not pf_status:
logging.info("Set pf state to up then check again.")
pf_iface_obj.up()
virsh.attach_device(vm_name,
iface.xml,
debug=True,
ignore_status=False)
libvirt_vmxml.check_guest_xml(vm.name, params["net_name"])
sriov_base.check_vm_network_accessed(vm_session)
def test_connection():
"""
Test network connections
1. Create a network
2. Attach the interfaces and check network connections
3. Check the network connections after detaching ifaces, restarting
libvirtd and destroying the VM
"""
vf_no = int(params.get("vf_no", "4"))
net_name = params.get("net_name")
iface_type = params.get("iface_type")
logging.info("Define network - %s.", net_name)
create_network(params)
libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface')
libvirt_pcicontr.reset_pci_num(vm_name)
vm.start()
vm.wait_for_serial_login(timeout=240)
logging.info("Attach 4 interfaces to the guest.")
opts = ' '.join(
["network", net_name,
params.get('attach_extra_opts', "")])
for i in range(vf_no):
virsh.attach_interface(vm_name,
option=opts,
debug=True,
ignore_status=False)
libvirt_network.check_network_connection(net_name, i + 1)
logging.info("Try to attach one more interface.")
res = virsh.attach_interface(vm_name, option=opts, debug=True)
libvirt.check_exit_status(res, True)
logging.info("Detach an interface.")
vm_ifaces = [
iface for iface in vm_xml.VMXML.new_from_dumpxml(
vm_name).devices.by_device_tag("interface")
]
mac_addr = vm_ifaces[0].get_mac_address()
opts = ' '.join([iface_type, "--mac %s" % mac_addr])
virsh.detach_interface(vm_name,
option=opts,
debug=True,
wait_for_event=True,
ignore_status=False)
libvirt_network.check_network_connection(net_name, vf_no - 1)
logging.info(
"Restart libvirtd service and check the network connection.")
utils_libvirtd.Libvirtd().restart()
libvirt_network.check_network_connection(net_name, vf_no - 1)
logging.info("Destroy the VM and check the network connection.")
vm.destroy(gracefully=False)
libvirt_network.check_network_connection(net_name, 0)
test_case = params.get("test_case", "")
run_test = eval("test_%s" % test_case)
status_error = "yes" == params.get("status_error", "no")
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(vm_name)
pf_pci = utils_sriov.get_pf_pci()
if not pf_pci:
test.cancel("NO available pf found.")
sriov_base.setup_vf(pf_pci, params)
vf_pci = utils_sriov.get_vf_pci_id(pf_pci)
params['vf_iface'] = utils_sriov.get_iface_name(vf_pci)
pf_status = "active" == params.get("pf_status", "active")
pf_name = utils_sriov.get_pf_info_by_pci(pf_pci).get('iface')
params['pf_name'] = pf_name
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
orig_config_xml = vmxml.copy()
try:
run_test()
finally:
logging.info("Recover test enviroment.")
if not pf_status:
pf_iface_obj = utils_net.Interface(pf_name)
pf_iface_obj.up()
sriov_base.recover_vf(pf_pci, params)
if vm.is_alive():
vm.destroy(gracefully=False)
orig_config_xml.sync()
libvirt_network.create_or_del_network(
{"net_name": params.get("net_name")}, True)
def run(test, params, env):
"""
SR-IOV: managed related test.
"""
def start_vm(vm, test_login=False, destroy_vm=False):
"""
Start up VM
:param vm: The vm object
:param test_login: Whether to login VM
:param destroy_vm: Whether to destroy VM
"""
if vm.is_alive():
vm.destroy()
vm.start()
if test_login:
vm.wait_for_serial_login(timeout=180).close()
if destroy_vm:
vm.destroy()
def create_vf_pool():
"""
Create VF pool
"""
net_hostdev_dict = {
"net_name": params.get("net_name"),
"net_forward": params.get("net_forward"),
"vf_list_attrs": "[%s]" % utils_sriov.pci_to_addr(vf_pci)
}
libvirt_network.create_or_del_network(net_hostdev_dict)
def check_vm_iface_managed(vm_name, iface_dict):
"""
Check 'managed' in VM's iface
:param vm_name: Name of VM
:param iface_dict: The parameters dict
:raise: TestFail if not match
"""
vm_iface_managed = [
iface.get("managed") for iface in vm_xml.VMXML.new_from_dumpxml(
vm_name).devices.by_device_tag("interface")
][0]
expr_managed = "yes" if iface_dict.get("managed",
"") == "yes" else None
if vm_iface_managed != expr_managed:
test.fail("Unable to get the expected managed! Actual: %s, "
"Expected: %s." % (vm_iface_managed, expr_managed))
def test_networks():
"""
Start vm with VF from VF Pool with "managed=no" or default setting
1) Create VF pool
2) Prepare device xml and hot-plug to the guest
3) Detach the device from host
4) Check the driver of device
5) Start VM
6) Destroy vm then check the driver
7) Reattach the device to the host and check the driver
"""
create_vf_pool()
libvirt_vfio.check_vfio_pci(vf_pci, status_error=True)
iface_dict = {
"type": "network",
"source": "{'network': '%s'}" % params.get("net_name")
}
libvirt.modify_vm_iface(vm.name, "update_iface", iface_dict)
res = virsh.start(vm.name, debug=True)
libvirt.check_exit_status(res, True)
virsh.nodedev_detach(dev_name, debug=True, ignore_status=False)
libvirt_vfio.check_vfio_pci(vf_pci)
start_vm(vm, True, True)
libvirt_vfio.check_vfio_pci(vf_pci)
virsh.nodedev_reattach(dev_name, debug=True, ignore_status=False)
libvirt_vfio.check_vfio_pci(vf_pci, status_error=True)
def test_device_hotplug():
"""
Hotplug/unplug VF with managed='no'
1) Prepare a running guest
2) Check the driver of vf on host
3) Prepare a xml with "managed=no"and attach to guest
4) Detach the device from host
5) Check the driver of vf on host
6) Attach the device to guest
7) Check the interface of the guest
8) Detach the device from guest and check the driver
9) Reattach the device to the host and check the driver
"""
libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface')
start_vm(vm)
libvirt_vfio.check_vfio_pci(vf_pci, status_error=True)
mac_addr = utils_net.generate_mac_address_simple()
iface_dict = eval(
params.get('iface_dict', '{"hostdev_addr": "%s"}') %
utils_sriov.pci_to_addr(vf_pci))
iface = interface.Interface("hostdev")
iface.xml = libvirt.modify_vm_iface(vm.name, "get_xml", iface_dict)
res = virsh.attach_device(vm_name, iface.xml, debug=True)
libvirt.check_exit_status(res, True)
virsh.nodedev_detach(dev_name, debug=True, ignore_status=False)
libvirt_vfio.check_vfio_pci(vf_pci)
virsh.attach_device(vm_name,
iface.xml,
debug=True,
ignore_status=False)
check_vm_iface_managed(vm_name, iface_dict)
vm.wait_for_serial_login().close()
virsh.detach_device(vm_name,
iface.xml,
wait_remove_event=True,
debug=True,
ignore_status=False)
libvirt_vfio.check_vfio_pci(vf_pci)
virsh.nodedev_reattach(dev_name, debug=True, ignore_status=False)
libvirt_vfio.check_vfio_pci(vf_pci, status_error=True)
test_case = params.get("test_case", "")
run_test = eval("test_%s" % test_case)
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(vm_name)
pf_pci = utils_sriov.get_pf_pci()
if not pf_pci:
test.cancel("NO available pf found.")
default_vf = sriov_base.setup_vf(pf_pci, params)
vf_pci = utils_sriov.get_vf_pci_id(pf_pci)
dev_name = utils_sriov.get_device_name(vf_pci)
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
orig_config_xml = vmxml.copy()
try:
run_test()
finally:
logging.info("Recover test enviroment.")
sriov_base.recover_vf(pf_pci, params, default_vf)
if vm.is_alive():
vm.destroy(gracefully=False)
orig_config_xml.sync()
libvirt_network.create_or_del_network(
{"net_name": params.get("net_name")}, True)
virsh.nodedev_reattach(dev_name, debug=True)
def teardown_hotplug_hostdev_iface_with_teaming():
logging.info("Delete hostdev network.")
net_hostdev_dict = {"net_name": net_hostdev_name}
libvirt_network.create_or_del_network(net_hostdev_dict, is_del=True)
def run(test, params, env):
"""
Sriov net failover related test.
"""
def setup_hotplug_hostdev_iface_with_teaming():
logging.info("Create hostdev network.")
net_hostdev_fwd = params.get("net_hostdev_fwd",
'{"mode": "hostdev", "managed": "yes"}')
net_hostdev_dict = {
"net_name": net_hostdev_name,
"net_forward": net_hostdev_fwd,
"net_forward_pf": '{"dev": "%s"}' % pf_name
}
libvirt_network.create_or_del_network(net_hostdev_dict)
logging.info("Clear up VM interface.")
libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface')
iface = interface.Interface("network")
iface.xml = create_bridge_iface_xml(vm, mac_addr, params)
virsh.attach_device(vm_name,
iface.xml,
flagstr='--persistent',
debug=True,
ignore_status=False)
vm.start()
vm.wait_for_serial_login(timeout=180).close()
def teardown_hotplug_hostdev_iface_with_teaming():
logging.info("Delete hostdev network.")
net_hostdev_dict = {"net_name": net_hostdev_name}
libvirt_network.create_or_del_network(net_hostdev_dict, is_del=True)
def test_hotplug_hostdev_iface_with_teaming():
logging.info("Attach a hostdev interface.")
hostdev_iface_xml = create_hostdev_iface_xml(vm, mac_addr, params)
virsh.attach_device(vm_name,
hostdev_iface_xml,
debug=True,
ignore_status=False)
check_ifaces(vm_name, expected_ifaces={"bridge", "hostdev"})
vm_session = vm.wait_for_serial_login(timeout=240)
ping_ip = get_ping_dest(vm_session, mac_addr)
check_vm_network_accessed(vm_session,
ping_dest=ping_ip,
tcpdump_iface=bridge_name,
tcpdump_status_error=True)
logging.info("Detach the hostdev interface.")
hostdev_iface = interface.Interface("network")
for ifc in vm_xml.VMXML.new_from_dumpxml(
vm_name).devices.by_device_tag("interface"):
if ifc.type_name == "hostdev":
ifc.del_address()
hostdev_iface = ifc
virsh.detach_device(vm_name,
hostdev_iface.xml,
wait_remove_event=True,
debug=True,
ignore_status=False)
check_ifaces(vm_name, expected_ifaces={"hostdev"}, status_error=True)
check_vm_network_accessed(vm_session,
2,
ping_dest=ping_ip,
tcpdump_iface=bridge_name,
tcpdump_status_error=False)
libvirt_vfio.check_vfio_pci(vf_pci, status_error=True)
logging.info("Re-attach the hostdev interface.")
virsh.attach_device(vm_name,
hostdev_iface.xml,
debug=True,
ignore_status=False)
check_vm_network_accessed(vm_session,
ping_dest=ping_ip,
tcpdump_iface=bridge_name,
tcpdump_status_error=True)
def setup_hotplug_hostdev_device_with_teaming():
libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface')
vm.start()
vm.wait_for_serial_login(timeout=240).close()
def test_hotplug_hostdev_device_with_teaming():
default_vf_mac = utils_sriov.get_vf_mac(pf_name)
utils_sriov.set_vf_mac(pf_name, mac_addr)
logging.info("Attach the bridge interface.")
brg_iface_xml = create_bridge_iface_xml(vm, mac_addr, params)
virsh.attach_device(vm_name,
brg_iface_xml,
debug=True,
ignore_status=False)
# Wait for 10s before attaching the hostdev device
time.sleep(10)
logging.info("Attach the hostdev device.")
hostdev_dev = libvirt.create_hostdev_xml(vf_pci,
teaming=hostdev_teaming_dict)
virsh.attach_device(vm_name,
hostdev_dev.xml,
debug=True,
ignore_status=False)
vm_session = vm.wait_for_serial_login(timeout=240)
ping_ip = get_ping_dest(vm_session, mac_addr)
check_vm_network_accessed(vm_session,
ping_dest=ping_ip,
tcpdump_iface=bridge_name,
tcpdump_status_error=True)
logging.info("Detach the hostdev device.")
virsh.detach_device(vm_name,
hostdev_dev.xml,
wait_remove_event=True,
debug=True,
ignore_status=False)
logging.debug("Recover vf's mac to %s.", default_vf_mac)
utils_sriov.set_vf_mac(pf_name, default_vf_mac)
check_hostdev = vm_xml.VMXML.new_from_dumpxml(vm_name)\
.devices.by_device_tag('hostdev')
if check_hostdev:
test.fail("The hostdev device exists after detaching %s." %
check_hostdev)
libvirt_vfio.check_vfio_pci(vf_pci, status_error=True)
check_vm_network_accessed(vm_session,
2,
ping_dest=ping_ip,
tcpdump_iface=bridge_name,
tcpdump_status_error=False)
def setup_save_restore_hostdev_device_with_teaming():
logging.info("Start a VM with bridge iface and hostdev device.")
libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface')
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
iface = interface.Interface("network")
iface.xml = create_bridge_iface_xml(vm, mac_addr, params)
vmxml.add_device(iface)
hostdev_dev = libvirt.create_hostdev_xml(vf_pci,
teaming=hostdev_teaming_dict)
vmxml.add_device(hostdev_dev)
vmxml.sync()
vm.start()
utils_sriov.set_vf_mac(pf_name, mac_addr)
vm.wait_for_serial_login(timeout=240).close()
def test_save_restore_hostdev_device_with_teaming():
logging.info("Save/restore VM.")
save_file = os.path.join(data_dir.get_tmp_dir(), "save_file")
virsh.save(vm_name,
save_file,
debug=True,
ignore_status=False,
timeout=10)
if not libvirt.check_vm_state(vm_name, "shut off"):
test.fail("The guest should be down after executing 'virsh save'.")
virsh.restore(save_file, debug=True, ignore_status=False)
if not libvirt.check_vm_state(vm_name, "running"):
test.fail(
"The guest should be running after executing 'virsh restore'.")
vm.cleanup_serial_console()
vm.create_serial_console()
vm_session = vm.wait_for_serial_login()
ping_ip = get_ping_dest(vm_session, mac_addr)
check_vm_network_accessed(vm_session,
ping_dest=ping_ip,
tcpdump_iface=bridge_name,
tcpdump_status_error=True)
logging.info("Detach the hostdev device.")
hostdev_dev = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name).devices.\
by_device_tag("hostdev")
virsh.detach_device(vm_name,
hostdev_dev.xml,
wait_remove_event=True,
debug=True,
ignore_status=False)
check_hostdev = vm_xml.VMXML.new_from_dumpxml(vm_name)\
.devices.by_device_tag('hostdev')
if check_hostdev:
test.fail("The hostdev device exists after detaching %s." %
check_hostdev)
check_vm_network_accessed(vm_session,
2,
ping_dest=ping_ip,
tcpdump_iface=bridge_name,
tcpdump_status_error=False)
logging.info("Attach the hostdev device.")
virsh.attach_device(vm_name,
hostdev_dev.xml,
debug=True,
ignore_status=False)
check_vm_network_accessed(vm_session,
ping_dest=ping_ip,
tcpdump_iface=bridge_name,
tcpdump_status_error=True)
def setup_save_restore_hostdev_iface_with_teaming():
logging.info("Create hostdev network.")
net_hostdev_fwd = params.get("net_hostdev_fwd",
'{"mode": "hostdev", "managed": "yes"}')
net_hostdev_dict = {
"net_name": net_hostdev_name,
"net_forward": net_hostdev_fwd,
"net_forward_pf": '{"dev": "%s"}' % pf_name
}
libvirt_network.create_or_del_network(net_hostdev_dict)
libvirt_vmxml.remove_vm_devices_by_type(vm, 'interface')
vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name)
iface = interface.Interface("network")
iface.xml = create_bridge_iface_xml(vm, mac_addr, params)
vmxml.add_device(iface)
iface.xml = create_hostdev_iface_xml(vm, mac_addr, params)
vmxml.add_device(iface)
vmxml.sync()
logging.debug("VMXML after updating ifaces: %s.",
vm_xml.VMXML.new_from_dumpxml(vm_name))
vm.start()
vm_session = vm.wait_for_serial_login(timeout=240)
ping_ip = get_ping_dest(vm_session, mac_addr)
check_vm_network_accessed(vm_session,
ping_dest=ping_ip,
tcpdump_iface=bridge_name,
tcpdump_status_error=True)
def teardown_save_restore_hostdev_iface_with_teaming():
teardown_hotplug_hostdev_iface_with_teaming()
def test_save_restore_hostdev_iface_with_teaming():
logging.info("Save/restore VM.")
save_file = os.path.join(data_dir.get_tmp_dir(), "save_file")
virsh.save(vm_name,
save_file,
debug=True,
ignore_status=False,
timeout=10)
if not libvirt.check_vm_state(vm_name, "shut off"):
test.fail("The guest should be down after executing 'virsh save'.")
virsh.restore(save_file, debug=True, ignore_status=False)
if not libvirt.check_vm_state(vm_name, "running"):
test.fail(
"The guest should be running after executing 'virsh restore'.")
vm.cleanup_serial_console()
vm.create_serial_console()
vm_session = vm.wait_for_serial_login(timeout=240)
ping_ip = get_ping_dest(vm_session, mac_addr, False)
logging.debug(ping_ip)
check_vm_network_accessed(vm_session,
ping_dest=ping_ip,
tcpdump_iface=bridge_name,
tcpdump_status_error=True)
def check_vm_iface_num(session, exp_num=3):
"""
Check he number of interfaces
:param session: The session to the guest
:param exp_num: The expected number
:return: True when interfaces' number is equal to exp_num
"""
p_iface = utils_net.get_remote_host_net_ifs(session)[0]
logging.debug("Ifaces in VM: %s", p_iface)
return len(p_iface) == exp_num
def check_vm_network_accessed(vm_session,
expected_iface_no=3,
ping_dest="8.8.8.8",
timeout=30,
tcpdump_iface=None,
tcpdump_status_error=False):
"""
Test VM's network by checking ifaces' number and the accessibility
:param vm_session: The session object to the guest
:param expected_iface_no: The expected number of ifaces
:param ping_dest: The destination to be ping
:param timeout: The timeout of the checking
:param tcpdump_iface: The interface to check
:param tcpdump_status_error: Whether the tcpdump's output should include
the string "ICMP echo request"
:raise: test.fail when ifaces' number is incorrect or ping fails.
"""
if not utils_misc.wait_for(
lambda: check_vm_iface_num(vm_session, expected_iface_no),
first=3,
timeout=timeout):
test.fail("%d interfaces should be found on the vm." %
expected_iface_no)
if tcpdump_iface:
cmd = "tcpdump -i %s icmp" % tcpdump_iface
tcpdump_session = aexpect.ShellSession('bash')
tcpdump_session.sendline(cmd)
if not utils_misc.wait_for(
lambda: not utils_test.ping(ping_dest,
count=3,
timeout=5,
output_func=logging.debug,
session=vm_session)[0],
first=5,
timeout=timeout):
test.fail("Failed to ping %s." % ping_dest)
if tcpdump_iface:
output = tcpdump_session.get_stripped_output()
logging.debug("tcpdump's output: %s.", output)
pat_str = "ICMP echo request"
if re.search(pat_str, output):
if tcpdump_status_error:
test.fail(
"Get incorrect tcpdump output: {}, it should not "
"include '{}'.".format(output, pat_str))
else:
if not tcpdump_status_error:
test.fail("Get incorrect tcpdump output: {}, it should "
"include '{}'.".format(output, pat_str))
def get_ping_dest(vm_session, mac_addr, restart_network=True):
"""
Get an ip address to ping
:param vm_session: The session object to the guest
:param mac_addr: mac address of given interface
:param restart_network: Whether to restart guest's network
:return: ip address
"""
if restart_network:
utils_misc.cmd_status_output("dhclient -r; sleep 5; dhclient",
shell=True,
session=vm_session)
vm_iface_info = utils_net.get_linux_iface_info(
mac_addr, vm_session)['addr_info'][0]['local']
return re.sub('\d+$', '1', vm_iface_info)
def create_bridge_iface_xml(vm, mac_addr, params):
"""
Create xml of bridge interface
:param vm: The vm object
:param mac_address: The mac address
:param params: Dictionary with the test parameters
:return: The interface xml
"""
net_bridge_name = params.get("net_bridge_name", "host-bridge")
iface_bridge_dict = {
"type": "network",
"source": "{'network': '%s'}" % net_bridge_name,
"mac": mac_addr,
"model": "virtio",
"teaming": '{"type":"persistent"}',
"alias": '{"name": "ua-backup0"}'
}
return libvirt.modify_vm_iface(vm.name, "get_xml", iface_bridge_dict)
def create_hostdev_iface_xml(vm, mac_addr, params):
"""
Create xml of hostdev interface
:param vm: The vm object
:param mac_address: The mac address
:param params: Dictionary with the test parameters
:return: The interface xml
"""
net_hostdev_name = params.get("net_hostdev_name", "hostdev-net")
hostdev_iface_dict = {
"type": "network",
"source": "{'network': '%s'}" % net_hostdev_name,
"mac": mac_addr,
"teaming": '{"type":"transient", "persistent": "ua-backup0"}'
}
return libvirt.modify_vm_iface(vm.name, "get_xml", hostdev_iface_dict,
4)
def check_ifaces(vm_name,
expected_ifaces={"bridge", "hostdev"},
status_error=False):
"""
Check VM's interfaces
:param vm_name: The name of VM
:param expected_ifaces: The expected interfaces
:param status_error: Whether the ifaces should be same with the expected_ifaces
:raise: test.fail if the interface(s) is(are) as expected
"""
if not expected_ifaces:
return
else:
expected_ifaces = set(expected_ifaces)
vm_ifaces = [
iface for iface in vm_xml.VMXML.new_from_dumpxml(
vm_name).devices.by_device_tag("interface")
]
ifaces_net = {iface.get_type_name() for iface in vm_ifaces}
if expected_ifaces.issubset(ifaces_net) == status_error:
test.fail(
"Unable to get expected interface. The interface %s "
"should%s be %s." %
(ifaces_net, ' not' if status_error else '', expected_ifaces))
else:
logging.debug("{}Found iface(s) as expected: {}.".format(
'Not ' if status_error else '', expected_ifaces))
test_case = params.get("test_case", "")
run_test = eval("test_%s" % test_case)
setup_test = eval("setup_%s" % test_case) if "setup_%s" % test_case in \
locals() else "setup_%s" % test_case
teardown_test = eval("teardown_%s" % test_case) if "teardown_%s" % \
test_case in locals() else "teardown_%s" % test_case
vm_name = params.get("main_vm", "avocado-vt-vm1")
vm = env.get_vm(params["main_vm"])
driver = params.get("driver", "ixgbe")
bridge_name = params.get("bridge_name", "br0")
net_bridge_name = params.get("net_bridge_name", "host-bridge")
net_bridge_fwd = params.get("net_bridge_fwd", '{"mode": "bridge"}')
net_hostdev_name = params.get("net_hostdev_name", "hostdev-net")
bridge_name = params.get("bridge_name", "br0")
hostdev_teaming_dict = params.get("hostdev_device_teaming_dict", '{}')
default_vf = 0
try:
vf_no = int(params.get("vf_no", "4"))
except ValueError as e:
test.error(e)
libvirt_version.is_libvirt_feature_supported(params)
mac_addr = utils_net.generate_mac_address_simple()
pf_pci = utils_sriov.get_pf_pci()
if not pf_pci:
test.cancel("NO available pf found.")
pf_name = utils_sriov.get_pf_info_by_pci(pf_pci).get('iface')
brg_dict = {'pf_name': pf_name, 'bridge_name': bridge_name}
bridge_dict = {
"net_name": net_bridge_name,
"net_forward": net_bridge_fwd,
"net_bridge": '{"name": "%s"}' % bridge_name
}
pf_pci_path = utils_misc.get_pci_path(pf_pci)
cmd = "cat %s/sriov_numvfs" % (pf_pci_path)
default_vf = process.run(cmd, shell=True, verbose=True).stdout_text
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
orig_config_xml = new_xml.copy()
try:
if not utils_sriov.set_vf(pf_pci_path, vf_no):
test.error("Failed to set vf.")
utils_sriov.add_or_del_connection(brg_dict, is_del=False)
libvirt_network.create_or_del_network(bridge_dict)
vf_pci = utils_sriov.get_vf_pci_id(pf_pci)
exec_function(setup_test)
run_test()
finally:
logging.info("Recover test enviroment.")
utils_sriov.add_or_del_connection(brg_dict, is_del=True)
libvirt_network.create_or_del_network(bridge_dict, is_del=True)
if 'pf_pci_path' in locals() and default_vf != vf_no:
utils_sriov.set_vf(pf_pci_path, default_vf)
if vm.is_alive():
vm.destroy(gracefully=False)
try:
orig_config_xml.sync()
except:
# FIXME: Workaround for 'save'/'managedsave' hanging issue
utils_libvirtd.Libvirtd().restart()
orig_config_xml.sync()
exec_function(teardown_test)
def run(test, params, env):
"""
Test migration with special network settings
1) migrate guest with bridge type interface connected to ovs bridge
:param test: test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def check_vm_network_accessed(ping_dest, session=None):
"""
The operations to the VM need to be done before or after
migration happens
:param ping_dest: The destination to be ping
:param session: The session object to the host
:raise: test.fail when ping fails
"""
# Confirm local/remote VM can be accessed through network.
logging.info("Check VM network connectivity")
status, output = utils_net.ping(ping_dest,
count=10,
timeout=20,
output_func=logging.debug,
session=session)
if status != 0:
test.fail("Ping failed, status: %s, output: %s" % (status, output))
def update_iface_xml(vm_name, iface_dict):
"""
Update interfaces for guest
:param vm_name: The name of VM
:param iface_dict: The interface configurations params
"""
logging.debug("update iface xml")
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
vmxml.remove_all_device_by_type('interface')
vmxml.sync()
iface = interface.Interface('network')
iface.xml = libvirt.modify_vm_iface(vm.name, "get_xml", iface_dict)
libvirt.add_vm_device(vmxml, iface)
migration_test = migration.MigrationTest()
migration_test.check_parameters(params)
# Params for NFS shared storage
shared_storage = params.get("migrate_shared_storage", "")
if shared_storage == "":
default_guest_asset = defaults.get_default_guest_os_info()['asset']
default_guest_asset = "%s.qcow2" % default_guest_asset
shared_storage = os.path.join(params.get("nfs_mount_dir"),
default_guest_asset)
logging.debug("shared_storage:%s", shared_storage)
# Params to update disk using shared storage
params["disk_type"] = "file"
params["disk_source_protocol"] = "netfs"
params["mnt_path_name"] = params.get("nfs_mount_dir")
# Local variables
virsh_args = {"debug": True}
server_ip = params.get("server_ip")
server_user = params.get("server_user", "root")
server_pwd = params.get("server_pwd")
client_ip = params.get("client_ip")
client_pwd = params.get("client_pwd")
virsh_options = params.get("virsh_options", "")
extra = params.get("virsh_migrate_extra")
options = params.get("virsh_migrate_options", "--live --p2p --verbose")
func_params_exists = "yes" == params.get("func_params_exists", "no")
migr_vm_back = "yes" == params.get("migr_vm_back", "no")
ovs_bridge_name = params.get("ovs_bridge_name")
network_dict = eval(params.get("network_dict", '{}'))
iface_dict = eval(params.get("iface_dict", '{}'))
remote_virsh_dargs = {
'remote_ip': server_ip,
'remote_user': server_user,
'remote_pwd': server_pwd,
'unprivileged_user': None,
'ssh_remote_auth': True
}
func_name = None
libvirtd_conf = None
mig_result = None
# params for migration connection
params["virsh_migrate_desturi"] = libvirt_vm.complete_uri(
params.get("migrate_dest_host"))
params["virsh_migrate_connect_uri"] = libvirt_vm.complete_uri(
params.get("migrate_source_host"))
src_uri = params.get("virsh_migrate_connect_uri")
dest_uri = params.get("virsh_migrate_desturi")
vm_name = params.get("migrate_main_vm")
vm = env.get_vm(vm_name)
vm.verify_alive()
extra_args = {}
if func_params_exists:
extra_args.update({'func_params': params})
postcopy_options = params.get("postcopy_options")
if postcopy_options:
extra = "%s %s" % (extra, postcopy_options)
func_name = virsh.migrate_postcopy
# For safety reasons, we'd better back up xmlfile.
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
orig_config_xml = new_xml.copy()
try:
# Create a remote runner for later use
runner_on_target = remote.RemoteRunner(host=server_ip,
username=server_user,
password=server_pwd)
remote_session = remote.remote_login("ssh", server_ip, "22",
server_user, server_pwd, r'[$#%]')
if ovs_bridge_name:
status, stdout = utils_net.create_ovs_bridge(ovs_bridge_name)
if status:
test.fail("Failed to create ovs bridge on local. Status: %s"
"Stdout: %s" % (status, stdout))
status, stdout = utils_net.create_ovs_bridge(
ovs_bridge_name, session=remote_session)
if status:
test.fail("Failed to create ovs bridge on remote. Status: %s"
"Stdout: %s" % (status, stdout))
if network_dict:
libvirt_network.create_or_del_network(
network_dict, remote_args=remote_virsh_dargs)
libvirt_network.create_or_del_network(network_dict)
remote_session.close()
# Change domain network xml
if iface_dict:
if "mac" not in iface_dict:
mac = utils_net.generate_mac_address_simple()
iface_dict.update({'mac': mac})
else:
mac = iface_dict["mac"]
update_iface_xml(vm_name, iface_dict)
# Change the disk of the vm
libvirt.set_vm_disk(vm, params)
if not vm.is_alive():
try:
vm.start()
except virt_vm.VMStartError as err:
test.fail("Failed to start VM: %s" % err)
logging.debug("Guest xml after starting:\n%s",
vm_xml.VMXML.new_from_dumpxml(vm_name))
# Check local guest network connection before migration
if vm.serial_console is not None:
vm.cleanup_serial_console()
vm.create_serial_console()
vm_session = vm.wait_for_serial_login(timeout=240)
utils_net.restart_guest_network(vm_session)
vm_ip = utils_net.get_guest_ip_addr(vm_session, mac)
logging.debug("VM IP Addr: %s", vm_ip)
check_vm_network_accessed(vm_ip)
# Execute migration process
vms = [vm]
migration_test.do_migration(vms,
None,
dest_uri,
'orderly',
options,
thread_timeout=900,
ignore_status=True,
virsh_opt=virsh_options,
func=func_name,
extra_opts=extra,
**extra_args)
mig_result = migration_test.ret
migration_test.check_result(mig_result, params)
if int(mig_result.exit_status) == 0:
remote_session = remote.remote_login("ssh", server_ip, "22",
server_user, server_pwd,
r'[$#%]')
check_vm_network_accessed(vm_ip, session=remote_session)
remote_session.close()
# Execute migration from remote
if migr_vm_back:
ssh_connection = utils_conn.SSHConnection(server_ip=client_ip,
server_pwd=client_pwd,
client_ip=server_ip,
client_pwd=server_pwd)
try:
ssh_connection.conn_check()
except utils_conn.ConnectionError:
ssh_connection.conn_setup()
ssh_connection.conn_check()
# Pre migration setup for local machine
migration_test.migrate_pre_setup(src_uri, params)
cmd = "virsh migrate %s %s %s" % (vm_name, options, src_uri)
logging.debug("Start migration: %s", cmd)
cmd_result = remote.run_remote_cmd(cmd, params, runner_on_target)
logging.info(cmd_result)
if cmd_result.exit_status:
test.fail("Failed to run '%s' on remote: %s" %
(cmd, cmd_result))
logging.debug("VM is migrated back.")
check_vm_network_accessed(vm_ip)
finally:
logging.debug("Recover test environment")
# Clean VM on destination and source
try:
migration_test.cleanup_dest_vm(vm, vm.connect_uri, dest_uri)
except Exception as err:
logging.error(err)
if vm.is_alive():
vm.destroy(gracefully=False)
logging.info("Recovery VM XML configration")
orig_config_xml.sync()
remote_session = remote.remote_login("ssh", server_ip, "22",
server_user, server_pwd, r'[$#%]')
if network_dict:
libvirt_network.create_or_del_network(
network_dict, is_del=True, remote_args=remote_virsh_dargs)
libvirt_network.create_or_del_network(network_dict, is_del=True)
if ovs_bridge_name:
utils_net.delete_ovs_bridge(ovs_bridge_name)
utils_net.delete_ovs_bridge(ovs_bridge_name,
session=remote_session)
remote_session.close()
if migr_vm_back:
if 'ssh_connection' in locals():
ssh_connection.auto_recover = True
migration_test.migrate_pre_setup(src_uri, params, cleanup=True)
logging.info("Remove local NFS image")
source_file = params.get("source_file")
if source_file:
libvirt.delete_local_disk("file", path=source_file)
def run(test, params, env):
"""
Test migration with special network settings
1) migrate guest with bridge type interface connected to ovs bridge
2) migrate guest with direct type interface when a macvtap device name
exists on dest host
:param test: test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def check_vm_network_accessed(ping_dest, session=None):
"""
The operations to the VM need to be done before or after
migration happens
:param ping_dest: The destination to be ping
:param session: The session object to the host
:raise: test.fail when ping fails
"""
# Confirm local/remote VM can be accessed through network.
logging.info("Check VM network connectivity")
status, output = utils_net.ping(ping_dest,
count=10,
timeout=20,
output_func=logging.debug,
session=session)
if status != 0:
test.fail("Ping failed, status: %s, output: %s" % (status, output))
def vm_sync(vmxml, vm_name=None, virsh_instance=virsh):
"""
A wrapper to sync vm xml on localhost and remote host
:param vmxml: domain VMXML instance
:param vm_name: The name of VM
:param virsh_instance: virsh instance object
"""
if vm_name and virsh_instance != virsh:
remote.scp_to_remote(server_ip, '22', server_user,
server_pwd,
vmxml.xml, vmxml.xml)
if virsh_instance.domain_exists(vm_name):
if virsh_instance.is_alive(vm_name):
virsh_instance.destroy(vm_name, ignore_status=True)
virsh_instance.undefine(vmxml.xml, ignore_status=True)
virsh_instance.define(vmxml.xml, debug=True)
else:
vmxml.sync()
def update_iface_xml(vm_name, iface_dict, virsh_instance=virsh):
"""
Update interfaces for guest
:param vm_name: The name of VM
:param iface_dict: The interface configurations params
:param virsh_instance: virsh instance object
"""
logging.debug("update iface xml")
vmxml = vm_xml.VMXML.new_from_inactive_dumpxml(
vm_name, virsh_instance=virsh_instance)
vmxml.remove_all_device_by_type('interface')
vm_sync(vmxml, vm_name, virsh_instance=virsh_instance)
iface = interface.Interface('network')
iface.xml = libvirt.modify_vm_iface(vm_name, "get_xml", iface_dict,
virsh_instance=virsh_instance)
vmxml.add_device(iface)
vmxml.xmltreefile.write()
vm_sync(vmxml, vm_name, virsh_instance=virsh_instance)
logging.debug("VM XML after updating interface: %s" % vmxml)
def update_net_dict(net_dict, runner=utils_net.local_runner):
"""
Update network dict
:param net_dict: The network dict to be updated
:param runner: Command runner
:return: Updated network dict
"""
if net_dict.get("net_name", "") == "direct-macvtap":
logging.info("Updating network iface name")
iface_name = utils_net.get_net_if(runner=runner, state="UP")[0]
net_dict.update({"forward_iface": iface_name})
else:
# TODO: support other types
logging.info("No need to update net_dict. We only support to "
"update direct-macvtap type for now.")
logging.debug("net_dict is %s" % net_dict)
return net_dict
def get_remote_direct_mode_vm_mac(vm_name, uri):
"""
Get mac of remote direct mode VM
:param vm_name: The name of VM
:param uri: The uri on destination
:return: mac
:raise: test.fail when the result of virsh domiflist is incorrect
"""
vm_mac = None
res = virsh.domiflist(
vm_name, uri=uri, ignore_status=False).stdout_text.strip().split("\n")
if len(res) < 2:
test.fail("Unable to get remote VM's mac: %s" % res)
else:
vm_mac = res[-1].split()[-1]
return vm_mac
def create_fake_tap(remote_session):
"""
Create a fake macvtap on destination host.
:param remote_session: The session to the destination host.
:return: The new tap device
"""
tap_cmd = "ls /dev/tap* |awk -F 'tap' '{print $NF}'"
tap_idx = remote_session.cmd_output(tap_cmd).strip()
if not tap_idx:
test.fail("Unable to get tap index using %s."
% tap_cmd)
fake_tap_dest = 'tap'+str(int(tap_idx)+1)
logging.debug("creating a fake tap %s...", fake_tap_dest)
cmd = "touch /dev/%s" % fake_tap_dest
remote_session.cmd(cmd)
return fake_tap_dest
migration_test = migration.MigrationTest()
migration_test.check_parameters(params)
libvirt_version.is_libvirt_feature_supported(params)
# Params to update disk using shared storage
params["disk_type"] = "file"
params["disk_source_protocol"] = "netfs"
params["mnt_path_name"] = params.get("nfs_mount_dir")
# Local variables
virsh_args = {"debug": True}
server_ip = params.get("server_ip")
server_user = params.get("server_user", "root")
server_pwd = params.get("server_pwd")
client_ip = params.get("client_ip")
client_pwd = params.get("client_pwd")
virsh_options = params.get("virsh_options", "")
extra = params.get("virsh_migrate_extra")
options = params.get("virsh_migrate_options", "--live --p2p --verbose")
restart_dhclient = params.get("restart_dhclient", "dhclient -r; dhclient")
ping_dest = params.get("ping_dest", "www.baidu.com")
extra_args = migration_test.update_virsh_migrate_extra_args(params)
migrate_vm_back = "yes" == params.get("migrate_vm_back", "no")
target_vm_name = params.get("target_vm_name")
direct_mode = "yes" == params.get("direct_mode", "no")
check_macvtap_exists = "yes" == params.get("check_macvtap_exists", "no")
create_fake_tap_dest = "yes" == params.get("create_fake_tap_dest", "no")
macvtap_cmd = params.get("macvtap_cmd")
modify_target_vm = "yes" == params.get("modify_target_vm", "no")
ovs_bridge_name = params.get("ovs_bridge_name")
network_dict = eval(params.get("network_dict", '{}'))
iface_dict = eval(params.get("iface_dict", '{}'))
remote_virsh_dargs = {'remote_ip': server_ip, 'remote_user': server_user,
'remote_pwd': server_pwd, 'unprivileged_user': None,
'ssh_remote_auth': True}
cmd_parms = {'server_ip': server_ip, 'server_user': server_user,
'server_pwd': server_pwd}
virsh_session_remote = None
libvirtd_conf = None
mig_result = None
target_org_xml = None
target_vm_session = None
target_vm = None
exp_macvtap = []
fake_tap_dest = None
# params for migration connection
params["virsh_migrate_desturi"] = libvirt_vm.complete_uri(
params.get("migrate_dest_host"))
params["virsh_migrate_connect_uri"] = libvirt_vm.complete_uri(
params.get("migrate_source_host"))
src_uri = params.get("virsh_migrate_connect_uri")
dest_uri = params.get("virsh_migrate_desturi")
vm_name = params.get("migrate_main_vm")
vm = env.get_vm(vm_name)
vm.verify_alive()
bk_uri = vm.connect_uri
postcopy_options = params.get("postcopy_options")
action_during_mig = None
if postcopy_options:
extra = "%s %s" % (extra, postcopy_options)
action_during_mig = virsh.migrate_postcopy
# For safety reasons, we'd better back up xmlfile.
new_xml = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name)
orig_config_xml = new_xml.copy()
try:
# Create a remote runner for later use
runner_on_target = remote.RemoteRunner(host=server_ip,
username=server_user,
password=server_pwd)
remote_session = remote.remote_login("ssh", server_ip, "22",
server_user, server_pwd,
r'[$#%]')
virsh_session_remote = virsh.VirshPersistent(**remote_virsh_dargs)
if target_vm_name:
target_vm = libvirt_vm.VM(target_vm_name, params, vm.root_dir,
vm.address_cache)
target_vm.connect_uri = dest_uri
if not virsh_session_remote.domain_exists(target_vm_name):
test.error("VM %s should be installed on %s."
% (target_vm_name, server_ip))
# Backup guest's xml on remote
target_org_xml = vm_xml.VMXML.new_from_inactive_dumpxml(
target_vm_name, virsh_instance=virsh_session_remote)
# Scp original xml to remote for restoration
remote.scp_to_remote(server_ip, '22', server_user,
server_pwd,
target_org_xml.xml, target_org_xml.xml)
logging.debug("target xml is %s" % target_org_xml)
if ovs_bridge_name:
status, stdout = utils_net.create_ovs_bridge(ovs_bridge_name)
if status:
test.fail("Failed to create ovs bridge on local. Status: %s"
"Stdout: %s" % (status, stdout))
status, stdout = utils_net.create_ovs_bridge(
ovs_bridge_name, session=remote_session)
if status:
test.fail("Failed to create ovs bridge on remote. Status: %s"
"Stdout: %s" % (status, stdout))
if network_dict:
update_net_dict(network_dict, runner=remote_session.cmd)
libvirt_network.create_or_del_network(
network_dict, remote_args=remote_virsh_dargs)
logging.info("dest: network created")
update_net_dict(network_dict)
libvirt_network.create_or_del_network(network_dict)
logging.info("localhost: network created")
if target_vm_name:
if modify_target_vm and iface_dict:
logging.info("Updating remote VM's interface")
update_iface_xml(target_vm_name, iface_dict,
virsh_instance=virsh_session_remote)
target_vm.start()
target_vm_session = target_vm.wait_for_serial_login(timeout=240)
check_vm_network_accessed(ping_dest, session=target_vm_session)
if check_macvtap_exists and macvtap_cmd:
# Get macvtap device's index on remote after target_vm started
idx = remote_session.cmd_output(macvtap_cmd).strip()
if not idx:
test.fail("Unable to get macvtap index using %s."
% macvtap_cmd)
# Generate the expected macvtap devices' index list
exp_macvtap = ['macvtap'+idx, 'macvtap'+str(int(idx)+1)]
if create_fake_tap_dest:
fake_tap_dest = create_fake_tap(remote_session)
remote_session.close()
# Change domain network xml
if iface_dict:
if "mac" not in iface_dict:
mac = utils_net.generate_mac_address_simple()
iface_dict.update({'mac': mac})
else:
mac = iface_dict["mac"]
update_iface_xml(vm_name, iface_dict)
# Change the disk of the vm
libvirt.set_vm_disk(vm, params)
if not vm.is_alive():
try:
vm.start()
except virt_vm.VMStartError as err:
test.fail("Failed to start VM: %s" % err)
logging.debug("Guest xml after starting:\n%s",
vm_xml.VMXML.new_from_dumpxml(vm_name))
# Check local guest network connection before migration
if vm.serial_console is not None:
vm.cleanup_serial_console()
vm.create_serial_console()
vm_session = vm.wait_for_serial_login(timeout=240)
if not utils_package.package_install('dhcp-client', session=vm_session):
test.error("Failed to install dhcp-client on guest.")
utils_net.restart_guest_network(vm_session)
vm_ip = utils_net.get_guest_ip_addr(vm_session, mac)
logging.debug("VM IP Addr: %s", vm_ip)
if direct_mode:
check_vm_network_accessed(ping_dest, session=vm_session)
else:
check_vm_network_accessed(vm_ip)
# Execute migration process
vms = [vm]
migration_test.do_migration(vms, None, dest_uri, 'orderly',
options, thread_timeout=900,
ignore_status=True, virsh_opt=virsh_options,
func=action_during_mig,
extra_opts=extra,
**extra_args)
mig_result = migration_test.ret
# Check network accessibility after migration
if int(mig_result.exit_status) == 0:
vm.connect_uri = dest_uri
if vm.serial_console is not None:
vm.cleanup_serial_console()
vm.create_serial_console()
vm_session_after_mig = vm.wait_for_serial_login(timeout=240)
vm_session_after_mig.cmd(restart_dhclient)
check_vm_network_accessed(ping_dest, session=vm_session_after_mig)
if check_macvtap_exists and macvtap_cmd:
remote_session = remote.remote_login("ssh", server_ip, "22",
server_user, server_pwd,
r'[$#%]')
# Check macvtap devices' index after migration
idx = remote_session.cmd_output(macvtap_cmd)
act_macvtap = ['macvtap'+i for i in idx.strip().split("\n")]
if act_macvtap != exp_macvtap:
test.fail("macvtap devices after migration are incorrect!"
" Actual: %s, Expected: %s. "
% (act_macvtap, exp_macvtap))
else:
if fake_tap_dest:
res = remote.run_remote_cmd("ls /dev/%s" % fake_tap_dest,
params, runner_on_target)
libvirt.check_exit_status(res)
if target_vm_session:
check_vm_network_accessed(ping_dest, session=target_vm_session)
# Execute migration from remote
if migrate_vm_back:
ssh_connection = utils_conn.SSHConnection(server_ip=client_ip,
server_pwd=client_pwd,
client_ip=server_ip,
client_pwd=server_pwd)
try:
ssh_connection.conn_check()
except utils_conn.ConnectionError:
ssh_connection.conn_setup()
ssh_connection.conn_check()
# Pre migration setup for local machine
migration_test.migrate_pre_setup(src_uri, params)
cmd = "virsh migrate %s %s %s" % (vm_name, options, src_uri)
logging.debug("Start migration: %s", cmd)
cmd_result = remote.run_remote_cmd(cmd, params, runner_on_target)
logging.info(cmd_result)
if cmd_result.exit_status:
test.fail("Failed to run '%s' on remote: %s" % (cmd, cmd_result))
logging.debug("VM is migrated back.")
vm.connect_uri = bk_uri
if vm.serial_console is not None:
vm.cleanup_serial_console()
vm.create_serial_console()
vm_session_after_mig_bak = vm.wait_for_serial_login(timeout=240)
vm_session_after_mig_bak.cmd(restart_dhclient)
check_vm_network_accessed(ping_dest, vm_session_after_mig_bak)
finally:
logging.debug("Recover test environment")
vm.connect_uri = bk_uri
migration_test.cleanup_vm(vm, dest_uri)
logging.info("Recovery VM XML configration")
orig_config_xml.sync()
remote_session = remote.remote_login("ssh", server_ip, "22",
server_user, server_pwd,
r'[$#%]')
if target_vm and target_vm.is_alive():
target_vm.destroy(gracefully=False)
if target_org_xml and target_vm_name:
logging.info("Recovery XML configration for %s.", target_vm_name)
virsh_session_remote = virsh.VirshPersistent(**remote_virsh_dargs)
vm_sync(target_org_xml, vm_name=target_vm_name,
virsh_instance=virsh_session_remote)
virsh_session_remote.close_session()
if fake_tap_dest:
remote_session.cmd_output_safe("rm -rf /dev/%s" % fake_tap_dest)
if network_dict:
libvirt_network.create_or_del_network(
network_dict, is_del=True, remote_args=remote_virsh_dargs)
libvirt_network.create_or_del_network(network_dict, is_del=True)
if ovs_bridge_name:
utils_net.delete_ovs_bridge(ovs_bridge_name)
utils_net.delete_ovs_bridge(ovs_bridge_name, session=remote_session)
remote_session.close()
if target_vm_session:
target_vm_session.close()
if virsh_session_remote:
virsh_session_remote.close_session()
if migrate_vm_back:
if 'ssh_connection' in locals():
ssh_connection.auto_recover = True
migration_test.migrate_pre_setup(src_uri, params,
cleanup=True)
logging.info("Remove local NFS image")
source_file = params.get("source_file")
if source_file:
libvirt.delete_local_disk("file", path=source_file)
