def download(self, reference, package_ids, remote=None):
""" 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
"""
assert (isinstance(reference, ConanFileReference))
remote_proxy = ConanProxy(self._client_cache, self._user_io,
self._remote_manager, remote)
package = remote_proxy.search(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
remote_proxy.get_recipe(reference)
if package_ids:
remote_proxy.download_packages(reference, package_ids)
else:
self._user_io.out.info("Getting the complete package list "
"from '%s'..." % str(reference))
packages_props = remote_proxy.search_packages(reference, None)
if not packages_props:
output = ScopedOutput(str(reference), self._user_io.out)
output.warn("No remote binary packages found in remote")
else:
remote_proxy.download_packages(reference,
list(packages_props.keys()))
def copy(self, reference, package_ids, username, channel, force=False):
""" Copy or move conanfile (exported) and packages to another user and or channel
@param reference: ConanFileReference containing the packages to be moved
@param package_ids: list of ids or [] for all list
@param username: Destination username
@param channel: Destination channel
@param remote: install only from that remote
"""
# It is necessary to make sure the sources are complete before proceeding
remote_proxy = ConanProxy(self._client_cache, self._user_io,
self._remote_manager, None)
# Now we can actually copy
conan_file_path = self._client_cache.conanfile(reference)
conanfile = load_conanfile_class(conan_file_path)
remote_proxy.complete_recipe_sources(reference,
short_paths=conanfile.short_paths)
copier = PackageCopier(self._client_cache, self._user_io,
conanfile.short_paths)
if not package_ids:
packages = self._client_cache.packages(reference)
if os.path.exists(packages):
package_ids = os.listdir(packages)
else:
package_ids = []
copier.copy(reference, package_ids, username, channel, force)
def __init__(self, client_cache, user_io, remote_manager, remote,
recorder):
self._client_cache = client_cache
self._user_io = user_io
self._remote_proxy = ConanProxy(self._client_cache, self._user_io,
remote_manager, remote, recorder)
self._cache_search = DiskSearchManager(self._client_cache)
def get_path(self, reference, package_id=None, path=None, remote=None):
remote_proxy = ConanProxy(self._client_cache, self._user_io, self._remote_manager, remote)
if not path and not package_id:
path = "conanfile.py"
elif not path and package_id:
path = "conaninfo.txt"
return remote_proxy.get_path(reference, package_id, path), path
def user(self, remote=None, name=None, password=None):
remote_proxy = ConanProxy(self._client_cache, self._user_io, self._remote_manager, remote)
if password == "":
if not remote:
remote = remote_proxy.registry.default_remote.name
name, password = self._user_io.request_login(remote_name=remote, username=name)
return remote_proxy.authenticate(name, password)
def __init__(self, client_cache, user_io, remote_manager, search_manager,
remote):
self._client_cache = client_cache
self._user_io = user_io
self._remote_proxy = ConanProxy(self._client_cache, self._user_io,
remote_manager, remote)
self._search_manager = search_manager
def _prepare_sources(client_cache, user_io, remote_manager, reference):
remote_proxy = ConanProxy(client_cache, user_io, remote_manager, None)
conan_file_path = client_cache.conanfile(reference)
conanfile = load_conanfile_class(conan_file_path)
remote_proxy.complete_recipe_sources(conanfile,
reference,
short_paths=conanfile.short_paths)
return conanfile.short_paths
def test_returns_on_failures(self):
test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")])
servers = {"default": test_server}
class Response(object):
ok = None
status_code = None
charset = None
text = ""
headers = {}
def __init__(self, ok, status_code):
self.ok = ok
self.status_code = status_code
class BuggyRequester(object):
def __init__(self, *args, **kwargs):
pass
def get(self, *args, **kwargs):
return Response(False, 404)
client2 = TestClient(servers=servers, requester_class=BuggyRequester)
conan_ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable")
package_ref = PackageReference(conan_ref, "123123123")
registry = RemoteRegistry(client2.client_cache.registry, client2.out)
installer = ConanProxy(client2.paths, client2.user_io, client2.remote_manager,
"default", recorder=ActionRecorder(), registry=registry)
package_folder = client2.client_cache.package(package_ref)
with self.assertRaises(NotFoundException):
installer.get_recipe(conan_ref, False, False)
self.assertFalse(installer.package_available(package_ref, package_folder, True))
class BuggyRequester2(BuggyRequester):
def get(self, *args, **kwargs):
return Response(False, 500)
client2 = TestClient(servers=servers, requester_class=BuggyRequester2)
registry = RemoteRegistry(client2.client_cache.registry, client2.out)
installer = ConanProxy(client2.paths, client2.user_io, client2.remote_manager, "default",
recorder=ActionRecorder(), registry=registry)
try:
installer.get_recipe(conan_ref, False, False)
except NotFoundException:
self.assertFalse(True) # Shouldn't capture here
except ConanException:
pass
try:
installer.package_available(package_ref, package_folder, True)
except NotFoundException:
self.assertFalse(True) # Shouldn't capture here
except ConanException:
pass
def search(self, pattern_or_reference=None, remote=None, ignorecase=True, packages_query=None):
""" Print the single information saved in conan.vars about all the packages
or the packages which match with a pattern
Attributes:
pattern = string to match packages
remote = search on another origin to get packages info
packages_pattern = String query with binary
packages properties: "arch=x86 AND os=Windows"
"""
printer = Printer(self._user_io.out)
if remote:
remote_proxy = ConanProxy(self._client_cache, self._user_io, self._remote_manager,
remote)
adapter = remote_proxy
else:
adapter = self._search_manager
if isinstance(pattern_or_reference, ConanFileReference):
packages_props = adapter.search_packages(pattern_or_reference, packages_query)
ordered_packages = OrderedDict(sorted(packages_props.items()))
try:
recipe_hash = self._client_cache.load_manifest(pattern_or_reference).summary_hash
except IOError: # It could not exist in local
recipe_hash = None
printer.print_search_packages(ordered_packages, pattern_or_reference,
recipe_hash, packages_query)
else:
references = adapter.search(pattern_or_reference, ignorecase)
printer.print_search_recipes(references, pattern_or_reference)
def _get_graph(self, reference, current_path, remote, options, settings,
filename, update, check_updates, manifest_manager, scopes,
package_settings, env, package_env):
loader = self._loader(current_path, settings, package_settings,
options, scopes, env, package_env)
# Not check for updates for info command, it'll be checked when dep graph is built
remote_proxy = ConanProxy(self._client_cache,
self._user_io,
self._remote_manager,
remote,
update=update,
check_updates=check_updates,
manifest_manager=manifest_manager)
if isinstance(reference, ConanFileReference):
project_reference = None
conanfile = loader.load_virtual(reference, current_path)
is_txt = True
else:
conanfile_path = reference
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
local_search = None if update else self._search_manager
resolver = RequireResolver(self._user_io.out, local_search,
remote_proxy)
builder = DepsGraphBuilder(remote_proxy, self._user_io.out, loader,
resolver)
deps_graph = builder.load(None, conanfile)
# These lines are so the conaninfo stores the correct complete info
if is_txt:
conanfile.info.settings = loader._settings.values
conanfile.info.full_settings = loader._settings.values
conanfile.info.scope = self._current_scopes
conanfile.cpp_info = CppInfo(current_path)
conanfile.env_info = EnvInfo(current_path)
registry = RemoteRegistry(self._client_cache.registry,
self._user_io.out)
return (builder, deps_graph, project_reference, registry, conanfile,
remote_proxy, loader)
def package_files(self, reference, source_folder, build_folder,
package_folder, profile, force):
""" Bundle pre-existing binaries
@param reference: ConanFileReference
"""
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))
current_path = package_folder
remote_proxy = ConanProxy(self._client_cache,
self._user_io,
self._remote_manager,
remote_name=None,
update=False,
check_updates=False,
manifest_manager=None)
loader = self.get_loader(profile)
conanfile = loader.load_virtual([reference], current_path)
graph_builder = self._get_graph_builder(loader, False, remote_proxy)
deps_graph = graph_builder.load(conanfile)
# this is a bit tricky, but works. The loading of a cache package makes the referenced
# one, the first of the first level, always existing
nodes = deps_graph.direct_requires()
_, conanfile = nodes[0]
pkg_id = conanfile.info.package_id()
self._user_io.out.info("Packaging to %s" % pkg_id)
pkg_reference = PackageReference(reference, pkg_id)
dest_package_folder = self._client_cache.package(
pkg_reference, short_paths=conanfile.short_paths)
if os.path.exists(dest_package_folder):
if force:
rmdir(dest_package_folder)
else:
raise ConanException(
"Package already exists. Please use --force, -f to overwrite it"
)
recipe_hash = self._client_cache.load_manifest(reference).summary_hash
conanfile.info.recipe_hash = recipe_hash
if source_folder or build_folder:
package_output = ScopedOutput(str(reference), self._user_io.out)
packager.create_package(conanfile,
source_folder,
build_folder,
dest_package_folder,
package_output,
local=True)
else: # we are specifying a final package
shutil.copytree(package_folder, dest_package_folder, symlinks=True)
save(os.path.join(dest_package_folder, CONANINFO),
conanfile.info.dumps())
# Create the digest for the package
digest = FileTreeManifest.create(dest_package_folder)
save(os.path.join(dest_package_folder, CONAN_MANIFEST),
str(digest))
def remove(self,
pattern,
src=False,
build_ids=None,
package_ids_filter=None,
force=False,
remote=None,
packages_query=None,
outdated=False):
""" Remove conans and/or packages
@param pattern: string to match packages
@param src: Remove src folder
@param package_ids_filter: list of ids or [] for all list
@param build_ids: list of ids or [] for all list
@param remote: search on another origin to get packages info
@param force: if True, it will be deleted without requesting anything
@param packages_query: Only if src is a reference. Query settings and options
"""
remote_proxy = ConanProxy(self._client_cache, self._user_io,
self._remote_manager, remote)
remover = ConanRemover(self._client_cache, self._search_manager,
self._user_io, remote_proxy)
remover.remove(pattern,
src,
build_ids,
package_ids_filter,
force=force,
packages_query=packages_query,
outdated=outdated)
def package_files(self, reference, path, profile):
""" Bundle pre-existing binaries
@param reference: ConanFileReference
"""
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))
current_path = path
remote_proxy = ConanProxy(self._client_cache, self._user_io, self._remote_manager,
remote_name=None, update=False, check_updates=False,
manifest_manager=None)
loader = ConanFileLoader(self._runner, self._client_cache.settings, profile)
conanfile = loader.load_virtual([reference], current_path)
graph_builder = self._get_graph_builder(loader, False, remote_proxy)
deps_graph = graph_builder.load(conanfile)
# this is a bit tricky, but works. The loading of a cache package makes the referenced
# one, the first of the first level, always existing
nodes = deps_graph.direct_requires()
_, conanfile = nodes[0]
packages_folder = self._client_cache.packages(reference)
package_folder = os.path.join(packages_folder, conanfile.info.package_id())
shutil.copytree(path, package_folder)
save(os.path.join(package_folder, CONANINFO), conanfile.info.dumps())
# Create the digest for the package
digest = FileTreeManifest.create(package_folder)
save(os.path.join(package_folder, CONAN_MANIFEST), str(digest))
def upload(self,
conan_reference_or_pattern,
package_id=None,
remote=None,
all_packages=None,
force=False,
confirm=False,
retry=0,
retry_wait=0,
skip_upload=False):
"""If package_id is provided, conan_reference_or_pattern is a ConanFileReference"""
t1 = time.time()
remote_proxy = ConanProxy(self._client_cache, self._user_io,
self._remote_manager, remote)
uploader = ConanUploader(self._client_cache, self._user_io,
remote_proxy, self._search_manager)
if package_id: # Upload package
ref = ConanFileReference.loads(conan_reference_or_pattern)
uploader.check_reference(ref)
uploader.upload_package(PackageReference(ref, package_id),
retry=retry,
retry_wait=retry_wait,
skip_upload=skip_upload)
else: # Upload conans
uploader.upload(conan_reference_or_pattern,
all_packages=all_packages,
force=force,
confirm=confirm,
retry=retry,
retry_wait=retry_wait,
skip_upload=skip_upload)
logger.debug("====> Time manager upload: %f" % (time.time() - t1))
def upload(self,
conan_reference,
package_id=None,
remote=None,
all_packages=None,
force=False):
remote_proxy = ConanProxy(self._paths, self._user_io,
self._remote_manager, remote)
uploader = ConanUploader(self._paths, self._user_io, remote_proxy)
# Load conanfile to check if the build policy is set to always
try:
conanfile_path = self._paths.conanfile(conan_reference)
output = ScopedOutput(str(conan_reference), self._user_io.out)
conan_file = self._loader().load_conan(conanfile_path,
output,
consumer=False)
except NotFoundException:
raise NotFoundException(
"There is no local conanfile exported as %s" %
str(conan_reference))
if conan_file.build_policy_always and (all_packages or package_id):
raise ConanException("Conanfile has build_policy='always', "
"no packages can be uploaded")
if package_id: # Upload package
uploader.upload_package(
PackageReference(conan_reference, package_id))
else: # Upload conans
uploader.upload_conan(conan_reference,
all_packages=all_packages,
force=force)
def search_packages(self,
reference=None,
remote=None,
packages_query=None,
outdated=False):
""" Return the single information saved in conan.vars about all the packages
or the packages which match with a pattern
Attributes:
pattern = string to match packages
remote = search on another origin to get packages info
packages_pattern = String query with binary
packages properties: "arch=x86 AND os=Windows"
"""
packages_props = self._get_search_adapter(remote).search_packages(
reference, packages_query)
ordered_packages = OrderedDict(sorted(packages_props.items()))
if remote:
remote_proxy = ConanProxy(self._client_cache, self._user_io,
self._remote_manager, remote)
remote = remote_proxy.registry.remote(remote)
manifest = self._remote_manager.get_conan_digest(reference, remote)
recipe_hash = manifest.summary_hash
else:
try:
recipe_hash = self._client_cache.load_manifest(
reference).summary_hash
except IOError: # It could not exist in local
recipe_hash = None
if outdated and recipe_hash:
ordered_packages = filter_outdated(ordered_packages, recipe_hash)
return ordered_packages, reference, recipe_hash, packages_query
def info_get_graph(self,
reference,
current_path,
profile,
remote=None,
filename=None,
check_updates=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
"""
remote_proxy = ConanProxy(self._client_cache,
self._user_io,
self._remote_manager,
remote,
update=False,
check_updates=check_updates)
deps_graph, graph_builder, conanfile = self._get_deps_graph(
reference, profile, filename, current_path, remote_proxy)
if check_updates:
graph_updates_info = graph_builder.get_graph_updates_info(
deps_graph)
else:
graph_updates_info = {}
return deps_graph, graph_updates_info, self._get_project_reference(
reference, conanfile)
def upload(self, conan_reference, package_id=None, remote=None, all_packages=None,
force=False):
t1 = time.time()
remote_proxy = ConanProxy(self._client_cache, self._user_io, self._remote_manager, remote)
uploader = ConanUploader(self._client_cache, self._user_io, remote_proxy)
# Load conanfile to check if the build policy is set to always
try:
conanfile_path = self._client_cache.conanfile(conan_reference)
conan_file = self._loader().load_class(conanfile_path)
except NotFoundException:
raise NotFoundException("There is no local conanfile exported as %s"
% str(conan_reference))
# Can't use build_policy_always here because it's not loaded (only load_class)
if conan_file.build_policy == "always" and (all_packages or package_id):
raise ConanException("Conanfile has build_policy='always', "
"no packages can be uploaded")
if package_id: # Upload package
uploader.upload_package(PackageReference(conan_reference, package_id))
else: # Upload conans
uploader.upload_conan(conan_reference, all_packages=all_packages, force=force)
logger.debug("====> Time manager upload: %f" % (time.time() - t1))
def info_get_graph(self,
reference,
profile,
remote=None,
check_updates=False):
""" Fetch and build all dependencies for the given reference
@param reference: ConanFileReference or path to user space conanfile
@param remote: install only from that remote
"""
remote_proxy = ConanProxy(self._client_cache,
self._user_io,
self._remote_manager,
remote,
update=False,
check_updates=check_updates,
recorder=self._recorder)
deps_graph, graph_builder, conanfile = self._get_deps_graph(
reference, profile, remote_proxy)
if check_updates:
graph_updates_info = graph_builder.get_graph_updates_info(
deps_graph)
else:
graph_updates_info = {}
return deps_graph, graph_updates_info, self._get_project_reference(
reference, conanfile)
def info_nodes_to_build(self, reference, profile, build_modes, remote,
check_updates):
remote_proxy = ConanProxy(self._client_cache,
self._user_io,
self._remote_manager,
remote,
update=False,
check_updates=check_updates,
recorder=self._recorder)
deps_graph, _, conanfile = self._get_deps_graph(
reference, profile, remote_proxy)
build_mode = BuildMode(build_modes, self._user_io.out)
installer = ConanInstaller(self._client_cache,
self._user_io.out,
remote_proxy,
build_mode,
None,
recorder=self._recorder)
nodes = installer.nodes_to_build(deps_graph)
counter = Counter(ref.conan.name for ref, _ in nodes)
ret = [
ref if counter[ref.conan.name] > 1 else str(ref.conan)
for ref, _ in nodes
]
return ret, self._get_project_reference(reference, conanfile)
def _get_search_adapter(self, remote):
if remote:
remote_proxy = ConanProxy(self._client_cache, self._user_io, self._remote_manager, remote)
adapter = remote_proxy
else:
adapter = self._search_manager
return adapter
def get_proxy(self, remote_name=None):
remote_proxy = ConanProxy(self._client_cache,
self._user_io,
self._remote_manager,
remote_name=remote_name,
recorder=self._recorder,
registry=self._registry)
return remote_proxy
def search(self,
pattern=None,
remote=None,
ignorecase=True,
verbose=False,
extra_verbose=False,
package_pattern=None):
""" Print the single information saved in conan.vars about all the packages
or the packages which match with a pattern
Attributes:
pattern = string to match packages
remote = search on another origin to get packages info
"""
if remote:
remote_proxy = ConanProxy(self._paths, self._user_io,
self._remote_manager, remote)
info = remote_proxy.search(pattern, ignorecase)
else:
info = self.file_manager.search(pattern, ignorecase)
filtered_info = info
# Filter packages if package_pattern
if package_pattern:
try:
# Prepare ER to be more user natural
if ".*" not in package_pattern:
package_pattern = package_pattern.replace("*", ".*")
# Compile expression
package_pattern = re.compile(package_pattern, re.IGNORECASE)
filtered_info = SearchInfo()
for conan_ref, packages in sorted(info.items()):
filtered_packages = {
pid: data
for pid, data in packages.items()
if package_pattern.match(pid)
}
if filtered_packages:
filtered_info[conan_ref] = filtered_packages
except Exception: # Invalid pattern
raise ConanException("Invalid package pattern")
printer = Printer(self._user_io.out)
printer.print_search(filtered_info, pattern, verbose, extra_verbose)
def export_pkg(self, reference, source_folder, build_folder,
package_folder, install_folder, profile, force):
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))
remote_proxy = ConanProxy(self._client_cache,
self._user_io,
self._remote_manager,
remote_name=None,
update=False,
check_updates=False,
manifest_manager=None,
recorder=self._recorder)
loader = self.get_loader(profile)
conanfile = loader.load_virtual([reference], scope_options=True)
if install_folder and existing_info_files(install_folder):
_load_deps_info(install_folder, conanfile, required=True)
graph_builder = self._get_graph_builder(loader, False, remote_proxy)
deps_graph = graph_builder.load(conanfile)
# this is a bit tricky, but works. The loading of a cache package makes the referenced
# one, the first of the first level, always existing
nodes = deps_graph.direct_requires()
_, conanfile = nodes[0]
pkg_id = conanfile.info.package_id()
self._user_io.out.info("Packaging to %s" % pkg_id)
pkg_reference = PackageReference(reference, pkg_id)
dest_package_folder = self._client_cache.package(
pkg_reference, short_paths=conanfile.short_paths)
if os.path.exists(dest_package_folder):
if force:
rmdir(dest_package_folder)
else:
raise ConanException(
"Package already exists. Please use --force, -f to "
"overwrite it")
recipe_hash = self._client_cache.load_manifest(reference).summary_hash
conanfile.info.recipe_hash = recipe_hash
conanfile.develop = True
package_output = ScopedOutput(str(reference), self._user_io.out)
if package_folder:
packager.export_pkg(conanfile, package_folder, dest_package_folder,
package_output)
else:
packager.create_package(conanfile,
source_folder,
build_folder,
dest_package_folder,
install_folder,
package_output,
local=True)
def remove(self, pattern, src=False, build_ids=None, package_ids_filter=None, force=False,
remote=None):
""" Remove conans and/or packages
@param pattern: string to match packages
@param package_ids: list of ids or [] for all list
@param remote: search on another origin to get packages info
@param force: if True, it will be deleted without requesting anything
"""
remote_proxy = ConanProxy(self._paths, self._user_io, self._remote_manager, remote)
remover = ConanRemover(self.file_manager, self._user_io, remote_proxy)
remover.remove(pattern, src, build_ids, package_ids_filter, force=force)
def info_build_order(self, reference, profile, filename, build_order,
remote, check_updates, cwd):
remote_proxy = ConanProxy(self._client_cache,
self._user_io,
self._remote_manager,
remote,
update=False,
check_updates=check_updates)
deps_graph, _, _ = self._get_deps_graph(reference, profile, filename,
cwd, remote_proxy)
result = deps_graph.build_order(build_order)
return result
def copy(self, reference, package_ids, username, channel, force=False):
""" Copy or move conanfile (exported) and packages to another user and or channel
@param reference: ConanFileReference containing the packages to be moved
@param package_ids: list of ids or [] for all list
@param username: Destination username
@param channel: Destination channel
@param remote: install only from that remote
"""
# It is necessary to make sure the sources are complete before proceeding
remote_proxy = ConanProxy(self._client_cache, self._user_io, self._remote_manager, None)
remote_proxy.complete_recipe_sources(reference)
# Now we can actually copy
conan_file_path = self._client_cache.conanfile(reference)
conanfile = load_conanfile_class(conan_file_path)
copier = PackageCopier(self._client_cache, self._user_io, conanfile.short_paths)
if not package_ids:
packages = self._client_cache.packages(reference)
if os.path.exists(packages):
package_ids = os.listdir(packages)
else:
package_ids = []
copier.copy(reference, package_ids, username, channel, force)
def search(self, pattern=None, remote=None, ignorecase=True,
verbose=False, extra_verbose=False, package_pattern=None):
""" Print the single information saved in conan.vars about all the packages
or the packages which match with a pattern
Attributes:
pattern = string to match packages
remote = search on another origin to get packages info
"""
if remote:
remote_proxy = ConanProxy(self._paths, self._user_io, self._remote_manager, remote)
info = remote_proxy.search(pattern, ignorecase)
else:
info = self.file_manager.search(pattern, ignorecase)
filtered_info = info
# Filter packages if package_pattern
if package_pattern:
try:
# Prepare ER to be more user natural
if ".*" not in package_pattern:
package_pattern = package_pattern.replace("*", ".*")
# Compile expression
package_pattern = re.compile(package_pattern, re.IGNORECASE)
filtered_info = SearchInfo()
for conan_ref, packages in sorted(info.items()):
filtered_packages = {pid: data for pid, data in packages.items()
if package_pattern.match(pid)}
if filtered_packages:
filtered_info[conan_ref] = filtered_packages
except Exception: # Invalid pattern
raise ConanException("Invalid package pattern")
printer = Printer(self._user_io.out)
printer.print_search(filtered_info, pattern, verbose, extra_verbose)
def upload(self,
conan_reference,
package_id=None,
remote=None,
all_packages=None,
force=False):
remote_proxy = ConanProxy(self._paths, self._user_io,
self._remote_manager, remote)
uploader = ConanUploader(self._paths, self._user_io, remote_proxy)
if package_id: # Upload package
uploader.upload_package(
PackageReference(conan_reference, package_id))
else: # Upload conans
uploader.upload_conan(conan_reference,
all_packages=all_packages,
force=force)
def download(self, reference, package_ids, remote=None):
""" 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
"""
assert(isinstance(reference, ConanFileReference))
remote_proxy = ConanProxy(self._client_cache, self._user_io, self._remote_manager, remote)
if package_ids:
remote_proxy.download_packages(reference, package_ids)
else: # Not specified packages, download all
packages_props = remote_proxy.search_packages(reference, None)
if not packages_props: # No filter by properties
raise ConanException("'%s' not found in remote" % str(reference))
remote_proxy.download_packages(reference, list(packages_props.keys()))
def download(self, reference, package_ids, remote=None):
""" 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
"""
assert(isinstance(reference, ConanFileReference))
remote_proxy = ConanProxy(self._paths, self._user_io, self._remote_manager, remote)
if package_ids:
remote_proxy.download_packages(reference, package_ids)
else: # Not specified packages, download all
info = remote_proxy.search(str(reference), ignorecase=False)
if reference not in info:
remote = remote or self._remote_manager.default_remote
raise ConanException("'%s' not found in remote '%s'" % (str(reference), remote))
remote_proxy.download_packages(reference, list(info[reference].keys()))
def download(self, reference, package_ids, remote=None):
""" 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
"""
assert(isinstance(reference, ConanFileReference))
remote_proxy = ConanProxy(self._client_cache, self._user_io, self._remote_manager, remote)
if package_ids:
remote_proxy.download_packages(reference, package_ids)
else: # Not specified packages, download all
packages_props = remote_proxy.search_packages(reference, None)
if not packages_props: # No filter by properties
raise ConanException("'%s' not found in remote" % str(reference))
remote_proxy.download_packages(reference, list(packages_props.keys()))
def download(self, reference, package_ids, remote=None):
""" 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
"""
assert(isinstance(reference, ConanFileReference))
remote_proxy = ConanProxy(self._paths, self._user_io, self._remote_manager, remote)
if package_ids:
remote_proxy.download_packages(reference, package_ids)
else: # Not specified packages, download all
info = remote_proxy.search(str(reference), ignorecase=False)
if reference not in info:
remote = remote or self._remote_manager.default_remote
raise ConanException("'%s' not found in remote '%s'" % (str(reference), remote))
remote_proxy.download_packages(reference, list(info[reference].keys()))
def download(self, reference, package_ids, remote=None):
""" 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
"""
assert(isinstance(reference, ConanFileReference))
remote_proxy = ConanProxy(self._client_cache, self._user_io, self._remote_manager, remote)
package = remote_proxy.search(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))
if package_ids:
remote_proxy.download_packages(reference, package_ids)
else:
packages_props = remote_proxy.search_packages(reference, None)
if not packages_props:
output = ScopedOutput(str(reference), self._user_io.out)
output.warn("No remote binary packages found in remote")
else:
remote_proxy.download_packages(reference, list(packages_props.keys()))
def user(self, remote=None, name=None, password=None):
remote_proxy = ConanProxy(self._client_cache, self._user_io,
self._remote_manager, remote)
return remote_proxy.authenticate(name, password)
def complete_test(self):
""" basic installation of a new conans
"""
servers = {}
# All can write (for avoid authentication until we mock user_io)
test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")])
servers["default"] = test_server
conan_digest = FileTreeManifest(123123123, {})
client = TestClient(servers=servers)
client.init_dynamic_vars()
conan_ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable")
reg_folder = client.paths.export(conan_ref)
files = hello_source_files()
client.save(files, path=reg_folder)
client.save({CONANFILE: myconan1,
CONAN_MANIFEST: str(conan_digest),
"include/math/lib1.h": "//copy",
"my_lib/debug/libd.a": "//copy",
"my_data/readme.txt": "//copy"}, path=reg_folder)
package_ref = PackageReference(conan_ref, "fakeid")
package_folder = client.paths.package(package_ref)
save(os.path.join(package_folder, "include", "lib1.h"), "//header")
save(os.path.join(package_folder, "lib", "my_lib", "libd.a"), "//lib")
save(os.path.join(package_folder, "res", "shares", "readme.txt"),
"//res")
client.run("upload %s" % str(conan_ref))
client.run("upload %s -p %s" % (str(conan_ref), package_ref.package_id))
client2 = TestClient(servers=servers)
client2.init_dynamic_vars()
installer = ConanProxy(client2.paths,
client2.user_io,
client2.remote_manager,
"default")
installer.get_conanfile(conan_ref)
installer.get_package(package_ref, force_build=False)
reg_path = client2.paths.export(ConanFileReference.loads("Hello/1.2.1/frodo/stable"))
pack_folder = client2.paths.package(package_ref)
# Test the file in the downloaded conans
files = ['CMakeLists.txt',
'my_lib/debug/libd.a',
'hello.cpp',
'hello0.h',
CONANFILE,
CONAN_MANIFEST,
'main.cpp',
'include/math/lib1.h',
'my_data/readme.txt']
for _file in files:
self.assertTrue(os.path.exists(os.path.join(reg_path, _file)))
self.assertTrue(os.path.exists(pack_folder))
# Test the file in the downloaded package
self.assertTrue(os.path.exists(pack_folder))
self.assertTrue(os.path.exists(os.path.join(pack_folder, "include",
"lib1.h")))
self.assertTrue(os.path.exists(os.path.join(pack_folder, "lib",
"my_lib/libd.a")))
self.assertTrue(os.path.exists(os.path.join(pack_folder, "res",
"shares/readme.txt")))
def install(self,
reference,
current_path,
profile,
remote=None,
build_modes=None,
filename=None,
update=False,
manifest_folder=None,
manifest_verify=False,
manifest_interactive=False,
generators=None,
no_imports=False,
inject_require=None):
""" Fetch and build all dependencies for the given reference
@param reference: ConanFileReference or path to user space conanfile
@param current_path: where the output files will be saved
@param remote: install only from that remote
@param profile: Profile object with both the -s introduced options and profile readed values
@param build_modes: List of build_modes specified
@param filename: Optional filename of the conanfile
@param update: Check for updated in the upstream remotes (and update)
@param manifest_folder: Folder to install the manifests
@param manifest_verify: Verify dependencies manifests against stored ones
@param manifest_interactive: Install deps manifests in folder for later verify, asking user for confirmation
@param generators: List of generators from command line
@param no_imports: Install specified packages but avoid running imports
"""
generators = generators or []
manifest_manager = ManifestManager(
manifest_folder,
user_io=self._user_io,
client_cache=self._client_cache,
verify=manifest_verify,
interactive=manifest_interactive) if manifest_folder else None
remote_proxy = ConanProxy(self._client_cache,
self._user_io,
self._remote_manager,
remote,
update=update,
check_updates=False,
manifest_manager=manifest_manager)
loader = ConanFileLoader(self._runner, self._client_cache.settings,
self._profile_with_defaults(profile))
conanfile = self._get_conanfile_object(loader, reference, filename,
current_path)
if inject_require:
self._inject_require(conanfile, inject_require)
graph_builder = self._get_graph_builder(loader, update, remote_proxy)
deps_graph = graph_builder.load(conanfile)
# This line is so the conaninfo stores the correct complete info
conanfile.info.scope = profile.scopes
registry = RemoteRegistry(self._client_cache.registry,
self._user_io.out)
if inject_require:
output = ScopedOutput("%s test package" % str(inject_require),
self._user_io.out)
output.info("Installing dependencies")
elif not isinstance(reference, ConanFileReference):
output = ScopedOutput("PROJECT", self._user_io.out)
Printer(self._user_io.out).print_graph(deps_graph, registry)
else:
output = ScopedOutput(str(reference), self._user_io.out)
output.highlight("Installing package")
try:
if loader._settings.os and detected_os() != loader._settings.os:
message = "Cross-platform from '%s' to '%s'" % (
detected_os(), loader._settings.os)
self._user_io.out.writeln(message, Color.BRIGHT_MAGENTA)
except ConanException: # Setting os doesn't exist
pass
build_mode = BuildMode(build_modes, self._user_io.out)
build_requires = BuildRequires(loader, graph_builder, registry, output,
profile.build_requires)
installer = ConanInstaller(self._client_cache, output, remote_proxy,
build_mode, build_requires)
# Apply build_requires to consumer conanfile
if not isinstance(reference, ConanFileReference):
build_requires.install("", conanfile, installer)
installer.install(deps_graph, current_path)
build_mode.report_matches()
# Write generators
tmp = list(
conanfile.generators) # Add the command line specified generators
tmp.extend([g for g in generators if g not in tmp])
conanfile.generators = tmp
write_generators(conanfile, current_path, output)
if not isinstance(reference, ConanFileReference):
content = normalize(conanfile.info.dumps())
save(os.path.join(current_path, CONANINFO), content)
output.info("Generated %s" % CONANINFO)
if not no_imports:
run_imports(conanfile, current_path, output)
installer.call_system_requirements(conanfile, output)
if manifest_manager:
manifest_manager.print_log()
def install(self, reference, current_path, remote=None, options=None, settings=None,
build_mode=False, info=None, filename=None, 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 user(self, remote=None, name=None, password=None):
remote_proxy = ConanProxy(self._paths, self._user_io, self._remote_manager, remote)
return remote_proxy.authenticate(name, password)
def complete_test(self):
""" basic installation of a new conans
"""
servers = {}
# All can write (for avoid authentication until we mock user_io)
test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")])
servers["default"] = test_server
conan_digest = FileTreeManifest(123123123, {})
client = TestClient(servers=servers)
client.init_dynamic_vars()
conan_ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable")
reg_folder = client.paths.export(conan_ref)
files = hello_source_files()
client.save(files, path=reg_folder)
client.save({CONANFILE: myconan1,
CONAN_MANIFEST: str(conan_digest),
"include/math/lib1.h": "//copy",
"my_lib/debug/libd.a": "//copy",
"my_data/readme.txt": "//copy"}, path=reg_folder)
package_ref = PackageReference(conan_ref, "fakeid")
package_folder = client.paths.package(package_ref)
save(os.path.join(package_folder, CONANINFO), "info")
save(os.path.join(package_folder, CONAN_MANIFEST), "manifest")
save(os.path.join(package_folder, "include", "lib1.h"), "//header")
save(os.path.join(package_folder, "lib", "my_lib", "libd.a"), "//lib")
save(os.path.join(package_folder, "res", "shares", "readme.txt"),
"//res")
digest_path = client.client_cache.digestfile_package(package_ref)
expected_manifest = FileTreeManifest.create(os.path.dirname(digest_path))
save(os.path.join(package_folder, CONAN_MANIFEST), str(expected_manifest))
client.run("upload %s" % str(conan_ref))
client.run("upload %s -p %s" % (str(conan_ref), package_ref.package_id))
client2 = TestClient(servers=servers)
client2.init_dynamic_vars()
installer = ConanProxy(client2.paths, client2.user_io, client2.remote_manager, "default")
installer.get_recipe(conan_ref)
installer.get_package(package_ref, force_build=False, short_paths=False, check_outdated=False)
# Check that the output is done in order
lines = [line.strip() for line in str(client2.user_io.out).splitlines()
if line.startswith("Downloading")]
self.assertEqual(lines, ["Downloading conanmanifest.txt",
"Downloading conanfile.py",
"Downloading conan_export.tgz",
"Downloading conanmanifest.txt",
"Downloading conaninfo.txt",
"Downloading conan_package.tgz"
])
reg_path = client2.paths.export(ConanFileReference.loads("Hello/1.2.1/frodo/stable"))
pack_folder = client2.paths.package(package_ref)
# Test the file in the downloaded conans
files = ['CMakeLists.txt',
'my_lib/debug/libd.a',
'hello.cpp',
'hello0.h',
CONANFILE,
CONAN_MANIFEST,
'main.cpp',
'include/math/lib1.h',
'my_data/readme.txt']
for _file in files:
self.assertTrue(os.path.exists(os.path.join(reg_path, _file)))
self.assertTrue(os.path.exists(pack_folder))
# Test the file in the downloaded package
self.assertTrue(os.path.exists(pack_folder))
self.assertTrue(os.path.exists(os.path.join(pack_folder, "include",
"lib1.h")))
self.assertTrue(os.path.exists(os.path.join(pack_folder, "lib",
"my_lib/libd.a")))
self.assertTrue(os.path.exists(os.path.join(pack_folder, "res",
"shares/readme.txt")))
