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, 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, 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,
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()
