def load_graph(self, reference, create_reference, graph_info, build_mode, check_updates, update,
remotes, recorder, apply_build_requires=True, lockfile_node_id=None):
""" main entry point to compute a full dependency graph
"""
profile_host, profile_build = graph_info.profile_host, graph_info.profile_build
graph_lock, root_ref = graph_info.graph_lock, graph_info.root
root_node = self._load_root_node(reference, create_reference, profile_host, graph_lock,
root_ref, lockfile_node_id)
deps_graph = self._resolve_graph(root_node, profile_host, profile_build, graph_lock,
build_mode, check_updates, update, remotes, recorder,
apply_build_requires=apply_build_requires)
# Run some validations once the graph is built
self._validate_graph_provides(deps_graph)
# THIS IS NECESSARY to store dependencies options in profile, for consumer
# FIXME: This is a hack. Might dissapear if graph for local commands is always recomputed
graph_info.options = root_node.conanfile.options.values
if root_node.ref:
graph_info.root = root_node.ref
if graph_info.graph_lock is None:
graph_info.graph_lock = GraphLock(deps_graph, self._cache.config.revisions_enabled)
return deps_graph
def _resolve_graph(self, root_node, graph_info, build_mode, check_updates,
update, remotes, recorder, apply_build_requires=True):
build_mode = BuildMode(build_mode, self._output)
profile_host = graph_info.profile_host
graph_lock = graph_info.graph_lock
deps_graph = self._load_graph(root_node, check_updates, update,
build_mode=build_mode, remotes=remotes,
recorder=recorder,
profile_host=profile_host,
profile_build=graph_info.profile_build,
apply_build_requires=apply_build_requires,
graph_lock=graph_lock)
# THIS IS NECESSARY to store dependencies options in profile, for consumer
# FIXME: This is a hack. Might dissapear if graph for local commands is always recomputed
graph_info.options = root_node.conanfile.options.values
if root_node.ref:
graph_info.root = root_node.ref
if graph_info.graph_lock is None:
graph_info.graph_lock = GraphLock(deps_graph, self._cache.config.revisions_enabled)
version_ranges_output = self._resolver.output
if version_ranges_output:
self._output.success("Version ranges solved")
for msg in version_ranges_output:
self._output.info(" %s" % msg)
self._output.writeln("")
self._resolver.clear_output()
build_mode.report_matches()
return deps_graph
def load_graph(self,
reference,
create_reference,
graph_info,
build_mode,
check_updates,
update,
remotes,
recorder,
apply_build_requires=True):
def _inject_require(conanfile, ref):
""" test_package functionality requires injecting the tested package as requirement
before running the install
"""
require = conanfile.requires.get(ref.name)
if require:
require.ref = require.range_ref = ref
else:
conanfile.requires.add_ref(ref)
conanfile._conan_user = ref.user
conanfile._conan_channel = ref.channel
# Computing the full dependency graph
profile = graph_info.profile
processed_profile = profile
processed_profile.dev_reference = create_reference
ref = None
graph_lock = graph_info.graph_lock
if isinstance(reference,
list): # Install workspace with multiple root nodes
conanfile = self._loader.load_virtual(reference,
processed_profile,
scope_options=False)
root_node = Node(ref, conanfile, recipe=RECIPE_VIRTUAL)
elif isinstance(reference, ConanFileReference):
if not self._cache.config.revisions_enabled and reference.revision is not None:
raise ConanException(
"Revisions not enabled in the client, specify a "
"reference without revision")
# create without test_package and install <ref>
conanfile = self._loader.load_virtual([reference],
processed_profile)
root_node = Node(ref, conanfile, recipe=RECIPE_VIRTUAL)
if graph_lock: # Find the Node ID in the lock of current root
graph_lock.find_consumer_node(root_node, reference)
else:
path = reference
if path.endswith(".py"):
test = str(create_reference) if create_reference else None
lock_python_requires = None
# do not try apply lock_python_requires for test_package/conanfile.py consumer
if graph_lock and not create_reference:
if graph_info.root.name is None:
# If the graph_info information is not there, better get what we can from
# the conanfile
conanfile = self._loader.load_class(path)
graph_info.root = ConanFileReference(
graph_info.root.name or conanfile.name,
graph_info.root.version or conanfile.version,
graph_info.root.user,
graph_info.root.channel,
validate=False)
node_id = graph_lock.get_node(graph_info.root)
lock_python_requires = graph_lock.python_requires(node_id)
conanfile = self._loader.load_consumer(
path,
processed_profile,
test=test,
name=graph_info.root.name,
version=graph_info.root.version,
user=graph_info.root.user,
channel=graph_info.root.channel,
lock_python_requires=lock_python_requires)
if create_reference: # create with test_package
_inject_require(conanfile, create_reference)
ref = ConanFileReference(conanfile.name,
conanfile.version,
conanfile._conan_user,
conanfile._conan_channel,
validate=False)
else:
conanfile = self._loader.load_conanfile_txt(
path, processed_profile, ref=graph_info.root)
root_node = Node(ref, conanfile, recipe=RECIPE_CONSUMER)
if graph_lock: # Find the Node ID in the lock of current root
graph_lock.find_consumer_node(root_node, create_reference)
build_mode = BuildMode(build_mode, self._output)
deps_graph = self._load_graph(
root_node,
check_updates,
update,
build_mode=build_mode,
remotes=remotes,
profile_build_requires=profile.build_requires,
recorder=recorder,
processed_profile=processed_profile,
apply_build_requires=apply_build_requires,
graph_lock=graph_lock)
# THIS IS NECESSARY to store dependencies options in profile, for consumer
# FIXME: This is a hack. Might dissapear if graph for local commands is always recomputed
graph_info.options = root_node.conanfile.options.values
if ref:
graph_info.root = ref
if graph_info.graph_lock is None:
graph_info.graph_lock = GraphLock(deps_graph)
else:
graph_info.graph_lock.update_check_graph(deps_graph, self._output)
version_ranges_output = self._resolver.output
if version_ranges_output:
self._output.success("Version ranges solved")
for msg in version_ranges_output:
self._output.info(" %s" % msg)
self._output.writeln("")
build_mode.report_matches()
return deps_graph, conanfile