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 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)