def _init_collaborators(self, user_io=None):
output = TestBufferConanOutput()
self.user_io = user_io or MockedUserIO(self.users, out=output)
self.runner = TestRunner(output, runner=self.conan_runner)
# Check if servers are real
real_servers = False
for server in self.servers.values():
if isinstance(server, str): # Just URI
real_servers = True
if real_servers:
requester = requests.Session()
else:
if self.requester_class:
requester = self.requester_class(self.servers)
else:
requester = TestRequester(self.servers)
self.requester = ConanRequester(requester, self.client_cache)
self.localdb, self.rest_api_client, self.remote_manager = Conan.instance_remote_manager(
self.requester, self.client_cache, self.user_io,
self.client_version, self.min_server_compatible_version)
set_global_instances(output, self.requester)
def vcvars_constrained_test(self):
text = """os: [Windows]
compiler:
Visual Studio:
version: ["14"]
"""
settings = Settings.loads(text)
settings.os = "Windows"
settings.compiler = "Visual Studio"
with self.assertRaisesRegexp(
ConanException,
"compiler.version setting required for vcvars not defined"):
tools.vcvars_command(settings)
new_out = StringIO()
tools.set_global_instances(ConanOutput(new_out), None)
settings.compiler.version = "14"
with tools.environment_append({"vs140comntools": "path/to/fake"}):
tools.vcvars_command(settings)
if platform.system() != "Windows":
self.assertIn("VS non-existing installation",
new_out.getvalue())
with tools.environment_append({"VisualStudioVersion": "12"}):
with self.assertRaisesRegexp(
ConanException,
"Error, Visual environment already set to 12"):
tools.vcvars_command(settings)
with tools.environment_append({"VisualStudioVersion": "12"}):
# Not raising
tools.vcvars_command(settings, force=True)
def _init_collaborators(self, user_io=None):
output = TestBufferConanOutput()
self.user_io = user_io or MockedUserIO(self.users, out=output)
self.runner = TestRunner(output, runner=self.conan_runner)
# Check if servers are real
real_servers = False
for server in self.servers.values():
if isinstance(server, str): # Just URI
real_servers = True
if real_servers:
requester = requests
else:
if self.requester_class:
requester = self.requester_class(self.servers)
else:
requester = TestRequester(self.servers)
# Verify client version against remotes
self.requester = VersionCheckerRequester(requester, self.client_version,
self.min_server_compatible_version, output)
put_headers = self.client_cache.read_put_headers()
self.rest_api_client = RestApiClient(output, requester=self.requester, put_headers=put_headers)
# To store user and token
self.localdb = LocalDB(self.client_cache.localdb)
# Wraps RestApiClient to add authentication support (same interface)
auth_manager = ConanApiAuthManager(self.rest_api_client, self.user_io, self.localdb)
# Handle remote connections
self.remote_manager = RemoteManager(self.client_cache, auth_manager, self.user_io.out)
set_global_instances(output, self.requester)
def _init_collaborators(self, user_io=None):
output = TestBufferConanOutput()
self.user_io = user_io or MockedUserIO(self.users, out=output)
self.runner = TestRunner(output, runner=self.conan_runner)
# Check if servers are real
real_servers = False
for server in self.servers.values():
if isinstance(server, str): # Just URI
real_servers = True
with tools.environment_append(self.client_cache.conan_config.env_vars):
if real_servers:
requester = requests.Session()
else:
if self.requester_class:
requester = self.requester_class(self.servers)
else:
requester = TestRequester(self.servers)
self.requester = ConanRequester(requester, self.client_cache,
get_request_timeout())
self.plugin_manager = PluginManager(
self.client_cache.plugins_path,
get_env("CONAN_PLUGINS", list()), self.user_io.out)
self.localdb, self.rest_api_client, self.remote_manager = Conan.instance_remote_manager(
self.requester, self.client_cache, self.user_io,
self.client_version, self.min_server_compatible_version,
self.plugin_manager)
set_global_instances(output, self.requester)
def no_configuration_test(self):
dummy = """GlobalSection
EndGlobalSection
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
Debug|x64 = Debug|x64
Release|Win32 = Release|Win32
Release|x64 = Release|x64
EndGlobalSection
"""
folder = temp_folder()
path = os.path.join(folder, "dummy.sln")
save(path, dummy)
new_out = StringIO()
tools.set_global_instances(ConanOutput(new_out), None)
command = build_sln_command(Settings({}), sln_path=path, targets=None, upgrade_project=False,
build_type='Debug', arch="x86", parallel=False)
self.assertIn('/p:Configuration=Debug /p:Platform="x86"', command)
self.assertIn("WARN: ***** The configuration Debug|x86 does not exist in this solution *****",
new_out.getvalue())
# use platforms
new_out = StringIO()
tools.set_global_instances(ConanOutput(new_out), None)
command = build_sln_command(Settings({}), sln_path=path, targets=None, upgrade_project=False,
build_type='Debug', arch="x86", parallel=False, platforms={"x86": "Win32"})
self.assertIn('/p:Configuration=Debug /p:Platform="Win32"', command)
self.assertNotIn("WARN", new_out.getvalue())
self.assertNotIn("ERROR", new_out.getvalue())
def vcvars_constrained_test(self):
text = """os: [Windows]
compiler:
Visual Studio:
version: ["14"]
"""
settings = Settings.loads(text)
settings.os = "Windows"
settings.compiler = "Visual Studio"
with self.assertRaisesRegexp(ConanException,
"compiler.version setting required for vcvars not defined"):
tools.vcvars_command(settings)
new_out = StringIO()
tools.set_global_instances(ConanOutput(new_out), None)
settings.compiler.version = "14"
with tools.environment_append({"vs140comntools": "path/to/fake"}):
tools.vcvars_command(settings)
with tools.environment_append({"VisualStudioVersion": "12"}):
with self.assertRaisesRegexp(ConanException,
"Error, Visual environment already set to 12"):
tools.vcvars_command(settings)
with tools.environment_append({"VisualStudioVersion": "12"}):
# Not raising
tools.vcvars_command(settings, force=True)
def _init_collaborators(self, user_io=None):
output = TestBufferConanOutput()
self.user_io = user_io or MockedUserIO(self.users, out=output)
self.runner = TestRunner(output, runner=self.conan_runner)
# Check if servers are real
real_servers = False
for server in self.servers.values():
if isinstance(server, str): # Just URI
real_servers = True
with tools.environment_append(self.client_cache.conan_config.env_vars):
if real_servers:
requester = requests.Session()
else:
if self.requester_class:
requester = self.requester_class(self.servers)
else:
requester = TestRequester(self.servers)
self.requester = ConanRequester(requester, self.client_cache,
get_request_timeout())
self.localdb, self.rest_api_client, self.remote_manager = Conan.instance_remote_manager(
self.requester, self.client_cache,
self.user_io, self.client_version,
self.min_server_compatible_version)
set_global_instances(output, self.requester)
def run(self,
command_line,
user_io=None,
ignore_error=False,
should_error=False):
""" run a single command as in the command line.
If user or password is filled, user_io will be mocked to return this
tuple if required
"""
output, requester = self.init_dynamic_vars(user_io)
with tools.environment_append(self.client_cache.conan_config.env_vars):
# Settings preprocessor
interactive = not get_env("CONAN_NON_INTERACTIVE", False)
conan = Conan(self.client_cache,
self.user_io,
self.runner,
self.remote_manager,
self.hook_manager,
interactive=interactive)
outputer = CommandOutputer(self.user_io, self.client_cache)
command = Command(conan, self.client_cache, self.user_io, outputer)
args = shlex.split(command_line)
current_dir = os.getcwd()
os.chdir(self.current_folder)
old_path = sys.path[:]
sys.path.append(os.path.join(self.client_cache.conan_folder, "python"))
old_modules = list(sys.modules.keys())
old_output, old_requester = set_global_instances(output, requester)
try:
error = command.run(args)
finally:
set_global_instances(old_output, old_requester)
sys.path = old_path
os.chdir(current_dir)
# Reset sys.modules to its prev state. A .copy() DOES NOT WORK
added_modules = set(sys.modules).difference(old_modules)
for added in added_modules:
sys.modules.pop(added, None)
if not ignore_error and error and not should_error:
exc_message = "\n{command_header}\n{command}\n{output_header}\n{output}\n{output_footer}\n".format(
command_header='{:-^80}'.format(" Command failed: "),
output_header='{:-^80}'.format(" Output: "),
output_footer='-' * 80,
command=command_line,
output=self.user_io.out)
raise Exception(exc_message)
if should_error and not error:
raise Exception("This command should have failed: %s" %
command_line)
self.all_output += str(self.user_io.out)
return error
def __init__(self, client_cache, user_io, runner, remote_manager, search_manager,
settings_preprocessor):
assert isinstance(user_io, UserIO)
assert isinstance(client_cache, ClientCache)
self._client_cache = client_cache
self._user_io = user_io
self._runner = runner
self._manager = ConanManager(client_cache, user_io, runner, remote_manager, search_manager,
settings_preprocessor)
# Patch the tools module with a good requester and user_io
set_global_instances(self._user_io.out, get_basic_requester(self._client_cache))
def factory(interactive=None):
"""Factory"""
# Respect color env setting or check tty if unset
color_set = "CONAN_COLOR_DISPLAY" in os.environ
if ((color_set and get_env("CONAN_COLOR_DISPLAY", 1))
or (not color_set
and hasattr(sys.stdout, "isatty")
and sys.stdout.isatty())):
import colorama
if get_env("PYCHARM_HOSTED"): # in PyCharm disable convert/strip
colorama.init(convert=False, strip=False)
else:
colorama.init()
color = True
else:
color = False
out = ConanOutput(sys.stdout, color)
user_io = UserIO(out=out)
try:
user_home = get_conan_user_home()
client_cache = migrate_and_get_client_cache(user_home, out)
sys.path.append(os.path.join(user_home, "python"))
except Exception as e:
out.error(str(e))
raise
with tools.environment_append(client_cache.conan_config.env_vars):
# Adjust CONAN_LOGGING_LEVEL with the env readed
conans.util.log.logger = configure_logger()
# Create Plugin Manager
plugin_manager = PluginManager(client_cache.plugins_path,
get_env("CONAN_PLUGINS", list()), user_io.out)
# Get the new command instance after migrations have been done
requester = get_basic_requester(client_cache)
_, _, remote_manager = ConanAPIV1.instance_remote_manager(
requester,
client_cache, user_io,
Version(client_version),
Version(MIN_SERVER_COMPATIBLE_VERSION),
plugin_manager)
# Adjust global tool variables
set_global_instances(out, requester)
# Settings preprocessor
if interactive is None:
interactive = not get_env("CONAN_NON_INTERACTIVE", False)
conan = ConanAPIV1(client_cache, user_io, get_conan_runner(), remote_manager,
plugin_manager, interactive=interactive)
return conan, client_cache, user_io
def download_retries_test(self):
out = TestBufferConanOutput()
set_global_instances(out, requests)
# Connection error
with self.assertRaisesRegexp(ConanException, "HTTPConnectionPool"):
tools.download("http://fakeurl3.es/nonexists",
os.path.join(temp_folder(), "file.txt"), out=out,
retry=3, retry_wait=0)
# Not found error
self.assertEquals(str(out).count("Waiting 0 seconds to retry..."), 2)
with self.assertRaisesRegexp(NotFoundException, "Not found: "):
tools.download("https://github.com/conan-io/conan/blob/develop/FILE_NOT_FOUND.txt",
os.path.join(temp_folder(), "README.txt"), out=out,
retry=3, retry_wait=0)
# And OK
dest = os.path.join(temp_folder(), "manual.html")
tools.download("http://www.zlib.net/manual.html",
dest, out=out,
retry=3, retry_wait=0)
self.assertTrue(os.path.exists(dest))
content = load(dest)
# overwrite = False
with self.assertRaises(ConanException):
tools.download("http://www.zlib.net/manual.html",
dest, out=out,
retry=3, retry_wait=0, overwrite=False)
# overwrite = True
tools.download("http://www.zlib.net/manual.html",
dest, out=out,
retry=3, retry_wait=0, overwrite=True)
self.assertTrue(os.path.exists(dest))
content_new = load(dest)
self.assertEqual(content, content_new)
# Not authorized
with self.assertRaises(ConanException):
tools.download("https://httpbin.org/basic-auth/user/passwd", dest, overwrite=True)
# Authorized
tools.download("https://httpbin.org/basic-auth/user/passwd", dest, auth=("user", "passwd"),
overwrite=True)
# Authorized using headers
tools.download("https://httpbin.org/basic-auth/user/passwd", dest,
headers={"Authorization": "Basic dXNlcjpwYXNzd2Q="}, overwrite=True)
def download_retries_test(self):
out = TestBufferConanOutput()
set_global_instances(out, requests)
# Connection error
with self.assertRaisesRegexp(ConanException, "HTTPConnectionPool"):
tools.download("http://fakeurl3.es/nonexists",
os.path.join(temp_folder(), "file.txt"), out=out,
retry=3, retry_wait=0)
# Not found error
self.assertEquals(str(out).count("Waiting 0 seconds to retry..."), 2)
with self.assertRaisesRegexp(NotFoundException, "Not found: "):
tools.download("https://github.com/conan-io/conan/blob/develop/FILE_NOT_FOUND.txt",
os.path.join(temp_folder(), "README.txt"), out=out,
retry=3, retry_wait=0)
# And OK
dest = os.path.join(temp_folder(), "manual.html")
tools.download("http://www.zlib.net/manual.html",
dest, out=out,
retry=3, retry_wait=0)
self.assertTrue(os.path.exists(dest))
content = load(dest)
# overwrite = False
with self.assertRaises(ConanException):
tools.download("http://www.zlib.net/manual.html",
dest, out=out,
retry=3, retry_wait=0, overwrite=False)
# overwrite = True
tools.download("http://www.zlib.net/manual.html",
dest, out=out,
retry=3, retry_wait=0, overwrite=True)
self.assertTrue(os.path.exists(dest))
content_new = load(dest)
self.assertEqual(content, content_new)
# Not authorized
with self.assertRaises(ConanException):
tools.download("https://httpbin.org/basic-auth/user/passwd", dest, overwrite=True)
# Authorized
tools.download("https://httpbin.org/basic-auth/user/passwd", dest, auth=("user", "passwd"),
overwrite=True)
# Authorized using headers
tools.download("https://httpbin.org/basic-auth/user/passwd", dest,
headers={"Authorization": "Basic dXNlcjpwYXNzd2Q="}, overwrite=True)
def factory(interactive=None):
"""Factory"""
use_color = get_env("CONAN_COLOR_DISPLAY", 1)
if use_color and hasattr(sys.stdout, "isatty") and sys.stdout.isatty():
import colorama
colorama.init()
color = True
else:
color = False
out = ConanOutput(sys.stdout, color)
user_io = UserIO(out=out)
try:
user_home = get_conan_user_home()
client_cache = migrate_and_get_client_cache(user_home, out)
sys.path.append(os.path.join(user_home, "python"))
except Exception as e:
out.error(str(e))
raise
with tools.environment_append(client_cache.conan_config.env_vars):
# Adjust CONAN_LOGGING_LEVEL with the env readed
conans.util.log.logger = configure_logger()
# Get the new command instance after migrations have been done
requester = get_basic_requester(client_cache)
_, _, remote_manager = ConanAPIV1.instance_remote_manager(
requester,
client_cache, user_io,
Version(client_version),
Version(MIN_SERVER_COMPATIBLE_VERSION))
# Adjust global tool variables
set_global_instances(out, requester)
# Get a search manager
search_manager = DiskSearchManager(client_cache)
# Settings preprocessor
if interactive is None:
interactive = not get_env("CONAN_NON_INTERACTIVE", False)
conan = Conan(client_cache, user_io, get_conan_runner(), remote_manager, search_manager,
settings_preprocessor, interactive=interactive)
return conan, client_cache, user_io
def _configureConan():
'''
Ensures Conan is configured correctly so we can use its utility functionality from outside recipes
'''
# We only need to perform configuration once
if ConanTools._isConanConfigured == True:
return
# Ensure Conan's global configuration object is not `None` when using Conan 1.22.0 or newer
if hasattr(tools, 'get_global_instances') and hasattr(
tools, 'set_global_instances'):
if 'config' in inspect.signature(
tools.set_global_instances).parameters:
instances = tools.get_global_instances()
tools.set_global_instances(the_output=instances[0],
the_requester=instances[1],
config=_DummyConfig())
ConanTools._isConanConfigured = True
