def __init__(self): user_folder = conan_expand_user("~") server_folder = os.path.join(user_folder, '.conan_server') server_config = migrate_and_get_server_config(user_folder) custom_auth = server_config.custom_authenticator if custom_auth: authenticator = load_authentication_plugin(server_folder, custom_auth) else: authenticator = BasicAuthenticator(dict(server_config.users)) authorizer = BasicAuthorizer(server_config.read_permissions, server_config.write_permissions) credentials_manager = JWTCredentialsManager( server_config.jwt_secret, server_config.jwt_expire_time) updown_auth_manager = JWTUpDownAuthManager( server_config.updown_secret, server_config.authorize_timeout) file_manager = get_file_manager( server_config, updown_auth_manager=updown_auth_manager) search_adapter = DiskSearchAdapter() search_manager = DiskSearchManager( SimplePaths(server_config.disk_storage_path), search_adapter) server_capabilities = SERVER_CAPABILITIES self.ra = ConanServer(server_config.port, credentials_manager, updown_auth_manager, authorizer, authenticator, file_manager, search_manager, Version(SERVER_VERSION), Version(MIN_CLIENT_COMPATIBLE_VERSION), server_capabilities)
def storage_path(self): # Try with CONAN_STORAGE_PATH result = get_env('CONAN_STORAGE_PATH', None) # Try with conan.conf "path" if not result: try: env_conan_user_home = os.getenv("CONAN_USER_HOME") # if env var is declared, any specified path will be relative to CONAN_USER_HOME # even with the ~/ if env_conan_user_home: storage = self.storage["path"] if storage[:2] == "~/": storage = storage[2:] result = os.path.join(env_conan_user_home, storage) else: result = self.storage["path"] except KeyError: pass # expand the result and check if absolute if result: result = conan_expand_user(result) if not os.path.isabs(result): raise ConanException("Conan storage path has to be an absolute path") return result
def storage_path(self): # Try with CONAN_STORAGE_PATH result = get_env('CONAN_STORAGE_PATH', None) # Try with conan.conf "path" if not result: try: env_conan_user_home = os.getenv("CONAN_USER_HOME") # if env var is declared, any specified path will be relative to CONAN_USER_HOME # even with the ~/ if env_conan_user_home: storage = self.storage["path"] if storage[:2] == "~/": storage = storage[2:] result = os.path.join(env_conan_user_home, storage) else: result = self.storage["path"] except KeyError: pass # expand the result and check if absolute if result: result = conan_expand_user(result) if not os.path.isabs(result): raise ConanException( "Conan storage path has to be an absolute path") return result
def storage_path(self): # Try with CONAN_STORAGE_PATH result = get_env('CONAN_STORAGE_PATH', None) if not result: # Try with conan.conf "path" try: # TODO: Fix this mess for Conan 2.0 env_conan_user_home = os.getenv("CONAN_USER_HOME") current_dir = os.path.dirname(self.filename) # if env var is declared, any specified path will be relative to CONAN_USER_HOME # even with the ~/ result = self.storage["path"] if result.startswith("."): result = os.path.abspath(os.path.join(current_dir, result)) elif result[:2] == "~/": if env_conan_user_home: result = os.path.join(env_conan_user_home, result[2:]) except (KeyError, ConanException): # If storage not defined, to return None pass if result: result = conan_expand_user(result) if not os.path.isabs(result): raise ConanException( "Conan storage path has to be an absolute path") return result
def __init__(self): user_folder = conan_expand_user("~") server_folder = os.path.join(user_folder, '.conan_server') server_config = migrate_and_get_server_config(user_folder) custom_auth = server_config.custom_authenticator if custom_auth: authenticator = load_authentication_plugin(server_folder, custom_auth) else: authenticator = BasicAuthenticator(dict(server_config.users)) authorizer = BasicAuthorizer(server_config.read_permissions, server_config.write_permissions) credentials_manager = JWTCredentialsManager(server_config.jwt_secret, server_config.jwt_expire_time) updown_auth_manager = JWTUpDownAuthManager(server_config.updown_secret, server_config.authorize_timeout) server_store = get_server_store(server_config.disk_storage_path, server_config.public_url, updown_auth_manager=updown_auth_manager) server_capabilities = SERVER_CAPABILITIES server_capabilities.append(REVISIONS) self.ra = ConanServer(server_config.port, credentials_manager, updown_auth_manager, authorizer, authenticator, server_store, Version(SERVER_VERSION), Version(MIN_CLIENT_COMPATIBLE_VERSION), server_capabilities, only_v1=False)
def __init__(self): user_folder = conan_expand_user("~") server_config = migrate_and_get_server_config(user_folder) authorizer = BasicAuthorizer(server_config.read_permissions, server_config.write_permissions) authenticator = BasicAuthenticator(dict(server_config.users)) credentials_manager = JWTCredentialsManager( server_config.jwt_secret, server_config.jwt_expire_time) updown_auth_manager = JWTUpDownAuthManager( server_config.updown_secret, server_config.authorize_timeout) file_manager = get_file_manager( server_config, updown_auth_manager=updown_auth_manager) search_adapter = DiskSearchAdapter() search_manager = DiskSearchManager( SimplePaths(server_config.disk_storage_path), search_adapter) self.ra = ConanServer(server_config.port, server_config.ssl_enabled, credentials_manager, updown_auth_manager, authorizer, authenticator, file_manager, search_manager, Version(SERVER_VERSION), Version(MIN_CLIENT_COMPATIBLE_VERSION))
def test_values(self): config = ConanServerConfigParser(self.file_path, environment=self.environ) self.assertEquals(config.jwt_secret, "mysecret") self.assertEquals(config.jwt_expire_time, timedelta(minutes=121)) self.assertEquals(config.disk_storage_path, self.storage_path) self.assertTrue(config.ssl_enabled) self.assertEquals(config.port, 9220) self.assertEquals(config.write_permissions, [("openssl/2.0.1@lasote/testing", "pepe")]) self.assertEquals(config.read_permissions, [("*/*@*/*", "*"), ("openssl/2.0.1@lasote/testing", "pepe")]) self.assertEquals(config.users, {"lasote": "defaultpass", "pepe": "pepepass"}) # Now check with environments tmp_storage = temp_folder() self.environ["CONAN_STORAGE_PATH"] = tmp_storage self.environ["CONAN_JWT_SECRET"] = "newkey" self.environ["CONAN_JWT_EXPIRE_MINUTES"] = "123" self.environ["CONAN_SSL_ENABLED"] = "False" self.environ["CONAN_SERVER_PORT"] = "1233" self.environ["CONAN_SERVER_USERS"] = "lasote:lasotepass,pepe2:pepepass2" config = ConanServerConfigParser(self.file_path, environment=self.environ) self.assertEquals(config.jwt_secret, "newkey") self.assertEquals(config.jwt_expire_time, timedelta(minutes=123)) self.assertEquals(config.disk_storage_path, conan_expand_user(tmp_storage)) self.assertFalse(config.ssl_enabled) self.assertEquals(config.port, 1233) self.assertEquals(config.write_permissions, [("openssl/2.0.1@lasote/testing", "pepe")]) self.assertEquals(config.read_permissions, [("*/*@*/*", "*"), ("openssl/2.0.1@lasote/testing", "pepe")]) self.assertEquals(config.users, {"lasote": "lasotepass", "pepe2": "pepepass2"})
def __init__(self): user_folder = conan_expand_user("~") server_folder = os.path.join(user_folder, '.conan_server') server_config = migrate_and_get_server_config(user_folder) custom_auth = server_config.custom_authenticator if custom_auth: authenticator = load_authentication_plugin(server_folder, custom_auth) else: authenticator = BasicAuthenticator(dict(server_config.users)) authorizer = BasicAuthorizer(server_config.read_permissions, server_config.write_permissions) credentials_manager = JWTCredentialsManager(server_config.jwt_secret, server_config.jwt_expire_time) updown_auth_manager = JWTUpDownAuthManager(server_config.updown_secret, server_config.authorize_timeout) file_manager = get_file_manager(server_config, updown_auth_manager=updown_auth_manager) search_manager = DiskSearchManager(SimplePaths(server_config.disk_storage_path)) server_capabilities = SERVER_CAPABILITIES self.ra = ConanServer(server_config.port, credentials_manager, updown_auth_manager, authorizer, authenticator, file_manager, search_manager, Version(SERVER_VERSION), Version(MIN_CLIENT_COMPATIBLE_VERSION), server_capabilities)
def get_command(): 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 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) user_folder = os.getenv("CONAN_USER_HOME", conan_expand_user("~")) try: # To capture exceptions in conan.conf parsing client_cache = ClientCache(user_folder, None, out) # obtain a temp ConanManager instance to execute the migrations remote_manager = instance_remote_manager(client_cache) # Get a DiskSearchManager search_adapter = DiskSearchAdapter() search_manager = DiskSearchManager(client_cache, search_adapter) manager = ConanManager(client_cache, user_io, ConanRunner(), remote_manager, search_manager) client_cache = migrate_and_get_client_cache(user_folder, out, manager) except Exception as e: out.error(str(e)) sys.exit(True) # Get the new command instance after migrations have been done remote_manager = instance_remote_manager(client_cache) # Get a search manager search_adapter = DiskSearchAdapter() search_manager = DiskSearchManager(client_cache, search_adapter) command = Command(client_cache, user_io, ConanRunner(), remote_manager, search_manager) return command
def expand_user_test(self): if platform.system() == "Windows": old_env = dict(os.environ) try: os.environ["HOME"] = "%USERPROFILE%" user_home = conan_expand_user("~") finally: os.environ.clear() os.environ.update(old_env) self.assertTrue(os.path.exists(user_home))
def factory(): """Factory""" def instance_remote_manager(client_cache): requester = get_basic_requester(client_cache) # Verify client version against remotes version_checker_requester = 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_requester, 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 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) user_folder = os.getenv("CONAN_USER_HOME", conan_expand_user("~")) try: client_cache = migrate_and_get_client_cache(user_folder, out) 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 remote_manager = instance_remote_manager(client_cache) # Get a search manager search_adapter = DiskSearchAdapter() search_manager = DiskSearchManager(client_cache, search_adapter) conan = Conan(client_cache, user_io, get_conan_runner(), remote_manager, search_manager) return conan
def get_command(): 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 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) user_folder = os.getenv("CONAN_USER_HOME", conan_expand_user("~")) try: # To capture exceptions in conan.conf parsing client_cache = ClientCache(user_folder, None, out) # obtain a temp ConanManager instance to execute the migrations remote_manager = instance_remote_manager(client_cache) # Get a DiskSearchManager search_adapter = DiskSearchAdapter() search_manager = DiskSearchManager(client_cache, search_adapter) manager = ConanManager(client_cache, user_io, ConanRunner(), remote_manager, search_manager) client_cache = migrate_and_get_client_cache(user_folder, out, manager) except Exception as e: out.error(str(e)) sys.exit(True) # Get the new command instance after migrations have been done remote_manager = instance_remote_manager(client_cache) # Get a search manager search_adapter = DiskSearchAdapter() search_manager = DiskSearchManager(client_cache, search_adapter) command = Command(client_cache, user_io, ConanRunner(), remote_manager, search_manager) return command
def disk_storage_path(self): """If adapter is disk, means the directory for storage""" try: ret = conan_expand_user(self._get_conf_server_string("disk_storage_path")) except ConanException: # If storage_path is not defined, use the current dir # So tests use test folder instead of user/.conan_server ret = os.path.dirname(self.config_filename) ret = os.path.normpath(ret) # Convert to O.S paths mkdir(ret) return ret
def factory(): """Factory""" def instance_remote_manager(client_cache): requester = get_basic_requester(client_cache) # Verify client version against remotes version_checker_requester = 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_requester, 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 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) user_folder = os.getenv("CONAN_USER_HOME", conan_expand_user("~")) try: client_cache = migrate_and_get_client_cache(user_folder, out) 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 remote_manager = instance_remote_manager(client_cache) # Get a search manager search_adapter = DiskSearchAdapter() search_manager = DiskSearchManager(client_cache, search_adapter) conan = Conan(client_cache, user_io, get_conan_runner(), remote_manager, search_manager) return conan
def storage_path(self): try: conan_user_home = os.getenv("CONAN_USER_HOME") if conan_user_home: storage = self.storage["path"] if storage[:2] == "~/": storage = storage[2:] result = os.path.join(conan_user_home, storage) else: result = conan_expand_user(self.storage["path"]) except KeyError: result = None result = get_env('CONAN_STORAGE_PATH', result) return result
def __init__(self, force_migration=False, server_dir=None): if sys.version_info.major == 2: raise Exception("The conan_server needs Python>=3 for running") self.force_migration = force_migration if server_dir: user_folder = server_folder = server_dir else: user_folder = conan_expand_user("~") server_folder = os.path.join(user_folder, '.conan_server') server_config = migrate_and_get_server_config(user_folder, self.force_migration, server_dir is not None) custom_auth = server_config.custom_authenticator if custom_auth: authenticator = load_authentication_plugin(server_folder, custom_auth) else: authenticator = BasicAuthenticator(dict(server_config.users)) authorizer = BasicAuthorizer(server_config.read_permissions, server_config.write_permissions) credentials_manager = JWTCredentialsManager( server_config.jwt_secret, server_config.jwt_expire_time) updown_auth_manager = JWTUpDownAuthManager( server_config.updown_secret, server_config.authorize_timeout) server_store = get_server_store( server_config.disk_storage_path, server_config.public_url, updown_auth_manager=updown_auth_manager) server_capabilities = SERVER_CAPABILITIES server_capabilities.append(REVISIONS) self.server = ConanServer(server_config.port, credentials_manager, updown_auth_manager, authorizer, authenticator, server_store, server_capabilities) if not self.force_migration: print("***********************") print("Using config: %s" % server_config.config_filename) print("Storage: %s" % server_config.disk_storage_path) print("Public URL: %s" % server_config.public_url) print("PORT: %s" % server_config.port) print("***********************")
def __init__(self, force_migration=False): self.force_migration = force_migration user_folder = conan_expand_user("~") server_folder = os.path.join(user_folder, '.conan_server') server_config = migrate_and_get_server_config(user_folder, None, self.force_migration) custom_auth = server_config.custom_authenticator if custom_auth: authenticator = load_authentication_plugin(server_folder, custom_auth) else: authenticator = BasicAuthenticator(dict(server_config.users)) authorizer = BasicAuthorizer(server_config.read_permissions, server_config.write_permissions) credentials_manager = JWTCredentialsManager( server_config.jwt_secret, server_config.jwt_expire_time) updown_auth_manager = JWTUpDownAuthManager( server_config.updown_secret, server_config.authorize_timeout) server_store = get_server_store( server_config.disk_storage_path, server_config.public_url, updown_auth_manager=updown_auth_manager) server_capabilities = SERVER_CAPABILITIES server_capabilities.append(REVISIONS) self.server = ConanServer(server_config.port, credentials_manager, updown_auth_manager, authorizer, authenticator, server_store, Version(SERVER_VERSION), Version(MIN_CLIENT_COMPATIBLE_VERSION), server_capabilities) if not self.force_migration: print("***********************") print("Using config: %s" % server_config.config_filename) print("Storage: %s" % server_config.disk_storage_path) print("Public URL: %s" % server_config.public_url) print("PORT: %s" % server_config.port) print("***********************")
def __init__(self): user_folder = conan_expand_user("~") server_config = migrate_and_get_server_config(user_folder) authorizer = BasicAuthorizer(server_config.read_permissions, server_config.write_permissions) authenticator = BasicAuthenticator(dict(server_config.users)) credentials_manager = JWTCredentialsManager(server_config.jwt_secret, server_config.jwt_expire_time) updown_auth_manager = JWTUpDownAuthManager(server_config.updown_secret, server_config.authorize_timeout) file_manager = get_file_manager(server_config, updown_auth_manager=updown_auth_manager) search_adapter = DiskSearchAdapter() search_manager = DiskSearchManager(SimplePaths(server_config.disk_storage_path), search_adapter) self.ra = ConanServer(server_config.port, server_config.ssl_enabled, credentials_manager, updown_auth_manager, authorizer, authenticator, file_manager, search_manager, Version(SERVER_VERSION), Version(MIN_CLIENT_COMPATIBLE_VERSION))