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()