def setUp(self): """ Set up """ if 'ppc64' not in process.system_output('uname -a', ignore_status=True, shell=True, sudo=True).decode("utf-8"): self.cancel("Platform does not support HTX tests") self.parameters() self.localhost = LocalHost() if 'start' in str(self.name.name): for ipaddr, interface in zip(self.ipaddr, self.host_intfs): 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.host_distro = distro.detect() self.login(self.peer_ip, self.peer_user, self.peer_password) self.remotehost = RemoteHost(self.peer_ip, self.peer_user, password=self.peer_password) self.get_peer_distro()
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 setUp(self): """ Identify the virtualized device. """ smm = SoftwareManager() for pkg in ["net-tools"]: if not smm.check_installed(pkg) and not smm.install(pkg): self.cancel("%s package is need to test" % pkg) interfaces = netifaces.interfaces() self.virtual_device = self.params.get('virtual_device') self.virtual_slot = self.params.get('virtual_slot') if "T" in self.virtual_slot: self.virtual_slot = self.virtual_slot.split("-T")[0] output = process.system_output("lsslot", shell=True) for line in output.decode("utf-8").splitlines(): if self.virtual_slot in line: self.device_type = line.split()[-1] self.device = line.split()[-2] self.count = int(self.params.get('count', default="1")) self.peer_ip = self.params.get('peer_ip', default=None) self.ipaddr = self.params.get("host_ip", default="") self.netmask = self.params.get("netmask", default="") local = LocalHost() if self.device_type in ["l-lan", "vnic"]: if self.virtual_device not in interfaces: self.cancel("%s interface is not available" % self.virtual_device) self.networkinterface = NetworkInterface(self.virtual_device, 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()
def setUp(self): ''' Gather necessary test inputs. ''' self.interface = self.params.get('interface', default=None) self.peer_ip = self.params.get('peer_ip', default=None) self.num_of_dlpar = int(self.params.get("num_of_dlpar", default='1')) self.vios_ip = self.params.get('vios_ip', '*', default=None) self.vios_user = self.params.get('vios_username', '*', default=None) self.vios_pwd = self.params.get('vios_pwd', '*', default=None) self.login(self.vios_ip, self.vios_user, self.vios_pwd) cmd = "lscfg -l %s" % self.interface for line in process.system_output(cmd, shell=True).decode("utf-8") \ .splitlines(): if self.interface in line: self.slot = line.split()[-1].split('-')[-2] cmd = "lsmap -all -net" output = self.run_command(cmd) for line in output.splitlines(): if self.slot in line: self.iface = line.split()[0] cmd = "lsmap -vadapter %s -net" % self.iface output = self.run_command(cmd) for line in output.splitlines(): if "SEA" in line: self.sea = line.split()[-1] if not self.sea: self.cancel("failed to get SEA") self.log.info(self.sea) local = LocalHost() self.networkinterface = NetworkInterface(self.interface, local) if self.networkinterface.ping_check(self.peer_ip, count=5) is not None: self.cancel("peer connection is failed")
def setUp(self): ''' To check and install dependencies for the test ''' sm = SoftwareManager() for pkg in ["ethtool", "net-tools"]: if not sm.check_installed(pkg) and not sm.install(pkg): self.cancel("%s package is need to test" % pkg) interfaces = netifaces.interfaces() self.iface = self.params.get("interface") 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() cmd = "basename -a /sys/class/net/%s/device/driver/module/drivers/*" % self.iface output = process.system_output(cmd, shell=True).decode("utf-8") for line in output.splitlines(): if line.split(':')[0] in ['pci', 'vio']: self.iface_type, self.driver = line.split(':') break self.businfo = self.get_bus_info(self.iface, self.iface_type)
def setUp(self): ''' To get all the parameter for the test ''' 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="") 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.peer = self.params.get("peer_ip") if not self.peer: self.cancel("No peer provided") if self.networkinterface.ping_check(self.peer, count=2) is not None: self.cancel("No connection to peer") self.switch_name = self.params.get("switch_name", '*', default="") self.userid = self.params.get("userid", '*', default="") self.password = self.params.get("password", '*', default="") self.port_id = self.params.get("port_id", default="") if not self.port_id: self.cancel("user should specify port id") self.switch_login(self.switch_name, self.userid, self.password)
def test_add_migratable_sriov(self): ''' test to create Migratable sriov device ''' if not self.migratable: self.cancel("Test unsupported") for slot, port, mac, ipaddr, netmask, peer_ip in zip(self.sriov_adapter, self.sriov_port, self.mac_id, self.ipaddr, self.netmask, self.peer_ip): self.device_add_remove(slot, port, mac, '', 'add') if not self.list_device(mac): self.fail( "failed to list Migratable logical device after add operation") bond_device = self.get_hnv_bond(mac) if bond_device: ret = process.run('nmcli c mod id %s ipv4.method manual ipv4.addres %s/%s' % (bond_device, ipaddr, self.prefix), ignore_status=True) if ret.exit_status: self.fail("nmcli ip configuration for hnv bond fail with %s" % (ret.exit_status)) ret = process.run('nmcli c up %s' % bond_device, ignore_status=True) if ret.exit_status: self.fail("hnv bond ip bring up fail with %s" % (ret.exit_status)) networkinterface = NetworkInterface(bond_device, self.local) if networkinterface.ping_check(peer_ip, count=5) is not None: self.fail("ping check failed for hnv bond device") else: self.fail("failed to create hnv bond device")
def test_hmcfailover(self): ''' Triggers Failover for the Network virtualized device ''' original = self.get_active_device_logport(self.slot_num[0]) for _ in range(self.count): before = self.get_active_device_logport(self.slot_num[0]) self.trigger_failover( self.get_backing_device_logport(self.slot_num[0])) time.sleep(10) after = self.get_active_device_logport(self.slot_num[0]) self.log.debug("Active backing device: %s", after) if before == after: self.fail("No failover happened") device = self.find_device(self.mac_id[0]) networkinterface = NetworkInterface(device, self.local) if networkinterface.ping_check(self.peer_ip[0], count=5) is not None: self.fail("Failover has affected Network connectivity") if original != self.get_active_device_logport(self.slot_num[0]): self.trigger_failover(original) if original != self.get_active_device_logport(self.slot_num[0]): self.log.warn("Fail: Activating Initial backing dev %s" % original) self.check_dmesg_error()
def test_vnic_auto_failover(self): ''' Set the priority for vNIC active and backing devices and check if autofailover works ''' if len(self.backing_adapter) >= 2: for _ in range(self.count): self.update_backing_devices(self.slot_num[0]) backing_logport = self.get_backing_device_logport( self.slot_num[0]) active_logport = self.get_active_device_logport( self.slot_num[0]) if self.enable_auto_failover(): if not self.change_failover_priority(backing_logport, '1'): self.fail( "Fail to change the priority for backing device %s", backing_logport) if not self.change_failover_priority( active_logport, '100'): self.fail( "Fail to change the priority for active device %s", active_logport) time.sleep(10) if backing_logport != self.get_active_device_logport( self.slot_num[0]): self.fail("Auto failover of backing device failed") device = self.find_device(self.mac_id[0]) networkinterface = NetworkInterface(device, self.local) if networkinterface.ping_check(self.peer_ip[0], count=5) is not None: self.fail("Auto failover has effected connectivity") else: self.fail("Could not enable auto failover") else: self.cancel("Provide more backing device, only 1 given") self.check_dmesg_error()
def test_clientfailover(self): ''' Performs Client initiated failover for Network virtualized device ''' device_id = self.find_device_id(self.mac_id[0]) try: for _ in range(self.count): for val in range(int(self.backing_dev_count())): self.log.info( "Performing Client initiated\ failover - Attempt %s", int(val + 1)) genio.write_file_or_fail( "/sys/devices/vio/%s/failover" % device_id, "1") time.sleep(10) self.log.info("Running a ping test to check if failover \ affected Network connectivity") device = self.find_device(self.mac_id[0]) networkinterface = NetworkInterface(device, self.local) if networkinterface.ping_check(self.peer_ip[0], count=5, options="-w50") is not None: self.fail("Ping test failed. Network virtualized \ failover has affected Network connectivity") except CmdError as details: self.log.debug(str(details)) self.fail("Client initiated Failover for Network virtualized \ device has failed") self.check_dmesg_error()
def test_add(self): ''' Network virtualized device add operation ''' for slot, mac, sriov_port, adapter_id, device_ip, netmask in zip( self.slot_num, self.mac_id, self.sriov_port, self.backing_adapter_id, self.device_ip, self.netmask): if not self.check_slot_availability(slot): self.fail("Slot does not exist") self.device_add_remove(slot, mac, sriov_port, adapter_id, 'add') self.interface_naming(mac, slot) output = self.list_device(slot) if 'slot_num=%s' % slot not in str(output): self.log.debug(output) self.fail("lshwres fails to list Network virtualized device \ after add operation") if mac not in str(output): self.log.debug(output) self.fail("MAC address in HMC differs") if not self.find_device(mac): self.fail("MAC address differs in linux") device = self.find_device(mac) networkinterface = NetworkInterface(device, self.local) try: networkinterface.add_ipaddr(device_ip, netmask) networkinterface.save(device_ip, netmask) except Exception: networkinterface.save(device_ip, netmask) networkinterface.bring_up() if not wait.wait_for(networkinterface.is_link_up, timeout=120): self.fail("Unable to bring up the link on the Network \ virtualized device") self.check_dmesg_error()
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 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.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') 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() 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 test_rmdev_viosfailover(self): ''' using mrdev and mkdev command to check vios failover works ''' self.session = Session(self.vios_ip, user=self.vios_user, password=self.vios_pwd) if not wait.wait_for(self.session.connect, timeout=30): self.fail("Failed connecting to VIOS") cmd = "ioscli lsmap -all -vnic -cpid %s" % self.lpar_id vnic_servers = self.session.cmd(cmd).stdout_text.splitlines() device = self.find_device(self.mac_id[0]) temp_idx = vnic_servers.index("Client device name:" + device) vnic_server = vnic_servers[temp_idx - 5].split()[0] cmd = "ioscli lsmap -vnic -vadapter %s" % vnic_server output = self.session.cmd(cmd) vnic_backing_device = None for line in output.stdout_text.splitlines(): if 'Backing device' in line: vnic_backing_device = line.split(':')[-1] before = self.get_active_device_logport(self.slot_num[0]) self.log.debug("Active backing device before : %s", before) self.validate_vios_command('rmdev -l %s' % vnic_server, 'Defined') if vnic_backing_device: self.validate_vios_command('rmdev -l %s' % vnic_backing_device, 'Defined') time.sleep(10) for backing_dev in self.backing_dev_list().splitlines(): if backing_dev.startswith('%s,' % self.slot_num[0]): backing_dev = backing_dev.strip('%s,"' % self.slot_num[0]) if 'Powered Off' not in backing_dev: self.fail("Failover did not occur") time.sleep(60) if vnic_backing_device: self.validate_vios_command('mkdev -l %s' % vnic_backing_device, 'Available') self.validate_vios_command('mkdev -l %s' % vnic_server, 'Available') networkinterface = NetworkInterface(device, self.local) if networkinterface.ping_check(self.peer_ip[0], count=5) is not None: self.fail("Ping test failed. Network virtualized \ vios failover has affected Network connectivity") self.check_dmesg_error()
def test_disable_enable_dev(self): ''' Test if disabling and enabling of an adapter works ''' self.disable_enable_dev('d') self.is_disabled_enabled_dev('1') self.disable_enable_dev('e') self.is_disabled_enabled_dev('0') device = self.find_device(self.mac_id[0]) networkinterface = NetworkInterface(device, self.local) wait.wait_for(networkinterface.is_link_up, timeout=60) if networkinterface.ping_check(self.peer_ip[0], count=5) is not None: self.fail("Enabling and disabling of the interface has affected network connectivity") self.check_dmesg_error()
def test_rmdev_viosfailover(self): ''' using mrdev and mkdev command to check vios failover works ''' self.session = Session(self.vios_ip, user=self.vios_user, password=self.vios_pwd) if not self.session.connect(): self.fail("Failed connecting to VIOS") cmd = "ioscli lsmap -all -vnic -cpid %s" % self.lpar_id vnic_server = self.session.cmd( cmd).stdout_text.splitlines()[2].split()[0] cmd = "ioscli lsmap -vnic -vadapter %s" % vnic_server output = self.session.cmd(cmd) vnic_backing_device = None for line in output.stdout_text.splitlines(): if 'Backing device' in line: vnic_backing_device = line.split(':')[-1] before = self.get_active_device_logport(self.slot_num[0]) self.log.debug("Active backing device before : %s", before) self.validate_vios_command('rmdev -l %s' % vnic_server, 'Defined') if vnic_backing_device: self.validate_vios_command('rmdev -l %s' % vnic_backing_device, 'Defined') after = self.get_active_device_logport(self.slot_num[0]) self.log.debug("Active backing device after: %s", after) if before == after: self.fail("failover not occour") time.sleep(20) if vnic_backing_device: self.validate_vios_command('mkdev -l %s' % vnic_backing_device, 'Available') self.validate_vios_command('mkdev -l %s' % vnic_server, 'Available') device = self.find_device(self.mac_id[0]) networkinterface = NetworkInterface(device, self.local) if networkinterface.ping_check(self.peer_ip[0], count=5) is not None: self.fail("Ping test failed. Network virtualized \ vios failover has affected Network connectivity") self.check_dmesg_error()
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="") 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() 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_user = self.params.get("peer_user", default="root") self.peer_password = self.params.get("peer_password", '*', default=None) remotehost = RemoteHost(self.peer, self.peer_user, password=self.peer_password) self.peer_interface = remotehost.get_interface_by_ipaddr(self.peer).name self.peer_networkinterface = NetworkInterface(self.peer_interface, remotehost) 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 net_recovery_check(): """ Checks if the network adapter fuctionality like ping/link_state, after adapter added back. Returns True on propper Recovery, False if not. """ self.log.info("entering the net recovery check") local = LocalHost() iface = pci.get_interfaces_in_pci_address(pci_addr, 'net') networkinterface = NetworkInterface(iface[0], local) if wait.wait_for(networkinterface.is_link_up, timeout=120): if networkinterface.ping_check(self.peer_ip, count=5) is None: self.log.info("inteface is up and pinging") return True return False
def setUp(self): """ get parameters """ self.module = self.params.get('module', default=None) if not self.module: self.cancel("Please provide the Module name") interfaces = netifaces.interfaces() self.ifaces = self.params.get("interface") if self.ifaces not in interfaces: self.cancel("%s interface is not available" % self.ifaces) self.ipaddr = self.params.get("host_ip", default="") self.netmask = self.params.get("netmask", default="") self.peer = self.params.get("peer_ip") if not self.peer: self.cancel("No peer provided") self.param_name = self.params.get('module_param_name', default=None) self.param_value = self.params.get('module_param_value', default=None) self.sysfs_chk = self.params.get('sysfs_check_required', default=None) local = LocalHost() if self.ifaces[0:2] == 'ib': self.networkinterface = NetworkInterface(self.ifaces, 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.ifaces, 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.load_unload_sleep_time = 10 self.error_modules = [] self.mod_list = [] self.uname = linux_modules.platform.uname()[2] if self.built_in_module(self.module) is True: self.cancel("Module %s is Built-in Skipping " % self.module) if self.param_check() is False: self.cancel("Param %s is not Valid for Module %s" % (self.param_name, self.module))
def test_vnic_dlpar(self): ''' Perform vNIC device hot add and hot remove using drmgr command ''' for slot_no, device_ip, netmask, mac, peer_ip in zip( self.slot_num, self.device_ip, self.netmask, self.mac_id, self.peer_ip): self.update_backing_devices(slot_no) dev_id = self.find_device_id(mac) device_name = self.find_device(mac) slot = self.find_virtual_slot(dev_id) if slot: try: for _ in range(self.num_of_dlpar): self.drmgr_vnic_dlpar('-r', slot) self.drmgr_vnic_dlpar('-a', slot) self.wait_intrerface(device_name) except CmdError as details: self.log.debug(str(details)) self.fail("dlpar operation did not complete") device = self.find_device(mac) networkinterface = NetworkInterface(device, self.local) try: networkinterface.add_ipaddr(device_ip, netmask) except Exception: networkinterface.save(device_ip, netmask) if not wait.wait_for(networkinterface.is_link_up, timeout=120): self.fail("Unable to bring up the link on the Network \ virtualized device") if networkinterface.ping_check(peer_ip, count=5) is not None: self.fail("dlpar has affected Network connectivity") else: self.fail("slot not found") self.check_dmesg_error()
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 ip_restore_host(self): ''' restoring ip for host ''' for ipaddr, interface in zip(self.ipaddr, self.host_intfs): cmd = "ip addr flush %s" % interface process.run(cmd, ignore_status=True, shell=True, sudo=True) networkinterface = NetworkInterface(interface, self.localhost) networkinterface.add_ipaddr(ipaddr, self.netmask) networkinterface.save(ipaddr, self.netmask) networkinterface.bring_up()
def setUp(self): ''' Gather necessary test inputs. ''' self.interface = self.params.get('interface', default=None) self.ipaddr = self.params.get("host_ip", default="") self.netmask = self.params.get("netmask", default="") self.peer_ip = self.params.get('peer_ip', default=None) self.num_of_dlpar = int(self.params.get("num_of_dlpar", default='1')) self.vios_ip = self.params.get('vios_ip', '*', default=None) self.vios_user = self.params.get('vios_username', '*', default=None) self.vios_pwd = self.params.get('vios_pwd', '*', default=None) self.session = Session(self.vios_ip, user=self.vios_user, password=self.vios_pwd) self.session.connect() local = LocalHost() self.networkinterface = NetworkInterface(self.interface, 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() cmd = "lscfg -l %s" % self.interface for line in process.system_output(cmd, shell=True).decode("utf-8") \ .splitlines(): if self.interface in line: self.slot = line.split()[-1].split('-')[-2] cmd = "ioscli lsmap -all -net" output = self.session.cmd(cmd) for line in output.stdout_text.splitlines(): if self.slot in line: self.iface = line.split()[0] cmd = "ioscli lsmap -vadapter %s -net" % self.iface output = self.session.cmd(cmd) for line in output.stdout_text.splitlines(): if "SEA" in line: self.sea = line.split()[-1] if not self.sea: self.cancel("failed to get SEA") self.log.info(self.sea) if self.networkinterface.ping_check(self.peer_ip, count=5) is not None: self.cancel("peer connection is failed")
def interfaces(self): cmd = 'ls /sys/class/net' try: names = run_command(cmd, self).split() except Exception as ex: raise NWException(f"Failed to get interfaces: {ex}") if "bonding_masters" in names: names.remove("bonding_masters") return [NetworkInterface(if_name=name, host=self) for name in names]
def ip_config(self): """ configuring ip for host and peer interfaces """ for (host_intf, net_id) in zip(self.host_intfs, self.net_ids): ip_addr = "%s.1.1.%s" % (net_id, self.host_ip.split('.')[-1]) networkinterface = NetworkInterface(host_intf, self.localhost) try: networkinterface.add_ipaddr(ip_addr, self.netmask) networkinterface.save(ip_addr, self.netmask) except Exception: networkinterface.save(ip_addr, self.netmask) networkinterface.bring_up() for (peer_intf, net_id) in zip(self.peer_intfs, self.net_ids): ip_addr = "%s.1.1.%s" % (net_id, self.peer_ip.split('.')[-1]) cmd = "ip addr add dev %s %s/%s" % (peer_intf, ip_addr, self.netmask) self.run_command(cmd) cmd = "ip link set dev %s up" % peer_intf self.run_command(cmd)
def test_add_logical_device(self): ''' test to create logical sriov device ''' for slot, port, mac, ipaddr, netmask, peer_ip in zip( self.sriov_adapter, self.sriov_port, self.mac_id, self.ipaddr, self.netmask, self.peer_ip): self.device_add_remove(slot, port, mac, '', 'add') if not self.list_device(mac): self.fail("failed to list logical device after add operation") device = self.find_device(mac) networkinterface = NetworkInterface(device, self.local) networkinterface.add_ipaddr(ipaddr, netmask) networkinterface.bring_up() if networkinterface.ping_check(peer_ip, count=5) is not None: self.fail("ping check failed")
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") 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 in peer")
class SwitchTest(Test): ''' switch port test ''' def setUp(self): ''' To get all the parameter for the test ''' 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="") 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.peer = self.params.get("peer_ip") if not self.peer: self.cancel("No peer provided") if self.networkinterface.ping_check(self.peer, count=2) is not None: self.cancel("No connection to peer") self.switch_name = self.params.get("switch_name", '*', default="") self.userid = self.params.get("userid", '*', default="") self.password = self.params.get("password", '*', default="") self.port_id = self.params.get("port_id", default="") if not self.port_id: self.cancel("user should specify port id") self.switch_login(self.switch_name, self.userid, self.password) def switch_login(self, ip, username, password): ''' Login method for remote fc switch ''' self.tnc = paramiko.SSHClient() self.tnc.set_missing_host_key_policy(paramiko.AutoAddPolicy()) self.tnc.connect(ip, username=username, password=password, look_for_keys=False, allow_agent=False) self.log.info("SSH connection established to " + ip) self.remote_conn = self.tnc.invoke_shell() self.log.info("Interactive SSH session established") assert self.remote_conn self.remote_conn.send("iscli" + '\n') def _send_only_result(self, command, response): output = response.decode("utf-8").splitlines() if command in output[0]: output.pop(0) output.pop() output = [element.lstrip() + '\n' for element in output] response = ''.join(output) response = response.strip() self.log.info(''.join(response)) return ''.join(response) def run_switch_command(self, command, timeout=300): ''' Run command method for running commands on fc switch ''' self.prompt = "#" self.log.info("Running the %s command on fc/nic switch", command) if not hasattr(self, 'tnc'): self.fail("telnet connection to the fc/nic switch not yet done") self.remote_conn.send(command + '\n') response = self.remote_conn.recv(1000) return self._send_only_result(command, response) def test(self): ''' switch port enable and disable test ''' self.log.info("Enabling the privilege mode") self.run_switch_command("enable") self.log.info("Entering configuration mode") self.run_switch_command("conf t") cmd = "interface port %s" % self.port_id self.run_switch_command(cmd) self.run_switch_command("shutdown") time.sleep(5) if self.networkinterface.ping_check(self.peer, count=5) is None: self.fail("pinging after disable port") self.run_switch_command("no shutdown") time.sleep(5) if self.networkinterface.ping_check(self.peer, count=5) is not None: self.fail("ping test failed") self.run_switch_command("end") def tearDown(self): ''' unset ip address ''' self.networkinterface.remove_ipaddr(self.ipaddr, self.netmask) self.networkinterface.restore_from_backup()
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")
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()