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) self.hbond = self.params.get("hbond", default=False) for root, dirct, files in os.walk("/root/.ssh"): for file in files: if file.startswith("avocado-master-root"): path = os.path.join(root, file) os.remove(path) local = LocalHost() if self.hbond: self.networkinterface = NetworkInterface(self.iface, local, if_type='Bond') else: 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.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() if 'scp' or 'ssh' in str(self.name.name): self.session.quit()
class Ethtool(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(["iputils-ping"]) elif detected_distro.name == "SuSE": pkgs.extend(["iputils"]) else: pkgs.extend(["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.hbond = self.params.get("hbond", default=False) self.peer = self.params.get("peer_ip") self.tx = self.params.get("tx_channel", default='') self.rx = self.params.get("rx_channel", default='') self.other = self.params.get("other_channel", default='') self.combined = self.params.get("combined_channel", default='') if not self.peer: self.cancel("No peer provided") local = LocalHost() if self.iface[0:2] == 'ib': self.networkinterface = NetworkInterface(self.iface, local, if_type='Infiniband') elif self.hbond: self.networkinterface = NetworkInterface(self.iface, local, if_type='Bond') 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() if not wait.wait_for(self.networkinterface.is_link_up, timeout=120): self.cancel("Link up of interface is taking longer than 120s") if self.networkinterface.ping_check(self.peer, count=5) is not None: self.cancel("No connection to peer") self.args = self.params.get("arg", default='') self.elapse = self.params.get("action_elapse", default='') self.priv_test = self.params.get("privflag_test", default=False) if self.priv_test: cmd = "ethtool --show-priv-flags %s" % (self.iface) self.ret_val = process.run(cmd, shell=True, verbose=True, ignore_status=True) if self.ret_val.exit_status: self.cancel("Device Doesn't support Private flags") def interface_state_change(self, interface, state, status): ''' Set the interface state specified, and return True if done. Returns False otherwise. ''' cmd = "ip link set dev %s %s" % (interface, state) if state == "up": if process.system(cmd, shell=True, ignore_status=True) != 0: return False if not wait.wait_for(self.networkinterface.is_link_up, timeout=120): self.fail("Link up of interface is taking longer than 120s") else: if process.system(cmd, shell=True, ignore_status=True) != 0: return False if status != self.interface_link_status(interface): return False return True def interface_link_status(self, interface): ''' Return the status of the interface link from ethtool. ''' cmd = "ethtool %s" % interface for line in process.system_output(cmd, shell=True, ignore_status=True).decode("utf-8") \ .splitlines(): if 'Link detected' in line: return line.split()[-1] return '' def test_ethtool(self): ''' Test the ethtool args provided ''' for state, status in zip(["down", "up"], ["no", "yes"]): if not self.interface_state_change(self.iface, state, status): self.fail("interface %s failed" % state) if self.args == "-L": value = [self.tx, self.rx, self.other, self.combined] self.param = ['tx', 'rx', 'other', 'combined'] default = [] cmd_l = "ethtool %s %s %s" % ("-l", self.iface, self.elapse) output = process.run(cmd_l, shell=True, verbose=True, ignore_status=True).stdout_text \ .splitlines()[2:6] for i in range(len(output)): default.append(output[i].split(':')[1]) if 'n/a' in output[i]: self.param[i], value[i], default[i] = '', '', '' self.default_set = default.copy() elements = all([elem == '' for elem in value]) if elements: self.log.warn("Cannot set device channel for null") else: for i in range(4): if default[i] != '': default[i] = ['0', '1', int(default[i])//2, default[i], int(default[i])+1] for j in range(5): if value[i] != '': cmd = "ethtool %s %s %s %s" % ( self.args, self.iface, self.param[i], default[i][j]) result = process.run(cmd, shell=True, verbose=True, ignore_status=True) if state is 'up': if self.networkinterface.ping_check( self.peer, count=5) is not None: self.cancel("ping fail value %s \ to %s parameter" % ( default[i][j], self.param[i])) err_channel = "no RX or TX channel" err_count = "count exceeds maximum" if result.exit_status != 0: if err_channel in result.stderr_text: self.log.info("Cannot set %s \ value on %s parameter" % ( default[i][j], self.param[i])) elif err_count in result.stderr_text: self.log.info("Cannot set %s \ value on %s parameter" % ( default[i][j], self.param[i])) else: self.fail("%s %s" % ( self.args, result.stderr_text)) cmd = "ethtool %s %s %s %s %s %s %s %s %s %s" % ( self.args, self.iface, self.param[0], value[0], self.param[1], value[1], self.param[2], value[2], self.param[3], value[3]) ret = process.run(cmd, shell=True, verbose=True, ignore_status=True) if ret.exit_status != 0: self.fail("%s %s" % (self.args, ret.stderr_text)) else: cmd = "ethtool %s %s %s" % (self.args, self.iface, self.elapse) ret = process.run(cmd, shell=True, verbose=True, ignore_status=True) if ret.exit_status != 0: if "Operation not supported" in ret.stderr_text: self.log.warn("%s failed" % self.args) else: self.fail("%s failed" % self.args) if not wait.wait_for(lambda: self.networkinterface.are_packets_lost( self.peer, options=['-c 10000', '-f']), timeout=30): self.cancel("Packet recieved in Ping flood is not 100 percent \ after waiting for 30sec") if self.priv_test: self.ethtool_toggle_priv_flags() def ethtool_toggle_priv_flags(self): ''' Toggle the priv flag settings of the driver. ''' priv_pass = [] priv_fail = [] for oper in ('toggle', 'setback'): for line in self.ret_val.stdout_text.splitlines(): if "off" in line: val = "on" else: val = "off" if "flags" not in line: priv_flag = line.split(':')[0] cmd = "ethtool --set-priv-flags %s \"%s\" %s" % \ (self.iface, priv_flag.rstrip(), val) ret1 = process.run(cmd, shell=True, verbose=True, ignore_status=True) if ret1.exit_status == 0 or 'supported' in \ ret1.stderr_text: priv_pass.append(priv_flag.rstrip()) else: priv_fail.append(priv_flag.rstrip()) if self.networkinterface.ping_check(self.peer, count=500000, options='-f') is not None: self.fail("Ping failed oper = %s" % oper) if priv_fail: self.fail("Private flags could not be toggled: %s" % ",".join(list(set(priv_fail)))) def tearDown(self): ''' Set the interface up at the end of test. ''' if self.args == "-L": cmd = "ethtool %s %s %s %s %s %s %s %s %s %s" % ( self.args, self.iface, self.param[0], self.default_set[0], self.param[1], self.default_set[1], self.param[2], self.default_set[2], self.param[3], self.default_set[3]) ret = process.run(cmd, shell=True, verbose=True, ignore_status=True) if ret.exit_status != 0: self.fail("%s %s" % (self.args, ret.stderr_text)) self.interface_state_change(self.iface, "up", "yes") 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()
class ReceiveMulticastTest(Test): ''' check multicast receive using ping tool ''' def setUp(self): ''' To check and install dependencies for the test ''' self.peer = self.params.get("peer_ip", default="") self.user = self.params.get("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="") self.hbond = self.params.get("hbond", default=False) local = LocalHost() if self.hbond: self.networkinterface = NetworkInterface(self.iface, local, if_type='Bond') 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, user=self.user, password=self.peer_password) if not self.session.connect(): self.cancel("failed connecting to peer") self.count = self.params.get("count", default="500000") smm = SoftwareManager() pkgs = ["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) if self.peer == "": self.cancel("peer ip should specify in input") cmd = "ip addr show | grep %s" % self.peer output = self.session.cmd(cmd) result = "" result = result.join(output.stdout.decode("utf-8")) self.peerif = result.split()[-1] if self.peerif == "": self.cancel("unable to get peer interface") cmd = "ip -f inet -o addr show %s | awk '{print $4}' | cut -d / -f1"\ % self.iface self.local_ip = process.system_output(cmd, shell=True).strip() if self.local_ip == "": self.cancel("unable to get local ip") def test_multicast(self): ''' ping to peer machine ''' cmd = "echo 0 > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts" if process.system(cmd, shell=True, verbose=True, ignore_status=True) != 0: self.fail("unable to set value to icmp_echo_ignore_broadcasts") cmd = "ip link set %s allmulticast on" % self.iface if process.system(cmd, shell=True, verbose=True, ignore_status=True) != 0: self.fail("unable to set all mulicast option to test interface") cmd = "ip route add 224.0.0.0/4 dev %s" % self.peerif output = self.session.cmd(cmd) if not output.exit_status == 0: self.fail("Unable to add route for Peer interafce") cmd = "timeout 600 ping -I %s 224.0.0.1 -c %s -f" % (self.peerif, self.count) output = self.session.cmd(cmd) if not output.exit_status == 0: self.fail("multicast test failed") def tearDown(self): ''' delete multicast route and turn off multicast option ''' cmd = "ip route del 224.0.0.0/4" output = self.session.cmd(cmd) if not output.exit_status == 0: self.log.info("Unable to delete multicast route added for peer") cmd = "echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts" if process.system(cmd, shell=True, verbose=True, ignore_status=True) != 0: self.log.info("unable to unset all mulicast option") cmd = "ip link set %s allmulticast off" % self.iface if process.system(cmd, shell=True, verbose=True, ignore_status=True) != 0: self.log.info("unable to unset all mulicast option") 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.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 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='') self.hbond = self.params.get("hbond", default=False) # Check if interface exists in the system self.networkinterface = None interfaces = netifaces.interfaces() if not self.iface: self.cancel("Please specify interface to be used") 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() 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() 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 """ if self.count <= 10: nping_count = round((200 * int(self.count)) / 100) else: 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: 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.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()
class Bridging(Test): ''' Test bridge interface ''' def check_failure(self, cmd): if process.system(cmd, sudo=True, shell=True, ignore_status=True): self.fail("Command %s failed" % cmd) def setUp(self): self.host_interfaces = self.params.get("interfaces", default="").split(" ") if not self.host_interfaces: self.cancel("User should specify host interface/s") if self.host_interfaces[0:2] == 'ib': self.cancel("Network Bridge is not supported for IB") interfaces = netifaces.interfaces() for host_interface in self.host_interfaces: if host_interface not in interfaces: self.cancel("Interface is not available") self.peer_ip = self.params.get("peer_ip", default=None) if not self.peer_ip: self.cancel("User should specify peer IP") self.ipaddr = self.params.get("host_ip", default="") self.netmask = self.params.get("netmask", default="") self.bridge_interface = self.params.get("bridge_interface", default="br0") local = LocalHost() self.networkinterface = NetworkInterface(self.bridge_interface, local, if_type="Bridge") def test_bridge_create(self): ''' Set up the ethernet bridge configuration in the linux kernel ''' detected_distro = distro.detect() net_path = 'network-scripts' if detected_distro.name == "SuSE": net_path = 'network' if os.path.exists('/etc/sysconfig/%s/ifcfg-%s' % (net_path, self.bridge_interface)): self.networkinterface.remove_cfg_file() self.check_failure('ip link del %s' % self.bridge_interface) self.check_failure('ip link add dev %s type bridge' % self.bridge_interface) check_flag = False cmd = 'ip -d link show %s' % self.bridge_interface check_br = process.system_output(cmd, verbose=True, ignore_status=True).decode("utf-8") for line in check_br.splitlines(): if line.find('bridge'): check_flag = True if not check_flag: self.fail('Bridge interface is not created') for host_interface in self.host_interfaces: self.check_failure('ip link set %s master %s' % (host_interface, self.bridge_interface)) self.check_failure('ip addr flush dev %s' % host_interface) def test_bridge_run(self): ''' run bridge test ''' 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 self.networkinterface.ping_check(self.peer_ip, count=5) is not None: self.fail('Ping using bridge failed') self.networkinterface.remove_ipaddr(self.ipaddr, self.netmask) def test_bridge_delete(self): ''' Set to original state ''' self.check_failure('ip link del dev %s' % self.bridge_interface) try: self.networkinterface.restore_from_backup() except Exception: self.networkinterface.remove_cfg_file()
class Ethtool(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(["iputils-ping"]) elif detected_distro.name == "SuSE": pkgs.extend(["iputils"]) else: pkgs.extend(["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.hbond = self.params.get("hbond", default=False) self.peer = self.params.get("peer_ip") if not self.peer: self.cancel("No peer provided") local = LocalHost() if self.iface[0:2] == 'ib': self.networkinterface = NetworkInterface(self.iface, local, if_type='Infiniband') elif self.hbond: self.networkinterface = NetworkInterface(self.iface, local, if_type='Bond') 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() if not wait.wait_for(self.networkinterface.is_link_up, timeout=120): self.cancel("Link up of interface is taking longer than 120s") if self.networkinterface.ping_check(self.peer, count=5) is not None: self.cancel("No connection to peer") self.args = self.params.get("arg", default='') self.elapse = self.params.get("action_elapse", default='') self.priv_test = self.params.get("privflag_test", default=False) if self.priv_test: cmd = "ethtool --show-priv-flags %s" % (self.iface) self.ret_val = process.run(cmd, shell=True, verbose=True, ignore_status=True) if self.ret_val.exit_status: self.cancel("Device Doesn't support Private flags") def interface_state_change(self, interface, state, status): ''' Set the interface state specified, and return True if done. Returns False otherwise. ''' cmd = "ip link set dev %s %s" % (interface, state) if state == "up": if process.system(cmd, shell=True, ignore_status=True) != 0: return False if not wait.wait_for(self.networkinterface.is_link_up, timeout=120): self.fail("Link up of interface is taking longer than 120s") else: if process.system(cmd, shell=True, ignore_status=True) != 0: return False if status != self.interface_link_status(interface): return False return True def interface_link_status(self, interface): ''' Return the status of the interface link from ethtool. ''' cmd = "ethtool %s" % interface for line in process.system_output(cmd, shell=True, ignore_status=True).decode("utf-8") \ .splitlines(): if 'Link detected' in line: return line.split()[-1] return '' def test_ethtool(self): ''' Test the ethtool args provided ''' for state, status in zip(["down", "up"], ["no", "yes"]): if not self.interface_state_change(self.iface, state, status): self.fail("interface %s failed" % state) cmd = "ethtool %s %s %s" % (self.args, self.iface, self.elapse) ret = process.run(cmd, shell=True, verbose=True, ignore_status=True) if ret.exit_status != 0: if "Operation not supported" in ret.stderr_text: self.log.warn("%s failed" % self.args) else: self.fail("failed") if self.networkinterface.ping_check(self.peer, count=10000, options='-f') is not None: self.fail("flood ping test failed") if self.priv_test: self.ethtool_toggle_priv_flags() def ethtool_toggle_priv_flags(self): ''' Toggle the priv flag settings of the driver. ''' priv_pass = [] priv_fail = [] for oper in ('toggle', 'setback'): for line in self.ret_val.stdout_text.splitlines(): if "off" in line: val = "on" else: val = "off" if "flags" not in line: priv_flag = line.split(':')[0] cmd = "ethtool --set-priv-flags %s \"%s\" %s" % \ (self.iface, priv_flag.rstrip(), val) ret1 = process.run(cmd, shell=True, verbose=True, ignore_status=True) if ret1.exit_status == 0 or 'supported' in \ ret1.stderr_text: priv_pass.append(priv_flag.rstrip()) else: priv_fail.append(priv_flag.rstrip()) if self.networkinterface.ping_check(self.peer, count=500000, options='-f') is not None: self.fail("Ping failed oper = %s" % oper) if priv_fail: self.fail("Private flags could not be toggled: %s" % ",".join(list(set(priv_fail)))) def tearDown(self): ''' Set the interface up at the end of test. ''' self.interface_state_change(self.iface, "up", "yes") 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()