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)
