def _process_node(self, node, pref, build_mode, update, remotes):
# Check that this same reference hasn't already been checked
if self._evaluate_is_cached(node, pref):
return
conanfile = node.conanfile
if node.recipe == RECIPE_EDITABLE:
node.binary = BINARY_EDITABLE # TODO: PREV?
return
if self._evaluate_build(node, build_mode):
return
package_layout = self._cache.package_layout(
pref.ref, short_paths=conanfile.short_paths)
package_folder = package_layout.package(pref)
metadata = self._evaluate_clean_pkg_folder_dirty(
node, package_layout, package_folder, pref)
remote = remotes.selected
if not remote:
# If the remote_name is not given, follow the binary remote, or the recipe remote
# If it is defined it won't iterate (might change in conan2.0)
metadata = metadata or package_layout.load_metadata()
remote_name = metadata.packages[
pref.id].remote or metadata.recipe.remote
remote = remotes.get(remote_name)
if os.path.exists(
package_folder): # Binary already in cache, check for updates
self._evaluate_cache_pkg(node, package_layout, pref, metadata,
remote, remotes, update, package_folder)
recipe_hash = None
else: # Binary does NOT exist locally
# Returned remote might be different than the passed one if iterating remotes
recipe_hash, remote = self._evaluate_remote_pkg(
node, pref, remote, remotes)
if build_mode.outdated:
if node.binary in (BINARY_CACHE, BINARY_DOWNLOAD, BINARY_UPDATE):
if node.binary == BINARY_UPDATE:
info, pref = self._remote_manager.get_package_info(
pref, remote)
recipe_hash = info.recipe_hash
elif node.binary == BINARY_CACHE:
recipe_hash = ConanInfo.load_from_package(
package_folder).recipe_hash
local_recipe_hash = package_layout.recipe_manifest(
).summary_hash
if local_recipe_hash != recipe_hash:
conanfile.output.info("Outdated package!")
node.binary = BINARY_BUILD
node.prev = None
else:
conanfile.output.info("Package is up to date")
node.binary_remote = remote
def _evaluate_node(self, node, build_mode, update, evaluated_references,
remote_name):
assert node.binary is None
conan_ref, conanfile = node.conan_ref, node.conanfile
package_id = conanfile.info.package_id()
package_ref = PackageReference(conan_ref, package_id)
# Check that this same reference hasn't already been checked
previous_node = evaluated_references.get(package_ref)
if previous_node:
node.binary = previous_node.binary
node.binary_remote = previous_node.binary_remote
return
evaluated_references[package_ref] = node
output = ScopedOutput(str(conan_ref), self._out)
if build_mode.forced(conanfile, conan_ref):
output.warn('Forced build from source')
node.binary = BINARY_BUILD
return
package_folder = self._client_cache.package(
package_ref, short_paths=conanfile.short_paths)
# Check if dirty, to remove it
local_project = self._workspace[conan_ref] if self._workspace else None
if local_project:
node.binary = BINARY_WORKSPACE
return
with self._client_cache.package_lock(package_ref):
if is_dirty(package_folder):
output.warn("Package is corrupted, removing folder: %s" %
package_folder)
rmdir(package_folder)
if remote_name:
remote = self._registry.remote(remote_name)
else:
remote = self._registry.get_recipe_remote(conan_ref)
remotes = self._registry.remotes
if os.path.exists(package_folder):
if update:
if remote:
if self._check_update(package_folder, package_ref, remote,
output):
node.binary = BINARY_UPDATE
if build_mode.outdated:
package_hash = self._get_package_info(
package_ref, remote).recipe_hash
elif remotes:
pass
else:
output.warn("Can't update, no remote defined")
if not node.binary:
node.binary = BINARY_CACHE
package_hash = ConanInfo.load_from_package(
package_folder).recipe_hash
else: # Binary does NOT exist locally
remote_info = None
if remote:
remote_info = self._get_package_info(package_ref, remote)
elif remotes: # Iterate all remotes to get this binary
for r in remotes:
remote_info = self._get_package_info(package_ref, r)
if remote_info:
remote = r
break
if remote_info:
node.binary = BINARY_DOWNLOAD
package_hash = remote_info.recipe_hash
else:
if build_mode.allowed(conanfile, conan_ref):
node.binary = BINARY_BUILD
else:
node.binary = BINARY_MISSING
if build_mode.outdated:
if node.binary in (BINARY_CACHE, BINARY_DOWNLOAD, BINARY_UPDATE):
local_recipe_hash = self._client_cache.load_manifest(
package_ref.conan).summary_hash
if local_recipe_hash != package_hash:
output.info("Outdated package!")
node.binary = BINARY_BUILD
else:
output.info("Package is up to date")
node.binary_remote = remote
def _evaluate_node(self, node, build_mode, update, evaluated_references,
remote_name):
assert node.binary is None
conan_ref, conanfile = node.conan_ref, node.conanfile
revisions_enabled = get_env("CONAN_CLIENT_REVISIONS_ENABLED", False)
package_id = conanfile.info.package_id()
package_ref = PackageReference(conan_ref, package_id)
# Check that this same reference hasn't already been checked
previous_node = evaluated_references.get(package_ref)
if previous_node:
node.binary = previous_node.binary
node.binary_remote = previous_node.binary_remote
return
evaluated_references[package_ref] = node
output = ScopedOutput(str(conan_ref), self._out)
if build_mode.forced(conanfile, conan_ref):
output.warn('Forced build from source')
node.binary = BINARY_BUILD
return
package_folder = self._client_cache.package(
package_ref, short_paths=conanfile.short_paths)
# Check if dirty, to remove it
local_project = self._workspace[conan_ref] if self._workspace else None
if local_project:
node.binary = BINARY_WORKSPACE
return
with self._client_cache.package_lock(package_ref):
if is_dirty(package_folder):
output.warn("Package is corrupted, removing folder: %s" %
package_folder)
rmdir(package_folder)
if remote_name:
remote = self._registry.remotes.get(remote_name)
else:
# If the remote_name is not given, follow the binary remote, or
# the recipe remote
# If it is defined it won't iterate (might change in conan2.0)
remote = self._registry.prefs.get(
package_ref) or self._registry.refs.get(conan_ref)
remotes = self._registry.remotes.list
if os.path.exists(package_folder):
if update:
if remote:
if self._check_update(package_folder, package_ref, remote,
output, node):
node.binary = BINARY_UPDATE
if build_mode.outdated:
package_hash = self._get_package_info(
package_ref, remote).recipe_hash
elif remotes:
pass
else:
output.warn("Can't update, no remote defined")
if not node.binary:
node.binary = BINARY_CACHE
package_hash = ConanInfo.load_from_package(
package_folder).recipe_hash
else: # Binary does NOT exist locally
if not revisions_enabled and not node.revision_pinned:
# Do not search for packages for the specific resolved recipe revision but all
package_ref = package_ref.copy_clear_rev()
remote_info = None
if remote:
remote_info = self._get_package_info(package_ref, remote)
# If the "remote" came from the registry but the user didn't specified the -r, with
# revisions iterate all remotes
if not remote or (not remote_info and revisions_enabled
and not remote_name):
for r in remotes:
remote_info = self._get_package_info(package_ref, r)
if remote_info:
remote = r
break
if remote_info:
node.binary = BINARY_DOWNLOAD
package_hash = remote_info.recipe_hash
else:
if build_mode.allowed(conanfile, conan_ref):
node.binary = BINARY_BUILD
else:
node.binary = BINARY_MISSING
if build_mode.outdated:
if node.binary in (BINARY_CACHE, BINARY_DOWNLOAD, BINARY_UPDATE):
local_recipe_hash = self._client_cache.load_manifest(
package_ref.conan).summary_hash
if local_recipe_hash != package_hash:
output.info("Outdated package!")
node.binary = BINARY_BUILD
else:
output.info("Package is up to date")
node.binary_remote = remote
def _evaluate_node(self, node, build_mode, update, evaluated_nodes,
remotes):
assert node.binary is None, "Node.binary should be None"
assert node.package_id is not None, "Node.package_id shouldn't be None"
ref, conanfile = node.ref, node.conanfile
pref = PackageReference(ref, node.package_id)
# Check that this same reference hasn't already been checked
previous_nodes = evaluated_nodes.get(pref)
if previous_nodes:
previous_nodes.append(node)
previous_node = previous_nodes[0]
node.binary = previous_node.binary
node.binary_remote = previous_node.binary_remote
node.prev = previous_node.prev
return
evaluated_nodes[pref] = [node]
output = conanfile.output
if node.recipe == RECIPE_EDITABLE:
node.binary = BINARY_EDITABLE
# TODO: PREV?
return
with_deps_to_build = any(
[dep.dst.binary == BINARY_BUILD for dep in node.dependencies])
if build_mode.forced(conanfile, ref, with_deps_to_build):
output.info('Forced build from source')
node.binary = BINARY_BUILD
node.prev = None
return
package_folder = self._cache.package_layout(
pref.ref, short_paths=conanfile.short_paths).package(pref)
# Check if dirty, to remove it
with self._cache.package_layout(pref.ref).package_lock(pref):
assert node.recipe != RECIPE_EDITABLE, "Editable package shouldn't reach this code"
if is_dirty(package_folder):
output.warn("Package is corrupted, removing folder: %s" %
package_folder)
rmdir(package_folder) # Do not remove if it is EDITABLE
if self._cache.config.revisions_enabled:
metadata = self._cache.package_layout(pref.ref).load_metadata()
rec_rev = metadata.packages[pref.id].recipe_revision
if rec_rev and rec_rev != node.ref.revision:
output.warn(
"The package {} doesn't belong "
"to the installed recipe revision, removing folder".
format(pref))
rmdir(package_folder)
remote = remotes.selected
if not remote:
# If the remote_name is not given, follow the binary remote, or
# the recipe remote
# If it is defined it won't iterate (might change in conan2.0)
metadata = self._cache.package_layout(pref.ref).load_metadata()
remote_name = metadata.packages[
pref.id].remote or metadata.recipe.remote
remote = remotes.get(remote_name)
if os.path.exists(package_folder):
if update:
if remote:
try:
tmp = self._remote_manager.get_package_manifest(
pref, remote)
upstream_manifest, pref = tmp
except NotFoundException:
output.warn("Can't update, no package in remote")
except NoRemoteAvailable:
output.warn("Can't update, no remote defined")
else:
if self._check_update(upstream_manifest,
package_folder, output, node):
node.binary = BINARY_UPDATE
node.prev = pref.revision # With revision
if build_mode.outdated:
info, pref = self._remote_manager.get_package_info(
pref, remote)
package_hash = info.recipe_hash
elif remotes:
pass
else:
output.warn("Can't update, no remote defined")
if not node.binary:
node.binary = BINARY_CACHE
metadata = self._cache.package_layout(pref.ref).load_metadata()
node.prev = metadata.packages[pref.id].revision
assert node.prev, "PREV for %s is None: %s" % (
str(pref), metadata.dumps())
package_hash = ConanInfo.load_from_package(
package_folder).recipe_hash
else: # Binary does NOT exist locally
remote_info = None
if remote:
try:
remote_info, pref = self._remote_manager.get_package_info(
pref, remote)
except NotFoundException:
pass
except Exception:
conanfile.output.error(
"Error downloading binary package: '{}'".format(pref))
raise
# If the "remote" came from the registry but the user didn't specified the -r, with
# revisions iterate all remotes
if not remote or (not remote_info
and self._cache.config.revisions_enabled):
for r in remotes.values():
try:
remote_info, pref = self._remote_manager.get_package_info(
pref, r)
except NotFoundException:
pass
else:
if remote_info:
remote = r
break
if remote_info:
node.binary = BINARY_DOWNLOAD
node.prev = pref.revision
package_hash = remote_info.recipe_hash
else:
if build_mode.allowed(conanfile):
node.binary = BINARY_BUILD
else:
node.binary = BINARY_MISSING
node.prev = None
if build_mode.outdated:
if node.binary in (BINARY_CACHE, BINARY_DOWNLOAD, BINARY_UPDATE):
local_recipe_hash = self._cache.package_layout(
ref).recipe_manifest().summary_hash
if local_recipe_hash != package_hash:
output.info("Outdated package!")
node.binary = BINARY_BUILD
node.prev = None
else:
output.info("Package is up to date")
node.binary_remote = remote
