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 _handle_node_cache(self, node, keep_build, processed_package_references, remotes): pref = node.pref assert pref.id, "Package-ID without value" assert pref.id != PACKAGE_ID_UNKNOWN, "Package-ID error: %s" % str(pref) conanfile = node.conanfile output = conanfile.output layout = self._cache.package_layout(pref.ref, conanfile.short_paths) package_folder = layout.package(pref) with layout.package_lock(pref): if pref not in processed_package_references: processed_package_references.add(pref) if node.binary == BINARY_BUILD: assert node.prev is None, "PREV for %s to be built should be None" % str(pref) with set_dirty_context_manager(package_folder): pref = self._build_package(node, output, keep_build, remotes) assert node.prev, "Node PREV shouldn't be empty" assert node.pref.revision, "Node PREF revision shouldn't be empty" assert pref.revision is not None, "PREV for %s to be built is None" % str(pref) elif node.binary in (BINARY_UPDATE, BINARY_DOWNLOAD): # this can happen after a re-evaluation of packageID with Package_ID_unknown self._download_pkg(layout, node.pref, node) elif node.binary == BINARY_CACHE: assert node.prev, "PREV for %s is None" % str(pref) output.success('Already installed!') log_package_got_from_local_cache(pref) self._recorder.package_fetched_from_cache(pref) # Call the info method self._call_package_info(conanfile, package_folder, ref=pref.ref) self._recorder.package_cpp_info(pref, conanfile.cpp_info)
def _handle_node_cache(self, node, package_ref, keep_build, processed_package_references): conan_ref, conan_file = node.conan_ref, node.conanfile output = ScopedOutput(str(conan_ref), self._out) package_folder = self._client_cache.package(package_ref, conan_file.short_paths) with self._client_cache.package_lock(package_ref): if package_ref not in processed_package_references: processed_package_references.add(package_ref) set_dirty(package_folder) if node.binary == BINARY_BUILD: self._build_package(node, package_ref, output, keep_build) elif node.binary in (BINARY_UPDATE, BINARY_DOWNLOAD): self._remote_manager.get_package(package_ref, package_folder, node.binary_remote, output, self._recorder) if node.binary_remote != node.remote: self._registry.set_ref(conan_ref, node.binary_remote.name) elif node.binary == BINARY_CACHE: output.success('Already installed!') log_package_got_from_local_cache(package_ref) self._recorder.package_fetched_from_cache(package_ref) clean_dirty(package_folder) # Call the info method self._call_package_info(conan_file, package_folder)
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_cache(self, node, keep_build, processed_package_references): pref = node.pref conan_file = node.conanfile output = conan_file.output package_folder = self._cache.package(pref, conan_file.short_paths) with self._cache.package_lock(pref): if pref not in processed_package_references: processed_package_references.add(pref) if node.binary == BINARY_BUILD: set_dirty(package_folder) self._build_package(node, pref, output, keep_build) clean_dirty(package_folder) elif node.binary in (BINARY_UPDATE, BINARY_DOWNLOAD): if not self._node_concurrently_installed(node, package_folder): set_dirty(package_folder) assert pref.revision is not None, "Installer should receive #PREV always" self._remote_manager.get_package(pref, package_folder, node.binary_remote, output, self._recorder) self._registry.prefs.set(pref, node.binary_remote.name) clean_dirty(package_folder) else: output.success('Download skipped. Probable concurrent download') log_package_got_from_local_cache(pref) self._recorder.package_fetched_from_cache(pref) elif node.binary == BINARY_CACHE: output.success('Already installed!') log_package_got_from_local_cache(pref) self._recorder.package_fetched_from_cache(pref) # Call the info method self._call_package_info(conan_file, package_folder) self._recorder.package_cpp_info(pref, conan_file.cpp_info)
def get_package(conanfile, package_ref, package_folder, output, recorder, proxy, update): # TODO: This access to proxy attributes has to be improved remote_manager = proxy._remote_manager registry = proxy.registry try: if update: _remove_if_outdated(package_folder, package_ref, proxy, output) local_package = os.path.exists(package_folder) if local_package: output.success('Already installed!') log_package_got_from_local_cache(package_ref) recorder.package_fetched_from_cache(package_ref) return False else: remote = registry.get_ref(package_ref.conan) # remote will be defined, as package availability has been checked from installer remote_manager.get_package(conanfile, package_ref, package_folder, remote, output, recorder) if get_env("CONAN_READ_ONLY_CACHE", False): make_read_only(package_folder) recorder.package_downloaded(package_ref, remote.url) return True except BaseException as e: output.error("Exception while getting package: %s" % str(package_ref.package_id)) output.error("Exception: %s %s" % (type(e), str(e))) _clean_package(package_folder, output) raise
def _handle_node_cache(self, node, keep_build, processed_package_references, remotes): pref = node.pref assert pref.id, "Package-ID without value" conanfile = node.conanfile output = conanfile.output package_folder = self._cache.package_layout( pref.ref, conanfile.short_paths).package(pref) with self._cache.package_layout(pref.ref).package_lock(pref): if pref not in processed_package_references: processed_package_references.add(pref) if node.binary == BINARY_BUILD: assert node.prev is None, "PREV for %s to be built should be None" % str( pref) with set_dirty_context_manager(package_folder): pref = self._build_package(node, output, keep_build, remotes) assert node.prev, "Node PREV shouldn't be empty" assert node.pref.revision, "Node PREF revision shouldn't be empty" assert node.prev is not None, "PREV for %s to be built is None" % str( pref) assert pref.revision is not None, "PREV for %s to be built is None" % str( pref) elif node.binary in (BINARY_UPDATE, BINARY_DOWNLOAD): assert node.prev, "PREV for %s is None" % str(pref) # not really concurrently, but a different node with same pref if not self._node_concurrently_installed( node, package_folder): with set_dirty_context_manager(package_folder): assert pref.revision is not None, \ "Installer should receive #PREV always" self._remote_manager.get_package( pref, package_folder, node.binary_remote, output, self._recorder) output.info("Downloaded package revision %s" % pref.revision) with self._cache.package_layout( pref.ref).update_metadata() as metadata: metadata.packages[ pref.id].remote = node.binary_remote.name else: output.success( 'Download skipped. Probable concurrent download') log_package_got_from_local_cache(pref) self._recorder.package_fetched_from_cache(pref) elif node.binary == BINARY_CACHE: assert node.prev, "PREV for %s is None" % str(pref) output.success('Already installed!') log_package_got_from_local_cache(pref) self._recorder.package_fetched_from_cache(pref) # Call the info method self._call_package_info(conanfile, package_folder, ref=pref.ref) self._recorder.package_cpp_info(pref, conanfile.cpp_info)
def _handle_node_cache(self, node, keep_build, processed_package_references, remotes): pref = node.pref assert pref.id, "Package-ID without value" assert pref.id != PACKAGE_ID_UNKNOWN, "Package-ID error: %s" % str( pref) conanfile = node.conanfile output = conanfile.output layout = self._cache.package_layout(pref.ref, conanfile.short_paths) with layout.package_lock(pref): bare_pref = PackageReference(pref.ref, pref.id) processed_prev = processed_package_references.get(bare_pref) if processed_prev is None: # This package-id has not been processed before if node.binary == BINARY_BUILD: assert node.prev is None, "PREV for %s to be built should be None" % str( pref) layout.package_remove(pref) with layout.set_dirty_context_manager(pref): pref = self._build_package(node, output, keep_build, remotes) assert node.prev, "Node PREV shouldn't be empty" assert node.pref.revision, "Node PREF revision shouldn't be empty" assert pref.revision is not None, "PREV for %s to be built is None" % str( pref) elif node.binary in (BINARY_UPDATE, BINARY_DOWNLOAD): # this can happen after a re-evaluation of packageID with Package_ID_unknown self._download_pkg(layout, node) elif node.binary == BINARY_CACHE: assert node.prev, "PREV for %s is None" % str(pref) output.success('Already installed!') log_package_got_from_local_cache(pref) self._recorder.package_fetched_from_cache(pref) processed_package_references[bare_pref] = node.prev else: # We need to update the PREV of this node, as its processing has been skipped, # but it could be that another node with same PREF was built and obtained a new PREV node.prev = processed_prev package_folder = layout.package(pref) assert os.path.isdir(package_folder), ( "Package '%s' folder must exist: %s\n" % (str(pref), package_folder)) # Call the info method conanfile.folders.set_base_package(package_folder) conanfile.folders.set_base_source(None) conanfile.folders.set_base_build(None) conanfile.folders.set_base_install(None) self._call_package_info(conanfile, package_folder, ref=pref.ref, is_editable=False) self._recorder.package_cpp_info(pref, conanfile.cpp_info)