def setUp(self):
"""
test parameters
"""
self.switch_name = self.params.get("switch_name", '*', default=None)
self.userid = self.params.get("userid", '*', default=None)
self.password = self.params.get("password", '*', default=None)
self.wwids = self.params.get("wwids", default=None).split(" ")
self.sbt = int(self.params.get("sbt", '*', default=10))
self.lbt = int(self.params.get("lbt", '*', default=250))
self.count = int(self.params.get("count", '*', default="2"))
self.prompt = ">"
self.verify_sleep_time = 20
self.port_ids = []
self.host = []
self.dic = {}
system_wwids = multipath.get_multipath_wwids()
for wwid in self.wwids:
paths = []
if wwid not in system_wwids:
self.wwids.remove(wwid)
continue
paths = multipath.get_paths(wwid)
for path in paths:
self.host.append(self.get_fc_host(path))
self.host = list(dict.fromkeys(self.host))
self.log.info("AllHostValues: %s" % self.host)
self.switch_login(self.switch_name, self.userid, self.password)
for host in self.host:
port_id = self.get_switch_port(host)
self.port_ids.append(port_id)
self.dic[port_id] = host
self.log.info("AllSwitchPorts:%s " % self.port_ids)
def setUp(self):
'''
Function for preliminary set-up to execute the test
'''
self.err_paths = []
self.device_list = []
smm = SoftwareManager()
for pkg in ["lsscsi", "pciutils"]:
if not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel("%s is not installed" % pkg)
self.wwids = self.params.get('wwids', default='')
self.pci_device = self.params.get("pci_devices", default='')
self.count = int(self.params.get("count", default=1))
system_pci_adress = pci.get_pci_addresses()
system_wwids = multipath.get_multipath_wwids()
if self.wwids:
self.wwids = self.wwids.split(' ')
for wwid in self.wwids:
if wwid not in system_wwids:
self.cancel("%s not present in the system", wwid)
for path in multipath.get_paths(wwid):
self.device_list.append(path)
elif self.pci_device:
self.pci_device = self.pci_device.split(' ')
for pci_id in self.pci_device:
if pci_id not in system_pci_adress:
self.cancel("%s not present in the system", pci_id)
cmd = "ls -l /dev/disk/by-path/"
output = process.system_output(cmd).decode('utf-8')
for line in output.splitlines():
if pci_id in line and 'part' not in line:
self.device_list.append(line.split('/')[-1])
else:
self.cancel("please provide pci adrees or wwids of scsi disk")
def setUp(self):
"""
Verifies if we have list of packages installed on OS
and also skips the test if user gives the current OS boot disk as
disk input it may erase the data
:param disk: test disk where the disk operations can be done
:param fs: type of filesystem to create
:param dir: path of the directory to mount the disk device
"""
smm = SoftwareManager()
pkg = ""
if 'ppc' not in platform.processor():
self.cancel("Processor is not ppc64")
self.disk = self.params.get('disk', default=None)
self.dirs = self.params.get('dir', default=self.workdir)
self.fstype = self.params.get('fs', default='ext4')
self.log.info("disk: %s, dir: %s, fstype: %s", self.disk, self.dirs,
self.fstype)
if not self.disk:
self.cancel("No disk input, please update yaml and re-run")
cmd = "df --output=source"
if self.disk in process.system_output(cmd, ignore_status=True) \
.decode("utf-8"):
self.cancel("Given disk is os boot disk,"
"it will be harmful to run this test")
pkg_list = ["lshw"]
self.distro = distro.detect().name
if self.distro == 'Ubuntu':
pkg_list.append("hwinfo")
if self.fstype == 'ext4':
pkg_list.append('e2fsprogs')
if self.fstype == 'xfs':
pkg_list.append('xfsprogs')
if self.fstype == 'btrfs':
ver = int(distro.detect().version)
rel = int(distro.detect().release)
if distro.detect().name == 'rhel':
if (ver == 7 and rel >= 4) or ver > 7:
self.cancel("btrfs is not supported with \
RHEL 7.4 onwards")
if self.distro == 'Ubuntu':
pkg_list.append("btrfs-tools")
for pkg in pkg_list:
if pkg and not smm.check_installed(pkg) and not smm.install(pkg):
self.cancel(
"Package %s is missing and could not be installed" % pkg)
self.disk_nodes = []
self.disk_base = os.path.basename(self.disk)
if multipath.is_mpath_dev(self.disk_base):
self.mpath = True
self.disk_abs = os.path.basename(os.readlink(self.disk))
mwwid = multipath.get_multipath_wwid(self.disk_base)
self.disk_nodes = multipath.get_paths(mwwid)
else:
self.mpath = False
self.disk_abs = self.disk_base
self.disk_nodes.append(self.disk_base)
def setUp(self):
"""
Set up.
"""
# Install needed packages
dist = distro.detect()
pkg_name = ""
svc_name = ""
if dist.name == 'Ubuntu':
pkg_name += "multipath-tools"
svc_name = "multipath-tools"
elif dist.name == 'SuSE':
pkg_name += "multipath-tools"
svc_name = "multipathd"
else:
pkg_name += "device-mapper-multipath"
svc_name = "multipathd"
smm = SoftwareManager()
if not smm.check_installed(pkg_name) and not smm.install(pkg_name):
self.skip("Can not install %s" % pkg_name)
# Create service object
self.mpath_svc = service.SpecificServiceManager(svc_name)
self.mpath_svc.restart()
# Check if multipath devices are present in system
self.wwids = multipath.get_multipath_wwids()
if self.wwids == ['']:
self.skip("No Multipath Devices")
# Take a backup of current config file
self.mpath_file = "/etc/multipath.conf"
if os.path.isfile(self.mpath_file):
shutil.copyfile(self.mpath_file, "%s.bkp" % self.mpath_file)
self.mpath_list = []
# Find all details of multipath devices
for wwid in self.wwids:
if wwid not in process.system_output('multipath -ll',
ignore_status=True,
shell=True):
continue
self.mpath_dic = {}
self.mpath_dic["wwid"] = wwid
self.mpath_dic["name"] = multipath.get_mpath_name(wwid)
self.mpath_dic["paths"] = multipath.get_paths(wwid)
self.mpath_dic["policy"] = multipath.get_policy(wwid)
self.mpath_dic["size"] = multipath.get_size(wwid)
self.mpath_list.append(self.mpath_dic)
pprint(self.mpath_list)
def setUp(self):
"""
Set up.
"""
# Install needed packages
dist = distro.detect()
pkg_name = ""
svc_name = ""
if dist.name == 'Ubuntu':
pkg_name += "multipath-tools"
svc_name = "multipath-tools"
elif dist.name == 'SuSE':
pkg_name += "multipath-tools"
svc_name = "multipathd"
else:
pkg_name += "device-mapper-multipath"
svc_name = "multipathd"
smm = SoftwareManager()
if not smm.check_installed(pkg_name) and not smm.install(pkg_name):
self.cancel("Can not install %s" % pkg_name)
# Create service object
self.mpath_svc = service.SpecificServiceManager(svc_name)
self.mpath_svc.restart()
# Check if multipath devices are present in system
self.wwids = multipath.get_multipath_wwids()
if self.wwids == ['']:
self.cancel("No Multipath Devices")
# Take a backup of current config file
self.mpath_file = "/etc/multipath.conf"
if os.path.isfile(self.mpath_file):
shutil.copyfile(self.mpath_file, "%s.bkp" % self.mpath_file)
self.mpath_list = []
# Find all details of multipath devices
for wwid in self.wwids:
if wwid not in process.system_output('multipath -ll',
ignore_status=True,
shell=True):
continue
self.mpath_dic = {}
self.mpath_dic["wwid"] = wwid
self.mpath_dic["name"] = multipath.get_mpath_name(wwid)
self.mpath_dic["paths"] = multipath.get_paths(wwid)
self.mpath_dic["policy"] = multipath.get_policy(wwid)
self.mpath_dic["size"] = multipath.get_size(wwid)
self.mpath_list.append(self.mpath_dic)
pprint(self.mpath_list)
def test(self):
"""
Tests Multipath.
"""
msg = ""
multipath.form_conf_mpath_file()
plcy = "path_selector \"%s 0\"" % self.policy
multipath.form_conf_mpath_file(defaults_extra=plcy)
for path_dic in self.mpath_list:
self.log.debug("operating on paths: %s", path_dic["paths"])
# Path Selector policy
self.log.info("changing Selector policy")
for policy in self.policies:
cmd = "path_selector \"%s 0\"" % policy
multipath.form_conf_mpath_file(defaults_extra=cmd)
if multipath.get_policy(path_dic["wwid"]) != policy:
msg += "%s for %s fails\n" % (policy, path_dic["wwid"])
# mutipath -f mpathX
if not multipath.flush_path(path_dic["name"]):
msg += "Flush of %s fails\n" % path_dic["name"]
self.mpath_svc.restart()
wait.wait_for(self.mpath_svc.status, timeout=10)
# Blacklisting wwid
self.log.info("Black listing WWIDs")
cmd = "wwid %s" % path_dic["wwid"]
multipath.form_conf_mpath_file(blacklist=cmd, defaults_extra=plcy)
if multipath.device_exists(path_dic["wwid"]):
msg += "Blacklist of %s fails\n" % path_dic["wwid"]
else:
multipath.form_conf_mpath_file(defaults_extra=plcy)
if not multipath.device_exists(path_dic["wwid"]):
msg += "Recovery of %s fails\n" % path_dic["wwid"]
# Blacklisting sdX
self.log.info("Black listing individual paths")
for disk in path_dic["paths"]:
cmd = "devnode %s" % disk
multipath.form_conf_mpath_file(blacklist=cmd,
defaults_extra=plcy)
if disk in multipath.get_paths(path_dic["wwid"]):
msg += "Blacklist of %s fails\n" % disk
multipath.form_conf_mpath_file(defaults_extra=plcy)
if msg:
self.fail("Some tests failed. Find details below:\n%s" % msg)
def test(self):
"""
Tests Multipath.
"""
msg = ""
multipath.form_conf_mpath_file()
for path_dic in self.mpath_list:
# mutipath -f mpathX
if not multipath.flush_path(path_dic["name"]):
msg += "Flush of %s fails\n" % path_dic["name"]
self.mpath_svc.restart()
# Path Selector policy
for policy in ["service-time", "round-robin", "queue-length"]:
cmd = "path_selector \"%s 0\"" % policy
multipath.form_conf_mpath_file(defaults_extra=cmd)
if multipath.get_policy(path_dic["wwid"]) != policy:
msg += "%s for %s fails\n" % (policy, path_dic["wwid"])
# Blacklist wwid
cmd = "wwid %s" % path_dic["wwid"]
multipath.form_conf_mpath_file(blacklist=cmd)
if multipath.device_exists(path_dic["wwid"]):
msg += "Blacklist of %s fails\n" % path_dic["wwid"]
else:
multipath.form_conf_mpath_file()
if not multipath.device_exists(path_dic["wwid"]):
msg += "Recovery of %s fails\n" % path_dic["wwid"]
# Blacklist sdX
for disk in path_dic["paths"]:
cmd = "devnode %s" % disk
multipath.form_conf_mpath_file(blacklist=cmd)
if disk in multipath.get_paths(path_dic["wwid"]):
msg += "Blacklist of %s fails\n" % disk
# Print errors
if msg:
msg = "Following Tests Failed\n" + msg
self.log.debug(msg)
self.fail("Some tests failed")
def setUp(self):
"""
Set up.
"""
self.policy = self.params.get('policy', default='service-time')
self.policies = ["service-time", "round-robin", "queue-length"]
# We will remove and add the policy back, so that this becomes
# the last member of the list. This is done so that in the
# policy change test later, this policy is set in the last
# iteration.
self.policies.remove(self.policy)
self.policies.append(self.policy)
# Install needed packages
dist = distro.detect()
pkg_name = ""
svc_name = ""
if dist.name == 'Ubuntu':
pkg_name += "multipath-tools"
svc_name = "multipath-tools"
elif dist.name == 'SuSE':
pkg_name += "multipath-tools"
svc_name = "multipathd"
else:
pkg_name += "device-mapper-multipath"
svc_name = "multipathd"
smm = SoftwareManager()
if not smm.check_installed(pkg_name) and not smm.install(pkg_name):
self.cancel("Can not install %s" % pkg_name)
# Check if given multipath devices are present in system
self.wwids = self.params.get('wwids', default='').split(',')
system_wwids = multipath.get_multipath_wwids()
wwids_to_remove = []
for wwid in self.wwids:
if wwid not in system_wwids:
self.log.info("%s not present in the system", wwid)
wwids_to_remove.append(wwid)
for wwid in wwids_to_remove:
self.wwids.remove(wwid)
if self.wwids == []:
self.cancel("No Multipath Devices Given")
# Create service object
self.mpath_svc = service.SpecificServiceManager(svc_name)
self.mpath_svc.restart()
wait.wait_for(self.mpath_svc.status, timeout=10)
# Take a backup of current config file
self.mpath_file = "/etc/multipath.conf"
if os.path.isfile(self.mpath_file):
shutil.copyfile(self.mpath_file, "%s.bkp" % self.mpath_file)
self.mpath_list = []
# Find all details of multipath devices
for wwid in self.wwids:
if wwid not in process.system_output('multipath -ll',
ignore_status=True,
shell=True).decode("utf-8"):
continue
self.mpath_dic = {}
self.mpath_dic["wwid"] = wwid
self.mpath_dic["name"] = multipath.get_mpath_name(wwid)
self.mpath_dic["paths"] = multipath.get_paths(wwid)
self.mpath_dic["policy"] = multipath.get_policy(wwid)
self.mpath_dic["size"] = multipath.get_size(wwid)
self.mpath_list.append(self.mpath_dic)
pprint(self.mpath_list)
def test(self):
"""
Tests Multipath.
"""
msg = ""
multipath.form_conf_mpath_file()
plcy = "path_selector \"%s 0\"" % self.policy
multipath.form_conf_mpath_file(defaults_extra=plcy)
for path_dic in self.mpath_list:
self.log.debug("operating on paths", path_dic["paths"])
# Path Selector policy
self.log.info("changing Selector policy")
for policy in self.policies:
cmd = "path_selector \"%s 0\"" % policy
multipath.form_conf_mpath_file(defaults_extra=cmd)
if multipath.get_policy(path_dic["wwid"]) != policy:
msg += "%s for %s fails\n" % (policy, path_dic["wwid"])
# mutipath -f mpathX
if not multipath.flush_path(path_dic["name"]):
msg += "Flush of %s fails\n" % path_dic["name"]
self.mpath_svc.restart()
wait.wait_for(self.mpath_svc.status, timeout=10)
# Blacklisting wwid
self.log.info("Black listing WWIDs")
cmd = "wwid %s" % path_dic["wwid"]
multipath.form_conf_mpath_file(blacklist=cmd, defaults_extra=plcy)
if multipath.device_exists(path_dic["wwid"]):
msg += "Blacklist of %s fails\n" % path_dic["wwid"]
else:
multipath.form_conf_mpath_file(defaults_extra=plcy)
if not multipath.device_exists(path_dic["wwid"]):
msg += "Recovery of %s fails\n" % path_dic["wwid"]
# Blacklisting sdX
self.log.info("Black listing individual paths")
for disk in path_dic["paths"]:
cmd = "devnode %s" % disk
multipath.form_conf_mpath_file(blacklist=cmd,
defaults_extra=plcy)
if disk in multipath.get_paths(path_dic["wwid"]):
msg += "Blacklist of %s fails\n" % disk
multipath.form_conf_mpath_file(defaults_extra=plcy)
# Failing and reinstating individual paths eg: sdX
self.log.info(" Failing and reinstating the individual paths")
for path in path_dic["paths"]:
if multipath.fail_path(path) is False:
msg += "test failed while failing %s\n" % path
elif multipath.reinstate_path(path) is False:
msg += "test failed while reinstating %s\n" % path
self.mpath_svc.restart()
wait.wait_for(self.mpath_svc.status, timeout=10)
# Failing n-1 paths for short time and reinstating back
self.log.info("Failing and reinstating the n-1 paths")
for path in path_dic['paths'][:-1]:
if multipath.fail_path(path) is False:
msg += "%s did not failed in n-1 path fail\n" % path
time.sleep(180)
for path in path_dic['paths'][:-1]:
if multipath.reinstate_path(path) is False:
msg += "%s failed to recover in n-1 paths fails\n" % path
self.mpath_svc.restart()
wait.wait_for(self.mpath_svc.status, timeout=10)
# Failing all paths for short time and reinstating back
self.log.info("Failing and reinstating the All paths")
for path in path_dic['paths']:
if multipath.fail_path(path) is False:
msg += "%s did not failed in all paths fail\n" % path
time.sleep(180)
for path in path_dic['paths']:
if multipath.reinstate_path(path) is False:
msg += "%s did not recovered in all path fail\n" % path
self.mpath_svc.restart()
wait.wait_for(self.mpath_svc.status, timeout=10)
# Print errors
if msg:
self.fail("Some tests failed. Find details below:\n%s" % msg)
def setUp(self):
"""
Set up.
"""
self.policy = self.params.get('policy', default='service-time')
self.policies = ["service-time", "round-robin", "queue-length"]
# We will remove and add the policy back, so that this becomes
# the last member of the list. This is done so that in the
# policy change test later, this policy is set in the last
# iteration.
self.policies.remove(self.policy)
self.policies.append(self.policy)
# Install needed packages
dist = distro.detect()
pkg_name = ""
svc_name = ""
if dist.name == 'Ubuntu':
pkg_name += "multipath-tools"
svc_name = "multipath-tools"
elif dist.name == 'SuSE':
pkg_name += "multipath-tools"
svc_name = "multipathd"
else:
pkg_name += "device-mapper-multipath"
svc_name = "multipathd"
smm = SoftwareManager()
if not smm.check_installed(pkg_name) and not smm.install(pkg_name):
self.cancel("Can not install %s" % pkg_name)
# Check if given multipath devices are present in system
self.wwids = self.params.get('wwids', default='').split(',')
system_wwids = multipath.get_multipath_wwids()
wwids_to_remove = []
for wwid in self.wwids:
if wwid not in system_wwids:
self.log.info("%s not present in the system" % wwid)
wwids_to_remove.append(wwid)
for wwid in wwids_to_remove:
self.wwids.remove(wwid)
if self.wwids == []:
self.cancel("No Multipath Devices Given")
# Create service object
self.mpath_svc = service.SpecificServiceManager(svc_name)
self.mpath_svc.restart()
wait.wait_for(self.mpath_svc.status, timeout=10)
# Take a backup of current config file
self.mpath_file = "/etc/multipath.conf"
if os.path.isfile(self.mpath_file):
shutil.copyfile(self.mpath_file, "%s.bkp" % self.mpath_file)
self.mpath_list = []
# Find all details of multipath devices
for wwid in self.wwids:
if wwid not in process.system_output('multipath -ll',
ignore_status=True,
shell=True):
continue
self.mpath_dic = {}
self.mpath_dic["wwid"] = wwid
self.mpath_dic["name"] = multipath.get_mpath_name(wwid)
self.mpath_dic["paths"] = multipath.get_paths(wwid)
self.mpath_dic["policy"] = multipath.get_policy(wwid)
self.mpath_dic["size"] = multipath.get_size(wwid)
self.mpath_list.append(self.mpath_dic)
pprint(self.mpath_list)
def test(self):
"""
Tests Multipath.
"""
msg = ""
multipath.form_conf_mpath_file()
plcy = "path_selector \"%s 0\"" % self.policy
multipath.form_conf_mpath_file(defaults_extra=plcy)
for path_dic in self.mpath_list:
self.log.debug("operating on paths", path_dic["paths"])
# Path Selector policy
self.log.info("changing Selector policy")
for policy in self.policies:
cmd = "path_selector \"%s 0\"" % policy
multipath.form_conf_mpath_file(defaults_extra=cmd)
if multipath.get_policy(path_dic["wwid"]) != policy:
msg += "%s for %s fails\n" % (policy, path_dic["wwid"])
# mutipath -f mpathX
if not multipath.flush_path(path_dic["name"]):
msg += "Flush of %s fails\n" % path_dic["name"]
self.mpath_svc.restart()
wait.wait_for(self.mpath_svc.status, timeout=10)
# Blacklisting wwid
self.log.info("Black listing WWIDs")
cmd = "wwid %s" % path_dic["wwid"]
multipath.form_conf_mpath_file(blacklist=cmd, defaults_extra=plcy)
if multipath.device_exists(path_dic["wwid"]):
msg += "Blacklist of %s fails\n" % path_dic["wwid"]
else:
multipath.form_conf_mpath_file(defaults_extra=plcy)
if not multipath.device_exists(path_dic["wwid"]):
msg += "Recovery of %s fails\n" % path_dic["wwid"]
# Blacklisting sdX
self.log.info("Black listing individual paths")
for disk in path_dic["paths"]:
cmd = "devnode %s" % disk
multipath.form_conf_mpath_file(blacklist=cmd,
defaults_extra=plcy)
if disk in multipath.get_paths(path_dic["wwid"]):
msg += "Blacklist of %s fails\n" % disk
multipath.form_conf_mpath_file(defaults_extra=plcy)
# Failing and reinstating individual paths eg: sdX
self.log.info(" Failing and reinstating the individual paths")
for path in path_dic["paths"]:
if multipath.fail_path(path) is False:
msg += "test failed while failing %s\n" % path
elif multipath.reinstate_path(path) is False:
msg += "test failed while reinstating %s\n" % path
self.mpath_svc.restart()
wait.wait_for(self.mpath_svc.status, timeout=10)
# Failing n-1 paths for short time and reinstating back
self.log.info("Failing and reinstating the n-1 paths")
for path in path_dic['paths'][:-1]:
if multipath.fail_path(path) is False:
msg += "%s did not failed in n-1 path fail\n" % path
time.sleep(180)
for path in path_dic['paths'][:-1]:
if multipath.reinstate_path(path) is False:
msg += "%s failed to recover in n-1 paths fails\n" % path
self.mpath_svc.restart()
wait.wait_for(self.mpath_svc.status, timeout=10)
# Failing all paths for short time and reinstating back
self.log.info("Failing and reinstating the All paths")
for path in path_dic['paths']:
if multipath.fail_path(path) is False:
msg += "%s did not failed in all paths fail\n" % path
time.sleep(180)
for path in path_dic['paths']:
if multipath.reinstate_path(path) is False:
msg += "%s did not recovered in all path fail\n" % path
self.mpath_svc.restart()
wait.wait_for(self.mpath_svc.status, timeout=10)
# Print errors
if msg:
self.fail("Some tests failed. Find details below:\n%s" % msg)
