Files
spark/tools/py/build_api_server.py
T

246 lines
7.4 KiB
Python

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()