def test_example_user_agent_policy():
url = "https://bing.com"
redirect_policy = RedirectPolicy()
# [START user_agent_policy]
from azure.core.pipeline.policies import UserAgentPolicy
user_agent_policy = UserAgentPolicy()
# The user-agent policy allows you to append a custom value to the header.
user_agent_policy.add_user_agent("CustomValue")
# You can also pass in a custom value per operation to append to the end of the user-agent.
# This can be used together with the policy configuration to append multiple values.
policies = [
redirect_policy,
user_agent_policy,
]
client = PipelineClient(base_url=url, policies=policies)
request = client.get(url)
pipeline_response = client._pipeline.run(request,
user_agent="AnotherValue")
# [END user_agent_policy]
response = pipeline_response.http_response
assert response.status_code == 200
def test_user_agent_environ():
with mock.patch.dict('os.environ', {'AZURE_HTTP_USER_AGENT': "mytools"}):
policy = UserAgentPolicy(None)
assert policy.user_agent.endswith("mytools")
request = HttpRequest('GET', 'http://127.0.0.1/')
policy.on_request(PipelineRequest(request, PipelineContext(None)))
assert request.headers["user-agent"].endswith("mytools")
def __init__(self, base_url, credential, **kwargs):
# type: (str, Any, dict) -> None
try:
if not base_url.lower().startswith("http"):
base_url = "https://" + base_url
except AttributeError:
raise ValueError("Base URL must be a string.")
if not credential:
raise ValueError("Missing credential")
self._config = AzureAppConfigurationConfiguration(
credential, base_url, **kwargs)
self._config.user_agent_policy = UserAgentPolicy(
base_user_agent=USER_AGENT, **kwargs)
pipeline = kwargs.get("pipeline")
if pipeline is None:
aad_mode = not isinstance(credential,
AppConfigConnectionStringCredential)
pipeline = self._create_appconfig_pipeline(credential=credential,
aad_mode=aad_mode,
base_url=base_url,
**kwargs)
self._impl = AzureAppConfiguration(credentials=credential,
endpoint=base_url,
pipeline=pipeline)
def _configure_policies(self, **kwargs):
# type: (**Any) -> None
try:
from azure.core.pipeline.transport import AioHttpTransport
if not kwargs.get("transport"):
kwargs.setdefault("transport", AioHttpTransport(**kwargs))
except ImportError:
raise ImportError(
"Unable to create async transport. Please check aiohttp is installed."
)
kwargs.setdefault("connection_timeout", CONNECTION_TIMEOUT)
kwargs.setdefault("read_timeout", READ_TIMEOUT)
self._policies = [
StorageHeadersPolicy(**kwargs),
ProxyPolicy(**kwargs),
UserAgentPolicy(sdk_moniker=SDK_MONIKER, **kwargs),
StorageContentValidation(),
StorageRequestHook(**kwargs),
self._credential_policy,
ContentDecodePolicy(response_encoding="utf-8"),
AsyncRedirectPolicy(**kwargs),
StorageHosts(hosts=self._hosts, **kwargs),
AsyncTablesRetryPolicy(**kwargs),
StorageLoggingPolicy(**kwargs),
AsyncStorageResponseHook(**kwargs),
DistributedTracingPolicy(**kwargs),
HttpLoggingPolicy(**kwargs),
]
def __init__(self, base_url, credential, **kwargs):
# type: (str, Union[AppConfigConnectionStringCredential, TokenCredential], **Any) -> None
try:
if not base_url.lower().startswith("http"):
base_url = "https://" + base_url
except AttributeError:
raise ValueError("Base URL must be a string.")
if not credential:
raise ValueError("Missing credential")
self._credential_scopes = base_url.strip("/") + "/.default"
self._config = AzureAppConfigurationConfiguration(
credential, base_url, credential_scopes=self._credential_scopes, **kwargs # type: ignore
)
self._config.user_agent_policy = UserAgentPolicy(
base_user_agent=USER_AGENT, **kwargs
)
self._sync_token_policy = SyncTokenPolicy()
pipeline = kwargs.get("pipeline")
if pipeline is None:
aad_mode = not isinstance(credential, AppConfigConnectionStringCredential)
pipeline = self._create_appconfig_pipeline(
credential=credential, aad_mode=aad_mode, base_url=base_url, **kwargs
)
self._impl = AzureAppConfiguration(
credential, base_url, pipeline=pipeline, credential_scopes=self._credential_scopes # type: ignore
)
def __init__(self, endpoint, credential, **kwargs):
# type: (str, MetricsAdvisorKeyCredential, Any) -> None
try:
if not endpoint.lower().startswith('http'):
endpoint = "https://" + endpoint
except AttributeError:
raise ValueError("Base URL must be a string.")
if not credential:
raise ValueError("Missing credential")
self._config = AzureCognitiveServiceMetricsAdvisorRESTAPIOpenAPIV2Configuration(
endpoint=endpoint, **kwargs)
self._endpoint = endpoint
self._credential = credential
self._config.user_agent_policy = UserAgentPolicy(
base_user_agent=None, sdk_moniker=SDK_MONIKER, **kwargs)
pipeline = kwargs.get("pipeline")
if pipeline is None:
aad_mode = not isinstance(credential, MetricsAdvisorKeyCredential)
pipeline = self._create_pipeline(credential=credential,
aad_mode=aad_mode,
endpoint=endpoint,
**kwargs)
self._client = AzureCognitiveServiceMetricsAdvisorRESTAPIOpenAPIV2(
endpoint=endpoint, pipeline=pipeline)
async def do():
conf = Configuration()
request = HttpRequest("GET", "https://bing.com/")
policies = [UserAgentPolicy("myusergant"), AsyncRedirectPolicy()]
async with AsyncPipeline(TrioRequestsTransport(conf),
policies=policies) as pipeline:
return await pipeline.run(request)
def _create_config(**kwargs: "Any") -> Configuration:
config = Configuration(**kwargs)
config.logging_policy = NetworkTraceLoggingPolicy(**kwargs)
config.retry_policy = AsyncRetryPolicy(**kwargs)
config.proxy_policy = ProxyPolicy(**kwargs)
config.user_agent_policy = UserAgentPolicy(base_user_agent=USER_AGENT, **kwargs)
return config
async def test_example_async_retry_policy():
url = "https://bing.com"
request = HttpRequest("GET", "https://bing.com")
policies = [
UserAgentPolicy("myuseragent"),
AsyncRedirectPolicy(),
]
# [START async_retry_policy]
from azure.core.pipeline.policies import AsyncRetryPolicy
retry_policy = AsyncRetryPolicy()
# Total number of retries to allow. Takes precedence over other counts.
# Default value is 10.
retry_policy.total_retries = 5
# How many connection-related errors to retry on.
# These are errors raised before the request is sent to the remote server,
# which we assume has not triggered the server to process the request. Default value is 3
retry_policy.connect_retries = 2
# How many times to retry on read errors.
# These errors are raised after the request was sent to the server, so the
# request may have side-effects. Default value is 3.
retry_policy.read_retries = 4
# How many times to retry on bad status codes. Default value is 3.
retry_policy.status_retries = 3
# A backoff factor to apply between attempts after the second try
# (most errors are resolved immediately by a second try without a delay).
# Retry policy will sleep for:
# {backoff factor} * (2 ** ({number of total retries} - 1))
# seconds. If the backoff_factor is 0.1, then the retry will sleep
# for [0.0s, 0.2s, 0.4s, ...] between retries.
# The default value is 0.8.
retry_policy.backoff_factor = 0.5
# The maximum back off time. Default value is 120 seconds (2 minutes).
retry_policy.backoff_max = 120
# Alternatively you can disable redirects entirely
retry_policy = AsyncRetryPolicy.no_retries()
# All of these settings can also be configured per operation.
policies.append(retry_policy)
async with AsyncPipelineClient(base_url=url, policies=policies) as client:
response = await client._pipeline.run(request,
retry_total=10,
retry_connect=1,
retry_read=1,
retry_status=5,
retry_backoff_factor=0.5,
retry_backoff_max=60,
retry_on_methods=['GET'])
# [END async_retry_policy]
assert client._pipeline._transport.session is None
assert response.http_response.status_code == 200
async def do():
request = HttpRequest("GET",
"http://localhost:{}/basic/string".format(port))
policies = [UserAgentPolicy("myusergant"), AsyncRedirectPolicy()]
async with AsyncPipeline(TrioRequestsTransport(),
policies=policies) as pipeline:
return await pipeline.run(request)
def _create_config(credential, api_version=None, **kwargs):
# type: (TokenCredential, Optional[str], Mapping[str, Any]) -> Configuration
if api_version is None:
api_version = KeyVaultClient.DEFAULT_API_VERSION
config = KeyVaultClient.get_configuration_class(api_version,
aio=False)(credential,
**kwargs)
config.authentication_policy = ChallengeAuthPolicy(credential)
# replace the autorest-generated UserAgentPolicy and its hard-coded user agent
# https://github.com/Azure/azure-sdk-for-python/issues/6637
config.user_agent_policy = UserAgentPolicy(base_user_agent=USER_AGENT,
**kwargs)
# Override config policies if found in kwargs
if "user_agent_policy" in kwargs:
config.user_agent_policy = kwargs["user_agent_policy"]
if "headers_policy" in kwargs:
config.headers_policy = kwargs["headers_policy"]
if "proxy_policy" in kwargs:
config.proxy_policy = kwargs["proxy_policy"]
if "logging_policy" in kwargs:
config.logging_policy = kwargs["logging_policy"]
if "retry_policy" in kwargs:
config.retry_policy = kwargs["retry_policy"]
if "custom_hook_policy" in kwargs:
config.custom_hook_policy = kwargs["custom_hook_policy"]
if "redirect_policy" in kwargs:
config.redirect_policy = kwargs["redirect_policy"]
return config
def _create_config(credential: "TokenCredential",
api_version: str = None,
**kwargs: "Any") -> Configuration:
if api_version is None:
api_version = KeyVaultClient.DEFAULT_API_VERSION
config = KeyVaultClient.get_configuration_class(api_version,
aio=True)(credential,
**kwargs)
config.authentication_policy = AsyncChallengeAuthPolicy(credential)
# replace the autorest-generated UserAgentPolicy and its hard-coded user agent
# https://github.com/Azure/azure-sdk-for-python/issues/6637
config.user_agent_policy = UserAgentPolicy(base_user_agent=USER_AGENT,
**kwargs)
# Override config policies if found in kwargs
# TODO: should be unnecessary after next regeneration (written 2019-08-02)
if "user_agent_policy" in kwargs:
config.user_agent_policy = kwargs["user_agent_policy"]
if "headers_policy" in kwargs:
config.headers_policy = kwargs["headers_policy"]
if "proxy_policy" in kwargs:
config.proxy_policy = kwargs["proxy_policy"]
if "logging_policy" in kwargs:
config.logging_policy = kwargs["logging_policy"]
if "retry_policy" in kwargs:
config.retry_policy = kwargs["retry_policy"]
if "custom_hook_policy" in kwargs:
config.custom_hook_policy = kwargs["custom_hook_policy"]
if "redirect_policy" in kwargs:
config.redirect_policy = kwargs["redirect_policy"]
return config
def create_configuration(**kwargs):
# type: (**Any) -> Configuration
config = Configuration(**kwargs)
config.headers_policy = StorageHeadersPolicy(**kwargs)
config.user_agent_policy = UserAgentPolicy(
sdk_moniker="storage-{}/{}".format(kwargs.pop('storage_sdk'), VERSION),
**kwargs)
config.retry_policy = kwargs.get("retry_policy") or ExponentialRetry(
**kwargs)
config.logging_policy = StorageLoggingPolicy(**kwargs)
config.proxy_policy = ProxyPolicy(**kwargs)
# Storage settings
config.max_single_put_size = kwargs.get("max_single_put_size",
64 * 1024 * 1024)
config.copy_polling_interval = 15
# Block blob uploads
config.max_block_size = kwargs.get("max_block_size", 4 * 1024 * 1024)
config.min_large_block_upload_threshold = kwargs.get(
"min_large_block_upload_threshold", 4 * 1024 * 1024 + 1)
config.use_byte_buffer = kwargs.get("use_byte_buffer", False)
# Page blob uploads
config.max_page_size = kwargs.get("max_page_size", 4 * 1024 * 1024)
# Blob downloads
config.max_single_get_size = kwargs.get("max_single_get_size",
32 * 1024 * 1024)
config.max_chunk_get_size = kwargs.get("max_chunk_get_size",
4 * 1024 * 1024)
# File uploads
config.max_range_size = kwargs.get("max_range_size", 4 * 1024 * 1024)
return config
def _create_config(**kwargs):
# type: (Mapping[str, Any]) -> Configuration
config = Configuration(**kwargs)
config.logging_policy = NetworkTraceLoggingPolicy(**kwargs)
config.retry_policy = RetryPolicy(**kwargs)
config.proxy_policy = ProxyPolicy(**kwargs)
config.user_agent_policy = UserAgentPolicy(base_user_agent=USER_AGENT, **kwargs)
return config
def _create_configuration(self, **kwargs): # pylint: disable=no-self-use
config = Configuration(**kwargs)
config.user_agent_policy = kwargs.get('user_agent_policy') or \
UserAgentPolicy(base_user_agent=USER_AGENT, **kwargs)
config.headers_policy = kwargs.get('headers_policy') or HeadersPolicy(**kwargs)
config.proxy_policy = kwargs.get('proxy_policy') or ProxyPolicy(**kwargs)
config.logging_policy = kwargs.get('logging_policy') or NetworkTraceLoggingPolicy(**kwargs)
return config
def test_basic_options_requests(self):
request = HttpRequest("OPTIONS", "https://httpbin.org")
policies = [UserAgentPolicy("myusergant"), RedirectPolicy()]
with Pipeline(RequestsTransport(), policies=policies) as pipeline:
response = pipeline.run(request)
assert pipeline._transport.session is None
assert isinstance(response.http_response.status_code, int)
async def test_conf_async_requests():
request = HttpRequest("GET", "https://bing.com/")
policies = [UserAgentPolicy("myusergant"), AsyncRedirectPolicy()]
async with AsyncPipeline(AsyncioRequestsTransport(),
policies=policies) as pipeline:
response = await pipeline.run(request)
assert isinstance(response.http_response.status_code, int)
async def req():
request = HttpRequest("GET", "https://bing.com/")
policies = [UserAgentPolicy("myuseragent"), AsyncRedirectPolicy()]
# [START trio]
from azure.core.pipeline.transport import TrioRequestsTransport
async with AsyncPipeline(TrioRequestsTransport(),
policies=policies) as pipeline:
return await pipeline.run(request)
def _get_policies(config: "Configuration", **kwargs: "Any") -> "List[PolicyType]":
return [
UserAgentPolicy(base_user_agent=USER_AGENT, **kwargs),
config.proxy_policy,
config.retry_policy,
ArcChallengeAuthPolicy(),
NetworkTraceLoggingPolicy(**kwargs),
DistributedTracingPolicy(**kwargs),
HttpLoggingPolicy(**kwargs),
]
def _get_config(**kwargs):
"""Configuration common to a/sync pipelines"""
config = Configuration(**kwargs)
config.custom_hook_policy = CustomHookPolicy(**kwargs)
config.headers_policy = HeadersPolicy(**kwargs)
config.http_logging_policy = HttpLoggingPolicy(**kwargs)
config.logging_policy = NetworkTraceLoggingPolicy(**kwargs)
config.proxy_policy = ProxyPolicy(**kwargs)
config.user_agent_policy = UserAgentPolicy(base_user_agent=USER_AGENT, **kwargs)
return config
async def test_conf_async_requests(port):
request = HttpRequest("GET",
"http://localhost:{}/basic/string".format(port))
policies = [UserAgentPolicy("myusergant"), AsyncRedirectPolicy()]
async with AsyncPipeline(AsyncioRequestsTransport(),
policies=policies) as pipeline:
response = await pipeline.run(request)
assert isinstance(response.http_response.status_code, int)
def _get_policies(config, **kwargs):
return [
HeadersPolicy(**kwargs),
UserAgentPolicy(base_user_agent=USER_AGENT, **kwargs),
config.proxy_policy,
config.retry_policy,
NetworkTraceLoggingPolicy(**kwargs),
DistributedTracingPolicy(**kwargs),
HttpLoggingPolicy(**kwargs),
]
async def test_basic_aiohttp():
request = HttpRequest("GET", "https://bing.com")
policies = [UserAgentPolicy("myusergant"), AsyncRedirectPolicy()]
async with AsyncPipeline(AioHttpTransport(),
policies=policies) as pipeline:
response = await pipeline.run(request)
assert pipeline._transport.session is None
assert response.http_response.status_code == 200
def test_basic_requests(self):
conf = Configuration()
request = HttpRequest("GET", "https://bing.com")
policies = [UserAgentPolicy("myusergant"), RedirectPolicy()]
with Pipeline(RequestsTransport(conf), policies=policies) as pipeline:
response = pipeline.run(request)
assert pipeline._transport.session is None
assert response.http_response.status_code == 200
def _create_configuration(self, **kwargs): # pylint: disable=no-self-use
config = Configuration(**kwargs)
config.user_agent_policy = kwargs.get("user_agent_policy") or UserAgentPolicy(**kwargs)
config.headers_policy = kwargs.get("headers_policy") or HeadersPolicy(**kwargs)
config.proxy_policy = kwargs.get("proxy_policy") or ProxyPolicy(**kwargs)
config.logging_policy = kwargs.get("logging_policy") or NetworkTraceLoggingPolicy(**kwargs)
config.retry_policy = kwargs.get("retry_policy") or RetryPolicy(**kwargs)
config.redirect_policy = kwargs.get("redirect_policy") or RedirectPolicy(**kwargs)
return config
def __init__(self, credentials, base_url, **kwargs):
self.config = ConfigurationClientConfiguration(credentials, **kwargs)
self.config.user_agent_policy = UserAgentPolicy(
base_user_agent=USER_AGENT, **kwargs)
self._impl = ConfigurationClient(
credentials,
base_url,
pipeline=self._create_appconfig_pipeline(),
)
def test_requests_socket_timeout(self):
conf = Configuration()
request = HttpRequest("GET", "https://bing.com")
policies = [UserAgentPolicy("myusergant"), RedirectPolicy()]
# Sometimes this will raise a read timeout, sometimes a socket timeout depending on timing.
# Either way, the error should always be wrapped as an AzureError to ensure it's caught
# by the retry policy.
with pytest.raises(AzureError):
with Pipeline(RequestsTransport(), policies=policies) as pipeline:
response = pipeline.run(request, connection_timeout=0.000001)
async def test_basic_aiohttp():
request = HttpRequest("GET", "https://bing.com")
policies = [UserAgentPolicy("myusergant"), AsyncRedirectPolicy()]
async with AsyncPipeline(AioHttpTransport(),
policies=policies) as pipeline:
response = await pipeline.run(request)
assert pipeline._transport.session is None
# all we need to check is if we are able to make the call
assert isinstance(response.http_response.status_code, int)
def create_config(credential, scopes, **kwargs):
# Here the SDK developer would define the default
# config to interact with the service
config = Configuration(**kwargs)
config.headers_policy = HeadersPolicy({"CustomHeader": "Value"}, **kwargs)
config.authentication_policy = BearerTokenCredentialPolicy(credential, scopes, **kwargs)
config.user_agent_policy = UserAgentPolicy("ServiceUserAgentValue", **kwargs)
config.retry_policy = RetryPolicy(**kwargs)
config.redirect_policy = RedirectPolicy(**kwargs)
config.logging_policy = NetworkTraceLoggingPolicy(**kwargs)
config.proxy_policy = ProxyPolicy(**kwargs)
def test_request_hook_policy_in_request():
def test_callback(response):
raise ValueError()
url = "https://bing.com"
custom_hook_policy = CustomHookPolicy()
policies = [UserAgentPolicy("myuseragent"), custom_hook_policy]
client = PipelineClient(base_url=url, policies=policies)
request = client.get(url)
with pytest.raises(ValueError):
client._pipeline.run(request, raw_request_hook=test_callback)
