def tearDown(self):
'''
unset ip for host interface
'''
for host_interface in self.host_interfaces:
networkinterface = NetworkInterface(host_interface, self.local)
if networkinterface.set_mtu("1500") is not None:
self.cancel("Failed to set mtu in host")
for peer_ip in self.peer_ips:
peer_interface = self.remotehost.get_interface_by_ipaddr(peer_ip).name
try:
peer_networkinterface = NetworkInterface(peer_interface,
self.remotehost)
peer_networkinterface.set_mtu("1500")
except Exception:
peer_public_networkinterface = NetworkInterface(peer_interface,
self.remotehost_public)
peer_public_networkinterface.set_mtu("1500")
for ipaddr, interface in zip(self.ipaddr, self.host_interfaces):
networkinterface = NetworkInterface(interface, self.local)
networkinterface.remove_ipaddr(ipaddr, self.netmask)
try:
networkinterface.restore_from_backup()
except Exception:
self.log.info("backup file not availbale, could not restore file.")
self.remotehost.remote_session.quit()
self.remotehost_public.remote_session.quit()
def test_cleanup(self):
'''
clean up the interface config
'''
self.bond_remove("local")
for val in self.host_interfaces:
cmd = "ifdown %s; ifup %s" % (val, val)
process.system(cmd, shell=True, ignore_status=True)
for _ in range(0, 600, 60):
if 'state UP' in process.system_output(
"ip link \
show %s" % val, shell=True).decode("utf-8"):
self.log.info("Interface %s is up", val)
break
time.sleep(60)
else:
self.log.warn(
"Interface %s in not up\
in the host machine", val)
if self.gateway:
cmd = 'ip route add default via %s' % \
(self.gateway)
process.system(cmd, shell=True, ignore_status=True)
if self.peer_bond_needed:
self.bond_remove("peer")
for val in self.peer_interfaces:
cmd = "ifdown %s; ifup %s; sleep %s"\
% (val, val, self.peer_wait_time)
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.log.warn("unable to bring to original state in peer")
time.sleep(self.sleep_time)
self.error_check()
for host_interface in self.host_interfaces:
networkinterface = NetworkInterface(host_interface, self.localhost)
if networkinterface.set_mtu("1500") is not None:
self.cancel("Failed to set mtu in host")
try:
networkinterface.restore_from_backup()
except Exception:
self.log.info(
"backup file not availbale, could not restore file.")
try:
for interface in self.peer_interfaces:
peer_networkinterface = NetworkInterface(
interface, self.remotehost)
peer_networkinterface.set_mtu("1500")
except Exception:
for interface in self.peer_interfaces:
peer_public_networkinterface = NetworkInterface(
interface, self.remotehost_public)
peer_public_networkinterface.set_mtu("1500")
self.remotehost.remote_session.quit()
self.remotehost_public.remote_session.quit()
def test_cleanup(self):
'''
clean up the interface config
'''
self.bond_remove("local")
if self.gateway:
cmd = 'ip route add default via %s' % \
(self.gateway)
process.system(cmd, shell=True, ignore_status=True)
if self.peer_bond_needed:
self.bond_remove("peer")
for val in self.peer_interfaces:
cmd = "ifdown %s; ifup %s; sleep %s"\
% (val, val, self.peer_wait_time)
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.log.warn("unable to bring to original state in peer")
time.sleep(self.sleep_time)
self.error_check()
for ipaddr, host_interface in zip(self.ipaddr, self.host_interfaces):
networkinterface = NetworkInterface(host_interface, self.localhost)
try:
networkinterface.add_ipaddr(ipaddr, self.netmask)
networkinterface.bring_up()
except Exception:
self.fail("Interface is taking long time to link up")
if networkinterface.set_mtu("1500") is not None:
self.cancel("Failed to set mtu in host")
try:
networkinterface.restore_from_backup()
except Exception:
self.log.info(
"backup file not availbale, could not restore file.")
try:
for interface in self.peer_interfaces:
peer_networkinterface = NetworkInterface(
interface, self.remotehost)
peer_networkinterface.set_mtu("1500")
except Exception:
for interface in self.peer_interfaces:
peer_public_networkinterface = NetworkInterface(
interface, self.remotehost_public)
peer_public_networkinterface.set_mtu("1500")
self.remotehost.remote_session.quit()
self.remotehost_public.remote_session.quit()
def tearDown(self):
'''
unset ip for host interface
'''
for host_interface in self.host_interfaces:
networkinterface = NetworkInterface(host_interface, self.local)
if networkinterface.set_mtu("1500") is not None:
self.cancel("Failed to set mtu in host")
for peer_ip in self.peer_ips:
peer_interface = self.remotehost.get_interface_by_ipaddr(
peer_ip).name
peer_networkinterface = NetworkInterface(peer_interface,
self.remotehost)
if peer_networkinterface.set_mtu("1500") is not None:
self.cancel("Failed to set mtu in peer")
for ipaddr, interface in zip(self.ipaddr, self.host_interfaces):
networkinterface = NetworkInterface(interface, self.local)
networkinterface.remove_ipaddr(ipaddr, self.netmask)
def setUp(self):
'''
To check and install dependencies for the test
'''
self.host_interfaces = self.params.get("host_interfaces",
default="").split(" ")
if not self.host_interfaces:
self.cancel("user should specify host interfaces")
smm = SoftwareManager()
if distro.detect().name == 'Ubuntu':
pkg = 'iputils-ping'
else:
pkg = 'iputils'
if not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel("Package %s is needed to test" % pkg)
self.peer_ips = self.params.get("peer_ips", default="").split(" ")
self.peer_public_ip = self.params.get("peer_public_ip", default="")
interfaces = netifaces.interfaces()
for self.host_interface in self.host_interfaces:
if self.host_interface not in interfaces:
self.cancel("interface is not available")
self.count = self.params.get("count", default="1000")
self.ipaddr = self.params.get("host_ips", default="").split(" ")
self.netmask = self.params.get("netmask", default="")
self.local = LocalHost()
for ipaddr, interface in zip(self.ipaddr, self.host_interfaces):
networkinterface = NetworkInterface(interface, self.local)
try:
networkinterface.add_ipaddr(ipaddr, self.netmask)
networkinterface.save(ipaddr, self.netmask)
except Exception:
networkinterface.save(ipaddr, self.netmask)
networkinterface.bring_up()
self.peer_user = self.params.get("peer_user", default="root")
self.peer_password = self.params.get("peer_password",
'*',
default="None")
self.mtu = self.params.get("mtu", default=1500)
self.remotehost = RemoteHost(self.peer_ips[0],
self.peer_user,
password=self.peer_password)
self.remotehost_public = RemoteHost(self.peer_public_ip,
self.peer_user,
password=self.peer_password)
for peer_ip in self.peer_ips:
peer_interface = self.remotehost.get_interface_by_ipaddr(
peer_ip).name
peer_networkinterface = NetworkInterface(peer_interface,
self.remotehost)
if peer_networkinterface.set_mtu(self.mtu) is not None:
self.cancel("Failed to set mtu in peer")
for host_interface in self.host_interfaces:
self.networkinterface = NetworkInterface(host_interface,
self.local)
if self.networkinterface.set_mtu(self.mtu) is not None:
self.cancel("Failed to set mtu in host")
def bond_fail(self, arg1):
'''
bond fail
'''
if len(self.host_interfaces) > 1:
for interface in self.host_interfaces:
self.log.info("Failing interface %s for mode %s", interface,
arg1)
cmd = "ip link set %s down" % interface
if process.system(cmd, shell=True, ignore_status=True) != 0:
self.fail("bonding not working when trying to down the\
interface %s " % interface)
time.sleep(self.sleep_time)
if self.ping_check():
self.log.info("Ping passed for Mode %s", arg1)
else:
error_str = "Ping fail in Mode %s when interface %s down"\
% (arg1, interface)
self.log.debug(error_str)
self.err.append(error_str)
self.log.info(genio.read_file(self.bond_status))
cmd = "ip link set %s up" % interface
time.sleep(self.sleep_time)
if process.system(cmd, shell=True, ignore_status=True) != 0:
self.fail("Not able to bring up the slave\
interface %s" % interface)
time.sleep(self.sleep_time)
else:
self.log.debug("Need a min of 2 host interfaces to test\
slave failover in Bonding")
self.log.info("\n----------------------------------------")
self.log.info("Failing all interfaces for mode %s", arg1)
self.log.info("----------------------------------------")
for interface in self.host_interfaces:
cmd = "ip link set %s down" % interface
if process.system(cmd, shell=True, ignore_status=True) != 0:
self.fail("Could not bring down the interface %s " % interface)
time.sleep(self.sleep_time)
if not self.ping_check():
self.log.info("Ping to Bond interface failed. This is expected")
self.log.info(genio.read_file(self.bond_status))
for interface in self.host_interfaces:
cmd = "ip link set %s up" % interface
time.sleep(self.sleep_time)
if process.system(cmd, shell=True, ignore_status=True) != 0:
self.fail("Not able to bring up the slave\
interface %s" % interface)
time.sleep(self.sleep_time)
bond_mtu = [
'2000', '3000', '4000', '5000', '6000', '7000', '8000', '9000'
]
if self.is_vnic():
bond_mtu = ['9000']
for mtu in bond_mtu:
self.bond_networkinterface = NetworkInterface(
self.bond_name, self.localhost)
if self.bond_networkinterface.set_mtu(mtu) is not None:
self.cancel("Failed to set mtu in host")
for interface in self.peer_interfaces:
peer_networkinterface = NetworkInterface(
interface, self.remotehost)
if peer_networkinterface.set_mtu(mtu) is not None:
self.cancel("Failed to set mtu in peer")
if self.ping_check():
self.log.info("Ping passed for Mode %s", self.mode, mtu)
else:
error_str = "Ping fail in Mode %s after MTU change to %s"\
% (arg1, mtu)
if self.bond_networkinterface.set_mtu('1500'):
self.cancel("Failed to set mtu back to 1500 in host")
for interface in self.peer_interfaces:
peer_networkinterface = NetworkInterface(
interface, self.remotehost)
if peer_networkinterface.set_mtu('1500') is not None:
self.cancel("Failed to set mtu back to 1500 in peer")
class Uperf(Test):
"""
Uperf Test
"""
def setUp(self):
"""
To check and install dependencies for the test
"""
self.peer_ip = self.params.get("peer_ip", default="")
self.peer_public_ip = self.params.get("peer_public_ip", default="")
self.peer_user = self.params.get("peer_user_name", default="root")
self.peer_password = self.params.get("peer_password", '*',
default="None")
interfaces = netifaces.interfaces()
self.iface = self.params.get("interface", default="")
if self.iface not in interfaces:
self.cancel("%s interface is not available" % self.iface)
self.ipaddr = self.params.get("host_ip", default="")
self.netmask = self.params.get("netmask", default="")
local = LocalHost()
self.networkinterface = NetworkInterface(self.iface, local)
try:
self.networkinterface.add_ipaddr(self.ipaddr, self.netmask)
self.networkinterface.save(self.ipaddr, self.netmask)
except Exception:
self.networkinterface.save(self.ipaddr, self.netmask)
self.networkinterface.bring_up()
self.session = Session(self.peer_ip, user=self.peer_user,
password=self.peer_password)
if not self.session.connect():
self.cancel("failed connecting to peer")
smm = SoftwareManager()
detected_distro = distro.detect()
pkgs = ["gcc", "autoconf", "perl", "m4", "git-core", "automake"]
if detected_distro.name == "Ubuntu":
pkgs.extend(["libsctp1", "libsctp-dev", "lksctp-tools"])
else:
pkgs.extend(["lksctp-tools", "lksctp-tools-devel"])
for pkg in pkgs:
if not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel("%s package is need to test" % pkg)
cmd = "%s install %s" % (smm.backend.base_command, pkg)
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.cancel("unable to install the package %s on peer machine "
% pkg)
if self.peer_ip == "":
self.cancel("%s peer machine is not available" % self.peer_ip)
self.mtu = self.params.get("mtu", default=1500)
self.remotehost = RemoteHost(self.peer_ip, self.peer_user,
password=self.peer_password)
self.peer_interface = self.remotehost.get_interface_by_ipaddr(self.peer_ip).name
self.peer_networkinterface = NetworkInterface(self.peer_interface,
self.remotehost)
self.remotehost_public = RemoteHost(self.peer_public_ip, self.peer_user,
password=self.peer_password)
self.peer_public_networkinterface = NetworkInterface(self.peer_interface,
self.remotehost_public)
if self.peer_networkinterface.set_mtu(self.mtu) is not None:
self.cancel("Failed to set mtu in peer")
if self.networkinterface.set_mtu(self.mtu) is not None:
self.cancel("Failed to set mtu in host")
uperf_download = self.params.get("uperf_download", default="https:"
"//github.com/uperf/uperf/"
"archive/master.zip")
tarball = self.fetch_asset("uperf.zip", locations=[uperf_download],
expire='7d')
archive.extract(tarball, self.teststmpdir)
self.uperf_dir = os.path.join(self.teststmpdir, "uperf-master")
destination = "%s:/tmp" % self.peer_ip
output = self.session.copy_files(self.uperf_dir, destination,
recursive=True)
if not output:
self.cancel("unable to copy the uperf into peer machine")
cmd = "cd /tmp/uperf-master;autoreconf -fi;./configure ppc64le;make"
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.cancel("Unable to compile Uperf into peer machine")
self.uperf_run = str(self.params.get("UPERF_SERVER_RUN", default=0))
if self.uperf_run == '1':
cmd = "/tmp/uperf-master/src/uperf -s &"
cmd = self.session.get_raw_ssh_command(cmd)
self.obj = SubProcess(cmd)
self.obj.start()
os.chdir(self.uperf_dir)
process.system('autoreconf -fi', shell=True)
process.system('./configure ppc64le', shell=True)
build.make(self.uperf_dir)
self.expected_tp = self.params.get("EXPECTED_THROUGHPUT", default="85")
def test(self):
"""
Test run is a One way throughput test. In this test, we have one host
transmitting (or receiving) data from a client. This transmit large
messages using multiple threads or processes.
"""
speed = int(read_file("/sys/class/net/%s/speed" % self.iface))
cmd = "h=%s proto=tcp ./src/uperf -m manual/throughput.xml -a" \
% self.peer_ip
result = process.run(cmd, shell=True, ignore_status=True)
if result.exit_status:
self.fail("FAIL: Uperf Run failed")
for line in result.stdout.decode("utf-8").splitlines():
if self.peer_ip in line:
if 'Mb/s' in line:
tput = int(line.split()[3].split('.')[0])
else:
# Converting the throughput calculated in Gb to Mb
tput = int(line.split()[3].split('.')[0]) * 1000
if tput < (int(self.expected_tp) * speed) / 100:
self.fail("FAIL: Throughput Actual - %s%%, Expected - %s%%"
", Throughput Actual value - %s "
% ((tput*100)/speed, self.expected_tp,
str(tput)+'Mb/sec'))
if 'WARNING' in result.stdout.decode("utf-8"):
self.log.warn('Test completed with warning')
def tearDown(self):
"""
Killing Uperf process in peer machine
"""
self.obj.stop()
cmd = "pkill uperf; rm -rf /tmp/uperf-master"
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.fail("Either the ssh to peer machine machine\
failed or uperf process was not killed")
if self.networkinterface.set_mtu('1500') is not None:
self.cancel("Failed to set mtu in host")
try:
self.peer_networkinterface.set_mtu('1500')
except Exception:
self.peer_public_networkinterface.set_mtu('1500')
self.networkinterface.remove_ipaddr(self.ipaddr, self.netmask)
try:
self.networkinterface.restore_from_backup()
except Exception:
self.log.info("backup file not availbale, could not restore file.")
self.remotehost.remote_session.quit()
self.remotehost_public.remote_session.quit()
self.session.quit()
def test_cleanup(self):
'''
clean up the interface config
'''
self.bond_remove("local")
if self.gateway:
cmd = 'ip route add default via %s' % \
(self.gateway)
process.system(cmd, shell=True, ignore_status=True)
for ipaddr, host_interface in zip(self.ipaddr, self.host_interfaces):
networkinterface = NetworkInterface(host_interface, self.localhost)
try:
networkinterface.flush_ipaddr()
networkinterface.add_ipaddr(ipaddr, self.netmask)
networkinterface.bring_up()
except Exception:
self.fail("Interface is taking long time to link up")
if networkinterface.set_mtu("1500") is not None:
self.cancel("Failed to set mtu in host")
try:
networkinterface.restore_from_backup()
except Exception:
self.log.info(
"backup file not availbale, could not restore file.")
if self.peer_bond_needed:
self.bond_remove("peer")
for ipaddr, interface in zip(self.peer_first_ipinterface,
self.peer_interfaces):
self.remotehost = RemoteHost(self.peer_public_ip,
self.user,
password=self.password)
peer_networkinterface = NetworkInterface(
interface, self.remotehost)
try:
peer_networkinterface.flush_ipaddr()
peer_networkinterface.add_ipaddr(ipaddr, self.netmask)
peer_networkinterface.bring_up()
except Exception:
peer_networkinterface.save(ipaddr, self.netmask)
time.sleep(self.sleep_time)
self.error_check()
detected_distro = distro.detect()
if detected_distro.name == "rhel":
cmd = "systemctl restart NetworkManager.service"
elif detected_distro.name == "Ubuntu":
cmd = "systemctl restart networking"
else:
cmd = "systemctl restart network"
if process.system(cmd, shell=True, ignore_status=True) != 0:
self.fail("Failed to restart the network service on host")
try:
for interface in self.peer_interfaces:
peer_networkinterface = NetworkInterface(
interface, self.remotehost)
peer_networkinterface.set_mtu("1500")
self.remotehost.remote_session.quit()
except Exception:
self.log.debug("Could not revert peer interface MTU to 1500")
def setUp(self):
'''
To check and install dependencies for the test
'''
detected_distro = distro.detect()
smm = SoftwareManager()
depends = []
# FIXME: "redhat" as the distro name for RHEL is deprecated
# on Avocado versions >= 50.0. This is a temporary compatibility
# enabler for older runners, but should be removed soon
if detected_distro.name == "Ubuntu":
depends.extend(["openssh-client", "iputils-ping"])
elif detected_distro.name in ["rhel", "fedora", "centos", "redhat"]:
depends.extend(["openssh-clients", "iputils"])
else:
depends.extend(["openssh", "iputils"])
for pkg in depends:
if not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel("%s package is need to test" % pkg)
self.mode = self.params.get("bonding_mode", default="")
if 'setup' in str(self.name) or 'run' in str(self.name):
if not self.mode:
self.cancel("test skipped because mode not specified")
interfaces = netifaces.interfaces()
self.peer_public_ip = self.params.get("peer_public_ip", default="")
self.user = self.params.get("user_name", default="root")
self.password = self.params.get("peer_password", '*', default="None")
self.host_interfaces = self.params.get("bond_interfaces",
default="").split(" ")
if not self.host_interfaces:
self.cancel("user should specify host interfaces")
self.peer_interfaces = self.params.get("peer_interfaces",
default="").split(" ")
for self.host_interface in self.host_interfaces:
if self.host_interface not in interfaces:
self.cancel("interface is not available")
self.peer_first_ipinterface = self.params.get("peer_ips",
default="").split(" ")
if not self.peer_interfaces or self.peer_first_ipinterface == "":
self.cancel("peer machine should available")
self.ipaddr = self.params.get("host_ips", default="").split(" ")
self.netmask = self.params.get("netmask", default="")
self.peer_bond_needed = self.params.get("peer_bond_needed",
default=False)
self.localhost = LocalHost()
if 'setup' in str(self.name.name):
for ipaddr, interface in zip(self.ipaddr, self.host_interfaces):
networkinterface = NetworkInterface(interface, self.localhost)
try:
networkinterface.flush_ipaddr()
networkinterface.add_ipaddr(ipaddr, self.netmask)
networkinterface.save(ipaddr, self.netmask)
except Exception:
networkinterface.save(ipaddr, self.netmask)
networkinterface.bring_up()
for ipaddr, interface in zip(self.peer_first_ipinterface,
self.peer_interfaces):
if self.peer_bond_needed:
self.remotehost = RemoteHost(self.peer_public_ip,
self.user,
password=self.password)
peer_networkinterface = NetworkInterface(
interface, self.remotehost)
try:
peer_networkinterface.flush_ipaddr()
peer_networkinterface.add_ipaddr(ipaddr, self.netmask)
peer_networkinterface.save(ipaddr, self.netmask)
except Exception:
peer_networkinterface.save(ipaddr, self.netmask)
networkinterface.bring_up()
self.miimon = self.params.get("miimon", default="100")
self.fail_over_mac = self.params.get("fail_over_mac", default="2")
self.downdelay = self.params.get("downdelay", default="0")
self.bond_name = self.params.get("bond_name", default="tempbond")
self.net_path = "/sys/class/net/"
self.bond_status = "/proc/net/bonding/%s" % self.bond_name
self.bond_dir = os.path.join(self.net_path, self.bond_name)
self.bonding_slave_file = "%s/bonding/slaves" % self.bond_dir
self.bonding_masters_file = "%s/bonding_masters" % self.net_path
self.peer_bond_needed = self.params.get("peer_bond_needed",
default=False)
self.peer_wait_time = self.params.get("peer_wait_time", default=20)
self.sleep_time = int(self.params.get("sleep_time", default=10))
self.peer_wait_time = self.params.get("peer_wait_time", default=5)
self.sleep_time = int(self.params.get("sleep_time", default=5))
self.mtu = self.params.get("mtu", default=1500)
for root, dirct, files in os.walk("/root/.ssh"):
for file in files:
if file.startswith("avocado-master-"):
path = os.path.join(root, file)
os.remove(path)
self.ib = False
if self.host_interface[0:2] == 'ib':
self.ib = True
self.log.info("Bond Test on IB Interface? = %s", self.ib)
'''
An individual interface, that has a LACP PF, cannot communicate without
being bonded. So the test uses the public ip address to create an SSH
session instead of the private one when setting up a bonding interface.
'''
if self.mode == "4" and "setup" in str(self.name.name):
self.session = Session(self.peer_public_ip,
user=self.user,
password=self.password)
else:
self.session = Session(self.peer_first_ipinterface[0],
user=self.user,
password=self.password)
if not self.session.connect():
'''
LACP bond interface takes some time to get it to ping peer after it
is setup. This code block tries at most 5 times to get it to connect
to the peer.
'''
if self.mode == "4":
connect = False
for _ in range(5):
if self.session.connect():
connect = True
self.log.info("Was able to connect to peer.")
break
time.sleep(5)
if not connect:
self.cancel("failed connecting to peer")
else:
self.cancel("failed connecting to peer")
self.setup_ip()
self.err = []
if self.mode == "4" and "setup" in str(self.name.name):
self.remotehost = RemoteHost(self.peer_public_ip,
self.user,
password=self.password)
else:
self.remotehost = RemoteHost(self.peer_first_ipinterface[0],
self.user,
password=self.password)
if 'setup' in str(self.name.name):
for interface in self.peer_interfaces:
peer_networkinterface = NetworkInterface(
interface, self.remotehost)
if peer_networkinterface.set_mtu(self.mtu) is not None:
self.cancel("Failed to set mtu in peer")
for host_interface in self.host_interfaces:
self.networkinterface = NetworkInterface(
host_interface, self.localhost)
if self.networkinterface.set_mtu(self.mtu) is not None:
self.cancel("Failed to set mtu in host")
class TcpdumpTest(Test):
"""
Test the tcpdump for specified interface.
"""
def setUp(self):
"""
Set up.
"""
self.iface = self.params.get("interface", default="")
self.count = self.params.get("count", default="500")
self.peer_ip = self.params.get("peer_ip", default="")
self.peer_public_ip = self.params.get("peer_public_ip", default="")
self.drop = self.params.get("drop_accepted", default="10")
self.host_ip = self.params.get("host_ip", default="")
self.option = self.params.get("option", default='')
# Check if interface exists in the system
interfaces = netifaces.interfaces()
if self.iface not in interfaces:
self.cancel("%s interface is not available" % self.iface)
if not self.peer_ip:
self.cancel("peer ip should specify in input")
self.ipaddr = self.params.get("host_ip", default="")
self.netmask = self.params.get("netmask", default="")
localhost = LocalHost()
self.networkinterface = NetworkInterface(self.iface, localhost)
try:
self.networkinterface.add_ipaddr(self.ipaddr, self.netmask)
self.networkinterface.save(self.ipaddr, self.netmask)
except Exception:
self.networkinterface.save(self.ipaddr, self.netmask)
self.networkinterface.bring_up()
if not wait.wait_for(self.networkinterface.is_link_up, timeout=120):
self.cancel(
"Link up of interface is taking longer than 120 seconds")
self.peer_user = self.params.get("peer_user", default="root")
self.peer_password = self.params.get("peer_password",
'*',
default="None")
self.timeout = self.params.get("TIMEOUT", default="600")
self.mtu = self.params.get("mtu", default=1500)
self.mtu_timeout = self.params.get("mtu_timeout", default=30)
self.remotehost = RemoteHost(self.peer_ip,
self.peer_user,
password=self.peer_password)
self.peer_interface = self.remotehost.get_interface_by_ipaddr(
self.peer_ip).name
self.peer_networkinterface = NetworkInterface(self.peer_interface,
self.remotehost)
self.remotehost_public = RemoteHost(self.peer_public_ip,
self.peer_user,
password=self.peer_password)
self.peer_public_networkinterface = NetworkInterface(
self.peer_interface, self.remotehost_public)
if self.peer_networkinterface.set_mtu(
self.mtu, timeout=self.mtu_timeout) is not None:
self.cancel("Failed to set mtu in peer")
if self.networkinterface.set_mtu(self.mtu,
timeout=self.mtu_timeout) is not None:
self.cancel("Failed to set mtu in host")
# Install needed packages
smm = SoftwareManager()
detected_distro = distro.detect()
pkgs = ['tcpdump', 'flex', 'bison', 'gcc', 'gcc-c++', 'nmap']
for pkg in pkgs:
if not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel("%s package Can not install" % pkg)
if detected_distro.name == "SuSE":
self.nmap = os.path.join(self.teststmpdir, 'nmap')
nmap_download = self.params.get("nmap_download",
default="https:"
"//nmap.org/dist/"
"nmap-7.80.tar.bz2")
tarball = self.fetch_asset(nmap_download)
self.version = os.path.basename(tarball.split('.tar')[0])
self.n_map = os.path.join(self.nmap, self.version)
archive.extract(tarball, self.nmap)
os.chdir(self.n_map)
process.system('./configure ppc64le', shell=True)
build.make(self.n_map)
process.system('./nping/nping -h', shell=True)
def test(self):
"""
Performs the tcpdump test.
"""
cmd = "ping -I %s %s -c %s" % (self.iface, self.peer_ip, self.count)
output_file = os.path.join(self.outputdir, 'tcpdump')
if self.option in ('tcp', 'udp', 'icmp'):
obj = self.nping(self.option)
obj.start()
else:
obj = process.SubProcess(cmd, verbose=False, shell=True)
obj.start()
cmd = "timeout %s tcpdump -i %s -n -c %s" % (self.timeout, self.iface,
self.count)
if self.option in ('host', 'src'):
cmd = "%s %s %s" % (cmd, self.option, self.host_ip)
elif self.option == "dst":
cmd = "%s %s %s" % (cmd, self.option, self.peer_ip)
else:
cmd = "%s %s" % (cmd, self.option)
cmd = "%s -w '%s'" % (cmd, output_file)
for line in process.run(cmd, shell=True,
ignore_status=True).stderr.decode("utf-8") \
.splitlines():
if "packets dropped by kernel" in line:
self.log.info(line)
if int(line[0]) >= (int(self.drop) * int(self.count) / 100):
self.fail("%s, more than %s percent" % (line, self.drop))
obj.stop()
def nping(self, param):
"""
perform nping
"""
nping_count = round((120 * int(self.count)) / 100)
detected_distro = distro.detect()
if detected_distro.name == "SuSE":
cmd = "./nping/nping --%s %s -c %s" % (param, self.peer_ip,
nping_count)
return process.SubProcess(cmd, verbose=False, shell=True)
else:
cmd = "nping --%s %s -c %s" % (param, self.peer_ip, nping_count)
return process.SubProcess(cmd, verbose=False, shell=True)
def tearDown(self):
'''
unset ip for host interface
'''
if self.networkinterface.set_mtu('1500',
timeout=self.mtu_timeout) is not None:
self.cancel("Failed to set mtu in host")
try:
self.peer_networkinterface.set_mtu('1500',
timeout=self.mtu_timeout)
except Exception:
self.peer_public_networkinterface.set_mtu('1500',
timeout=self.mtu_timeout)
self.networkinterface.remove_ipaddr(self.ipaddr, self.netmask)
try:
self.networkinterface.restore_from_backup()
except Exception:
self.log.info("backup file not availbale, could not restore file.")
self.remotehost.remote_session.quit()
self.remotehost_public.remote_session.quit()
class PingPong(Test):
'''
ibv_ud_pingpong test
ibv_ud_pingpong tool should be installed
'''
def setUp(self):
'''
To check and install dependencies for the test
'''
interfaces = netifaces.interfaces()
self.flag = self.params.get("ext_flag", default="0")
self.iface = self.params.get("interface", default="")
self.peer_ip = self.params.get("peer_ip", default="")
self.peer_user = self.params.get("peer_user_name", default="root")
self.peer_password = self.params.get("peer_password", '*',
default="None")
self.ipaddr = self.params.get("host_ip", default="")
self.netmask = self.params.get("netmask", default="")
local = LocalHost()
if self.iface[0:2] == 'ib':
self.networkinterface = NetworkInterface(self.iface, local,
if_type='Infiniband')
try:
self.networkinterface.add_ipaddr(self.ipaddr, self.netmask)
self.networkinterface.save(self.ipaddr, self.netmask)
except Exception:
self.networkinterface.save(self.ipaddr, self.netmask)
else:
self.networkinterface = NetworkInterface(self.iface, local)
try:
self.networkinterface.add_ipaddr(self.ipaddr, self.netmask)
self.networkinterface.save(self.ipaddr, self.netmask)
except Exception:
self.networkinterface.save(self.ipaddr, self.netmask)
self.networkinterface.bring_up()
self.session = Session(self.peer_ip, user=self.peer_user,
password=self.peer_password)
if self.iface not in interfaces:
self.cancel("%s interface is not available" % self.iface)
if self.peer_ip == "":
self.cancel("%s peer machine is not available" % self.peer_ip)
self.ca_name = self.params.get("CA_NAME", default="mlx4_0")
self.gid = int(self.params.get("GID_NUM", default="0"))
self.port = int(self.params.get("PORT_NUM", default="1"))
self.peer_ca = self.params.get("PEERCA", default="mlx4_0")
self.peer_gid = int(self.params.get("PEERGID", default="0"))
self.peer_port = int(self.params.get("PEERPORT", default="1"))
self.tmo = self.params.get("TIMEOUT", default="120")
self.mtu = self.params.get("mtu", default=1500)
self.remotehost = RemoteHost(self.peer_ip, self.peer_user,
password=self.peer_password)
self.peer_interface = self.remotehost.get_interface_by_ipaddr(self.peer_ip).name
self.peer_networkinterface = NetworkInterface(self.peer_interface,
self.remotehost)
smm = SoftwareManager()
detected_distro = distro.detect()
pkgs = []
if detected_distro.name == "Ubuntu":
pkgs.extend(["ibverbs-utils", 'openssh-client'])
cmd = "service ufw stop"
# FIXME: "redhat" as the distro name for RHEL is deprecated
# on Avocado versions >= 50.0. This is a temporary compatibility
# enabler for older runners, but should be removed soon
elif detected_distro.name in ['rhel', 'fedora', 'redhat']:
pkgs.extend(["libibverbs", 'openssh-clients'])
cmd = "systemctl stop firewalld"
elif detected_distro.name == "SuSE":
pkgs.append('openssh')
if detected_distro.version == 15:
cmd = "systemctl stop firewalld"
else:
cmd = "rcSuSEfirewall2 stop"
elif detected_distro.name == "centos":
pkgs.extend(['libibverbs', 'openssh-clients'])
cmd = "service iptables stop"
else:
self.cancel("Distro not supported")
if process.system(cmd, ignore_status=True, shell=True) != 0:
self.cancel("Unable to disable firewall")
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.cancel("Unable to disable firewall on peer")
for pkg in pkgs:
if not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel("%s package is need to test" % pkg)
if process.system("ibstat", shell=True, ignore_status=True) != 0:
self.cancel("infiniband adaptors not available")
self.tool_name = self.params.get("tool")
self.log.info("test with %s", self.tool_name)
self.peer_iface = ''
cmd = "ip addr show"
output = self.session.cmd(cmd)
for line in output.stdout.decode("utf-8").splitlines():
if self.peer_ip in line:
self.peer_iface = line.split()[-1]
break
def pingpong_exec(self, arg1, arg2, arg3):
'''
ping pong exec function
'''
test = arg2
logs = "> /tmp/ib_log 2>&1 &"
if test == "basic":
test = ""
cmd = "timeout %s %s -d %s -g %d -i %d %s %s %s" \
% (self.tmo, arg1, self.peer_ca, self.peer_gid, self.peer_port,
test, arg3, logs)
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.fail("ssh failed to remote machine")
time.sleep(2)
self.log.info("client data for %s(%s)", arg1, arg2)
self.log.info("%s -d %s -g %d %s -i %d %s %s", arg1, self.ca_name,
self.gid, self.peer_ip, self.port, test, arg3)
tmp = "timeout %s %s -d %s -g %d -i %d %s %s %s" \
% (self.tmo, arg1, self.ca_name, self.gid, self.port, self.peer_ip,
test, arg3)
if process.system(tmp, shell=True, ignore_status=True) != 0:
self.fail("test failed")
self.log.info("server data for %s(%s)", arg1, arg2)
self.log.info("%s -d %s -g %d -i %d %s %s", arg1, self.peer_ca,
self.peer_gid, self.peer_port, test, arg3)
cmd = "timeout %s cat /tmp/ib_log && rm -rf /tmp/ib_log" \
% self.tmo
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.fail("test failed")
def test_ib_pingpong(self):
'''
test options are mandatory
ext test options are depends upon user
'''
# change MTU to 9000 for non-IB tests
if "ib" not in self.iface and self.tool_name == "ibv_ud_pingpong":
self.mtu = "9000"
if self.peer_networkinterface.set_mtu(self.mtu) is not None:
self.fail("Failed to set mtu in peer")
if self.networkinterface.set_mtu(self.mtu) is not None:
self.fail("Failed to set mtu in host")
time.sleep(10)
val1 = ""
val2 = ""
test_op = self.params.get("test_opt", default="").split(",")
for val in test_op:
try:
val1, val2 = val.split()
except ValueError:
pass
self.pingpong_exec(self.tool_name, val1, val2)
ext_test_op = self.params.get("ext_test_opt", default="").split(",")
if self.flag == "1":
for val in ext_test_op:
self.pingpong_exec(self.tool_name, val, "")
else:
self.log.info("Extended test option skipped")
def tearDown(self):
if self.networkinterface.set_mtu('1500') is not None:
self.fail("Failed to set mtu in host")
if self.peer_networkinterface.set_mtu('1500') is not None:
self.fail("Failed to set mtu in peer")
self.remotehost.remote_session.quit()
class Iperf(Test):
"""
Iperf Test
"""
def setUp(self):
"""
To check and install dependencies for the test
"""
self.peer_user = self.params.get("peer_user", default="root")
self.peer_ip = self.params.get("peer_ip", default="")
self.peer_public_ip = self.params.get("peer_public_ip", default="")
self.peer_password = self.params.get("peer_password",
'*',
default=None)
interfaces = netifaces.interfaces()
self.iface = self.params.get("interface", default="")
if self.iface not in interfaces:
self.cancel("%s interface is not available" % self.iface)
self.ipaddr = self.params.get("host_ip", default="")
self.netmask = self.params.get("netmask", default="")
self.hbond = self.params.get("hbond", default=False)
localhost = LocalHost()
if self.hbond:
self.networkinterface = NetworkInterface(self.iface,
localhost,
if_type='Bond')
else:
self.networkinterface = NetworkInterface(self.iface, localhost)
try:
self.networkinterface.add_ipaddr(self.ipaddr, self.netmask)
self.networkinterface.save(self.ipaddr, self.netmask)
except Exception:
self.networkinterface.save(self.ipaddr, self.netmask)
self.networkinterface.bring_up()
self.session = Session(self.peer_ip,
user=self.peer_user,
password=self.peer_password)
if not self.session.connect():
self.cancel("failed connecting to peer")
smm = SoftwareManager()
for pkg in ["gcc", "autoconf", "perl", "m4", "libtool", "gcc-c++"]:
if not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel("%s package is need to test" % pkg)
cmd = "%s install %s" % (smm.backend.base_command, pkg)
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.cancel(
"unable to install the package %s on peer machine " % pkg)
detected_distro = distro.detect()
pkg = "nmap"
if detected_distro.name == 'rhel':
if not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel("%s package Can not install" % pkg)
if detected_distro.name == "SuSE":
self.nmap = os.path.join(self.teststmpdir, 'nmap')
nmap_download = self.params.get("nmap_download",
default="https:"
"//nmap.org/dist/"
"nmap-7.80.tar.bz2")
tarball = self.fetch_asset(nmap_download)
self.version = os.path.basename(tarball.split('.tar')[0])
self.n_map = os.path.join(self.nmap, self.version)
archive.extract(tarball, self.nmap)
os.chdir(self.n_map)
process.system('./configure ppc64le', shell=True)
build.make(self.n_map)
process.system('./nping/nping -h', shell=True)
if self.peer_ip == "":
self.cancel("%s peer machine is not available" % self.peer_ip)
self.mtu = self.params.get("mtu", default=1500)
self.remotehost = RemoteHost(self.peer_ip,
self.peer_user,
password=self.peer_password)
self.peer_interface = self.remotehost.get_interface_by_ipaddr(
self.peer_ip).name
self.peer_networkinterface = NetworkInterface(self.peer_interface,
self.remotehost)
self.remotehost_public = RemoteHost(self.peer_public_ip,
self.peer_user,
password=self.peer_password)
self.peer_public_networkinterface = NetworkInterface(
self.peer_interface, self.remotehost_public)
if self.peer_networkinterface.set_mtu(self.mtu) is not None:
self.cancel("Failed to set mtu in peer")
if self.networkinterface.set_mtu(self.mtu) is not None:
self.cancel("Failed to set mtu in host")
self.iperf = os.path.join(self.teststmpdir, 'iperf')
iperf_download = self.params.get("iperf_download",
default="https:"
"//sourceforge.net/projects/iperf2/"
"files/iperf-2.0.13.tar.gz")
tarball = self.fetch_asset(iperf_download, expire='7d')
archive.extract(tarball, self.iperf)
self.version = os.path.basename(tarball.split('.tar')[0])
self.iperf_dir = os.path.join(self.iperf, self.version)
destination = "%s:/tmp" % self.peer_ip
output = self.session.copy_files(self.iperf_dir,
destination,
recursive=True)
if not output:
self.cancel("unable to copy the iperf into peer machine")
cmd = "cd /tmp/%s;./configure ppc64le;make" % self.version
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.cancel("Unable to compile Iperf into peer machine")
self.iperf_run = str(self.params.get("IPERF_SERVER_RUN", default=0))
if self.iperf_run == '1':
cmd = "/tmp/%s/src/iperf -s" % self.version
cmd = self.session.get_raw_ssh_command(cmd)
self.obj = SubProcess(cmd)
self.obj.start()
os.chdir(self.iperf_dir)
process.system('./configure', shell=True)
build.make(self.iperf_dir)
self.iperf = os.path.join(self.iperf_dir, 'src')
self.expected_tp = self.params.get("EXPECTED_THROUGHPUT", default="85")
def nping(self):
"""
Run nping test with tcp packets
"""
detected_distro = distro.detect()
if detected_distro.name == "SuSE":
os.chdir(self.n_map)
cmd = "./nping/nping --tcp %s -c 10" % self.peer_ip
return process.run(cmd, verbose=False, shell=True)
else:
cmd = "nping --tcp %s -c 10" % self.peer_ip
return process.run(cmd, verbose=False, shell=True)
def test(self):
"""
Test run is a One way throughput test. In this test, we have one host
transmitting (or receiving) data from a client. This transmit large
messages using multiple threads or processes.
"""
speed = int(read_file("/sys/class/net/%s/speed" % self.iface))
os.chdir(self.iperf)
cmd = "./iperf -c %s" % self.peer_ip
result = process.run(cmd, shell=True, ignore_status=True)
nping_result = self.nping()
if result.exit_status:
self.fail("FAIL: Iperf Run failed")
for line in result.stdout.decode("utf-8").splitlines():
if 'local {}'.format(self.ipaddr) in line:
id = line[3]
for line in result.stdout.decode("utf-8").splitlines():
if id in line and 'Mbits/sec' in line:
tput = int(line.split()[6])
elif id in line and 'Gbits/sec' in line:
tput = int(float(line.split()[6])) * 1000
if tput < (int(self.expected_tp) * speed) / 100:
self.fail(
"FAIL: Throughput Actual - %s%%, Expected - %s%%"
", Throughput Actual value - %s " %
((tput * 100) / speed, self.expected_tp, str(tput) + 'Mb/sec'))
for line in nping_result.stdout.decode("utf-8").splitlines():
if 'Raw packets' in line:
lost = int(line.split("|")[2].split(" ")[2]) * 10
if lost > 60:
self.fail("FAIL: Ping fails after iperf test")
def tearDown(self):
"""
Killing Iperf process in peer machine
"""
cmd = "pkill iperf; rm -rf /tmp/%s" % self.version
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.fail("Either the ssh to peer machine machine\
failed or iperf process was not killed")
self.obj.stop()
if self.networkinterface.set_mtu('1500') is not None:
self.cancel("Failed to set mtu in host")
try:
self.peer_networkinterface.set_mtu('1500')
except Exception:
self.peer_public_networkinterface.set_mtu('1500')
self.networkinterface.remove_ipaddr(self.ipaddr, self.netmask)
try:
self.networkinterface.restore_from_backup()
except Exception:
self.networkinterface.remove_cfg_file()
self.log.info("backup file not availbale, could not restore file.")
if self.hbond:
self.networkinterface.restore_slave_cfg_file()
self.remotehost.remote_session.quit()
self.remotehost_public.remote_session.quit()
self.session.quit()
class Iperf(Test):
"""
Iperf Test
"""
def setUp(self):
"""
To check and install dependencies for the test
"""
self.peer_user = self.params.get("peer_user_name", default="root")
self.peer_ip = self.params.get("peer_ip", default="")
self.peer_password = self.params.get("peer_password",
'*',
default=None)
interfaces = netifaces.interfaces()
self.iface = self.params.get("interface", default="")
if self.iface not in interfaces:
self.cancel("%s interface is not available" % self.iface)
self.ipaddr = self.params.get("host_ip", default="")
self.netmask = self.params.get("netmask", default="")
localhost = LocalHost()
self.networkinterface = NetworkInterface(self.iface, localhost)
try:
self.networkinterface.add_ipaddr(self.ipaddr, self.netmask)
self.networkinterface.save(self.ipaddr, self.netmask)
except Exception:
self.networkinterface.save(self.ipaddr, self.netmask)
self.networkinterface.bring_up()
self.session = Session(self.peer_ip,
user=self.peer_user,
password=self.peer_password)
smm = SoftwareManager()
for pkg in ["gcc", "autoconf", "perl", "m4", "libtool"]:
if not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel("%s package is need to test" % pkg)
cmd = "%s install %s" % (smm.backend.base_command, pkg)
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.cancel(
"unable to install the package %s on peer machine " % pkg)
if self.peer_ip == "":
self.cancel("%s peer machine is not available" % self.peer_ip)
self.mtu = self.params.get("mtu", default=1500)
remotehost = RemoteHost(self.peer_ip,
self.peer_user,
password=self.peer_password)
self.peer_interface = remotehost.get_interface_by_ipaddr(
self.peer_ip).name
self.peer_networkinterface = NetworkInterface(self.peer_interface,
remotehost)
if self.peer_networkinterface.set_mtu(self.mtu) is not None:
self.cancel("Failed to set mtu in peer")
if self.networkinterface.set_mtu(self.mtu) is not None:
self.cancel("Failed to set mtu in host")
self.iperf = os.path.join(self.teststmpdir, 'iperf')
iperf_download = self.params.get("iperf_download",
default="https:"
"//excellmedia.dl.sourceforge.net/"
"project/iperf2/iperf-2.0.13.tar.gz")
tarball = self.fetch_asset(iperf_download, expire='7d')
archive.extract(tarball, self.iperf)
self.version = os.path.basename(tarball.split('.tar')[0])
self.iperf_dir = os.path.join(self.iperf, self.version)
cmd = "scp -r %s %s@%s:/tmp" % (self.iperf_dir, self.peer_user,
self.peer_ip)
if process.system(cmd, shell=True, ignore_status=True) != 0:
self.cancel("unable to copy the iperf into peer machine")
cmd = "cd /tmp/%s;./configure ppc64le;make" % self.version
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.cancel("Unable to compile Iperf into peer machine")
self.iperf_run = str(self.params.get("IPERF_SERVER_RUN", default=0))
if self.iperf_run == '1':
cmd = "/tmp/%s/src/iperf -s" % self.version
cmd = self.session.get_raw_ssh_command(cmd)
self.obj = SubProcess(cmd)
self.obj.start()
os.chdir(self.iperf_dir)
process.system('./configure', shell=True)
build.make(self.iperf_dir)
self.iperf = os.path.join(self.iperf_dir, 'src')
self.expected_tp = self.params.get("EXPECTED_THROUGHPUT", default="85")
def test(self):
"""
Test run is a One way throughput test. In this test, we have one host
transmitting (or receiving) data from a client. This transmit large
messages using multiple threads or processes.
"""
speed = int(read_file("/sys/class/net/%s/speed" % self.iface))
os.chdir(self.iperf)
cmd = "./iperf -c %s" % self.peer_ip
result = process.run(cmd, shell=True, ignore_status=True)
if result.exit_status:
self.fail("FAIL: Iperf Run failed")
for line in result.stdout.decode("utf-8").splitlines():
if 'sender' in line:
tput = int(line.split()[6].split('.')[0])
if tput < (int(self.expected_tp) * speed) / 100:
self.fail("FAIL: Throughput Actual - %s%%, Expected - %s%%"
", Throughput Actual value - %s " %
((tput * 100) / speed, self.expected_tp,
str(tput) + 'Mb/sec'))
def tearDown(self):
"""
Killing Iperf process in peer machine
"""
cmd = "pkill iperf; rm -rf /tmp/%s" % self.version
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.fail("Either the ssh to peer machine machine\
failed or iperf process was not killed")
self.obj.stop()
if self.networkinterface.set_mtu('1500') is not None:
self.cancel("Failed to set mtu in host")
if self.peer_networkinterface.set_mtu('1500') is not None:
self.cancel("Failed to set mtu in peer")
self.networkinterface.remove_ipaddr(self.ipaddr, self.netmask)
class Netperf(Test):
"""
Netperf Test
"""
def setUp(self):
"""
To check and install dependencies for the test
"""
self.peer_user = self.params.get("peer_user_name", default="root")
self.peer_ip = self.params.get("peer_ip", default="")
self.peer_password = self.params.get("peer_password",
'*',
default="None")
interfaces = netifaces.interfaces()
self.iface = self.params.get("interface", default="")
if self.iface not in interfaces:
self.cancel("%s interface is not available" % self.iface)
self.ipaddr = self.params.get("host_ip", default="")
self.netmask = self.params.get("netmask", default="")
local = LocalHost()
self.networkinterface = NetworkInterface(self.iface, local)
try:
self.networkinterface.add_ipaddr(self.ipaddr, self.netmask)
self.networkinterface.save(self.ipaddr, self.netmask)
except Exception:
self.networkinterface.save(self.ipaddr, self.netmask)
self.networkinterface.bring_up()
self.session = Session(self.peer_ip,
user=self.peer_user,
password=self.peer_password)
smm = SoftwareManager()
detected_distro = distro.detect()
pkgs = ['gcc']
if detected_distro.name == "Ubuntu":
pkgs.append('openssh-client')
elif detected_distro.name == "SuSE":
pkgs.append('openssh')
else:
pkgs.append('openssh-clients')
for pkg in pkgs:
if not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel("%s package is need to test" % pkg)
cmd = "%s install %s" % (smm.backend.base_command, pkg)
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.cancel(
"unable to install the package %s on peer machine " % pkg)
if self.peer_ip == "":
self.cancel("%s peer machine is not available" % self.peer_ip)
self.timeout = self.params.get("TIMEOUT", default="600")
self.mtu = self.params.get("mtu", default=1500)
remotehost = RemoteHost(self.peer_ip,
username=self.peer_user,
password=self.peer_password)
self.peer_interface = remotehost.get_interface_by_ipaddr(
self.peer_ip).name
self.peer_networkinterface = NetworkInterface(self.peer_interface,
remotehost)
if self.peer_networkinterface.set_mtu(self.mtu) is not None:
self.cancel("Failed to set mtu in peer")
if self.networkinterface.set_mtu(self.mtu) is not None:
self.cancel("Failed to set mtu in host")
self.netperf_run = str(self.params.get("NETSERVER_RUN", default=0))
self.netperf = os.path.join(self.teststmpdir, 'netperf')
netperf_download = self.params.get("netperf_download",
default="https:"
"//github.com/HewlettPackard/"
"netperf/archive/netperf-2.7.0.zip")
tarball = self.fetch_asset(netperf_download, expire='7d')
archive.extract(tarball, self.netperf)
self.version = "%s-%s" % ("netperf",
os.path.basename(tarball.split('.zip')[0]))
self.neperf = os.path.join(self.netperf, self.version)
cmd = "scp -r %s %s@%s:/tmp/" % (self.neperf, self.peer_user,
self.peer_ip)
if process.system(cmd, shell=True, ignore_status=True) != 0:
self.cancel("unable to copy the netperf into peer machine")
cmd = "cd /tmp/%s;./configure ppc64le;make" % self.version
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.fail("test failed because command failed in peer machine")
os.chdir(self.neperf)
process.system('./configure ppc64le', shell=True)
build.make(self.neperf)
self.perf = os.path.join(self.neperf, 'src', 'netperf')
self.expected_tp = self.params.get("EXPECTED_THROUGHPUT", default="90")
self.duration = self.params.get("duration", default="300")
self.min = self.params.get("minimum_iterations", default="1")
self.max = self.params.get("maximum_iterations", default="15")
self.option = self.params.get("option", default='')
def test(self):
"""
netperf test
"""
if self.netperf_run == '1':
cmd = "chmod 777 /tmp/%s/src" % self.version
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.fail("test failed because netserver not available")
cmd = "/tmp/%s/src/netserver" % self.version
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.fail("test failed because netserver not available")
speed = int(read_file("/sys/class/net/%s/speed" % self.iface))
cmd = "timeout %s %s -H %s" % (self.timeout, self.perf, self.peer_ip)
if self.option != "":
cmd = "%s -t %s" % (cmd, self.option)
cmd = "%s -l %s -i %s,%s" % (cmd, self.duration, self.max, self.min)
result = process.run(cmd, shell=True, ignore_status=True)
if result.exit_status != 0:
self.fail("FAIL: Run failed")
for line in result.stdout.decode("utf-8").splitlines():
if line and 'Throughput' in line.split()[-1]:
tput = int(
result.stdout.decode("utf-8").split()[-1].split('.')[0])
if tput < (int(self.expected_tp) * speed) / 100:
self.fail("FAIL: Throughput Actual - %s%%, Expected - %s%%"
", Throughput Actual value - %s " %
((tput * 100) / speed, self.expected_tp,
str(tput) + 'Mb/sec'))
if 'WARNING' in result.stdout.decode("utf-8"):
self.log.warn('Test completed with warning')
def tearDown(self):
"""
removing the data in peer machine
"""
cmd = "pkill netserver; rm -rf /tmp/%s" % self.version
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.fail("test failed because peer sys not connected")
if self.networkinterface.set_mtu('1500') is not None:
self.cancel("Failed to set mtu in host")
if self.peer_networkinterface.set_mtu('1500') is not None:
self.cancel("Failed to set mtu in peer")
self.networkinterface.remove_ipaddr(self.ipaddr, self.netmask)
class Bonding(Test):
'''
Channel bonding enables two or more network interfaces to act as one,
simultaneously increasing the bandwidth and providing redundancy.
'''
def setUp(self):
'''
To check and install dependencies for the test
'''
detected_distro = distro.detect()
smm = SoftwareManager()
depends = []
# FIXME: "redhat" as the distro name for RHEL is deprecated
# on Avocado versions >= 50.0. This is a temporary compatibility
# enabler for older runners, but should be removed soon
if detected_distro.name == "Ubuntu":
depends.extend(["openssh-client", "iputils-ping"])
elif detected_distro.name in ["rhel", "fedora", "centos", "redhat"]:
depends.extend(["openssh-clients", "iputils"])
else:
depends.extend(["openssh", "iputils"])
for pkg in depends:
if not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel("%s package is need to test" % pkg)
self.mode = self.params.get("bonding_mode", default="")
if 'setup' in str(self.name) or 'run' in str(self.name):
if not self.mode:
self.cancel("test skipped because mode not specified")
interfaces = netifaces.interfaces()
self.peer_public_ip = self.params.get("peer_public_ip", default="")
self.user = self.params.get("user_name", default="root")
self.password = self.params.get("peer_password", '*', default="None")
self.host_interfaces = self.params.get("bond_interfaces",
default="").split(" ")
if not self.host_interfaces:
self.cancel("user should specify host interfaces")
self.peer_interfaces = self.params.get("peer_interfaces",
default="").split(" ")
for self.host_interface in self.host_interfaces:
if self.host_interface not in interfaces:
self.cancel("interface is not available")
self.peer_first_ipinterface = self.params.get("peer_ip", default="")
if not self.peer_interfaces or self.peer_first_ipinterface == "":
self.cancel("peer machine should available")
self.ipaddr = self.params.get("host_ips", default="").split(" ")
self.netmask = self.params.get("netmask", default="")
self.localhost = LocalHost()
if 'setup' in str(self.name.name):
for ipaddr, interface in zip(self.ipaddr, self.host_interfaces):
networkinterface = NetworkInterface(interface, self.localhost)
try:
networkinterface.add_ipaddr(ipaddr, self.netmask)
networkinterface.save(ipaddr, self.netmask)
except Exception:
networkinterface.save(ipaddr, self.netmask)
networkinterface.bring_up()
self.miimon = self.params.get("miimon", default="100")
self.fail_over_mac = self.params.get("fail_over_mac", default="2")
self.downdelay = self.params.get("downdelay", default="0")
self.bond_name = self.params.get("bond_name", default="tempbond")
self.net_path = "/sys/class/net/"
self.bond_status = "/proc/net/bonding/%s" % self.bond_name
self.bond_dir = os.path.join(self.net_path, self.bond_name)
self.bonding_slave_file = "%s/bonding/slaves" % self.bond_dir
self.bonding_masters_file = "%s/bonding_masters" % self.net_path
self.peer_bond_needed = self.params.get("peer_bond_needed",
default=False)
self.peer_wait_time = self.params.get("peer_wait_time", default=5)
self.sleep_time = int(self.params.get("sleep_time", default=5))
self.mtu = self.params.get("mtu", default=1500)
self.ib = False
if self.host_interface[0:2] == 'ib':
self.ib = True
self.log.info("Bond Test on IB Interface? = %s", self.ib)
self.session = Session(self.peer_first_ipinterface,
user=self.user,
password=self.password)
if not self.session.connect():
self.cancel("failed connecting to peer")
self.setup_ip()
self.err = []
self.remotehost = RemoteHost(self.peer_first_ipinterface,
self.user,
password=self.password)
self.remotehost_public = RemoteHost(self.peer_public_ip,
self.user,
password=self.password)
if 'setup' in str(self.name.name):
for interface in self.peer_interfaces:
peer_networkinterface = NetworkInterface(
interface, self.remotehost)
if peer_networkinterface.set_mtu(self.mtu) is not None:
self.cancel("Failed to set mtu in peer")
for host_interface in self.host_interfaces:
self.networkinterface = NetworkInterface(
host_interface, self.localhost)
if self.networkinterface.set_mtu(self.mtu) is not None:
self.cancel("Failed to set mtu in host")
def bond_ib_conf(self, bond_name, arg1, arg2):
'''
configure slaves for IB cards
'''
cmd = 'ip link set %s up;' % (bond_name)
if process.system(cmd, shell=True, ignore_status=True) != 0:
self.fail("unable to bring Bond interface %s up" % bond_name)
if arg2 == "ATTACH":
cmd = 'ifenslave %s %s -f;' % (bond_name, arg1)
else:
cmd = 'ifenslave %s -d %s ;' % (bond_name, arg1)
if process.system(cmd, shell=True, ignore_status=True) != 0:
self.fail("unable to %s IB interface " % arg2)
def setup_ip(self):
'''
set up the IP config
'''
if 'setup' in str(self.name):
interface = self.host_interfaces[0]
else:
interface = self.bond_name
cmd = "ip addr show | grep %s" % self.peer_first_ipinterface
output = self.session.cmd(cmd)
result = ""
result = result.join(output.stdout.decode("utf-8"))
self.peer_first_interface = result.split()[-1]
if self.peer_first_interface == "":
self.fail("test failed because peer interface can not retrieved")
self.peer_ips = [self.peer_first_ipinterface]
self.local_ip = netifaces.ifaddresses(interface)[2][0]['addr']
self.net_mask = []
stf = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
for val1, val2 in zip([interface], [self.local_ip]):
mask = ""
if val2:
tmp = fcntl.ioctl(stf.fileno(), 0x891b,
struct.pack('256s', val1.encode()))
mask = socket.inet_ntoa(tmp[20:24]).strip('\n')
self.net_mask.append(mask)
cmd = "route -n | grep %s | grep -w UG | awk "\
"'{ print $2 }'" % interface
self.gateway = process.system_output('%s' % cmd, shell=True)
def bond_remove(self, arg1):
'''
bond_remove
'''
if arg1 == "local":
self.log.info("Removing Bonding configuration on local machine")
self.log.info("------------------------------------------------")
for ifs in self.host_interfaces:
cmd = "ip link set %s down" % ifs
if process.system(cmd, shell=True, ignore_status=True) != 0:
self.log.info("unable to bring down the interface")
if self.ib:
self.bond_ib_conf(self.bond_name, ifs, "REMOVE")
else:
genio.write_file(self.bonding_slave_file, "-%s" % ifs)
genio.write_file(self.bonding_masters_file, "-%s" % self.bond_name)
self.log.info("Removing bonding module")
linux_modules.unload_module("bonding")
time.sleep(self.sleep_time)
else:
self.log.info("Removing Bonding configuration on Peer machine")
self.log.info("------------------------------------------------")
cmd = ''
cmd += 'ip link set %s down;' % self.bond_name
for val in self.peer_interfaces:
cmd += 'ip link set %s down;' % val
for val in self.peer_interfaces:
cmd += 'ip addr flush dev %s;' % val
for val in self.peer_interfaces:
if self.ib:
self.bond_ib_conf(self.bond_name, val, "REMOVE")
else:
cmd += 'echo "-%s" > %s;' % (val, self.bonding_slave_file)
cmd += 'echo "-%s" > %s;' % (self.bond_name,
self.bonding_masters_file)
cmd += 'rmmod bonding;'
cmd += 'ip addr add %s/%s dev %s;ip link set %s up;sleep 5;'\
% (self.peer_first_ipinterface, self.net_mask[0],
self.peer_interfaces[0], self.peer_interfaces[0])
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.log.info("bond removing command failed in peer machine")
def ping_check(self):
'''
ping check
'''
# need some time for specific interface before ping
time.sleep(10)
cmd = "ping -I %s %s -c 5"\
% (self.bond_name, self.peer_first_ipinterface)
if process.system(cmd, shell=True, ignore_status=True) != 0:
return False
return True
def is_vnic(self):
'''
check if slave interface is vnic
'''
for interface in self.host_interfaces:
cmd = "lsdevinfo -q name=%s" % interface
if 'type="IBM,vnic"' in process.system_output(
cmd, shell=True).decode("utf-8"):
return True
return False
def bond_fail(self, arg1):
'''
bond fail
'''
if len(self.host_interfaces) > 1:
for interface in self.host_interfaces:
self.log.info("Failing interface %s for mode %s", interface,
arg1)
cmd = "ip link set %s down" % interface
if process.system(cmd, shell=True, ignore_status=True) != 0:
self.fail("bonding not working when trying to down the\
interface %s " % interface)
time.sleep(self.sleep_time)
if self.ping_check():
self.log.info("Ping passed for Mode %s", arg1)
else:
error_str = "Ping fail in Mode %s when interface %s down"\
% (arg1, interface)
self.log.debug(error_str)
self.err.append(error_str)
self.log.info(genio.read_file(self.bond_status))
cmd = "ip link set %s up" % interface
time.sleep(self.sleep_time)
if process.system(cmd, shell=True, ignore_status=True) != 0:
self.fail("Not able to bring up the slave\
interface %s" % interface)
time.sleep(self.sleep_time)
else:
self.log.debug("Need a min of 2 host interfaces to test\
slave failover in Bonding")
self.log.info("\n----------------------------------------")
self.log.info("Failing all interfaces for mode %s", arg1)
self.log.info("----------------------------------------")
for interface in self.host_interfaces:
cmd = "ip link set %s down" % interface
if process.system(cmd, shell=True, ignore_status=True) != 0:
self.fail("Could not bring down the interface %s " % interface)
time.sleep(self.sleep_time)
if not self.ping_check():
self.log.info("Ping to Bond interface failed. This is expected")
self.log.info(genio.read_file(self.bond_status))
for interface in self.host_interfaces:
cmd = "ip link set %s up" % interface
time.sleep(self.sleep_time)
if process.system(cmd, shell=True, ignore_status=True) != 0:
self.fail("Not able to bring up the slave\
interface %s" % interface)
time.sleep(self.sleep_time)
bond_mtu = [
'2000', '3000', '4000', '5000', '6000', '7000', '8000', '9000'
]
if self.is_vnic():
bond_mtu = ['9000']
for mtu in bond_mtu:
self.bond_networkinterface = NetworkInterface(
self.bond_name, self.localhost)
if self.bond_networkinterface.set_mtu(mtu) is not None:
self.cancel("Failed to set mtu in host")
for interface in self.peer_interfaces:
peer_networkinterface = NetworkInterface(
interface, self.remotehost)
if peer_networkinterface.set_mtu(mtu) is not None:
self.cancel("Failed to set mtu in peer")
if self.ping_check():
self.log.info("Ping passed for Mode %s", self.mode, mtu)
else:
error_str = "Ping fail in Mode %s after MTU change to %s"\
% (arg1, mtu)
if self.bond_networkinterface.set_mtu('1500'):
self.cancel("Failed to set mtu back to 1500 in host")
for interface in self.peer_interfaces:
peer_networkinterface = NetworkInterface(
interface, self.remotehost)
if peer_networkinterface.set_mtu('1500') is not None:
self.cancel("Failed to set mtu back to 1500 in peer")
def bond_setup(self, arg1, arg2):
'''
bond setup
'''
if arg1 == "local":
self.log.info("Configuring Bonding on Local machine")
self.log.info("--------------------------------------")
for ifs in self.host_interfaces:
cmd = "ip addr flush dev %s" % ifs
process.system(cmd, shell=True, ignore_status=True)
for ifs in self.host_interfaces:
cmd = "ip link set %s down" % ifs
process.system(cmd, shell=True, ignore_status=True)
linux_modules.load_module("bonding")
genio.write_file(self.bonding_masters_file, "+%s" % self.bond_name)
genio.write_file("%s/bonding/mode" % self.bond_dir, arg2)
genio.write_file("%s/bonding/miimon" % self.bond_dir, self.miimon)
genio.write_file("%s/bonding/fail_over_mac" % self.bond_dir,
self.fail_over_mac)
genio.write_file("%s/bonding/downdelay" % self.bond_dir,
self.downdelay)
dict = {
'0': ['packets_per_slave', 'resend_igmp'],
'1':
['num_unsol_na', 'primary', 'primary_reselect', 'resend_igmp'],
'2': ['xmit_hash_policy'],
'4': ['lacp_rate', 'xmit_hash_policy'],
'5': [
'tlb_dynamic_lb', 'primary', 'primary_reselect',
'resend_igmp', 'xmit_hash_policy', 'lp_interval'
],
'6':
['primary', 'primary_reselect', 'resend_igmp', 'lp_interval']
}
if self.mode in dict.keys():
for param in dict[self.mode]:
param_value = self.params.get(param, default='')
if param_value:
genio.write_file(
"%s/bonding/%s" % (self.bond_dir, param),
param_value)
for val in self.host_interfaces:
if self.ib:
self.bond_ib_conf(self.bond_name, val, "ATTACH")
else:
genio.write_file(self.bonding_slave_file, "+%s" % val)
time.sleep(2)
bond_name_val = ''
for line in genio.read_file(self.bond_status).splitlines():
if 'Bonding Mode' in line:
bond_name_val = line.split(':')[1]
self.log.info("Trying bond mode %s [ %s ]", arg2, bond_name_val)
for ifs in self.host_interfaces:
cmd = "ip link set %s up" % ifs
if process.system(cmd, shell=True, ignore_status=True) != 0:
self.fail("unable to interface up")
cmd = "ip addr add %s/%s dev %s;ip link set %s up"\
% (self.local_ip, self.net_mask[0],
self.bond_name, self.bond_name)
process.system(cmd, shell=True, ignore_status=True)
for _ in range(0, 600, 60):
if 'state UP' in process.system_output(
"ip link \
show %s" % self.bond_name,
shell=True).decode("utf-8"):
self.log.info("Bonding setup is successful on\
local machine")
break
time.sleep(60)
else:
self.fail("Bonding setup on local machine has failed")
if self.gateway:
cmd = 'ip route add default via %s dev %s' % \
(self.gateway, self.bond_name)
process.system(cmd, shell=True, ignore_status=True)
else:
self.log.info("Configuring Bonding on Peer machine")
self.log.info("------------------------------------------")
cmd = ''
for val in self.peer_interfaces:
cmd += 'ip addr flush dev %s;' % val
for val in self.peer_interfaces:
cmd += 'ip link set %s down;' % val
cmd += 'modprobe bonding;'
cmd += 'echo +%s > %s;'\
% (self.bond_name, self.bonding_masters_file)
cmd += 'echo 0 > %s/bonding/mode;'\
% self.bond_dir
cmd += 'echo 100 > %s/bonding/miimon;'\
% self.bond_dir
cmd += 'echo 2 > %s/bonding/fail_over_mac;'\
% self.bond_dir
for val in self.peer_interfaces:
if self.ib:
self.bond_ib_conf(self.bond_name, val, "ATTACH")
else:
cmd += 'echo "+%s" > %s;' % (val, self.bonding_slave_file)
for val in self.peer_interfaces:
cmd += 'ip link set %s up;' % val
cmd += 'ip addr add %s/%s dev %s;ip link set %s up;sleep 5;'\
% (self.peer_first_ipinterface, self.net_mask[0],
self.bond_name, self.bond_name)
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.fail("bond setup command failed in peer machine")
def test_setup(self):
'''
bonding the interfaces
work for multiple interfaces on both host and peer
'''
cmd = "[ -d %s ]" % self.bond_dir
output = self.session.cmd(cmd)
if output.exit_status == 0:
self.fail("bond name already exists on peer machine")
if os.path.isdir(self.bond_dir):
self.fail("bond name already exists on local machine")
if self.peer_bond_needed:
self.bond_setup("peer", "")
self.bond_setup("local", self.mode)
self.log.info(genio.read_file(self.bond_status))
self.ping_check()
self.error_check()
def test_run(self):
self.bond_fail(self.mode)
self.log.info("Mode %s OK", self.mode)
self.error_check()
# need few sec for interface to not lost the connection to peer
time.sleep(5)
def test_cleanup(self):
'''
clean up the interface config
'''
self.bond_remove("local")
if self.gateway:
cmd = 'ip route add default via %s' % \
(self.gateway)
process.system(cmd, shell=True, ignore_status=True)
if self.peer_bond_needed:
self.bond_remove("peer")
for val in self.peer_interfaces:
cmd = "ifdown %s; ifup %s; sleep %s"\
% (val, val, self.peer_wait_time)
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.log.warn("unable to bring to original state in peer")
time.sleep(self.sleep_time)
self.error_check()
for ipaddr, host_interface in zip(self.ipaddr, self.host_interfaces):
networkinterface = NetworkInterface(host_interface, self.localhost)
try:
networkinterface.add_ipaddr(ipaddr, self.netmask)
networkinterface.bring_up()
except Exception:
self.fail("Interface is taking long time to link up")
if networkinterface.set_mtu("1500") is not None:
self.cancel("Failed to set mtu in host")
try:
networkinterface.restore_from_backup()
except Exception:
self.log.info(
"backup file not availbale, could not restore file.")
try:
for interface in self.peer_interfaces:
peer_networkinterface = NetworkInterface(
interface, self.remotehost)
peer_networkinterface.set_mtu("1500")
except Exception:
for interface in self.peer_interfaces:
peer_public_networkinterface = NetworkInterface(
interface, self.remotehost_public)
peer_public_networkinterface.set_mtu("1500")
self.remotehost.remote_session.quit()
self.remotehost_public.remote_session.quit()
def error_check(self):
if self.err:
self.fail("Tests failed. Details:\n%s" % "\n".join(self.err))
def tearDown(self):
self.session.quit()
def setUp(self):
'''
To check and install dependencies for the test
'''
detected_distro = distro.detect()
smm = SoftwareManager()
depends = []
# FIXME: "redhat" as the distro name for RHEL is deprecated
# on Avocado versions >= 50.0. This is a temporary compatibility
# enabler for older runners, but should be removed soon
if detected_distro.name == "Ubuntu":
depends.extend(["openssh-client", "iputils-ping"])
elif detected_distro.name in ["rhel", "fedora", "centos", "redhat"]:
depends.extend(["openssh-clients", "iputils"])
else:
depends.extend(["openssh", "iputils"])
for pkg in depends:
if not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel("%s package is need to test" % pkg)
self.mode = self.params.get("bonding_mode", default="")
if 'setup' in str(self.name) or 'run' in str(self.name):
if not self.mode:
self.cancel("test skipped because mode not specified")
interfaces = netifaces.interfaces()
self.peer_public_ip = self.params.get("peer_public_ip", default="")
self.user = self.params.get("user_name", default="root")
self.password = self.params.get("peer_password", '*', default="None")
self.host_interfaces = self.params.get("bond_interfaces",
default="").split(" ")
if not self.host_interfaces:
self.cancel("user should specify host interfaces")
self.peer_interfaces = self.params.get("peer_interfaces",
default="").split(" ")
for self.host_interface in self.host_interfaces:
if self.host_interface not in interfaces:
self.cancel("interface is not available")
self.peer_first_ipinterface = self.params.get("peer_ip", default="")
if not self.peer_interfaces or self.peer_first_ipinterface == "":
self.cancel("peer machine should available")
self.ipaddr = self.params.get("host_ips", default="").split(" ")
self.netmask = self.params.get("netmask", default="")
self.localhost = LocalHost()
if 'setup' in str(self.name.name):
for ipaddr, interface in zip(self.ipaddr, self.host_interfaces):
networkinterface = NetworkInterface(interface, self.localhost)
try:
networkinterface.add_ipaddr(ipaddr, self.netmask)
networkinterface.save(ipaddr, self.netmask)
except Exception:
networkinterface.save(ipaddr, self.netmask)
networkinterface.bring_up()
self.miimon = self.params.get("miimon", default="100")
self.fail_over_mac = self.params.get("fail_over_mac", default="2")
self.downdelay = self.params.get("downdelay", default="0")
self.bond_name = self.params.get("bond_name", default="tempbond")
self.net_path = "/sys/class/net/"
self.bond_status = "/proc/net/bonding/%s" % self.bond_name
self.bond_dir = os.path.join(self.net_path, self.bond_name)
self.bonding_slave_file = "%s/bonding/slaves" % self.bond_dir
self.bonding_masters_file = "%s/bonding_masters" % self.net_path
self.peer_bond_needed = self.params.get("peer_bond_needed",
default=False)
self.peer_wait_time = self.params.get("peer_wait_time", default=5)
self.sleep_time = int(self.params.get("sleep_time", default=5))
self.mtu = self.params.get("mtu", default=1500)
self.ib = False
if self.host_interface[0:2] == 'ib':
self.ib = True
self.log.info("Bond Test on IB Interface? = %s", self.ib)
self.session = Session(self.peer_first_ipinterface,
user=self.user,
password=self.password)
if not self.session.connect():
self.cancel("failed connecting to peer")
self.setup_ip()
self.err = []
self.remotehost = RemoteHost(self.peer_first_ipinterface,
self.user,
password=self.password)
self.remotehost_public = RemoteHost(self.peer_public_ip,
self.user,
password=self.password)
if 'setup' in str(self.name.name):
for interface in self.peer_interfaces:
peer_networkinterface = NetworkInterface(
interface, self.remotehost)
if peer_networkinterface.set_mtu(self.mtu) is not None:
self.cancel("Failed to set mtu in peer")
for host_interface in self.host_interfaces:
self.networkinterface = NetworkInterface(
host_interface, self.localhost)
if self.networkinterface.set_mtu(self.mtu) is not None:
self.cancel("Failed to set mtu in host")
class MultiportStress(Test):
'''
To perform IO stress on multiple ports on a NIC adapter
'''
def setUp(self):
'''
To check and install dependencies for the test
'''
self.host_interfaces = self.params.get("host_interfaces",
default="").split(" ")
if not self.host_interfaces:
self.cancel("user should specify host interfaces")
smm = SoftwareManager()
if distro.detect().name == 'Ubuntu':
pkg = 'iputils-ping'
else:
pkg = 'iputils'
if not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel("Package %s is needed to test" % pkg)
self.peer_ips = self.params.get("peer_ips",
default="").split(" ")
self.peer_public_ip = self.params.get("peer_public_ip", default="")
interfaces = netifaces.interfaces()
for self.host_interface in self.host_interfaces:
if self.host_interface not in interfaces:
self.cancel("interface is not available")
self.count = self.params.get("count", default="1000")
self.ipaddr = self.params.get("host_ips", default="").split(" ")
self.netmask = self.params.get("netmask", default="")
self.local = LocalHost()
for ipaddr, interface in zip(self.ipaddr, self.host_interfaces):
networkinterface = NetworkInterface(interface, self.local)
try:
networkinterface.add_ipaddr(ipaddr, self.netmask)
networkinterface.save(ipaddr, self.netmask)
except Exception:
networkinterface.save(ipaddr, self.netmask)
networkinterface.bring_up()
self.peer_user = self.params.get("peer_user", default="root")
self.peer_password = self.params.get("peer_password", '*',
default="None")
self.mtu = self.params.get("mtu", default=1500)
self.remotehost = RemoteHost(self.peer_ips[0], self.peer_user,
password=self.peer_password)
self.remotehost_public = RemoteHost(self.peer_public_ip,
self.peer_user,
password=self.peer_password)
for peer_ip in self.peer_ips:
peer_interface = self.remotehost.get_interface_by_ipaddr(peer_ip).name
peer_networkinterface = NetworkInterface(peer_interface,
self.remotehost)
if peer_networkinterface.set_mtu(self.mtu) is not None:
self.cancel("Failed to set mtu in peer")
for host_interface in self.host_interfaces:
self.networkinterface = NetworkInterface(host_interface, self.local)
if self.networkinterface.set_mtu(self.mtu) is not None:
self.cancel("Failed to set mtu in host")
def multiport_ping(self, ping_option):
'''
Ping to multiple peers parallely
'''
parallel_procs = []
for host, peer in zip(self.host_interfaces, self.peer_ips):
self.log.info('Starting Ping test')
cmd = "ping -I %s %s -c %s %s" % (host, peer, self.count,
ping_option)
obj = process.SubProcess(cmd, verbose=False, shell=True)
obj.start()
parallel_procs.append(obj)
self.log.info('Wait for background processes to finish'
' before proceeding')
for proc in parallel_procs:
proc.wait()
errors = []
for proc in parallel_procs:
out_buf = proc.get_stdout()
out_buf += proc.get_stderr()
for val in out_buf.decode("utf-8").splitlines():
if 'packet loss' in val and ', 0% packet loss,' not in val:
errors.append(out_buf)
break
if errors:
self.fail(b"\n".join(errors))
def test_multiport_ping(self):
self.multiport_ping('')
def test_multiport_floodping(self):
self.multiport_ping('-f')
def tearDown(self):
'''
unset ip for host interface
'''
for host_interface in self.host_interfaces:
networkinterface = NetworkInterface(host_interface, self.local)
if networkinterface.set_mtu("1500") is not None:
self.cancel("Failed to set mtu in host")
for peer_ip in self.peer_ips:
peer_interface = self.remotehost.get_interface_by_ipaddr(peer_ip).name
try:
peer_networkinterface = NetworkInterface(peer_interface,
self.remotehost)
peer_networkinterface.set_mtu("1500")
except Exception:
peer_public_networkinterface = NetworkInterface(peer_interface,
self.remotehost_public)
peer_public_networkinterface.set_mtu("1500")
for ipaddr, interface in zip(self.ipaddr, self.host_interfaces):
networkinterface = NetworkInterface(interface, self.local)
networkinterface.remove_ipaddr(ipaddr, self.netmask)
try:
networkinterface.restore_from_backup()
except Exception:
self.log.info("backup file not availbale, could not restore file.")
self.remotehost.remote_session.quit()
self.remotehost_public.remote_session.quit()
class NetworkTest(Test):
'''
To test different types of pings
'''
def setUp(self):
'''
To check and install dependencies for the test
'''
smm = SoftwareManager()
pkgs = ["ethtool", "net-tools"]
detected_distro = distro.detect()
if detected_distro.name == "Ubuntu":
pkgs.extend(["openssh-client", "iputils-ping"])
elif detected_distro.name == "SuSE":
pkgs.extend(["openssh", "iputils"])
else:
pkgs.extend(["openssh-clients", "iputils"])
for pkg in pkgs:
if not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel("%s package is need to test" % pkg)
interfaces = netifaces.interfaces()
interface = self.params.get("interface")
if interface not in interfaces:
self.cancel("%s interface is not available" % interface)
self.iface = interface
self.ipaddr = self.params.get("host_ip", default="")
self.netmask = self.params.get("netmask", default="")
self.ip_config = self.params.get("ip_config", default=True)
local = LocalHost()
self.networkinterface = NetworkInterface(self.iface, local)
if self.ip_config:
try:
self.networkinterface.add_ipaddr(self.ipaddr, self.netmask)
self.networkinterface.save(self.ipaddr, self.netmask)
except Exception:
self.networkinterface.save(self.ipaddr, self.netmask)
self.networkinterface.bring_up()
if not wait.wait_for(self.networkinterface.is_link_up, timeout=120):
self.fail("Link up of interface is taking longer than 120 seconds")
self.peer = self.params.get("peer_ip")
if not self.peer:
self.cancel("No peer provided")
self.mtu = self.params.get("mtu", default=1500)
self.peer_public_ip = self.params.get("peer_public_ip", default="")
self.peer_user = self.params.get("peer_user", default="root")
self.peer_password = self.params.get("peer_password",
'*',
default=None)
if 'scp' or 'ssh' in str(self.name.name):
self.session = Session(self.peer,
user=self.peer_user,
password=self.peer_password)
if not self.session.connect():
self.cancel("failed connecting to peer")
self.remotehost = RemoteHost(self.peer,
self.peer_user,
password=self.peer_password)
self.peer_interface = self.remotehost.get_interface_by_ipaddr(
self.peer).name
self.peer_networkinterface = NetworkInterface(self.peer_interface,
self.remotehost)
self.remotehost_public = RemoteHost(self.peer_public_ip,
self.peer_user,
password=self.peer_password)
self.peer_public_networkinterface = NetworkInterface(
self.peer_interface, self.remotehost_public)
self.mtu = self.params.get("mtu", default=1500)
self.mtu_set()
if self.networkinterface.ping_check(self.peer, count=5) is not None:
self.cancel("No connection to peer")
def mtu_set(self):
'''
set mtu size
'''
if self.peer_networkinterface.set_mtu(self.mtu) is not None:
self.cancel("Failed to set mtu in peer")
if self.networkinterface.set_mtu(self.mtu) is not None:
self.cancel("Failed to set mtu in host")
def test_gro(self):
'''
Test GRO
'''
ro_type = "gro"
ro_type_full = "generic-receive-offload"
if not self.offload_state(ro_type_full):
self.fail("Could not get state of %s" % ro_type)
if self.offload_state(ro_type_full) == 'fixed':
self.fail("Can not change the state of %s" % ro_type)
self.offload_toggle_test(ro_type, ro_type_full)
def test_gso(self):
'''
Test GSO
'''
ro_type = "gso"
ro_type_full = "generic-segmentation-offload"
if not self.offload_state(ro_type_full):
self.fail("Could not get state of %s" % ro_type)
if self.offload_state(ro_type_full) == 'fixed':
self.fail("Can not change the state of %s" % ro_type)
self.offload_toggle_test(ro_type, ro_type_full)
def test_lro(self):
'''
Test LRO
'''
ro_type = "lro"
ro_type_full = "large-receive-offload"
path = '/sys/class/net/%s/device/uevent' % self.iface
if os.path.exists(path):
output = open(path, 'r').read()
for line in output.splitlines():
if "OF_NAME" in line:
if 'vnic' in line.split('=')[-1]:
self.cancel("Unsupported on vNIC")
if not self.offload_state(ro_type_full):
self.fail("Could not get state of %s" % ro_type)
if self.offload_state(ro_type_full) == 'fixed':
self.fail("Can not change the state of %s" % ro_type)
self.offload_toggle_test(ro_type, ro_type_full)
def test_tso(self):
'''
Test TSO
'''
ro_type = "tso"
ro_type_full = "tcp-segmentation-offload"
if not self.offload_state(ro_type_full):
self.fail("Could not get state of %s" % ro_type)
if self.offload_state(ro_type_full) == 'fixed':
self.fail("Can not change the state of %s" % ro_type)
self.offload_toggle_test(ro_type, ro_type_full)
def test_ping(self):
'''
ping to peer machine
'''
if self.networkinterface.ping_check(self.peer, count=10) is not None:
self.fail("ping test failed")
def test_floodping(self):
'''
Flood ping to peer machine
'''
if self.networkinterface.ping_check(self.peer,
count=500000,
options='-f') is not None:
self.fail("flood ping test failed")
def test_ssh(self):
'''
Test ssh
'''
cmd = "echo hi"
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.fail("unable to ssh into peer machine")
def test_scp(self):
'''
Test scp
'''
process.run("dd if=/dev/zero of=/tmp/tempfile bs=1024000000 count=1",
shell=True)
md_val1 = hashlib.md5(open('/tmp/tempfile', 'rb').read()).hexdigest()
destination = "%s:/tmp" % self.peer
output = self.session.copy_files('/tmp/tempfile', destination)
if not output:
self.fail("unable to copy into peer machine")
source = "%s:/tmp/tempfile" % self.peer
output = self.session.copy_files(source, '/tmp')
if not output:
self.fail("unable to copy from peer machine")
md_val2 = hashlib.md5(open('/tmp/tempfile', 'rb').read()).hexdigest()
if md_val1 != md_val2:
self.fail("Test Failed")
def test_jumbo_frame(self):
'''
Test jumbo frames
'''
if self.networkinterface.ping_check(self.peer,
count=30,
options='-i 0.1 -s %d' %
(int(self.mtu) - 28)) is not None:
self.fail("jumbo frame test failed")
def test_statistics(self):
'''
Test Statistics
'''
rx_file = "/sys/class/net/%s/statistics/rx_packets" % self.iface
tx_file = "/sys/class/net/%s/statistics/tx_packets" % self.iface
rx_before = genio.read_file(rx_file)
tx_before = genio.read_file(tx_file)
self.networkinterface.ping_check(self.peer, count=500000, options='-f')
rx_after = genio.read_file(rx_file)
tx_after = genio.read_file(tx_file)
if (rx_after <= rx_before) or (tx_after <= tx_before):
self.log.debug("Before\nrx: %s tx: %s" % (rx_before, tx_before))
self.log.debug("After\nrx: %s tx: %s" % (rx_after, tx_after))
self.fail("Statistics not incremented properly")
def mtu_set_back(self):
'''
Test set mtu back to 1500
'''
try:
self.peer_networkinterface.set_mtu('1500')
except Exception:
self.peer_public_networkinterface.set_mtu('1500')
if self.networkinterface.set_mtu('1500') is not None:
self.cancel("Failed to set mtu in host")
def offload_toggle_test(self, ro_type, ro_type_full):
'''
Check to toggle the LRO / GRO / GSO / TSO
'''
for state in ["off", "on"]:
if not self.offload_state_change(ro_type, ro_type_full, state):
self.fail("%s %s failed" % (ro_type, state))
if self.networkinterface.ping_check(self.peer,
count=500000,
options='-f') is not None:
self.fail("ping failed in %s %s" % (ro_type, state))
def offload_state_change(self, ro_type, ro_type_full, state):
'''
Change the state of LRO / GRO / GSO / TSO to specified state
'''
cmd = "ethtool -K %s %s %s" % (self.iface, ro_type, state)
if process.system(cmd, shell=True, ignore_status=True) != 0:
return False
if self.offload_state(ro_type_full) != state:
return False
return True
def offload_state(self, ro_type_full):
'''
Return the state of LRO / GRO / GSO / TSO.
If the state can not be changed, we return 'fixed'.
If any other error, we return ''.
'''
cmd = "ethtool -k %s" % self.iface
output = process.system_output(cmd, shell=True,
ignore_status=True).decode("utf-8")
for line in output.splitlines():
if ro_type_full in line:
if 'fixed' in line.split()[-1]:
return 'fixed'
return line.split()[-1]
return ''
def test_promisc(self):
'''
promisc mode testing
'''
cmd = "ip link set %s promisc on" % self.iface
if process.system(cmd, shell=True, ignore_status=True) != 0:
self.fail("failed to enable promisc mode")
self.networkinterface.ping_check(self.peer, count=100000, options='-f')
cmd = "ip link set %s promisc off" % self.iface
if process.system(cmd, shell=True, ignore_status=True) != 0:
self.fail("failed to disable promisc mode")
self.networkinterface.ping_check(self.peer, count=5)
def tearDown(self):
'''
Remove the files created
'''
self.mtu_set_back()
if 'scp' in str(self.name.name):
process.run("rm -rf /tmp/tempfile")
cmd = "rm -rf /tmp/tempfile"
self.session.cmd(cmd)
if self.ip_config:
self.networkinterface.remove_ipaddr(self.ipaddr, self.netmask)
try:
self.networkinterface.restore_from_backup()
except Exception:
self.log.info(
"backup file not availbale, could not restore file.")
self.remotehost.remote_session.quit()
self.remotehost_public.remote_session.quit()
if 'scp' or 'ssh' in str(self.name.name):
self.session.quit()
def run(test, params, env):
"""
Expose host MTU to guest test
1) Boot up guest with param 'host_mtu=4000' in nic part
2) Disable NetworkManager in guest
3) set mtu of guest tap (eg: tap0) and physical nic (eg: eno1) to
4000 in host
4) check the mtu in guest
5) ping from guest to external host with packet size 3972
:param test: kvm test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment
"""
def cleanup_ovs_ports(netdst, ports):
"""
Clean up created ovs ports in this case
:param netdst: netdst get from command line
:param ports: existing ports need to be remain before this test
"""
host_bridge = utils_net.find_bridge_manager(netdst)
if utils_net.ovs_br_exists(netdst) is True:
ports = set(host_bridge.list_ports(netdst)) - set(ports)
for p in ports:
utils_net.find_bridge_manager(netdst).del_port(netdst, p)
netdst = params.get("netdst", "switch")
mtu_value = params.get_numeric("mtu_value")
host_bridge = utils_net.find_bridge_manager(netdst)
localhost = LocalHost()
try:
if netdst in utils_net.Bridge().list_br():
host_hw_interface = utils_net.Bridge().list_iface(netdst)[0]
else:
host_hw_interface = host_bridge.list_ports(netdst)
tmp_ports = re.findall(r"t[0-9]{1,}-[a-zA-Z0-9]{6}",
' '.join(host_hw_interface))
if tmp_ports:
for p in tmp_ports:
host_bridge.del_port(netdst, p)
host_hw_interface = host_bridge.list_ports(netdst)
except IndexError:
host_hw_interface = netdst
params["start_vm"] = "yes"
env_process.preprocess_vm(test, params, env, params["main_vm"])
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
vm_iface = vm.get_ifname()
# Get host interface original mtu value before setting
if netdst in utils_net.Bridge().list_br():
host_hw_iface = NetworkInterface(host_hw_interface, localhost)
elif utils_net.ovs_br_exists(netdst) is True:
host_hw_iface = NetworkInterface(' '.join(host_hw_interface),
localhost)
host_mtu_origin = host_hw_iface.get_mtu()
set_mtu_host(vm_iface, mtu_value)
host_hw_iface.set_mtu(mtu_value)
os_type = params.get("os_type", "linux")
login_timeout = float(params.get("login_timeout", 360))
session = vm.wait_for_login(timeout=login_timeout)
host_ip = utils_net.get_ip_address_by_interface(params["netdst"])
if os_type == "linux":
session.cmd_output_safe(params["nm_stop_cmd"])
guest_ifname = utils_net.get_linux_ifname(session,
vm.get_mac_address())
output = session.cmd_output_safe(params["check_linux_mtu_cmd"] %
guest_ifname)
error_context.context(output, logging.info)
match_string = "mtu %s" % params["mtu_value"]
if match_string not in output:
test.fail("host mtu %s not exposed to guest" % params["mtu_value"])
elif os_type == "windows":
connection_id = utils_net.get_windows_nic_attribute(
session, "macaddress", vm.get_mac_address(), "netconnectionid")
output = session.cmd_output_safe(params["check_win_mtu_cmd"] %
connection_id)
error_context.context(output, logging.info)
lines = output.strip().splitlines()
lines_len = len(lines)
line_table = lines[0].split(' ')
line_value = lines[2].split(' ')
while '' in line_table:
line_table.remove('')
while '' in line_value:
line_value.remove('')
index = 0
for name in line_table:
if re.findall("MTU", name):
break
index += 1
guest_mtu_value = line_value[index]
logging.info("MTU is %s", guest_mtu_value)
if not int(guest_mtu_value) == mtu_value:
test.fail("Host mtu %s is not exposed to "
"guest!" % params["mtu_value"])
logging.info("Ping from guest to host with packet size 3972")
status, output = utils_test.ping(host_ip,
10,
packetsize=3972,
timeout=30,
session=session)
ratio = utils_test.get_loss_ratio(output)
if ratio != 0:
test.fail("Loss ratio is %s", ratio)
# Restore host mtu after finish testing
set_mtu_host(vm_iface, host_mtu_origin)
host_hw_iface.set_mtu(host_mtu_origin)
if netdst not in utils_net.Bridge().list_br():
cleanup_ovs_ports(netdst, host_hw_interface)
session.close()
class Udady(Test):
"""
Udaddy Test.
"""
def setUp(self):
"""
Setup and install dependencies for the test.
"""
self.test_name = "udaddy"
self.basic = self.params.get("basic_option", default="None")
self.ext = self.params.get("ext_option", default="None")
self.flag = self.params.get("ext_flag", default="0")
if self.basic == "None" and self.ext == "None":
self.cancel("No option given")
if self.flag == "1" and self.ext != "None":
self.option = self.ext
else:
self.option = self.basic
if process.system("ibstat", shell=True, ignore_status=True) != 0:
self.cancel("MOFED is not installed. Skipping")
detected_distro = distro.detect()
pkgs = []
smm = SoftwareManager()
if detected_distro.name == "Ubuntu":
pkgs.extend(["openssh-client", "iputils-ping"])
elif detected_distro.name == "SuSE":
pkgs.extend(["openssh", "iputils"])
else:
pkgs.extend(["openssh-clients", "iputils"])
for pkg in pkgs:
if not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel("Not able to install %s" % pkg)
interfaces = netifaces.interfaces()
self.iface = self.params.get("interface", default="")
self.peer_ip = self.params.get("peer_ip", default="")
self.peer_user = self.params.get("peer_user", default="root")
self.peer_password = self.params.get("peer_password", '*',
default="None")
self.ipaddr = self.params.get("host_ip", default="")
self.netmask = self.params.get("netmask", default="")
local = LocalHost()
if self.iface[0:2] == 'ib':
self.networkinterface = NetworkInterface(self.iface, local,
if_type='Infiniband')
try:
self.networkinterface.add_ipaddr(self.ipaddr, self.netmask)
self.networkinterface.save(self.ipaddr, self.netmask)
except Exception:
self.networkinterface.save(self.ipaddr, self.netmask)
else:
self.networkinterface = NetworkInterface(self.iface, local)
try:
self.networkinterface.add_ipaddr(self.ipaddr, self.netmask)
self.networkinterface.save(self.ipaddr, self.netmask)
except Exception:
self.networkinterface.save(self.ipaddr, self.netmask)
self.networkinterface.bring_up()
self.session = Session(self.peer_ip, user=self.peer_user,
password=self.peer_password)
if self.iface not in interfaces:
self.cancel("%s interface is not available" % self.iface)
if self.peer_ip == "":
self.cancel("%s peer machine is not available" % self.peer_ip)
self.timeout = "2m"
self.local_ip = netifaces.ifaddresses(self.iface)[AF_INET][0]['addr']
self.mtu = self.params.get("mtu", default=1500)
self.remotehost = RemoteHost(self.peer_ip, self.peer_user,
password=self.peer_password)
self.peer_interface = self.remotehost.get_interface_by_ipaddr(self.peer_ip).name
self.peer_networkinterface = NetworkInterface(self.peer_interface,
self.remotehost)
if detected_distro.name == "Ubuntu":
cmd = "service ufw stop"
# FIXME: "redhat" as the distro name for RHEL is deprecated
# on Avocado versions >= 50.0. This is a temporary compatibility
# enabler for older runners, but should be removed soon
elif detected_distro.name in ['rhel', 'fedora', 'redhat']:
cmd = "systemctl stop firewalld"
elif detected_distro.name == "SuSE":
if detected_distro.version == 15:
cmd = "systemctl stop firewalld"
else:
cmd = "rcSuSEfirewall2 stop"
elif detected_distro.name == "centos":
cmd = "service iptables stop"
else:
self.cancel("Distro not supported")
if process.system(cmd, ignore_status=True, shell=True) != 0:
self.cancel("Unable to disable firewall")
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.cancel("Unable to disable firewall on peer")
def test(self):
"""
Test udaddy
"""
if self.peer_networkinterface.set_mtu(self.mtu) is not None:
self.fail("Failed to set mtu in peer")
if self.networkinterface.set_mtu(self.mtu) is not None:
self.fail("Failed to set mtu in host")
self.log.info(self.test_name)
logs = "> /tmp/ib_log 2>&1 &"
cmd = " timeout %s %s -b %s %s %s" % (self.timeout, self.test_name,
self.peer_ip, self.option, logs)
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.fail("SSH connection (or) Server command failed")
time.sleep(5)
self.log.info("Client data - %s(%s)" % (self.test_name, self.option))
cmd = "timeout %s %s -s %s -b %s %s" \
% (self.timeout, self.test_name, self.peer_ip,
self.local_ip, self.option)
if process.system(cmd, shell=True, ignore_status=True) != 0:
self.fail("Client command failed")
time.sleep(5)
self.log.info("Server data - %s(%s)" % (self.test_name, self.option))
cmd = "timeout %s cat /tmp/ib_log && rm -rf /tmp/ib_log" \
% (self.timeout)
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.fail("Server output retrieval failed")
def tearDown(self):
"""
unset ip
"""
if self.networkinterface.set_mtu('1500') is not None:
self.fail("Failed to set mtu in host")
if self.peer_networkinterface.set_mtu('1500') is not None:
self.fail("Failed to set mtu in peer")
class RDMA(Test):
'''
RDMA test for infiniband adaptors
'''
def setUp(self):
'''
check the availability of perftest package installed
perftest package should be installed
'''
smm = SoftwareManager()
detected_distro = distro.detect()
pkgs = ["perftest"]
if detected_distro.name == "Ubuntu":
pkgs.append('openssh-client')
elif detected_distro.name == "SuSE":
pkgs.append('openssh')
else:
pkgs.append('openssh-clients')
for pkg in pkgs:
if not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel("%s package is need to test" % pkg)
interfaces = netifaces.interfaces()
self.iface = self.params.get("interface", default="")
self.peer_ip = self.params.get("peer_ip", default="")
self.peer_user = self.params.get("peer_user_name", default="root")
self.peer_password = self.params.get("peer_password", '*',
default="None")
self.ipaddr = self.params.get("host_ip", default="")
self.netmask = self.params.get("netmask", default="")
local = LocalHost()
if self.iface[0:2] == 'ib':
self.networkinterface = NetworkInterface(self.iface, local,
if_type='Infiniband')
try:
self.networkinterface.add_ipaddr(self.ipaddr, self.netmask)
self.networkinterface.save(self.ipaddr, self.netmask)
except Exception:
self.networkinterface.save(self.ipaddr, self.netmask)
else:
self.networkinterface = NetworkInterface(self.iface, local)
try:
self.networkinterface.add_ipaddr(self.ipaddr, self.netmask)
self.networkinterface.save(self.ipaddr, self.netmask)
except Exception:
self.networkinterface.save(self.ipaddr, self.netmask)
self.networkinterface.bring_up()
self.session = Session(self.peer_ip, user=self.peer_user,
password=self.peer_password)
if self.iface not in interfaces:
self.cancel("%s interface is not available" % self.iface)
if self.peer_ip == "":
self.cancel("%s peer machine is not available" % self.peer_ip)
self.ca_name = self.params.get("CA_NAME", default="mlx4_0")
self.port = self.params.get("PORT_NUM", default="1")
self.peer_ca = self.params.get("PEERCA", default="mlx4_0")
self.peer_port = self.params.get("PEERPORT", default="1")
self.tmo = self.params.get("TIMEOUT", default="600")
self.tool_name = self.params.get("tool")
if self.tool_name == "":
self.cancel("should specify tool name")
self.log.info("test with %s", self.tool_name)
self.test_op = self.params.get("test_opt", default="")
self.mtu = self.params.get("mtu", default=1500)
self.remotehost = RemoteHost(self.peer_ip, self.peer_user,
password=self.peer_password)
self.peer_interface = self.remotehost.get_interface_by_ipaddr(self.peer_ip).name
self.peer_networkinterface = NetworkInterface(self.peer_interface,
self.remotehost)
if detected_distro.name == "Ubuntu":
cmd = "service ufw stop"
# FIXME: "redhat" as the distro name for RHEL is deprecated
# on Avocado versions >= 50.0. This is a temporary compatibility
# enabler for older runners, but should be removed soon
elif detected_distro.name in ['rhel', 'fedora', 'redhat']:
cmd = "systemctl stop firewalld"
elif detected_distro.name == "SuSE":
if detected_distro.version == 15:
cmd = "systemctl stop firewalld"
else:
cmd = "rcSuSEfirewall2 stop"
elif detected_distro.name == "centos":
cmd = "service iptables stop"
else:
self.cancel("Distro not supported")
if process.system(cmd, ignore_status=True, shell=True) != 0:
self.cancel("Unable to disable firewall")
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.cancel("Unable to disable firewall on peer")
def rdma_exec(self, arg1, arg2, arg3):
'''
bandwidth performance exec function
'''
flag = 0
logs = "> /tmp/ib_log 2>&1 &"
cmd = "timeout %s %s -d %s -i %s %s %s %s" \
% (self.tmo, arg1, self.peer_ca, self.peer_port, arg2, arg3, logs)
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.fail("ssh failed to remote machine\
or faing data from remote machine failed")
time.sleep(2)
self.log.info("client data for %s(%s)", arg1, arg2)
cmd = "timeout %s %s -d %s -i %s %s %s %s" \
% (self.tmo, arg1, self.ca_name, self.port, self.peer_ip,
arg2, arg3)
if process.system(cmd, shell=True, ignore_status=True) != 0:
flag = 1
self.log.info("server data for %s(%s)", arg1, arg2)
cmd = "timeout %s cat /tmp/ib_log && rm -rf /tmp/ib_log" % (self.tmo)
output = self.session.cmd(cmd)
if not output.exit_status == 0:
self.fail("ssh failed to remote machine\
or fetching data from remote machine failed")
return flag
def test(self):
'''
test options are mandatory
'''
if self.peer_networkinterface.set_mtu(self.mtu) is not None:
self.fail("Failed to set mtu in peer")
if self.networkinterface.set_mtu(self.mtu) is not None:
self.fail("Failed to set mtu in host")
if self.rdma_exec(self.tool_name, self.test_op, "") != 0:
self.fail("Client cmd: %s %s" % (self.tool_name, self.test_op))
def tearDown(self):
"""
unset ip
"""
if self.networkinterface.set_mtu('1500') is not None:
self.fail("Failed to set mtu in host")
if self.peer_networkinterface.set_mtu('1500') is not None:
self.fail("Failed to set mtu in peer")
self.remotehost.remote_session.quit()
