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
redirect_policy = AsyncRedirectPolicy()
# Client allows redirects. Defaults to True.
redirect_policy.allow = True
# The maximum allowed redirects. The default value is 30
redirect_policy.max_redirects = 10
# Alternatively you can disable redirects entirely
redirect_policy = AsyncRedirectPolicy.no_redirects()
# It can also be overridden per operation.
async with AsyncPipelineClient(base_url=url,
policies=[redirect_policy]) 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
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():
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)
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 _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 _create_pipeline(self, credential, **kwargs):
credential_policy = None
if credential is None:
raise ValueError("Parameter 'credential' must not be None.")
if hasattr(credential, "get_token"):
credential_policy = AsyncBearerTokenCredentialPolicy(
credential, "https://cognitiveservices.azure.com/.default")
elif isinstance(credential, six.string_types):
credential_policy = CognitiveServicesCredentialPolicy(credential)
elif credential is not None:
raise TypeError("Unsupported credential: {}".format(credential))
config = self._create_configuration(**kwargs)
config.transport = kwargs.get("transport") # type: ignore
if not config.transport:
try:
from azure.core.pipeline.transport import AioHttpTransport
except ImportError:
raise ImportError(
"Unable to create async transport. Please check aiohttp is installed."
)
config.transport = AioHttpTransport(**kwargs)
policies = [
config.headers_policy, config.user_agent_policy,
RequestIdPolicy(**kwargs), config.proxy_policy,
AsyncRedirectPolicy(**kwargs),
AsyncRetryPolicy(**kwargs), credential_policy,
config.logging_policy,
AsyncTextAnalyticsResponseHook(**kwargs),
DistributedTracingPolicy(**kwargs),
HttpLoggingPolicy(**kwargs)
]
return AsyncPipeline(config.transport, policies=policies)
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)
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)
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
async def client(cookie_policy):
"""Create a AutoRestHttpInfrastructureTestService client with test server credentials."""
policies = [
HeadersPolicy(),
ContentDecodePolicy(),
AsyncRedirectPolicy(),
AsyncRetryPolicy(),
cookie_policy
]
async with AutoRestHttpInfrastructureTestService(base_url="http://localhost:3000", policies=policies) as client:
await yield_(client)
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)
async def test_example_aiohttp():
request = HttpRequest("GET", "https://bing.com")
policies = [UserAgentPolicy("myuseragent"), AsyncRedirectPolicy()]
# [START aiohttp]
from azure.core.pipeline.transport import AioHttpTransport
async with AsyncPipeline(AioHttpTransport(),
policies=policies) as pipeline:
response = await pipeline.run(request)
# [END aiohttp]
assert pipeline._transport.session is None
assert response.http_response.status_code == 200
async def test_basic_aiohttp_separate_session():
session = aiohttp.ClientSession()
request = HttpRequest("GET", "https://bing.com")
policies = [UserAgentPolicy("myusergant"), AsyncRedirectPolicy()]
transport = AioHttpTransport(session=session, session_owner=False)
async with AsyncPipeline(transport, policies=policies) as pipeline:
response = await pipeline.run(request)
assert transport.session
assert isinstance(response.http_response.status_code, int)
await transport.close()
assert transport.session
await transport.session.close()
def __init__(self, credential, **kwargs): # pylint:disable=super-init-not-called
self._set_universal(**kwargs)
# async-specific azure pipeline policies
if isinstance(credential, str):
self.headers_policy.add_header("Ocp-Apim-Subscription-Key",
credential)
else:
scopes = kwargs.pop("scopes", [])
self.authentication_policy = AsyncBearerTokenCredentialPolicy(
credential, *scopes, **kwargs)
self.retry_policy = kwargs.get("retry_policy",
AsyncRetryPolicy(**kwargs))
self.redirect_policy = kwargs.get("redirect_policy",
AsyncRedirectPolicy(**kwargs))
self.transport = kwargs.get("transport", AioHttpTransport())
def _configure_policies(self, **kwargs):
return [
RequestIdPolicy(**kwargs),
StorageHeadersPolicy(**kwargs),
UserAgentPolicy(sdk_moniker=SDK_MONIKER, **kwargs),
ProxyPolicy(**kwargs),
self._credential_policy,
ContentDecodePolicy(response_encoding="utf-8"),
AsyncRedirectPolicy(**kwargs),
StorageHosts(**kwargs),
AsyncTablesRetryPolicy(**kwargs),
CustomHookPolicy(**kwargs),
NetworkTraceLoggingPolicy(**kwargs),
DistributedTracingPolicy(**kwargs),
HttpLoggingPolicy(**kwargs),
]
def _create_pipeline(self, credential, **kwargs):
# type: (Any, **Any) -> Tuple[Configuration, Pipeline]
self._credential_policy = None
if hasattr(credential, 'get_token'):
self._credential_policy = AsyncBearerTokenCredentialPolicy(
credential, STORAGE_OAUTH_SCOPE)
elif isinstance(credential, SharedKeyCredentialPolicy):
self._credential_policy = credential
elif isinstance(credential, AzureSasCredential):
self._credential_policy = AzureSasCredentialPolicy(credential)
elif credential is not None:
raise TypeError("Unsupported credential: {}".format(credential))
config = kwargs.get('_configuration') or create_configuration(**kwargs)
if kwargs.get('_pipeline'):
return config, kwargs['_pipeline']
config.transport = kwargs.get('transport') # type: ignore
kwargs.setdefault("connection_timeout", CONNECTION_TIMEOUT)
kwargs.setdefault("read_timeout", READ_TIMEOUT)
if not config.transport:
try:
from azure.core.pipeline.transport import AioHttpTransport
except ImportError:
raise ImportError(
"Unable to create async transport. Please check aiohttp is installed."
)
config.transport = AioHttpTransport(**kwargs)
policies = [
QueueMessagePolicy(),
config.headers_policy,
config.proxy_policy,
config.user_agent_policy,
StorageContentValidation(),
StorageRequestHook(**kwargs),
self._credential_policy,
ContentDecodePolicy(response_encoding="utf-8"),
AsyncRedirectPolicy(**kwargs),
StorageHosts(hosts=self._hosts, **kwargs), # type: ignore
config.retry_policy,
config.logging_policy,
AsyncStorageResponseHook(**kwargs),
DistributedTracingPolicy(**kwargs),
HttpLoggingPolicy(**kwargs),
]
if kwargs.get("_additional_pipeline_policies"):
policies = policies + kwargs.get("_additional_pipeline_policies")
return config, AsyncPipeline(config.transport, policies=policies)
async def test_example_async_pipeline():
# [START build_async_pipeline]
from azure.core.pipeline import AsyncPipeline
from azure.core.pipeline.policies import AsyncRedirectPolicy, UserAgentPolicy
from azure.core.pipeline.transport import AioHttpTransport, HttpRequest
# example: create request and policies
request = HttpRequest("GET", "https://bing.com")
policies = [UserAgentPolicy("myuseragent"), AsyncRedirectPolicy()]
# run the pipeline
async with AsyncPipeline(transport=AioHttpTransport(),
policies=policies) as pipeline:
response = await pipeline.run(request)
# [END build_async_pipeline]
assert pipeline._transport.session is None
assert response.http_response.status_code == 200
def _policies(credential: Union[AzureKeyCredential, AzureSasCredential],
**kwargs: Any) -> List[Any]:
auth_policy = _get_authentication_policy(credential)
sdk_moniker = 'eventgridpublisherclient/{}'.format(VERSION)
policies = [
RequestIdPolicy(**kwargs),
HeadersPolicy(**kwargs),
UserAgentPolicy(sdk_moniker=sdk_moniker, **kwargs),
ProxyPolicy(**kwargs),
ContentDecodePolicy(**kwargs),
AsyncRedirectPolicy(**kwargs),
AsyncRetryPolicy(**kwargs), auth_policy,
CustomHookPolicy(**kwargs),
NetworkTraceLoggingPolicy(**kwargs),
DistributedTracingPolicy(**kwargs),
CloudEventDistributedTracingPolicy(),
HttpLoggingPolicy(**kwargs)
]
return policies
async def test_cloud_shell_live(cloud_shell):
credential = ManagedIdentityCredential()
token = credential.get_token("https://vault.azure.net")
# Validate the token by sending a request to the Key Vault. The request is manual because azure-keyvault-secrets
# can't authenticate in Cloud Shell; the MSI endpoint there doesn't support AADv2 scopes.
policies = [
ContentDecodePolicy(),
AsyncRedirectPolicy(),
AsyncRetryPolicy(),
HttpLoggingPolicy()
]
client = AsyncPipelineClient(cloud_shell["vault_url"], policies=policies)
list_secrets = client.get(
"secrets",
headers={"Authorization": "Bearer " + token.token},
params={"api-version": "7.0"})
async with client:
await client._pipeline.run(list_secrets)
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
async def test_example_async_pipeline_client():
url = "https://bing.com"
# [START build_async_pipeline_client]
from azure.core import AsyncPipelineClient
from azure.core.pipeline.policies import AsyncRedirectPolicy, UserAgentPolicy
from azure.core.pipeline.transport import HttpRequest
# example policies
request = HttpRequest("GET", url)
policies = [
UserAgentPolicy("myuseragent"),
AsyncRedirectPolicy(),
]
async with AsyncPipelineClient(base_url=url, policies=policies) 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 _create_pipeline(self, credential, **kwargs):
# type: (Any, **Any) -> Tuple[Configuration, Pipeline]
credential_policy = None
if hasattr(credential, 'get_token'):
credential_policy = AsyncBearerTokenCredentialPolicy(credential, STORAGE_OAUTH_SCOPE)
elif isinstance(credential, SharedKeyCredentialPolicy):
credential_policy = credential
elif credential is not None:
raise TypeError("Unsupported credential: {}".format(credential))
config = kwargs.get('_configuration') or create_configuration(**kwargs)
if kwargs.get('_pipeline'):
return config, kwargs['_pipeline']
config.transport = kwargs.get('transport') # type: ignore
if 'connection_timeout' not in kwargs:
kwargs['connection_timeout'] = DEFAULT_SOCKET_TIMEOUT[0] # type: ignore
if not config.transport:
try:
from azure.core.pipeline.transport import AioHttpTransport
except ImportError:
raise ImportError("Unable to create async transport. Please check aiohttp is installed.")
config.transport = AioHttpTransport(**kwargs)
policies = [
QueueMessagePolicy(),
config.headers_policy,
config.user_agent_policy,
StorageContentValidation(),
StorageRequestHook(**kwargs),
credential_policy,
ContentDecodePolicy(),
AsyncRedirectPolicy(**kwargs),
StorageHosts(hosts=self._hosts, **kwargs), # type: ignore
config.retry_policy,
config.logging_policy,
AsyncStorageResponseHook(**kwargs),
DistributedTracingPolicy(),
]
return config, AsyncPipeline(config.transport, policies=policies)