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)