def user(self, name=None, clean=False, remote=None, password=None):
if clean:
localdb = LocalDB(self._client_cache.localdb)
localdb.init(clean=True)
self._user_io.out.success("Deleted user data")
return
self._manager.user(remote, name, password)
def user(self, *parameters):
""" shows or change the current user """
parser = argparse.ArgumentParser(description=self.user.__doc__,
prog="conan user")
parser.add_argument(
"name",
nargs='?',
default=None,
help='Username you want to use. '
'If no name is provided it will show the current user.')
parser.add_argument(
"-p",
"--password",
help='User password. Use double quotes '
'if password with spacing, and escape quotes if existing')
parser.add_argument("--remote",
"-r",
help='look for in the remote storage')
parser.add_argument('-c',
'--clean',
default=False,
action='store_true',
help='Remove user and tokens for all remotes')
args = parser.parse_args(*parameters) # To enable -h
if args.clean:
localdb = LocalDB(self._conan_paths.localdb)
localdb.init(clean=True)
self._user_io.out.success("Deleted user data")
return
self._manager.user(args.remote, args.name, args.password)
def user(self, name=None, clean=False, remote=None, password=None):
if clean:
localdb = LocalDB(self._client_cache.localdb)
localdb.init(clean=True)
self._user_io.out.success("Deleted user data")
return
self._manager.user(remote, name, password)
def users_list(localdb_file, remotes):
if not remotes:
raise ConanException("No remotes defined")
localdb = LocalDB(localdb_file)
remotes_info = []
for remote in remotes:
user_info = {}
user, token = localdb.get_login(remote.url)
user_info["name"] = remote.name
user_info["user_name"] = user
user_info["authenticated"] = True if token else False
remotes_info.append(user_info)
return remotes_info
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)
def init_dynamic_vars(self, user_io=None):
output = TestBufferConanOutput()
# Migration system
self.paths = migrate_and_get_paths(self.base_folder,
output,
storage_folder=self.storage_folder)
self.user_io = user_io or MockedUserIO(self.users, out=output)
self.runner = TestRunner(output)
requester = TestRequester(self.servers)
# Verify client version against remotes
self.requester = VersionCheckerRequester(
requester, self.client_version, self.min_server_compatible_version,
output)
self.rest_api_client = RestApiClient(output, requester=self.requester)
# To store user and token
self.localdb = LocalDB(self.paths.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.paths, self.servers.items(),
auth_manager, self.user_io.out)
def users_list(client_cache, registry, remote_name=None):
# List all users from required remotes
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 user_set(client_cache, output, registry, user, remote_name=None):
localdb = LocalDB(client_cache.localdb)
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 user(self, *parameters):
""" shows or change the current user """
parser = argparse.ArgumentParser(description=self.user.__doc__, prog="conan user")
parser.add_argument("name", nargs='?', default=None,
help='Username you want to use. '
'If no name is provided it will show the current user.')
parser.add_argument("-p", "--password", help='User password. Use double quotes '
'if password with spacing, and escape quotes if existing')
parser.add_argument("--remote", "-r", help='look for in the remote storage')
parser.add_argument('-c', '--clean', default=False,
action='store_true', help='Remove user and tokens for all remotes')
args = parser.parse_args(*parameters) # To enable -h
if args.clean:
localdb = LocalDB(self._conan_paths.localdb)
localdb.init(clean=True)
self._user_io.out.success("Deleted user data")
return
self._manager.user(args.remote, args.name, args.password)
def user_set(localdb_file, user, remote_name=None):
localdb = LocalDB.create(localdb_file)
if user.lower() == "none":
user = None
return update_localdb(localdb,
user,
token=None,
refresh_token=None,
remote=remote_name)
def localdb_test(self):
tmp_dir = temp_folder()
db_file = os.path.join(tmp_dir, "dbfile")
localdb = LocalDB(db_file)
# Test write and read login
localdb.init()
login, token = localdb.get_login()
self.assertIsNone(login)
self.assertIsNone(token)
localdb.set_login(("pepe", "token"))
login, token = localdb.get_login()
self.assertEquals("pepe", login)
self.assertEquals("token", token)
self.assertEquals("pepe", localdb.get_username())
def test_token_encryption_none(self):
tmp_dir = temp_folder()
db_file = os.path.join(tmp_dir, "dbfile")
encryption_key = str(uuid.uuid4())
localdb = LocalDB.create(db_file, encryption_key=encryption_key)
localdb.store("pepe", "token", None, "myurl1")
user, token, access_token = localdb.get_login("myurl1")
self.assertEqual("pepe", user)
self.assertEqual("token", token)
self.assertEqual(None, access_token)
def test_token_encryption_unicode(self):
tmp_dir = temp_folder()
db_file = os.path.join(tmp_dir, "dbfile")
encryption_key = str(uuid.uuid4())
localdb = LocalDB.create(db_file, encryption_key=encryption_key)
token_input = b'espa\xc3\xb1a\xe2\x82\xac$'.decode(
'utf-8') # Only ASCII files in codebase
localdb.store("pepe", token_input, token_input, "myurl1")
user, token, access_token = localdb.get_login("myurl1")
self.assertEqual("pepe", user)
self.assertEqual(token_input, token)
self.assertEqual(token_input, access_token)
self.assertEqual("pepe", localdb.get_username("myurl1"))
# Without the encryption key we get obfuscated values
other_db = LocalDB.create(db_file)
user, token, access_token = other_db.get_login("myurl1")
self.assertEqual("pepe", user)
self.assertNotEqual(token_input, token)
self.assertNotEqual(token_input, access_token)
def migrate_localdb_refresh_token(cache, out):
from conans.client.store.localdb import LocalDB
from sqlite3 import OperationalError
localdb = LocalDB.create(cache.localdb)
with localdb._connect() as connection:
try:
statement = connection.cursor()
statement.execute("ALTER TABLE users_remotes ADD refresh_token TEXT;")
except OperationalError:
# This likely means the column is already there (fresh created table)
# In the worst scenario the user will be requested to remove the file by hand
pass
def localdb_test(self):
tmp_dir = temp_folder()
db_file = os.path.join(tmp_dir, "dbfile")
localdb = LocalDB(db_file)
# Test write and read login
localdb.init()
user, token = localdb.get_login("myurl1")
self.assertIsNone(user)
self.assertIsNone(token)
localdb.set_login(("pepe", "token"), "myurl1")
user, token = localdb.get_login("myurl1")
self.assertEquals("pepe", user)
self.assertEquals("token", token)
self.assertEquals("pepe", localdb.get_username("myurl1"))
def localdb_test(self):
tmp_dir = temp_folder()
db_file = os.path.join(tmp_dir, "dbfile")
localdb = LocalDB.create(db_file)
# Test write and read login
user, token = localdb.get_login("myurl1")
self.assertIsNone(user)
self.assertIsNone(token)
localdb.set_login(("pepe", "token"), "myurl1")
user, token = localdb.get_login("myurl1")
self.assertEqual("pepe", user)
self.assertEqual("token", token)
self.assertEqual("pepe", localdb.get_username("myurl1"))
def instance_remote_manager(client_cache):
requester = requests.Session()
requester.proxies = client_cache.conan_config.proxies
# Verify client version against remotes
version_checker_requester = VersionCheckerRequester(requester, Version(CLIENT_VERSION),
Version(MIN_SERVER_COMPATIBLE_VERSION),
out)
# To handle remote connections
rest_api_client = RestApiClient(out, requester=version_checker_requester)
# To store user and token
localdb = LocalDB(client_cache.localdb)
# Wraps RestApiClient to add authentication support (same interface)
auth_manager = ConanApiAuthManager(rest_api_client, user_io, localdb)
# Handle remote connections
remote_manager = RemoteManager(client_cache, auth_manager, out)
return remote_manager
def instance_remote_manager(client_cache):
requester = get_basic_requester(client_cache)
# Verify client version against remotes
version_checker_req = VersionCheckerRequester(requester, Version(client_version),
Version(MIN_SERVER_COMPATIBLE_VERSION),
out)
# To handle remote connections
put_headers = client_cache.read_put_headers()
rest_api_client = RestApiClient(out, requester=version_checker_req,
put_headers=put_headers)
# To store user and token
localdb = LocalDB(client_cache.localdb)
# Wraps RestApiClient to add authentication support (same interface)
auth_manager = ConanApiAuthManager(rest_api_client, user_io, localdb)
# Handle remote connections
remote_manager = RemoteManager(client_cache, auth_manager, out)
return remote_manager
def main(args):
""" main entry point of the conans application, using a Command to
parse parameters
"""
if 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)
user_folder = os.path.expanduser("~")
paths = migrate_and_get_paths(user_folder, out)
# Verify client version against remotes
version_checker_requester = VersionCheckerRequester(
requests, Version(CLIENT_VERSION),
Version(MIN_SERVER_COMPATIBLE_VERSION), out)
# To handle remote connections
rest_api_client = RestApiClient(out, requester=version_checker_requester)
# To store user and token
localdb = LocalDB(paths.localdb)
# Wraps RestApiClient to add authentication support (same interface)
auth_manager = ConanApiAuthManager(rest_api_client, user_io, localdb)
# Handle remote connections
remote_manager = RemoteManager(paths, paths.conan_config.remotes,
auth_manager, out)
command = Command(paths, user_io, os.system, remote_manager, localdb)
current_dir = os.getcwd()
try:
import signal
def sigint_handler(signal, frame):
print('You pressed Ctrl+C!')
sys.exit(0)
signal.signal(signal.SIGINT, sigint_handler)
error = command.run(args)
finally:
os.chdir(current_dir)
sys.exit(error)
def instance_remote_manager(requester, client_cache, user_io, _client_version,
min_server_compatible_version):
# Verify client version against remotes
version_checker_req = VersionCheckerRequester(requester, _client_version,
min_server_compatible_version,
user_io.out)
# To handle remote connections
put_headers = client_cache.read_put_headers()
rest_api_client = RestApiClient(user_io.out, requester=version_checker_req,
put_headers=put_headers)
# To store user and token
localdb = LocalDB(client_cache.localdb)
# Wraps RestApiClient to add authentication support (same interface)
auth_manager = ConanApiAuthManager(rest_api_client, user_io, localdb)
# Handle remote connections
remote_manager = RemoteManager(client_cache, auth_manager, user_io.out)
return localdb, rest_api_client, remote_manager
def test_command_user_with_password(self):
""" Checks the -p option, that obtains a token from the password.
Useful for integrations as travis, that interactive password is not
possible
"""
test_server = TestServer()
servers = {"default": test_server}
client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
client.run('user dummy -p ping_pong2', assert_error=True)
self.assertIn("ERROR: Wrong user or password", client.out)
client.run('user lasote -p mypass')
self.assertNotIn("ERROR: Wrong user or password", client.out)
self.assertIn("Changed user of remote 'default' from 'None' (anonymous) to 'lasote'",
client.out)
client.run('user none')
self.assertIn("Changed user of remote 'default' from 'lasote' to 'None' (anonymous)",
client.out)
localdb = LocalDB.create(client.cache.localdb)
self.assertEqual((None, None, None), localdb.get_login(test_server.fake_url))
client.run('user')
self.assertIn("Current user of remote 'default' set to: 'None' (anonymous)", client.out)
def init_dynamic_vars(self, user_io=None):
# Migration system
output = TestBufferConanOutput()
self.user_io = user_io or MockedUserIO(self.users, out=output)
self.cache = ClientCache(self.base_folder, output)
# Migration system
migrator = ClientMigrator(self.cache, Version(__version__), output)
migrator.migrate()
http_requester = self._get_http_requester()
config = self.cache.config
if self.conan_runner:
self.runner = self.conan_runner
else:
self.runner = ConanRunner(config.print_commands_to_output,
config.generate_run_log_file,
config.log_run_to_output,
output=output)
self.requester = ConanRequester(config, http_requester)
self.hook_manager = HookManager(self.cache.hooks_path, config.hooks,
self.user_io.out)
put_headers = self.cache.read_put_headers()
self.rest_api_client = RestApiClient(
self.user_io.out,
self.requester,
revisions_enabled=config.revisions_enabled,
put_headers=put_headers)
# To store user and token
self.localdb = LocalDB.create(self.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.cache, auth_manager,
self.user_io.out,
self.hook_manager)
return output, self.requester
def test_with_remote_no_connect(self):
test_server = TestServer()
client = TestClient(servers={"default": test_server})
client.run('user')
self.assertIn("Current user of remote 'default' set to: 'None' (anonymous)", client.out)
client.run('user john')
self.assertIn("Changed user of remote 'default' from 'None' (anonymous) to 'john'",
client.out)
localdb = LocalDB.create(client.cache.localdb)
self.assertEqual(('john', None, None), localdb.get_login(test_server.fake_url))
client.run('user will')
self.assertIn("Changed user of remote 'default' from 'john' to 'will'", client.out)
self.assertEqual(('will', None, None), localdb.get_login(test_server.fake_url))
client.run('user None')
self.assertIn("Changed user of remote 'default' from 'will' to 'None' (anonymous)",
client.out)
self.assertEqual((None, None, None), localdb.get_login(test_server.fake_url))
client.run('user')
self.assertIn("Current user of remote 'default' set to: 'None' (anonymous)", client.out)
def users_clean(client_cache):
localdb = LocalDB(client_cache.localdb)
localdb.init(clean=True)
def localdb(self):
localdb_filename = os.path.join(self.cache_folder, LOCALDB)
return LocalDB.create(localdb_filename)
def localdb(self):
localdb_filename = os.path.join(self.cache_folder, LOCALDB)
encryption_key = os.getenv('CONAN_LOGIN_ENCRYPTION_KEY', None)
return LocalDB.create(localdb_filename, encryption_key=encryption_key)
def users_clean(localdb_file):
localdb = LocalDB(localdb_file)
localdb.init(clean=True)
def user_set(localdb_file, user, remote_name=None):
localdb = LocalDB(localdb_file)
if user.lower() == "none":
user = None
return update_localdb(localdb, user, None, remote_name)
def token_present(localdb_file, remote, user):
localdb = LocalDB.create(localdb_file)
current_user, token = localdb.get_login(remote.url)
return token is not None and (user is None or user == current_user)
def users_clean(localdb_file):
LocalDB.create(localdb_file, clean=True)
