From e93342ccd9c90eba6a3057acb8f6b859a7f057b2 Mon Sep 17 00:00:00 2001 From: Tasmiya Nalatwad Date: Mon, 1 Apr 2024 18:01:01 +0530 Subject: [PATCH] Adapting the new changes made in htx setup/configuration. The build_net multisystem command introduced is for automatic configuration of network interfaces on both host and peer. The command set's the interfaces with some local net id's and pings the interfaces. The command also starts the htx deamon creates/selects and activates net.mdt for the network devices. No need to explicitely start the htx deamon or create/select or activate net.mdt file. Also removing the code that was supporting the old htx network topology and made compatible to new configuration changes. Signed-off-by: Tasmiya Nalatwad --- io/net/htx_nic_devices.py | 634 ++++-------------- .../htx_nic_devices.yaml | 4 - 2 files changed, 113 insertions(+), 525 deletions(-) diff --git a/io/net/htx_nic_devices.py b/io/net/htx_nic_devices.py index a7bf1831f..7acb5c8b0 100755 --- a/io/net/htx_nic_devices.py +++ b/io/net/htx_nic_devices.py @@ -18,14 +18,12 @@ import os import re import time +import shutil from avocado import Test from avocado.utils import distro from avocado.utils import process from avocado.utils.software_manager.manager import SoftwareManager -from avocado.utils import build -from avocado.utils import archive -from avocado.utils.process import CmdError from avocado.utils.network.interfaces import NetworkInterface from avocado.utils.network.hosts import LocalHost, RemoteHost from avocado.utils.ssh import Session @@ -61,15 +59,6 @@ def setUp(self): self.localhost = LocalHost() self.parameters() - 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.host_distro_name = self.host_distro.name self.host_distro_version = self.host_distro.version @@ -80,6 +69,21 @@ def setUp(self): self.remotehost = RemoteHost(self.peer_ip, self.peer_user, password=self.peer_password) + if 'start' in str(self.name.name): + # Flush out the ip addresses on host before starting the test + for interface in self.host_intfs: + cmd = 'ip addr flush dev %s' % interface + process.run(cmd, shell=True, sudo=True, ignore_status=True) + cmd = 'ip link set dev %s up' % interface + process.run(cmd, shell=True, sudo=True, ignore_status=True) + + # Flush out the ip addresses on peer before starting the test + for peer_interface in self.peer_intfs: + cmd = 'ip addr flush dev %s' % peer_interface + self.session.cmd(cmd) + cmd = 'ip link set dev %s up' % peer_interface + self.session.cmd(cmd) + self.get_peer_distro() self.get_peer_distro_version() self.htx_rpm_link = self.params.get('htx_rpm_link', default=None) @@ -133,78 +137,74 @@ def build_htx(self): self.cancel( "Unable to install the package %s on peer machine" % pkg) - if self.htx_rpm_link: - if self.host_distro_name and self.peer_distro == "SuSE": - self.host_distro_name = self.peer_distro = "sles" - - host_distro_pattern = "%s%s" % ( - self.host_distro_name, - self.host_distro_version) - peer_distro_pattern = "%s%s" % ( - self.peer_distro, - self.peer_distro_version) - patterns = [host_distro_pattern, peer_distro_pattern] - for pattern in patterns: - temp_string = process.getoutput( - "curl --silent %s" % (self.htx_rpm_link), - verbose=False, shell=True, ignore_status=True) - matching_htx_versions = re.findall( - r"(?<=\>)htx\w*[-]\d*[-]\w*[.]\w*[.]\w*", str(temp_string)) - distro_specific_htx_versions = [htx_rpm - for htx_rpm - in matching_htx_versions - if pattern in htx_rpm] - distro_specific_htx_versions.sort(reverse=True) - self.latest_htx_rpm = distro_specific_htx_versions[0] - - if pattern == host_distro_pattern: - if process.system('rpm -ivh --nodeps %s%s ' - '--force' % ( - self.htx_rpm_link, self.latest_htx_rpm - ), shell=True, ignore_status=True): - self.cancel("Installion of rpm failed") - - if pattern == peer_distro_pattern: - cmd = ('rpm -ivh --nodeps %s%s ' - '--force' % (self.htx_rpm_link, - self.latest_htx_rpm)) - output = self.session.cmd(cmd) - if not output.exit_status == 0: - self.cancel("Unable to install the package %s %s" - " on peer machine" % (self.htx_rpm_link, - self.latest_htx_rpm)) - else: - url = "https://github.com/open-power/HTX/archive/master.zip" - tarball = self.fetch_asset("htx.zip", locations=[url], expire='7d') - archive.extract(tarball, self.teststmpdir) - htx_path = os.path.join(self.teststmpdir, "HTX-master") - os.chdir(htx_path) - - exercisers = ["hxecapi_afu_dir", "hxecapi", "hxeocapi"] - if not smm.check_installed('dapl-devel'): - exercisers.append("hxedapl") - for exerciser in exercisers: - process.run("sed -i 's/%s//g' %s/bin/Makefile" % (exerciser, - htx_path)) - build.make(htx_path, extra_args='all') - build.make(htx_path, extra_args='tar') - process.run('tar --touch -xvzf htx_package.tar.gz') - os.chdir('htx_package') - if process.system('./installer.sh -f'): - self.fail("Installation of htx fails:please refer job.log") - - # Installing htx on peer - self.session.cmd("wget %s -O /tmp/master.zip" % url) - self.session.cmd("cd /tmp") - self.session.cmd("unzip master.zip") - self.session.cmd("cd HTX-master") - for exerciser in exercisers: - self.session.cmd("sed -i 's/%s//g' bin/Makefile" % exerciser) - self.session.cmd("make all") - self.session.cmd("make tar") - self.session.cmd("tar --touch -xvzf htx_package.tar.gz") - self.session.cmd("cd htx_package") - self.session.cmd("./installer.sh -f") + # Deleting old htx rpms as sometimes the old rpm packages doesn't + # support the latest htx changes. Also old multiple htx rpms must be + # deleted before starting the htx on multisystems for NIC devices + ins_htx = process.system_output('rpm -qa | grep htx', shell=True, + sudo=True, ignore_status=True) + ins_htx = ins_htx.decode("utf-8").splitlines() + if ins_htx: + for rpm in ins_htx: + process.run("rpm -e %s" % rpm, shell=True, sudo=True, + ignore_status=True, timeout=30) + if os.path.exists('/usr/lpp/htx'): + shutil.rmtree('/usr/lpp/htx') + self.log.info("Deleted old htx rpm packages from host") + + peer_ins_htx = self.session.cmd('rpm -qa | grep htx') + peer_ins_htx = peer_ins_htx.stdout.decode("utf-8").splitlines() + if peer_ins_htx: + for rpm in peer_ins_htx: + self.session.cmd('rpm -e %s' % rpm) + self.log.info("Deleted old htx rpm package from peer") + + if self.host_distro_name and self.peer_distro == "SuSE": + self.host_distro_name = self.peer_distro = "sles" + + host_distro_pattern = "%s%s" % ( + self.host_distro_name, + self.host_distro_version) + peer_distro_pattern = "%s%s" % ( + self.peer_distro, + self.peer_distro_version) + patterns = [host_distro_pattern, peer_distro_pattern] + for pattern in patterns: + temp_string = process.getoutput( + "curl --silent %s" % (self.htx_rpm_link), + verbose=False, shell=True, ignore_status=True) + matching_htx_versions = re.findall( + r"(?<=\>)htx\w*[-]\d*[-]\w*[.]\w*[.]\w*", str(temp_string)) + distro_specific_htx_versions = [htx_rpm + for htx_rpm + in matching_htx_versions + if pattern in htx_rpm] + distro_specific_htx_versions.sort(reverse=True) + self.latest_htx_rpm = distro_specific_htx_versions[0] + + cmd = ('rpm -ivh --nodeps %s%s ' + '--force' % (self.htx_rpm_link, + self.latest_htx_rpm)) + # If host and peer distro is same then perform installation + # only one time. This check is to avoid multiple times installation + if host_distro_pattern == peer_distro_pattern: + if process.system(cmd, shell=True, ignore_status=True): + self.cancel("Installion of rpm failed") + output = self.session.cmd(cmd) + if not output.exit_status == 0: + self.cancel("Unable to install the package %s %s" + " on peer machine" % (self.htx_rpm_link, + self.latest_htx_rpm)) + break + if pattern == host_distro_pattern: + if process.system(cmd, shell=True, ignore_status=True): + self.cancel("Installion of rpm failed") + + if pattern == peer_distro_pattern: + output = self.session.cmd(cmd) + if not output.exit_status == 0: + self.cancel("Unable to install the package %s %s" + " on peer machine" % (self.htx_rpm_link, + self.latest_htx_rpm)) def parameters(self): self.host_intfs = [] @@ -219,20 +219,18 @@ def parameters(self): for device in devices.split(" "): if device in interfaces: self.host_intfs.append(device) - elif self.localhost.validate_mac_addr(device) and device in self.localhost.get_all_hwaddr(): - self.host_intfs.append(self.localhost.get_interface_by_hwaddr(device).name) + elif self.localhost.validate_mac_addr( + device) and device in self.localhost.get_all_hwaddr(): + self.host_intfs.append(self.localhost.get_interface_by_hwaddr( + device).name) else: self.cancel("Please check the network device") self.peer_intfs = self.params.get("peer_interfaces", '*', default=None).split(" ") - self.net_ids = self.params.get("net_ids", '*', default=None).split(" ") self.mdt_file = self.params.get("mdt_file", '*', default="net.mdt") self.time_limit = int(self.params.get("time_limit", '*', default=2)) * 60 self.query_cmd = "htxcmdline -query -mdt %s" % self.mdt_file - self.ipaddr = self.params.get("host_ips", default="").split(" ") - self.netmask = self.params.get("netmask", default="") - self.peer_ips = self.params.get("peer_ips", default="").split(" ") self.htx_url = self.params.get("htx_rpm", default="") def test_start(self): @@ -243,7 +241,7 @@ def test_start(self): Phase 2: Start the HTX setup & execution of test. """ self.build_htx() - self.setup_htx_nic() + self.htx_configuration() self.run_htx() def test_check(self): @@ -252,340 +250,40 @@ def test_check(self): def test_stop(self): self.htx_cleanup() - def setup_htx_nic(self): - self.update_host_peer_names() - self.generate_bpt_file() - self.check_bpt_file_existence() - self.update_otherids_in_bpt() - self.update_net_ids_in_bpt() - self.htx_configure_net() - - def update_host_peer_names(self): - """ - Update hostname & ip of both Host & Peer in /etc/hosts file of both - Host & Peer - """ - host_name = process.system_output("hostname", - ignore_status=True, - shell=True, - sudo=True).decode("utf-8") - cmd = "hostname" - output = self.session.cmd(cmd) - peer_name = output.stdout.decode("utf-8") - hosts_file = '/etc/hosts' - self.log.info("Updating hostname of both Host & Peer in \ - %s file", hosts_file) - with open(hosts_file, 'r') as file: - filedata = file.read().splitlines() - search_str1 = "%s %s.*" % (self.host_ip, host_name) - search_str2 = "%s %s.*" % (self.peer_ip, peer_name) - add_str1 = "%s %s" % (self.host_ip, host_name) - add_str2 = "%s %s" % (self.peer_ip, peer_name) - - for index, line in enumerate(filedata): - filedata[index] = line.replace('\t', ' ') - - filedata = "\n".join(filedata) - obj = re.search(search_str1, filedata) - if not obj: - filedata = "%s\n%s" % (filedata, add_str1) - - obj = re.search(search_str2, filedata) - if not obj: - filedata = "%s\n%s" % (filedata, add_str2) - - with open(hosts_file, 'w') as file: - for line in filedata: - file.write(line) - - destination = "%s:/etc" % self.peer_ip - output = self.session.copy_files(hosts_file, destination) - if not output: - self.fail("unable to copy the file into peer machine") - - def generate_bpt_file(self): - """ - Generates bpt file in both Host & Peer - """ - self.log.info("Generating bpt file in both Host & Peer") - cmd = "/usr/bin/build_net help n" - self.session.cmd(cmd) - exit_code = process.run( - cmd, shell=True, sudo=True, ignore_status=True).exit_status - if exit_code == 0 or exit_code == 43: - return True - else: - self.fail("Command %s failed with exit status %s " % - (cmd, exit_code)) - - def check_bpt_file_existence(self): + def htx_configuration(self): """ - Verifies the bpt file existence in both Host & Peer + The function is to setup network topology for htx run + on both host and peer. + The build_net multisystem command + configures the netwrok interfaces on both host and peer Lpars with + some random net_ids and check pingum and also + starts the htx deamon for net.mdt + There is no need to explicitly start the htx deamon, create/select + nd activate for net.mdt """ - self.bpt_file = '/usr/lpp/htx/bpt' - cmd = "ls %s" % self.bpt_file - res = self.session.cmd(cmd) - if "No such file or directory" in res.stdout.decode("utf-8"): - self.fail("bpt file not generated in peer lpar") - try: - process.run(cmd, shell=True, sudo=True) - except CmdError as details: - msg = "Command %s failed %s, bpt file %s doesn't \ - exist in host" % (cmd, details, self.bpt_file) - self.fail(msg) - - def update_otherids_in_bpt(self): - """ - Update host ip in peer bpt file & peer ip in host bpt file - """ - # Update other id's in host lpar - with open(self.bpt_file, 'r') as file: - filedata = file.read() - search_str1 = "other_ids=%s:" % self.host_ip - replace_str1 = "%s%s" % (search_str1, self.peer_ip) - - filedata = re.sub(search_str1, replace_str1, filedata) - with open(self.bpt_file, 'w') as file: - for line in filedata: - file.write(line) - - # Update other id's in peer lpar - search_str2 = "other_ids=%s:" % self.peer_ip - replace_str2 = "%s%s" % (search_str2, self.host_ip) - self.session.cmd("hostname") - filedata = self.session.cmd("cat %s" % self.bpt_file) - filedata = filedata.stdout.decode("utf-8") - filedata = filedata.splitlines() - - for index, line in enumerate(filedata): - obj = re.search(search_str2, line) - if obj: - filedata[index] = replace_str2 - break - - else: - self.fail("Failed to get other_ids string in peer lpar") + self.log.info("Setting up the Network configuration on Host and Peer") - filedata = "\n".join(filedata) - self.session.cmd("echo \"%s\" > %s" % (filedata, self.bpt_file)) - self.session.cmd("cat %s" % self.bpt_file) - - def update_net_ids_in_bpt(self): - """ - Update net id's in both Host & Peer bpt file for both N/W interfaces - """ - # Update net id in host lpar - with open(self.bpt_file, 'r') as file: - filedata = file.read() - for (host_intf, net_id) in zip(self.host_intfs, self.net_ids): - search_str = "%s n" % host_intf - replace_str = "%s %s" % (host_intf, net_id) - filedata = re.sub(search_str, replace_str, filedata) - with open(self.bpt_file, 'w') as file: - for line in filedata: - file.write(line) - - # Update net id in peer lpar - filedata = self.session.cmd("cat %s" % self.bpt_file) - filedata = filedata.stdout.decode("utf-8") - filedata = filedata.splitlines() - - for (peer_intf, net_id) in zip(self.peer_intfs, self.net_ids): - search_str = "%s n" % peer_intf - replace_str = "%s %s" % (peer_intf, net_id) - - for index, line in enumerate(filedata): - obj = re.search(search_str, line) - if obj: - string = re.sub(search_str, replace_str, line) - filedata[index] = string - break - - else: - self.fail("Failed to get %s net_id in peer bpt" % peer_intf) - - filedata = "\n".join(filedata) - self.session.cmd("echo \"%s\" > %s" % (filedata, self.bpt_file)) - - 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]) - peer_networkinterface = NetworkInterface( - peer_intf, self.remotehost) - peer_networkinterface.add_ipaddr(ip_addr, self.netmask) - peer_networkinterface.bring_up() - - def htx_configure_net(self): - self.log.info("Starting the N/W ping test for HTX in Host") - cmd = "build_net %s" % self.bpt_file + cmd = "build_net multisystem %s" % self.peer_ip output = process.system_output(cmd, ignore_status=True, shell=True, sudo=True) output = output.decode("utf-8") host_obj = re.search("All networks ping Ok", output) - # Try up to 10 times until pingum test passes - for count in range(11): - if count == 0: - try: - peer_output = self.session.cmd(cmd) - peer_output = peer_output.stdout.decode("utf-8") - peer_obj = re.search("All networks ping Ok", peer_output) - except Exception: - self.log.info("build_net command failed in peer") + # try up to 3 times if the command fails to set the network interfaces + for i in range(3): if host_obj is not None: - if self.peer_distro == "rhel": - self.session.cmd("systemctl start NetworkManager") - else: - self.session.cmd("systemctl restart network") - if self.host_distro == "rhel": - process.system("systemctl start NetworkManager", - shell=True, - ignore_status=True) - else: - process.system("systemctl restart network", shell=True, - ignore_status=True) - output = process.system_output("pingum", ignore_status=True, - shell=True, sudo=True) - else: - break - time.sleep(30) - else: - self.log.info("manually configuring ip because of pingum failed.") - self.ip_config() - - self.log.info("Starting the N/W ping test for HTX in Peer") - for count in range(11): - if peer_obj is not None: - try: - self.session.cmd("pingum") - except Exception: - self.log.info("Pingum failed on peer lpar") - else: + self.log.info("Htx setup was successful on host and peer") break - time.sleep(30) - - self.log.info("N/W ping test for HTX passed in both Host & Peer") + output = process.system_output('pingum', ignore_status=True, + shell=True, sudo=True) + output = output.decode("utf-8") + ping_obj = re.search("All networks ping Ok", output) + if ping_obj is None: + self.fail("Failed to set htx configuration on host and peer") def run_htx(self): - self.start_htx_deamon() - self.shutdown_active_mdt() - self.generate_mdt_files() - self.select_net_mdt() - self.query_net_devices_in_mdt() - self.suspend_all_net_devices() - self.activate_mdt() - self.is_net_devices_active() self.start_htx_run() - def start_htx_deamon(self): - cmd = '/usr/lpp/htx/etc/scripts/htxd_run' - self.log.info("Starting the HTX Deamon in Host") - process.run(cmd, shell=True, sudo=True) - - self.log.info("Starting the HTX Deamon in Peer") - self.session.cmd(cmd) - - def generate_mdt_files(self): - self.log.info("Generating mdt files in Host") - cmd = "htxcmdline -createmdt" - process.run(cmd, shell=True, sudo=True) - - self.log.info("Generating mdt files in Peer") - self.session.cmd(cmd) - - def select_net_mdt(self): - self.log.info("Selecting the htx %s file in Host", self.mdt_file) - cmd = "htxcmdline -select -mdt %s" % self.mdt_file - process.run(cmd, shell=True, sudo=True) - - self.log.info("Selecting the htx %s file in Peer", self.mdt_file) - self.session.cmd(cmd) - - def query_net_devices_in_mdt(self): - self.is_net_devices_in_host_mdt() - self.is_net_devices_in_peer_mdt() - - def is_net_devices_in_host_mdt(self): - ''' - verifies the presence of given net devices in selected mdt file - ''' - self.log.info("Checking host_interfaces presence in %s", - self.mdt_file) - output = process.system_output(self.query_cmd, shell=True, - sudo=True).decode("utf-8") - absent_devices = [] - for intf in self.host_intfs: - if intf not in output: - absent_devices.append(intf) - if absent_devices: - self.log.info("net_devices %s are not avalable in host %s ", - absent_devices, self.mdt_file) - self.fail("HTX fails to list host n/w interfaces") - - self.log.info("Given host net interfaces %s are available in %s", - self.host_intfs, self.mdt_file) - - def is_net_devices_in_peer_mdt(self): - ''' - verifies the presence of given net devices in selected mdt file - ''' - self.log.info("Checking peer_interfaces presence in %s", - self.mdt_file) - output = self.session.cmd(self.query_cmd) - output = output.stdout.decode("utf-8") - absent_devices = [] - for intf in self.peer_intfs: - if intf not in output: - absent_devices.append(intf) - if absent_devices: - self.log.info("net_devices %s are not avalable in peer %s ", - absent_devices, self.mdt_file) - self.fail("HTX fails to list peer n/w interfaces") - - self.log.info("Given peer net interfaces %s are available in %s", - self.peer_intfs, self.mdt_file) - - def activate_mdt(self): - self.log.info("Activating the N/W devices with mdt %s in Host", - self.mdt_file) - cmd = "htxcmdline -activate all -mdt %s" % self.mdt_file - try: - process.run(cmd, shell=True, sudo=True) - except CmdError as details: - self.log.debug("Activation of N/W devices (%s) failed in Host", - self.mdt_file) - self.fail("Command %s failed %s" % (cmd, details)) - - self.log.info("Activating the N/W devices with mdt %s in Peer", - self.mdt_file) - try: - self.session.cmd(cmd) - except Exception: - self.log.debug("Activation of N/W devices (%s) failed in Peer", - self.mdt_file) - self.fail("Command %s failed" % cmd) - - def is_net_devices_active(self): - if not self.is_net_device_active_in_host(): - self.fail("Net devices are failed to activate in Host \ - after HTX activate") - if not self.is_net_device_active_in_peer(): - self.fail("Net devices are failed to activate in Peer \ - after HTX activate") - def start_htx_run(self): self.log.info("Running the HTX for %s on Host", self.mdt_file) cmd = "htxcmdline -run -mdt %s" % self.mdt_file @@ -633,71 +331,6 @@ def shutdown_active_mdt(self): if not output.exit_status == 0: pass - def suspend_all_net_devices(self): - self.suspend_all_net_devices_in_host() - self.suspend_all_net_devices_in_peer() - - def suspend_all_net_devices_in_host(self): - ''' - Suspend the Net devices, if active. - ''' - self.log.info("Suspending net_devices in host if any running") - self.susp_cmd = "htxcmdline -suspend all -mdt %s" % self.mdt_file - process.run(self.susp_cmd, ignore_status=True, shell=True, sudo=True) - - def suspend_all_net_devices_in_peer(self): - ''' - Suspend the Net devices, if active. - ''' - self.log.info("Suspending net_devices in peer if any running") - cmd = "htxcmdline -suspend all -mdt %s" % self.mdt_file - output = self.session.cmd(cmd) - if not output.exit_status == 0: - pass - - def is_net_device_active_in_host(self): - ''' - Verifies whether the net devices are active or not in host - ''' - self.log.info("Checking whether all net_devices are active or \ - not in host ") - output = process.system_output(self.query_cmd, ignore_status=True, - shell=True, - sudo=True).decode("utf-8").split('\n') - active_devices = [] - for line in output: - for intf in self.host_intfs: - if intf in line and 'ACTIVE' in line: - active_devices.append(intf) - non_active_device = list(set(self.host_intfs) - set(active_devices)) - if non_active_device: - return False - else: - self.log.info("Active N/W devices in Host %s", active_devices) - return True - - def is_net_device_active_in_peer(self): - ''' - Verifies whether the net devices are active or not in peer - ''' - self.log.info("Checking whether all net_devices are active or \ - not in peer") - output = self.session.cmd(self.query_cmd) - if not output.exit_status == 0: - pass - active_devices = [] - output = output.stdout.decode("utf-8").splitlines() - for line in output: - for intf in self.peer_intfs: - if intf in line and 'ACTIVE' in line: - active_devices.append(intf) - non_active_device = list(set(self.peer_intfs) - set(active_devices)) - if non_active_device: - return False - else: - self.log.info("Active N/W devices in Peer %s", active_devices) - return True - def shutdown_htx_daemon(self): status_cmd = '/usr/lpp/htx/etc/scripts/htx.d status' shutdown_cmd = '/usr/lpp/htx/etc/scripts/htxd_shutdown' @@ -719,69 +352,28 @@ def shutdown_htx_daemon(self): if not output.exit_status == 0: pass - def clean_state(self): - ''' - Reset bpt, suspend and shutdown the active mdt - ''' - self.log.info("Resetting bpt file in both Host & Peer") - cmd = "/usr/bin/build_net help n" - self.session.cmd(cmd) - exit_code = process.run( - cmd, shell=True, sudo=True, ignore_status=True).exit_status - if exit_code == 0 or exit_code == 43: - return True - else: - self.fail("Command %s failed with exit status %s " % - (cmd, exit_code)) - - if self.is_net_device_active_in_host(): - self.suspend_all_net_devices_in_host() - self.log.info("Shutting down the %s in host", self.mdt_file) - cmd = 'htxcmdline -shutdown -mdt %s' % self.mdt_file - process.system(cmd, timeout=120, ignore_status=True, - shell=True, sudo=True) - if self.is_net_device_active_in_peer(): - self.suspend_all_net_devices_in_peer() - self.log.info("Shutting down the %s in peer", self.mdt_file) - try: - output = self.session.cmd(cmd) - except Exception: - self.log.info("Unable to shutdown the mdt") - if not output.exit_status == 0: - pass - - self.session.cmd("rm -rf /tmp/HTX-master") - def ip_restore_host(self): ''' restoring ip for host ''' - for ipaddr, interface in zip(self.ipaddr, self.host_intfs): + for interface in 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 ip_restore_peer(self): ''' config ip for peer ''' - for ip, interface in zip(self.peer_ips, self.peer_intfs): + for interface in self.peer_intfs: + cmd = "ip addr flush %s" % interface + self.session.cmd(cmd) peer_networkinterface = NetworkInterface( interface, self.remotehost) - try: - cmd = "ip addr flush %s" % interface - self.session.cmd(cmd) - peer_networkinterface.add_ipaddr(ip, self.netmask) - peer_networkinterface.save(ip, self.netmask) - except Exception: - peer_networkinterface.save(ip, self.netmask) peer_networkinterface.bring_up() def htx_cleanup(self): - self.clean_state() self.shutdown_htx_daemon() self.ip_restore_host() self.ip_restore_peer() diff --git a/io/net/htx_nic_devices.py.data/htx_nic_devices.yaml b/io/net/htx_nic_devices.py.data/htx_nic_devices.yaml index 891036322..3ced82d0c 100644 --- a/io/net/htx_nic_devices.py.data/htx_nic_devices.yaml +++ b/io/net/htx_nic_devices.py.data/htx_nic_devices.yaml @@ -5,10 +5,6 @@ peer_password: "*******" peer_user: "root" htx_host_interfaces: "" peer_interfaces: "" -host_ips: "" -netmask: "" -peer_ips: "" -net_ids: "" # time limit in minutes time_limit: 2 htx_rpm_link: ""