Add rpath_wrappers_dir build option

Author: ocaisa

easybuild/framework/easyblock.py

@@ -2102,7 +2102,9 @@ def install_extensions_sequential(self, install=True):
                 # don't reload modules for toolchain, there is no need since they will be loaded already;
                 # the (fake) module for the parent software gets loaded before installing extensions
                 ext.toolchain.prepare(onlymod=self.cfg['onlytcmod'], silent=True, loadmod=False,
-                                      rpath_filter_dirs=self.rpath_filter_dirs)
+                                      rpath_filter_dirs=self.rpath_filter_dirs,
+                                      rpath_include_dirs=self.rpath_include_dirs,
+                                      rpath_wrappers_dir=self.rpath_wrappers_dir)
 
             # actual installation of the extension
             if install:
@@ -2264,7 +2266,9 @@ def update_exts_progress_bar_helper(running_exts, progress_size):
                     # don't reload modules for toolchain, there is no need since they will be loaded already;
                     # the (fake) module for the parent software gets loaded before installing extensions
                     ext.toolchain.prepare(onlymod=self.cfg['onlytcmod'], silent=True, loadmod=False,
-                                          rpath_filter_dirs=self.rpath_filter_dirs)
+                                          rpath_filter_dirs=self.rpath_filter_dirs,
+                                          rpath_include_dirs=self.rpath_include_dirs,
+                                          rpath_wrappers_dir=self.rpath_wrappers_dir)
                     if install:
                         ext.install_extension_substep("pre_install_extension")
                         ext.async_cmd_task = ext.install_extension_substep("install_extension_async", thread_pool)
@@ -2878,6 +2882,15 @@ def prepare_step(self, start_dir=True, load_tc_deps_modules=True):
             '$ORIGIN/../lib64',
         ])
 
+        # Location to store RPATH wrappers
+        self.rpath_wrappers_dir = build_option('rpath_wrappers_dir')
+        if self.rpath_wrappers_dir is not None:
+            # Verify the path given is absolute
+            if os.path.isabs(self.rpath_wrappers_dir):
+                _log.debug("Using %s to store/use RPATH wrappers" % self.rpath_wrappers_dir)
+            else:
+                raise EasyBuildError("Path used for rpath_wrappers_dir is not an absolute path: %s", path)
+
         if self.iter_idx > 0:
             # reset toolchain for iterative runs before preparing it again
             self.toolchain.reset()
@@ -2895,7 +2908,7 @@ def prepare_step(self, start_dir=True, load_tc_deps_modules=True):
         # prepare toolchain: load toolchain module and dependencies, set up build environment
         self.toolchain.prepare(self.cfg['onlytcmod'], deps=self.cfg.dependencies(), silent=self.silent,
                                loadmod=load_tc_deps_modules, rpath_filter_dirs=self.rpath_filter_dirs,
-                               rpath_include_dirs=self.rpath_include_dirs)
+                               rpath_include_dirs=self.rpath_include_dirs, rpath_wrappers_dir=self.rpath_wrappers_dir)
 
         # keep track of environment variables that were tweaked and need to be restored after environment got reset
         # $TMPDIR may be tweaked for OpenMPI 2.x, which doesn't like long $TMPDIR paths...

easybuild/tools/config.py

@@ -276,6 +276,7 @@ def mk_full_default_path(name, prefix=DEFAULT_PREFIX):
         'regtest_output_dir',
         'rpath_filter',
         'rpath_override_dirs',
+        'rpath_wrappers_dir',
         'required_linked_shared_libs',
         'search_path_cpp_headers',
         'search_path_linker',

easybuild/tools/options.py

@@ -521,6 +521,8 @@ def override_options(self):
             'rpath-filter': ("List of regex patterns to use for filtering out RPATH paths", 'strlist', 'store', None),
             'rpath-override-dirs': ("Path(s) to be prepended when linking with RPATH (string, colon-separated)",
                                     None, 'store', None),
+            'rpath-wrappers-dir': ("Absolute path to directory to use for RPATH wrappers creation/use",
+                                   None, 'store', None),
             'sanity-check-only': ("Only run sanity check (module is expected to be installed already",
                                   None, 'store_true', False),
             'set-default-module': ("Set the generated module as default", None, 'store_true', False),

easybuild/tools/toolchain/toolchain.py

@@ -839,7 +839,7 @@ def reset(self):
         self.variables_init()
 
     def prepare(self, onlymod=None, deps=None, silent=False, loadmod=True,
-                rpath_filter_dirs=None, rpath_include_dirs=None):
+                rpath_filter_dirs=None, rpath_include_dirs=None, rpath_wrappers_dir=None):
         """
         Prepare a set of environment parameters based on name/version of toolchain
         - load modules for toolchain and dependencies
@@ -853,6 +853,7 @@ def prepare(self, onlymod=None, deps=None, silent=False, loadmod=True,
         :param loadmod: whether or not to (re)load the toolchain module, and the modules for the dependencies
         :param rpath_filter_dirs: extra directories to include in RPATH filter (e.g. build dir, tmpdir, ...)
         :param rpath_include_dirs: extra directories to include in RPATH
+        :param rpath_wrappers_dir: directory in which to create RPATH wrappers
         """
 
         # take into account --sysroot configuration setting
@@ -906,7 +907,11 @@ def prepare(self, onlymod=None, deps=None, silent=False, loadmod=True,
 
         if build_option('rpath'):
             if self.options.get('rpath', True):
-                self.prepare_rpath_wrappers(rpath_filter_dirs, rpath_include_dirs)
+                self.prepare_rpath_wrappers(
+                    rpath_filter_dirs=rpath_filter_dirs,
+                    rpath_include_dirs=rpath_include_dirs,
+                    rpath_wrappers_dir=rpath_wrappers_dir
+                    )
                 self.use_rpath = True
             else:
                 self.log.info("Not putting RPATH wrappers in place, disabled via 'rpath' toolchain option")
@@ -975,8 +980,7 @@ def is_rpath_wrapper(path):
         # need to use binary mode to read the file, since it may be an actual compiler command (which is a binary file)
         return b'rpath_args.py $CMD' in read_file(path, mode='rb')
 
-    def prepare_rpath_wrappers(self, rpath_filter_dirs=None, rpath_include_dirs=None, wrappers_dir=None,
-                               add_to_path=True, disable_wrapper_log=False):
+    def prepare_rpath_wrappers(self, rpath_filter_dirs=None, rpath_include_dirs=None, rpath_wrappers_dir=None):
         """
         Put RPATH wrapper script in place for compiler and linker commands
 
@@ -999,10 +1003,13 @@ def prepare_rpath_wrappers(self, rpath_filter_dirs=None, rpath_include_dirs=None
                 rpath_filter_dirs.append(lib_stubs_pattern)
 
         # directory where all wrappers will be placed
-        if wrappers_dir is None:
+        disable_wrapper_log = False
+        if rpath_wrappers_dir is None:
             wrappers_dir = os.path.join(tempfile.mkdtemp(), RPATH_WRAPPERS_SUBDIR)
         else:
-            wrappers_dir = os.path.join(wrappers_dir, RPATH_WRAPPERS_SUBDIR)
+            wrappers_dir = os.path.join(rpath_wrappers_dir, RPATH_WRAPPERS_SUBDIR)
+            # No logging when we may be exporting wrappers
+            disable_wrapper_log = True
 
         # must also wrap compilers commands, required e.g. for Clang ('gcc' on OS X)?
         c_comps, fortran_comps = self.compilers()
@@ -1068,8 +1075,7 @@ def prepare_rpath_wrappers(self, rpath_filter_dirs=None, rpath_include_dirs=None
                 adjust_permissions(cmd_wrapper, stat.S_IXUSR)
 
                 # prepend location to this wrapper to $PATH
-                if add_to_path:
-                    setvar('PATH', '%s:%s' % (wrapper_dir, os.getenv('PATH')))
+                setvar('PATH', '%s:%s' % (wrapper_dir, os.getenv('PATH')))
 
                 self.log.info("RPATH wrapper script for %s: %s (log: %s)", orig_cmd, which(cmd), rpath_wrapper_log)
             else:

easybuild/tools/toolchain/utilities.py

@@ -36,15 +36,13 @@
 * Kenneth Hoste (Ghent University)
 """
 import copy
-import os
 import re
 import sys
 
 import easybuild.tools.toolchain
 from easybuild.base import fancylogger
 from easybuild.tools.build_log import EasyBuildError
-from easybuild.tools.environment import setvar
-from easybuild.tools.toolchain.toolchain import Toolchain, RPATH_WRAPPERS_SUBDIR
+from easybuild.tools.toolchain.toolchain import Toolchain
 from easybuild.tools.utilities import get_subclasses, import_available_modules, nub
 
 
@@ -153,25 +151,3 @@ def get_toolchain(tc, tcopts, mns=None, tcdeps=None, modtool=None):
     tc_inst.set_options(tcopts)
 
     return tc_inst
-
-
-def export_rpath_wrappers(targetdir, toolchain_name, toolchain_version, rpath_filter_dirs=None,
-                          rpath_include_dirs=None):
-    tc = get_toolchain({'name': toolchain_name, 'version': toolchain_version}, {})
-
-    # Temporarily filter any existing RPATH wrappers from the PATH
-    orig_paths = os.getenv('PATH')
-    filtered_paths = [path for path in orig_paths.split(':') if RPATH_WRAPPERS_SUBDIR not in path]
-    setvar('PATH', ':'.join(filtered_paths))
-
-    tc.prepare_rpath_wrappers(
-        rpath_filter_dirs=rpath_filter_dirs,
-        rpath_include_dirs=rpath_include_dirs,
-        wrappers_dir=targetdir,
-        add_to_path=False,
-        disable_wrapper_log=True,
-        )
-    _log.debug("Installed RPATH wrappers in command specific subdirectories of %s" % (str(targetdir)))
-
-    # Restore the PATH
-    setvar('PATH', orig_paths)

test/framework/toolchain.py

@@ -3137,61 +3137,31 @@ def test_toolchain_prepare_rpath(self):
         self.assertTrue(os.path.samefile(res[1], fake_gxx))
         self.assertFalse(any(os.path.samefile(x, fake_gxx) for x in res[2:]))
 
-    def test_export_rpath(self):
-        """Test tools.toolchain.export_rpath_wrappers()"""
+    def test_toolchain_prepare_rpath_external(self):
+        """Test toolchain.prepare under --rpath with --rpath-wrappers-dir"""
 
         # put fake 'g++' command in place that just echos its arguments
         fake_gxx = os.path.join(self.test_prefix, 'fake', 'g++')
         write_file(fake_gxx, '#!/bin/bash\necho "$@"')
         adjust_permissions(fake_gxx, stat.S_IXUSR)
         os.environ['PATH'] = '%s:%s' % (os.path.join(self.test_prefix, 'fake'), os.getenv('PATH', ''))
 
+        # export the wrappers to a target location
+        target_wrapper_dir = os.path.join(self.test_prefix, 'target')
         # enable --rpath for a toolchain so we test against it
-        init_config(build_options={'rpath': True, 'silent': True})
+        init_config(build_options={'rpath': True, 'silent': True, 'rpath_wrappers_dir': target_wrapper_dir})
         tc = self.get_toolchain('gompi', version='2018a')
         tc.set_options({'rpath': True})
         # allow the underlying toolchain to be in a prepared state (which may include rpath wrapping)
         tc.prepare()
 
-        # export the wrappers to a target location
-        target_wrapper_dir = os.path.join(self.test_prefix, 'target')
-        export_rpath_wrappers(targetdir=target_wrapper_dir, toolchain_name='gompi', toolchain_version='2018a',
-                              rpath_filter_dirs=['/filter_path'], rpath_include_dirs=['/include_path'])
-
         # check that wrapper was created
         target_wrapper = os.path.join(target_wrapper_dir, RPATH_WRAPPERS_SUBDIR, 'gxx_wrapper', 'g++')
         self.assertTrue(os.path.exists(target_wrapper))
         # Make sure it is a wrapper
         self.assertTrue(b'rpath_args.py $CMD' in read_file(target_wrapper, mode='rb'))
         # Make sure it wraps our fake 'g++'
         self.assertTrue(fake_gxx.encode(encoding="utf-8") in read_file(target_wrapper, mode='rb'))
-        # Make sure the wrapper is not in PATH (we export only)
-        self.assertFalse(any(os.path.samefile(x, target_wrapper) for x in which('g++', retain_all=True)))
-
-        # check whether fake g++ was wrapped and that arguments are what they should be
-        # no -rpath for /path because of rpath filter
-        mkdir(os.path.join(self.test_prefix, 'foo'), parents=True)
-        cmd = ' '.join([
-            target_wrapper,
-            '${USER}.c',
-            '-L%s/foo' % self.test_prefix,
-            '-L/filter_path',
-            "'$FOO'",
-            '-DX="\\"\\""',
-        ])
-        res = run_shell_cmd(cmd, hidden=True)
-        self.assertEqual(res.exit_code, 0)
-        expected = ' '.join([
-            '-Wl,-rpath=/include_path',
-            '-Wl,--disable-new-dtags',
-            '-Wl,-rpath=%s/foo' % self.test_prefix,
-            '%(user)s.c',
-            '-L%s/foo' % self.test_prefix,
-            '-L/filter_path',
-            '$FOO',
-            '-DX=""',
-        ])
-        self.assertEqual(res.output.strip(), expected % {'user': os.getenv('USER')})
 
     def test_prepare_openmpi_tmpdir(self):
         """Test handling of long $TMPDIR path for OpenMPI 2.x"""