def build_package(self, node, keep_build, recorder, remotes):
t1 = time.time()
conanfile = node.conanfile
pref = node.pref
package_layout = self._cache.package_layout(pref.ref,
conanfile.short_paths)
source_folder = package_layout.source()
conanfile_path = package_layout.conanfile()
package_folder = package_layout.package(pref)
build_folder, skip_build = self._get_build_folder(
conanfile, package_layout, pref, keep_build, recorder)
# PREPARE SOURCES
if not skip_build:
with package_layout.conanfile_write_lock(self._output):
set_dirty(build_folder)
self._prepare_sources(conanfile, pref, package_layout,
conanfile_path, source_folder,
build_folder, remotes)
# BUILD & PACKAGE
with package_layout.conanfile_read_lock(self._output):
_remove_folder_raising(package_folder)
mkdir(build_folder)
with tools.chdir(build_folder):
self._output.info('Building your package in %s' % build_folder)
try:
if getattr(conanfile, 'no_copy_source', False):
conanfile.source_folder = source_folder
else:
conanfile.source_folder = build_folder
if not skip_build:
with get_env_context_manager(conanfile):
conanfile.build_folder = build_folder
conanfile.package_folder = package_folder
# In local cache, install folder always is build_folder
conanfile.install_folder = build_folder
self._build(conanfile, pref, build_folder)
clean_dirty(build_folder)
prev = self._package(conanfile, pref, package_layout,
conanfile_path, build_folder,
package_folder)
assert prev
node.prev = prev
log_file = os.path.join(build_folder, RUN_LOG_NAME)
log_file = log_file if os.path.exists(log_file) else None
log_package_built(pref, time.time() - t1, log_file)
recorder.package_built(pref)
except ConanException as exc:
recorder.package_install_error(pref,
INSTALL_ERROR_BUILDING,
str(exc),
remote_name=None)
raise exc
return node.pref
def build_package(self, node, keep_build, recorder, remotes):
t1 = time.time()
conanfile = node.conanfile
pref = node.pref
package_layout = self._cache.package_layout(pref.ref,
conanfile.short_paths)
base_source = package_layout.source()
conanfile_path = package_layout.conanfile()
base_package = package_layout.package(pref)
base_build, skip_build = self._get_build_folder(
conanfile, package_layout, pref, keep_build, recorder)
# PREPARE SOURCES
if not skip_build:
with package_layout.conanfile_write_lock(self._output):
set_dirty(base_build)
self._prepare_sources(conanfile, pref, package_layout, remotes)
self._copy_sources(conanfile, base_source, base_build)
# BUILD & PACKAGE
with package_layout.conanfile_read_lock(self._output):
self._output.info('Building your package in %s' % base_build)
try:
if getattr(conanfile, 'no_copy_source', False):
conanfile.folders.set_base_source(base_source)
else:
conanfile.folders.set_base_source(base_build)
conanfile.folders.set_base_build(base_build)
conanfile.folders.set_base_imports(base_build)
conanfile.folders.set_base_package(base_package)
if not skip_build:
# In local cache, generators folder always in build_folder
conanfile.folders.set_base_generators(base_build)
# In local cache, install folder always is build_folder
conanfile.folders.set_base_install(base_build)
self._build(conanfile, pref)
clean_dirty(base_build)
prev = self._package(conanfile, pref, package_layout,
conanfile_path)
assert prev
node.prev = prev
log_file = os.path.join(base_build, RUN_LOG_NAME)
log_file = log_file if os.path.exists(log_file) else None
log_package_built(pref, time.time() - t1, log_file)
recorder.package_built(pref)
except ConanException as exc:
recorder.package_install_error(pref,
INSTALL_ERROR_BUILDING,
str(exc),
remote_name=None)
raise exc
return node.pref
def _log_built_package(self, build_folder, package_ref, duration):
log_file = os.path.join(build_folder, RUN_LOG_NAME)
log_file = log_file if os.path.exists(log_file) else None
log_package_built(package_ref, duration, log_file)
self._recorder.package_built(package_ref)
def _log_built_package(self, conan_file, package_ref, duration):
build_folder = self._client_cache.build(package_ref, conan_file.short_paths)
log_file = os.path.join(build_folder, RUN_LOG_NAME)
log_file = log_file if os.path.exists(log_file) else None
log_package_built(package_ref, duration, log_file)
def _build(self, nodes_by_level, skip_private_nodes, build_mode):
""" The build assumes an input of conans ordered by degree, first level
should be independent from each other, the next-second level should have
dependencies only to first level conans.
param nodes_by_level: list of lists [[nodeA, nodeB], [nodeC], [nodeD, ...], ...]
build_mode => ["*"] if user wrote "--build"
=> ["hello*", "bye*"] if user wrote "--build hello --build bye"
=> False if user wrote "never"
=> True if user wrote "missing"
=> "outdated" if user wrote "--build outdated"
"""
inverse = self._deps_graph.inverse_levels()
flat = []
for level in inverse:
level = sorted(level, key=lambda x: x.conan_ref)
flat.extend(level)
# Get the nodes in order and if we have to build them
nodes_to_process = self._get_nodes(nodes_by_level, skip_private_nodes,
build_mode)
for conan_ref, package_id, conan_file, build_needed in nodes_to_process:
if build_needed:
build_allowed = build_mode.allowed(conan_ref, conan_file)
if not build_allowed:
self._raise_package_not_found_error(conan_ref, conan_file)
output = ScopedOutput(str(conan_ref), self._out)
package_ref = PackageReference(conan_ref, package_id)
package_folder = self._client_cache.package(
package_ref, conan_file.short_paths)
if conan_file.build_policy_missing:
output.info(
"Building package from source as defined by build_policy='missing'"
)
elif build_mode.forced(conan_ref, conan_file):
output.warn('Forced build from source')
self._build_requires.install(conan_ref, conan_file)
t1 = time.time()
# Assign to node the propagated info
self._propagate_info(conan_ref, conan_file, flat)
self._remote_proxy.get_recipe_sources(conan_ref)
# Call the conanfile's build method
build_folder = self._build_conanfile(conan_ref, conan_file,
package_ref,
package_folder, output)
# Call the conanfile's package method
self._package_conanfile(conan_ref, conan_file, package_ref,
build_folder, package_folder, output)
# Call the info method
self._package_info_conanfile(conan_ref, conan_file)
duration = time.time() - t1
log_file = os.path.join(build_folder, RUN_LOG_NAME)
log_file = log_file if os.path.exists(log_file) else None
log_package_built(package_ref, duration, log_file)
else:
# Get the package, we have a not outdated remote package
if conan_ref:
self._get_package(conan_ref, conan_file)
# Assign to the node the propagated info
# (conan_ref could be None if user project, but of course assign the info
self._propagate_info(conan_ref, conan_file, flat)
# Call the info method
self._package_info_conanfile(conan_ref, conan_file)
def _build(self, nodes_by_level, skip_private_nodes, build_mode):
""" The build assumes an input of conans ordered by degree, first level
should be independent from each other, the next-second level should have
dependencies only to first level conans.
param nodes_by_level: list of lists [[nodeA, nodeB], [nodeC], [nodeD, ...], ...]
build_mode => ["*"] if user wrote "--build"
=> ["hello*", "bye*"] if user wrote "--build hello --build bye"
=> False if user wrote "never"
=> True if user wrote "missing"
=> "outdated" if user wrote "--build outdated"
"""
inverse = self._deps_graph.inverse_levels()
flat = []
for level in inverse:
level = sorted(level, key=lambda x: x.conan_ref)
flat.extend(level)
# Get the nodes in order and if we have to build them
nodes_to_process = self._get_nodes(nodes_by_level, skip_private_nodes, build_mode)
for conan_ref, package_id, conan_file, build_needed in nodes_to_process:
if build_needed:
build_allowed = build_mode.allowed(conan_ref, conan_file)
if not build_allowed:
self._raise_package_not_found_error(conan_ref, conan_file)
output = ScopedOutput(str(conan_ref), self._out)
package_ref = PackageReference(conan_ref, package_id)
package_folder = self._client_cache.package(package_ref, conan_file.short_paths)
if conan_file.build_policy_missing:
output.info("Building package from source as defined by build_policy='missing'")
elif build_mode.forced(conan_ref, conan_file):
output.warn('Forced build from source')
self._build_requires.install(conan_ref, conan_file)
t1 = time.time()
# Assign to node the propagated info
self._propagate_info(conan_ref, conan_file, flat)
self._remote_proxy.get_recipe_sources(conan_ref)
# Call the conanfile's build method
build_folder = self._build_conanfile(conan_ref, conan_file, package_ref,
package_folder, output)
# Call the conanfile's package method
self._package_conanfile(conan_ref, conan_file, package_ref, build_folder,
package_folder, output)
# Call the info method
self._package_info_conanfile(conan_ref, conan_file)
duration = time.time() - t1
log_file = os.path.join(build_folder, RUN_LOG_NAME)
log_file = log_file if os.path.exists(log_file) else None
log_package_built(package_ref, duration, log_file)
else:
# Get the package, we have a not outdated remote package
if conan_ref:
self._get_package(conan_ref, conan_file)
# Assign to the node the propagated info
# (conan_ref could be None if user project, but of course assign the info
self._propagate_info(conan_ref, conan_file, flat)
# Call the info method
self._package_info_conanfile(conan_ref, conan_file)
def _log_built_package(self, build_folder, package_ref, duration):
log_file = os.path.join(build_folder, RUN_LOG_NAME)
log_file = log_file if os.path.exists(log_file) else None
log_package_built(package_ref, duration, log_file)
self._recorder.package_built(package_ref)
