def package_available(self, package_ref, package_folder, check_outdated): """ Returns True if there is a local or remote package available (and up to date if check_outdated). It wont download the package, just check its hash """ output = ScopedOutput(str(package_ref.conan), self._out) remote_info = None # No package in local cache if not os.path.exists(package_folder): try: # NOTE This call can associate a recently exported recipe, with anything # to a remote containing the recipe reference remote_info = self._get_package_info(package_ref) except (NotFoundException, NoRemoteAvailable): # 404 or no remote return False # Maybe we have the package (locally or in remote) but it's outdated if check_outdated: if remote_info: package_hash = remote_info.recipe_hash else: package_hash = self._client_cache.read_package_recipe_hash( package_folder) local_recipe_hash = self._client_cache.load_manifest( package_ref.conan).summary_hash up_to_date = local_recipe_hash == package_hash if not up_to_date: output.info("Outdated package!") else: output.info("Package is up to date") return up_to_date return True
def get_recipe(self, conan_reference): output = ScopedOutput(str(conan_reference), self._out) def _refresh(): export_path = self._client_cache.export(conan_reference) rmdir(export_path) # It might need to remove shortpath rm_conandir(self._client_cache.source(conan_reference)) current_remote, _ = self._get_remote(conan_reference) output.info("Retrieving from remote '%s'..." % current_remote.name) self._remote_manager.get_recipe(conan_reference, export_path, current_remote) if self._update: output.info("Updated!") else: output.info("Installed!") # check if it is in disk conanfile_path = self._client_cache.conanfile(conan_reference) if os.path.exists(conanfile_path): log_recipe_got_from_local_cache(conan_reference) if self._check_updates: ret = self.update_available(conan_reference) if ret != 0: # Found and not equal remote, ref_remote = self._get_remote(conan_reference) if ret == 1: if not self._update: if remote != ref_remote: # Forced new remote output.warn("There is a new conanfile in '%s' remote. " "Execute 'install -u -r %s' to update it." % (remote.name, remote.name)) else: output.warn("There is a new conanfile in '%s' remote. " "Execute 'install -u' to update it." % remote.name) output.warn("Refused to install!") else: if remote != ref_remote: # Delete packages, could be non coherent with new remote DiskRemover(self._client_cache).remove_packages(conan_reference) _refresh() elif ret == -1: if not self._update: output.info("Current conanfile is newer " "than %s's one" % remote.name) else: output.error("Current conanfile is newer than %s's one. " "Run 'conan remove %s' and run install again " "to replace it." % (remote.name, conan_reference)) else: self._retrieve_recipe(conan_reference, output) if self._manifest_manager: # Just make sure that the recipe sources are there to check self.get_recipe_sources(conan_reference) remote = self._registry.get_ref(conan_reference) self._manifest_manager.check_recipe(conan_reference, remote) return conanfile_path
def package_available(self, package_ref, short_paths, check_outdated): """ Returns True if there is a local or remote package available (and up to date if check_outdated). It wont download the package, just check its hash """ output = ScopedOutput(str(package_ref.conan), self._out) package_folder = self._client_cache.package(package_ref, short_paths=short_paths) remote_info = None # No package in local cache if not os.path.exists(package_folder): try: remote_info = self.get_package_info(package_ref) except ConanException: return False # Not local nor remote # Maybe we have the package (locally or in remote) but it's outdated if check_outdated: if remote_info: package_hash = remote_info.recipe_hash else: package_hash = self._client_cache.read_package_recipe_hash( package_folder) local_recipe_hash = self._client_cache.load_manifest( package_ref.conan).summary_hash up_to_date = local_recipe_hash == package_hash if not up_to_date: output.info("Outdated package!") else: output.info("Package is up to date") return up_to_date return True
def get_package(self, package_ref, short_paths): """ obtain a package, either from disk or retrieve from remotes if necessary and not necessary to build """ output = ScopedOutput(str(package_ref.conan), self._out) package_folder = self._client_cache.package(package_ref, short_paths=short_paths) # Check current package status if os.path.exists(package_folder): if self._check_updates: read_manifest = self._client_cache.load_package_manifest(package_ref) try: # get_conan_digest can fail, not in server upstream_manifest = self.get_package_digest(package_ref) if upstream_manifest.file_sums != read_manifest.file_sums: if upstream_manifest.time > read_manifest.time: output.warn("Current package is older than remote upstream one") if self._update: output.warn("Removing it to retrieve or build an updated one") rmdir(package_folder) else: output.warn("Current package is newer than remote upstream one") except ConanException: pass installed = False local_package = os.path.exists(package_folder) if local_package: output.info('Already installed!') installed = True log_package_got_from_local_cache(package_ref) else: installed = self._retrieve_remote_package(package_ref, package_folder, output) self.handle_package_manifest(package_ref, installed) return installed
def download(reference, package_ids, remote_name, recipe, remote_manager, client_cache, out, recorder, loader, hook_manager): assert(isinstance(reference, ConanFileReference)) output = ScopedOutput(str(reference), out) registry = client_cache.registry remote = registry.remotes.get(remote_name) if remote_name else registry.remotes.default hook_manager.execute("pre_download", reference=reference, remote=remote) # First of all download package recipe try: remote_manager.get_recipe(reference, remote) except NotFoundException: raise NotFoundException("'%s' not found in remote '%s'" % (str(reference), remote.name)) registry.refs.set(reference, remote.name) conan_file_path = client_cache.conanfile(reference) conanfile = loader.load_class(conan_file_path) if not recipe: # Not only the recipe # Download the sources too, don't be lazy complete_recipe_sources(remote_manager, client_cache, conanfile, reference) if not package_ids: # User didnt specify a specific package binary output.info("Getting the complete package list from '%s'..." % str(reference)) packages_props = remote_manager.search_packages(remote, reference, None) package_ids = list(packages_props.keys()) if not package_ids: output.warn("No remote binary packages found in remote") _download_binaries(conanfile, reference, package_ids, client_cache, remote_manager, remote, output, recorder) hook_manager.execute("post_download", conanfile_path=conan_file_path, reference=reference, remote=remote)
def download(ref, package_ids, remote, recipe, remote_manager, cache, out, recorder, loader, hook_manager, remotes): assert (isinstance(ref, ConanFileReference)) output = ScopedOutput(str(ref), out) hook_manager.execute("pre_download", reference=ref, remote=remote) ref = remote_manager.get_recipe(ref, remote) with cache.package_layout(ref).update_metadata() as metadata: metadata.recipe.remote = remote.name conan_file_path = cache.package_layout(ref).conanfile() conanfile = loader.load_class(conan_file_path) # Download the sources too, don't be lazy complete_recipe_sources(remote_manager, cache, conanfile, ref, remotes) if not recipe: # Not only the recipe if not package_ids: # User didn't specify a specific package binary output.info("Getting the complete package list from '%s'..." % ref.full_repr()) packages_props = remote_manager.search_packages(remote, ref, None) package_ids = list(packages_props.keys()) if not package_ids: output.warn("No remote binary packages found in remote") _download_binaries(conanfile, ref, package_ids, cache, remote_manager, remote, output, recorder) hook_manager.execute("post_download", conanfile_path=conan_file_path, reference=ref, remote=remote)
def download(app, ref, package_ids, remote, recipe, recorder, remotes): out, remote_manager, cache, loader = app.out, app.remote_manager, app.cache, app.loader hook_manager = app.hook_manager assert (isinstance(ref, ConanFileReference)) output = ScopedOutput(str(ref), out) hook_manager.execute("pre_download", reference=ref, remote=remote) try: ref = remote_manager.get_recipe(ref, remote) except NotFoundException: raise RecipeNotFoundException(ref) conan_file_path = cache.package_layout(ref).conanfile() conanfile = loader.load_basic(conan_file_path) # Download the sources too, don't be lazy retrieve_exports_sources(remote_manager, cache, conanfile, ref, remotes) if not recipe: # Not only the recipe if not package_ids: # User didn't specify a specific package binary output.info("Getting the complete package list from '%s'..." % ref.full_str()) packages_props = remote_manager.search_packages(remote, ref, None) package_ids = list(packages_props.keys()) if not package_ids: output.warn("No remote binary packages found in remote") parallel = cache.config.parallel_download _download_binaries(conanfile, ref, package_ids, cache, remote_manager, remote, output, recorder, parallel) hook_manager.execute("post_download", conanfile_path=conan_file_path, reference=ref, remote=remote)
def export_recipe(conanfile, origin_folder, destination_folder): if isinstance(conanfile.exports, str): conanfile.exports = (conanfile.exports, ) output = conanfile.output package_output = ScopedOutput("%s exports" % output.scope, output) if os.path.exists(os.path.join(origin_folder, DATA_YML)): package_output.info( "File '{}' found. Exporting it...".format(DATA_YML)) tmp = [DATA_YML] if conanfile.exports: tmp.extend(conanfile.exports ) # conanfile.exports could be a tuple (immutable) conanfile.exports = tmp included_exports, excluded_exports = _classify_patterns(conanfile.exports) try: os.unlink(os.path.join(origin_folder, CONANFILE + 'c')) except OSError: pass copier = FileCopier([origin_folder], destination_folder) for pattern in included_exports: copier(pattern, links=True, excludes=excluded_exports) copier.report(package_output)
def package_available(self, package_ref, package_folder, check_outdated): """ Returns True if there is a local or remote package available (and up to date if check_outdated). It wont download the package, just check its hash """ output = ScopedOutput(str(package_ref.conan), self._out) remote_info = None # No package in local cache if not os.path.exists(package_folder): try: remote_info = self.get_package_info(package_ref) except (NotFoundException, NoRemoteAvailable): # 404 or no remote return False # Maybe we have the package (locally or in remote) but it's outdated if check_outdated: if remote_info: package_hash = remote_info.recipe_hash else: package_hash = self._client_cache.read_package_recipe_hash(package_folder) local_recipe_hash = self._client_cache.load_manifest(package_ref.conan).summary_hash up_to_date = local_recipe_hash == package_hash if not up_to_date: output.info("Outdated package!") else: output.info("Package is up to date") return up_to_date return True
def package(self, reference, package_id): # Package paths conan_file_path = self._client_cache.conanfile(reference) if not os.path.exists(conan_file_path): raise ConanException("Package recipe '%s' does not exist" % str(reference)) if not package_id: packages = [PackageReference(reference, packid) for packid in self._client_cache.conan_builds(reference)] if not packages: raise NotFoundException("%s: Package recipe has not been built locally\n" "Please read the 'conan package' command help\n" "Use 'conan install' or 'conan test_package' to build and " "create binaries" % str(reference)) else: packages = [PackageReference(reference, package_id)] for package_reference in packages: build_folder = self._client_cache.build(package_reference, short_paths=None) if not os.path.exists(build_folder): raise NotFoundException("%s: Package binary '%s' folder doesn't exist\n" "Please read the 'conan package' command help\n" "Use 'conan install' or 'conan test_package' to build and " "create binaries" % (str(reference), package_reference.package_id)) # The package already exist, we can use short_paths if they were defined package_folder = self._client_cache.package(package_reference, short_paths=None) # Will read current conaninfo with specified options and load conanfile with them output = ScopedOutput(str(reference), self._user_io.out) output.info("Re-packaging %s" % package_reference.package_id) loader = self._loader(build_folder) conanfile = loader.load_conan(conan_file_path, self._user_io.out) self._load_deps_info(build_folder, conanfile, output) rmdir(package_folder) packager.create_package(conanfile, build_folder, package_folder, output)
def get_package(self, package_ref, short_paths): """ obtain a package, either from disk or retrieve from remotes if necessary and not necessary to build """ output = ScopedOutput(str(package_ref.conan), self._out) package_folder = self._client_cache.package(package_ref, short_paths=short_paths) # Check current package status if os.path.exists(package_folder): if self._check_updates: read_manifest = self._client_cache.load_package_manifest(package_ref) try: # get_conan_digest can fail, not in server upstream_manifest = self.get_package_digest(package_ref) if upstream_manifest != read_manifest: if upstream_manifest.time > read_manifest.time: output.warn("Current package is older than remote upstream one") if self._update: output.warn("Removing it to retrieve or build an updated one") rmdir(package_folder) else: output.warn("Current package is newer than remote upstream one") except ConanException: pass installed = False local_package = os.path.exists(package_folder) if local_package: output.info('Already installed!') installed = True log_package_got_from_local_cache(package_ref) else: installed = self._retrieve_remote_package(package_ref, package_folder, output) self.handle_package_manifest(package_ref, installed) return installed
def _handle_node_workspace(self, node, workspace_package, inverse_levels, deps_graph): conan_ref, conan_file = node.conan_ref, node.conanfile output = ScopedOutput("Workspace %s" % conan_ref.name, self._out) include_dirs = workspace_package.includedirs lib_dirs = workspace_package.libdirs self._call_package_info(conan_file, workspace_package.package_folder) if include_dirs: conan_file.cpp_info.includedirs = include_dirs if lib_dirs: conan_file.cpp_info.libdirs = lib_dirs # Make sure the folders exists, otherwise they will be filtered out lib_paths = [ os.path.join(conan_file.cpp_info.rootpath, p) if not os.path.isabs(p) else p for p in lib_dirs ] for p in lib_paths: mkdir(p) self._propagate_info(node, inverse_levels, deps_graph, output) build_folder = workspace_package.build_folder write_generators(conan_file, build_folder, output) save(os.path.join(build_folder, CONANINFO), conan_file.info.dumps()) output.info("Generated %s" % CONANINFO) save(os.path.join(build_folder, BUILD_INFO), TXTGenerator(conan_file).content) output.info("Generated %s" % BUILD_INFO) # Build step might need DLLs, binaries as protoc to generate source files # So execute imports() before build, storing the list of copied_files from conans.client.importer import run_imports copied_files = run_imports(conan_file, build_folder, output) report_copied_files(copied_files, output)
def _get_recipe(self, reference, check_updates, update, remote_name): output = ScopedOutput(str(reference), self._out) # check if it is in disk conanfile_path = self._client_cache.conanfile(reference) # NOT in disk, must be retrieved from remotes if not os.path.exists(conanfile_path): ref_remote = self._download_recipe(reference, output, remote_name) status = RECIPE_DOWNLOADED return conanfile_path, status, ref_remote ref_remote = self._registry.get_ref(reference) check_updates = check_updates or update # Recipe exists in disk, but no need to check updates if not check_updates: status = RECIPE_INCACHE log_recipe_got_from_local_cache(reference) self._recorder.recipe_fetched_from_cache(reference) return conanfile_path, status, ref_remote named_remote = self._registry.remote( remote_name) if remote_name else None update_remote = named_remote or ref_remote if not update_remote: status = RECIPE_NO_REMOTE log_recipe_got_from_local_cache(reference) self._recorder.recipe_fetched_from_cache(reference) return conanfile_path, status, None try: # get_conan_manifest can fail, not in server upstream_manifest = self._remote_manager.get_conan_manifest( reference, update_remote) except NotFoundException: status = RECIPE_NOT_IN_REMOTE log_recipe_got_from_local_cache(reference) self._recorder.recipe_fetched_from_cache(reference) return conanfile_path, status, update_remote export = self._client_cache.export(reference) read_manifest = FileTreeManifest.load(export) if upstream_manifest != read_manifest: if upstream_manifest.time > read_manifest.time: if update: DiskRemover(self._client_cache).remove_recipe(reference) output.info("Retrieving from remote '%s'..." % update_remote.name) self._remote_manager.get_recipe(reference, update_remote) self._registry.set_ref(reference, update_remote) status = RECIPE_UPDATED else: status = RECIPE_UPDATEABLE else: status = RECIPE_NEWER else: status = RECIPE_INCACHE log_recipe_got_from_local_cache(reference) self._recorder.recipe_fetched_from_cache(reference) return conanfile_path, status, update_remote
def get_conanfile(self, conan_reference): output = ScopedOutput(str(conan_reference), self._out) def _refresh(): conan_dir_path = self._paths.export(conan_reference) rmdir(conan_dir_path) rmdir(self._paths.source(conan_reference), True) # It might need to remove shortpath current_remote, _ = self._get_remote(conan_reference) output.info("Retrieving from remote '%s'..." % current_remote.name) self._remote_manager.get_conanfile(conan_reference, current_remote) if self._update: output.info("Updated!") else: output.info("Installed!") # check if it is in disk conanfile_path = self._paths.conanfile(conan_reference) path_exist = path_exists(conanfile_path, self._paths.store) if path_exist: if self._check_integrity: # Check if package is corrupted read_manifest, expected_manifest = self._paths.conan_manifests(conan_reference) if read_manifest.file_sums != expected_manifest.file_sums: output.warn("Bad conanfile detected! Removing export directory... ") _refresh() else: # Check for updates if self._check_updates: ret = self.update_available(conan_reference) if ret != 0: # Found and not equal remote, ref_remote = self._get_remote(conan_reference) if ret == 1: if not self._update: if remote != ref_remote: # Forced new remote output.warn("There is a new conanfile in '%s' remote. " "Execute 'install -u -r %s' to update it." % (remote.name, remote.name)) else: output.warn("There is a new conanfile in '%s' remote. " "Execute 'install -u' to update it." % remote.name) output.warn("Refused to install!") else: if remote != ref_remote: # Delete packages, could be non coherent with new remote rmdir(self._paths.packages(conan_reference)) _refresh() elif ret == -1: if not self._update: output.info("Current conanfile is newer " "than %s's one" % remote.name) else: output.error("Current conanfile is newer than %s's one. " "Run 'conan remove %s' and run install again " "to replace it." % (remote.name, conan_reference)) else: self._retrieve_conanfile(conan_reference, output) return conanfile_path
def package(self, reference, package_id): # Package paths conan_file_path = self._client_cache.conanfile(reference) if not os.path.exists(conan_file_path): raise ConanException("Package recipe '%s' does not exist" % str(reference)) conanfile = load_conanfile_class(conan_file_path) if hasattr(conanfile, "build_id"): raise ConanException( "package command does not support recipes with 'build_id'\n" "To repackage them use 'conan install'") if not package_id: packages = [ PackageReference(reference, packid) for packid in self._client_cache.conan_builds(reference) ] if not packages: raise NotFoundException( "%s: Package recipe has not been built locally\n" "Please read the 'conan package' command help\n" "Use 'conan install' or 'conan test_package' to build and " "create binaries" % str(reference)) else: packages = [PackageReference(reference, package_id)] package_source_folder = self._client_cache.source( reference, conanfile.short_paths) for package_reference in packages: build_folder = self._client_cache.build(package_reference, short_paths=None) if not os.path.exists(build_folder): raise NotFoundException( "%s: Package binary '%s' folder doesn't exist\n" "Please read the 'conan package' command help\n" "Use 'conan install' or 'conan test_package' to build and " "create binaries" % (str(reference), package_reference.package_id)) # The package already exist, we can use short_paths if they were defined package_folder = self._client_cache.package(package_reference, short_paths=None) # Will read current conaninfo with specified options and load conanfile with them output = ScopedOutput(str(reference), self._user_io.out) output.info("Re-packaging %s" % package_reference.package_id) conanfile = load_consumer_conanfile(conan_file_path, build_folder, self._client_cache.settings, self._runner, output, reference=reference) rmdir(package_folder) if getattr(conanfile, 'no_copy_source', False): source_folder = package_source_folder else: source_folder = build_folder with environment_append(conanfile.env): packager.create_package(conanfile, source_folder, build_folder, package_folder, output)
def allowed(self, conan_file, reference): if self.missing or self.outdated: return True if conan_file.build_policy_missing: out = ScopedOutput(str(reference), self._out) out.info( "Building package from source as defined by build_policy='missing'" ) return True return False
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 forced(self, reference, conanfile): if self.all: return True if conanfile.build_policy_always: out = ScopedOutput(str(reference), self._out) out.info("Building package from source as defined by build_policy='always'") return True ref = reference.name # Patterns to match, if package matches pattern, build is forced force_build = any([fnmatch.fnmatch(ref, pattern) for pattern in self.patterns]) return force_build
def get_package(self, package_reference, force_build): """ obtain a package, either from disk or retrieve from remotes if necessary and not necessary to build """ output = ScopedOutput(str(package_reference.conan), self._out) package_folder = self._paths.package(package_reference) # Check current package status if path_exists(package_folder, self._paths.store): if self._check_integrity or self._check_updates: read_manifest, expected_manifest = self._paths.package_manifests( package_reference) if self._check_integrity: # Check if package is corrupted if read_manifest.file_sums != expected_manifest.file_sums: # If not valid package, ensure empty folder output.warn("Bad package '%s' detected! Removing " "package directory... " % str(package_reference.package_id)) rmdir(package_folder) if self._check_updates: try: # get_conan_digest can fail, not in server upstream_manifest = self.get_package_digest( package_reference) if upstream_manifest.file_sums != read_manifest.file_sums: if upstream_manifest.time > read_manifest.time: output.warn( "Current package is older than remote upstream one" ) if self._update: output.warn( "Removing it to retrieve or build an updated one" ) rmdir(package_folder) else: output.warn( "Current package is newer than remote upstream one" ) except ConanException: pass if not force_build: local_package = os.path.exists(package_folder) if local_package: output = ScopedOutput(str(package_reference.conan), self._out) output.info('Already installed!') return True return self._retrieve_remote_package(package_reference, output) return False
def _build_node(self, conan_ref, conan_file, build_mode): # Compute conan_file package from local (already compiled) or from remote output = ScopedOutput(str(conan_ref), self._out) package_id = conan_file.info.package_id() package_reference = PackageReference(conan_ref, package_id) conan_ref = package_reference.conan package_folder = self._paths.package(package_reference) build_folder = self._paths.build(package_reference, conan_file.short_paths) src_folder = self._paths.source(conan_ref, conan_file.short_paths) export_folder = self._paths.export(conan_ref) # If already exists do not dirt the output, the common situation # is that package is already installed and OK. If don't, the proxy # will print some other message about it if not os.path.exists(package_folder): output.info("Installing package %s" % package_id) self._handle_system_requirements(conan_ref, package_reference, conan_file, output) force_build = self._build_forced(conan_ref, build_mode, conan_file) if self._remote_proxy.get_package(package_reference, force_build): return # we need and can build? Only if we are forced or build_mode missing and package not exists build = force_build or build_mode is True or conan_file.build_policy_missing if build: if not force_build and not build_mode: output.info( "Building package from source as defined by build_policy='missing'" ) try: rmdir(build_folder, conan_file.short_paths) rmdir(package_folder) except Exception as e: raise ConanException( "%s\n\nCouldn't remove folder, might be busy or open\n" "Close any app using it, and retry" % str(e)) if force_build: output.warn('Forced build from source') self._build_package(export_folder, src_folder, build_folder, package_folder, conan_file, output) # Creating ***info.txt files save(os.path.join(build_folder, CONANINFO), conan_file.info.dumps()) output.info("Generated %s" % CONANINFO) save(os.path.join(build_folder, BUILD_INFO), TXTGenerator(conan_file).content) output.info("Generated %s" % BUILD_INFO) os.chdir(build_folder) create_package(conan_file, build_folder, package_folder, output) else: self._raise_package_not_found_error(conan_ref, conan_file)
def _build_forced(self, conan_ref, build_mode, conan_file): if conan_file.build_policy_always: out = ScopedOutput(str(conan_ref), self._out) out.info("Building package from source as defined by build_policy='always'") return True if build_mode is False: # "never" option, default return False if build_mode is True: # Build missing (just if needed), not force return False # Patterns to match, if package matches pattern, build is forced force_build = any([fnmatch.fnmatch(str(conan_ref), pattern) for pattern in build_mode]) return force_build
def source(self, conanfile_path, source_folder, info_folder): """ :param conanfile_path: Absolute path to a conanfile :param source_folder: Absolute path where to put the files :param info_folder: Absolute path where to read the info files :param package_folder: Absolute path to the package_folder, only to have the var present :return: """ output = ScopedOutput("PROJECT", self._user_io.out) # only infos if exist conanfile = self._load_consumer_conanfile(conanfile_path, info_folder, output) conanfile_folder = os.path.dirname(conanfile_path) if conanfile_folder != source_folder: output.info("Executing exports to: %s" % source_folder) _execute_export(conanfile_path, conanfile, source_folder, source_folder, output) config_source_local(source_folder, conanfile, conanfile_folder, output)
def package(self, reference, package_id): # Package paths conan_file_path = self._client_cache.conanfile(reference) if not os.path.exists(conan_file_path): raise ConanException("Package recipe '%s' does not exist" % str(reference)) conanfile = load_conanfile_class(conan_file_path) if hasattr(conanfile, "build_id"): raise ConanException("package command does not support recipes with 'build_id'\n" "To repackage them use 'conan install'") if not package_id: packages = [PackageReference(reference, packid) for packid in self._client_cache.conan_builds(reference)] if not packages: raise NotFoundException("%s: Package recipe has not been built locally\n" "Please read the 'conan package' command help\n" "Use 'conan install' or 'conan test_package' to build and " "create binaries" % str(reference)) else: packages = [PackageReference(reference, package_id)] package_source_folder = self._client_cache.source(reference, conanfile.short_paths) for package_reference in packages: build_folder = self._client_cache.build(package_reference, short_paths=None) if not os.path.exists(build_folder): raise NotFoundException("%s: Package binary '%s' folder doesn't exist\n" "Please read the 'conan package' command help\n" "Use 'conan install' or 'conan test_package' to build and " "create binaries" % (str(reference), package_reference.package_id)) # The package already exist, we can use short_paths if they were defined package_folder = self._client_cache.package(package_reference, short_paths=None) # Will read current conaninfo with specified options and load conanfile with them output = ScopedOutput(str(reference), self._user_io.out) output.info("Re-packaging %s" % package_reference.package_id) conanfile = load_consumer_conanfile(conan_file_path, build_folder, self._client_cache.settings, self._runner, output, reference) rmdir(package_folder) if getattr(conanfile, 'no_copy_source', False): source_folder = package_source_folder else: source_folder = build_folder with environment_append(conanfile.env): packager.create_package(conanfile, source_folder, build_folder, package_folder, output)
def source(self, conanfile_path, source_folder, info_folder): """ :param conanfile_path: Absolute path to a conanfile :param source_folder: Absolute path where to put the files :param info_folder: Absolute path where to read the info files :param package_folder: Absolute path to the package_folder, only to have the var present :return: """ output = ScopedOutput("PROJECT", self._user_io.out) # only infos if exist conanfile = self._load_consumer_conanfile(conanfile_path, info_folder, output) conanfile_folder = os.path.dirname(conanfile_path) if conanfile_folder != source_folder: output.info("Executing exports to: %s" % source_folder) _execute_export(conanfile_path, conanfile, source_folder, source_folder, output) config_source_local(source_folder, conanfile, output)
def retrieve_conanfile(self, conan_reference, consumer=False): """ returns the requested conanfile object, retrieving it from remotes if necessary. Can raise NotFoundException """ output = ScopedOutput(str(conan_reference), self._out) conanfile_path = self._paths.conanfile(conan_reference) if not self._paths.valid_conan_digest(conan_reference): conan_dir_path = self._paths.export(conan_reference) if path_exists(conan_dir_path, self._paths.store): # If not valid conanfile, ensure empty folder output.warn("Bad conanfile detected! Removing export directory... ") rmdir(conan_dir_path) output.info("Conanfile not found, retrieving from server") # If not in localhost, download it. Will raise if not found self._remote_manager.get_conanfile(conan_reference, self._remote) conanfile = self._loader.load_conan(conanfile_path, output, consumer) return conanfile
def _build_node(self, conan_ref, conan_file, build_mode): # Compute conan_file package from local (already compiled) or from remote output = ScopedOutput(str(conan_ref), self._out) package_id = conan_file.info.package_id() package_reference = PackageReference(conan_ref, package_id) conan_ref = package_reference.conan package_folder = self._paths.package(package_reference, conan_file.short_paths) build_folder = self._paths.build(package_reference, conan_file.short_paths) src_folder = self._paths.source(conan_ref, conan_file.short_paths) export_folder = self._paths.export(conan_ref) # If already exists do not dirt the output, the common situation # is that package is already installed and OK. If don't, the proxy # will print some other message about it if not package_exists(package_folder): output.info("Installing package %s" % package_id) self._handle_system_requirements(conan_ref, package_reference, conan_file, output) force_build = self._build_forced(conan_ref, build_mode, conan_file) if self._remote_proxy.get_package(package_reference, force_build, short_paths=conan_file.short_paths): return # we need and can build? Only if we are forced or build_mode missing and package not exists build = force_build or build_mode is True or conan_file.build_policy_missing if build: if not force_build and not build_mode: output.info("Building package from source as defined by build_policy='missing'") try: rmdir(build_folder, conan_file.short_paths) rmdir(package_folder) except Exception as e: raise ConanException("%s\n\nCouldn't remove folder, might be busy or open\n" "Close any app using it, and retry" % str(e)) if force_build: output.warn('Forced build from source') self._build_package(export_folder, src_folder, build_folder, package_folder, conan_file, output) # Creating ***info.txt files save(os.path.join(build_folder, CONANINFO), conan_file.info.dumps()) output.info("Generated %s" % CONANINFO) save(os.path.join(build_folder, BUILD_INFO), TXTGenerator(conan_file).content) output.info("Generated %s" % BUILD_INFO) os.chdir(build_folder) create_package(conan_file, build_folder, package_folder, output) self._remote_proxy.handle_package_manifest(package_reference, installed=True) else: self._raise_package_not_found_error(conan_ref, conan_file)
def download(self, reference, package_ids, remote_name, recipe): """ Download conanfile and specified packages to local repository @param reference: ConanFileReference @param package_ids: Package ids or empty for download all @param remote: install only from that remote @param only_recipe: download only the recipe """ assert (isinstance(reference, ConanFileReference)) output = ScopedOutput(str(reference), self._user_io.out) remote = self._registry.remote( remote_name) if remote_name else self._registry.default_remote package = self._remote_manager.search_recipes(remote, reference, None) if not package: # Search the reference first, and raise if it doesn't exist raise ConanException("'%s' not found in remote" % str(reference)) # First of all download package recipe self._remote_manager.get_recipe(reference, remote) self._registry.set_ref(reference, remote) if recipe: return # Download the sources too, don't be lazy conan_file_path = self._client_cache.conanfile(reference) conanfile = load_conanfile_class(conan_file_path) complete_recipe_sources(self._remote_manager, self._client_cache, self._registry, conanfile, reference) if package_ids: download_binaries(reference, package_ids, self._client_cache, self._remote_manager, remote, output, self._recorder) else: output.info("Getting the complete package list " "from '%s'..." % str(reference)) packages_props = self._remote_manager.search_packages( remote, reference, None) if not packages_props: output = ScopedOutput(str(reference), self._user_io.out) output.warn("No remote binary packages found in remote") else: download_binaries(reference, list(packages_props.keys()), self._client_cache, self._remote_manager, remote, output, self._recorder)
def download(reference, package_ids, remote_name, recipe, registry, remote_manager, client_cache, out, recorder, loader, hook_manager): assert (isinstance(reference, ConanFileReference)) output = ScopedOutput(str(reference), out) remote = registry.remotes.get( remote_name) if remote_name else registry.remotes.default package = remote_manager.search_recipes(remote, reference, None) if not package: # Search the reference first, and raise if it doesn't exist raise ConanException("'%s' not found in remote" % str(reference)) hook_manager.execute("pre_download", reference=reference, remote=remote) # First of all download package recipe remote_manager.get_recipe(reference, remote) registry.refs.set(reference, remote.name) conan_file_path = client_cache.conanfile(reference) conanfile = loader.load_class(conan_file_path) if not recipe: # Download the sources too, don't be lazy complete_recipe_sources(remote_manager, client_cache, registry, conanfile, reference) if package_ids: _download_binaries(reference, package_ids, client_cache, remote_manager, remote, output, recorder, loader) else: output.info("Getting the complete package list " "from '%s'..." % str(reference)) packages_props = remote_manager.search_packages( remote, reference, None) if not packages_props: output = ScopedOutput(str(reference), out) output.warn("No remote binary packages found in remote") else: _download_binaries(reference, list(packages_props.keys()), client_cache, remote_manager, remote, output, recorder, loader) hook_manager.execute("post_download", conanfile_path=conan_file_path, reference=reference, remote=remote)
def get_package(self, package_reference, force_build): """ obtain a package, either from disk or retrieve from remotes if necessary and not necessary to build """ output = ScopedOutput(str(package_reference.conan), self._out) package_folder = self._paths.package(package_reference) # Check current package status if path_exists(package_folder, self._paths.store): if self._check_integrity or self._check_updates: read_manifest, expected_manifest = self._paths.package_manifests(package_reference) if self._check_integrity: # Check if package is corrupted if read_manifest.file_sums != expected_manifest.file_sums: # If not valid package, ensure empty folder output.warn("Bad package '%s' detected! Removing " "package directory... " % str(package_reference.package_id)) rmdir(package_folder) if self._check_updates: try: # get_conan_digest can fail, not in server upstream_manifest = self.get_package_digest(package_reference) if upstream_manifest.file_sums != read_manifest.file_sums: if upstream_manifest.time > read_manifest.time: output.warn("Current package is older than remote upstream one") if self._update: output.warn("Removing it to retrieve or build an updated one") rmdir(package_folder) else: output.warn("Current package is newer than remote upstream one") except ConanException: pass if not force_build: local_package = os.path.exists(package_folder) if local_package: output = ScopedOutput(str(package_reference.conan), self._out) output.info('Already installed!') return True return self._retrieve_remote_package(package_reference, output) return False
def _get_package(self, conan_ref, conan_file): '''Get remote package. It won't check if it's outdated''' # Compute conan_file package from local (already compiled) or from remote output = ScopedOutput(str(conan_ref), self._out) package_id = conan_file.info.package_id() package_reference = PackageReference(conan_ref, package_id) conan_ref = package_reference.conan package_folder = self._client_cache.package(package_reference, conan_file.short_paths) # If already exists do not dirt the output, the common situation # is that package is already installed and OK. If don't, the proxy # will print some other message about it if not os.path.exists(package_folder): output.info("Retrieving package %s" % package_id) if self._remote_proxy.get_package(package_reference, short_paths=conan_file.short_paths): self._handle_system_requirements(conan_ref, package_reference, conan_file, output) return True self._raise_package_not_found_error(conan_ref, conan_file)
def _get_package(self, conan_ref, conan_file): '''Get remote package. It won't check if it's outdated''' # Compute conan_file package from local (already compiled) or from remote output = ScopedOutput(str(conan_ref), self._out) package_id = conan_file.info.package_id() package_reference = PackageReference(conan_ref, package_id) conan_ref = package_reference.conan package_folder = self._client_cache.package(package_reference, conan_file.short_paths) # If already exists do not dirt the output, the common situation # is that package is already installed and OK. If don't, the proxy # will print some other message about it if not os.path.exists(package_folder): output.info("Installing package %s" % package_id) if self._remote_proxy.get_package(package_reference, short_paths=conan_file.short_paths): self._handle_system_requirements(conan_ref, package_reference, conan_file, output) return True self._raise_package_not_found_error(conan_ref, conan_file)
def forced(self, conan_file, reference): if self.never: return False if self.all: return True if conan_file.build_policy_always: out = ScopedOutput(str(reference), self._out) out.info( "Building package from source as defined by build_policy='always'" ) return True ref = reference.name # Patterns to match, if package matches pattern, build is forced for pattern in self.patterns: if fnmatch.fnmatch(ref, pattern): try: self._unused_patterns.remove(pattern) except ValueError: pass return True return False
def _compute_private_nodes(self, deps_graph, build_mode): """ computes a list of nodes that are not required to be built, as they are private requirements of already available shared libraries as binaries """ private_closure = deps_graph.private_nodes() skippable_nodes = [] for private_node, private_requirers in private_closure: for private_requirer in private_requirers: conan_ref, conan_file = private_requirer if conan_ref is None: continue package_id = conan_file.info.package_id() package_reference = PackageReference(conan_ref, package_id) package_folder = self._paths.package(package_reference) if not path_exists(package_folder, self._paths.store): if not self._force_build(conan_ref, build_mode): # Not download package output = ScopedOutput(str(conan_ref), self._out) output.info("Package not installed") if not self._retrieve_remote_package(package_reference, output): break else: skippable_nodes.append(private_node) return skippable_nodes
def package(self, reference, package_id): assert(isinstance(reference, ConanFileReference)) # Package paths conan_file_path = self._client_cache.conanfile(reference) if not os.path.exists(conan_file_path): raise ConanException("Package recipe '%s' does not exist" % str(reference)) if not package_id: packages = [PackageReference(reference, packid) for packid in self._client_cache.conan_builds(reference)] if not packages: raise NotFoundException("%s: Package recipe has not been built locally\n" "Please read the 'conan package' command help\n" "Use 'conan install' or 'conan test_package' to build and " "create binaries" % str(reference)) else: packages = [PackageReference(reference, package_id)] for package_reference in packages: build_folder = self._client_cache.build(package_reference, short_paths=None) if not build_exists(build_folder): raise NotFoundException("%s: Package binary '%s' folder doesn't exist\n" "Please read the 'conan package' command help\n" "Use 'conan install' or 'conan test_package' to build and " "create binaries" % (str(reference), package_reference.package_id)) # The package already exist, we can use short_paths if they were defined package_folder = self._client_cache.package(package_reference, short_paths=None) # Will read current conaninfo with specified options and load conanfile with them output = ScopedOutput(str(reference), self._user_io.out) output.info("Re-packaging %s" % package_reference.package_id) loader = self._loader(build_folder) conanfile = loader.load_conan(conan_file_path, self._user_io.out) rmdir(package_folder) packager.create_package(conanfile, build_folder, package_folder, output)
def _get_recipe(self, conan_reference, check_updates, update): output = ScopedOutput(str(conan_reference), self._out) check_updates = check_updates or update # check if it is in disk conanfile_path = self._client_cache.conanfile(conan_reference) if os.path.exists(conanfile_path): if check_updates: ret = self.update_available(conan_reference) if ret != 0: # Found and not equal remote, ref_remote = self._get_remote(conan_reference) if ret == 1: if not update: if remote != ref_remote: # Forced new remote output.warn("There is a new conanfile in '%s' remote. " "Execute 'install -u -r %s' to update it." % (remote.name, remote.name)) else: output.warn("There is a new conanfile in '%s' remote. " "Execute 'install -u' to update it." % remote.name) output.warn("Refused to install!") else: DiskRemover(self._client_cache).remove(conan_reference) output.info("Retrieving from remote '%s'..." % remote.name) self._remote_manager.get_recipe(conan_reference, remote) output.info("Updated!") elif ret == -1: if not update: output.info("Current conanfile is newer than %s's one" % remote.name) else: output.error("Current conanfile is newer than %s's one. " "Run 'conan remove %s' and run install again " "to replace it." % (remote.name, conan_reference)) log_recipe_got_from_local_cache(conan_reference) self._recorder.recipe_fetched_from_cache(conan_reference) else: self._retrieve_recipe(conan_reference, output) if self._manifest_manager: # Just make sure that the recipe sources are there to check conanfile = load_conanfile_class(conanfile_path) complete_recipe_sources(self._remote_manager, self._client_cache, self._registry, conanfile, conan_reference) remote = self._registry.get_ref(conan_reference) self._manifest_manager.check_recipe(conan_reference, remote) return conanfile_path
def _build_node(self, conan_ref, conan_file, build_mode): # Compute conan_file package from local (already compiled) or from remote output = ScopedOutput(str(conan_ref), self._out) package_id = conan_file.info.package_id() package_reference = PackageReference(conan_ref, package_id) conan_ref = package_reference.conan package_folder = self._paths.package(package_reference) build_folder = self._paths.build(package_reference) src_folder = self._paths.source(conan_ref) export_folder = self._paths.export(conan_ref) # If already exists do not dirt the output, the common situation # is that package is already installed and OK. If don't, the proxy # will print some other message about it if not os.path.exists(package_folder): output.info("Installing package %s" % package_id) self._handle_system_requirements(conan_ref, package_reference, conan_file, output) force_build = self._force_build(conan_ref, build_mode) if self._remote_proxy.get_package(package_reference, force_build): return # Can we build? Only if we are forced or build_mode missing and package not exists build_allowed = force_build or build_mode is True if build_allowed: rmdir(build_folder) rmdir(package_folder) if force_build: output.warn('Forced build from source') self._build_package(export_folder, src_folder, build_folder, conan_file, output) # Creating ***info.txt files save(os.path.join(build_folder, CONANINFO), conan_file.info.dumps()) output.info("Generated %s" % CONANINFO) save( os.path.join(build_folder, BUILD_INFO), TXTGenerator(conan_file.deps_cpp_info, conan_file.cpp_info).content) output.info("Generated %s" % BUILD_INFO) os.chdir(build_folder) create_package(conan_file, build_folder, package_folder, output) else: self._raise_package_not_found_error(conan_ref, conan_file)
def _build_node(self, conan_ref, conan_file, build_mode): # Compute conan_file package from local (already compiled) or from remote output = ScopedOutput(str(conan_ref), self._out) package_id = conan_file.info.package_id() package_reference = PackageReference(conan_ref, package_id) conan_ref = package_reference.conan package_folder = self._paths.package(package_reference) build_folder = self._paths.build(package_reference) src_folder = self._paths.source(conan_ref) export_folder = self._paths.export(conan_ref) # If already exists do not dirt the output, the common situation # is that package is already installed and OK. If don't, the proxy # will print some other message about it if not os.path.exists(package_folder): output.info("Installing package %s" % package_id) self._handle_system_requirements(conan_ref, package_reference, conan_file, output) force_build = self._force_build(conan_ref, build_mode) if self._remote_proxy.get_package(package_reference, force_build): return # Can we build? Only if we are forced or build_mode missing and package not exists build_allowed = force_build or build_mode is True if build_allowed: rmdir(build_folder) rmdir(package_folder) if force_build: output.warn('Forced build from source') self._build_package(export_folder, src_folder, build_folder, conan_file, output) # Creating ***info.txt files save(os.path.join(build_folder, CONANINFO), conan_file.info.dumps()) output.info("Generated %s" % CONANINFO) save(os.path.join(build_folder, BUILD_INFO), TXTGenerator(conan_file.deps_cpp_info, conan_file.cpp_info).content) output.info("Generated %s" % BUILD_INFO) os.chdir(build_folder) create_package(conan_file, build_folder, package_folder, output) else: self._raise_package_not_found_error(conan_ref, conan_file)
def _get_recipe(self, conan_reference, check_updates, update): output = ScopedOutput(str(conan_reference), self._out) check_updates = check_updates or update # check if it is in disk conanfile_path = self._client_cache.conanfile(conan_reference) remote = None if os.path.exists(conanfile_path): if check_updates: ret = self.update_available(conan_reference) if ret != 0: # Found and not equal remote, ref_remote = self._get_remote(conan_reference) if ret == 1: if not update: if remote != ref_remote: # Forced new remote output.warn("There is a new conanfile in '%s' remote. " "Execute 'install -u -r %s' to update it." % (remote.name, remote.name)) else: output.warn("There is a new conanfile in '%s' remote. " "Execute 'install -u' to update it." % remote.name) output.warn("Refused to install!") else: DiskRemover(self._client_cache).remove(conan_reference) output.info("Retrieving from remote '%s'..." % remote.name) self._remote_manager.get_recipe(conan_reference, remote) self._registry.set_ref(conan_reference, remote) output.info("Updated!") elif ret == -1: if not update: output.info("Current conanfile is newer than %s's one" % remote.name) else: output.error("Current conanfile is newer than %s's one. " "Run 'conan remove %s' and run install again " "to replace it." % (remote.name, conan_reference)) log_recipe_got_from_local_cache(conan_reference) self._recorder.recipe_fetched_from_cache(conan_reference) else: remote = self._retrieve_recipe(conan_reference, output) if not remote: remote = self._registry.get_ref(conan_reference) return conanfile_path, remote
def get_package(self, package_reference, force_build, short_paths, check_outdated): """ obtain a package, either from disk or retrieve from remotes if necessary and not necessary to build """ output = ScopedOutput(str(package_reference.conan), self._out) package_folder = self._client_cache.package(package_reference, short_paths=short_paths) # Check current package status if os.path.exists(package_folder): if self._check_updates: read_manifest = self._client_cache.load_package_manifest(package_reference) try: # get_conan_digest can fail, not in server upstream_manifest = self.get_package_digest(package_reference) if upstream_manifest.file_sums != read_manifest.file_sums: if upstream_manifest.time > read_manifest.time: output.warn("Current package is older than remote upstream one") if self._update: output.warn("Removing it to retrieve or build an updated one") rmdir(package_folder) else: output.warn("Current package is newer than remote upstream one") except ConanException: pass installed = False if not force_build: local_package = os.path.exists(package_folder) if local_package: output.info('Already installed!') installed = True else: installed = self._retrieve_remote_package(package_reference, package_folder, output) # Check if the package is outdated if check_outdated and os.path.exists(package_folder): if self._package_outdated(package_reference, package_folder): output.info("Outdated package!") installed = False else: output.info("Package is up to date") self.handle_package_manifest(package_reference, installed) return installed
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, 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, 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 _build_node(self, conan_ref, conan_file, build_mode): # Compute conan_file package from local (already compiled) or from remote output = ScopedOutput(str(conan_ref), self._out) package_id = conan_file.info.package_id() self._out.writeln("") output.info("Installing package %s" % package_id) package_reference = PackageReference(conan_ref, package_id) conan_ref = package_reference.conan package_folder = self._paths.package(package_reference) build_folder = self._paths.build(package_reference) src_folder = self._paths.source(conan_ref) export_folder = self._paths.export(conan_ref) self._handle_system_requirements(conan_ref, package_reference, conan_file, output) # Check if package is corrupted valid_package_digest = self._paths.valid_package_digest(package_reference) if os.path.exists(package_folder) and not valid_package_digest: # If not valid package, ensure empty folder output.warn("Bad package '%s' detected! Removing " "package directory... " % str(package_id)) rmdir(package_folder) # Check if any only_source pattern matches with package force_build = self._force_build(conan_ref, build_mode) if not force_build: local_package = os.path.exists(package_folder) if local_package: output.info("Package installed in %s" % package_folder) return output.info("Package not installed") remote_package = self._retrieve_remote_package(package_reference, output) if remote_package: return # Can we build? Only if we are forced or build_mode missing and package not exists build_allowed = force_build or build_mode is True if build_allowed: rmdir(build_folder) rmdir(package_folder) if force_build: output.warn("Forced build from source") self._build_package(export_folder, src_folder, build_folder, conan_file, output) # Creating ***info.txt files save(os.path.join(build_folder, CONANINFO), conan_file.info.dumps()) output.info("Generated %s" % CONANINFO) save( os.path.join(build_folder, BUILD_INFO), TXTGenerator(conan_file.deps_cpp_info, conan_file.cpp_info).content, ) output.info("Generated %s" % BUILD_INFO) os.chdir(build_folder) create_package(conan_file, build_folder, package_folder, output) else: self._raise_package_not_found_error(conan_ref, conan_file)
def _build(self, nodes_by_level, skip_private_nodes, deps_graph, profile_build_requires): """ The build assumes an input of conans ordered by degree, first level should be independent from each other, the next-second level should have dependencies only to first level conans. param nodes_by_level: list of lists [[nodeA, nodeB], [nodeC], [nodeD, ...], ...] build_mode => ["*"] if user wrote "--build" => ["hello*", "bye*"] if user wrote "--build hello --build bye" => False if user wrote "never" => True if user wrote "missing" => "outdated" if user wrote "--build outdated" """ inverse = deps_graph.inverse_levels() flat = [] for level in inverse: level = sorted(level, key=lambda x: x.conan_ref) flat.extend(n for n in level if n not in skip_private_nodes) # Get the nodes in order and if we have to build them nodes_to_process = self._get_nodes(nodes_by_level, skip_private_nodes) for conan_ref, package_id, conan_file, build_needed in nodes_to_process: output = ScopedOutput(str(conan_ref), self._out) if build_needed and (conan_ref, package_id) not in self._built_packages: package_ref = PackageReference(conan_ref, package_id) build_allowed = self._build_mode.allowed(conan_file, conan_ref) if not build_allowed: _raise_package_not_found_error(conan_file, conan_ref, output) if conan_file.build_policy_missing: output.info("Building package from source as defined by build_policy='missing'") elif self._build_mode.forced(conan_file, conan_ref): output.warn('Forced build from source') self._build_requires.install(conan_ref, conan_file, self, profile_build_requires, output) t1 = time.time() # Assign to node the propagated info self._propagate_info(conan_file, conan_ref, flat, deps_graph) builder = _ConanPackageBuilder(conan_file, package_ref, self._client_cache, output) with self._client_cache.conanfile_write_lock(conan_ref): self._remote_proxy.get_recipe_sources(conan_ref, conan_file.short_paths) builder.prepare_build() with self._client_cache.conanfile_read_lock(conan_ref): with self._client_cache.package_lock(builder.build_reference): builder.build() builder.package() self._remote_proxy.handle_package_manifest(package_ref, installed=True) package_folder = self._client_cache.package(package_ref, conan_file.short_paths) # Call the info method call_package_info(conan_file, package_folder) # Log build self._log_built_package(conan_file, package_ref, time.time() - t1) self._built_packages.add((conan_ref, package_id)) else: # Get the package, we have a not outdated remote package package_ref = None if conan_ref: package_ref = PackageReference(conan_ref, package_id) with self._client_cache.package_lock(package_ref): self._get_remote_package(conan_file, package_ref, output) # Assign to the node the propagated info # (conan_ref could be None if user project, but of course assign the info self._propagate_info(conan_file, conan_ref, flat, deps_graph) if package_ref: # Call the info method package_folder = self._client_cache.package(package_ref, conan_file.short_paths) call_package_info(conan_file, package_folder)
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, 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 _get_recipe(self, ref, check_updates, update, remotes, recorder): output = ScopedOutput(str(ref), self._out) # check if it is in disk conanfile_path = self._cache.package_layout(ref).conanfile() # NOT in disk, must be retrieved from remotes if not os.path.exists(conanfile_path): remote, new_ref = self._download_recipe(ref, output, remotes, remotes.selected, recorder) status = RECIPE_DOWNLOADED return conanfile_path, status, remote, new_ref metadata = self._cache.package_layout(ref).load_metadata() cur_revision = metadata.recipe.revision cur_remote = metadata.recipe.remote cur_remote = remotes[cur_remote] if cur_remote else None selected_remote = remotes.selected or cur_remote check_updates = check_updates or update # Recipe exists in disk, but no need to check updates requested_different_revision = ( ref.revision is not None) and cur_revision != ref.revision if requested_different_revision and not check_updates: raise NotFoundException( "The recipe in the local cache doesn't match the specified " "revision. Use '--update' to check in the remote.") if not requested_different_revision: if not check_updates: status = RECIPE_INCACHE ref = ref.copy_with_rev(cur_revision) return conanfile_path, status, cur_remote, ref if not selected_remote: status = RECIPE_NO_REMOTE ref = ref.copy_with_rev(cur_revision) return conanfile_path, status, None, ref else: # Requested different revision and with --update remote, new_ref = self._download_recipe(ref, output, remotes, selected_remote, recorder) status = RECIPE_DOWNLOADED return conanfile_path, status, remote, new_ref try: # get_recipe_manifest can fail, not in server upstream_manifest, ref = self._remote_manager.get_recipe_manifest( ref, selected_remote) except NotFoundException: status = RECIPE_NOT_IN_REMOTE ref = ref.copy_with_rev(cur_revision) return conanfile_path, status, selected_remote, ref export = self._cache.package_layout(ref).export() read_manifest = FileTreeManifest.load(export) if upstream_manifest != read_manifest: if upstream_manifest.time > read_manifest.time: if update: DiskRemover().remove_recipe( self._cache.package_layout(ref), output=output) output.info("Retrieving from remote '%s'..." % selected_remote.name) self._download_recipe(ref, output, remotes, selected_remote, recorder) with self._cache.package_layout( ref).update_metadata() as metadata: metadata.recipe.remote = selected_remote.name status = RECIPE_UPDATED return conanfile_path, status, selected_remote, ref else: status = RECIPE_UPDATEABLE else: status = RECIPE_NEWER else: status = RECIPE_INCACHE ref = ref.copy_with_rev(cur_revision) return conanfile_path, status, selected_remote, ref
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()
def _build(self, nodes_by_level, skip_private_nodes, build_mode): """ The build assumes an input of conans ordered by degree, first level should be independent from each other, the next-second level should have dependencies only to first level conans. param nodes_by_level: list of lists [[nodeA, nodeB], [nodeC], [nodeD, ...], ...] build_mode => ["*"] if user wrote "--build" => ["hello*", "bye*"] if user wrote "--build hello --build bye" => False if user wrote "never" => True if user wrote "missing" => "outdated" if user wrote "--build outdated" """ inverse = self._deps_graph.inverse_levels() flat = [] for level in inverse: level = sorted(level, key=lambda x: x.conan_ref) flat.extend(level) # Get the nodes in order and if we have to build them nodes_to_process = self._get_nodes(nodes_by_level, skip_private_nodes, build_mode) for conan_ref, package_id, conan_file, build_needed in nodes_to_process: if build_needed: build_allowed = build_mode.allowed(conan_ref, conan_file) if not build_allowed: self._raise_package_not_found_error(conan_ref, conan_file) output = ScopedOutput(str(conan_ref), self._out) package_ref = PackageReference(conan_ref, package_id) package_folder = self._client_cache.package(package_ref, conan_file.short_paths) if conan_file.build_policy_missing: output.info("Building package from source as defined by build_policy='missing'") elif build_mode.forced(conan_ref, conan_file): output.warn('Forced build from source') self._build_requires.install(conan_ref, conan_file) t1 = time.time() # Assign to node the propagated info self._propagate_info(conan_ref, conan_file, flat) self._remote_proxy.get_recipe_sources(conan_ref) # Call the conanfile's build method build_folder = self._build_conanfile(conan_ref, conan_file, package_ref, package_folder, output) # Call the conanfile's package method self._package_conanfile(conan_ref, conan_file, package_ref, build_folder, package_folder, output) # Call the info method self._package_info_conanfile(conan_ref, conan_file) duration = time.time() - t1 log_file = os.path.join(build_folder, RUN_LOG_NAME) log_file = log_file if os.path.exists(log_file) else None log_package_built(package_ref, duration, log_file) else: # Get the package, we have a not outdated remote package if conan_ref: self._get_package(conan_ref, conan_file) # Assign to the node the propagated info # (conan_ref could be None if user project, but of course assign the info self._propagate_info(conan_ref, conan_file, flat) # Call the info method self._package_info_conanfile(conan_ref, conan_file)