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): 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): """ 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): ''' 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 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 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(["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_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) 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) remotehost_public = RemoteHost(self.peer_public_ip, self.peer_user, password=self.peer_password) self.peer_public_networkinterface = NetworkInterface( self.peer_interface, 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 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 test_bridge_run(self): ''' run bridge test ''' local = LocalHost() networkinterface = NetworkInterface(self.bridge_interface, local, if_type="Bridge") networkinterface.add_ipaddr(self.ipaddr, self.netmask) networkinterface.bring_up() networkinterface.save(self.ipaddr, self.netmask) if networkinterface.ping_check(self.peer_ip, count=5) is not None: self.fail('Ping using bridge failed') networkinterface.remove_ipaddr(self.ipaddr, self.netmask)
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 setUp(self): ''' set up required packages and gather necessary test inputs ''' smm = SoftwareManager() packages = [ 'src', 'rsct.basic', 'rsct.core.utils', 'rsct.core', 'DynamicRM', 'powerpc-utils' ] for pkg in packages: if not smm.check_installed(pkg) and not smm.install(pkg): self.cancel('%s is needed for the test to be run' % pkg) self.hmc_ip = self.get_mcp_component("HMCIPAddr") if not self.hmc_ip: self.cancel("HMC IP not got") self.hmc_pwd = self.params.get("hmc_pwd", '*', default=None) self.hmc_username = self.params.get("hmc_username", '*', default=None) self.lpar = self.get_partition_name("Partition Name") if not self.lpar: self.cancel("LPAR Name not got from lparstat command") self.session = Session(self.hmc_ip, user=self.hmc_username, password=self.hmc_pwd) if not self.session.connect(): self.cancel("failed connetion to HMC") cmd = 'lssyscfg -r sys -F name' output = self.session.cmd(cmd) self.server = '' for line in output.stdout_text.splitlines(): if line in self.lpar: self.server = line break if not self.server: self.cancel("Managed System not got") self.sriov_adapter = self.params.get('sriov_adapter', '*', default=None).split(' ') self.sriov_port = self.params.get('sriov_port', '*', default=None).split(' ') self.ipaddr = self.params.get('ipaddr', '*', default="").split(' ') self.netmask = self.params.get('netmasks', '*', default="").split(' ') self.peer_ip = self.params.get('peer_ip', '*', default="").split(' ') self.mac_id = self.params.get('mac_id', default="02:03:03:03:03:01").split(' ') self.mac_id = [mac.replace(':', '') for mac in self.mac_id] self.local = LocalHost()
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 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()
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 setUp(self): ''' set up required packages and gather necessary test inputs ''' self.install_packages() self.hmc_ip = self.get_mcp_component("HMCIPAddr") if not self.hmc_ip: self.cancel("HMC IP not got") self.hmc_pwd = self.params.get("hmc_pwd", '*', default=None) self.hmc_username = self.params.get("hmc_username", '*', default=None) self.lpar = self.get_partition_name("Partition Name") if not self.lpar: self.cancel("LPAR Name not got from lparstat command") self.session_hmc = Session(self.hmc_ip, user=self.hmc_username, password=self.hmc_pwd) if not self.session_hmc.connect(): self.cancel("failed connecting to HMC") cmd = 'lssyscfg -r sys -F name' output = self.session_hmc.cmd(cmd) self.server = '' for line in output.stdout_text.splitlines(): if line in self.lpar: self.server = line break if not self.server: self.cancel("Managed System not got") self.slot_num = self.params.get("slot_num", '*', default=None) self.slot_num = self.slot_num.split(' ') for slot in self.slot_num: if int(slot) < 3 or int(slot) > 2999: self.cancel("Slot invalid. Valid range: 3 - 2999") self.vios_name = self.params.get("vios_names", '*', default=None).split(' ') self.sriov_port = self.params.get("sriov_ports", '*', default=None).split(' ') self.backing_adapter = self.params.get("sriov_adapters", '*', default=None).split(' ') if len(self.sriov_port) != len(self.backing_adapter): self.cancel('Backing Device counts and port counts differ') if len(self.vios_name) != len(self.backing_adapter): self.cancel('Backing Device counts and vios name counts differ') self.backingdev_count = len(self.backing_adapter) self.bandwidth = self.params.get("bandwidth", '*', default=None) self.vnic_priority = self.params.get("priority", '*', default=None) if not self.vnic_priority: self.vnic_priority = [50] * len(self.backing_adapter) else: self.vnic_priority = self.vnic_priority.split(' ') if len(self.vnic_priority) != len(self.backing_adapter): self.cancel('Backing Device counts and priority counts differ') self.auto_failover = self.params.get("auto_failover", '*', default=None) if self.auto_failover not in ['0', '1']: self.auto_failover = '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) if 'vios' in str(self.name.name): self.session = Session(self.vios_ip, user=self.vios_user, password=self.vios_pwd) self.session.connect() self.count = int(self.params.get('vnic_test_count', default="1")) self.num_of_dlpar = int(self.params.get("num_of_dlpar", default='1')) self.device_ip = self.params.get('device_ip', '*', default=None).split(' ') self.mac_id = self.params.get('mac_id', default="02:03:03:03:03:01").split(' ') self.mac_id = [mac.replace(':', '') for mac in self.mac_id] self.netmask = self.params.get('netmasks', '*', default=None).split(' ') self.peer_ip = self.params.get('peer_ip', default=None).split(' ') self.session_hmc.cmd("uname -a") cmd = 'lssyscfg -m ' + self.server + \ ' -r lpar --filter lpar_names=' + self.lpar + \ ' -F lpar_id' self.lpar_id = self.session_hmc.cmd(cmd).stdout_text.split()[0] self.vios_id = [] for vios_name in self.vios_name: cmd = 'lssyscfg -m ' + self.server + \ ' -r lpar --filter lpar_names=' + vios_name + \ ' -F lpar_id' self.vios_id.append( self.session_hmc.cmd(cmd).stdout_text.split()[0]) cmd = 'lshwres -m %s -r sriov --rsubtype adapter -F \ phys_loc:adapter_id' % self.server adapter_id_output = self.session_hmc.cmd(cmd).stdout_text self.backing_adapter_id = [] for backing_adapter in self.backing_adapter: for line in adapter_id_output.splitlines(): if str(backing_adapter) in line: self.backing_adapter_id.append(line.split(':')[1]) self.rsct_service_start() if len(self.slot_num) > 1: if 'backing' in str(self.name.name) or \ 'failover' in str(self.name.name): self.cancel("this test is not needed") self.local = LocalHost()
def setUp(self): ''' set up required packages and gather necessary test inputs ''' smm = SoftwareManager() packages = [ 'src', 'rsct.basic', 'rsct.core.utils', 'NetworkManager', 'rsct.core', 'DynamicRM', 'powerpc-utils' ] for pkg in packages: if not smm.check_installed(pkg) and not smm.install(pkg): self.cancel('%s is needed for the test to be run' % pkg) self.hmc_ip = self.get_mcp_component("HMCIPAddr") if not self.hmc_ip: self.cancel("HMC IP not got") self.hmc_pwd = self.params.get("hmc_pwd", '*', default=None) self.hmc_username = self.params.get("hmc_username", '*', default=None) self.lpar = self.get_partition_name("Partition Name") if not self.lpar: self.cancel("LPAR Name not got from lparstat command") self.session = Session(self.hmc_ip, user=self.hmc_username, password=self.hmc_pwd) if not self.session.connect(): self.cancel("failed connetion to HMC") cmd = 'lssyscfg -r sys -F name' output = self.session.cmd(cmd) self.server = '' for line in output.stdout_text.splitlines(): if line in self.lpar: self.server = line break if not self.server: self.cancel("Managed System not got") self.sriov_adapter = self.params.get('sriov_adapter', '*', default=None).split(' ') self.sriov_port = self.params.get('sriov_port', '*', default=None).split(' ') self.ipaddr = self.params.get('ipaddr', '*', default="").split(' ') self.netmask = self.params.get('netmasks', '*', default="").split(' ') self.prefix = self.netmask_to_cidr(self.netmask[0]) self.peer_ip = self.params.get('peer_ip', '*', default="").split(' ') self.mac_id = self.params.get('mac_id', default="02:03:03:03:03:01").split(' ') self.mac_id = [mac.replace(':', '') for mac in self.mac_id] self.migratable = self.params.get('migratable', '*', default=0) self.backup_device_type = self.params.get('backup_device_type', '*', default='') self.backup_device_slot_num = self.params.get('backup_device_slot_num', '*', default=None) self.backup_veth_vnetwork = self.params.get('backup_veth_vnetwork', '*', default=None) if 'vnic' in self.backup_device_type: self.vnic_sriov_adapter = self.params.get('vnic_sriov_adapter', '*', default=None) self.vnic_port_id = self.params.get('vnic_port_id', '*', default=None) self.vnic_adapter_id = self.get_adapter_id(self.vnic_sriov_adapter) self.priority = self.params.get('failover_priority', '*', default='50') self.max_capacity = self.params.get('max_capacity', '*', default='10') self.capacity = self.params.get('capacity', '*', default='2') self.vios_name = self.params.get('vios_name', '*', default=None) cmd = 'lssyscfg -m %s -r lpar --filter lpar_names=%s -F lpar_id' % ( self.server, self.vios_name) self.vios_id = self.session.cmd(cmd).stdout_text.split()[0] self.backup_vnic_backing_device = 'sriov/%s/%s/%s/%s/%s/%s/%s' % \ (self.vios_name, self.vios_id, self.vnic_adapter_id, self.vnic_port_id, self.capacity, self.priority, self.max_capacity) self.local = LocalHost()
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 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 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")
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 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 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 setUp(self): ''' set up required packages and gather necessary test inputs ''' self.install_packages() self.hmc_ip = self.get_mcp_component("HMCIPAddr") if not self.hmc_ip: self.cancel("HMC IP not got") self.hmc_pwd = self.params.get("hmc_pwd", '*', default=None) self.hmc_username = self.params.get("hmc_username", '*', default=None) self.lpar = self.get_partition_name("Partition Name") if not self.lpar: self.cancel("LPAR Name not got from lparstat command") 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) self.session_hmc = Session(self.hmc_ip, user=self.hmc_username, password=self.hmc_pwd) if not self.session_hmc.connect(): self.cancel("failed connecting to HMC") cmd = 'lssyscfg -r sys -F name' output = self.session_hmc.cmd(cmd) self.server = '' for line in output.stdout_text.splitlines(): if line in self.lpar: self.server = line break if not self.server: self.cancel("Managed System not got") self.slot_num = self.params.get("slot_num", '*', default=None) self.slot_num = self.slot_num.split(' ') for slot in self.slot_num: if int(slot) < 3 or int(slot) > 2999: self.cancel("Slot invalid. Valid range: 3 - 2999") self.vios_name = self.params.get("vios_names", '*', default=None).split(' ') self.sriov_port = self.params.get("sriov_ports", '*', default=None).split(' ') self.backing_adapter = self.params.get("sriov_adapters", '*', default=None).split(' ') if len(self.sriov_port) != len(self.backing_adapter): self.cancel('Backing Device counts and port counts differ') if len(self.vios_name) != len(self.backing_adapter): self.cancel('Backing Device counts and vios name counts differ') self.backingdev_count = len(self.backing_adapter) self.bandwidth = self.params.get("bandwidth", '*', default=None) self.vnic_priority = self.params.get("priority", '*', default=None) if not self.vnic_priority: self.vnic_priority = [50] * len(self.backing_adapter) else: self.vnic_priority = self.vnic_priority.split(' ') if len(self.vnic_priority) != len(self.backing_adapter): self.cancel('Backing Device counts and priority counts differ') self.auto_failover = self.params.get("auto_failover", '*', default=None) if self.auto_failover not in ['0', '1']: self.auto_failover = '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.count = int(self.params.get('vnic_test_count', default="1")) self.num_of_dlpar = int(self.params.get("num_of_dlpar", default='1')) self.device_ip = self.params.get('device_ip', '*', default=None).split(' ') self.mac_id = self.params.get('mac_id', default="02:03:03:03:03:01").split(' ') self.mac_id = [mac.replace(':', '') for mac in self.mac_id] self.netmask = self.params.get('netmasks', '*', default=None).split(' ') self.peer_ip = self.params.get('peer_ip', default=None).split(' ') dmesg.clear_dmesg() self.session_hmc.cmd("uname -a") cmd = 'lssyscfg -m ' + self.server + \ ' -r lpar --filter lpar_names=' + self.lpar + \ ' -F lpar_id' self.lpar_id = self.session_hmc.cmd(cmd).stdout_text.split()[0] self.vios_id = [] for vios_name in self.vios_name: cmd = 'lssyscfg -m ' + self.server + \ ' -r lpar --filter lpar_names=' + vios_name + \ ' -F lpar_id' self.vios_id.append( self.session_hmc.cmd(cmd).stdout_text.split()[0]) cmd = 'lshwres -m %s -r sriov --rsubtype adapter -F \ phys_loc:adapter_id' % self.server adapter_id_output = self.session_hmc.cmd(cmd).stdout_text self.backing_adapter_id = [] for backing_adapter in self.backing_adapter: for line in adapter_id_output.splitlines(): if str(backing_adapter) in line: self.backing_adapter_id.append(line.split(':')[1]) if not self.backing_adapter_id: self.cancel("SRIOV adapter provided was not found.") self.rsct_service_start() if len(self.slot_num) > 1: if 'backing' in str(self.name.name) or \ 'failover' in str(self.name.name): self.cancel("this test is not needed") self.local = LocalHost() cmd = "echo 'module ibmvnic +p; func send_subcrq -p' > /sys/kernel/debug/dynamic_debug/control" result = process.run(cmd, shell=True, ignore_status=True) if result.exit_status: self.fail("failed to enable debug mode")
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 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 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 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) 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) 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