import argparse import subprocess import os from typing import Optional from cmake.cmake_utils import CMakeCompilerPair, CMakeConfigureCommand from core.argparse_utils import add_toggle_opt, get_arg from core.file_utils import CWD, SparkPaths, as_path, create_dir, link_file from core.iter_utils import flatten, is_none_or_empty from core.logging import exit_msg def _parse_compiler(arg: str or None): '''Parses compiler input (from cli) and returns a tuple of c, cxx compilers respectively''' known_compilers = { 'gcc': CMakeCompilerPair('gcc', 'gcc-11', 'g++-11'), 'clang': CMakeCompilerPair('clang', 'clang', 'clang++'), 'clang-13': CMakeCompilerPair('clang', 'clang-13', 'clang++-13'), } if arg in known_compilers: return known_compilers[arg] raise ValueError( f"Unexpected compiler '{arg}'. Please use one of [{' '.join(known_compilers)}]" ) def _parse_build_dir(build_dir, build_type: Optional[str] = None): if build_dir is not None: return as_path(build_dir).value() rv = SparkPaths.root().joinpath('build') if build_type is not None: rv = rv.joinpath(build_type) return rv class BuildApiServerArgs: def __init__(self, args): args_dict = vars(args) self.compiler = _parse_compiler(get_arg(args_dict, 'compiler', 'gcc')) # Forcibly correct case (so user doesn't have to worry abt it) self.build_type = args.build_type.title() if self.build_type not in ['Debug', 'Release']: raise ValueError(f"Unexpected build_type '{args.build_type}'") self.cmake_build_dir = _parse_build_dir( args_dict.get('cmake_output_dir')).absolute() self.clean = args.clean self.jobs = args.jobs self.targets = None if args.target is None else flatten(args.target) self.dotnet_verbosity = args.verbosity # Translate dotnet verbosity level to binary '--verbose' flag for cmake self.cmake_verbose = args.verbosity in [ 'd', 'detailed', 'diag', 'diagnostic' ] def _get_arg_parser(): parser = argparse.ArgumentParser(description='Build spark_client.sln') parser.add_argument( '--build-type', metavar='debug|release', type=str, nargs='?', help='The build type') parser.add_argument( '--compiler', metavar='gcc|clang', type=str, nargs='?', help='The compiler') parser.add_argument( '-o', '--cmake-output-dir', metavar='path', type=str, nargs='?', help= 'The directory in which to build libspark (defaults to [repo_root]/build)' ) parser.add_argument( '-t', '--target', type=str, action='append', nargs='+', help='The target(s) to build') parser.add_argument( '-j', '--jobs', type=int, help='[CMake] The number of parallel jobs to run') add_toggle_opt( parser, 'clean', help='Whether or not to perform a clean build') parser.add_argument( '--verbosity', metavar='[q(uiet)|m(inimal)|n(ormal)|d(etailed)|diag(nostic)]', choices=[ 'q', 'quiet', 'm', 'minimal', 'n', 'normal', 'd', 'detailed', 'diag', 'diagnostic' ], type=str, help='The output verbosity level') parser.set_defaults( build_type='Debug', compiler='gcc', verbosity='minimal') return parser def _configure(src_dir, build_dir, compiler: CMakeCompilerPair): '''Configures sparkd (server) build''' cmd = CMakeConfigureCommand( src_dir=src_dir, build_dir=build_dir, generator='"Ninja Multi-Config"', compiler=compiler) cmd.add_opt('BUILD_API_SERVER', True) cmd.add_opt('BUILD_SPARKD', False) cmd.add_opt('BUILD_WEB', False) cmd.add_opt('CMAKE_EXPORT_COMPILE_COMMANDS', True) return _run_cmd(str(cmd)) def _check_results(proc_results): for res in proc_results: if res.returncode != 0: exit_msg(1, f'The following build subprocess failed: {res}') def _run_cmd(cmd): print(f'run cmd: {cmd}') return subprocess.run(cmd, shell=True) def _dotnet_build(build_type='Debug', verbosity='minimal'): '''Builds dotnet''' with (CWD(SparkPaths.root())): cmd_parts = [f'dotnet build Spark.Api.Server.sln'] if verbosity is not None: cmd_parts.append(f'--verbosity {verbosity}') if build_type is not None: cmd_parts.append(f'--configuration {build_type}') return _run_cmd(' '.join(cmd_parts)) def _dotnet_clean(build_type='Debug', verbosity='minimal'): '''Cleans dotnet''' with (CWD(SparkPaths.root())): cmd_parts = [f'dotnet clean Spark.Api.Server.sln'] if verbosity is not None: cmd_parts.append(f'--verbosity {verbosity}') if build_type is not None: cmd_parts.append(f'--configuration {build_type}') return _run_cmd(' '.join(cmd_parts)) def _cmake_build( build_dir, build_type=None, targets=None, jobs=None, verbose=False): '''Builds libspark''' build_type = build_type or 'release' build_dir = as_path(build_dir).value() cmd_parts = [f'cmake --build {build_dir} --config {build_type.title()}'] if jobs is not None: cmd_parts.append(f'-j {jobs}') if not is_none_or_empty(targets): cmd_parts.append(' '.join([f"--target {t}" for t in targets])) if verbose: cmd_parts.append('--verbose') return _run_cmd(' '.join(cmd_parts)) def _cmake_clean(build_dir, build_type=None, jobs=None, verbose=False): '''Cleans libspark''' # In cmake, 'clean' is technically a build target _cmake_build(build_dir, build_type, ['clean'], jobs=jobs, verbose=verbose) def _build( src_dir, cmake_build_dir, build_type: str, compiler=None, targets=None, clean=False, jobs=None, cmake_verbose=False, dotnet_verbosity: Optional[str] = None) -> list: '''Builds libspark''' # check if explicit no-op if targets is not None and len(targets) == 0: return [] compiler = compiler or CMakeCompilerPair('gcc', 'gcc', 'g++') cmake_build_dir = as_path(cmake_build_dir).value() proc_results = [] try: create_dir(cmake_build_dir) proc_results.append( _configure( src_dir=src_dir, build_dir=cmake_build_dir, compiler=compiler)) if proc_results[-1].returncode: # Build is broken (exit early) return proc_results except Exception as e: exit_msg(1, e) if clean: # cmake clean proc_results.append( _cmake_clean(cmake_build_dir, build_type, jobs, cmake_verbose)) # dotnet clean proc_results.append(_dotnet_clean(build_type, dotnet_verbosity)) # cmake build proc_results.append( _cmake_build( cmake_build_dir, build_type, targets, jobs, cmake_verbose)) return proc_results def _main(): args = BuildApiServerArgs(_get_arg_parser().parse_args()) proc_results = _build( src_dir=SparkPaths.root(), cmake_build_dir=args.cmake_build_dir, build_type=args.build_type, compiler=args.compiler, targets=args.targets, jobs=args.jobs, cmake_verbose=args.cmake_verbose, dotnet_verbosity=args.dotnet_verbosity) _check_results(proc_results) if __name__ == '__main__': _main()