| #!/usr/bin/env python |
| # utils/rth - Resilience test helper |
| # |
| # This source file is part of the Swift.org open source project |
| # |
| # Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors |
| # Licensed under Apache License v2.0 with Runtime Library Exception |
| # |
| # See https://swift.org/LICENSE.txt for license information |
| # See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors |
| |
| from __future__ import print_function |
| |
| import argparse |
| import glob |
| import os |
| import pipes |
| import shlex |
| import shutil |
| import subprocess |
| import sys |
| |
| VERBOSE = True |
| |
| |
| def verbose_print_command(command): |
| if VERBOSE: |
| print(" ".join(pipes.quote(c) for c in command)) |
| sys.stdout.flush() |
| |
| |
| class ResilienceTest(object): |
| |
| def __init__(self, target_build_swift, target_run, target_codesign, |
| target_nm, tmp_dir, test_dir, test_src, lib_prefix, |
| lib_suffix, additional_compile_flags, |
| backward_deployment, no_symbol_diff): |
| self.target_build_swift = shlex.split(target_build_swift) |
| self.target_run = shlex.split(target_run) |
| self.target_codesign = shlex.split(target_codesign) |
| self.target_nm = shlex.split(target_nm) |
| self.tmp_dir = tmp_dir |
| self.test_dir = test_dir |
| self.test_src = test_src |
| self.lib_prefix = lib_prefix |
| self.lib_suffix = lib_suffix |
| self.additional_compile_flags = shlex.split(additional_compile_flags) |
| |
| self.before_dir = os.path.join(self.tmp_dir, 'before') |
| self.after_dir = os.path.join(self.tmp_dir, 'after') |
| self.config_dir_map = {'BEFORE': self.before_dir, |
| 'AFTER': self.after_dir} |
| |
| self.lib_src_name = os.path.basename(self.test_src)[5:] |
| self.lib_name = self.lib_src_name[:-6] |
| self.lib_src = os.path.join(self.test_dir, 'Inputs', self.lib_src_name) |
| |
| self.backward_deployment = backward_deployment |
| self.no_symbol_diff = no_symbol_diff |
| |
| def run(self): |
| self.set_up() |
| self.compile_library() |
| self.compare_symbols() |
| self.compile_main() |
| self.link() |
| self.execute() |
| return 0 |
| |
| def set_up(self): |
| shutil.rmtree(self.tmp_dir, ignore_errors=True) |
| os.makedirs(self.after_dir) |
| os.makedirs(self.before_dir) |
| |
| def is_apple_platform(self): |
| return any('-apple-' in arg for arg in self.target_build_swift) |
| |
| def compile_library(self): |
| for config in self.config_dir_map: |
| lib_file = self.lib_prefix + self.lib_name + self.lib_suffix |
| output_dylib = os.path.join(self.config_dir_map[config], |
| lib_file) |
| compiler_flags = ['-emit-library', '-emit-module', |
| '-swift-version', '4', |
| '-enable-library-evolution', |
| '-D', config, |
| self.lib_src, |
| '-o', output_dylib] |
| if self.is_apple_platform(): |
| compiler_flags += ['-Xlinker', |
| '-install_name', |
| '-Xlinker', |
| os.path.join('@rpath', lib_file)] |
| |
| command = self.target_build_swift + \ |
| self.additional_compile_flags + \ |
| compiler_flags |
| verbose_print_command(command) |
| returncode = subprocess.call(command) |
| assert returncode == 0, str(command) |
| |
| codesign_cmd = self.target_codesign + [output_dylib] |
| verbose_print_command(codesign_cmd) |
| returncode = subprocess.call(codesign_cmd) |
| assert returncode == 0, str(codesign_cmd) |
| |
| if not self.no_symbol_diff: |
| # Global symbols only, don't display address or type, don't |
| # display undefined symbols |
| nm_cmd = self.target_nm + ["-gjU", output_dylib] |
| verbose_print_command(nm_cmd) |
| |
| symbol_file = os.path.join(self.config_dir_map[config], |
| self.lib_name + ".symbols") |
| |
| with open(symbol_file, "w") as handle: |
| returncode = subprocess.call(nm_cmd, stdout=handle) |
| assert returncode == 0, str(nm_cmd) |
| |
| def compare_symbols(self): |
| if self.no_symbol_diff: |
| return |
| |
| before_symbol_file = os.path.join(self.config_dir_map["BEFORE"], |
| self.lib_name + ".symbols") |
| after_symbol_file = os.path.join(self.config_dir_map["AFTER"], |
| self.lib_name + ".symbols") |
| |
| diff_cmd = ["diff", |
| "--changed-group-format=%<", |
| "--unchanged-group-format=", |
| before_symbol_file, after_symbol_file] |
| try: |
| subprocess.check_output(diff_cmd) |
| except subprocess.CalledProcessError as e: |
| assert len(e.output) == 0, "Removed symbols:\n" + e.output |
| |
| def compile_main(self): |
| for config in self.config_dir_map: |
| # If we're testing backward deployment, we only want to build |
| # the app against the new version of the library. |
| if self.backward_deployment and \ |
| config == "BEFORE": |
| continue |
| |
| output_obj = os.path.join(self.config_dir_map[config], 'main.o') |
| compiler_flags = ['-D', config, '-c', self.test_src, |
| '-I', self.config_dir_map[config], |
| '-o', output_obj] |
| command = self.target_build_swift + \ |
| self.additional_compile_flags + \ |
| compiler_flags |
| verbose_print_command(command) |
| returncode = subprocess.call(command) |
| assert returncode == 0, str(command) |
| |
| def configs(self): |
| for config1 in self.config_dir_map: |
| for config2 in self.config_dir_map: |
| if self.backward_deployment and \ |
| config2 == "BEFORE": |
| continue |
| |
| yield (config1, config2) |
| |
| def link(self): |
| for config1, config2 in self.configs(): |
| config1_lower = config1.lower() |
| config2_lower = config2.lower() |
| output_obj = os.path.join(self.tmp_dir, |
| config1_lower + '_' + config2_lower) |
| if self.is_apple_platform(): |
| rpath_origin = '@executable_path' |
| else: |
| rpath_origin = '$ORIGIN' |
| |
| compiler_flags = [ |
| '-L', self.config_dir_map[config2], |
| '-l' + self.lib_name, |
| os.path.join(self.config_dir_map[config2], |
| 'main.o'), |
| '-Xlinker', '-rpath', '-Xlinker', |
| os.path.join(rpath_origin, |
| os.path.relpath(self.config_dir_map[config1], |
| self.tmp_dir)), |
| '-o', output_obj |
| ] |
| |
| if self.is_apple_platform(): |
| compiler_flags += ['-Xlinker', '-bind_at_load'] |
| |
| command = self.target_build_swift + compiler_flags |
| verbose_print_command(command) |
| returncode = subprocess.call(command) |
| assert returncode == 0, str(command) |
| |
| codesign_cmd = self.target_codesign + [output_obj] |
| verbose_print_command(codesign_cmd) |
| returncode = subprocess.call(codesign_cmd) |
| assert returncode == 0, str(codesign_cmd) |
| |
| def execute(self): |
| for config1, config2 in self.configs(): |
| config1_lower = config1.lower() |
| config2_lower = config2.lower() |
| output_obj = os.path.join(self.tmp_dir, |
| config1_lower + '_' + config2_lower) |
| tmp_dir_contents = glob.glob( |
| os.path.join(self.tmp_dir, self.config_dir_map[config1], '*')) |
| command = self.target_run + [output_obj] + tmp_dir_contents |
| verbose_print_command(command) |
| returncode = subprocess.call(command) |
| assert returncode == 0, str(command) |
| |
| |
| def main(): |
| parser = argparse.ArgumentParser(description='Resilience test helper') |
| parser.add_argument('--target-build-swift', required=True) |
| parser.add_argument('--target-run', required=True) |
| parser.add_argument('--target-codesign', default='echo') |
| parser.add_argument('--target-nm', default='nm') |
| parser.add_argument('--t', required=True) |
| parser.add_argument('--S', required=True) |
| parser.add_argument('--s', required=True) |
| parser.add_argument('--lib-prefix', required=True) |
| parser.add_argument('--lib-suffix', required=True) |
| parser.add_argument('--additional-compile-flags', default='') |
| parser.add_argument('--backward-deployment', default=False, |
| action='store_true') |
| parser.add_argument('--no-symbol-diff', default=False, |
| action='store_true') |
| |
| args = parser.parse_args() |
| |
| resilience_test = ResilienceTest(args.target_build_swift, args.target_run, |
| args.target_codesign, args.target_nm, |
| args.t, args.S, args.s, args.lib_prefix, |
| args.lib_suffix, |
| args.additional_compile_flags, |
| args.backward_deployment, |
| args.no_symbol_diff) |
| |
| return resilience_test.run() |
| |
| |
| if __name__ == '__main__': |
| exit(main()) |
