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