def setUp(self): """ Setup the device. """ if 'ppc' not in platform.processor(): self.cancel("Processor is not ppc64") if os.path.exists('/proc/device-tree/bmc'): self.cancel("Test Unsupported! on this platform") if 'pSeries' in open('/proc/cpuinfo', 'r').read(): for mdl in ['rpaphp', 'rpadlpar_io']: if not linux_modules.module_is_loaded(mdl): linux_modules.load_module(mdl) elif 'PowerNV' in open('/proc/cpuinfo', 'r').read(): if not linux_modules.module_is_loaded("pnv_php"): linux_modules.load_module("pnv_php") self.dic = {} self.device = self.params.get('pci_devices', default="") self.peer_ip = self.params.get('peer_ip', default="") self.count = int(self.params.get('count', default='1')) if not self.device: self.cancel("PCI_address not given") self.device = self.device.split(" ") smm = SoftwareManager() if not smm.check_installed("pciutils") and not smm.install("pciutils"): self.cancel("pciutils package is need to test") for pci_addr in self.device: if not os.path.isdir('/sys/bus/pci/devices/%s' % pci_addr): self.cancel("%s not present in device path" % pci_addr) slot = pci.get_slot_from_sysfs(pci_addr) if not slot: self.cancel("slot number not available for: %s" % pci_addr) self.dic[pci_addr] = slot
def setUp(self): """ Setup the device. """ if 'ppc' not in platform.processor(): self.cancel("Processor is not ppc64") if os.path.exists('/proc/device-tree/bmc'): self.cancel("Test Unsupported! on this platform") if cpu._list_matches( open('/proc/cpuinfo').readlines(), 'platform\t: pSeries\n'): self.power_vm = True for mdl in ['rpaphp', 'rpadlpar_io']: if not linux_modules.module_is_loaded(mdl): linux_modules.load_module(mdl) elif cpu._list_matches( open('/proc/cpuinfo').readlines(), 'platform\t: PowerNV\n'): self.power_vm = False if not linux_modules.module_is_loaded("pnv_php"): linux_modules.load_module("pnv_php") self.dic = {} self.device = self.params.get('pci_devices', default=' ').split(",") self.count = int(self.params.get('count', default='1')) if not self.device: self.cancel("PCI_address not given") for pci_addr in self.device: if not os.path.isdir('/sys/bus/pci/devices/%s' % pci_addr): self.cancel("%s not present in device path" % pci_addr) slot = self.get_slot(pci_addr) if not slot: self.cancel("slot number not available for: %s" % pci_addr) self.dic[pci_addr] = slot
def module_load_unload(self, mod1): """ Unloading and loading the given module """ if linux_modules.module_is_loaded(mod1) is False: linux_modules.load_module(mod1) time.sleep(self.load_unload_sleep_time) sub_mod = linux_modules.get_submodules(mod1) if sub_mod: for mod in sub_mod: linux_modules.unload_module(mod) if linux_modules.module_is_loaded(mod) is True: self.error_modules.append(mod) break if linux_modules.unload_module(mod1) is False: self.fail("Unloading Module %s failed" % mod1) time.sleep(self.load_unload_sleep_time) cmd = "%s %s=%s" % (mod1, self.param_name, self.param_value) if linux_modules.load_module(cmd) is False: self.fail("Param %s = Value %s Failed for Module %s" % (self.param_name, self.param_value, mod1)) time.sleep(self.load_unload_sleep_time) if self.sysfs_chk: if self.sysfs_value_check() is False: self.fail("Sysfs check failed ") if not wait.wait_for(configure_network.is_interface_link_up, timeout=120, args=[self.ifaces]): self.fail("Link up of interface is taking longer than 120s") if not configure_network.ping_check( self.ifaces, self.peer, '1000', flood=True): self.fail("ping test failed")
def setUp(self): """ Sets up NVMf configuration """ self.nss = self.params.get('namespaces', default='') self.peer_ips = self.params.get('peer_ips', default='') if not self.nss or not self.peer_ips: self.cancel("No inputs provided") self.peer_user = self.params.get("peer_user", default="root") self.peer_password = self.params.get("peer_password", default=None) self.nss = self.nss.split(' ') self.peer_ips = self.peer_ips.split(' ') self.ids = range(1, len(self.peer_ips) + 1) if len(self.nss) != len(self.peer_ips): self.cancel("Count of namespace and peer ips mismatch") smm = SoftwareManager() if not smm.check_installed("nvme-cli") and not \ smm.install("nvme-cli"): self.cancel('nvme-cli is needed for the test to be run') try: if not linux_modules.module_is_loaded("nvme-rdma"): linux_modules.load_module("nvme-rdma") except CmdError: self.cancel("nvme-rdma module not loadable") self.cfg_tmpl = self.get_data("nvmf_template.cfg") dirname = os.path.dirname(os.path.abspath(self.cfg_tmpl)) self.cfg_file = os.path.join(dirname, "nvmf.cfg") self.nvmf_discovery_file = "/etc/nvme/discovery.conf"
def setUp(self): """ Sets up NVMf configuration """ self.nss = self.params.get('namespaces', default='') self.peer_ips = self.params.get('peer_ips', default='') if not self.nss or not self.peer_ips: self.cancel("No inputs provided") self.nss = self.nss.split(',') self.peer_ips = self.peer_ips.split(',') self.ids = range(1, len(self.peer_ips) + 1) if len(self.nss) != len(self.peer_ips): self.cancel("Count of namespace and peer ips mismatch") smm = SoftwareManager() if not smm.check_installed("nvme-cli") and not \ smm.install("nvme-cli"): self.cancel('nvme-cli is needed for the test to be run') try: if not linux_modules.module_is_loaded("nvme-rdma"): linux_modules.load_module("nvme-rdma") except CmdError: self.cancel("nvme-rdma module not loadable") self.cfg_tmpl = self.get_data("nvmf_template.cfg") self.cfg_file = self.get_data("nvmf.cfg") self.nvmf_discovery_file = "/etc/nvme/discovery.conf"
def test(self): """ Check for the IPIs before and after ipistorm module """ pre_dbl_val = self.get_interrupts("DBL") pre_ipi_val = self.get_interrupts("IPI") if not linux_modules.module_is_loaded("ipistorm"): if process.system( "insmod ./ipistorm.ko", ignore_status=True, shell=True, sudo=True): self.fail("Failed to insert ipistorm module") else: self.cancel( "Cannot verify the DBL interrupt with module already loaded") time.sleep(5) process.system("rmmod ipistorm", ignore_status=True, sudo=True) post_dbl_val = self.get_interrupts("DBL") post_ipi_val = self.get_interrupts("IPI") for idx, _ in enumerate(post_dbl_val): if (int(post_dbl_val[idx]) <= int(pre_dbl_val[idx])) or\ (int(post_ipi_val[idx]) <= int(pre_ipi_val[idx])): self.fail("Interrupts does not seemed to be used") else: self.log.info("Old DBL %s, New DBL: %s", pre_dbl_val[idx], post_dbl_val[idx]) self.log.info("Old IPI %s, New IPI: %s", pre_ipi_val[idx], post_ipi_val[idx])
def setUp(self): """ get parameters """ self.module = self.params.get('module', default=None) self.param_name = self.params.get('module_param_name', default=None) self.param_value = self.params.get('module_param_value', default=None) self.mpath_enabled = self.params.get('multipath_enabled', default=False) self.disk = self.params.get('disk', default=None) self.load_unload_sleep_time = 30 self.error_modules = [] self.uname = linux_modules.platform.uname()[2] if not self.module: self.cancel("Please provide the Module name") if not self.disk: self.cancel("Please provide the Disk name") if linux_modules.module_is_loaded(self.module) is False: linux_modules.load_module(self.module) time.sleep(self.load_unload_sleep_time) 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))
class DiskSpace(unittest.TestCase): @unittest.skipIf( process.system("modinfo scsi_debug", shell=True, ignore_status=True), "Kernel mod 'scsi_debug' not available.") @unittest.skipIf(linux_modules.module_is_loaded("scsi_debug"), "Kernel mod 'scsi_debug' is already loaded.") @unittest.skipIf(sys.platform.startswith('darwin'), 'macOS does not support scsi_debug module') @unittest.skipIf(not process.can_sudo(), "This test requires root or " "passwordless sudo configured.") def test_get_diskspace(self): """ Use scsi_debug device to check disk size """ pre = glob.glob("/dev/sd*") process.system("modprobe scsi_debug", sudo=True) disks = set(glob.glob("/dev/sd*")).difference(pre) self.assertEqual(len(disks), 1, "pre: %s\npost: %s" % (disks, glob.glob("/dev/sd*"))) disk = disks.pop() self.assertEqual(lv_utils.get_diskspace(disk), "8388608") def tearDown(self): for _ in range(10): if process.run("modprobe -r scsi_debug", ignore_status=True, sudo=True).exit_status == 0: return time.sleep(0.05) raise RuntimeError("Failed to remove scsi_debug after testing")
def tearDown(self): """ Restore back the default Parameters """ self.log.info("Restoring Default param") linux_modules.unload_module(self.module) linux_modules.load_module(self.module) time.sleep(self.load_unload_sleep_time) if linux_modules.module_is_loaded(self.module) is False: self.fail("Cannot restore default values for Module : %s" % self.module)
def run(test, params, env): """ load/unload kernel modules several times. This tests the kernel pre-installed kernel modules """ # Destory all vms for unload/load module kvm_intel/kvm_amd for vm in env.get_all_vms(): if vm: vm.destroy() env.unregister_vm(vm.name) installer_object = base_installer.NoopInstaller('noop', 'module_probe', test, params) logging.debug('installer object: %r', installer_object) submodules = [] modules_str = " " for module in installer_object.module_list: if " %s " % module in modules_str: continue tmp_list = [module] if linux_modules.module_is_loaded(module): tmp_list += linux_modules.get_submodules(module) modules_str += "%s " % " ".join(tmp_list) if len(tmp_list) > 1: for _ in submodules: if _[0] in tmp_list: submodules.remove(_) break submodules.append(tmp_list) installer_object.module_list = [] for submodule_list in submodules: installer_object.module_list += submodule_list load_count = int(params.get("load_count", 100)) try: # unload the modules before starting: installer_object.unload_modules() for _ in range(load_count): try: installer_object.load_modules() except base_installer.NoModuleError as e: logging.error(e) break except Exception as e: test.fail("Failed to load modules [%r]: %s" % (installer_object.module_list, e)) installer_object.unload_modules() finally: try: installer_object.load_modules() except base_installer.NoModuleError: pass
def run(test, params, env): """ load/unload kernel modules several times. This tests the kernel pre-installed kernel modules """ # Destory all vms for unload/load module kvm_intel/kvm_amd for vm in env.get_all_vms(): if vm: vm.destroy() env.unregister_vm(vm.name) installer_object = base_installer.NoopInstaller('noop', 'module_probe', test, params) test.log.debug('installer object: %r', installer_object) submodules = [] modules_str = " " for module in installer_object.module_list: if " %s " % module in modules_str: continue tmp_list = [module] if linux_modules.module_is_loaded(module): tmp_list += linux_modules.get_submodules(module) modules_str += "%s " % " ".join(tmp_list) if len(tmp_list) > 1: for _ in submodules: if _[0] in tmp_list: submodules.remove(_) break submodules.append(tmp_list) installer_object.module_list = [] for submodule_list in submodules: installer_object.module_list += submodule_list load_count = int(params.get("load_count", 100)) try: # unload the modules before starting: installer_object.unload_modules() for _ in range(load_count): try: installer_object.load_modules() except base_installer.NoModuleError as e: test.log.error(e) break except Exception as e: test.fail("Failed to load modules [%r]: %s" % (installer_object.module_list, e)) installer_object.unload_modules() finally: try: installer_object.load_modules() except base_installer.NoModuleError: pass
def setUp(self): """ Verifies if CONFIG_RCU_TORTURE_TEST is enabled """ self.results = [] self.log.info("Check if CONFIG_RCU_TORTURE_TEST is enabled\n") ret = linux_modules.check_kernel_config('CONFIG_RCU_TORTURE_TEST') if ret == linux_modules.ModuleConfig.NOT_SET: self.cancel("CONFIG_RCU_TORTURE_TEST is not set in .config !!\n") self.log.info("Check rcutorture module is already loaded\n") if linux_modules.module_is_loaded('rcutorture'): linux_modules.unload_module('rcutorture')
def setUp(self): """ Verifies if CONFIG_RCU_TORTURE_TEST is enabled """ self.results = [] self.log.info("Check if CONFIG_RCU_TORTURE_TEST is enabled\n") ret = linux_modules.check_kernel_config("CONFIG_RCU_TORTURE_TEST") if ret == 0: self.fail("CONFIG_RCU_TORTURE_TEST is not set in .config !!\n") self.log.info("Check rcutorture module is already loaded\n") if linux_modules.module_is_loaded("rcutorture"): linux_modules.unload_module("rcutorture")
def setUp(self): """ Check pre-requisites before running sensors command Testcase should be executed only on bare-metal environment. """ s_mg = SoftwareManager() d_distro = distro.detect() if d_distro.name == "Ubuntu": if not s_mg.check_installed("lm-sensors") and not s_mg.install( "lm-sensors"): self.cancel('Need sensors to run the test') elif d_distro.name == "SuSE": if not s_mg.check_installed("sensors") and not s_mg.install( "sensors"): self.cancel('Need sensors to run the test') else: if not s_mg.check_installed("lm_sensors") and not s_mg.install( "lm_sensors"): self.cancel('Need sensors to run the test') if d_distro.arch in ["ppc64", "ppc64le"]: if not cpu._list_matches( open('/proc/cpuinfo').readlines(), 'platform\t: PowerNV\n'): self.cancel( 'sensors test is applicable to bare-metal environment.') config_check = linux_modules.check_kernel_config( 'CONFIG_SENSORS_IBMPOWERNV') if config_check == 0: self.cancel('Config is not set') elif config_check == 1: if linux_modules.load_module('ibmpowernv'): if linux_modules.module_is_loaded('ibmpowernv'): self.log.info('Module Loaded Successfully') else: self.cancel('Module Loading Failed') else: self.log.info('Module is Built In') if not d_distro.name == "Ubuntu": try: process.run('service lm_sensors stop', sudo=True) process.run('service lm_sensors start', sudo=True) process.run('service lm_sensors status', sudo=True) except process.CmdError: self.error( 'Starting Service Failed. Make sure module is loaded') cmd = "yes | sudo sensors-detect" det_op = process.run(cmd, shell=True, ignore_status=True).stdout if 'no sensors were detected' in det_op: self.cancel('No sensors found to test !')
def setUp(self): """ Setup the device. """ if 'ppc' not in platform.processor(): self.cancel("Processor is not ppc64") if os.path.exists('/proc/device-tree/bmc'): self.cancel("Test Unsupported! on this platform") cmd = "cat /proc/cpuinfo" if cpu._list_matches(open('/proc/cpuinfo').readlines(), 'platform\t: pSeries\n'): PowerVM = True for mdl in ['rpaphp', 'rpadlpar_io']: if not linux_modules.module_is_loaded(mdl): linux_modules.load_module(mdl) elif cpu._list_matches(open('/proc/cpuinfo').readlines(), 'platform\t: PowerNV\n'): PowerVM = False if not linux_modules.module_is_loaded("pnv_php"): linux_modules.load_module("pnv_php") self.return_code = 0 self.device = self.params.get('pci_device', default=' ') self.num_of_hotplug = int(self.params.get('num_of_hotplug', default='1')) if not os.path.isdir('/sys/bus/pci/devices/%s' % self.device): self.cancel("PCI device given does not exist") if PowerVM: devspec = genio.read_file("/sys/bus/pci/devices/%s/devspec" % self.device) self.slot = genio.read_file("/proc/device-tree/%s/ibm,loc-code" % devspec) self.slot = re.match(r'((\w+)[\.])+(\w+)-P(\d+)-C(\d+)|Slot(\d+)', self.slot).group() else: self.slot = pci.get_pci_prop(self.device, "PhySlot") if not os.path.isdir('/sys/bus/pci/slots/%s' % self.slot): self.cancel("%s Slot not available" % self.slot) if not os.path.exists('/sys/bus/pci/slots/%s/power' % self.slot): self.cancel("%s Slot does not support hotplug" % self.slot)
def setUp(self): """ Setup the device. """ cmd = "uname -p" if 'ppc' not in process.system_output(cmd, ignore_status=True): self.cancel("Processor is not ppc64") cmd = "cat /proc/cpuinfo" if cpu._list_matches(open('/proc/cpuinfo').readlines(), 'platform\t: pSeries\n'): PowerVM = True for mdl in ['rpaphp', 'rpadlpar_io']: if not linux_modules.module_is_loaded(mdl): linux_modules.load_module(mdl) elif cpu._list_matches(open('/proc/cpuinfo').readlines(), 'platform\t: PowerNV\n'): PowerVM = False if not linux_modules.module_is_loaded("pnv_php"): linux_modules.load_module("pnv_php") self.return_code = 0 self.device = self.params.get('pci_device', default=' ') self.num_of_hotplug = int(self.params.get('num_of_hotplug', default='1')) if not os.path.isdir('/sys/bus/pci/devices/%s' % self.device): self.cancel("PCI device given does not exist") if PowerVM: devspec = genio.read_file("/sys/bus/pci/devices/%s/devspec" % self.device) self.slot = genio.read_file("/proc/device-tree/%s/ibm,loc-code" % devspec) self.slot = re.match(r'((\w+)[\.])+(\w+)-P(\d+)-C(\d+)|Slot(\d+)', self.slot).group() else: self.slot = pci.get_pci_prop(self.device, "PhySlot") if not os.path.isdir('/sys/bus/pci/slots/%s' % self.slot): self.cancel("%s Slot not available" % self.slot) if not os.path.exists('/sys/bus/pci/slots/%s/power' % self.slot): self.cancel("%s Slot does not support hotplug" % self.slot)
def setUp(self): """ Check pre-requisites before running sensors command Testcase should be executed only on bare-metal environment. """ s_mg = SoftwareManager() d_distro = distro.detect() if d_distro.name == "Ubuntu": if not s_mg.check_installed("lm-sensors") and not s_mg.install( "lm-sensors"): self.cancel('Need sensors to run the test') elif d_distro.name == "SuSE": if not s_mg.check_installed("sensors") and not s_mg.install( "sensors"): self.cancel('Need sensors to run the test') else: if not s_mg.check_installed("lm_sensors") and not s_mg.install( "lm_sensors"): self.cancel('Need sensors to run the test') if d_distro.arch in ["ppc64", "ppc64le"]: if not cpu._list_matches(open('/proc/cpuinfo').readlines(), 'platform\t: PowerNV\n'): self.cancel( 'sensors test is applicable to bare-metal environment.') config_check = linux_modules.check_kernel_config( 'CONFIG_SENSORS_IBMPOWERNV') if config_check == 0: self.cancel('Config is not set') elif config_check == 1: if linux_modules.load_module('ibmpowernv'): if linux_modules.module_is_loaded('ibmpowernv'): self.log.info('Module Loaded Successfully') else: self.cancel('Module Loading Failed') else: self.log.info('Module is Built In') if not d_distro.name == "Ubuntu": try: process.run('service lm_sensors stop', sudo=True) process.run('service lm_sensors start', sudo=True) process.run('service lm_sensors status', sudo=True) except process.CmdError: self.error( 'Starting Service Failed. Make sure module is loaded') cmd = "yes | sudo sensors-detect" det_op = process.run(cmd, shell=True, ignore_status=True).stdout if 'no sensors were detected' in det_op: self.cancel('No sensors found to test !')
def module_load_unload(self, module_list): """ Unloading and loading the given module """ for mod1 in module_list: if linux_modules.module_is_loaded(mod1) is False: linux_modules.load_module(mod1) time.sleep(self.load_unload_sleep_time) for mdl in module_list: for _ in range(0, self.iteration): sub_mod = self.get_depend_modules(mdl) if sub_mod: for mod in sub_mod.split(' '): if mod == 'multipath': if self.flush_mpath(mdl) is False: self.error_modules.append(mdl) break else: self.log.info("unloading sub module %s " % mod) linux_modules.unload_module(mod) if linux_modules.module_is_loaded(mod) is True: self.error_modules.append(mod) break self.log.info("unloading module %s " % mdl) linux_modules.unload_module(mdl) time.sleep(self.load_unload_sleep_time) if linux_modules.module_is_loaded(mdl) is True: self.error_modules.append(mdl) break self.log.info("loading module : %s " % mdl) linux_modules.load_module(mdl) time.sleep(self.load_unload_sleep_time) if linux_modules.module_is_loaded(mdl) is False: self.error_modules.append(mdl) break
def tearDown(self): """ Restore back the default Parameters """ self.log.info("Restoiring Default param") if self.mpath_enabled is True: if not wait.wait_for(self.is_mpath_flushed, timeout=90): self.fail("multipath is in USE and cannot be flushed") linux_modules.unload_module(self.module) linux_modules.load_module(self.module) time.sleep(self.load_unload_sleep_time) if linux_modules.module_is_loaded(self.module) is False: self.fail("Cannot restore default values for Module : %s" % self.module) self.log.info("Restore of default param is success")
def setUp(self): smg = SoftwareManager() if 'SuSE' in distro.detect().name: if not smg.check_installed("kernel-source") and not\ smg.install("kernel-source"): self.cancel("Failed to install kernel-source for this test.") if not os.path.exists("/usr/src/linux"): self.cancel("kernel source missing after install") self.buldir = "/usr/src/linux" shutil.copy('/boot/config-%s' % platform.uname()[2], '%s/.config' % self.buldir) os.chdir(self.buldir) process.system("sed -i 's/^.*CONFIG_SYSTEM_TRUSTED_KEYS/#&/g'\ .config", shell=True, sudo=True) process.system("sed -i 's/^.*CONFIG_SYSTEM_TRUSTED_KEYRING/#&/g' \ .config", shell=True, sudo=True) process.system("sed -i 's/^.*CONFIG_MODULE_SIG_KEY/#&/g' .config", shell=True, sudo=True) process.system("sed -i 's/^.*CONFIG_DEBUG_INFO_BTF/#&/g' .config", shell=True, sudo=True) process.system('make') process.system('make modules_install') """ Verifies if CONFIG_RCU_TORTURE_TEST is enabled """ self.results = [] self.log.info("Check if CONFIG_RCU_TORTURE_TEST is enabled\n") ret = linux_modules.check_kernel_config('CONFIG_RCU_TORTURE_TEST') if ret == linux_modules.ModuleConfig.NOT_SET: self.cancel("CONFIG_RCU_TORTURE_TEST is not set in .config !!\n") self.log.info("Check rcutorture module is already loaded\n") if linux_modules.module_is_loaded('rcutorture'): linux_modules.unload_module('rcutorture')
def module_parameter_test(self): """ Unloading and loading the given module """ if self.mpath_enabled is True: if not wait.wait_for(self.is_mpath_flushed, timeout=90): self.fail("multipath is in USE and cannot be flushed") else: sub_mod = linux_modules.get_submodules(self.module) if sub_mod: for mod in sub_mod.split(' '): linux_modules.unload_module(mod) if linux_modules.module_is_loaded(mod) is True: self.error_modules.append(mod) break self.log.info("Testing %s=%s" % (self.param_name, self.param_value)) self.log.info("unloading driver module: %s" % self.module) if linux_modules.unload_module(self.module) is False: self.fail("Unloading Module %s failed" % self.module) time.sleep(self.load_unload_sleep_time) self.log.info("loading driver with %s=%s" % (self.param_name, self.param_value)) cmd = "%s %s=%s" % (self.module, self.param_name, self.param_value) if linux_modules.load_module(cmd) is False: self.fail("Param %s = Value %s Failed for Module %s" % (self.param_name, self.param_value, self.module)) else: self.log.info("Driver module=%s loaded successfully" % cmd) self.log.info("checking sysfs for %s after successful load" % cmd) if self.sysfs_value_check() is False: self.fail("Sysfs check failed ") self.log.info("sysfs check for %s success" % cmd) self.log.info("Running DD after %s changed" % cmd) if self.dd_run() is False: self.fail("dd run failed on disk: %s" % self.disk) self.log.info("DD run for %s is success" % cmd)
asset.download_asset(os_asset, interactive=interactive, restore_image=restore_image) except AssertionError: pass # Not all files are managed via asset check_modules = [] if options.vt_type == "qemu": check_modules = arch.get_kvm_module_list() elif options.vt_type == "openvswitch": check_modules = ["openvswitch"] if check_modules: logging.info("") step += 1 logging.info("%d - Checking for modules %s", step, ", ".join(check_modules)) for module in check_modules: if not linux_modules.module_is_loaded(module): logging.warning("Module %s is not loaded. You might want to " "load it", module) else: logging.debug("Module %s loaded", module) online_docs_url = 'http://avocado-vt.readthedocs.org/' logging.info("") step += 1 logging.info("%d - If you wish, you may take a look at the online docs for " "more info", step) logging.info("") logging.info(online_docs_url)
except AssertionError: pass # Not all files are managed via asset check_modules = [] if options.vt_type == "qemu": check_modules = arch.get_kvm_module_list() elif options.vt_type == "openvswitch": check_modules = ["openvswitch"] if check_modules: logging.info("") step += 1 logging.info("%d - Checking for modules %s", step, ", ".join(check_modules)) for module in check_modules: if not linux_modules.module_is_loaded(module): logging.warning( "Module %s is not loaded. You might want to " "load it", module) else: logging.debug("Module %s loaded", module) online_docs_url = 'http://avocado-vt.readthedocs.org/' logging.info("") step += 1 logging.info( "%d - If you wish, you may take a look at the online docs for " "more info", step) logging.info("") logging.info(online_docs_url)
def tearDown(self): if linux_modules.module_is_loaded('rcutorture'): linux_modules.unload_module('rcutorture')
def bootstrap(options, interactive=False): """ Common virt test assistant module. :param options: Command line options. :param interactive: Whether to ask for confirmation. """ if get_opt(options, 'yes_to_all'): interactive = False vt_type = get_opt(options, 'vt.type') LOG.info("Running bootstrap for %s", vt_type) step = 0 LOG.info("") step += 1 LOG.info("%d - Checking the mandatory programs and headers", step) guest_os = get_opt(options, 'vt.guest_os') or defaults.DEFAULT_GUEST_OS try: verify_mandatory_programs(vt_type, guest_os) except Exception as details: LOG.debug(details) LOG.debug('Install the missing programs and/or headers and ' 're-run boostrap') sys.exit(1) LOG.info("") step += 1 LOG.info("%d - Checking the recommended programs", step) verify_recommended_programs(vt_type) LOG.info("") step += 1 LOG.info("%d - Updating test providers repo configuration from local copy", step) tp_base_dir = data_dir.get_base_test_providers_dir() tp_local_dir = data_dir.get_test_providers_dir() dir_util.copy_tree(tp_base_dir, tp_local_dir) not_downloaded = asset.test_providers_not_downloaded() if not_downloaded: action = "Downloading" else: action = "Updating" if not get_opt(options, 'vt_no_downloads'): LOG.info("") step += 1 LOG.info("%d - %s the test providers from remote repos", step, action) asset.download_all_test_providers( get_opt(options, 'vt_update_providers')) else: if not_downloaded: LOG.warn( "The following test providers have not been downloaded: %s", ", ".join(not_downloaded)) LOG.info("") step += 1 LOG.info("%d - Verifying directories", step) datadir = data_dir.get_data_dir() shared_dir = data_dir.get_shared_dir() sub_dir_list = ["images", "isos", "steps_data", "gpg", "downloads"] for sub_dir in sub_dir_list: sub_dir_path = os.path.join(datadir, sub_dir) if not os.path.isdir(sub_dir_path): LOG.debug("Creating %s", sub_dir_path) os.makedirs(sub_dir_path) else: LOG.debug("Dir %s exists, not creating", sub_dir_path) base_backend_dir = data_dir.get_base_backend_dir() local_backend_dir = data_dir.get_local_backend_dir() LOG.info("") step += 1 LOG.info("%d - Syncing backend dirs %s -> %s", step, base_backend_dir, local_backend_dir) dir_util.copy_tree(base_backend_dir, local_backend_dir) sync_download_dir(interactive) test_dir = data_dir.get_backend_dir(vt_type) if vt_type == 'libvirt': step = create_config_files(test_dir, shared_dir, interactive, vt_type, step, force_update=get_opt( options, 'vt_update_config')) create_subtests_cfg(vt_type) create_guest_os_cfg(vt_type) # Don't bother checking if changes can't be made if os.getuid() == 0: verify_selinux(datadir, os.path.join(datadir, 'images'), os.path.join(datadir, 'isos'), data_dir.get_tmp_dir(), interactive, get_opt(options, 'vt_selinux_setup')) # lvsb test doesn't use any shared configs elif vt_type == 'lvsb': create_subtests_cfg(vt_type) if os.getuid() == 0: # Don't bother checking if changes can't be made verify_selinux(datadir, os.path.join(datadir, 'images'), os.path.join(datadir, 'isos'), data_dir.get_tmp_dir(), interactive, get_opt(options, 'vt_selinux_setup')) else: # Some other test step = create_config_files(test_dir, shared_dir, interactive, vt_type, step, force_update=get_opt( options, 'vt_update_config')) create_subtests_cfg(vt_type) create_guest_os_cfg(vt_type) create_host_os_cfg(options) if not (get_opt(options, 'vt_no_downloads') or get_opt(options, 'vt_skip_verify_download_assets')): LOG.info("") step += 1 LOG.info("%s - Verifying (and possibly downloading) guest image", step) try: for os_info in get_guest_os_info_list(vt_type, guest_os): os_asset = os_info['asset'] try: asset.download_asset(os_asset, interactive=interactive, restore_image=True) except AssertionError: pass # Not all files are managed via asset except ValueError as details: LOG.error(details) sys.exit(1) check_modules = [] if vt_type == "qemu": check_modules = arch.get_kvm_module_list() elif vt_type == "openvswitch": check_modules = ["openvswitch"] if check_modules: LOG.info("") step += 1 LOG.info("%d - Checking for modules %s", step, ", ".join(check_modules)) for module in check_modules: if not linux_modules.module_is_loaded(module): LOG.warning( "Module %s is not loaded. You might want to " "load it", module) else: LOG.debug("Module %s loaded", module) LOG.info("") LOG.info("VT-BOOTSTRAP FINISHED") LOG.debug( "You may take a look at the following online docs for more info:") LOG.debug(" - http://avocado-vt.readthedocs.org/") LOG.debug(" - http://avocado-framework.readthedocs.org/")
def test_is_module_loaded(self): with mock.patch('avocado.utils.linux_modules.open', return_value=self._get_file_mock(self.PROC_MODULES_OUT)): self.assertTrue(linux_modules.module_is_loaded("rfcomm")) self.assertFalse(linux_modules.module_is_loaded("unknown_module"))
def test_is_module_loaded(self): with unittest.mock.patch('builtins.open', return_value=self._get_file_mock( self.PROC_MODULES_OUT)): self.assertTrue(linux_modules.module_is_loaded("rfcomm")) self.assertFalse(linux_modules.module_is_loaded("unknown_module"))
def test_is_module_loaded(self): with unittest.mock.patch( 'builtins.open', return_value=self._get_data_mock('proc_modules')): self.assertTrue(linux_modules.module_is_loaded("rfcomm")) self.assertFalse(linux_modules.module_is_loaded("unknown_module"))
def bootstrap(options, interactive=False): """ Common virt test assistant module. :param options: Command line options. :param interactive: Whether to ask for confirmation. """ if options.yes_to_all: interactive = False LOG.info("Running bootstrap for %s", options.vt_type) step = 0 LOG.info("") step += 1 LOG.info("%d - Checking the mandatory programs and headers", step) guest_os = options.vt_guest_os or defaults.DEFAULT_GUEST_OS try: verify_mandatory_programs(options.vt_type, guest_os) except Exception as details: LOG.debug(details) LOG.debug('Install the missing programs and/or headers and ' 're-run boostrap') sys.exit(1) LOG.info("") step += 1 LOG.info("%d - Checking the recommended programs", step) verify_recommended_programs(options.vt_type) LOG.info("") step += 1 LOG.info("%d - Updating test providers repo configuration from local copy", step) tp_base_dir = data_dir.get_base_test_providers_dir() tp_local_dir = data_dir.get_test_providers_dir() dir_util.copy_tree(tp_base_dir, tp_local_dir) not_downloaded = asset.test_providers_not_downloaded() if not_downloaded: action = "Downloading" else: action = "Updating" if not options.vt_no_downloads: LOG.info("") step += 1 LOG.info("%d - %s the test providers from remote repos", step, action) asset.download_all_test_providers(options.vt_update_providers) else: if not_downloaded: LOG.warn("The following test providers have not been downloaded: %s", ", ".join(not_downloaded)) LOG.info("") step += 1 LOG.info("%d - Verifying directories", step) datadir = data_dir.get_data_dir() shared_dir = data_dir.get_shared_dir() sub_dir_list = ["images", "isos", "steps_data", "gpg", "downloads"] for sub_dir in sub_dir_list: sub_dir_path = os.path.join(datadir, sub_dir) if not os.path.isdir(sub_dir_path): LOG.debug("Creating %s", sub_dir_path) os.makedirs(sub_dir_path) else: LOG.debug("Dir %s exists, not creating", sub_dir_path) base_backend_dir = data_dir.get_base_backend_dir() local_backend_dir = data_dir.get_local_backend_dir() LOG.info("") step += 1 LOG.info("%d - Syncing backend dirs %s -> %s", step, base_backend_dir, local_backend_dir) dir_util.copy_tree(base_backend_dir, local_backend_dir) sync_download_dir(interactive) test_dir = data_dir.get_backend_dir(options.vt_type) if options.vt_type == 'libvirt': step = create_config_files(test_dir, shared_dir, interactive, options.vt_type, step, force_update=options.vt_update_config) create_subtests_cfg(options.vt_type) create_guest_os_cfg(options.vt_type) # Don't bother checking if changes can't be made if os.getuid() == 0: verify_selinux(datadir, os.path.join(datadir, 'images'), os.path.join(datadir, 'isos'), data_dir.get_tmp_dir(), interactive, options.vt_selinux_setup) # lvsb test doesn't use any shared configs elif options.vt_type == 'lvsb': create_subtests_cfg(options.vt_type) if os.getuid() == 0: # Don't bother checking if changes can't be made verify_selinux(datadir, os.path.join(datadir, 'images'), os.path.join(datadir, 'isos'), data_dir.get_tmp_dir(), interactive, options.vt_selinux_setup) else: # Some other test step = create_config_files(test_dir, shared_dir, interactive, options.vt_type, step, force_update=options.vt_update_config) create_subtests_cfg(options.vt_type) create_guest_os_cfg(options.vt_type) create_host_os_cfg(options) if not (options.vt_no_downloads or options.vt_skip_verify_download_assets): LOG.info("") step += 1 LOG.info("%s - Verifying (and possibly downloading) guest image", step) try: for os_info in get_guest_os_info_list(options.vt_type, guest_os): os_asset = os_info['asset'] try: asset.download_asset(os_asset, interactive=interactive, restore_image=True) except AssertionError: pass # Not all files are managed via asset except ValueError as details: LOG.error(details) sys.exit(1) check_modules = [] if options.vt_type == "qemu": check_modules = arch.get_kvm_module_list() elif options.vt_type == "openvswitch": check_modules = ["openvswitch"] if check_modules: LOG.info("") step += 1 LOG.info("%d - Checking for modules %s", step, ", ".join(check_modules)) for module in check_modules: if not linux_modules.module_is_loaded(module): LOG.warning("Module %s is not loaded. You might want to " "load it", module) else: LOG.debug("Module %s loaded", module) LOG.info("") LOG.info("VT-BOOTSTRAP FINISHED") LOG.debug("You may take a look at the following online docs for more info:") LOG.debug(" - http://avocado-vt.readthedocs.org/") LOG.debug(" - http://avocado-framework.readthedocs.org/")