[libcxx][executors] Add a --wrapper-command flag to prepend a command

[arichardson]

Summary

This can be used to run tests under GDB/LLDB/Valgrind/qemu-user etc.
A follow-up change will use this flag to enable running all tests under
GDB (printing a backtrace on crashes).

[ldionne]

libcxx/utils/run.py

27

This is like an executor within an executor. Is there a reason why you don't simply write a separate executor that does the things you need?

I think it would be good to leave these basic executors simple -- the whole thing was meant to be extended by writing new executors, not by making the existing executors more complex.

[arichardson]

libcxx/utils/run.py

27

That would work well for the local executor, but adding the prefix to the ssh executor means I'd also have to duplicate the ssh executor (that's the one I really want this feature for). I feel like adding this command line flag is simpler than duplicating every executor.

libcxx/utils/run.py

 #!/usr/bin/env python
 #===----------------------------------------------------------------------===##
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 
 """run.py is a utility for running a program.
 
 It can perform code signing, forward arguments to the program, and return the
 program's error code.
 """
 
 import argparse
+import shlex
 import subprocess
 import sys
 
 
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument('--execdir', type=str, required=True)
     parser.add_argument('--codesign_identity', type=str, required=False, default=None)
     parser.add_argument('--env', type=str, nargs='*', required=False, default=dict())
+    parser.add_argument('--wrapper-command', type=str, required=False, default=None)
     parser.add_argument("command", nargs=argparse.ONE_OR_MORE)
     args = parser.parse_args()
     commandLine = args.command
 
     # Do any necessary codesigning.
     if args.codesign_identity:
         exe = commandLine[0]
         rc = subprocess.call(['xcrun', 'codesign', '-f', '-s', args.codesign_identity, exe], env={})
         if rc != 0:
             sys.stderr.write('Failed to codesign: ' + exe)
             return rc
 
     # Extract environment variables into a dictionary
     env = {k : v  for (k, v) in map(lambda s: s.split('=', 1), args.env)}
 
+    # Prepend the wrapper command to allow running under GDB/LLDB/valgrind/qemu-user/etc.
+    if args.wrapper_command:
+        commandLine = shlex.split(args.wrapper_command) + commandLine
     # Run the command line with the given environment in the execution directory.
     return subprocess.call(subprocess.list2cmdline(commandLine), cwd=args.execdir, env=env, shell=True)
 
 
 if __name__ == '__main__':
     exit(main())

libcxx/utils/ssh.py

 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument('--host', type=str, required=True)
     parser.add_argument('--execdir', type=str, required=True)
     parser.add_argument('--extra-ssh-args', type=str, required=False)
     parser.add_argument('--extra-scp-args', type=str, required=False)
     parser.add_argument('--codesign_identity', type=str, required=False, default=None)
     parser.add_argument('--env', type=str, nargs='*', required=False, default=dict())
+    parser.add_argument('--wrapper-command', type=str, required=False, default=None)
     parser.add_argument("command", nargs=argparse.ONE_OR_MORE)
     args = parser.parse_args()
     commandLine = args.command
 
     # Create a temporary directory where the test will be run.
     # That is effectively the value of %T on the remote host.
     tmp = subprocess.check_output(ssh(args, 'mktemp -d /tmp/libcxx.XXXXXXXXXX'), universal_newlines=True).strip()
 
try:
         for exe in map(pathOnRemote, filter(isTestExe, commandLine)):
             remoteCommands.append('chmod +x {}'.format(exe))
 
         # Execute the command through SSH in the temporary directory, with the
         # correct environment. We tweak the command line to run it on the remote
         # host by transforming the path of test-executables to their path in the
         # temporary directory on the remote host.
         commandLine = (pathOnRemote(x) if isTestExe(x) else x for x in commandLine)
+        # Prepend the wrapper command to allow running under GDB/LLDB/valgrind/qemu-user/etc.
+        if args.wrapper_command:
+            commandLine = shlex.split(args.wrapper_command) + list(commandLine)
         remoteCommands.append('cd {}'.format(tmp))
         if args.env:
             remoteCommands.append('export {}'.format(' '.join(args.env)))
         remoteCommands.append(subprocess.list2cmdline(commandLine))
 
         # Finally, SSH to the remote host and execute all the commands.
         rc = subprocess.call(ssh(args, ' && '.join(remoteCommands)))
         return rc
 
     finally:
         # Make sure the temporary directory is removed when we're done.
         subprocess.check_call(ssh(args, 'rm -r {}'.format(tmp)))
 
 
 if __name__ == '__main__':
     exit(main())