[libcxx] Introduce LinuxRemoteTI for remote testing

[broadwaylamb]

Summary

This patch adds a new target info object called LinuxRemoteTI.
Unlike LinuxLocalTI, which asks the host system about various things
like available locales, distribution name etc. which don't make sense
if we're testing on a remote board, LinuxRemoteTI uses SSHExecutor
to get information from the target system.

[jroelofs]

Awesome, LGTM!

libcxx/utils/libcxx/test/config.py

def configure_executor(self):
                 self.lit_config.fatal("Cannot infer how to create a Valgrind "
                                       " executor.")
         else:
             te = LocalExecutor()
             if self.lit_config.useValgrind:
                 te = ValgrindExecutor(self.lit_config.valgrindArgs, te)
 
         te.target_info = self.target_info
+        self.target_info.executor = te
 
         self.executor = te
 
     def configure_target_info(self):
         self.target_info = make_target_info(self)
 
     def configure_cxx(self):
         # Gather various compiler parameters.

libcxx/utils/libcxx/test/executor.py

def copy_in(self, local_srcs, remote_dsts):
         for src, dst in zip(local_srcs, remote_dsts):
             self._copy_in_file(src, dst)
 
     def _copy_in_file(self, src, dst):
         raise NotImplementedError()
 
     def delete_remote(self, remote):
         try:
-            self._execute_command_remote(['rm', '-rf', remote])
+            self.execute_command_remote(['rm', '-rf', remote])
         except OSError:
             # TODO: Log failure to delete?
             pass
 
     def run(self, exe_path, cmd=None, work_dir='.', file_deps=None, env=None):
         target_exe_path = None
         target_cwd = None
         try:
def run(self, exe_path, cmd=None, work_dir='.', file_deps=None, env=None):
             # When testing executables that were cross-compiled on Windows for
             # Linux, we may need to explicitly set the execution permission to
             # avoid the 'Permission denied' error:
             chmod_cmd = ['chmod', '+x', target_exe_path]
 
             # TODO(jroelofs): capture the copy_in and delete_remote commands,
             # and conjugate them with '&&'s around the first tuple element
             # returned here:
-            return self._execute_command_remote(chmod_cmd + ['&&'] + cmd,
-                                                target_cwd,
-                                                env)
+            return self.execute_command_remote(chmod_cmd + ['&&'] + cmd,
         finally:
             if target_cwd:
                 self.delete_remote(target_cwd)
 
-    def _execute_command_remote(self, cmd, remote_work_dir='.', env=None):
+    def execute_command_remote(self, cmd, remote_work_dir='.', env=None):
         raise NotImplementedError()
 
 
 class SSHExecutor(RemoteExecutor):
     def __init__(self, host, username=None):
         super(SSHExecutor, self).__init__()
 
         self.user_prefix = username + '@' if username else ''
class SSHExecutor(RemoteExecutor):
     def _remote_temp(self, is_dir):
         # TODO: detect what the target system is, and use the correct
         # mktemp command for it. (linux and darwin differ here, and I'm
         # sure windows has another way to do it)
 
         # Not sure how to do suffix on osx yet
         dir_arg = '-d' if is_dir else ''
         cmd = 'mktemp -q {} /tmp/libcxx.XXXXXXXXXX'.format(dir_arg)
-        _, temp_path, err, exitCode = self._execute_command_remote([cmd])
+        _, temp_path, err, exitCode = self.execute_command_remote([cmd])
         temp_path = temp_path.strip()
         if exitCode != 0:
             raise RuntimeError(err)
         return temp_path
 
     def _copy_in_file(self, src, dst):
         scp = self.scp_command
         remote = self.host
def _export_command(self, env):
                     export_cmd.append('PATH="%s;%PATH%"' % v)
                 else:
                     export_cmd.append('PATH="%s:$PATH"' % v)
             else:
                 export_cmd.append('"%s"="%s"' % (k, v))
 
         return export_cmd
 
-    def _execute_command_remote(self, cmd, remote_work_dir='.', env=None):
+    def execute_command_remote(self, cmd, remote_work_dir='.', env=None):
         remote = self.user_prefix + self.host
         ssh_cmd = [self.ssh_command, '-oBatchMode=yes', remote]
         export_cmd = self._export_command(env)
         remote_cmd = ' '.join(cmd)
         if export_cmd:
             remote_cmd = ' '.join(export_cmd) + ' && ' + remote_cmd
         if remote_work_dir != '.':
             remote_cmd = 'cd ' + remote_work_dir + ' && ' + remote_cmd
         out, err, rc = self.local_run(ssh_cmd + [remote_cmd])
         return (remote_cmd, out, err, rc)

libcxx/utils/libcxx/test/target_info.py

 import subprocess
 import sys
 
 from libcxx.util import executeCommand
 
 class DefaultTargetInfo(object):
     def __init__(self, full_config):
         self.full_config = full_config
+        self.executor = None
 
     def platform(self):
         return sys.platform.lower().strip()
 
     def is_windows(self):
         return self.platform() == 'win32'
 
     def is_darwin(self):
def add_path(self, dest_env, new_path):
             return
         if 'PATH' not in dest_env:
             dest_env['PATH'] = new_path
         else:
             split_char = ';' if self.is_windows() else ':'
             dest_env['PATH'] = '%s%s%s' % (new_path, split_char,
                                            dest_env['PATH'])
 
-
-def test_locale(loc):
+    def _test_locale(self, loc):
         assert loc is not None
         default_locale = locale.setlocale(locale.LC_ALL)
         try:
             locale.setlocale(locale.LC_ALL, loc)
             return True
         except locale.Error:
             return False
         finally:
             locale.setlocale(locale.LC_ALL, default_locale)
 
-
-def add_common_locales(features, lit_config, is_windows=False):
+    def add_common_locales(self, features, is_windows=False):
         # A list of locales needed by the test-suite.
         # The list uses the canonical name for the locale used in the test-suite
         # TODO: On Linux ISO8859 *may* needs to hyphenated.
         locales = [
             ('en_US.UTF-8', 'English_United States.1252'),
             ('fr_FR.UTF-8', 'French_France.1252'),
             ('ru_RU.UTF-8', 'Russian_Russia.1251'),
             ('zh_CN.UTF-8', 'Chinese_China.936'),
             ('fr_CA.ISO8859-1', 'French_Canada.1252'),
             ('cs_CZ.ISO8859-2', 'Czech_Czech Republic.1250')
         ]
         for loc_id, windows_loc_name in locales:
             loc_name = windows_loc_name if is_windows else loc_id
-        if test_locale(loc_name):
+            if self._test_locale(loc_name):
                 features.add('locale.{0}'.format(loc_id))
             else:
-            lit_config.warning('The locale {0} is not supported by '
+                self.full_config.lit_config.warning('The locale {0} is not supported by '
                                 'your platform. Some tests will be '
                                 'unsupported.'.format(loc_name))
 
 
 class DarwinLocalTI(DefaultTargetInfo):
     def __init__(self, full_config):
         super(DarwinLocalTI, self).__init__(full_config)
 
     def is_host_macosx(self):
         name = subprocess.check_output(['sw_vers', '-productName']).strip()
def get_platform(self):
         # /usr/lib/libc++.dylib.
         if name == 'macosx':
             version = self.get_macosx_version()
         else:
             version = self.get_sdk_version(name)
         return (True, name, version)
 
     def add_locale_features(self, features):
-        add_common_locales(features, self.full_config.lit_config)
+        self.add_common_locales(features)
 
     def add_cxx_compile_flags(self, flags):
         if self.full_config.use_deployment:
             _, name, _ = self.full_config.config.deployment
             cmd = ['xcrun', '--sdk', name, '--show-sdk-path']
         else:
             cmd = ['xcrun', '--show-sdk-path']
         out, err, exit_code = executeCommand(cmd)
def allow_cxxabi_link(self):
         return False
 
 
 class FreeBSDLocalTI(DefaultTargetInfo):
     def __init__(self, full_config):
         super(FreeBSDLocalTI, self).__init__(full_config)
 
     def add_locale_features(self, features):
-        add_common_locales(features, self.full_config.lit_config)
+        self.add_common_locales(features)
 
     def add_cxx_link_flags(self, flags):
         flags += ['-lc', '-lm', '-lpthread', '-lgcc_s', '-lcxxrt']
 
 
 class NetBSDLocalTI(DefaultTargetInfo):
     def __init__(self, full_config):
         super(NetBSDLocalTI, self).__init__(full_config)
 
     def add_locale_features(self, features):
-        add_common_locales(features, self.full_config.lit_config)
+        self.add_common_locales(features)
 
     def add_cxx_link_flags(self, flags):
         flags += ['-lc', '-lm', '-lpthread', '-lgcc_s', '-lc++abi',
                   '-lunwind']
 
 
 class LinuxLocalTI(DefaultTargetInfo):
     def __init__(self, full_config):
def platform_name(self):
         return name # Permitted to be None
 
     def platform_ver(self):
         _, ver, _ = self._distribution()
         ver = ver.lower().strip().replace(' ', '-')
         return ver # Permitted to be None.
 
     def add_locale_features(self, features):
-        add_common_locales(features, self.full_config.lit_config)
+        self.add_common_locales(features)
         # Some linux distributions have different locale data than others.
         # Insert the distributions name and name-version into the available
         # features to allow tests to XFAIL on them.
         name = self.platform_name()
         ver = self.platform_ver()
         if name:
             features.add(name)
         if name and ver:
def add_cxx_link_flags(self, flags):
             flags += ['-latomic']
         san = self.full_config.get_lit_conf('use_sanitizer', '').strip()
         if san:
             # The libraries and their order are taken from the
             # linkSanitizerRuntimeDeps function in
             # clang/lib/Driver/Tools.cpp
             flags += ['-lpthread', '-lrt', '-lm', '-ldl']
 
+class LinuxRemoteTI(LinuxLocalTI):
+    def __init__(self, full_config):
+        super(LinuxRemoteTI, self).__init__(full_config)
+        self.__cached_locales = None
+    
+    def _test_locale(self, loc):
+        if self.__cached_locales is None:
+            self.full_config.lit_config.note('asking the remote host for supported locales...')
+            _, out, err, exit_code = self.executor.execute_command_remote(['locale', '-a'])
+            if exit_code != 0:
+                raise RuntimeError(err)
+            self.__cached_locales = out.splitlines()
+
+        # It is possible that the output will use 'en_US.utf8' instead of 'en_US.UTF-8',
+        # so we check both variants.
+        return loc in self.__cached_locales or \
+               loc.replace('UTF-8', 'utf8') in self.__cached_locales
 
 class WindowsLocalTI(DefaultTargetInfo):
     def __init__(self, full_config):
         super(WindowsLocalTI, self).__init__(full_config)
 
     def add_locale_features(self, features):
-        add_common_locales(features, self.full_config.lit_config,
-                           is_windows=True)
+        self.add_common_locales(features, is_windows=True)
 
     def use_lit_shell_default(self):
         # Default to the internal shell on Windows, as bash on Windows is
         # usually very slow.
         return True
 
 
 def make_target_info(full_config):