diff --git a/packages/google-api-core/google/api_core/grpc_helpers.py b/packages/google-api-core/google/api_core/grpc_helpers.py index 78b434e0bbdd..1e0f029964e2 100644 --- a/packages/google-api-core/google/api_core/grpc_helpers.py +++ b/packages/google-api-core/google/api_core/grpc_helpers.py @@ -17,6 +17,7 @@ import collections import functools import os +import re import urllib.parse import warnings from typing import ( @@ -38,10 +39,14 @@ import google.protobuf import grpc -from google.api_core import exceptions, general_helpers +from google.api_core import exceptions, general_helpers, universe from google.api_core._feature_gating_helpers import _strtobool _DIRECT_PATH_INTERCONNECT_ENV = "GOOGLE_CLOUD_ENABLE_DIRECT_PATH_XDS_OVER_INTERCONNECT" +_GOOGLEAPIS_HOST_PATTERN = re.compile( + rf"^(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)*{re.escape(universe.DEFAULT_UNIVERSE)}$", + re.IGNORECASE, +) def _resolve_direct_path_interconnect( @@ -91,6 +96,15 @@ def _extract_target_host(target: str) -> str: return target +def _is_googleapis_host(target: str) -> bool: + """Returns True if ``target`` resolves to a ``googleapis.com`` host.""" + return ( + "@" not in target + and "#" not in target + and bool(_GOOGLEAPIS_HOST_PATTERN.fullmatch(_extract_target_host(target))) + ) + + def _extract_direct_path_authority(target: str) -> Optional[str]: """Extracts the canonical TLS/HTTP2 authority for a ``-direct.googleapis.com`` target.""" clean_host = _extract_target_host(target) @@ -310,6 +324,28 @@ def _create_composite_credentials( Raises: google.api_core.DuplicateCredentialArgs: If both a credentials object and credentials_file are passed. """ + credentials = _resolve_credentials( + credentials=credentials, + credentials_file=credentials_file, + default_scopes=default_scopes, + scopes=scopes, + quota_project_id=quota_project_id, + ) + return _compose_channel_credentials( + credentials=credentials, + ssl_credentials=ssl_credentials, + default_host=default_host, + ) + + +def _resolve_credentials( + credentials=None, + credentials_file=None, + default_scopes=None, + scopes=None, + quota_project_id=None, +): + """Resolve auth credentials from explicit credentials, a file, or ADC.""" if credentials_file is not None: warnings.warn(general_helpers._CREDENTIALS_FILE_WARNING, DeprecationWarning) @@ -336,6 +372,15 @@ def _create_composite_credentials( ): credentials = credentials.with_quota_project(quota_project_id) + return credentials + + +def _compose_channel_credentials( + credentials, + ssl_credentials=None, + default_host=None, +): + """Compose gRPC channel credentials from resolved auth credentials.""" request = google.auth.transport.requests.Request() # Create the metadata plugin for inserting the authorization header. @@ -409,12 +454,16 @@ def _setup_direct_path_and_credentials( library. Use 'scopes' for user-defined scopes. default_host (str): The default endpoint. e.g., "pubsub.googleapis.com". attempt_direct_path (Optional[bool]): If set, Direct Path will be attempted. + Ignored if ``target`` is not a ``googleapis.com`` host or the + resolved credentials' ``universe_domain`` is not ``googleapis.com``. attempt_direct_path_xds_over_interconnect (Optional[bool]): If set, DirectPath over Cloud Interconnect will be attempted using standard TLS credentials and ``?force-xds`` C2P target resolution. If None (default), the setting is resolved from the ``GOOGLE_CLOUD_ENABLE_DIRECT_PATH_XDS_OVER_INTERCONNECT`` - environment variable. + environment variable. Ignored if ``target`` is not a + ``googleapis.com`` host or the resolved credentials' + ``universe_domain`` is not ``googleapis.com``. kwargs: Additional key-word args passed to the channel creation function. Returns: @@ -425,8 +474,17 @@ def _setup_direct_path_and_credentials( google.api_core.DuplicateCredentialArgs: If both a credentials object and credentials_file are passed. ValueError: If `ssl_credentials` is set and `attempt_direct_path` is - set to `True` without `attempt_direct_path_xds_over_interconnect`. + set to `True` without `attempt_direct_path_xds_over_interconnect` + in the ``googleapis.com`` universe. """ + credentials = _resolve_credentials( + credentials=credentials, + credentials_file=credentials_file, + default_scopes=default_scopes, + scopes=scopes, + quota_project_id=quota_project_id, + ) + if attempt_direct_path or attempt_direct_path_xds_over_interconnect is not None: use_dp_interconnect = _resolve_direct_path_interconnect( attempt_direct_path_xds_over_interconnect @@ -434,6 +492,18 @@ def _setup_direct_path_and_credentials( else: use_dp_interconnect = False + # DirectPath and DirectPath over Interconnect are only supported in the + # Google Default Universe (googleapis.com). Disable both if either the + # target host or the resolved credential universe_domain is non-GDU. + if attempt_direct_path or use_dp_interconnect: + if not ( + _is_googleapis_host(target) + and getattr(credentials, "universe_domain", universe.DEFAULT_UNIVERSE) + == universe.DEFAULT_UNIVERSE + ): + attempt_direct_path = False + use_dp_interconnect = False + # If `ssl_credentials` is set and `attempt_direct_path` is set to `True`, # raise ValueError as this is not yet supported for GCE ALTS DirectPath. # See https://github.com/googleapis/python-api-core/issues/590 @@ -443,13 +513,9 @@ def _setup_direct_path_and_credentials( if use_dp_interconnect and ssl_credentials is None: ssl_credentials = grpc.ssl_channel_credentials() - composite_credentials = _create_composite_credentials( + composite_credentials = _compose_channel_credentials( credentials=credentials, - credentials_file=credentials_file, - default_scopes=default_scopes, - scopes=scopes, ssl_credentials=ssl_credentials, - quota_project_id=quota_project_id, default_host=default_host, ) @@ -546,12 +612,17 @@ def create_channel( `False` as the Service may not support Direct Path. - Using `ssl_credentials` with `attempt_direct_path` set to `True` will result in `ValueError` as this combination is not yet supported. + - Ignored if ``target`` is not a ``googleapis.com`` host or the + resolved credentials' ``universe_domain`` is not + ``googleapis.com``. attempt_direct_path_xds_over_interconnect (Optional[bool]): If set, DirectPath over Cloud Interconnect will be attempted using standard TLS credentials and ``?force-xds`` C2P target resolution. If None (default), the setting is resolved from the ``GOOGLE_CLOUD_ENABLE_DIRECT_PATH_XDS_OVER_INTERCONNECT`` - environment variable. + environment variable. Ignored if ``target`` is not a + ``googleapis.com`` host or the resolved credentials' + ``universe_domain`` is not ``googleapis.com``. kwargs: Additional key-word args passed to :func:`grpc.secure_channel`. diff --git a/packages/google-api-core/google/api_core/grpc_helpers_async.py b/packages/google-api-core/google/api_core/grpc_helpers_async.py index 7d6bbf275972..a73a3fa72a77 100644 --- a/packages/google-api-core/google/api_core/grpc_helpers_async.py +++ b/packages/google-api-core/google/api_core/grpc_helpers_async.py @@ -271,12 +271,17 @@ def create_channel( `False` as the Service may not support Direct Path. - Using `ssl_credentials` with `attempt_direct_path` set to `True` will result in `ValueError` as this combination is not yet supported. + - Ignored if ``target`` is not a ``googleapis.com`` host or the + resolved credentials' ``universe_domain`` is not + ``googleapis.com``. attempt_direct_path_xds_over_interconnect (Optional[bool]): If set, DirectPath over Cloud Interconnect will be attempted using standard TLS credentials and ``?force-xds`` C2P target resolution. If None (default), the setting is resolved from the ``GOOGLE_CLOUD_ENABLE_DIRECT_PATH_XDS_OVER_INTERCONNECT`` - environment variable. + environment variable. Ignored if ``target`` is not a + ``googleapis.com`` host or the resolved credentials' + ``universe_domain`` is not ``googleapis.com``. kwargs: Additional key-word args passed to :func:`aio.secure_channel`. diff --git a/packages/google-api-core/tests/asyncio/test_grpc_helpers_async.py b/packages/google-api-core/tests/asyncio/test_grpc_helpers_async.py index 137c9e44a478..b1ef95eae918 100644 --- a/packages/google-api-core/tests/asyncio/test_grpc_helpers_async.py +++ b/packages/google-api-core/tests/asyncio/test_grpc_helpers_async.py @@ -344,8 +344,13 @@ def test_wrap_errors_streaming(wrap_stream_errors): [ (None, "example.com:443", "example.com:443"), (False, "example.com:443", "example.com:443"), - (True, "example.com:443", "google-c2p:///example.com"), - (True, "dns:///example.com", "google-c2p:///example.com"), + (True, "example.com:443", "example.com:443"), + (True, "example.googleapis.com:443", "google-c2p:///example.googleapis.com"), + ( + True, + "dns:///example.googleapis.com", + "google-c2p:///example.googleapis.com", + ), (True, "another-c2p:///example.com", "another-c2p:///example.com"), ], ) @@ -383,8 +388,13 @@ def test_create_channel_implicit( [ (None, "example.com:443", "example.com:443"), (False, "example.com:443", "example.com:443"), - (True, "example.com:443", "google-c2p:///example.com"), - (True, "dns:///example.com", "google-c2p:///example.com"), + (True, "example.com:443", "example.com:443"), + (True, "example.googleapis.com:443", "google-c2p:///example.googleapis.com"), + ( + True, + "dns:///example.googleapis.com", + "google-c2p:///example.googleapis.com", + ), (True, "another-c2p:///example.com", "another-c2p:///example.com"), ], ) @@ -467,8 +477,15 @@ def test_create_channel_implicit_with_ssl_creds( ) -def test_create_channel_implicit_with_ssl_creds_attempt_direct_path_true(): - target = "example.com:443" +@mock.patch( + "google.auth.default", + autospec=True, + return_value=(mock.sentinel.credentials, mock.sentinel.project), +) +def test_create_channel_implicit_with_ssl_creds_attempt_direct_path_true( + google_auth_default, +): + target = "example.googleapis.com:443" ssl_creds = grpc.ssl_channel_credentials() with pytest.raises( ValueError, match="Using ssl_credentials with Direct Path is not supported" @@ -476,6 +493,7 @@ def test_create_channel_implicit_with_ssl_creds_attempt_direct_path_true(): grpc_helpers_async.create_channel( target, ssl_credentials=ssl_creds, attempt_direct_path=True ) + google_auth_default.assert_called_once_with(scopes=None, default_scopes=None) @mock.patch("grpc.compute_engine_channel_credentials") @@ -871,7 +889,12 @@ def test_create_channel_interconnect_fallback_preserves_non_google_direct_host( ) -def test_create_channel_async_invalid_env_var_raises(monkeypatch): +@mock.patch( + "google.auth.default", + autospec=True, + return_value=(mock.sentinel.credentials, mock.sentinel.project), +) +def test_create_channel_async_invalid_env_var_raises(google_auth_default, monkeypatch): monkeypatch.setenv( "GOOGLE_CLOUD_ENABLE_DIRECT_PATH_XDS_OVER_INTERCONNECT", "invalid" ) @@ -883,6 +906,7 @@ def test_create_channel_async_invalid_env_var_raises(monkeypatch): "storage-direct.googleapis.com:443", attempt_direct_path=True, ) + google_auth_default.assert_called_once_with(scopes=None, default_scopes=None) @mock.patch("grpc.ssl_channel_credentials") @@ -1105,3 +1129,229 @@ class CustomInterceptor: result = grpc_helpers_async.apply_channel_interceptors(channel, [interceptor]) assert result is channel mock_append.append.assert_called_once_with(interceptor) + + +@pytest.mark.parametrize( + "target", + [ + "storage.universe.domain:443", + "dns:///storage.universe.domain:443", + "evilgoogleapis.com:443", + "storage.googleapis.com.universe.domain:443", + ], +) +@pytest.mark.parametrize( + "attempt_direct_path,attempt_interconnect,env_val", + [ + (True, None, None), + (True, True, None), + (False, True, None), + (True, None, "true"), + ], +) +@mock.patch("grpc.ssl_channel_credentials") +@mock.patch("grpc.compute_engine_channel_credentials") +@mock.patch("grpc.aio.secure_channel") +def test_create_channel_async_disables_direct_path_for_non_googleapis_target( + grpc_secure_channel, + compute_engine_creds_call, + ssl_creds_call, + monkeypatch, + target, + attempt_direct_path, + attempt_interconnect, + env_val, +): + if env_val is None: + monkeypatch.delenv( + "GOOGLE_CLOUD_ENABLE_DIRECT_PATH_XDS_OVER_INTERCONNECT", raising=False + ) + else: + monkeypatch.setenv( + "GOOGLE_CLOUD_ENABLE_DIRECT_PATH_XDS_OVER_INTERCONNECT", env_val + ) + + creds = mock.create_autospec(google.auth.credentials.Credentials, instance=True) + creds.universe_domain = "googleapis.com" + + grpc_helpers_async.create_channel( + target, + credentials=creds, + default_host="storage.googleapis.com", + attempt_direct_path=attempt_direct_path, + attempt_direct_path_xds_over_interconnect=attempt_interconnect, + ) + + ssl_creds_call.assert_not_called() + grpc_secure_channel.assert_called_once_with( + target, + compute_engine_creds_call.return_value, + compression=None, + ) + + +@pytest.mark.parametrize("universe_domain", ["universe.domain", None, ""]) +@pytest.mark.parametrize( + "target,expected_target", + [ + ("storage.googleapis.com:443", "storage.googleapis.com:443"), + ("storage-direct.googleapis.com:443", "storage.googleapis.com:443"), + ], +) +@pytest.mark.parametrize( + "attempt_direct_path,attempt_interconnect,env_val", + [ + (True, None, None), + (True, True, None), + (False, True, None), + (True, None, "true"), + ], +) +@mock.patch("grpc.ssl_channel_credentials") +@mock.patch("grpc.compute_engine_channel_credentials") +@mock.patch("grpc.aio.secure_channel") +def test_create_channel_async_disables_direct_path_for_non_gdu_explicit_credentials( + grpc_secure_channel, + compute_engine_creds_call, + ssl_creds_call, + monkeypatch, + universe_domain, + target, + expected_target, + attempt_direct_path, + attempt_interconnect, + env_val, +): + if env_val is None: + monkeypatch.delenv( + "GOOGLE_CLOUD_ENABLE_DIRECT_PATH_XDS_OVER_INTERCONNECT", raising=False + ) + else: + monkeypatch.setenv( + "GOOGLE_CLOUD_ENABLE_DIRECT_PATH_XDS_OVER_INTERCONNECT", env_val + ) + + creds = mock.create_autospec(google.auth.credentials.Credentials, instance=True) + creds.universe_domain = universe_domain + + grpc_helpers_async.create_channel( + target, + credentials=creds, + attempt_direct_path=attempt_direct_path, + attempt_direct_path_xds_over_interconnect=attempt_interconnect, + ) + + ssl_creds_call.assert_not_called() + grpc_secure_channel.assert_called_once_with( + expected_target, + compute_engine_creds_call.return_value, + compression=None, + ) + + +@mock.patch("grpc.ssl_channel_credentials") +@mock.patch("grpc.composite_channel_credentials") +@mock.patch("grpc.compute_engine_channel_credentials") +@mock.patch("google.auth.default", autospec=True) +@mock.patch("grpc.aio.secure_channel") +def test_create_channel_async_disables_direct_path_for_non_gdu_adc_and_ssl( + grpc_secure_channel, + google_auth_default, + compute_engine_creds_call, + composite_creds_call, + ssl_creds_call, + monkeypatch, +): + monkeypatch.setenv("GOOGLE_CLOUD_ENABLE_DIRECT_PATH_XDS_OVER_INTERCONNECT", "true") + creds = mock.create_autospec(google.auth.credentials.Credentials, instance=True) + creds.universe_domain = "universe.domain" + google_auth_default.return_value = (creds, "test-project") + + grpc_helpers_async.create_channel( + "storage-direct.googleapis.com:443", + attempt_direct_path=True, + ) + + google_auth_default.assert_called_once_with(scopes=None, default_scopes=None) + ssl_creds_call.assert_not_called() + grpc_secure_channel.assert_called_once_with( + "storage.googleapis.com:443", + compute_engine_creds_call.return_value, + compression=None, + ) + + monkeypatch.delenv( + "GOOGLE_CLOUD_ENABLE_DIRECT_PATH_XDS_OVER_INTERCONNECT", raising=False + ) + custom_ssl = mock.sentinel.custom_ssl + grpc_helpers_async.create_channel( + "storage.googleapis.com:443", + ssl_credentials=custom_ssl, + attempt_direct_path=True, + ) + composite_creds_call.assert_called_once_with(custom_ssl, mock.ANY) + grpc_secure_channel.assert_called_with( + "storage.googleapis.com:443", + composite_creds_call.return_value, + compression=None, + ) + + +@mock.patch("grpc.ssl_channel_credentials") +@mock.patch("grpc.compute_engine_channel_credentials") +@mock.patch("google.auth.load_credentials_from_file", autospec=True) +@mock.patch("grpc.aio.secure_channel") +def test_create_channel_async_disables_direct_path_for_non_gdu_credentials_file( + grpc_secure_channel, + load_credentials_from_file, + compute_engine_creds_call, + ssl_creds_call, +): + creds = mock.create_autospec(google.auth.credentials.Credentials, instance=True) + creds.universe_domain = "universe.domain" + load_credentials_from_file.return_value = (creds, "test-project") + + with warn_deprecated_credentials_file(): + grpc_helpers_async.create_channel( + "storage-direct.googleapis.com:443", + credentials_file="/path/to/creds.json", + attempt_direct_path=True, + attempt_direct_path_xds_over_interconnect=True, + ) + + load_credentials_from_file.assert_called_once_with( + "/path/to/creds.json", scopes=None, default_scopes=None + ) + ssl_creds_call.assert_not_called() + grpc_secure_channel.assert_called_once_with( + "storage.googleapis.com:443", + compute_engine_creds_call.return_value, + compression=None, + ) + + +@mock.patch("grpc.compute_engine_channel_credentials") +@mock.patch("grpc.aio.secure_channel") +def test_create_channel_async_does_not_access_universe_domain_when_unneeded( + grpc_secure_channel, + compute_engine_creds_call, +): + class FailingUniverseCreds: + requires_scopes = False + + @property + def universe_domain(self): # pragma: NO COVER + raise AssertionError("universe_domain should not be accessed") + + creds = FailingUniverseCreds() + + grpc_helpers_async.create_channel( + "storage.googleapis.com:443", + credentials=creds, + attempt_direct_path=False, + ) + grpc_secure_channel.assert_called_once_with( + "storage.googleapis.com:443", + compute_engine_creds_call.return_value, + compression=None, + ) diff --git a/packages/google-api-core/tests/unit/test_grpc_helpers.py b/packages/google-api-core/tests/unit/test_grpc_helpers.py index 87b716ef9744..e9c0255d0f8a 100644 --- a/packages/google-api-core/tests/unit/test_grpc_helpers.py +++ b/packages/google-api-core/tests/unit/test_grpc_helpers.py @@ -373,8 +373,13 @@ def test_wrap_errors_streaming(wrap_stream_errors): [ (None, "example.com:443", "example.com:443"), (False, "example.com:443", "example.com:443"), - (True, "example.com:443", "google-c2p:///example.com"), - (True, "dns:///example.com", "google-c2p:///example.com"), + (True, "example.com:443", "example.com:443"), + (True, "example.googleapis.com:443", "google-c2p:///example.googleapis.com"), + ( + True, + "dns:///example.googleapis.com", + "google-c2p:///example.googleapis.com", + ), (True, "another-c2p:///example.com", "another-c2p:///example.com"), ], ) @@ -415,8 +420,13 @@ def test_create_channel_implicit( [ (None, "example.com:443", "example.com:443"), (False, "example.com:443", "example.com:443"), - (True, "example.com:443", "google-c2p:///example.com"), - (True, "dns:///example.com", "google-c2p:///example.com"), + (True, "example.com:443", "example.com:443"), + (True, "example.googleapis.com:443", "google-c2p:///example.googleapis.com"), + ( + True, + "dns:///example.googleapis.com", + "google-c2p:///example.googleapis.com", + ), (True, "another-c2p:///example.com", "another-c2p:///example.com"), ], ) @@ -503,8 +513,15 @@ def test_create_channel_implicit_with_ssl_creds( ) -def test_create_channel_implicit_with_ssl_creds_attempt_direct_path_true(): - target = "example.com:443" +@mock.patch( + "google.auth.default", + autospec=True, + return_value=(mock.sentinel.credentials, mock.sentinel.project), +) +def test_create_channel_implicit_with_ssl_creds_attempt_direct_path_true( + google_auth_default, +): + target = "example.googleapis.com:443" ssl_creds = grpc.ssl_channel_credentials() with pytest.raises( ValueError, match="Using ssl_credentials with Direct Path is not supported" @@ -512,6 +529,7 @@ def test_create_channel_implicit_with_ssl_creds_attempt_direct_path_true(): grpc_helpers.create_channel( target, ssl_credentials=ssl_creds, attempt_direct_path=True ) + google_auth_default.assert_called_once_with(scopes=None, default_scopes=None) @mock.patch("grpc.compute_engine_channel_credentials") @@ -1444,3 +1462,435 @@ def test_create_channel_interconnect_gated_by_attempt_direct_path( compute_creds, compression=None, ) + + +@pytest.mark.parametrize( + "target,expected", + [ + ("storage.googleapis.com:443", True), + ("storage.googleapis.com", True), + ("googleapis.com:443", True), + ("googleapis.com", True), + ("storage-direct.googleapis.com:443", True), + ("us-east1-pubsub.googleapis.com:443", True), + ("storage.mtls.googleapis.com:443", True), + ("storage.mtls.sandbox.googleapis.com:443", True), + ("a.googleapis.com:443", True), + ("STORAGE.GOOGLEAPIS.COM:443", True), + ("dns:///storage.googleapis.com:443", True), + ("https://storage.googleapis.com:443/v1", True), + ("http://storage.googleapis.com:443", True), + ("google-c2p:///storage-direct.googleapis.com?force-xds", True), + ("storage.universe.domain:443", False), + ("dns:///storage.universe.domain:443", False), + ("https://storage.universe.domain:443", False), + ("google-c2p:///storage.universe.domain", False), + ("evilgoogleapis.com:443", False), + ("storage.googleapis.com.universe.domain:443", False), + (".googleapis.com:443", False), + ("-direct.googleapis.com:443", False), + ("storage-.googleapis.com:443", False), + ("a..b.googleapis.com:443", False), + ("https://?.googleapis.com", False), + ("[invalid.googleapis.com", False), + ("user@storage.googleapis.com:443", False), + ("storage.universe.domain:443@storage.googleapis.com", False), + ("storage.googleapis.com#universe.domain", False), + ("another-c2p:///storage.googleapis.com", False), + ("[::1]:8080", False), + ("", False), + ], +) +def test__is_googleapis_host(target, expected): + assert grpc_helpers._is_googleapis_host(target) is expected + + +@mock.patch("grpc.compute_engine_channel_credentials") +@mock.patch("grpc.metadata_call_credentials") +@mock.patch("google.auth.transport.grpc.AuthMetadataPlugin") +@mock.patch( + "google.auth.transport.requests.Request", + autospec=True, + return_value=mock.sentinel.Request, +) +@mock.patch( + "google.auth.default", + autospec=True, + return_value=(mock.sentinel.credentials, mock.sentinel.project), +) +def test__create_composite_credentials_and_legacy_auth_metadata_plugin( + google_auth_default, + request_cls, + auth_metadata_plugin, + metadata_call_creds, + compute_engine_creds, +): + plugin_instance = mock.sentinel.plugin + auth_metadata_plugin.side_effect = [ + TypeError("unexpected keyword argument 'suppress_metrics_header'"), + plugin_instance, + ] + + result = grpc_helpers._create_composite_credentials( + default_host="pubsub.googleapis.com" + ) + + assert result is compute_engine_creds.return_value + google_auth_default.assert_called_once_with(scopes=None, default_scopes=None) + assert auth_metadata_plugin.call_count == 2 + auth_metadata_plugin.assert_has_calls( + [ + mock.call( + mock.sentinel.credentials, + mock.sentinel.Request, + default_host="pubsub.googleapis.com", + suppress_metrics_header=True, + ), + mock.call( + mock.sentinel.credentials, + mock.sentinel.Request, + default_host="pubsub.googleapis.com", + ), + ] + ) + metadata_call_creds.assert_called_once_with(plugin_instance) + + +@pytest.mark.parametrize( + "target", + [ + "storage.universe.domain:443", + "dns:///storage.universe.domain:443", + "evilgoogleapis.com:443", + "storage.googleapis.com.universe.domain:443", + ], +) +@pytest.mark.parametrize( + "attempt_direct_path,attempt_interconnect,env_val", + [ + (True, None, None), + (True, True, None), + (False, True, None), + (True, None, "true"), + ], +) +@mock.patch("grpc.ssl_channel_credentials") +@mock.patch("grpc.compute_engine_channel_credentials") +@mock.patch("grpc.secure_channel") +def test_create_channel_disables_direct_path_for_non_googleapis_target( + grpc_secure_channel, + compute_engine_creds_call, + ssl_creds_call, + monkeypatch, + target, + attempt_direct_path, + attempt_interconnect, + env_val, +): + if env_val is None: + monkeypatch.delenv(grpc_helpers._DIRECT_PATH_INTERCONNECT_ENV, raising=False) + else: + monkeypatch.setenv(grpc_helpers._DIRECT_PATH_INTERCONNECT_ENV, env_val) + + creds = mock.create_autospec(google.auth.credentials.Credentials, instance=True) + creds.universe_domain = "googleapis.com" + + grpc_helpers.create_channel( + target, + credentials=creds, + default_host="storage.googleapis.com", + attempt_direct_path=attempt_direct_path, + attempt_direct_path_xds_over_interconnect=attempt_interconnect, + ) + + ssl_creds_call.assert_not_called() + grpc_secure_channel.assert_called_once_with( + target, + compute_engine_creds_call.return_value, + compression=None, + ) + + +@mock.patch("grpc.composite_channel_credentials") +@mock.patch("grpc.secure_channel") +def test_create_channel_allows_ssl_creds_when_direct_path_gated_off_by_target( + grpc_secure_channel, + composite_creds_call, +): + creds = mock.create_autospec(google.auth.credentials.Credentials, instance=True) + creds.universe_domain = "googleapis.com" + ssl_creds = mock.sentinel.ssl_creds + + grpc_helpers.create_channel( + "storage.universe.domain:443", + credentials=creds, + ssl_credentials=ssl_creds, + attempt_direct_path=True, + ) + + composite_creds_call.assert_called_once_with(ssl_creds, mock.ANY) + grpc_secure_channel.assert_called_once_with( + "storage.universe.domain:443", + composite_creds_call.return_value, + compression=None, + ) + + +@pytest.mark.parametrize("universe_domain", ["universe.domain", None, ""]) +@pytest.mark.parametrize( + "target,expected_target", + [ + ("storage.googleapis.com:443", "storage.googleapis.com:443"), + ("storage-direct.googleapis.com:443", "storage.googleapis.com:443"), + ], +) +@pytest.mark.parametrize( + "attempt_direct_path,attempt_interconnect,env_val", + [ + (True, None, None), + (True, True, None), + (False, True, None), + (True, None, "true"), + ], +) +@mock.patch("grpc.ssl_channel_credentials") +@mock.patch("grpc.compute_engine_channel_credentials") +@mock.patch("grpc.secure_channel") +def test_create_channel_disables_direct_path_for_non_gdu_explicit_credentials( + grpc_secure_channel, + compute_engine_creds_call, + ssl_creds_call, + monkeypatch, + universe_domain, + target, + expected_target, + attempt_direct_path, + attempt_interconnect, + env_val, +): + if env_val is None: + monkeypatch.delenv(grpc_helpers._DIRECT_PATH_INTERCONNECT_ENV, raising=False) + else: + monkeypatch.setenv(grpc_helpers._DIRECT_PATH_INTERCONNECT_ENV, env_val) + + creds = mock.create_autospec(google.auth.credentials.Credentials, instance=True) + creds.universe_domain = universe_domain + + grpc_helpers.create_channel( + target, + credentials=creds, + attempt_direct_path=attempt_direct_path, + attempt_direct_path_xds_over_interconnect=attempt_interconnect, + ) + + ssl_creds_call.assert_not_called() + grpc_secure_channel.assert_called_once_with( + expected_target, + compute_engine_creds_call.return_value, + compression=None, + ) + + +@mock.patch("grpc.ssl_channel_credentials") +@mock.patch("grpc.composite_channel_credentials") +@mock.patch("grpc.compute_engine_channel_credentials") +@mock.patch("google.auth.default", autospec=True) +@mock.patch("grpc.secure_channel") +def test_create_channel_disables_direct_path_for_non_gdu_adc_credentials( + grpc_secure_channel, + google_auth_default, + compute_engine_creds_call, + composite_creds_call, + ssl_creds_call, + monkeypatch, +): + monkeypatch.setenv(grpc_helpers._DIRECT_PATH_INTERCONNECT_ENV, "true") + creds = mock.create_autospec(google.auth.credentials.Credentials, instance=True) + creds.universe_domain = "universe.domain" + google_auth_default.return_value = (creds, "test-project") + + # 1. Without ssl_credentials: Interconnect and DirectPath are disabled, + # -direct.googleapis.com falls back to .googleapis.com, default called once + grpc_helpers.create_channel( + "storage-direct.googleapis.com:443", + attempt_direct_path=True, + ) + + google_auth_default.assert_called_once_with(scopes=None, default_scopes=None) + ssl_creds_call.assert_not_called() + grpc_secure_channel.assert_called_once_with( + "storage.googleapis.com:443", + compute_engine_creds_call.return_value, + compression=None, + ) + + # 2. With ssl_credentials and attempt_direct_path=True (Interconnect env unset): + # Does NOT raise ValueError because DirectPath is gated off for non-GDU ADC + monkeypatch.delenv(grpc_helpers._DIRECT_PATH_INTERCONNECT_ENV, raising=False) + custom_ssl = mock.sentinel.custom_ssl + grpc_helpers.create_channel( + "storage.googleapis.com:443", + ssl_credentials=custom_ssl, + attempt_direct_path=True, + ) + composite_creds_call.assert_called_once_with(custom_ssl, mock.ANY) + grpc_secure_channel.assert_called_with( + "storage.googleapis.com:443", + composite_creds_call.return_value, + compression=None, + ) + + +@mock.patch("grpc.ssl_channel_credentials") +@mock.patch("grpc.compute_engine_channel_credentials") +@mock.patch("google.auth.load_credentials_from_file", autospec=True) +@mock.patch("grpc.secure_channel") +def test_create_channel_disables_direct_path_for_non_gdu_credentials_file( + grpc_secure_channel, + load_credentials_from_file, + compute_engine_creds_call, + ssl_creds_call, +): + creds = mock.create_autospec(google.auth.credentials.Credentials, instance=True) + creds.universe_domain = "universe.domain" + load_credentials_from_file.return_value = (creds, "test-project") + + with warn_deprecated_credentials_file(): + grpc_helpers.create_channel( + "storage-direct.googleapis.com:443", + credentials_file="/path/to/creds.json", + attempt_direct_path=True, + attempt_direct_path_xds_over_interconnect=True, + ) + + load_credentials_from_file.assert_called_once_with( + "/path/to/creds.json", scopes=None, default_scopes=None + ) + ssl_creds_call.assert_not_called() + grpc_secure_channel.assert_called_once_with( + "storage.googleapis.com:443", + compute_engine_creds_call.return_value, + compression=None, + ) + + +@mock.patch("grpc.compute_engine_channel_credentials") +@mock.patch("grpc.secure_channel") +def test_create_channel_enables_direct_path_for_gdu_explicit_and_legacy_credentials( + grpc_secure_channel, + compute_engine_creds_call, +): + # Explicit credentials with universe_domain == "googleapis.com" + gdu_creds = mock.create_autospec(google.auth.credentials.Credentials, instance=True) + gdu_creds.universe_domain = "googleapis.com" + + grpc_helpers.create_channel( + "storage.googleapis.com:443", + credentials=gdu_creds, + attempt_direct_path=True, + ) + grpc_secure_channel.assert_called_once_with( + "google-c2p:///storage.googleapis.com", + compute_engine_creds_call.return_value, + compression=None, + ) + + # Legacy custom credentials without a universe_domain attribute default to GDU + class LegacyCreds: + requires_scopes = False + + grpc_helpers.create_channel( + "storage.googleapis.com:443", + credentials=LegacyCreds(), + attempt_direct_path=True, + ) + grpc_secure_channel.assert_called_with( + "google-c2p:///storage.googleapis.com", + compute_engine_creds_call.return_value, + compression=None, + ) + + +@mock.patch("grpc.compute_engine_channel_credentials") +@mock.patch("grpc.secure_channel") +def test_create_channel_does_not_access_universe_domain_when_unneeded( + grpc_secure_channel, + compute_engine_creds_call, +): + class FailingUniverseCreds: + requires_scopes = False + + @property + def universe_domain(self): # pragma: NO COVER + raise AssertionError("universe_domain should not be accessed") + + creds = FailingUniverseCreds() + + # 1. DirectPath not requested -> universe_domain is never read + grpc_helpers.create_channel( + "storage.googleapis.com:443", + credentials=creds, + attempt_direct_path=False, + ) + grpc_secure_channel.assert_called_once_with( + "storage.googleapis.com:443", + compute_engine_creds_call.return_value, + compression=None, + ) + + # 2. DirectPath requested on non-googleapis target -> short-circuits on host check + grpc_helpers.create_channel( + "storage.universe.domain:443", + credentials=creds, + attempt_direct_path=True, + ) + grpc_secure_channel.assert_called_with( + "storage.universe.domain:443", + compute_engine_creds_call.return_value, + compression=None, + ) + + +@mock.patch("grpc.compute_engine_channel_credentials") +@mock.patch("grpc.secure_channel") +def test_create_channel_checks_universe_domain_after_scopes_and_quota_project( + grpc_secure_channel, + compute_engine_creds_call, +): + class ScopedQuotaCreds( + google.auth.credentials.Scoped, + google.auth.credentials.CredentialsWithQuotaProject, + ): + pass + + initial_creds = mock.create_autospec(ScopedQuotaCreds, instance=True) + initial_creds.requires_scopes = True + initial_creds.universe_domain = "googleapis.com" + + scoped_creds = mock.create_autospec(ScopedQuotaCreds, instance=True) + scoped_creds.universe_domain = "googleapis.com" + initial_creds.with_scopes.return_value = scoped_creds + + quota_creds = mock.create_autospec(ScopedQuotaCreds, instance=True) + quota_creds.universe_domain = "universe.domain" + scoped_creds.with_quota_project.return_value = quota_creds + + grpc_helpers.create_channel( + "storage-direct.googleapis.com:443", + credentials=initial_creds, + scopes=["https://www.googleapis.com/auth/devstorage.full_control"], + quota_project_id="my-quota-project", + attempt_direct_path=True, + attempt_direct_path_xds_over_interconnect=True, + ) + + initial_creds.with_scopes.assert_called_once_with( + ["https://www.googleapis.com/auth/devstorage.full_control"], + default_scopes=None, + ) + scoped_creds.with_quota_project.assert_called_once_with("my-quota-project") + grpc_secure_channel.assert_called_once_with( + "storage.googleapis.com:443", + compute_engine_creds_call.return_value, + compression=None, + )