Merge branch '5.0.x' into parallel_prop

Author: Flamefire

easybuild/easyblocks/a/abaqus.py

@@ -71,6 +71,12 @@ def __init__(self, *args, **kwargs):
             self.log.info("Auto-enabling installation of fe-safe components for ABAQUS versions >= 2020")
             self.cfg['with_fe_safe'] = True
 
+        # add custom paths to $PATH
+        path_subdirs = ['Commands']
+        if self.cfg['with_tosca']:
+            path_subdirs.append(os.path.join('cae', 'linux_a64', 'code', 'command'))
+        self.module_load_environment.PATH.extend(path_subdirs)
+
     def extract_step(self):
         """Use default extraction procedure instead of the one for the Binary easyblock."""
         EasyBlock.extract_step(self)
@@ -353,20 +359,6 @@ def sanity_check_step(self):
 
         super(EB_ABAQUS, self).sanity_check_step(custom_paths=custom_paths, custom_commands=custom_commands)
 
-    def make_module_req_guess(self):
-        """Update $PATH guesses for ABAQUS."""
-        guesses = super(EB_ABAQUS, self).make_module_req_guess()
-
-        path_subdirs = ['Commands']
-        if self.cfg['with_tosca']:
-            path_subdirs.append(os.path.join('cae', 'linux_a64', 'code', 'command'))
-
-        guesses.update({
-            'PATH': path_subdirs,
-        })
-
-        return guesses
-
     def make_module_extra(self):
         """Add LM_LICENSE_FILE path if specified"""
         txt = super(EB_ABAQUS, self).make_module_extra()

easybuild/easyblocks/a/advisor.py

@@ -57,15 +57,14 @@ def __init__(self, *args, **kwargs):
         else:
             self.subdir = os.path.join('advisor', 'latest')
 
+        # prepare module load environment
+        self.prepare_intel_tools_env()
+
     def prepare_step(self, *args, **kwargs):
         """Since 2019u3 there is no license required."""
         kwargs['requires_runtime_license'] = False
         super(EB_Advisor, self).prepare_step(*args, **kwargs)
 
-    def make_module_req_guess(self):
-        """Find reasonable paths for Advisor"""
-        return self.get_guesses_tools()
-
     def sanity_check_step(self):
         """Custom sanity check paths for Advisor"""
         binaries = ['advixe-cl', 'advixe-feedback', 'advixe-gui', 'advixe-runss', 'advixe-runtrc', 'advixe-runtc']

easybuild/easyblocks/a/anaconda.py

@@ -34,12 +34,28 @@
 
 from easybuild.easyblocks.generic.binary import Binary
 from easybuild.tools.filetools import adjust_permissions, remove_dir
+from easybuild.tools.modules import MODULE_LOAD_ENV_HEADERS
 from easybuild.tools.run import run_shell_cmd
 
 
 class EB_Anaconda(Binary):
     """Support for building/installing Anaconda and Miniconda."""
 
+    def __init__(self, *args, **kwargs):
+        """Initialize class variables."""
+        super().__init__(*args, **kwargs)
+
+        # Do not add installation to search paths for headers or libraries to avoid
+        # that the Anaconda environment is used by other software at building or linking time.
+        # LD_LIBRARY_PATH issue discusses here:
+        # http://superuser.com/questions/980250/environment-module-cannot-initialize-tcl
+        mod_env_headers = self.module_load_environment.alias_vars(MODULE_LOAD_ENV_HEADERS)
+        mod_env_libs = ['LD_LIBRARY_PATH', 'LIBRARY_PATH']
+        mod_env_cmake = ['CMAKE_LIBRARY_PATH', 'CMAKE_PREFIX_PATH']
+        for disallowed_var in mod_env_headers + mod_env_libs + mod_env_cmake:
+            self.module_load_environment.remove(disallowed_var)
+            self.log.debug(f"Purposely not updating ${disallowed_var} in {self.name} module file")
+
     def install_step(self):
         """Copy all files in build directory to the install directory"""
 
@@ -53,16 +69,6 @@ def install_step(self):
         self.log.info("Installing %s using command '%s'..." % (self.name, cmd))
         run_shell_cmd(cmd)
 
-    def make_module_req_guess(self):
-        """
-        A dictionary of possible directories to look for.
-        """
-        return {
-            'MANPATH': ['man', os.path.join('share', 'man')],
-            'PATH': ['bin', 'sbin'],
-            'PKG_CONFIG_PATH': [os.path.join(x, 'pkgconfig') for x in ['lib', 'lib32', 'lib64', 'share']],
-        }
-
     def sanity_check_step(self):
         """
         Custom sanity check for Anaconda and Miniconda

easybuild/easyblocks/a/ansys.py

@@ -47,6 +47,29 @@ def __init__(self, *args, **kwargs):
         super(EB_ANSYS, self).__init__(*args, **kwargs)
         self.ansysver = None
 
+        # custom extra module environment entries for ANSYS
+        bin_dirs = [
+            'tgrid/bin',
+            'Framework/bin/Linux64',
+            'aisol/bin/linx64',
+            'RSM/bin',
+            'ansys/bin',
+            'autodyn/bin',
+            'CFD-Post/bin',
+            'CFX/bin',
+            'fluent/bin',
+            'TurboGrid/bin',
+            'polyflow/bin',
+            'Icepak/bin',
+            'icemcfd/linux64_amd/bin'
+        ]
+        if LooseVersion(self.version) >= LooseVersion('19.0'):
+            bin_dirs.append('CEI/bin')
+        # use glob pattern as we don't know exact version at this stage
+        # it will be expanded before injection into the module file
+        ansysver_glob = 'v[0-9]*'
+        self.module_load_environment.PATH = [os.path.join(ansysver_glob, d) for d in bin_dirs]
+
     def install_step(self):
         """Custom install procedure for ANSYS."""
         # Sources (e.g. iso files) may drop the execute permissions
@@ -77,35 +100,6 @@ def set_ansysver(self):
         else:
             self.ansysver = 'v' + ''.join(self.version.split('.')[0:2])
 
-    def make_module_req_guess(self):
-        """Custom extra module file entries for ANSYS."""
-
-        if self.ansysver is None:
-            self.set_ansysver()
-
-        guesses = super(EB_ANSYS, self).make_module_req_guess()
-        dirs = [
-            'tgrid/bin',
-            'Framework/bin/Linux64',
-            'aisol/bin/linx64',
-            'RSM/bin',
-            'ansys/bin',
-            'autodyn/bin',
-            'CFD-Post/bin',
-            'CFX/bin',
-            'fluent/bin',
-            'TurboGrid/bin',
-            'polyflow/bin',
-            'Icepak/bin',
-            'icemcfd/linux64_amd/bin'
-        ]
-        if LooseVersion(self.version) >= LooseVersion('19.0'):
-            dirs.append('CEI/bin')
-
-        guesses['PATH'] = [os.path.join(self.ansysver, d) for d in dirs]
-
-        return guesses
-
     def make_module_extra(self):
         """Define extra environment variables required by Ansys"""
 

easybuild/easyblocks/a/aocc.py

@@ -83,6 +83,11 @@ def __init__(self, *args, **kwargs):
         super(EB_AOCC, self).__init__(*args, **kwargs)
 
         self.clangversion = self.cfg['clangversion']
+        # AOCC is based on Clang. Try to guess the clangversion from the AOCC version
+        # if clangversion is not specified in the easyconfig
+        if self.clangversion is None:
+            self.clangversion = self._aocc_guess_clang_version()
+
         self.gcc_prefix = None
 
         # Bypass the .mod file check for GCCcore installs
@@ -207,11 +212,6 @@ def install_step(self):
         # or via 'accept_eula = True' in easyconfig file
         self.check_accepted_eula(more_info='http://developer.amd.com/wordpress/media/files/AOCC_EULA.pdf')
 
-        # AOCC is based on Clang. Try to guess the clangversion from the AOCC version
-        # if clangversion is not specified in the easyconfig
-        if self.clangversion is None:
-            self.clangversion = self._aocc_guess_clang_version()
-
         super(EB_AOCC, self).install_step()
 
     def post_processing_step(self):
@@ -299,13 +299,3 @@ def make_module_extra(self):
         # setting the AOCChome path
         txt += self.module_generator.set_environment('AOCChome', self.installdir)
         return txt
-
-    def make_module_req_guess(self):
-        """
-        A dictionary of possible directories to look for.
-        Include C_INCLUDE_PATH and CPLUS_INCLUDE_PATH as an addition to default ones
-        """
-        guesses = super(EB_AOCC, self).make_module_req_guess()
-        guesses['C_INCLUDE_PATH'] = ['include']
-        guesses['CPLUS_INCLUDE_PATH'] = ['include']
-        return guesses

easybuild/easyblocks/c/clang.py

@@ -47,7 +47,7 @@
 from easybuild.tools.build_log import EasyBuildError, print_warning
 from easybuild.tools.config import build_option
 from easybuild.tools.filetools import apply_regex_substitutions, change_dir, mkdir, symlink, which
-from easybuild.tools.modules import get_software_root
+from easybuild.tools.modules import MODULE_LOAD_ENV_HEADERS, get_software_root
 from easybuild.tools.run import run_shell_cmd
 from easybuild.tools.systemtools import AARCH32, AARCH64, POWER, RISCV64, X86_64
 from easybuild.tools.systemtools import get_cpu_architecture, get_os_name, get_os_version, get_shared_lib_ext
@@ -753,6 +753,21 @@ def sanity_check_step(self):
 
         super(EB_Clang, self).sanity_check_step(custom_paths=custom_paths, custom_commands=custom_commands)
 
+    def make_module_step(self, *args, **kwargs):
+        """
+        Set paths for module load environment based on the actual installation files
+        """
+        # Ensure that installation files are not added to search paths to headers and libs
+        mod_env_headers = self.module_load_environment.alias_vars(MODULE_LOAD_ENV_HEADERS)
+        mod_env_libs = ['LIBRARY_PATH']
+        for disallowed_var in mod_env_headers + mod_env_libs:
+            self.module_load_environment.remove(disallowed_var)
+            self.log.debug(f"Purposely not updating ${disallowed_var} in {self.name} module file")
+        # Clang can find its own headers and libraries but the .so's need to be in LD_LIBRARY_PATH
+        self.module_load_environment.LD_LIBRARY_PATH = ['lib', 'lib64', self.runtime_lib_path]
+
+        return super().make_module_step(*args, **kwargs)
+
     def make_module_extra(self):
         """Custom variables for Clang module."""
         txt = super(EB_Clang, self).make_module_extra()
@@ -762,15 +777,3 @@ def make_module_extra(self):
         if self.cfg['python_bindings']:
             txt += self.module_generator.prepend_paths('PYTHONPATH', os.path.join("lib", "python"))
         return txt
-
-    def make_module_req_guess(self):
-        """
-        Clang can find its own headers and libraries but the .so's need to be in LD_LIBRARY_PATH
-        """
-        guesses = super(EB_Clang, self).make_module_req_guess()
-        guesses.update({
-            'CPATH': [],
-            'LIBRARY_PATH': [],
-            'LD_LIBRARY_PATH': ['lib', 'lib64', self.runtime_lib_path],
-        })
-        return guesses

easybuild/easyblocks/c/cuda.py

@@ -92,6 +92,28 @@ def __init__(self, *args, **kwargs):
         self.cfg.template_values['cudaarch'] = cudaarch
         self.cfg.generate_template_values()
 
+        # Specify CUDA custom values for module load environment
+        # The dirs should be in the order ['open64/bin', 'bin']
+        bin_path = []
+        if LooseVersion(self.version) < LooseVersion('7'):
+            bin_path.append(os.path.join('open64', 'bin'))
+        bin_path.append('bin')
+
+        lib_path = ['lib64']
+        inc_path = ['include']
+        if LooseVersion(self.version) >= LooseVersion('7'):
+            lib_path.append(os.path.join('extras', 'CUPTI', 'lib64'))
+            inc_path.append(os.path.join('extras', 'CUPTI', 'include'))
+            bin_path.append(os.path.join('nvvm', 'bin'))
+            lib_path.append(os.path.join('nvvm', 'lib64'))
+            inc_path.append(os.path.join('nvvm', 'include'))
+
+        self.module_load_environment.CPATH = inc_path
+        self.module_load_environment.LD_LIBRARY_PATH = lib_path
+        self.module_load_environment.LIBRARY_PATH = lib_path + [os.path.join('stubs', 'lib64')]
+        self.module_load_environment.PATH = bin_path
+        self.module_load_environment.PKG_CONFIG_PATH = ['pkgconfig']
+
     def fetch_step(self, *args, **kwargs):
         """Check for EULA acceptance prior to getting sources."""
         # EULA for CUDA must be accepted via --accept-eula-for EasyBuild configuration option,
@@ -334,33 +356,3 @@ def make_module_extra(self):
         txt += self.module_generator.set_environment('CUDA_PATH', self.installdir)
         self.log.debug("make_module_extra added this: %s", txt)
         return txt
-
-    def make_module_req_guess(self):
-        """Specify CUDA custom values for PATH etc."""
-
-        guesses = super(EB_CUDA, self).make_module_req_guess()
-
-        # The dirs should be in the order ['open64/bin', 'bin']
-        bin_path = []
-        if LooseVersion(self.version) < LooseVersion('7'):
-            bin_path.append(os.path.join('open64', 'bin'))
-        bin_path.append('bin')
-
-        lib_path = ['lib64']
-        inc_path = ['include']
-        if LooseVersion(self.version) >= LooseVersion('7'):
-            lib_path.append(os.path.join('extras', 'CUPTI', 'lib64'))
-            inc_path.append(os.path.join('extras', 'CUPTI', 'include'))
-            bin_path.append(os.path.join('nvvm', 'bin'))
-            lib_path.append(os.path.join('nvvm', 'lib64'))
-            inc_path.append(os.path.join('nvvm', 'include'))
-
-        guesses.update({
-            'CPATH': inc_path,
-            'LD_LIBRARY_PATH': lib_path,
-            'LIBRARY_PATH': lib_path + [os.path.join('stubs', 'lib64')],
-            'PATH': bin_path,
-            'PKG_CONFIG_PATH': ['pkgconfig'],
-        })
-
-        return guesses

easybuild/easyblocks/c/cudacompat.py

@@ -65,6 +65,8 @@ def __init__(self, *args, **kwargs):
         """Initialize custom class variables for CUDACompat."""
         super(EB_CUDAcompat, self).__init__(*args, **kwargs)
         self._has_nvidia_smi = None
+        # avoid building software with this compat libraries
+        self.module_load_environment.remove('LIBRARY_PATH')
 
     @property
     def has_nvidia_smi(self):
@@ -214,17 +216,6 @@ def install_step(self):
             unversioned_symlink = versioned_symlink.rsplit('.', 1)[0]
             symlink(versioned_symlink, os.path.join(libdir, unversioned_symlink), use_abspath_source=False)
 
-    def make_module_req_guess(self):
-        """Don't try to guess anything."""
-        return dict()
-
-    def make_module_extra(self):
-        """Skip the changes from the Binary EasyBlock and (only) set LD_LIBRARY_PATH."""
-
-        txt = super(Binary, self).make_module_extra()
-        txt += self.module_generator.prepend_paths('LD_LIBRARY_PATH', 'lib')
-        return txt
-
     def sanity_check_step(self):
         """Check for core files (unversioned libs, symlinks)"""
         libraries = [

easybuild/easyblocks/e/eigen.py

@@ -98,12 +98,3 @@ def sanity_check_step(self):
                                    % os.path.join(self.installdir, cmake_config_dir))
 
         super(EB_Eigen, self).sanity_check_step(custom_paths=custom_paths, custom_commands=custom_commands)
-
-    def make_module_req_guess(self):
-        """
-        A dictionary of possible directories to look for.
-        Include CPLUS_INCLUDE_PATH as an addition to default ones
-        """
-        guesses = super(EB_Eigen, self).make_module_req_guess()
-        guesses.update({'CPLUS_INCLUDE_PATH': ['include']})
-        return guesses