def build(opts):
"""
support building cmake projects
With provided build options (``RelengBuildOptions``), the build stage will
be processed.
Args:
opts: build options
Returns:
``True`` if the building stage is completed; ``False`` otherwise
"""
if not CMAKE.exists():
err('unable to build package; cmake is not installed')
return False
# definitions
cmake_defs = {}
if opts.build_defs:
cmake_defs.update(expand(opts.build_defs))
# options
cmake_opts = {
# build RelWithDebInfo (when using multi-configuration projects)
'--config': 'RelWithDebInfo',
}
if opts.build_opts:
cmake_opts.update(expand(opts.build_opts))
# argument building
cmake_args = [
# tell cmake to invoke build process in the output directory
'--build',
opts.build_output_dir,
]
cmake_args.extend(prepare_definitions(cmake_defs, '-D'))
cmake_args.extend(prepare_arguments(cmake_opts))
# enable specific number of parallel jobs is set
#
# https://cmake.org/cmake/help/v3.12/manual/cmake.1.html#build-tool-mode
if 'releng.cmake.disable_parallel_option' not in opts._quirks:
if opts.jobsconf != 1 and opts.jobs > 1:
cmake_args.append('--parallel')
cmake_args.append(str(opts.jobs))
else:
verbose('cmake parallel jobs disabled by quirk')
if not CMAKE.execute(cmake_args, env=expand(opts.build_env)):
err('failed to build cmake project: {}', opts.name)
return False
return True
def configure(opts):
"""
support configuration for autotools projects
With provided configuration options (``RelengConfigureOptions``), the
configuration stage will be processed.
Args:
opts: configuration options
Returns:
``True`` if the configuration stage is completed; ``False`` otherwise
"""
# check if autoreconf
if opts._autotools_autoreconf:
verbose('configured to run autoreconf')
if not AUTORECONF.exists():
err('unable to configure package; autoreconf is not installed')
return False
if not AUTORECONF.execute(['--verbose']):
err('failed to prepare autotools project (autoreconf): {}',
opts.name)
return False
# definitions
autotools_defs = {
'--prefix': opts.prefix,
'--exec-prefix': opts.prefix,
}
if opts.conf_defs:
autotools_defs.update(expand(opts.conf_defs))
# default options
autotools_opts = {}
if opts.conf_opts:
autotools_opts.update(expand(opts.conf_opts))
# argument building
autotools_args = []
autotools_args.extend(prepare_definitions(autotools_defs))
autotools_args.extend(prepare_arguments(autotools_opts))
if not execute(['./configure'] + autotools_args,
env_update=expand(opts.conf_env),
critical=False):
err('failed to prepare autotools project (configure): {}', opts.name)
return False
return True
def build(opts):
"""
support building autotools projects
With provided build options (``RelengBuildOptions``), the build stage will
be processed.
Args:
opts: build options
Returns:
``True`` if the building stage is completed; ``False`` otherwise
"""
if not MAKE.exists():
err('unable to build package; make is not installed')
return False
# definitions
autotools_defs = {}
if opts.build_defs:
autotools_defs.update(expand(opts.build_defs))
# default options
autotools_opts = {}
if opts.build_opts:
autotools_opts.update(expand(opts.build_opts))
# argument building
autotools_args = []
autotools_args.extend(prepare_definitions(autotools_defs))
autotools_args.extend(prepare_arguments(autotools_opts))
if opts.jobs > 1:
autotools_args.append('--jobs')
autotools_args.append(str(opts.jobs))
if not MAKE.execute(autotools_args, env=expand(opts.build_env)):
err('failed to build autotools project: {}', opts.name)
return False
return True
def fetch(opts):
"""
support fetching from rsync sources
With provided fetch options (``RelengFetchOptions``), the fetch stage will
be processed.
Args:
opts: fetch options
Returns:
``True`` if the fetch stage is completed; ``False`` otherwise
"""
assert opts
cache_file = opts.cache_file
name = opts.name
site = opts.site
work_dir = opts.work_dir
cache_basename = os.path.basename(cache_file)
cache_stem, __ = interpret_stem_extension(cache_basename)
if not RSYNC.exists():
err('unable to fetch package; rsync is not installed')
return None
note('fetching {}...', name)
sys.stdout.flush()
# options
fetch_opts = {
'--recursive': '', # default recursive call
}
if opts.extra_opts:
fetch_opts.update(expand(opts.extra_opts))
# argument building
fetch_args = []
fetch_args.extend(prepare_arguments(fetch_opts))
# sanity check provided arguments
for fetch_arg in fetch_args:
if '--remove-source-files' in fetch_arg:
err('option `--remove-source-files` not permitted')
return None
elif not fetch_arg.startswith('-'):
err('invalid fetch option provided:', fetch_arg)
return None
fetch_args.append(site) # source directory
fetch_args.append(work_dir) # destination directory
if not RSYNC.execute(fetch_args, cwd=work_dir):
err('unable to rsync from source')
return None
log('successfully invoked rsync for source')
with tarfile.open(cache_file, 'w:gz') as tar:
tar.add(work_dir, arcname=cache_stem)
return cache_file
def install(opts):
"""
support installation python projects
With provided installation options (``RelengInstallOptions``), the
installation stage will be processed.
Args:
opts: installation options
Returns:
``True`` if the installation stage is completed; ``False`` otherwise
"""
if opts._python_interpreter:
python_tool = PythonTool(opts._python_interpreter,
env_include=PYTHON_EXTEND_ENV)
else:
python_tool = PYTHON
if not python_tool.exists():
err('unable to install package; python is not installed')
return False
# definitions
python_defs = {
'--prefix': opts.prefix,
}
if opts.install_defs:
python_defs.update(expand(opts.install_defs))
# always remove the prefix value if:
# - *nix: setup.py may ignore provided `--root` value with an "/" prefix
# - win32: does not use the prefix value
if python_defs['--prefix'] == '/' or sys.platform == 'win32':
del python_defs['--prefix']
# default options
python_opts = {}
if opts.install_opts:
python_opts.update(expand(opts.install_opts))
# argument building
python_args = [
'setup.py',
# ignore user's pydistutils.cfg
'--no-user-cfg',
# invoke the install operation
'install',
# avoid building pyc files
'--no-compile',
]
python_args.extend(prepare_definitions(python_defs))
python_args.extend(prepare_arguments(python_opts))
# install to target destination(s)
#
# If the package already defines a root path, use it over any other
# configured destination directories.
env = expand(opts.install_env)
if '--root' in python_opts:
if not python_tool.execute(python_args, env=env):
err('failed to install python project: {}', opts.name)
return False
else:
# install to each destination
for dest_dir in opts.dest_dirs:
if not python_tool.execute(python_args + ['--root', dest_dir],
env=env):
err('failed to install python project: {}', opts.name)
return False
return True