def test_example_redirect_policy():
url = "https://bing.com"
# [START redirect_policy]
from azure.core.pipeline.policies import RedirectPolicy
redirect_policy = RedirectPolicy()
# 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 = RedirectPolicy.no_redirects()
# It can also be overridden per operation.
client = PipelineClient(base_url=url, policies=[redirect_policy])
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_pipeline(self, credential, **kwargs):
# type: (Any, **Any) -> Tuple[Configuration, Pipeline]
self._credential_policy = None
if hasattr(credential, "get_token"):
self._credential_policy = BearerTokenCredentialPolicy(
credential, STORAGE_OAUTH_SCOPE)
elif isinstance(credential, SharedKeyCredentialPolicy):
self._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
kwargs.setdefault("connection_timeout", CONNECTION_TIMEOUT)
kwargs.setdefault("read_timeout", READ_TIMEOUT)
if not config.transport:
config.transport = RequestsTransport(**kwargs)
policies = [
QueueMessagePolicy(), config.headers_policy, config.proxy_policy,
config.user_agent_policy,
StorageContentValidation(),
StorageRequestHook(**kwargs), self._credential_policy,
ContentDecodePolicy(response_encoding="utf-8"),
RedirectPolicy(**kwargs),
StorageHosts(hosts=self._hosts,
**kwargs), config.retry_policy, config.logging_policy,
StorageResponseHook(**kwargs),
DistributedTracingPolicy(**kwargs),
HttpLoggingPolicy(**kwargs)
]
if kwargs.get("_additional_pipeline_policies"):
policies = policies + kwargs.get("_additional_pipeline_policies")
return config, Pipeline(config.transport, policies=policies)
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 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 _create_pipeline(self, credential, **kwargs):
# type: (Any, **Any) -> Tuple[Configuration, Pipeline]
self._credential_policy = None
if hasattr(credential, "get_token"):
self._credential_policy = BearerTokenCredentialPolicy(credential, STORAGE_OAUTH_SCOPE)
elif isinstance(credential, SharedKeyCredentialPolicy):
self._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
if not config.transport:
config.transport = RequestsTransport(**kwargs)
policies = [
QueueMessagePolicy(),
config.headers_policy,
config.user_agent_policy,
StorageContentValidation(),
StorageRequestHook(**kwargs),
self._credential_policy,
ContentDecodePolicy(),
RedirectPolicy(**kwargs),
StorageHosts(hosts=self._hosts, **kwargs),
config.retry_policy,
config.logging_policy,
StorageResponseHook(**kwargs),
DistributedTracingPolicy(),
]
return config, Pipeline(config.transport, policies=policies)
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)
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 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)
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_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 client(cookie_policy):
"""Create a AutoRestHttpInfrastructureTestService client with test server credentials."""
policies = [
HeadersPolicy(),
ContentDecodePolicy(),
RedirectPolicy(),
RetryPolicy(), cookie_policy
]
with AutoRestHttpInfrastructureTestService(
base_url="http://localhost:3000", policies=policies) as client:
yield client
def test_example_no_redirects():
url = "https://bing.com"
redirect_policy = RedirectPolicy.no_redirects()
client = PipelineClient(base_url=url, policies=[redirect_policy])
request = client.get(url)
pipeline_response = client._pipeline.run(request)
response = pipeline_response.http_response
# bing returns 301 if not redirected
assert response.status_code == 301
def create_config(**kwargs):
# type: (Any) -> Configuration
config = Configuration(**kwargs)
config.user_agent_policy = UserAgentPolicy("KeyClient", **kwargs)
config.headers_policy = None
config.retry_policy = RetryPolicy(**kwargs)
config.redirect_policy = RedirectPolicy(**kwargs)
# TODO: these are requests-specific
config.cert = config.timeout = None
config.verify = True
return config
def test_basic_options_requests(port):
request = HttpRequest("OPTIONS", "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 create_configuration(**kwargs):
# type: (**Any) -> Configuration
config = Configuration(**kwargs)
config.headers_policy = StorageHeadersPolicy(**kwargs)
config.user_agent_policy = StorageUserAgentPolicy(**kwargs)
config.retry_policy = kwargs.get('retry_policy') or ExponentialRetry(
**kwargs)
config.redirect_policy = RedirectPolicy(**kwargs)
config.logging_policy = StorageLoggingPolicy(**kwargs)
config.proxy_policy = ProxyPolicy(**kwargs)
config.data_settings = StorageDataSettings(**kwargs)
return config
def test_basic_requests(port, http_request):
conf = Configuration()
request = http_request("GET",
"http://localhost:{}/basic/string".format(port))
policies = [UserAgentPolicy("myusergant"), RedirectPolicy()]
with Pipeline(RequestsTransport(), policies=policies) as pipeline:
response = pipeline.run(request)
if is_rest(request):
assert is_rest(response.http_response)
assert pipeline._transport.session is None
assert isinstance(response.http_response.status_code, int)
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 __init__(self, credential, **kwargs): # pylint:disable=super-init-not-called
self._set_universal(**kwargs)
# sync-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 = BearerTokenCredentialPolicy(
credential, *scopes, **kwargs)
self.retry_policy = kwargs.get("retry_policy", RetryPolicy(**kwargs))
self.redirect_policy = kwargs.get("redirect_policy",
RedirectPolicy(**kwargs))
self.transport = kwargs.get("transport", RequestsTransport())
def test_basic_requests_separate_session(self):
session = requests.Session()
request = HttpRequest("GET", "https://bing.com")
policies = [UserAgentPolicy("myusergant"), RedirectPolicy()]
transport = RequestsTransport(session=session, session_owner=False)
with Pipeline(transport, policies=policies) as pipeline:
response = pipeline.run(request)
assert transport.session
assert isinstance(response.http_response.status_code, int)
transport.close()
assert transport.session
transport.session.close()
def create_configuration(**kwargs):
# type: (**Any) -> Configuration
if 'connection_timeout' not in kwargs:
kwargs['connection_timeout'] = DEFAULT_SOCKET_TIMEOUT
config = Configuration(**kwargs)
config.headers_policy = StorageHeadersPolicy(**kwargs)
config.user_agent_policy = StorageUserAgentPolicy(**kwargs)
config.retry_policy = kwargs.get('retry_policy') or ExponentialRetry(
**kwargs)
config.redirect_policy = RedirectPolicy(**kwargs)
config.logging_policy = StorageLoggingPolicy(**kwargs)
config.proxy_policy = ProxyPolicy(**kwargs)
config.blob_settings = StorageBlobSettings(**kwargs)
return config
def _create_pipeline(**kwargs):
"""Creates and returns a PipelineClient configured for the provided base_url and kwargs"""
transport = kwargs.get("transport", RequestsTransport(**kwargs))
policies = [
kwargs.get("user_agent_policy",
UserAgentPolicy(_constants.USER_AGENT, **kwargs)),
kwargs.get("headers_policy", HeadersPolicy(**kwargs)),
kwargs.get("authentication_policy"),
kwargs.get("retry_policy", RetryPolicy(**kwargs)),
kwargs.get("redirect_policy", RedirectPolicy(**kwargs)),
kwargs.get("logging_policy", NetworkTraceLoggingPolicy(**kwargs)),
kwargs.get("proxy_policy", ProxyPolicy(**kwargs)),
]
return Pipeline(policies=policies, transport=transport)
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"),
RedirectPolicy(**kwargs),
StorageHosts(**kwargs),
TablesRetryPolicy(**kwargs),
CustomHookPolicy(**kwargs),
NetworkTraceLoggingPolicy(**kwargs),
DistributedTracingPolicy(**kwargs),
HttpLoggingPolicy(**kwargs),
]
def __init__(self, **kwargs: Any) -> None:
"""Azure Monitor base exporter for OpenTelemetry.
:keyword str api_version: The service API version used. Defaults to latest.
:rtype: None
"""
parsed_connection_string = ConnectionStringParser(
kwargs.get('connection_string'))
self._instrumentation_key = parsed_connection_string.instrumentation_key
self._timeout = 10.0 # networking timeout in seconds
self._api_version = kwargs.get('api_version') or _SERVICE_API_LATEST
self._consecutive_redirects = 0 # To prevent circular redirects
temp_suffix = self._instrumentation_key or ""
default_storage_path = os.path.join(tempfile.gettempdir(),
_TEMPDIR_PREFIX + temp_suffix)
config = AzureMonitorClientConfiguration(
parsed_connection_string.endpoint, **kwargs)
policies = [
RequestIdPolicy(**kwargs),
config.headers_policy,
config.user_agent_policy,
config.proxy_policy,
ContentDecodePolicy(**kwargs),
# Handle redirects in exporter, set new endpoint if redirected
RedirectPolicy(permit_redirects=False),
config.retry_policy,
config.authentication_policy,
config.custom_hook_policy,
config.logging_policy,
# Explicitly disabling to avoid infinite loop of Span creation when data is exported
# DistributedTracingPolicy(**kwargs),
config.http_logging_policy or HttpLoggingPolicy(**kwargs)
]
self.client = AzureMonitorClient(
host=parsed_connection_string.endpoint,
connection_timeout=self._timeout,
policies=policies,
**kwargs)
self.storage = LocalFileStorage(
path=default_storage_path,
max_size=50 * 1024 * 1024, # Maximum size in bytes.
maintenance_period=60, # Maintenance interval in seconds.
retention_period=7 * 24 * 60 * 60, # Retention period in seconds
)
def test_basic_requests_separate_session(port, http_request):
session = requests.Session()
request = http_request("GET",
"http://localhost:{}/basic/string".format(port))
policies = [UserAgentPolicy("myusergant"), RedirectPolicy()]
transport = RequestsTransport(session=session, session_owner=False)
with Pipeline(transport, policies=policies) as pipeline:
response = pipeline.run(request)
if is_rest(request):
assert is_rest(response.http_response)
assert transport.session
assert isinstance(response.http_response.status_code, int)
transport.close()
assert transport.session
transport.session.close()
def test_example_pipeline():
# [START build_pipeline]
from azure.core.pipeline import Pipeline
from azure.core.pipeline.policies import RedirectPolicy, UserAgentPolicy
from azure.core.pipeline.transport import RequestsTransport, HttpRequest
# example: create request and policies
request = HttpRequest("GET", "https://bing.com")
policies = [UserAgentPolicy("myuseragent"), RedirectPolicy()]
# run the pipeline
with Pipeline(transport=RequestsTransport(),
policies=policies) as pipeline:
response = pipeline.run(request)
# [END build_pipeline]
assert pipeline._transport.session is None
assert response.http_response.status_code == 200
def test_example_pipeline_client():
url = "https://bing.com"
# [START build_pipeline_client]
from azure.core import PipelineClient
from azure.core.pipeline.policies import RedirectPolicy, UserAgentPolicy
# example configuration with some policies
policies = [UserAgentPolicy("myuseragent"), RedirectPolicy()]
client = PipelineClient(base_url=url, policies=policies)
request = client.get("https://bing.com")
pipeline_response = client._pipeline.run(request)
# [END build_pipeline_client]
response = pipeline_response.http_response
assert isinstance(response.status_code, int)
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_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(),
RedirectPolicy(),
RetryPolicy(),
HttpLoggingPolicy()
]
client = PipelineClient(cloud_shell["vault_url"], policies=policies)
list_secrets = client.get(
"secrets",
headers={"Authorization": "Bearer " + token.token},
params={"api-version": "7.0"})
with client:
client._pipeline.run(list_secrets)
def _policies(credential, **kwargs):
# type: (Union[AzureKeyCredential, EventGridSharedAccessSignatureCredential], Any) -> List[Any]
auth_policy = _get_authentication_policy(credential)
sdk_moniker = 'eventgrid/{}'.format(VERSION)
policies = [
RequestIdPolicy(**kwargs),
HeadersPolicy(**kwargs),
UserAgentPolicy(sdk_moniker=sdk_moniker, **kwargs),
ProxyPolicy(**kwargs),
ContentDecodePolicy(**kwargs),
RedirectPolicy(**kwargs),
RetryPolicy(**kwargs), auth_policy,
CustomHookPolicy(**kwargs),
NetworkTraceLoggingPolicy(**kwargs),
DistributedTracingPolicy(**kwargs),
CloudEventDistributedTracingPolicy(),
HttpLoggingPolicy(**kwargs)
]
return policies
def _configure(
self,
**kwargs
):
from azure.core.pipeline.policies import UserAgentPolicy, HeadersPolicy, ProxyPolicy, \
RetryPolicy, CustomHookPolicy, RedirectPolicy, SansIOHTTPPolicy
from azure.cli.core.sdk.policies import SafeNetworkTraceLoggingPolicy
from ._http_policy import AAZBearerTokenCredentialPolicy
self.user_agent_policy = kwargs.get('user_agent_policy') or UserAgentPolicy(**kwargs)
self.headers_policy = kwargs.get('headers_policy') or HeadersPolicy(**kwargs)
self.proxy_policy = kwargs.get('proxy_policy') or ProxyPolicy(**kwargs)
self.logging_policy = kwargs.get('logging_policy') or SafeNetworkTraceLoggingPolicy(**kwargs)
self.http_logging_policy = kwargs.get('http_logging_policy') or SansIOHTTPPolicy()
self.retry_policy = kwargs.get('retry_policy') or RetryPolicy(**kwargs)
self.custom_hook_policy = kwargs.get('custom_hook_policy') or CustomHookPolicy(**kwargs)
self.redirect_policy = kwargs.get('redirect_policy') or RedirectPolicy(**kwargs)
self.authentication_policy = kwargs.get('authentication_policy')
if self.credential and not self.authentication_policy:
self.authentication_policy = AAZBearerTokenCredentialPolicy(
self.credential, *self.credential_scopes, **kwargs)
