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")
registry = RemoteRegistry(client2.client_cache.registry, client2.out)
installer = ConanProxy(client2.paths,
client2.user_io.out,
client2.remote_manager,
registry=registry)
with self.assertRaises(NotFoundException):
installer.get_recipe(conan_ref, False, False, None,
ActionRecorder())
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.out,
client2.remote_manager,
registry=registry)
try:
installer.get_recipe(conan_ref, False, False, None,
ActionRecorder())
except NotFoundException:
self.assertFalse(True) # Shouldn't capture here
except ConanException:
pass
def add_remove_update_test(self):
f = os.path.join(temp_folder(), "aux_file")
registry = RemoteRegistry(f, TestBufferConanOutput())
# Add
registry.add("local", "http://localhost:9300")
self.assertEqual(registry.remotes,
[("conan.io", "https://server.conan.io"),
("local", "http://localhost:9300")])
# Add
registry.add("new", "new_url")
self.assertEqual(registry.remotes,
[("conan.io", "https://server.conan.io"),
("local", "http://localhost:9300"),
("new", "new_url")])
with self.assertRaises(ConanException):
registry.add("new", "new_url")
# Update
registry.update("new", "other_url")
self.assertEqual(registry.remotes,
[("conan.io", "https://server.conan.io"),
("local", "http://localhost:9300"),
("new", "other_url")])
with self.assertRaises(ConanException):
registry.update("new2", "new_url")
# Remove
registry.remove("local")
self.assertEqual(registry.remotes,
[("conan.io", "https://server.conan.io"),
("new", "other_url")])
with self.assertRaises(ConanException):
registry.remove("new2")
def add_remove_update_test(self):
f = os.path.join(temp_folder(), "aux_file")
save(f, dump_registry(default_remotes, {}, {}))
registry = RemoteRegistry(f, TestBufferConanOutput())
# Add
registry.remotes.add("local", "http://localhost:9300")
self.assertEqual(registry.remotes.list, [("conan-center", "https://conan.bintray.com", True),
("local", "http://localhost:9300", True)])
# Add
registry.remotes.add("new", "new_url", False)
self.assertEqual(registry.remotes.list, [("conan-center", "https://conan.bintray.com", True),
("local", "http://localhost:9300", True),
("new", "new_url", False)])
with self.assertRaises(ConanException):
registry.remotes.add("new", "new_url")
# Update
registry.remotes.update("new", "other_url")
self.assertEqual(registry.remotes.list, [("conan-center", "https://conan.bintray.com", True),
("local", "http://localhost:9300", True),
("new", "other_url", True)])
with self.assertRaises(ConanException):
registry.remotes.update("new2", "new_url")
registry.remotes.update("new", "other_url", False)
self.assertEqual(registry.remotes.list, [("conan-center", "https://conan.bintray.com", True),
("local", "http://localhost:9300", True),
("new", "other_url", False)])
# Remove
registry.remotes.remove("local")
self.assertEqual(registry.remotes.list, [("conan-center", "https://conan.bintray.com", True),
("new", "other_url", False)])
with self.assertRaises(ConanException):
registry.remotes.remove("new2")
def _install(self, references):
self._output.info("Installing build requires: [%s]" %
", ".join(str(r) for r in references))
conanfile = self._loader.load_virtual(
references, None, scope_options=False) # No need current path
# FIXME: Forced update=True, build_mode, Where to define it?
update = False
local_search = None if update else self._search_manager
resolver = RequireResolver(self._output, local_search,
self._remote_proxy)
graph_builder = DepsGraphBuilder(self._remote_proxy, self._output,
self._loader, resolver)
deps_graph = graph_builder.load(conanfile)
registry = RemoteRegistry(self._client_cache.registry, self._output)
Printer(self._output).print_graph(deps_graph, registry)
# Make sure we recursively do not propagate the "*" pattern
build_requires = copy.copy(self)
build_requires._build_requires = self._build_requires.copy()
build_requires._build_requires.pop("*", None)
build_requires._build_requires.pop("&!", None)
installer = ConanInstaller(self._client_cache, self._output,
self._remote_proxy, build_requires)
installer.install(deps_graph, self._build_modes, self._current_path)
self._output.info("Installed build requires: [%s]" %
", ".join(str(r) for r in references))
return deps_graph
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 _check(self, install_path):
settings_path = self.client.client_cache.settings_path
self.assertEqual(load(settings_path).splitlines(), settings_yml.splitlines())
registry_path = self.client.client_cache.registry
registry = RemoteRegistry(registry_path, TestBufferConanOutput())
self.assertEqual(registry.remotes,
[Remote("myrepo1", "https://myrepourl.net", False),
Remote("my-repo-2", "https://myrepo2.com", True),
])
self.assertEqual(registry.refs, {"MyPkg/0.1@user/channel": "my-repo-2"})
self.assertEqual(sorted(os.listdir(self.client.client_cache.profiles_path)),
sorted(["default", "linux", "windows"]))
self.assertEqual(load(os.path.join(self.client.client_cache.profiles_path, "linux")).splitlines(),
linux_profile.splitlines())
self.assertEqual(load(os.path.join(self.client.client_cache.profiles_path, "windows")).splitlines(),
win_profile.splitlines())
conan_conf = ConanClientConfigParser(self.client.client_cache.conan_conf_path)
self.assertEqual(conan_conf.get_item("log.run_to_output"), "False")
self.assertEqual(conan_conf.get_item("log.run_to_file"), "False")
self.assertEqual(conan_conf.get_item("log.level"), "10")
self.assertEqual(conan_conf.get_item("general.compression_level"), "6")
self.assertEqual(conan_conf.get_item("general.sysrequires_sudo"), "True")
self.assertEqual(conan_conf.get_item("general.cpu_count"), "1")
self.assertEqual(conan_conf.get_item("general.config_install"), install_path)
self.assertEqual(conan_conf.get_item("proxies.no_proxy"), "mylocalhost")
self.assertEqual(conan_conf.get_item("proxies.https"), "None")
self.assertEqual(conan_conf.get_item("proxies.http"), "http://*****:*****@10.10.1.10:3128/")
self.assertEqual("#Custom pylint",
load(os.path.join(self.client.client_cache.conan_folder, "pylintrc")))
def __init__(self, base_folder=None, current_folder=None,
servers=None, users=None, client_version=CLIENT_VERSION,
min_server_compatible_version=MIN_SERVER_COMPATIBLE_VERSION):
"""
storage_folder: Local storage path
current_folder: Current execution folder
servers: dict of {remote_name: TestServer}
logins is a list of (user, password) for auto input in order
if required==> [("lasote", "mypass"), ("other", "otherpass")]
"""
self.users = users or {"default":
[(TESTING_REMOTE_PRIVATE_USER, TESTING_REMOTE_PRIVATE_PASS)]}
self.servers = servers or {}
self.client_version = Version(str(client_version))
self.min_server_compatible_version = Version(str(min_server_compatible_version))
self.base_folder = base_folder or temp_folder()
# Define storage_folder, if not, it will be read from conf file & pointed to real user home
self.storage_folder = os.path.join(self.base_folder, ".conan", "data")
self.paths = ConanPaths(self.base_folder, self.storage_folder,
TestBufferConanOutput())
self.default_settings(get_env("CONAN_COMPILER", "gcc"),
get_env("CONAN_COMPILER_VERSION", "4.8"),
get_env("CONAN_LIBCXX", "libstdc++"))
self.init_dynamic_vars()
save(self.paths.registry, "")
registry = RemoteRegistry(self.paths.registry, TestBufferConanOutput())
for name, server in self.servers.items():
registry.add(name, server.fake_url)
logger.debug("Client storage = %s" % self.storage_folder)
self.current_folder = current_folder or temp_folder()
def search_packages(self, reference=None, remote=None, 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"
"""
if remote:
remote = RemoteRegistry(self._client_cache.registry, self._user_io).remote(remote)
packages_props = self._remote_manager.search_packages(remote, reference, query)
ordered_packages = OrderedDict(sorted(packages_props.items()))
manifest = self._remote_manager.get_conan_digest(reference, remote)
recipe_hash = manifest.summary_hash
else:
searcher = DiskSearchManager(self._client_cache)
packages_props = searcher.search_packages(reference, query)
ordered_packages = OrderedDict(sorted(packages_props.items()))
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, query
def retro_compatibility_test(self):
f = os.path.join(temp_folder(), "aux_file")
save(f, """conan.io https://server.conan.io
""") # Without SSL parameter
registry = RemoteRegistry(f, TestBufferConanOutput())
self.assertEqual(registry.remotes,
[("conan.io", "https://server.conan.io", True)])
def info(self, deps_graph, graph_updates_info, only, remote, package_filter, show_paths, project_reference):
registry = RemoteRegistry(self.client_cache.registry, self.user_io.out)
Printer(self.user_io.out).print_info(deps_graph, project_reference,
only, registry, graph_updates_info=graph_updates_info,
remote=remote, node_times=self._read_dates(deps_graph),
path_resolver=self.client_cache, package_filter=package_filter,
show_paths=show_paths)
def insert_test(self):
f = os.path.join(temp_folder(), "aux_file")
save(f, """
{
"remotes": [
{
"url": "https://server.conan.io",
"verify_ssl": true,
"name": "conan.io"
}
],
"references": {}
}
""")
registry = RemoteRegistry(f, TestBufferConanOutput())
registry.remotes.add("repo1", "url1", True, insert=0)
self.assertEqual(registry.remotes.list, [("repo1", "url1", True),
("conan.io", "https://server.conan.io", True)])
registry.remotes.add("repo2", "url2", True, insert=1)
self.assertEqual(registry.remotes.list, [("repo1", "url1", True),
("repo2", "url2", True),
("conan.io", "https://server.conan.io", True)])
registry.remotes.add("repo3", "url3", True, insert=5)
self.assertEqual(registry.remotes.list, [("repo1", "url1", True),
("repo2", "url2", True),
("conan.io", "https://server.conan.io", True),
("repo3", "url3", True)])
def _get_registry():
f = os.path.join(temp_folder(), "aux_file")
remotes, refs = load_registry_txt(
"conan.io https://server.conan.io True\n"
"conan.io2 https://server2.conan.io True\n")
reg = dump_registry(remotes, refs, {})
save(f, reg)
return RemoteRegistry(f, TestBufferConanOutput())
def remote(self, *args):
""" manage remotes
"""
parser = argparse.ArgumentParser(description=self.remote.__doc__,
prog="conan remote")
subparsers = parser.add_subparsers(dest='subcommand',
help='sub-command help')
# create the parser for the "a" command
subparsers.add_parser('list', help='list current remotes')
parser_add = subparsers.add_parser('add', help='add a remote')
parser_add.add_argument('remote', help='name of the remote')
parser_add.add_argument('url', help='url of the remote')
parser_rm = subparsers.add_parser('remove', help='remove a remote')
parser_rm.add_argument('remote', help='name of the remote')
parser_upd = subparsers.add_parser('update',
help='update the remote url')
parser_upd.add_argument('remote', help='name of the remote')
parser_upd.add_argument('url', help='url')
subparsers.add_parser(
'list_ref',
help='list the package recipes and its associated remotes')
parser_padd = subparsers.add_parser(
'add_ref', help="associate a recipe's reference to a remote")
parser_padd.add_argument('reference', help='package recipe reference')
parser_padd.add_argument('remote', help='name of the remote')
parser_prm = subparsers.add_parser(
'remove_ref',
help="dissociate a recipe's reference and its remote")
parser_prm.add_argument('reference', help='package recipe reference')
parser_pupd = subparsers.add_parser(
'update_ref',
help="update the remote associated "
"with a package recipe")
parser_pupd.add_argument('reference', help='package recipe reference')
parser_pupd.add_argument('remote', help='name of the remote')
args = parser.parse_args(*args)
registry = RemoteRegistry(self._conan_paths.registry,
self._user_io.out)
if args.subcommand == "list":
for r in registry.remotes:
self._user_io.out.info("%s: %s" % (r.name, r.url))
elif args.subcommand == "add":
registry.add(args.remote, args.url)
elif args.subcommand == "remove":
registry.remove(args.remote)
elif args.subcommand == "update":
registry.update(args.remote, args.url)
elif args.subcommand == "list_ref":
for ref, remote in registry.refs.items():
self._user_io.out.info("%s: %s" % (ref, remote))
elif args.subcommand == "add_ref":
registry.add_ref(args.reference, args.remote)
elif args.subcommand == "remove_ref":
registry.remove_ref(args.reference)
elif args.subcommand == "update_ref":
registry.update_ref(args.reference, args.remote)
def __init__(self,
base_folder=None,
current_folder=None,
servers=None,
users=None,
client_version=CLIENT_VERSION,
min_server_compatible_version=MIN_SERVER_COMPATIBLE_VERSION,
requester_class=None,
runner=None,
path_with_spaces=True):
"""
storage_folder: Local storage path
current_folder: Current execution folder
servers: dict of {remote_name: TestServer}
logins is a list of (user, password) for auto input in order
if required==> [("lasote", "mypass"), ("other", "otherpass")]
"""
self.all_output = "" # For debugging purpose, append all the run outputs
self.users = users or {
"default":
[(TESTING_REMOTE_PRIVATE_USER, TESTING_REMOTE_PRIVATE_PASS)]
}
self.servers = servers or {}
self.client_version = Version(str(client_version))
self.min_server_compatible_version = Version(
str(min_server_compatible_version))
self.base_folder = base_folder or temp_folder(path_with_spaces)
# Define storage_folder, if not, it will be read from conf file & pointed to real user home
self.storage_folder = os.path.join(self.base_folder, ".conan", "data")
self.client_cache = ClientCache(self.base_folder, self.storage_folder,
TestBufferConanOutput())
search_adapter = DiskSearchAdapter()
self.search_manager = DiskSearchManager(self.client_cache,
search_adapter)
self._default_settings(get_env("CONAN_COMPILER", "gcc"),
get_env("CONAN_COMPILER_VERSION", "4.8"),
get_env("CONAN_LIBCXX", "libstdc++"))
self.requester_class = requester_class
self.conan_runner = runner
self.init_dynamic_vars()
save(self.client_cache.registry, "")
registry = RemoteRegistry(self.client_cache.registry,
TestBufferConanOutput())
for name, server in self.servers.items():
if isinstance(server, TestServer):
registry.add(name, server.fake_url)
else:
registry.add(name, server)
logger.debug("Client storage = %s" % self.storage_folder)
self.current_folder = current_folder or temp_folder(path_with_spaces)
def update_servers(self, servers):
self.servers = servers or {}
save(self.client_cache.registry, "")
registry = RemoteRegistry(self.client_cache.registry, TestBufferConanOutput())
for name, server in self.servers.items():
if isinstance(server, TestServer):
registry.add(name, server.fake_url)
else:
registry.add(name, server)
def info(self, deps_graph, only, package_filter, show_paths):
registry = RemoteRegistry(self.client_cache.registry, self.user_io.out)
Printer(self.user_io.out).print_info(
deps_graph,
only,
registry,
node_times=self._read_dates(deps_graph),
path_resolver=self.client_cache,
package_filter=package_filter,
show_paths=show_paths)
def authenticate(self, name, password, remote=None):
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
if not remote:
remote = registry.default_remote
else:
remote = registry.remote(remote)
if password == "":
name, password = self._user_io.request_login(remote_name=remote.name,
username=name)
self._remote_manager.authenticate(remote, name, password)
def __init__(self, paths, user_io, remote_manager, remote_name,
update=False, check_updates=False, check_integrity=False):
self._paths = paths
self._out = user_io.out
self._remote_manager = remote_manager
self._registry = RemoteRegistry(self._paths.registry, self._out)
self._remote_name = remote_name
self._update = update
self._check_updates = check_updates or update # Update forces check
self._check_integrity = check_integrity
def __init__(self, client_cache, user_io, remote_manager, remote_name,
update=False, check_updates=False, manifest_manager=False):
self._client_cache = client_cache
self._out = user_io.out
self._remote_manager = remote_manager
self._registry = RemoteRegistry(self._client_cache.registry, self._out)
self._remote_name = remote_name
self._update = update
self._check_updates = check_updates or update # Update forces check
self._manifest_manager = manifest_manager
def user_set(client_cache, output, user, remote_name=None):
localdb = LocalDB(client_cache.localdb)
registry = RemoteRegistry(client_cache.registry, output)
if not remote_name:
remote = registry.default_remote
else:
remote = registry.remote(remote_name)
if user.lower() == "none":
user = None
update_localdb(localdb, user, None, remote, output)
def __init__(self, client_cache, user_io, runner, remote_manager,
_settings_preprocessor, interactive=True):
assert isinstance(user_io, UserIO)
assert isinstance(client_cache, ClientCache)
self._client_cache = client_cache
self._user_io = user_io
self._runner = runner
self._remote_manager = remote_manager
self._settings_preprocessor = _settings_preprocessor
self._registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
if not interactive:
self._user_io.disable_input()
def refs_test(self):
f = os.path.join(temp_folder(), "aux_file")
registry = RemoteRegistry(f, TestBufferConanOutput())
ref = ConanFileReference.loads("MyLib/0.1@lasote/stable")
remotes = registry.remotes
registry.set_ref(ref, remotes[0])
remote = registry.get_ref(ref)
self.assertEqual(remote, remotes[0])
registry.set_ref(ref, remotes[0])
remote = registry.get_ref(ref)
self.assertEqual(remote, remotes[0])
def refs_test(self):
f = os.path.join(temp_folder(), "aux_file")
save(f, dump_registry(default_remotes, {}, {}))
registry = RemoteRegistry(f, TestBufferConanOutput())
ref = ConanFileReference.loads("MyLib/0.1@lasote/stable")
remotes = registry.remotes.list
registry.refs.set(ref, remotes[0].name)
remote = registry.refs.get(ref)
self.assertEqual(remote, remotes[0])
registry.refs.set(ref, remotes[0].name)
remote = registry.refs.get(ref)
self.assertEqual(remote, remotes[0])
def __init__(self,
paths,
user_io,
remote_manager,
remote_name,
update=False,
check_updates=True):
self._paths = paths
self._out = user_io.out
self._remote_manager = remote_manager
self._registry = RemoteRegistry(self._paths.registry, self._out)
self._remote_name = remote_name
self._update = update
self._check_updates = check_updates
def to_json_migration_test(self):
tmp = temp_folder()
conf_dir = os.path.join(tmp, ".conan")
f = os.path.join(conf_dir, "registry.txt")
save(f, """conan.io https://server.conan.io True
lib/1.0@conan/stable conan.io
other/1.0@lasote/testing conan.io
""")
client = TestClient(base_folder=tmp, servers=False)
new_path = client.client_cache.registry
registry = RemoteRegistry(new_path, TestBufferConanOutput())
self.assertEqual(registry.remotes.list, [("conan.io", "https://server.conan.io", True)])
self.assertEqual(registry.refs.list, {'lib/1.0@conan/stable': 'conan.io',
'other/1.0@lasote/testing': 'conan.io'})
def insert_test(self):
f = os.path.join(temp_folder(), "aux_file")
save(f, "conan.io https://server.conan.io True")
registry = RemoteRegistry(f, TestBufferConanOutput())
registry.add("repo1", "url1", True, insert=0)
self.assertEqual(registry.remotes,
[("repo1", "url1", True),
("conan.io", "https://server.conan.io", True)])
registry.add("repo2", "url2", True, insert=1)
self.assertEqual(registry.remotes,
[("repo1", "url1", True), ("repo2", "url2", True),
("conan.io", "https://server.conan.io", True)])
registry.add("repo3", "url3", True, insert=5)
self.assertEqual(registry.remotes,
[("repo1", "url1", True), ("repo2", "url2", True),
("conan.io", "https://server.conan.io", True),
("repo3", "url3", True)])
def __init__(self, client_cache, user_io, runner, remote_manager, interactive=True):
assert isinstance(user_io, UserIO)
assert isinstance(client_cache, ClientCache)
self._client_cache = client_cache
self._user_io = user_io
self._runner = runner
self._remote_manager = remote_manager
self._registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
if not interactive:
self._user_io.disable_input()
self._proxy = ConanProxy(client_cache, self._user_io.out, remote_manager, registry=self._registry)
resolver = RangeResolver(self._user_io.out, client_cache, self._proxy)
python_requires = ConanPythonRequire(self._proxy, resolver)
self._loader = ConanFileLoader(self._runner, self._user_io.out, python_requires)
self._graph_manager = GraphManager(self._user_io.out, self._client_cache, self._registry,
self._remote_manager, self._loader, self._proxy, resolver)
def users_list(client_cache, output, remote_name=None):
# List all users from required remotes
registry = RemoteRegistry(client_cache.registry, output)
if remote_name:
remotes = [registry.remote(remote_name)]
else:
remotes = registry.remotes
if not remotes:
raise ConanException("No remotes defined")
localdb = LocalDB(client_cache.localdb)
result = []
for remote in remotes:
prev_user = localdb.get_username(remote.url)
username = prev_user or "None (anonymous)"
result.append((remote.name, username))
return result
def search_recipes(self, pattern, remote=None, case_sensitive=False):
ignorecase = not case_sensitive
if not remote:
return DiskSearchManager(self._client_cache).search_recipes(pattern, ignorecase)
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
if remote == 'all':
remotes = registry.remotes
# We have to check if there is a remote called "all"
# Deprecate: 2.0 can remove this check
if 'all' not in (r.name for r in remotes):
references = {}
for remote in remotes:
result = self._remote_manager.search_recipes(remote, pattern, ignorecase)
if result:
references[remote.name] = result
return references
# single remote
remote = registry.remote(remote)
return self._remote_manager.search_recipes(remote, pattern, ignorecase)
def update_servers(self):
save(self.client_cache.registry, dump_registry({}, {}, {}))
registry = RemoteRegistry(self.client_cache.registry,
TestBufferConanOutput())
def add_server_to_registry(name, server):
if isinstance(server, TestServer):
registry.remotes.add(name, server.fake_url)
else:
registry.remotes.add(name, server)
for name, server in self.servers.items():
if name == "default":
add_server_to_registry(name, server)
for name, server in self.servers.items():
if name != "default":
add_server_to_registry(name, server)
