def _install(self, references):
self._output.info("Installing build requires: [%s]" %
", ".join(str(r) for r in references))
conanfile = self._loader.load_virtual(
references, None, scope_options=False) # No need current path
# FIXME: Forced update=True, build_mode, Where to define it?
update = False
local_search = None if update else self._search_manager
resolver = RequireResolver(self._output, local_search,
self._remote_proxy)
graph_builder = DepsGraphBuilder(self._remote_proxy, self._output,
self._loader, resolver)
deps_graph = graph_builder.load(conanfile)
registry = RemoteRegistry(self._client_cache.registry, self._output)
Printer(self._output).print_graph(deps_graph, registry)
# Make sure we recursively do not propagate the "*" pattern
build_requires = copy.copy(self)
build_requires._build_requires = self._build_requires.copy()
build_requires._build_requires.pop("*", None)
build_requires._build_requires.pop("&!", None)
installer = ConanInstaller(self._client_cache, self._output,
self._remote_proxy, build_requires)
installer.install(deps_graph, self._build_modes, self._current_path)
self._output.info("Installed build requires: [%s]" %
", ".join(str(r) for r in references))
return deps_graph
def install_workspace(self, profile, workspace, remote_name, build_modes,
update):
loader = self.get_loader(profile)
references = [
ConanFileReference(v, "root", "project", "develop")
for v in workspace.root
]
conanfile = loader.load_virtual(references)
remote_proxy = self.get_proxy(remote_name=remote_name)
graph_builder = self._get_graph_builder(loader, remote_proxy)
graph_builder._workspace = workspace
deps_graph = graph_builder.load_graph(conanfile, False, update)
output = ScopedOutput(str("Workspace"), self._user_io.out)
output.highlight("Installing...")
print_graph(deps_graph, self._user_io.out)
build_mode = BuildMode(build_modes, self._user_io.out)
build_requires = BuildRequires(loader, graph_builder, self._registry)
installer = ConanInstaller(self._client_cache,
output,
remote_proxy,
build_mode,
build_requires,
recorder=self._recorder)
installer._workspace = workspace
installer.install(deps_graph,
profile.build_requires,
keep_build=False,
update=update)
build_mode.report_matches()
workspace.generate()
def install(self, reference, current_path, remote=None, options=None, settings=None,
build_mode=False, filename=None, update=False, check_updates=False,
integrity=False, scopes=None, generators=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 options: list of tuples: [(optionname, optionvalue), (optionname, optionvalue)...]
@param settings: list of tuples: [(settingname, settingvalue), (settingname, value)...]
"""
generators = generators or []
objects = self._get_graph(reference, current_path, remote, options, settings, filename,
update, check_updates, integrity, scopes)
(_, deps_graph, _, registry, conanfile, remote_proxy, loader) = objects
Printer(self._user_io.out).print_graph(deps_graph, registry)
# Warn if os doesn't match
try:
if detected_os() != loader._settings.os:
message = '''You are building this package with settings.os='%s' on a '%s' system.
If this is your intention, you can ignore this message.
If not:
- Check the passed settings (-s)
- Check your global settings in ~/.conan/conan.conf
- Remove conaninfo.txt to avoid bad cached settings
''' % (loader._settings.os, detected_os())
self._user_io.out.warn(message)
except ConanException: # Setting os doesn't exist
pass
installer = ConanInstaller(self._paths, self._user_io, remote_proxy)
installer.install(deps_graph, build_mode)
scope_prefix = "PROJECT" if not isinstance(reference, ConanFileReference) else str(reference)
output = ScopedOutput(scope_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)
local_installer = FileImporter(deps_graph, self._paths, current_path)
conanfile.copy = local_installer
conanfile.imports()
copied_files = local_installer.execute()
import_output = ScopedOutput("%s imports()" % output.scope, output)
report_copied_files(copied_files, import_output)
def install_workspace(self, profile, workspace, remote_name, build_modes, update):
references = [ConanFileReference(v, "root", "project", "develop") for v in workspace.root]
deps_graph, _, _ = self._graph_manager.load_graph(references, None, profile, build_modes,
False, update, remote_name, self._recorder,
workspace)
output = ScopedOutput(str("Workspace"), self._user_io.out)
output.highlight("Installing...")
print_graph(deps_graph, self._user_io.out)
installer = ConanInstaller(self._client_cache, output, self._remote_manager,
self._registry, recorder=self._recorder, workspace=workspace,
hook_manager=self._hook_manager)
installer.install(deps_graph, keep_build=False)
workspace.generate()
def install(self, reference, current_path, remote=None, options=None, settings=None,
build_mode=False, info=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 options: written in JSON, e.g. {"compiler": "Visual Studio 12", ...}
"""
if not isinstance(reference, ConanFileReference):
conanfile_path = reference
reference = None
loader = self._loader(current_path, settings, options)
installer = ConanInstaller(self._paths, self._user_io, loader, self.remote_manager, remote)
if reference:
conanfile = installer.retrieve_conanfile(reference, consumer=True)
else:
try:
conan_file_path = os.path.join(conanfile_path, CONANFILE)
conanfile = loader.load_conan(conan_file_path, consumer=True)
is_txt = False
except NotFoundException: # Load requirements.txt
conan_path = os.path.join(conanfile_path, CONANFILE_TXT)
conanfile = loader.load_conan_txt(conan_path)
is_txt = True
# build deps graph and install it
builder = DepsBuilder(installer, self._user_io.out)
deps_graph = builder.load(reference, conanfile)
if info:
Printer(self._user_io.out).print_info(deps_graph, info)
return
Printer(self._user_io.out).print_graph(deps_graph)
installer.install(deps_graph, build_mode)
if not reference:
if is_txt:
conanfile.info.settings = loader._settings.values
conanfile.info.full_settings = loader._settings.values
save(os.path.join(current_path, CONANINFO), conanfile.info.dumps())
self._user_io.out.info("Generated %s" % CONANINFO)
write_generators(conanfile, current_path, self._user_io.out)
local_installer = FileImporter(deps_graph, self._paths, current_path)
conanfile.copy = local_installer
conanfile.imports()
local_installer.execute()
def install(self, reference, current_path, remote=None, options=None, settings=None,
build_mode=False, info=None, filename=None, update=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 options: list of tuples: [(optionname, optionvalue), (optionname, optionvalue)...]
@param settings: list of tuples: [(settingname, settingvalue), (settingname, value)...]
"""
reference_given = True
if not isinstance(reference, ConanFileReference):
conanfile_path = reference
reference_given = False
reference = None
loader = self._loader(current_path, settings, options)
# Not check for updates for info command, it'll be checked when dep graph is built
check_updates = not info
remote_proxy = ConanProxy(self._paths, self._user_io, self._remote_manager,
remote, update, check_updates)
if reference_given:
project_reference = None
conanfile_path = remote_proxy.get_conanfile(reference)
output = ScopedOutput(str(reference), self._user_io.out)
conanfile = loader.load_conan(conanfile_path, output, consumer=True)
else:
project_reference = "PROJECT"
output = ScopedOutput(project_reference, self._user_io.out)
try:
if filename and filename.endswith(".txt"):
raise NotFoundException("")
conan_file_path = os.path.join(conanfile_path, filename or CONANFILE)
conanfile = loader.load_conan(conan_file_path, output, consumer=True)
is_txt = False
if conanfile.name is not None and conanfile.version is not None:
project_reference = "%s/%s@" % (conanfile.name, conanfile.version)
project_reference += "PROJECT"
except NotFoundException: # Load requirements.txt
conan_path = os.path.join(conanfile_path, filename or CONANFILE_TXT)
conanfile = loader.load_conan_txt(conan_path, output)
is_txt = True
# build deps graph and install it
builder = DepsBuilder(remote_proxy, self._user_io.out, loader)
deps_graph = builder.load(reference, conanfile)
registry = RemoteRegistry(self._paths.registry, self._user_io.out)
if info:
graph_updates_info = builder.get_graph_updates_info(deps_graph)
Printer(self._user_io.out).print_info(deps_graph, project_reference,
info, registry, graph_updates_info,
remote)
return
Printer(self._user_io.out).print_graph(deps_graph, registry)
installer = ConanInstaller(self._paths, self._user_io, remote_proxy)
installer.install(deps_graph, build_mode)
if not reference_given:
if is_txt:
conanfile.info.settings = loader._settings.values
# Just in case the current package is header only, we still store the full settings
# for reference and compiler checks
conanfile.info.full_settings = loader._settings.values
content = normalize(conanfile.info.dumps())
save(os.path.join(current_path, CONANINFO), content)
output.info("Generated %s" % CONANINFO)
write_generators(conanfile, current_path, output)
local_installer = FileImporter(deps_graph, self._paths, current_path)
conanfile.copy = local_installer
conanfile.imports()
copied_files = local_installer.execute()
import_output = ScopedOutput("%s imports()" % output.scope, output)
report_copied_files(copied_files, import_output)
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()
def install(self,
reference,
install_folder,
graph_info,
remote_name=None,
build_modes=None,
update=False,
manifest_folder=None,
manifest_verify=False,
manifest_interactive=False,
generators=None,
no_imports=False,
create_reference=None,
keep_build=False):
""" Fetch and build all dependencies for the given reference
@param reference: ConanFileReference or path to user space conanfile
@param install_folder: 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 read values
@param build_modes: List of build_modes specified
@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. If False, no generator will be
written
@param no_imports: Install specified packages but avoid running imports
@param inject_require: Reference to add as a requirement to the conanfile
"""
if generators is not False:
generators = set(generators) if generators else set()
generators.add("txt") # Add txt generator by default
self._user_io.out.info("Configuration:")
self._user_io.out.writeln(graph_info.profile.dumps())
result = self._graph_manager.load_graph(reference, create_reference,
graph_info, build_modes, False,
update, remote_name,
self._recorder, None)
deps_graph, conanfile, cache_settings = result
if not isinstance(reference, ConanFileReference):
output = ScopedOutput(
("%s (test package)" %
str(create_reference)) if create_reference else "PROJECT",
self._user_io.out)
output.highlight("Installing %s" % reference)
else:
output = ScopedOutput(str(reference), self._user_io.out)
output.highlight("Installing package")
print_graph(deps_graph, self._user_io.out)
try:
if cross_building(cache_settings):
b_os, b_arch, h_os, h_arch = get_cross_building_settings(
cache_settings)
message = "Cross-build from '%s:%s' to '%s:%s'" % (
b_os, b_arch, h_os, h_arch)
self._user_io.out.writeln(message, Color.BRIGHT_MAGENTA)
except ConanException: # Setting os doesn't exist
pass
installer = ConanInstaller(self._client_cache,
output,
self._remote_manager,
recorder=self._recorder,
workspace=None,
hook_manager=self._hook_manager)
installer.install(deps_graph, keep_build)
if manifest_folder:
manifest_manager = ManifestManager(manifest_folder,
user_io=self._user_io,
client_cache=self._client_cache)
for node in deps_graph.nodes:
if not node.conan_ref:
continue
complete_recipe_sources(self._remote_manager,
self._client_cache, node.conanfile,
node.conan_ref)
manifest_manager.check_graph(deps_graph,
verify=manifest_verify,
interactive=manifest_interactive)
manifest_manager.print_log()
if install_folder:
# Write generators
if generators is not False:
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, install_folder, output)
if not isinstance(reference, ConanFileReference):
# Write conaninfo
content = normalize(conanfile.info.dumps())
save(os.path.join(install_folder, CONANINFO), content)
output.info("Generated %s" % CONANINFO)
graph_info.save(install_folder)
output.info("Generated graphinfo")
if not no_imports:
run_imports(conanfile, install_folder, output)
call_system_requirements(conanfile, output)
if not create_reference and isinstance(reference,
ConanFileReference):
# The conanfile loaded is a virtual one. The one w deploy is the first level one
neighbours = deps_graph.root.neighbors()
deploy_conanfile = neighbours[0].conanfile
if hasattr(deploy_conanfile, "deploy") and callable(
deploy_conanfile.deploy):
run_deploy(deploy_conanfile, install_folder, output)
def install(self,
reference,
current_path,
remote=None,
options=None,
settings=None,
build_mode=False,
info=None,
filename=None,
update=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 options: list of tuples: [(optionname, optionvalue), (optionname, optionvalue)...]
@param settings: list of tuples: [(settingname, settingvalue), (settingname, settingvalue)...]
"""
reference_given = True
if not isinstance(reference, ConanFileReference):
conanfile_path = reference
reference_given = False
reference = None
loader = self._loader(current_path, settings, options)
# Not check for updates for info command, it'll be checked when dep graph is built
check_updates = not info
remote_proxy = ConanProxy(self._paths, self._user_io,
self._remote_manager, remote, update,
check_updates)
if reference_given:
project_reference = None
conanfile_path = remote_proxy.get_conanfile(reference)
output = ScopedOutput(str(reference), self._user_io.out)
conanfile = loader.load_conan(conanfile_path,
output,
consumer=True)
else:
project_reference = "PROJECT"
output = ScopedOutput(project_reference, self._user_io.out)
try:
if filename and filename.endswith(".txt"):
raise NotFoundException()
conan_file_path = os.path.join(conanfile_path, filename
or CONANFILE)
conanfile = loader.load_conan(conan_file_path,
output,
consumer=True)
is_txt = False
if conanfile.name is not None and conanfile.version is not None:
project_reference = "%s/%s@" % (conanfile.name,
conanfile.version)
project_reference += "PROJECT"
except NotFoundException: # Load requirements.txt
conan_path = os.path.join(conanfile_path, filename
or CONANFILE_TXT)
conanfile = loader.load_conan_txt(conan_path, output)
is_txt = True
# build deps graph and install it
builder = DepsBuilder(remote_proxy, self._user_io.out, loader)
deps_graph = builder.load(reference, conanfile)
registry = RemoteRegistry(self._paths.registry, self._user_io.out)
if info:
graph_updates_info = builder.get_graph_updates_info(deps_graph)
Printer(self._user_io.out).print_info(deps_graph,
project_reference, info,
registry, graph_updates_info,
remote)
return
Printer(self._user_io.out).print_graph(deps_graph, registry)
installer = ConanInstaller(self._paths, self._user_io, remote_proxy)
installer.install(deps_graph, build_mode)
if not reference_given:
if is_txt:
conanfile.info.settings = loader._settings.values
# Just in case the current package is header only, we still store the full settings
# for reference and compiler checks
conanfile.info.full_settings = loader._settings.values
content = normalize(conanfile.info.dumps())
save(os.path.join(current_path, CONANINFO), content)
output.info("Generated %s" % CONANINFO)
write_generators(conanfile, current_path, output)
local_installer = FileImporter(deps_graph, self._paths,
current_path)
conanfile.copy = local_installer
conanfile.imports()
local_installer.execute()
def install(self, reference, current_path, remote=None, options=None, settings=None,
build_mode=False, filename=None, update=False, check_updates=False,
manifest_folder=None, manifest_verify=False, manifest_interactive=False,
scopes=None, generators=None, profile_name=None, package_settings=None,
env_values=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 options: list of tuples: [(optionname, optionvalue), (optionname, optionvalue)...]
@param settings: list of tuples: [(settingname, settingvalue), (settingname, value)...]
@param package_settings: dict name=> settings: {"zlib": [(settingname, settingvalue), ...]}
@param profile: name of the profile to use
@param env: list of tuples for environment vars: [(var, value), (var2, value2)...]
@param package_env: package dict of list of tuples: {"package_name": [(var, value), (var2, value2)...]}
"""
generators = generators or []
if manifest_folder:
manifest_manager = ManifestManager(manifest_folder, user_io=self._user_io,
client_cache=self._client_cache,
verify=manifest_verify,
interactive=manifest_interactive)
else:
manifest_manager = None
profile = self.read_profile(profile_name, current_path)
# Mix Settings, Env vars and scopes between profile and command line
settings, package_settings, scopes, env_values = _mix_with_profile(profile, settings, package_settings,
scopes, env_values)
objects = self._get_graph(reference, current_path, remote, options, settings, filename,
update, check_updates, manifest_manager, scopes, package_settings,
env_values)
(_, deps_graph, _, registry, conanfile, remote_proxy, loader) = objects
Printer(self._user_io.out).print_graph(deps_graph, registry)
# Warn if os doesn't match
try:
if detected_os() != loader._settings.os:
message = '''You are building this package with settings.os='%s' on a '%s' system.
If this is your intention, you can ignore this message.
If not:
- Check the passed settings (-s)
- Check your global settings in ~/.conan/conan.conf
- Remove conaninfo.txt to avoid bad cached settings
''' % (loader._settings.os, detected_os())
self._user_io.out.warn(message)
except ConanException: # Setting os doesn't exist
pass
installer = ConanInstaller(self._client_cache, self._user_io, remote_proxy)
installer.install(deps_graph, build_mode)
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()
def install(self, reference, install_folder, profile, remote_name=None, build_modes=None,
update=False, manifest_folder=None, manifest_verify=False,
manifest_interactive=False, generators=None, no_imports=False, inject_require=None,
install_reference=False, keep_build=False):
""" Fetch and build all dependencies for the given reference
@param reference: ConanFileReference or path to user space conanfile
@param install_folder: 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 read values
@param build_modes: List of build_modes specified
@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. If False, no generator will be
written
@param no_imports: Install specified packages but avoid running imports
@param inject_require: Reference to add as a requirement to the conanfile
"""
if generators is not False:
generators = set(generators) if generators else set()
generators.add("txt") # Add txt generator by default
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 = self.get_proxy(remote_name=remote_name, manifest_manager=manifest_manager)
loader = self.get_loader(profile)
if not install_reference:
if isinstance(reference, ConanFileReference): # is a create
loader.dev_reference = reference
elif inject_require:
loader.dev_reference = inject_require
conanfile = self._load_install_conanfile(loader, reference)
if inject_require:
self._inject_require(conanfile, inject_require)
graph_builder = self._get_graph_builder(loader, remote_proxy)
deps_graph = graph_builder.load_graph(conanfile, False, update)
if not isinstance(reference, ConanFileReference):
output = ScopedOutput(("%s (test package)" % str(inject_require)) if inject_require else "PROJECT",
self._user_io.out)
output.highlight("Installing %s" % reference)
else:
output = ScopedOutput(str(reference), self._user_io.out)
output.highlight("Installing package")
Printer(self._user_io.out).print_graph(deps_graph, self._registry)
try:
if cross_building(loader._settings):
b_os, b_arch, h_os, h_arch = get_cross_building_settings(loader._settings)
message = "Cross-build from '%s:%s' to '%s:%s'" % (b_os, b_arch, h_os, h_arch)
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, self._registry)
installer = ConanInstaller(self._client_cache, output, remote_proxy, build_mode,
build_requires, recorder=self._recorder)
# Apply build_requires to consumer conanfile
if not isinstance(reference, ConanFileReference):
build_requires.install("", conanfile, installer, profile.build_requires, output, update)
installer.install(deps_graph, profile.build_requires, keep_build, update=update)
build_mode.report_matches()
if install_folder:
# Write generators
if generators is not False:
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, install_folder, output)
if not isinstance(reference, ConanFileReference):
# Write conaninfo
content = normalize(conanfile.info.dumps())
save(os.path.join(install_folder, CONANINFO), content)
output.info("Generated %s" % CONANINFO)
if not no_imports:
run_imports(conanfile, install_folder, output)
call_system_requirements(conanfile, output)
if install_reference:
# The conanfile loaded is really a virtual one. The one with the deploy is the first level one
deploy_conanfile = deps_graph.inverse_levels()[1][0].conanfile
if hasattr(deploy_conanfile, "deploy") and callable(deploy_conanfile.deploy):
run_deploy(deploy_conanfile, install_folder, output)
if manifest_manager:
manifest_manager.print_log()
def install(self,
reference,
current_path,
remote=None,
options=None,
settings=None,
build_mode=False,
info=None,
filename=None,
update=False,
check_updates=False,
integrity=False,
scopes=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 options: list of tuples: [(optionname, optionvalue), (optionname, optionvalue)...]
@param settings: list of tuples: [(settingname, settingvalue), (settingname, value)...]
"""
reference_given = True
if not isinstance(reference, ConanFileReference):
conanfile_path = reference
reference_given = False
reference = None
loader = self._loader(current_path, settings, options, scopes)
# Not check for updates for info command, it'll be checked when dep graph is built
remote_proxy = ConanProxy(self._paths,
self._user_io,
self._remote_manager,
remote,
update=update,
check_updates=check_updates,
check_integrity=integrity)
if reference_given:
project_reference = None
conanfile_path = remote_proxy.get_conanfile(reference)
output = ScopedOutput(str(reference), self._user_io.out)
conanfile = loader.load_conan(conanfile_path,
output,
consumer=True)
else:
project_reference = "PROJECT"
output = ScopedOutput(project_reference, self._user_io.out)
try:
if filename and filename.endswith(".txt"):
raise NotFoundException("")
conan_file_path = os.path.join(conanfile_path, filename
or CONANFILE)
conanfile = loader.load_conan(conan_file_path,
output,
consumer=True)
is_txt = False
if conanfile.name is not None and conanfile.version is not None:
project_reference = "%s/%s@" % (conanfile.name,
conanfile.version)
project_reference += "PROJECT"
except NotFoundException: # Load requirements.txt
conan_path = os.path.join(conanfile_path, filename
or CONANFILE_TXT)
conanfile = loader.load_conan_txt(conan_path, output)
is_txt = True
# build deps graph and install it
builder = DepsBuilder(remote_proxy, self._user_io.out, loader)
deps_graph = builder.load(reference, conanfile)
registry = RemoteRegistry(self._paths.registry, self._user_io.out)
if info:
if check_updates:
graph_updates_info = builder.get_graph_updates_info(deps_graph)
else:
graph_updates_info = {}
Printer(self._user_io.out).print_info(deps_graph,
project_reference, info,
registry, graph_updates_info,
remote)
return
Printer(self._user_io.out).print_graph(deps_graph, registry)
# Warn if os doesn't match
try:
if detected_os() != conanfile.settings.os:
message = '''You are building this package with settings.os='%s' on a '%s' system.
If this is your intention, you can ignore this message.
If not:
- Check the passed settings (-s)
- Check your global settings in ~/.conan/conan.conf
- Remove conaninfo.txt to avoid bad cached settings
''' % (conanfile.settings.os, detected_os())
self._user_io.out.warn(message)
except ConanException: # Setting os doesn't exist
pass
installer = ConanInstaller(self._paths, self._user_io, remote_proxy)
installer.install(deps_graph, build_mode)
if not reference_given:
if is_txt:
conanfile.info.settings = loader._settings.values
# Just in case the current package is header only, we still store the full settings
# for reference and compiler checks
conanfile.info.full_settings = loader._settings.values
conanfile.info.scope = self._current_scopes
content = normalize(conanfile.info.dumps())
save(os.path.join(current_path, CONANINFO), content)
output.info("Generated %s" % CONANINFO)
write_generators(conanfile, current_path, output)
local_installer = FileImporter(deps_graph, self._paths,
current_path)
conanfile.copy = local_installer
conanfile.imports()
copied_files = local_installer.execute()
import_output = ScopedOutput("%s imports()" % output.scope, output)
report_copied_files(copied_files, import_output)
def install(self,
reference,
current_path,
profile,
remote=None,
build_mode=None,
filename=None,
update=False,
check_updates=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 options: list of tuples: [(optionname, optionvalue), (optionname, optionvalue)...]
@param settings: list of tuples: [(settingname, settingvalue), (settingname, value)...]
@param package_settings: dict name=> settings: {"zlib": [(settingname, settingvalue), ...]}
@param profile: name of the profile to use
@param env: list of tuples for environment vars: [(var, value), (var2, value2)...]
@param package_env: package dict of list of tuples: {"package_name": [(var, value), (var2, value2)...]}
"""
generators = generators or []
if manifest_folder:
manifest_manager = ManifestManager(
manifest_folder,
user_io=self._user_io,
client_cache=self._client_cache,
verify=manifest_verify,
interactive=manifest_interactive)
else:
manifest_manager = None
objects = self._get_graph(reference, current_path, profile, remote,
filename, update, check_updates,
manifest_manager)
(_, deps_graph, _, registry, conanfile, remote_proxy, loader) = objects
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
installer = ConanInstaller(self._client_cache, self._user_io,
remote_proxy)
installer.install(deps_graph, build_mode)
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()
def install(self, reference, current_path, remote=None, options=None, settings=None,
build_mode=False, filename=None, update=False, check_updates=False,
manifest_folder=None, manifest_verify=False, manifest_interactive=False,
scopes=None, generators=None, profile_name=None, package_settings=None,
env=None, package_env=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 options: list of tuples: [(optionname, optionvalue), (optionname, optionvalue)...]
@param settings: list of tuples: [(settingname, settingvalue), (settingname, value)...]
@param package_settings: dict name=> settings: {"zlib": [(settingname, settingvalue), ...]}
@param profile: name of the profile to use
@param env: list of tuples for environment vars: [(var, value), (var2, value2)...]
@param package_env: package dict of list of tuples: {"package_name": [(var, value), (var2, value2)...]}
"""
generators = generators or []
if manifest_folder:
manifest_manager = ManifestManager(manifest_folder, user_io=self._user_io,
client_cache=self._client_cache,
verify=manifest_verify,
interactive=manifest_interactive)
else:
manifest_manager = None
profile = self.read_profile(profile_name, current_path)
# Mix Settings, Env vars and scopes between profile and command line
if profile:
profile.update_settings(settings)
profile.update_package_settings(package_settings)
settings = profile.settings
package_settings = profile.package_settings
profile.update_env(env)
profile.update_packages_env(package_env)
env = profile.env
package_env = profile.package_env
profile.update_scopes(scopes)
scopes = profile.scopes
objects = self._get_graph(reference, current_path, remote, options, settings, filename,
update, check_updates, manifest_manager, scopes, package_settings,
env, package_env)
(_, deps_graph, _, registry, conanfile, remote_proxy, loader) = objects
Printer(self._user_io.out).print_graph(deps_graph, registry)
# Warn if os doesn't match
try:
if detected_os() != loader._settings.os:
message = '''You are building this package with settings.os='%s' on a '%s' system.
If this is your intention, you can ignore this message.
If not:
- Check the passed settings (-s)
- Check your global settings in ~/.conan/conan.conf
- Remove conaninfo.txt to avoid bad cached settings
''' % (loader._settings.os, detected_os())
self._user_io.out.warn(message)
except ConanException: # Setting os doesn't exist
pass
installer = ConanInstaller(self._client_cache, self._user_io, remote_proxy)
installer.install(deps_graph, build_mode)
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)
if manifest_manager:
manifest_manager.print_log()
def install(self, reference, install_folder, profile, remote_name=None, build_modes=None,
update=False, manifest_folder=None, manifest_verify=False,
manifest_interactive=False, generators=None, no_imports=False, inject_require=None,
install_reference=False, keep_build=False):
""" Fetch and build all dependencies for the given reference
@param reference: ConanFileReference or path to user space conanfile
@param install_folder: 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 read values
@param build_modes: List of build_modes specified
@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. If False, no generator will be
written
@param no_imports: Install specified packages but avoid running imports
@param inject_require: Reference to add as a requirement to the conanfile
"""
if generators is not False:
generators = set(generators) if generators else set()
generators.add("txt") # Add txt generator by default
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 = self.get_proxy(remote_name=remote_name, manifest_manager=manifest_manager)
loader = self.get_loader(profile)
if not install_reference:
if isinstance(reference, ConanFileReference): # is a create
loader.dev_reference = reference
elif inject_require:
loader.dev_reference = inject_require
conanfile = self._load_install_conanfile(loader, reference)
if inject_require:
self._inject_require(conanfile, inject_require)
graph_builder = self._get_graph_builder(loader, remote_proxy)
deps_graph = graph_builder.load_graph(conanfile, False, update)
if not isinstance(reference, ConanFileReference):
output = ScopedOutput(("%s (test package)" % str(inject_require)) if inject_require else "PROJECT",
self._user_io.out)
output.highlight("Installing %s" % reference)
else:
output = ScopedOutput(str(reference), self._user_io.out)
output.highlight("Installing package")
Printer(self._user_io.out).print_graph(deps_graph, self._registry)
try:
if cross_building(loader._settings):
b_os, b_arch, h_os, h_arch = get_cross_building_settings(loader._settings)
message = "Cross-build from '%s:%s' to '%s:%s'" % (b_os, b_arch, h_os, h_arch)
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, self._registry)
installer = ConanInstaller(self._client_cache, output, remote_proxy, build_mode,
build_requires, recorder=self._recorder)
# Apply build_requires to consumer conanfile
if not isinstance(reference, ConanFileReference):
build_requires.install("", conanfile, installer, profile.build_requires, output, update)
installer.install(deps_graph, profile.build_requires, keep_build, update=update)
build_mode.report_matches()
if install_folder:
# Write generators
if generators is not False:
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, install_folder, output)
if not isinstance(reference, ConanFileReference):
# Write conaninfo
content = normalize(conanfile.info.dumps())
save(os.path.join(install_folder, CONANINFO), content)
output.info("Generated %s" % CONANINFO)
if not no_imports:
run_imports(conanfile, install_folder, output)
call_system_requirements(conanfile, output)
if install_reference:
# The conanfile loaded is really a virtual one. The one with the deploy is the first level one
deploy_conanfile = deps_graph.inverse_levels()[1][0].conanfile
if hasattr(deploy_conanfile, "deploy") and callable(deploy_conanfile.deploy):
run_deploy(deploy_conanfile, install_folder, output)
if manifest_manager:
manifest_manager.print_log()
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 install(self, reference, current_path, remote=None, options=None, settings=None,
build_mode=False, info=None, filename=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 options: written in JSON, e.g. {"compiler": "Visual Studio 12", ...}
"""
reference_given = True
if not isinstance(reference, ConanFileReference):
conanfile_path = reference
reference_given = False
reference = None
loader = self._loader(current_path, settings, options)
installer = ConanInstaller(self._paths, self._user_io, loader, self.remote_manager, remote)
if reference_given:
project_reference = None
conanfile = installer.retrieve_conanfile(reference, consumer=True)
else:
project_reference = "PROJECT"
output = ScopedOutput(project_reference, self._user_io.out)
try:
if filename and filename.endswith(".txt"):
raise NotFoundException()
conan_file_path = os.path.join(conanfile_path, filename or CONANFILE)
conanfile = loader.load_conan(conan_file_path, output, consumer=True)
is_txt = False
if conanfile.name is not None and conanfile.version is not None:
project_reference = "%s/%s@" % (conanfile.name, conanfile.version)
# Calculate a placeholder conan file reference for the project
current_user = self._localdb.get_username()
if current_user:
project_reference += "%s/" % current_user
project_reference += "PROJECT"
except NotFoundException: # Load requirements.txt
conan_path = os.path.join(conanfile_path, filename or CONANFILE_TXT)
conanfile = loader.load_conan_txt(conan_path, output)
is_txt = True
# build deps graph and install it
builder = DepsBuilder(installer, self._user_io.out)
deps_graph = builder.load(reference, conanfile)
if info:
Printer(self._user_io.out).print_info(deps_graph, project_reference, info)
return
Printer(self._user_io.out).print_graph(deps_graph)
installer.install(deps_graph, build_mode)
if not reference_given:
if is_txt:
conanfile.info.settings = loader._settings.values
# Just in case the current package is header only, we still store the full settings
# for reference and compiler checks
conanfile.info.full_settings = loader._settings.values
content = normalize(conanfile.info.dumps())
save(os.path.join(current_path, CONANINFO), content)
self._user_io.out.writeln("")
output.info("Generated %s" % CONANINFO)
write_generators(conanfile, current_path, output)
local_installer = FileImporter(deps_graph, self._paths, current_path)
conanfile.copy = local_installer
conanfile.imports()
local_installer.execute()