def info_nodes_to_build(self, reference, profile, filename, build_modes, remote, check_updates, cwd):
remote_proxy = ConanProxy(self._client_cache, self._user_io, self._remote_manager, remote,
update=False, check_updates=check_updates)
deps_graph, _, conanfile = self._get_deps_graph(reference, profile, filename, cwd, remote_proxy)
build_mode = BuildMode(build_modes, self._user_io.out)
installer = ConanInstaller(self._client_cache, self._user_io.out, remote_proxy, build_mode,
None)
nodes = installer.nodes_to_build(deps_graph)
counter = Counter(ref.conan.name for ref, _ in nodes)
ret = [ref if counter[ref.conan.name] > 1 else str(ref.conan) for ref, _ in nodes]
return ret, self._get_project_reference(reference, conanfile)
def install(self,
reference,
current_path,
profile,
remote=None,
build_modes=None,
filename=None,
update=False,
manifest_folder=None,
manifest_verify=False,
manifest_interactive=False,
generators=None,
no_imports=False,
inject_require=None):
""" Fetch and build all dependencies for the given reference
@param reference: ConanFileReference or path to user space conanfile
@param current_path: where the output files will be saved
@param remote: install only from that remote
@param profile: Profile object with both the -s introduced options and profile readed values
@param build_modes: List of build_modes specified
@param filename: Optional filename of the conanfile
@param update: Check for updated in the upstream remotes (and update)
@param manifest_folder: Folder to install the manifests
@param manifest_verify: Verify dependencies manifests against stored ones
@param manifest_interactive: Install deps manifests in folder for later verify, asking user for confirmation
@param generators: List of generators from command line
@param no_imports: Install specified packages but avoid running imports
"""
generators = generators or []
manifest_manager = ManifestManager(
manifest_folder,
user_io=self._user_io,
client_cache=self._client_cache,
verify=manifest_verify,
interactive=manifest_interactive) if manifest_folder else None
remote_proxy = ConanProxy(self._client_cache,
self._user_io,
self._remote_manager,
remote,
update=update,
check_updates=False,
manifest_manager=manifest_manager)
loader = ConanFileLoader(self._runner, self._client_cache.settings,
self._profile_with_defaults(profile))
conanfile = self._get_conanfile_object(loader, reference, filename,
current_path)
if inject_require:
self._inject_require(conanfile, inject_require)
graph_builder = self._get_graph_builder(loader, update, remote_proxy)
deps_graph = graph_builder.load(conanfile)
# This line is so the conaninfo stores the correct complete info
conanfile.info.scope = profile.scopes
registry = RemoteRegistry(self._client_cache.registry,
self._user_io.out)
if inject_require:
output = ScopedOutput("%s test package" % str(inject_require),
self._user_io.out)
output.info("Installing dependencies")
elif not isinstance(reference, ConanFileReference):
output = ScopedOutput("PROJECT", self._user_io.out)
Printer(self._user_io.out).print_graph(deps_graph, registry)
else:
output = ScopedOutput(str(reference), self._user_io.out)
output.highlight("Installing package")
try:
if loader._settings.os and detected_os() != loader._settings.os:
message = "Cross-platform from '%s' to '%s'" % (
detected_os(), loader._settings.os)
self._user_io.out.writeln(message, Color.BRIGHT_MAGENTA)
except ConanException: # Setting os doesn't exist
pass
build_mode = BuildMode(build_modes, self._user_io.out)
build_requires = BuildRequires(loader, graph_builder, registry, output,
profile.build_requires)
installer = ConanInstaller(self._client_cache, output, remote_proxy,
build_mode, build_requires)
# Apply build_requires to consumer conanfile
if not isinstance(reference, ConanFileReference):
build_requires.install("", conanfile, installer)
installer.install(deps_graph, current_path)
build_mode.report_matches()
# Write generators
tmp = list(
conanfile.generators) # Add the command line specified generators
tmp.extend([g for g in generators if g not in tmp])
conanfile.generators = tmp
write_generators(conanfile, current_path, output)
if not isinstance(reference, ConanFileReference):
content = normalize(conanfile.info.dumps())
save(os.path.join(current_path, CONANINFO), content)
output.info("Generated %s" % CONANINFO)
if not no_imports:
run_imports(conanfile, current_path, output)
installer.call_system_requirements(conanfile, output)
if manifest_manager:
manifest_manager.print_log()
def info(self,
reference,
current_path,
profile,
remote=None,
info=None,
filename=None,
check_updates=False,
build_order=None,
build_modes=None,
graph_filename=None,
package_filter=None,
show_paths=False):
""" Fetch and build all dependencies for the given reference
@param reference: ConanFileReference or path to user space conanfile
@param current_path: where the output files will be saved
@param remote: install only from that remote
@param profile: Profile object with both the -s introduced options and profile readed values
@param build_modes: List of build_modes specified
@param filename: Optional filename of the conanfile
"""
remote_proxy = ConanProxy(self._client_cache,
self._user_io,
self._remote_manager,
remote,
update=False,
check_updates=check_updates)
loader = ConanFileLoader(self._runner, self._client_cache.settings,
profile)
conanfile = self._get_conanfile_object(loader, reference, filename,
current_path)
graph_builder = self._get_graph_builder(loader, False, remote_proxy)
deps_graph = graph_builder.load(conanfile)
if build_order:
result = deps_graph.build_order(build_order)
self._user_io.out.info(", ".join(str(s) for s in result))
return
if build_modes is not None:
installer = ConanInstaller(self._client_cache, self._user_io.out,
remote_proxy, None)
build_mode = BuildMode(build_modes, self._user_io.out)
nodes = installer.nodes_to_build(deps_graph, build_mode)
counter = Counter(ref.conan.name for ref, _ in nodes)
self._user_io.out.info(", ".join(
(str(ref) if counter[ref.conan.name] > 1 else str(ref.conan))
for ref, _ in nodes))
return
if check_updates:
graph_updates_info = graph_builder.get_graph_updates_info(
deps_graph)
else:
graph_updates_info = {}
def read_dates(deps_graph):
ret = {}
for ref, _ in sorted(deps_graph.nodes):
if ref:
manifest = self._client_cache.load_manifest(ref)
ret[ref] = manifest.time_str
return ret
# Get project reference
project_reference = None
if isinstance(reference, ConanFileReference):
project_reference = None
else:
project_reference = str(conanfile)
# Print results
if graph_filename:
if graph_filename.endswith(".html"):
grapher = ConanHTMLGrapher(project_reference, deps_graph)
else:
grapher = ConanGrapher(project_reference, deps_graph)
grapher.graph_file(graph_filename)
else:
registry = RemoteRegistry(self._client_cache.registry,
self._user_io.out)
Printer(self._user_io.out).print_info(deps_graph,
project_reference, info,
registry,
graph_updates_info, remote,
read_dates(deps_graph),
self._client_cache,
package_filter, show_paths)
def install(self, reference, current_path, profile, remote=None,
build_modes=None, filename=None, update=False,
manifest_folder=None, manifest_verify=False, manifest_interactive=False,
generators=None, no_imports=False):
""" Fetch and build all dependencies for the given reference
@param reference: ConanFileReference or path to user space conanfile
@param current_path: where the output files will be saved
@param remote: install only from that remote
@param profile: Profile object with both the -s introduced options and profile readed values
@param build_modes: List of build_modes specified
@param filename: Optional filename of the conanfile
@param update: Check for updated in the upstream remotes (and update)
@param manifest_folder: Folder to install the manifests
@param manifest_verify: Verify dependencies manifests against stored ones
@param manifest_interactive: Install deps manifests in folder for later verify, asking user for confirmation
@param generators: List of generators from command line
@param no_imports: Install specified packages but avoid running imports
"""
generators = generators or []
manifest_manager = ManifestManager(manifest_folder, user_io=self._user_io,
client_cache=self._client_cache,
verify=manifest_verify,
interactive=manifest_interactive) if manifest_folder else None
remote_proxy = ConanProxy(self._client_cache, self._user_io, self._remote_manager, remote,
update=update, check_updates=False, manifest_manager=manifest_manager)
loader = ConanFileLoader(self._runner, self._client_cache.settings, profile)
conanfile = self._get_conanfile_object(loader, reference, filename, current_path)
graph_builder = self._get_graph_builder(loader, update, remote_proxy)
deps_graph = graph_builder.load(conanfile)
# This line is so the conaninfo stores the correct complete info
conanfile.info.scope = profile.scopes
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
Printer(self._user_io.out).print_graph(deps_graph, registry)
try:
if detected_os() != loader._settings.os:
message = "Cross-platform from '%s' to '%s'" % (detected_os(), loader._settings.os)
self._user_io.out.writeln(message, Color.BRIGHT_MAGENTA)
except ConanException: # Setting os doesn't exist
pass
build_mode = BuildMode(build_modes, self._user_io.out)
build_requires = BuildRequires(loader, remote_proxy, self._user_io.out, self._client_cache,
self._search_manager, profile.build_requires, current_path,
build_mode)
# Apply build_requires to consumer conanfile
build_requires.install("", conanfile)
installer = ConanInstaller(self._client_cache, self._user_io.out, remote_proxy,
build_requires)
installer.install(deps_graph, build_mode, current_path)
build_mode.report_matches()
prefix = "PROJECT" if not isinstance(reference, ConanFileReference) else str(reference)
output = ScopedOutput(prefix, self._user_io.out)
# Write generators
tmp = list(conanfile.generators) # Add the command line specified generators
tmp.extend(generators)
conanfile.generators = tmp
write_generators(conanfile, current_path, output)
if not isinstance(reference, ConanFileReference):
content = normalize(conanfile.info.dumps())
save(os.path.join(current_path, CONANINFO), content)
output.info("Generated %s" % CONANINFO)
if not no_imports:
run_imports(conanfile, current_path, output)
installer.call_system_requirements(conanfile, output)
if manifest_manager:
manifest_manager.print_log()