def __init__(self, *args, **kwargs): """Initialize either as EasyBlock or as Extension.""" self.is_extension = False if isinstance(args[0], EasyBlock): # make sure that extra custom easyconfig parameters are known extra_params = self.__class__.extra_options() kwargs['extra_params'] = extra_params Extension.__init__(self, *args, **kwargs) # name and version properties of EasyBlock are used, so make sure name and version are correct self.cfg['name'] = self.ext.get('name', None) self.cfg['version'] = self.ext.get('version', None) # We can't inherit the 'start_dir' value from the parent (which will be set, and will most likely be wrong). # It should be specified for the extension specifically, or be empty (so it is auto-derived). self.cfg['start_dir'] = self.ext.get('options', {}).get('start_dir', None) self.builddir = self.master.builddir self.installdir = self.master.installdir self.modules_tool = self.master.modules_tool self.module_generator = self.master.module_generator self.is_extension = True self.unpack_options = None else: EasyBlock.__init__(self, *args, **kwargs) self.options = copy.deepcopy(self.cfg.get('options', {})) # we need this for Extension.sanity_check_step self.ext_dir = None # dir where extension source was unpacked
def sanity_check_step(self, exts_filter=None, custom_paths=None, custom_commands=None): """ Custom sanity check for extensions, whether installed as stand-alone module or not """ if not self.cfg["exts_filter"]: self.cfg["exts_filter"] = exts_filter self.log.debug("starting sanity check for extension with filter %s", self.cfg["exts_filter"]) if not self.is_extension: # load fake module fake_mod_data = self.load_fake_module(purge=True) # perform sanity check sanity_check_ok = Extension.sanity_check_step(self) if not self.is_extension: # unload fake module and clean up self.clean_up_fake_module(fake_mod_data) if custom_paths or self.cfg["sanity_check_paths"] or custom_commands or self.cfg["sanity_check_commands"]: EasyBlock.sanity_check_step( self, custom_paths=custom_paths, custom_commands=custom_commands, extension=self.is_extension ) # pass or fail sanity check if not sanity_check_ok: msg = "Sanity check for %s failed: %s" % (self.name, "; ".join(self.sanity_check_fail_msgs)) if self.is_extension: self.log.warning(msg) else: self.log.error(msg) return False else: self.log.info("Sanity check for %s successful!" % self.name) return True
def test_exts_list(self): """Test handling of list of extensions.""" self.contents = '\n'.join([ 'name = "pi"', 'version = "3.14"', 'homepage = "http://example.com"', 'description = "test easyconfig"', 'toolchain = {"name": "dummy", "version": "dummy"}', 'exts_list = [', ' ("ext1", "ext_ver1", {', ' "source_tmpl": "gzip-1.4.eb",', # dummy source template to avoid downloading fail ' "source_urls": ["http://example.com/"]', ' }),', ' ("ext2", "ext_ver2", {', ' "source_tmpl": "gzip-1.4.eb",', # dummy source template to avoid downloading fail ' "source_urls": [("http://example.com", "suffix")],' ' "patches": ["toy-0.0.eb"],', # dummy patch to avoid downloading fail ' "checksums": [', ' "673085af5622393e543b9ea31f66c590",', # checksum for source (gzip-1.4.eb) ' "5e82b0e9faa5753545bb6da12d88d04b",', # checksum for patch () ' ],', ' }),', ']', ]) self.prep() eb = EasyBlock(self.eb_file) exts_sources = eb.fetch_extension_sources()
def test_buildininstalldir(self): """Test specifying build in install dir.""" config.variables['buildpath'] = tempfile.mkdtemp() config.variables['installpath'] = tempfile.mkdtemp() self.contents = '\n'.join([ 'name = "pi"', 'version = "3.14"', 'homepage = "http://example.com"', 'description = "test easyconfig"', 'toolchain = {"name": "dummy", "version": "dummy"}', 'buildininstalldir = True', ]) self.prep() eb = EasyBlock(self.eb_file) eb.gen_builddir() eb.mod_name = det_full_module_name(eb.cfg) # required by gen_installdir() eb.gen_installdir() eb.make_builddir() eb.make_installdir() self.assertEqual(eb.builddir, eb.installdir) self.assertTrue(os.path.isdir(eb.builddir)) # cleanup shutil.rmtree(config.variables['buildpath']) shutil.rmtree(config.variables['installpath'])
def test_exts_list(self): """Test handling of list of extensions.""" os.environ['EASYBUILD_SOURCEPATH'] = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'easyconfigs') init_config() self.contents = '\n'.join([ 'name = "pi"', 'version = "3.14"', 'homepage = "http://example.com"', 'description = "test easyconfig"', 'toolchain = {"name": "dummy", "version": "dummy"}', 'exts_list = [', ' ("ext1", "ext_ver1", {', ' "source_tmpl": "gzip-1.4.eb",', # dummy source template to avoid downloading fail ' "source_urls": ["http://example.com/"]', ' }),', ' ("ext2", "ext_ver2", {', ' "source_tmpl": "gzip-1.4.eb",', # dummy source template to avoid downloading fail ' "source_urls": [("http://example.com", "suffix")],' ' "patches": ["toy-0.0.eb"],', # dummy patch to avoid downloading fail ' "checksums": [', ' "504c7036558938f997c1c269a01d7458",', # checksum for source (gzip-1.4.eb) ' "ddd5161154f5db67701525123129ff09",', # checksum for patch (toy-0.0.eb) ' ],', ' }),', ']', ]) self.prep() ec = EasyConfig(self.eb_file) eb = EasyBlock(ec) exts_sources = eb.fetch_extension_sources()
def extra_options(extra_vars=None): """Extra easyconfig parameters specific to Binary easyblock.""" extra_vars = dict(EasyBlock.extra_options(extra_vars)) extra_vars.update({ 'install_cmd': [None, "Install command to be used.", CUSTOM], }) return EasyBlock.extra_options(extra_vars)
def test_make_module_req(self): """Testcase for make_module_req""" self.contents = '\n'.join([ 'name = "pi"', 'version = "3.14"', 'homepage = "http://example.com"', 'description = "test easyconfig"', 'toolchain = {"name":"dummy", "version": "dummy"}', ]) self.writeEC() eb = EasyBlock(EasyConfig(self.eb_file)) eb.installdir = config.install_path() # create fake directories and files that should be guessed os.makedirs(eb.installdir) open(os.path.join(eb.installdir, 'foo.jar'), 'w').write('foo.jar') open(os.path.join(eb.installdir, 'bla.jar'), 'w').write('bla.jar') os.mkdir(os.path.join(eb.installdir, 'bin')) os.mkdir(os.path.join(eb.installdir, 'share')) os.mkdir(os.path.join(eb.installdir, 'share', 'man')) # this is not a path that should be picked up os.mkdir(os.path.join(eb.installdir, 'CPATH')) guess = eb.make_module_req() self.assertTrue(re.search("^prepend-path\s+CLASSPATH\s+\$root/bla.jar$", guess, re.M)) self.assertTrue(re.search("^prepend-path\s+CLASSPATH\s+\$root/foo.jar$", guess, re.M)) self.assertTrue(re.search("^prepend-path\s+MANPATH\s+\$root/share/man$", guess, re.M)) self.assertTrue(re.search("^prepend-path\s+PATH\s+\$root/bin$", guess, re.M)) self.assertFalse(re.search("^prepend-path\s+CPATH\s+.*$", guess, re.M)) # cleanup eb.close_log() os.remove(eb.logfile)
def sanity_check_step(self, exts_filter, custom_paths=None, custom_commands=None): """ Custom sanity check for extensions, whether installed as stand-alone module or not """ if not self.cfg["exts_filter"]: self.cfg["exts_filter"] = exts_filter if not self.is_extension: # load fake module fake_mod_data = self.load_fake_module(purge=True) # perform sanity check sanity_check_ok = Extension.sanity_check_step(self) if not self.is_extension: # unload fake module and clean up self.clean_up_fake_module(fake_mod_data) if custom_paths or custom_commands: EasyBlock.sanity_check_step(self, custom_paths=custom_paths, custom_commands=custom_commands) # pass or fail sanity check if not sanity_check_ok: if self.is_extension: self.log.warning("Sanity check for %s failed!" % self.name) else: self.log.error("Sanity check for %s failed!" % self.name) return False else: self.log.info("Sanity check for %s successful!" % self.name) return True
def runTest(self): """ extra_options should allow other variables to be stored """ eb = EasyBlock(self.eb_file) self.assertRaises(KeyError, lambda: eb['custom_key']) extra_vars = { 'custom_key': ['default', "This is a default key"]} eb = EasyBlock(self.eb_file, extra_vars) self.assertEqual(eb['custom_key'], 'default') eb['custom_key'] = "not so default" self.assertEqual(eb['custom_key'], 'not so default') self.contents += "\ncustom_key = 'test'" self.setUp() eb = EasyBlock(self.eb_file, extra_vars) self.assertEqual(eb['custom_key'], 'test') eb['custom_key'] = "not so default" self.assertEqual(eb['custom_key'], 'not so default') # test if extra toolkit options are being passed self.assertEqual(eb.toolkit().opts['static'], True)
def test_make_module_step(self): """Test the make_module_step""" name = "pi" version = "3.14" deps = [("GCC", "4.6.4")] hiddendeps = [("toy", "0.0-deps")] alldeps = deps + hiddendeps # hidden deps must be included in list of deps modextravars = {"PI": "3.1415", "FOO": "bar"} modextrapaths = {"PATH": "pibin", "CPATH": "pi/include"} self.contents = "\n".join( [ 'name = "%s"' % name, 'version = "%s"' % version, 'homepage = "http://example.com"', 'description = "test easyconfig"', "toolchain = {'name': 'dummy', 'version': 'dummy'}", "dependencies = %s" % str(alldeps), "hiddendependencies = %s" % str(hiddendeps), "builddependencies = [('OpenMPI', '1.6.4-GCC-4.6.4')]", "modextravars = %s" % str(modextravars), "modextrapaths = %s" % str(modextrapaths), ] ) test_dir = os.path.dirname(os.path.abspath(__file__)) os.environ["MODULEPATH"] = os.path.join(test_dir, "modules") # test if module is generated correctly self.writeEC() ec = EasyConfig(self.eb_file) eb = EasyBlock(ec) # eb.builddir = self.test_buildpath eb.installdir = os.path.join(config.install_path(), "pi", "3.14") eb.check_readiness_step() modpath = os.path.join(eb.make_module_step(), name, version) self.assertTrue(os.path.exists(modpath), "%s exists" % modpath) # verify contents of module f = open(modpath, "r") txt = f.read() f.close() self.assertTrue(re.search("^#%Module", txt.split("\n")[0])) self.assertTrue(re.search("^conflict\s+%s$" % name, txt, re.M)) self.assertTrue(re.search("^set\s+root\s+%s$" % eb.installdir, txt, re.M)) self.assertTrue(re.search('^setenv\s+EBROOT%s\s+".root"\s*$' % name.upper(), txt, re.M)) self.assertTrue(re.search('^setenv\s+EBVERSION%s\s+"%s"$' % (name.upper(), version), txt, re.M)) for (key, val) in modextravars.items(): regex = re.compile('^setenv\s+%s\s+"%s"$' % (key, val), re.M) self.assertTrue(regex.search(txt), "Pattern %s found in %s" % (regex.pattern, txt)) for (key, val) in modextrapaths.items(): regex = re.compile("^prepend-path\s+%s\s+\$root/%s$" % (key, val), re.M) self.assertTrue(regex.search(txt), "Pattern %s found in %s" % (regex.pattern, txt)) for (name, ver) in deps: regex = re.compile("^\s*module load %s\s*$" % os.path.join(name, ver), re.M) self.assertTrue(regex.search(txt), "Pattern %s found in %s" % (regex.pattern, txt)) for (name, ver) in hiddendeps: regex = re.compile("^\s*module load %s/.%s\s*$" % (name, ver), re.M) self.assertTrue(regex.search(txt), "Pattern %s found in %s" % (regex.pattern, txt))
def extra_options(extra_vars=None): """Extra easyconfig parameters specific to ConfigureMake.""" extra_vars = dict(EasyBlock.extra_options(extra_vars)) extra_vars.update({ 'tar_config_opts': [False, "Override tar settings as determined by configure.", CUSTOM], 'prefix_opt': ['--prefix=', "Prefix command line option for configure script", CUSTOM], }) return EasyBlock.extra_options(extra_vars)
def extra_options(extra_vars=None): """Extra easyconfig parameters specific to RPMs.""" extra_vars = dict(EasyBlock.extra_options(extra_vars)) extra_vars.update({ 'force': [False, "Use force", CUSTOM], 'preinstall': [False, "Enable pre install", CUSTOM], 'postinstall': [False, "Enable post install", CUSTOM], 'makesymlinks': [[], "Create symlinks for listed paths", CUSTOM], # supports glob }) return EasyBlock.extra_options(extra_vars)
def test_exclude_path_to_top_of_module_tree(self): """ Make sure that modules under the HierarchicalMNS are correct, w.r.t. not including any load statements for modules that build up the path to the top of the module tree. """ self.orig_module_naming_scheme = config.get_module_naming_scheme() test_ecs_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'easyconfigs') all_stops = [x[0] for x in EasyBlock.get_steps()] build_options = { 'check_osdeps': False, 'robot_path': [test_ecs_path], 'valid_stops': all_stops, 'validate': False, } os.environ['EASYBUILD_MODULE_NAMING_SCHEME'] = 'HierarchicalMNS' init_config(build_options=build_options) self.setup_hierarchical_modules() modfile_prefix = os.path.join(self.test_installpath, 'modules', 'all') mkdir(os.path.join(modfile_prefix, 'Compiler', 'GCC', '4.8.3'), parents=True) mkdir(os.path.join(modfile_prefix, 'MPI', 'intel', '2013.5.192-GCC-4.8.3', 'impi', '4.1.3.049'), parents=True) impi_modfile_path = os.path.join('Compiler', 'intel', '2013.5.192-GCC-4.8.3', 'impi', '4.1.3.049') imkl_modfile_path = os.path.join('MPI', 'intel', '2013.5.192-GCC-4.8.3', 'impi', '4.1.3.049', 'imkl', '11.1.2.144') if get_module_syntax() == 'Lua': impi_modfile_path += '.lua' imkl_modfile_path += '.lua' # example: for imkl on top of iimpi toolchain with HierarchicalMNS, no module load statements should be included # not for the toolchain or any of the toolchain components, # since both icc/ifort and impi form the path to the top of the module tree tests = [ ('impi-4.1.3.049-iccifort-2013.5.192-GCC-4.8.3.eb', impi_modfile_path, ['icc', 'ifort', 'iccifort']), ('imkl-11.1.2.144-iimpi-5.5.3-GCC-4.8.3.eb', imkl_modfile_path, ['icc', 'ifort', 'impi', 'iccifort', 'iimpi']), ] for ec_file, modfile_path, excluded_deps in tests: ec = EasyConfig(os.path.join(test_ecs_path, ec_file)) eb = EasyBlock(ec) eb.toolchain.prepare() modpath = eb.make_module_step() modfile_path = os.path.join(modpath, modfile_path) modtxt = read_file(modfile_path) for dep in excluded_deps: tup = (dep, modfile_path, modtxt) failmsg = "No 'module load' statement found for '%s' not found in module %s: %s" % tup if get_module_syntax() == 'Tcl': self.assertFalse(re.search('module load %s' % dep, modtxt), failmsg) elif get_module_syntax() == 'Lua': self.assertFalse(re.search('load("%s")' % dep, modtxt), failmsg) else: self.assertTrue(False, "Unknown module syntax: %s" % get_module_syntax()) os.environ['EASYBUILD_MODULE_NAMING_SCHEME'] = self.orig_module_naming_scheme init_config(build_options=build_options)
def test_extensions_step(self): """Test the extensions_step""" self.contents = """ name = "pi" version = "3.14" homepage = "http://example.com" description = "test easyconfig" toolchain = {"name":"dummy", "version": "dummy"} exts_list = ['ext1'] """ self.writeEC() """Testcase for extensions""" # test for proper error message without the exts_defaultclass set eb = EasyBlock(self.eb_file) eb.installdir = config.variables['installpath'] self.assertRaises(EasyBuildError, eb.extensions_step) self.assertErrorRegex(EasyBuildError, "No default extension class set", eb.extensions_step) # test if everything works fine if set self.contents += "\nexts_defaultclass = ['easybuild.framework.extension', 'Extension']" self.writeEC() eb = EasyBlock(self.eb_file) eb.builddir = config.variables['buildpath'] eb.installdir = config.variables['installpath'] eb.extensions_step() # test for proper error message when skip is set, but no exts_filter is set self.assertRaises(EasyBuildError, eb.skip_extensions) self.assertErrorRegex(EasyBuildError, "no exts_filter set", eb.skip_extensions) # cleanup eb.close_log() os.remove(eb.logfile)
def test_extensions_step(self): """Test the extensions_step""" self.contents = '\n'.join([ 'easyblock = "ConfigureMake"', 'name = "pi"', 'version = "3.14"', 'homepage = "http://example.com"', 'description = "test easyconfig"', 'toolchain = {"name": "dummy", "version": "dummy"}', 'exts_list = ["ext1"]', ]) self.writeEC() """Testcase for extensions""" # test for proper error message without the exts_defaultclass set eb = EasyBlock(EasyConfig(self.eb_file)) eb.installdir = config.install_path() self.assertRaises(EasyBuildError, eb.extensions_step, fetch=True) self.assertErrorRegex(EasyBuildError, "No default extension class set", eb.extensions_step, fetch=True) # test if everything works fine if set self.contents += "\nexts_defaultclass = 'DummyExtension'" self.writeEC() eb = EasyBlock(EasyConfig(self.eb_file)) eb.builddir = config.build_path() eb.installdir = config.install_path() eb.extensions_step(fetch=True) # test for proper error message when skip is set, but no exts_filter is set self.assertRaises(EasyBuildError, eb.skip_extensions) self.assertErrorRegex(EasyBuildError, "no exts_filter set", eb.skip_extensions) # cleanup eb.close_log() os.remove(eb.logfile)
def test_exclude_path_to_top_of_module_tree(self): """ Make sure that modules under the HierarchicalMNS are correct, w.r.t. not including any load statements for modules that build up the path to the top of the module tree. """ self.orig_module_naming_scheme = config.get_module_naming_scheme() test_ecs_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "easyconfigs") all_stops = [x[0] for x in EasyBlock.get_steps()] build_options = { "check_osdeps": False, "robot_path": [test_ecs_path], "valid_stops": all_stops, "validate": False, } os.environ["EASYBUILD_MODULE_NAMING_SCHEME"] = "HierarchicalMNS" init_config(build_options=build_options) self.setup_hierarchical_modules() modtool = modules_tool() modfile_prefix = os.path.join(self.test_installpath, "modules", "all") mkdir(os.path.join(modfile_prefix, "Compiler", "GCC", "4.8.3"), parents=True) mkdir(os.path.join(modfile_prefix, "MPI", "intel", "2013.5.192-GCC-4.8.3", "impi", "4.1.3.049"), parents=True) impi_modfile_path = os.path.join("Compiler", "intel", "2013.5.192-GCC-4.8.3", "impi", "4.1.3.049") imkl_modfile_path = os.path.join( "MPI", "intel", "2013.5.192-GCC-4.8.3", "impi", "4.1.3.049", "imkl", "11.1.2.144" ) # example: for imkl on top of iimpi toolchain with HierarchicalMNS, no module load statements should be included # not for the toolchain or any of the toolchain components, # since both icc/ifort and impi form the path to the top of the module tree tests = [ ("impi-4.1.3.049-iccifort-2013.5.192-GCC-4.8.3.eb", impi_modfile_path, ["icc", "ifort", "iccifort"]), ( "imkl-11.1.2.144-iimpi-5.5.3-GCC-4.8.3.eb", imkl_modfile_path, ["icc", "ifort", "impi", "iccifort", "iimpi"], ), ] for ec_file, modfile_path, excluded_deps in tests: ec = EasyConfig(os.path.join(test_ecs_path, ec_file)) eb = EasyBlock(ec) eb.toolchain.prepare() modpath = eb.make_module_step() modfile_path = os.path.join(modpath, modfile_path) modtxt = read_file(modfile_path) for imkl_dep in excluded_deps: tup = (imkl_dep, modfile_path, modtxt) failmsg = "No 'module load' statement found for '%s' not found in module %s: %s" % tup self.assertFalse(re.search("module load %s" % imkl_dep, modtxt), failmsg) os.environ["EASYBUILD_MODULE_NAMING_SCHEME"] = self.orig_module_naming_scheme init_config(build_options=build_options)
def test_fake_module_load(self): """Testcase for fake module load""" self.contents = """ name = "pi" version = "3.14" homepage = "http://google.com" description = "test easyconfig" toolchain = {"name":"dummy", "version": "dummy"} """ self.writeEC() eb = EasyBlock(self.eb_file) eb.installdir = config.variables['install_path'] eb.load_fake_module()
def test_skip_extensions_step(self): """Test the skip_extensions_step""" self.contents = """ name = "pi" version = "3.14" homepage = "http://example.com" description = "test easyconfig" toolchain = {"name":"dummy", "version": "dummy"} exts_list = ['ext1', 'ext2'] exts_filter = ("if [ %(name)s == 'ext2' ]; then exit 0; else exit 1; fi", '') exts_defaultclass = ['easybuild.framework.extension', 'Extension'] """ # check if skip skips correct extensions self.writeEC() eb = EasyBlock(self.eb_file) #self.assertTrue('ext1' in eb.exts.keys() and 'ext2' in eb.exts.keys()) eb.builddir = config.variables['buildpath'] eb.installdir = config.variables['installpath'] eb.skip = True eb.extensions_step() # 'ext1' should be in eb.exts self.assertTrue('ext1' in [y for x in eb.exts for y in x.values()]) # 'ext2' should not self.assertFalse('ext2' in [y for x in eb.exts for y in x.values()]) # cleanup eb.close_log() os.remove(eb.logfile)
def test_prepare_step(self): """Test prepare step (setting up build environment).""" test_easyconfigs = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'easyconfigs', 'test_ecs') ec = process_easyconfig(os.path.join(test_easyconfigs, 't', 'toy', 'toy-0.0.eb'))[0] mkdir(os.path.join(self.test_buildpath, 'toy', '0.0', 'dummy-dummy'), parents=True) eb = EasyBlock(ec['ec']) eb.silent = True eb.prepare_step() self.assertEqual(self.modtool.list(), []) os.environ['THIS_IS_AN_UNWANTED_ENV_VAR'] = 'foo' eb.cfg['unwanted_env_vars'] = ['THIS_IS_AN_UNWANTED_ENV_VAR'] eb.cfg['allow_system_deps'] = [('Python', '1.2.3')] init_config(build_options={'extra_modules': ['GCC/4.7.2']}) eb.prepare_step() self.assertEqual(os.environ.get('THIS_IS_AN_UNWANTED_ENV_VAR'), None) self.assertEqual(os.environ.get('EBROOTPYTHON'), 'Python') self.assertEqual(os.environ.get('EBVERSIONPYTHON'), '1.2.3') self.assertEqual(len(self.modtool.list()), 1) self.assertEqual(self.modtool.list()[0]['mod_name'], 'GCC/4.7.2')
def test_make_module_extra(self): """Test for make_module_extra.""" self.contents = '\n'.join([ 'easyblock = "ConfigureMake"', 'name = "pi"', 'version = "3.14"', 'homepage = "http://example.com"', 'description = "test easyconfig"', "toolchain = {'name': 'gompi', 'version': '1.1.0-no-OFED'}", 'dependencies = [', " ('FFTW', '3.3.1'),", " ('LAPACK', '3.4.0'),", ']', ]) self.writeEC() eb = EasyBlock(EasyConfig(self.eb_file)) eb.installdir = os.path.join(config.install_path(), 'pi', '3.14') if get_module_syntax() == 'Tcl': expected_default = re.compile(r'\n'.join([ r'setenv\s+EBROOTPI\s+\"\$root"', r'setenv\s+EBVERSIONPI\s+"3.14"', r'setenv\s+EBDEVELPI\s+"\$root/easybuild/pi-3.14-gompi-1.1.0-no-OFED-easybuild-devel"', ])) expected_alt = re.compile(r'\n'.join([ r'setenv\s+EBROOTPI\s+"/opt/software/tau/6.28"', r'setenv\s+EBVERSIONPI\s+"6.28"', r'setenv\s+EBDEVELPI\s+"\$root/easybuild/pi-3.14-gompi-1.1.0-no-OFED-easybuild-devel"', ])) elif get_module_syntax() == 'Lua': expected_default = re.compile(r'\n'.join([ r'setenv\("EBROOTPI", root\)', r'setenv\("EBVERSIONPI", "3.14"\)', r'setenv\("EBDEVELPI", pathJoin\(root, "easybuild/pi-3.14-gompi-1.1.0-no-OFED-easybuild-devel"\)\)', ])) expected_alt = re.compile(r'\n'.join([ r'setenv\("EBROOTPI", "/opt/software/tau/6.28"\)', r'setenv\("EBVERSIONPI", "6.28"\)', r'setenv\("EBDEVELPI", pathJoin\(root, "easybuild/pi-3.14-gompi-1.1.0-no-OFED-easybuild-devel"\)\)', ])) else: self.assertTrue(False, "Unknown module syntax: %s" % get_module_syntax()) defaulttxt = eb.make_module_extra().strip() self.assertTrue(expected_default.match(defaulttxt), "Pattern %s found in %s" % (expected_default.pattern, defaulttxt)) alttxt = eb.make_module_extra(altroot='/opt/software/tau/6.28', altversion='6.28').strip() self.assertTrue(expected_alt.match(alttxt), "Pattern %s found in %s" % (expected_alt.pattern, alttxt))
def test_skip_extensions_step(self): """Test the skip_extensions_step""" self.contents = '\n'.join([ 'easyblock = "ConfigureMake"', 'name = "pi"', 'version = "3.14"', 'homepage = "http://example.com"', 'description = "test easyconfig"', 'toolchain = {"name": "dummy", "version": "dummy"}', 'exts_list = ["ext1", "ext2"]', 'exts_filter = ("if [ %(ext_name)s == \'ext2\' ]; then exit 0; else exit 1; fi", "")', 'exts_defaultclass = "DummyExtension"', ]) # check if skip skips correct extensions self.writeEC() eb = EasyBlock(EasyConfig(self.eb_file)) eb.builddir = config.build_path() eb.installdir = config.install_path() eb.skip = True eb.extensions_step(fetch=True) # 'ext1' should be in eb.exts self.assertTrue('ext1' in [y for x in eb.exts for y in x.values()]) # 'ext2' should not self.assertFalse('ext2' in [y for x in eb.exts for y in x.values()]) # cleanup eb.close_log() os.remove(eb.logfile)
def make_module_extra(self, extra=None): """Add custom entries to module.""" txt = EasyBlock.make_module_extra(self) if not extra is None: txt += extra return txt
def extra_options(): """Add extra easyconfig parameters custom to CHARMM.""" extra_vars = { 'build_options': ["FULL", "Specify the options to the build script", CUSTOM], 'system_size': ["medium", "Specify the supported systemsize: %s" % ', '.join(KNOWN_SYSTEM_SIZES), CUSTOM], } return EasyBlock.extra_options(extra_vars)
def extra_options(): """Custom easyconfig parameters for bar.""" extra_vars = { 'bar_extra1': [None, "first bar-specific easyconfig parameter (mandatory)", MANDATORY], 'bar_extra2': ['BAR', "second bar-specific easyconfig parameter", CUSTOM], } return EasyBlock.extra_options(extra_vars)
def extra_options(): """Add extra easyconfig parameters for Boost.""" extra_vars = { 'boost_mpi': [False, "Build mpi boost module", CUSTOM], 'toolset': [None, "Toolset to use for Boost configuration ('--with-toolset for bootstrap.sh')", CUSTOM], } return EasyBlock.extra_options(extra_vars)
def extra_options(): """Custom easyconfig parameters for ALADIN.""" extra_vars = { 'optional_extra_param': ['default value', "short description", CUSTOM], } return EasyBlock.extra_options(extra_vars)
def test_path_to_top_of_module_tree_categorized_hmns(self): """ Test function to determine path to top of the module tree for a categorized hierarchical module naming scheme. """ ecs_dir = os.path.join(os.path.dirname(__file__), 'easyconfigs') all_stops = [x[0] for x in EasyBlock.get_steps()] build_options = { 'check_osdeps': False, 'robot_path': [ecs_dir], 'valid_stops': all_stops, 'validate': False, } os.environ['EASYBUILD_MODULE_NAMING_SCHEME'] = 'CategorizedHMNS' init_config(build_options=build_options) self.setup_categorized_hmns_modules() modtool = modules_tool() mod_prefix = os.path.join(self.test_installpath, 'modules', 'all') init_modpaths = [os.path.join(mod_prefix, 'Core', 'compiler'), os.path.join(mod_prefix, 'Core', 'toolchain')] deps = ['GCC/4.7.2', 'OpenMPI/1.6.4', 'FFTW/3.3.3', 'OpenBLAS/0.2.6-LAPACK-3.4.2', 'ScaLAPACK/2.0.2-OpenBLAS-0.2.6-LAPACK-3.4.2'] path = modtool.path_to_top_of_module_tree(init_modpaths, 'goolf/1.4.10', os.path.join(mod_prefix, 'Core', 'toolchain'), deps) self.assertEqual(path, []) path = modtool.path_to_top_of_module_tree(init_modpaths, 'GCC/4.7.2', os.path.join(mod_prefix, 'Core', 'compiler'), []) self.assertEqual(path, []) full_mod_subdir = os.path.join(mod_prefix, 'Compiler', 'GCC', '4.7.2', 'mpi') deps = ['GCC/4.7.2', 'hwloc/1.6.2'] path = modtool.path_to_top_of_module_tree(init_modpaths, 'OpenMPI/1.6.4', full_mod_subdir, deps) self.assertEqual(path, ['GCC/4.7.2']) full_mod_subdir = os.path.join(mod_prefix, 'MPI', 'GCC', '4.7.2', 'OpenMPI', '1.6.4', 'numlib') deps = ['GCC/4.7.2', 'OpenMPI/1.6.4'] path = modtool.path_to_top_of_module_tree(init_modpaths, 'FFTW/3.3.3', full_mod_subdir, deps) self.assertEqual(path, ['OpenMPI/1.6.4', 'GCC/4.7.2'])
def extra_options(): extra_vars = { 'buildtype': [None, "Specify the type of build (smpar: OpenMP, dmpar: MPI).", MANDATORY], 'runtest': [True, "Build and run WPS tests", CUSTOM], 'testdata': [None, "URL to test data required to run WPS test", CUSTOM], } return EasyBlock.extra_options(extra_vars)
def basic_options(self): """basic runtime options""" all_stops = [x[0] for x in EasyBlock.get_steps()] strictness_options = [run.IGNORE, run.WARN, run.ERROR] try: default_robot_path = get_paths_for("easyconfigs", robot_path=None)[0] except: self.log.warning("basic_options: unable to determine default easyconfig path") default_robot_path = False # False as opposed to None, since None is used for indicating that --robot was not used descr = ("Basic options", "Basic runtime options for EasyBuild.") opts = OrderedDict({ 'dry-run': ("Print build overview incl. dependencies (full paths)", None, 'store_true', False), 'dry-run-short': ("Print build overview incl. dependencies (short paths)", None, 'store_true', False, 'D'), 'force': ("Force to rebuild software even if it's already installed (i.e. if it can be found as module)", None, 'store_true', False, 'f'), 'job': ("Submit the build as a job", None, 'store_true', False), 'logtostdout': ("Redirect main log to stdout", None, 'store_true', False, 'l'), 'only-blocks': ("Only build listed blocks", None, 'extend', None, 'b', {'metavar': 'BLOCKS'}), 'robot': ("Path(s) to search for easyconfigs for missing dependencies (colon-separated)" , None, 'store_or_None', default_robot_path, 'r', {'metavar': 'PATH'}), 'skip': ("Skip existing software (useful for installing additional packages)", None, 'store_true', False, 'k'), 'stop': ("Stop the installation after certain step", 'choice', 'store_or_None', 'source', 's', all_stops), 'strict': ("Set strictness level", 'choice', 'store', run.WARN, strictness_options), }) self.log.debug("basic_options: descr %s opts %s" % (descr, opts)) self.add_group_parser(opts, descr)
def basic_options(self): """basic runtime options""" all_stops = [x[0] for x in EasyBlock.get_steps()] strictness_options = [run.IGNORE, run.WARN, run.ERROR] descr = ("Basic options", "Basic runtime options for EasyBuild.") opts = OrderedDict({ 'dry-run': ("Print build overview incl. dependencies (full paths)", None, 'store_true', False), 'dry-run-short': ("Print build overview incl. dependencies (short paths)", None, 'store_true', False, 'D'), 'force': ("Force to rebuild software even if it's already installed (i.e. if it can be found as module)", None, 'store_true', False, 'f'), 'job': ("Submit the build as a job", None, 'store_true', False), 'logtostdout': ("Redirect main log to stdout", None, 'store_true', False, 'l'), 'only-blocks': ("Only build listed blocks", None, 'extend', None, 'b', {'metavar': 'BLOCKS'}), 'robot': ("Enable dependency resolution, using easyconfigs in specified paths", 'pathlist', 'store_or_None', [], 'r', {'metavar': 'PATH[%sPATH]' % os.pathsep}), 'robot-paths': ("Additional paths to consider by robot for easyconfigs (--robot paths get priority)", 'pathlist', 'add_flex', self.default_robot_paths, {'metavar': 'PATH[%sPATH]' % os.pathsep}), 'skip': ("Skip existing software (useful for installing additional packages)", None, 'store_true', False, 'k'), 'stop': ("Stop the installation after certain step", 'choice', 'store_or_None', SOURCE_STEP, 's', all_stops), 'strict': ("Set strictness level", 'choice', 'store', DEFAULT_STRICT, strictness_options), }) self.log.debug("basic_options: descr %s opts %s" % (descr, opts)) self.add_group_parser(opts, descr)
def extra_options(): extra_vars = { 'java_options': [ '-Xmx256m', "$_JAVA_OPTIONS value set for install and in module file.", CUSTOM ], } return EasyBlock.extra_options(extra_vars)
def extra_options(): """Custom easyconfig parameters for NEMO.""" extra_vars = { 'with_components': [None, "List of components to include (e.g. TOP_SRC)", MANDATORY], 'add_keys': [None, "Add compilation keys", CUSTOM], 'del_keys': [None, "Delete compilation keys", CUSTOM] } return EasyBlock.extra_options(extra_vars)
def process_easyconfig(path, onlyBlocks=None, regtest_online=False, validate=True): """ Process easyconfig, returning some information for each block """ blocks = retrieve_blocks_in_spec(path, onlyBlocks) easyconfigs = [] for spec in blocks: # process for dependencies and real installversionname # - use mod? __init__ and importCfg are ignored. _log.debug("Processing easyconfig %s" % spec) # create easyconfig try: all_stops = [x[0] for x in EasyBlock.get_steps()] ec = EasyConfig(spec, validate=validate, valid_module_classes=module_classes(), valid_stops=all_stops) except EasyBuildError, err: msg = "Failed to process easyconfig %s:\n%s" % (spec, err.msg) _log.exception(msg) name = ec['name'] # this app will appear as following module in the list easyconfig = { 'spec': spec, 'module': (ec.name, ec.get_installversion()), 'dependencies': [], 'builddependencies': [], } if len(blocks) > 1: easyconfig['originalSpec'] = path # add build dependencies for dep in ec.builddependencies(): deptup = (dep['name'], dep['tc']) _log.debug("Adding build dependency %s for app %s." % (deptup, name)) easyconfig['builddependencies'].append(deptup) # add dependencies (including build dependencies) for dep in ec.dependencies(): deptup = (dep['name'], dep['tc']) _log.debug("Adding dependency %s for app %s." % (deptup, name)) easyconfig['dependencies'].append(deptup) # add toolchain as dependency too if ec.toolchain.name != 'dummy': dep = (ec.toolchain.name, ec.toolchain.version) _log.debug("Adding toolchain %s as dependency for app %s." % (dep, name)) easyconfig['dependencies'].append(dep) del ec # this is used by the parallel builder easyconfig['unresolvedDependencies'] = copy.copy(easyconfig['dependencies']) easyconfigs.append(easyconfig)
class EasyConfigTest(TestCase): """Baseclass for easyconfig testcases.""" # initialize configuration (required for e.g. default modules_tool setting) eb_go = eboptions.parse_options() config.init(eb_go.options, eb_go.get_options_by_section('config')) build_options = { 'check_osdeps': False, 'force': True, 'robot_path': get_paths_for("easyconfigs")[0], 'suffix_modules_path': GENERAL_CLASS, 'valid_module_classes': config.module_classes(), 'valid_stops': [x[0] for x in EasyBlock.get_steps()], } config.init_build_options(build_options=build_options) config.set_tmpdir() del eb_go log = fancylogger.getLogger("EasyConfigTest", fname=False) # make sure a logger is present for main main._log = log ordered_specs = None parsed_easyconfigs = [] def process_all_easyconfigs(self): """Process all easyconfigs and resolve inter-easyconfig dependencies.""" # all available easyconfig files easyconfigs_path = get_paths_for("easyconfigs")[0] specs = glob.glob('%s/*/*/*.eb' % easyconfigs_path) # parse all easyconfigs if they haven't been already if not self.parsed_easyconfigs: for spec in specs: self.parsed_easyconfigs.extend(process_easyconfig(spec)) self.ordered_specs = resolve_dependencies(self.parsed_easyconfigs) def test_dep_graph(self): """Unit test that builds a full dependency graph.""" # pygraph dependencies required for constructing dependency graph are not available prior to Python 2.6 if LooseVersion( sys.version) >= LooseVersion('2.6') and single_tests_ok: # temporary file for dep graph (hn, fn) = tempfile.mkstemp(suffix='.dot') os.close(hn) if self.ordered_specs is None: self.process_all_easyconfigs() dep_graph(fn, self.ordered_specs, silent=True) try: os.remove(fn) except OSError, err: log.error("Failed to remove %s: %s" % (fn, err)) else:
def extra_options(): """Define custom easyconfig parameters for GAMESS-US.""" extra_vars = { 'ddi_comm': ['mpi', "DDI communication layer to use", CUSTOM], 'maxcpus': [None, "Maximum number of cores per node", MANDATORY], 'maxnodes': [None, "Maximum number of nodes", MANDATORY], 'runtest': [True, "Run GAMESS-US tests", CUSTOM], 'scratch_dir': ['$TMPDIR', "Scratch dir to be used in rungms script", CUSTOM], } return EasyBlock.extra_options(extra_vars)
def extra_options(more_extra_vars=None): """Custom easyconfig parameters for foo.""" if more_extra_vars is None: more_extra_vars = {} extra_vars = { 'foo_extra1': [None, "first foo-specific easyconfig parameter (mandatory)", MANDATORY], 'foo_extra2': ['FOO', "second foo-specific easyconfig parameter", CUSTOM], } extra_vars.update(more_extra_vars) return EasyBlock.extra_options(extra_vars)
def extra_options(): """Custom easyconfig parameters for Trinity.""" extra_vars = [ ('withsampledata', [False, "Include sample data", CUSTOM]), ('bwapluginver', [None, "BWA pugin version", CUSTOM]), ('RSEMmod', [False, "Enable RSEMmod", CUSTOM]), ] return EasyBlock.extra_options(extra_vars)
def extra_options(): """Custom easyconfig parameters for WRF-Fire.""" extra_vars = { 'buildtype': [ None, "Specify the type of build (serial, smpar (OpenMP), " "dmpar (MPI), dm+sm (hybrid OpenMP/MPI)).", MANDATORY ], 'runtest': [True, "Build and run WRF tests", CUSTOM], } return EasyBlock.extra_options(extra_vars)
def sanity_check_step(self, exts_filter=None, custom_paths=None, custom_commands=None): """ Custom sanity check for extensions, whether installed as stand-alone module or not """ if not self.cfg['exts_filter']: self.cfg['exts_filter'] = exts_filter self.log.debug("starting sanity check for extension with filter %s", self.cfg['exts_filter']) if not self.is_extension: # load fake module fake_mod_data = self.load_fake_module(purge=True) # perform sanity check sanity_check_ok = Extension.sanity_check_step(self) if not self.is_extension: # unload fake module and clean up self.clean_up_fake_module(fake_mod_data) if custom_paths or self.cfg[ 'sanity_check_paths'] or custom_commands or self.cfg[ 'sanity_check_commands']: EasyBlock.sanity_check_step(self, custom_paths=custom_paths, custom_commands=custom_commands, extension=self.is_extension) # pass or fail sanity check if not sanity_check_ok: msg = "Sanity check for %s failed: %s" % (self.name, '; '.join( self.sanity_check_fail_msgs)) if self.is_extension: self.log.warning(msg) else: raise EasyBuildError(msg) return False else: self.log.info("Sanity check for %s successful!" % self.name) return True
def extra_options(extra_vars=None): """Extra easyconfig parameters specific to EB_jhbuild.""" extra_vars = EasyBlock.extra_options(extra=extra_vars) extra_vars.update({ 'jhbuildrc_file': [ 'jhbuildrc', "File that contains the jhbuild configuration", CUSTOM ], }) return extra_vars
def extra_options(): extra_vars = { 'buildtype': [ None, "Specify the type of build (serial, smpar (OpenMP), " "dmpar (MPI), dm+sm (hybrid OpenMP/MPI)).", MANDATORY ], 'rewriteopts': [True, "Replace -O3 with CFLAGS/FFLAGS", CUSTOM], 'runtest': [True, "Build and run WRF tests", CUSTOM], } return EasyBlock.extra_options(extra_vars)
def setUp(self): """Set up everything for running a unit test.""" super(EasyConfigTest, self).setUp() self.cwd = os.getcwd() self.all_stops = [x[0] for x in EasyBlock.get_steps()] if os.path.exists(self.eb_file): os.remove(self.eb_file) self.orig_current_version = easybuild.tools.build_log.CURRENT_VERSION
def extra_options(): """Define custom easyconfig parameters for Molpro.""" # Combine extra variables from Binary and ConfigureMake easyblocks as # well as those needed for Molpro specifically extra_vars = Binary.extra_options() extra_vars = ConfigureMake.extra_options(extra_vars) extra_vars.update({ 'precompiled_binaries': [False, "Are we installing precompiled binaries?", CUSTOM], }) return EasyBlock.extra_options(extra_vars)
def extra_options(extra_vars=None): """Extra easyconfig parameters specific to Binary easyblock.""" extra_vars = EasyBlock.extra_options(extra_vars) extra_vars.update({ 'extract_sources': [False, "Whether or not to extract sources", CUSTOM], 'install_cmd': [None, "Install command to be used.", CUSTOM], # staged installation can help with the hard (potentially faulty) check on available disk space 'staged_install': [False, "Perform staged installation via subdirectory of build directory", CUSTOM], }) return extra_vars
def test_make_module_extend_modpath(self): """Test for make_module_extend_modpath""" self.contents = '\n'.join([ 'easyblock = "ConfigureMake"', 'name = "pi"', 'version = "3.14"', 'homepage = "http://example.com"', 'description = "test easyconfig"', 'toolchain = {"name":"dummy", "version": "dummy"}', 'moduleclass = "compiler"', ]) self.writeEC() eb = EasyBlock(EasyConfig(self.eb_file)) eb.installdir = config.install_path() # no $MODULEPATH extensions for default module naming scheme (EasyBuildMNS) self.assertEqual(eb.make_module_extend_modpath(), '') usermodsdir = 'my/own/modules' modclasses = ['compiler', 'tools'] os.environ['EASYBUILD_MODULE_NAMING_SCHEME'] = 'CategorizedHMNS' build_options = { 'subdir_user_modules': usermodsdir, 'valid_module_classes': modclasses, } init_config(build_options=build_options) eb = EasyBlock(EasyConfig(self.eb_file)) eb.installdir = config.install_path() txt = eb.make_module_extend_modpath() if get_module_syntax() == 'Tcl': regexs = [r'^module use ".*/modules/all/Compiler/pi/3.14/%s"$' % c for c in modclasses] home = r'\$env\(HOME\)' regexs.extend([ # extension for user modules is guarded r'if { \[ file isdirectory \[ file join %s "%s/Compiler/pi/3.14" \] \] } {$' % (home, usermodsdir), # no per-moduleclass extension for user modules r'^\s+module use \[ file join %s "%s/Compiler/pi/3.14"\ ]$' % (home, usermodsdir), ]) elif get_module_syntax() == 'Lua': regexs = [r'^prepend_path\("MODULEPATH", ".*/modules/all/Compiler/pi/3.14/%s"\)$' % c for c in modclasses] home = r'os.getenv\("HOME"\)' regexs.extend([ # extension for user modules is guarded r'if isDir\(pathJoin\(%s, "%s/Compiler/pi/3.14"\)\) then' % (home, usermodsdir), # no per-moduleclass extension for user modules r'\s+prepend_path\("MODULEPATH", pathJoin\(%s, "%s/Compiler/pi/3.14"\)\)' % (home, usermodsdir), ]) else: self.assertTrue(False, "Unknown module syntax: %s" % get_module_syntax()) for regex in regexs: regex = re.compile(regex, re.M) self.assertTrue(regex.search(txt), "Pattern '%s' found in: %s" % (regex.pattern, txt))
def extra_options(): """Custom easyconfig parameters for MCR.""" extra_vars = { 'java_options': [ '-Xmx256m', "$_JAVA_OPTIONS value set for install and in module file.", CUSTOM ], } return EasyBlock.extra_options(extra_vars)
def test_buildininstalldir(self): """Test specifying build in install dir.""" self.contents = '\n'.join([ 'name = "pi"', 'version = "3.14"', 'homepage = "http://example.com"', 'description = "test easyconfig"', 'toolchain = {"name": "dummy", "version": "dummy"}', 'buildininstalldir = True', ]) self.prep() ec = EasyConfig(self.eb_file) eb = EasyBlock(ec) eb.gen_builddir() eb.gen_installdir() eb.make_builddir() eb.make_installdir() self.assertEqual(eb.builddir, eb.installdir) self.assertTrue(os.path.isdir(eb.builddir))
def extra_options(): """Custom easyconfig parameters for bar.""" extra_vars = { 'bar_extra1': [ None, "first bar-specific easyconfig parameter (mandatory)", MANDATORY ], 'bar_extra2': ['BAR', "second bar-specific easyconfig parameter", CUSTOM], } return EasyBlock.extra_options(extra_vars)
def run(self, unpack_src=False): """Common operations for extensions: unpacking sources, patching, ...""" # unpack file if desired if unpack_src: targetdir = os.path.join(self.master.builddir, remove_unwanted_chars(self.name)) self.ext_dir = extract_file(self.src, targetdir, extra_options=self.unpack_options, change_into_dir=False, cmd=self.src_extract_cmd) # setting start dir must be done from unpacked source directory for extension, # because start_dir value is usually a relative path (if it is set) change_dir(self.ext_dir) self._set_start_dir() change_dir(self.start_dir) else: self._set_start_dir() # patch if needed EasyBlock.patch_step(self, beginpath=self.ext_dir)
def extra_options(): extra_vars = { 'compilerstr':[None, "Compiler string (gnu/intel/pgi).",MANDATORY], 'build_mpi_parts':[False, "Build MPI parallelized parts", CUSTOM], 'build_openmp_parts':[False, "Build OpenMP parts",CUSTOM], 'build_cuda_parts':[False,"Build CUDA accelerated parts",CUSTOM], 'amber_python_exe':[None, "Path to the python execuable to be forwarded to AMBER. This could be different from what easybuild is using.", CUSTOM], 'skip_patches':[False,"Skip downloading and applying patches",CUSTOM], 'runtest':[False,"Whether to run tests after build",CUSTOM], } return EasyBlock.extra_options(extra_vars)
def __init__(self, *args, **kwargs): """Initialize either as EasyBlock or as Extension.""" self.is_extension = False if isinstance(args[0], EasyBlock): Extension.__init__(self, *args, **kwargs) # name and version properties of EasyBlock are used, so make sure name and version are correct self.cfg['name'] = self.ext.get('name', None) self.cfg['version'] = self.ext.get('version', None) self.builddir = self.master.builddir self.installdir = self.master.installdir self.is_extension = True self.unpack_options = None else: EasyBlock.__init__(self, *args, **kwargs) self.options = copy.deepcopy(self.cfg.get( 'options', {})) # we need this for Extension.sanity_check_step self.ext_dir = None # dir where extension source was unpacked
def extra_options(extra_vars=None): """Extra easyconfig parameters specific to ExtensionEasyBlock.""" # using [] as default value is a bad idea, so we handle it this way if extra_vars is None: extra_vars = [] extra_vars.extend([ ('options', [{}, "Dictionary with extension options.", CUSTOM]), ]) return EasyBlock.extra_options(extra_vars)
def configure_step(self, name=None): """Configure build of toy.""" if name is None: name = self.name # make sure Python system dep is handled correctly when specified if self.cfg['allow_system_deps']: if get_software_root('Python') != 'Python' or get_software_version( 'Python') != platform.python_version(): raise EasyBlock( "Sanity check on allowed Python system dep failed.") os.rename('%s.source' % name, '%s.c' % name)
def extra_options(): """Add extra easyconfig parameters for Boost.""" extra_vars = { 'boost_mpi': [False, "Build mpi boost module", CUSTOM], 'toolset': [ None, "Toolset to use for Boost configuration ('--with-toolset for bootstrap.sh')", CUSTOM ], } return EasyBlock.extra_options(extra_vars)
def extra_options(extra_vars=None): """Extra easyconfig parameters specific to RPMs.""" extra_vars = EasyBlock.extra_options(extra_vars) extra_vars.update({ 'force': [False, "Use force", CUSTOM], 'preinstall': [False, "Enable pre install", CUSTOM], 'postinstall': [False, "Enable post install", CUSTOM], 'makesymlinks': [[], "Create symlinks for listed paths", CUSTOM], # supports glob }) return extra_vars
def extra_options(): testdata_urls = ["http://www.wien2k.at/reg_user/benchmark/test_case.tar.gz", "http://www.wien2k.at/reg_user/benchmark/mpi-benchmark.tar.gz"] extra_vars = { 'runtest': [True, "Run WIEN2k tests", CUSTOM], 'testdata': [testdata_urls, "test data URL for WIEN2k benchmark test", CUSTOM], 'wien_mpirun': [None, "MPI wrapper comand to use", CUSTOM], 'remote': [None, "Remote command to use (e.g. pbsssh, ...)", CUSTOM], } return EasyBlock.extra_options(extra_vars)
def check_start_dir(expected_start_dir): """Check start dir.""" eb = EasyBlock(ec['ec']) eb.silent = True eb.cfg['stop'] = 'patch' eb.run_all_steps(False) eb.guess_start_dir() abs_expected_start_dir = os.path.join(eb.builddir, expected_start_dir) self.assertTrue( os.path.samefile(eb.cfg['start_dir'], abs_expected_start_dir)) self.assertTrue( os.path.samefile(os.getcwd(), abs_expected_start_dir))
def extra_options(): """Add extra easyconfig parameters for Boost.""" extra_vars = { 'boost_mpi': [False, "Build mpi boost module", CUSTOM], 'boost_multi_thread': [False, "Build boost with multi-thread option", CUSTOM], 'toolset': [None, "Toolset to use for Boost configuration ('--with-toolset for bootstrap.sh')", CUSTOM], 'mpi_launcher': [None, "Launcher to use when running MPI regression tests", CUSTOM], 'only_python_bindings': [False, "Only install Boost.Python library providing Python bindings", CUSTOM], 'use_glibcxx11_abi': [None, "Use the GLIBCXX11 ABI", CUSTOM], } return EasyBlock.extra_options(extra_vars)
def extra_options(): extra_vars = { 'buildtype': [ None, "Specify the type of build (smpar: OpenMP, dmpar: MPI).", MANDATORY ], 'runtest': [True, "Build and run WPS tests", CUSTOM], 'testdata': [None, "URL to test data required to run WPS test", CUSTOM], } return EasyBlock.extra_options(extra_vars)
def extra_options(): testdata_urls = [ "http://www.mmm.ucar.edu/wrf/src/data/avn_data.tar.gz", "http://www.mmm.ucar.edu/wrf/src/wps_files/geog.tar.gz" # 697MB download, 16GB unpacked! ] extra_vars = [ ('buildtype', [None, "Specify the type of build (smpar: OpenMP, dmpar: MPI).", MANDATORY]), ('runtest', [True, "Build and run WPS tests (default: True).", CUSTOM]), ('testdata', [testdata_urls, "URL to test data required to run WPS test (default: %s)." % testdata_urls, CUSTOM]) ] return EasyBlock.extra_options(extra_vars)