async def test_example_async_redirect_policy():
url = "https://bing.com"
request = HttpRequest("GET", url)
# [START async_redirect_policy]
from azure.core.pipeline.policies import AsyncRedirectPolicy
config = Configuration()
config.redirect_policy = AsyncRedirectPolicy()
# Client allows redirects. Defaults to True.
config.redirect_policy.allow = True
# The maximum allowed redirects. The default value is 30
config.redirect_policy.max_redirects = 10
# Alternatively you can disable redirects entirely
config.redirect_policy = AsyncRedirectPolicy.no_redirects()
# It can also be overridden per operation.
async with AsyncPipelineClient(base_url=url, config=config) as client:
response = await client._pipeline.run(request,
permit_redirects=True,
redirect_max=5)
# [END async_redirect_policy]
assert client._pipeline._transport.session is None
assert response.http_response.status_code == 200
def test_example_redirect_policy():
url = "https://bing.com"
# [START redirect_policy]
from azure.core.pipeline.policies import RedirectPolicy
config = Configuration()
config.redirect_policy = RedirectPolicy()
# Client allows redirects. Defaults to True.
config.redirect_policy.allow = True
# The maximum allowed redirects. The default value is 30
config.redirect_policy.max_redirects = 10
# Alternatively you can disable redirects entirely
config.redirect_policy = RedirectPolicy.no_redirects()
# It can also be overridden per operation.
client = PipelineClient(base_url=url, config=config)
request = client.get(url)
pipeline_response = client._pipeline.run(request,
permit_redirects=True,
redirect_max=5)
# [END redirect_policy]
response = pipeline_response.http_response
assert response.status_code == 200
def _create_config(**kwargs):
# type: (Any) -> Configuration
config = Configuration(**kwargs)
config.logging_policy = NetworkTraceLoggingPolicy(**kwargs)
config.retry_policy = RetryPolicy(**kwargs)
config.proxy_policy = ProxyPolicy(**kwargs)
return config
def test_pass_in_http_logging_policy():
config = Configuration()
http_logging_policy = ARMHttpLoggingPolicy()
http_logging_policy.allowed_header_names.update({"x-ms-added-header"})
config.http_logging_policy = http_logging_policy
pipeline_client = AsyncARMPipelineClient(base_url="test", config=config)
http_logging_policy = pipeline_client._pipeline._impl_policies[-1]._policy
assert http_logging_policy.allowed_header_names == ARMHttpLoggingPolicy.DEFAULT_HEADERS_WHITELIST.union(
{"x-ms-added-header"})
def _set_universal(self, **kwargs):
Configuration.__init__(self)
self.connection = kwargs.get("connection_configuration",
ConnectionConfiguration(**kwargs))
self.user_agent_policy = kwargs.get("user_agent_policy",
UserAgentPolicy(**kwargs))
self.proxy_policy = kwargs.get("proxy_policy", ProxyPolicy(**kwargs))
self.logging_policy = kwargs.get("logging_policy",
NetworkTraceLoggingPolicy(**kwargs))
self.headers_policy = kwargs.get("headers_policy",
HeadersPolicy(**kwargs))
def example_proxy_policy():
# [START proxy_policy]
from azure.core.pipeline.policies import ProxyPolicy
config = Configuration()
config.proxy_policy = ProxyPolicy()
# Example
config.proxy_policy.proxies = {'http': 'http://10.10.1.10:3148'}
# Use basic auth
config.proxy_policy.proxies = {'https': 'http://*****:*****@10.10.1.10:1180/'}
def test_example_no_retries():
url = "https://bing.com"
config = Configuration()
config.retry_policy = RetryPolicy.no_retries()
client = PipelineClient(base_url=url, config=config)
request = client.get(url)
pipeline_response = client._pipeline.run(request)
response = pipeline_response.http_response
# bing returns 301 if not retried
assert response.status_code == 301
def test_default_http_logging_policy(http_request):
config = Configuration()
pipeline_client = PipelineClient(base_url="test")
pipeline = pipeline_client._build_pipeline(config)
http_logging_policy = pipeline._impl_policies[-1]._policy
assert http_logging_policy.allowed_header_names == HttpLoggingPolicy.DEFAULT_HEADERS_WHITELIST
assert "WWW-Authenticate" in http_logging_policy.allowed_header_names
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_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 _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():
conf = Configuration()
request = HttpRequest("GET", "https://www.bing.com/")
async with AsyncioRequestsTransport(conf) as sender:
response = await sender.send(request)
assert response.body() is not None
assert response.status_code == 200
async def test_conf_async_requests():
conf = Configuration()
request = HttpRequest("GET", "https://bing.com/")
policies = [UserAgentPolicy("myusergant"), AsyncRedirectPolicy()]
async with AsyncPipeline(AsyncioRequestsTransport(conf),
policies=policies) as pipeline:
response = await pipeline.run(request)
assert response.http_response.status_code == 200
def test_example_pipeline_client():
url = "https://bing.com"
# [START build_pipeline_client]
from azure.core import Configuration, PipelineClient
from azure.core.pipeline.policies import RedirectPolicy, UserAgentPolicy
# example configuration with some policies
config = Configuration()
config.user_agent_policy = UserAgentPolicy("myuseragent")
config.redirect_policy = RedirectPolicy()
client = PipelineClient(base_url=url, config=config)
request = client.get("https://bing.com")
pipeline_response = client._pipeline.run(request)
# [END build_pipeline_client]
response = pipeline_response.http_response
assert response.status_code == 200
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 req():
config = Configuration()
request = HttpRequest("GET", "https://bing.com/")
policies = [UserAgentPolicy("myuseragent"), AsyncRedirectPolicy()]
# [START trio]
from azure.core.pipeline.transport import TrioRequestsTransport
async with AsyncPipeline(TrioRequestsTransport(config),
policies=policies) as pipeline:
return await pipeline.run(request)
async def test_basic_aiohttp():
conf = Configuration()
request = HttpRequest("GET", "https://www.bing.com/")
async with AioHttpTransport(conf) as sender:
response = await sender.send(request)
assert response.body() is not None
assert sender.session is None
assert response.status_code == 200
def __init__(self,
configuration=None,
*,
session=None,
loop=None,
session_owner=True):
self._loop = loop
self._session_owner = session_owner
self.session = session
self.config = configuration or Configuration()
def test_basic_requests(self):
conf = Configuration()
request = HttpRequest("GET", "https://bing.com")
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)
def _create_config(**kwargs):
# type: (Mapping[str, Any]) -> Configuration
"""Build a default configuration for the credential's HTTP pipeline.
:rtype: :class:`azure.core.configuration`
"""
timeout = kwargs.pop("connection_timeout", 2)
config = Configuration(connection_timeout=timeout, **kwargs)
# retry is the only IO policy, so its class is a kwarg to increase async code sharing
retry_policy = kwargs.pop("retry_policy", RetryPolicy) # type: ignore
args = kwargs.copy() # combine kwargs and default retry settings in a Python 2-compatible way
args.update(_ManagedIdentityBase._retry_settings) # type: ignore
config.retry_policy = retry_policy(**args) # type: ignore
# Metadata header is required by IMDS and in Cloud Shell; App Service ignores it
config.headers_policy = HeadersPolicy(base_headers={"Metadata": "true"}, **kwargs)
config.logging_policy = NetworkTraceLoggingPolicy(**kwargs)
return config
async def test_basic_aiohttp():
conf = Configuration()
request = HttpRequest("GET", "https://bing.com")
policies = [UserAgentPolicy("myusergant"), AsyncRedirectPolicy()]
async with AsyncPipeline(AioHttpTransport(conf),
policies=policies) as pipeline:
response = await pipeline.run(request)
assert pipeline._transport.session is None
assert response.http_response.status_code == 200
async def test_example_async_pipeline_client():
url = "https://bing.com"
# [START build_async_pipeline_client]
from azure.core import Configuration, AsyncPipelineClient
from azure.core.pipeline.policies import AsyncRedirectPolicy, UserAgentPolicy
from azure.core.pipeline.transport import HttpRequest
# example configuration with some policies
request = HttpRequest("GET", url)
config = Configuration()
config.user_agent_policy = UserAgentPolicy("myuseragent")
config.redirect_policy = AsyncRedirectPolicy()
async with AsyncPipelineClient(base_url=url, config=config) as client:
response = await client._pipeline.run(request)
# [END build_async_pipeline_client]
assert client._pipeline._transport.session is None
assert response.http_response.status_code == 200
def test_example_retry_policy():
url = "https://bing.com"
config = Configuration()
config.user_agent_policy = UserAgentPolicy("myusergant")
config.redirect_policy = RedirectPolicy()
# [START retry_policy]
from azure.core.pipeline.policies import RetryPolicy
config.retry_policy = RetryPolicy()
# Total number of retries to allow. Takes precedence over other counts.
# Default value is 10.
config.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
config.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.
config.retry_policy.read_retries = 4
# How many times to retry on bad status codes. Default value is 3.
config.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.
config.retry_policy.backoff_factor = 0.5
# The maximum back off time. Default value is 120 seconds (2 minutes).
config.retry_policy.backoff_max = 120
# Alternatively you can disable redirects entirely
config.retry_policy = RetryPolicy.no_retries()
# All of these settings can also be configured per operation.
client = PipelineClient(base_url=url, config=config)
request = client.get(url)
pipeline_response = client._pipeline.run(request,
retry_total=10,
retry_connect=1,
retry_read=1,
retry_status=5,
retry_backoff_factor=0.5,
retry_backoff_max=120,
retry_on_methods=['GET'])
# [END retry_policy]
response = pipeline_response.http_response
assert response.status_code == 200
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
def test_example_requests():
request = HttpRequest("GET", "https://bing.com")
config = Configuration()
policies = [UserAgentPolicy("myuseragent"), RedirectPolicy()]
# [START requests]
from azure.core.pipeline.transport import RequestsTransport
with Pipeline(transport=RequestsTransport(),
policies=policies) as pipeline:
response = pipeline.run(request)
# [END requests]
assert pipeline._transport.session is None
assert response.http_response.status_code == 200
def test_basic_requests(port):
conf = Configuration()
request = HttpRequest("GET", "http://localhost:{}/basic/string".format(port))
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)
def test_example_user_agent_policy():
url = "https://bing.com"
config = Configuration()
config.redirect_policy = RedirectPolicy()
# [START user_agent_policy]
from azure.core.pipeline.policies import UserAgentPolicy
config.user_agent_policy = UserAgentPolicy()
# The user-agent policy allows you to append a custom value to the header.
config.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.
client = PipelineClient(base_url=url, config=config)
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_example_headers_policy():
url = "https://bing.com"
config = Configuration()
config.user_agent_policy = UserAgentPolicy("myusergant")
config.redirect_policy = RedirectPolicy()
# [START headers_policy]
from azure.core.pipeline.policies import HeadersPolicy
config.headers_policy = HeadersPolicy()
config.headers_policy.add_header('CustomValue', 'Foo')
# Or headers can be added per operation. These headers will supplement existing headers
# or those defined in the config headers policy. They will also overwrite existing
# identical headers.
client = PipelineClient(base_url=url, config=config)
request = client.get(url)
pipeline_response = client._pipeline.run(request, headers={'CustomValue': 'Bar'})
# [END headers_policy]
response = pipeline_response.http_response
assert 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(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 _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
