From b00ae22060acf80467e981d6138aa14de897785d Mon Sep 17 00:00:00 2001 From: Egor Tensin Date: Fri, 13 Dec 2019 06:22:03 +0300 Subject: build/ -> ci/ --- ci/boost/build.py | 375 +++++++++++++++++++++++++++++++++++++++++++++++ ci/boost/build_travis.py | 76 ++++++++++ ci/build.py | 222 ++++++++++++++++++++++++++++ ci/build_appveyor.py | 131 +++++++++++++++++ ci/build_travis.py | 61 ++++++++ 5 files changed, 865 insertions(+) create mode 100755 ci/boost/build.py create mode 100755 ci/boost/build_travis.py create mode 100755 ci/build.py create mode 100755 ci/build_appveyor.py create mode 100755 ci/build_travis.py (limited to 'ci') diff --git a/ci/boost/build.py b/ci/boost/build.py new file mode 100755 index 0000000..8c8a818 --- /dev/null +++ b/ci/boost/build.py @@ -0,0 +1,375 @@ +#!/usr/bin/env python3 + +# Copyright (c) 2019 Egor Tensin +# This file is part of the "cmake-common" project. +# For details, see https://github.com/egor-tensin/cmake-common. +# Distributed under the MIT License. + +# This script downloads and builds the Boost libraries. + +import argparse +from contextlib import contextmanager +from enum import Enum +import logging +import os.path +import platform +import re +import shutil +import struct +import subprocess +import sys +import tempfile +import urllib.request + + +@contextmanager +def _chdir(path): + cwd = os.getcwd() + os.chdir(path) + try: + yield + finally: + os.chdir(cwd) + + +def _setup_logging(): + logging.basicConfig( + format='%(asctime)s | %(levelname)s | %(message)s', + level=logging.INFO) + + +def _on_windows(): + return platform.system() == 'Windows' + + +def _run_executable(cmd_line): + logging.info('Running executable: %s', cmd_line) + result = subprocess.run(cmd_line) + result.check_returncode() + + +class Platform(Enum): + X86 = 'x86' + X64 = 'x64' + WIN32 = 'win32' + + def __str__(self): + return self.value + + @staticmethod + def all(): + return (Platform.X86, Platform.X64) + + def get_address_model(self): + if self is Platform.X86: + return 32 + if self is Platform.X64: + return 64 + if self is Platform.WIN32: + return 32 + raise NotImplementedError(f'unsupported platform: {self}') + + +def _parse_platform(s): + try: + return Platform(s.lower()) + except ValueError: + raise argparse.ArgumentTypeError(f'invalid platform: {s}') + + +class Configuration(Enum): + DEBUG = 'debug' + RELEASE = 'release' + + @staticmethod + def all(): + return tuple(Configuration) + + def __str__(self): + return self.value + + +def _parse_configuration(s): + try: + return Configuration(s.lower()) + except ValueError: + raise argparse.ArgumentTypeError(f'invalid configuration: {s}') + + +class Linkage(Enum): + STATIC = 'static' + SHARED = 'shared' + + @staticmethod + def all(): + return tuple(Linkage) + + def __str__(self): + return self.value + + +def _parse_linkage(s): + try: + return Linkage(s) + except ValueError: + raise argparse.ArgumentTypeError(f'invalid linkage settings: {s}') + + +class BoostVersion: + def __init__(self, major, minor, patch): + self.major = major + self.minor = minor + self.patch = patch + + def __str__(self): + return f'{self.major}.{self.minor}.{self.patch}' + + @property + def archive_ext(self): + return '.tar.gz' + + def dir_path(self, parent_dir): + return os.path.join(parent_dir, self.dir_name) + + @property + def dir_name(self): + return f'boost_{self.major}_{self.minor}_{self.patch}' + + @property + def archive_name(self): + return f'{self.dir_name}{self.archive_ext}' + + def get_download_url(self): + return f'https://dl.bintray.com/boostorg/release/{self}/source/{self.archive_name}' + + +def _parse_boost_version(s): + result = re.match(r'^(\d+)\.(\d+)\.(\d+)$', s) + if result is None: + raise argparse.ArgumentTypeError(f'invalid Boost version: {s}') + return BoostVersion(result.group(1), result.group(2), result.group(3)) + + +class BoostArchive: + def __init__(self, version, path): + self.version = version + self.path = path + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + logging.info('Removing temporary file: %s', self.path) + os.remove(self.path) + + @property + def dir_name(self): + return self.version.dir_name + + @staticmethod + def download(version): + path = None + with tempfile.NamedTemporaryFile(prefix='boost_', suffix=version.archive_ext, delete=False) as dest: + path = dest.name + logging.info('Downloading Boost to: %s', path) + url = version.get_download_url() + logging.info('Download URL: %s', url) + + with urllib.request.urlopen(url) as request: + dest.write(request.read()) + return BoostArchive(version, path) + + +class BoostDir: + def __init__(self, path): + if not os.path.isdir(path): + raise RuntimeError(f"Boost directory doesn't exist: {path}") + self.path = path + + @staticmethod + def unpack(archive, dest): + path = os.path.join(dest, archive.dir_name) + if os.path.exists(path): + raise RuntimeError(f'Boost directory already exists: {path}') + logging.info('Unpacking Boost to: %s', path) + shutil.unpack_archive(archive.path, dest) + return BoostDir(path) + + def _go(self): + return _chdir(self.path) + + def build(self, params): + with self._go(): + self._bootstrap_if_required() + self._b2(params) + + def _bootstrap_if_required(self): + if os.path.isfile(self._b2_path()): + logging.info('Not going to bootstrap, b2 is already there') + return + self._bootstrap() + + def _bootstrap(self): + _run_executable(self._bootstrap_path()) + + def _b2(self, params): + for b2_params in params.enum_b2_params(): + _run_executable([self._b2_path()] + b2_params) + + @staticmethod + def _bootstrap_path(): + return os.path.join('.', BoostDir._bootstrap_name()) + + @staticmethod + def _bootstrap_name(): + ext = '.sh' + if _on_windows(): + ext = '.bat' + return f'bootstrap{ext}' + + @staticmethod + def _b2_path(): + return os.path.join('.', BoostDir._b2_name()) + + @staticmethod + def _b2_name(): + ext = '' + if _on_windows(): + ext = '.exe' + return f'b2{ext}' + + +class BoostBuild: + def __init__(self, args): + self.toolchain = args.toolchain + self.platforms = args.platforms or Platform.all() + self.configurations = args.configurations or Configuration.all() + self.runtime_link = args.runtime_link or Linkage.all() + self.link = args.link or Linkage.all() + self.libraries = args.libraries + self.b2_args = args.b2_args + + def enum_b2_params(self): + for platform in self.platforms: + platform_params = [] + platform_params.append(self._address_model(platform)) + platform_params.append(self._runtime_link()) + platform_params.append(self._link()) + platform_params += self._user_config_optional() + platform_params += self._with_optional() + platform_params += self.b2_args + if _on_windows(): + platform_params.append(self._windows_stagedir(platform)) + platform_params.append(self._windows_variant(self.configurations)) + yield platform_params + else: + for configuration in self.configurations: + variant_params = list(platform_params) + variant_params.append(self._unix_stagedir(platform, configuration)) + variant_params.append(self._unix_variant(configuration)) + yield variant_params + + @staticmethod + def _address_model(platform): + return f'address-model={platform.get_address_model()}' + + def _runtime_link(self): + link = ','.join(map(str, self.runtime_link)) + return f'runtime-link={link}' + + def _link(self): + link = ','.join(map(str, self.link)) + return f'link={link}' + + def _user_config_optional(self): + if self.toolchain is None: + return [] + return [f'--user-config={self.toolchain}'] + + def _with_optional(self): + return [f'--with-{lib}' for lib in self.libraries] + + @staticmethod + def _windows_stagedir(platform): + return f'--stagedir=stage/{platform}' + + @staticmethod + def _unix_stagedir(platform, configuration): + return f'--stagedir=stage/{platform}/{configuration}' + + @staticmethod + def _windows_variant(configurations): + variant = ','.join(map(str, configurations)) + return f'variant={variant}' + + @staticmethod + def _unix_variant(configuration): + return f'variant={configuration}' + + +def _parse_args(argv=None): + if argv is None: + argv = sys.argv[1:] + logging.info('Command line arguments: %s', argv) + parser = argparse.ArgumentParser() + parser.add_argument('--version', metavar='VERSION', dest='boost_version', + type=_parse_boost_version, required=True, + help='Boost version (in the MAJOR.MINOR.PATCH format)') + parser.add_argument('--no-download', action='store_true', + help="don't download Boost, attempt to build the existing directory") + parser.add_argument('--toolchain', metavar='PATH', + help='Boost user configuration file') + parser.add_argument('--platform', metavar='PLATFORM', + nargs='*', dest='platforms', default=(), + type=_parse_platform, + help='target platform (e.g. x86/x64)') + parser.add_argument('--configuration', metavar='CONFIGURATION', + nargs='*', dest='configurations', default=(), + type=_parse_configuration, + help='target platform (e.g. Debug/Release)') + parser.add_argument('--runtime-link', metavar='LINKAGE', + nargs='*', dest='runtime_link', default=(), + type=_parse_linkage, + help='runtime linkage options (e.g. static/shared)') + parser.add_argument('--link', metavar='LINKAGE', + nargs='*', dest='link', default=(), + type=_parse_linkage, + help='library linkage options (e.g. static/shared)') + parser.add_argument('--build', metavar='DIR', dest='build_dir', + type=os.path.abspath, default='.', + help='destination directory') + parser.add_argument('--with', metavar='LIB', dest='libraries', + nargs='*', default=(), + help='only build these libraries') + parser.add_argument('b2_args', nargs='*', metavar='B2_ARG', default=(), + help='additional b2 arguments, to be passed verbatim') + return parser.parse_args(argv) + + +def _build(boost_dir, build_params): + boost_dir.build(build_params) + + +def download_and_build(argv=None): + args = _parse_args(argv) + build_params = BoostBuild(args) + if args.no_download: + boost_dir = BoostDir(args.boost_version.dir_path(args.build_dir)) + _build(boost_dir, build_params) + else: + with BoostArchive.download(args.boost_version) as archive: + boost_dir = BoostDir.unpack(archive, args.build_dir) + _build(boost_dir, build_params) + + +def main(argv=None): + _setup_logging() + try: + download_and_build(argv) + except Exception as e: + logging.exception(e) + raise + + +if __name__ == '__main__': + main() diff --git a/ci/boost/build_travis.py b/ci/boost/build_travis.py new file mode 100755 index 0000000..8e78f72 --- /dev/null +++ b/ci/boost/build_travis.py @@ -0,0 +1,76 @@ +#!/usr/bin/env python3 + +# Copyright (c) 2019 Egor Tensin +# This file is part of the "cmake-common" project. +# For details, see https://github.com/egor-tensin/cmake-common. +# Distributed under the MIT License. + +# This is similar to build.py, but auto-fills some parameters for build.py from +# the Travis-defined environment variables. +# Boost is built in $HOME. + +import logging +import os +import sys + +from build import download_and_build + + +def _env(name): + if name not in os.environ: + raise RuntimeError(f'undefined environment variable: {name}') + return os.environ[name] + + +def _check_travis(): + if 'TRAVIS' not in os.environ: + raise RuntimeError('not running on Travis') + + +def _get_build_dir(): + return _env('HOME') + + +def _get_boost_version(): + return _env('travis_boost_version') + + +def _get_configuration(): + return _env('configuration') + + +def _get_platform(): + return _env('platform') + + +def _setup_logging(): + logging.basicConfig( + format='%(asctime)s | %(levelname)s | %(message)s', + level=logging.INFO) + + +def build_travis(argv=None): + if argv is None: + argv = sys.argv[1:] + logging.info('Command line arguments: %s', argv) + _check_travis() + travis_argv = [ + '--build', _get_build_dir(), + '--version', _get_boost_version(), + '--configuration', _get_configuration(), + '--platform', _get_platform(), + ] + download_and_build(travis_argv + argv) + + +def main(argv=None): + _setup_logging() + try: + build_travis(argv) + except Exception as e: + logging.exception(e) + raise + + +if __name__ == '__main__': + main() diff --git a/ci/build.py b/ci/build.py new file mode 100755 index 0000000..dd88156 --- /dev/null +++ b/ci/build.py @@ -0,0 +1,222 @@ +#!/usr/bin/env python3 + +# Copyright (c) 2019 Egor Tensin +# This file is part of the "cmake-common" project. +# For details, see https://github.com/egor-tensin/cmake-common. +# Distributed under the MIT License. + +# This script is used basically to invoke the CMake executable in a +# cross-platform way (provided the platform has Python 3, of course). +# The motivation was to merge my Travis and AppVeyor build scripts (largely +# similar, but written in bash and PowerShell, respectively). + +import argparse +from contextlib import contextmanager +import logging +from enum import Enum +import os +import os.path +import shutil +import subprocess +import sys +import tempfile + + +def _make_tmp_dir(**kwargs): + path = tempfile.mkdtemp(**kwargs) + logging.info('Created temporary directory: %s', path) + return path + + +def _log_rmtree_error(function, path, exc_info): + logging.error("Couldn't remove path '%s': %s", path, exc_info) + + +def _remove_dir(path): + logging.info('Removing directory: %s', path) + shutil.rmtree(path, onerror=_log_rmtree_error) + + +def _run_executable(cmd_line): + logging.info('Running executable: %s', cmd_line) + result = subprocess.run(cmd_line) + result.check_returncode() + + +def _run_cmake(cmake_args): + _run_executable(['cmake'] + cmake_args) + + +class Configuration(Enum): + DEBUG = 'Debug' + RELEASE = 'Release' + + def __str__(self): + return self.value + + +def _parse_configuration(s): + try: + return Configuration(s) + except ValueError: + raise argparse.ArgumentTypeError(f'invalid configuration: {s}') + + +class BuildDir: + def __init__(self, args): + self.path = args.build_dir + self.clean = args.clean_build_dir + self.tmp_dir = self.path is None + if self.tmp_dir: + self.path = self._make_build_dir() + + @staticmethod + def _make_build_dir(): + return _make_tmp_dir(prefix='build_') + + def __enter__(self): + return self + + def __exit__(self, *args): + if self.tmp_dir and self.clean: + _remove_dir(self.path) + + +class GenerationPhase: + def __init__(self, build_dir, args): + self.build_dir = build_dir + self.args = args + + def _cmake_args(self): + return self._to_cmake_args(self.build_dir, self.args) + + @staticmethod + def _to_cmake_args(build_dir, args): + result = [] + if args.generator is not None: + result += ['-G', args.generator] + if args.platform is not None: + result += ['-A', args.platform] + if args.install_dir is not None: + result.append(f'-DCMAKE_INSTALL_PREFIX={args.install_dir}') + if args.configuration is not None: + result.append(f'-DCMAKE_BUILD_TYPE={args.configuration}') + if args.toolchain_path is not None: + result.append(f'-DCMAKE_TOOLCHAIN_FILE={args.toolchain_path}') + if args.boost_root is not None: + result.append(f'-DBOOST_ROOT={args.boost_root}') + if args.boost_librarydir is not None: + result.append(f'-DBOOST_LIBRARYDIR={args.boost_librarydir}') + if args.cmake_args is not None: + result += [arg for arg in args.cmake_args] + result += [f'-B{build_dir.path}'] + result += [f'-H{args.src_dir}'] + return result + + def run(self): + _run_cmake(self._cmake_args()) + + +class BuildPhase: + def __init__(self, build_dir, args): + self.build_dir = build_dir + self.args = args + + def _cmake_args(self): + return self._to_cmake_args(self.build_dir, self.args) + + @staticmethod + def _to_cmake_args(build_dir, args): + result = ['--build', build_dir.path] + if args.clean_build_dir: + result.append('--clean-first') + if args.configuration is not None: + result += ['--config', str(args.configuration)] + if args.install_dir is not None: + result += ['--target', 'install'] + return result + + def run(self): + _run_cmake(self._cmake_args()) + + +class CleanPhase: + def __init__(self, build_dir, args): + self.build_dir = build_dir + self.args = args + + def _cmake_args(self): + return self._to_cmake_args(self.build_dir, self.args) + + @staticmethod + def _to_cmake_args(build_dir, args): + result = ['--build', build_dir.path] + if args.configuration is not None: + result += ['--config', str(args.configuration)] + result += ['--target', 'clean'] + return result + + def run(self): + if self.args.clean_build_dir: + _run_cmake(self._cmake_args()) + + +def _parse_args(argv=None): + if argv is None: + argv = sys.argv[1:] + logging.info('Command line arguments: %s', argv) + parser = argparse.ArgumentParser(description='Build a CMake project') + parser.add_argument('--src', required=True, dest='src_dir', + type=os.path.abspath, metavar='DIR', + help='source directory') + parser.add_argument('--build', metavar='DIR', dest='build_dir', + help='build directory (temporary directory if not specified)') + parser.add_argument('--install', metavar='DIR', dest='install_dir', + help='install directory') + parser.add_argument('--clean', action='store_true', dest='clean_build_dir', + help='clean the build directory (temporary directory will be removed)') + parser.add_argument('--generator', help='build system to use') + parser.add_argument('--platform', help='target platform (i.e. Win32/x64)') + parser.add_argument('--configuration', metavar='CONFIG', + type=_parse_configuration, + help='build configuration (i.e. Debug/Release)') + parser.add_argument('--toolchain', metavar='PATH', dest='toolchain_path', + help='CMake toolchain file path') + parser.add_argument('--boost', metavar='DIR', dest='boost_root', + help='set Boost directory') + parser.add_argument('--boost-librarydir', metavar='DIR', + help='set Boost library directory (stage/lib by default)') + parser.add_argument('cmake_args', nargs='*', metavar='CMAKE_ARG', + help='additional CMake arguments, to be passed verbatim') + args = parser.parse_args(argv) + return args + + +def _setup_logging(): + logging.basicConfig( + format='%(asctime)s | %(levelname)s | %(message)s', + level=logging.INFO) + + +def build(argv=None): + args = _parse_args(argv) + with BuildDir(args) as build_dir: + gen_phase = GenerationPhase(build_dir, args) + gen_phase.run() + build_phase = BuildPhase(build_dir, args) + build_phase.run() + clean_phase = CleanPhase(build_dir, args) + clean_phase.run() + + +def main(argv=None): + _setup_logging() + try: + build(argv) + except Exception as e: + logging.exception(e) + raise + + +if __name__ == '__main__': + main() diff --git a/ci/build_appveyor.py b/ci/build_appveyor.py new file mode 100755 index 0000000..2d2ee65 --- /dev/null +++ b/ci/build_appveyor.py @@ -0,0 +1,131 @@ +#!/usr/bin/env python3 + +# Copyright (c) 2019 Egor Tensin +# This file is part of the "cmake-common" project. +# For details, see https://github.com/egor-tensin/cmake-common. +# Distributed under the MIT License. + +# This is similar to build.py, but auto-fills some parameters for build.py from +# the AppVeyor-defined environment variables. +# The project is built in C:\Projects\build. + +from enum import Enum +import logging +import os +import sys + +from build import build + + +class Image(Enum): + VS_2013 = 'Visual Studio 2013' + VS_2015 = 'Visual Studio 2015' + VS_2017 = 'Visual Studio 2017' + VS_2019 = 'Visual Studio 2019' + + def __str__(self): + return self.value + + +def _parse_image(s): + try: + return Image(s) + except ValueError as e: + raise ValueError(f'unsupported AppVeyor image: {s}') from e + + +class Generator(Enum): + VS_2013 = 'Visual Studio 12 2013' + VS_2015 = 'Visual Studio 14 2015' + VS_2017 = 'Visual Studio 15 2017' + VS_2019 = 'Visual Studio 16 2019' + + def __str__(self): + return self.value + + @staticmethod + def from_image(image): + if image is Image.VS_2013: + return Generator.VS_2013 + if image is Image.VS_2015: + return Generator.VS_2015 + if image is Image.VS_2017: + return Generator.VS_2017 + if image is Image.VS_2019: + return Generator.VS_2019 + raise RuntimeError(f"don't know which generator to use for image: {image}") + + +class Platform(Enum): + x86 = 'Win32' + X64 = 'x64' + + def __str__(self): + return self.value + + +def _parse_platform(s): + try: + return Platform(s) + except ValueError as e: + raise ValueError(f'unsupported AppVeyor platform: {s}') from e + + +def _env(name): + if name not in os.environ: + raise RuntimeError(f'undefined environment variable: {name}') + return os.environ[name] + + +def _get_src_dir(): + return _env('APPVEYOR_BUILD_FOLDER') + + +def _get_build_dir(): + return R'C:\Projects\build' + + +def _get_generator(): + image = _parse_image(_env('APPVEYOR_BUILD_WORKER_IMAGE')) + return str(Generator.from_image(image)) + + +def _get_platform(): + return str(_parse_platform(_env('PLATFORM'))) + + +def _get_configuration(): + return _env('CONFIGURATION') + + +def _setup_logging(): + logging.basicConfig( + format='%(asctime)s | %(levelname)s | %(message)s', + level=logging.INFO) + + +def build_appveyor(argv=None): + if argv is None: + argv = sys.argv[1:] + logging.info('Command line arguments: %s', argv) + appveyor_argv = [ + '--src', _get_src_dir(), + '--build', _get_build_dir(), + '--generator', _get_generator(), + '--platform', _get_platform(), + '--configuration', _get_configuration(), + ] + build(appveyor_argv + argv) + + +def main(argv=None): + _setup_logging() + try: + build_appveyor(argv) + except Exception as e: + logging.exception(e) + raise + + +if __name__ == '__main__': + main() diff --git a/ci/build_travis.py b/ci/build_travis.py new file mode 100755 index 0000000..dce7fd7 --- /dev/null +++ b/ci/build_travis.py @@ -0,0 +1,61 @@ +#!/usr/bin/env python3 + +# Copyright (c) 2019 Egor Tensin +# This file is part of the "cmake-common" project. +# For details, see https://github.com/egor-tensin/cmake-common. +# Distributed under the MIT License. + +# This is similar to build.py, but auto-fills some parameters for build.py from +# the Travis-defined environment variables. +# The project is built in $HOME/build. + +import logging +import os +import os.path +import sys + +from build import build + + +def _env(name): + if name not in os.environ: + raise RuntimeError(f'undefined environment variable: {name}') + return os.environ[name] + + +def _get_src_dir(): + return _env('TRAVIS_BUILD_DIR') + + +def _get_build_dir(): + return os.path.join(_env('HOME'), 'build') + + +def _setup_logging(): + logging.basicConfig( + format='%(asctime)s | %(levelname)s | %(message)s', + level=logging.INFO) + + +def build_travis(argv=None): + if argv is None: + argv = sys.argv[1:] + logging.info('Command line arguments: %s', argv) + travis_argv = [ + '--src', _get_src_dir(), + '--build', _get_build_dir(), + ] + build(travis_argv + argv) + + +def main(argv=None): + _setup_logging() + try: + build_travis(argv) + except Exception as e: + logging.exception(e) + raise + + +if __name__ == '__main__': + main() -- cgit v1.2.3