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 test_user_agent_environ(): with mock.patch.dict('os.environ', {'AZURE_HTTP_USER_AGENT': "mytools"}): policy = UserAgentPolicy(None) assert policy.user_agent.endswith("mytools") request = HttpRequest('GET', 'http://127.0.0.1/') policy.on_request(PipelineRequest(request, PipelineContext(None))) assert request.headers["user-agent"].endswith("mytools")
def __init__(self, base_url, credential, **kwargs): # type: (str, Any, dict) -> None try: if not base_url.lower().startswith("http"): base_url = "https://" + base_url except AttributeError: raise ValueError("Base URL must be a string.") if not credential: raise ValueError("Missing credential") self._config = AzureAppConfigurationConfiguration( credential, base_url, **kwargs) self._config.user_agent_policy = UserAgentPolicy( base_user_agent=USER_AGENT, **kwargs) pipeline = kwargs.get("pipeline") if pipeline is None: aad_mode = not isinstance(credential, AppConfigConnectionStringCredential) pipeline = self._create_appconfig_pipeline(credential=credential, aad_mode=aad_mode, base_url=base_url, **kwargs) self._impl = AzureAppConfiguration(credentials=credential, endpoint=base_url, pipeline=pipeline)
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 __init__(self, base_url, credential, **kwargs): # type: (str, Union[AppConfigConnectionStringCredential, TokenCredential], **Any) -> None try: if not base_url.lower().startswith("http"): base_url = "https://" + base_url except AttributeError: raise ValueError("Base URL must be a string.") if not credential: raise ValueError("Missing credential") self._credential_scopes = base_url.strip("/") + "/.default" self._config = AzureAppConfigurationConfiguration( credential, base_url, credential_scopes=self._credential_scopes, **kwargs # type: ignore ) self._config.user_agent_policy = UserAgentPolicy( base_user_agent=USER_AGENT, **kwargs ) self._sync_token_policy = SyncTokenPolicy() pipeline = kwargs.get("pipeline") if pipeline is None: aad_mode = not isinstance(credential, AppConfigConnectionStringCredential) pipeline = self._create_appconfig_pipeline( credential=credential, aad_mode=aad_mode, base_url=base_url, **kwargs ) self._impl = AzureAppConfiguration( credential, base_url, pipeline=pipeline, credential_scopes=self._credential_scopes # type: ignore )
def __init__(self, endpoint, credential, **kwargs): # type: (str, MetricsAdvisorKeyCredential, Any) -> None try: if not endpoint.lower().startswith('http'): endpoint = "https://" + endpoint except AttributeError: raise ValueError("Base URL must be a string.") if not credential: raise ValueError("Missing credential") self._config = AzureCognitiveServiceMetricsAdvisorRESTAPIOpenAPIV2Configuration( endpoint=endpoint, **kwargs) self._endpoint = endpoint self._credential = credential self._config.user_agent_policy = UserAgentPolicy( base_user_agent=None, sdk_moniker=SDK_MONIKER, **kwargs) pipeline = kwargs.get("pipeline") if pipeline is None: aad_mode = not isinstance(credential, MetricsAdvisorKeyCredential) pipeline = self._create_pipeline(credential=credential, aad_mode=aad_mode, endpoint=endpoint, **kwargs) self._client = AzureCognitiveServiceMetricsAdvisorRESTAPIOpenAPIV2( endpoint=endpoint, pipeline=pipeline)
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_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
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(): 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 _create_config(credential, api_version=None, **kwargs): # type: (TokenCredential, Optional[str], Mapping[str, Any]) -> Configuration if api_version is None: api_version = KeyVaultClient.DEFAULT_API_VERSION config = KeyVaultClient.get_configuration_class(api_version, aio=False)(credential, **kwargs) config.authentication_policy = ChallengeAuthPolicy(credential) # replace the autorest-generated UserAgentPolicy and its hard-coded user agent # https://github.com/Azure/azure-sdk-for-python/issues/6637 config.user_agent_policy = UserAgentPolicy(base_user_agent=USER_AGENT, **kwargs) # Override config policies if found in kwargs if "user_agent_policy" in kwargs: config.user_agent_policy = kwargs["user_agent_policy"] if "headers_policy" in kwargs: config.headers_policy = kwargs["headers_policy"] if "proxy_policy" in kwargs: config.proxy_policy = kwargs["proxy_policy"] if "logging_policy" in kwargs: config.logging_policy = kwargs["logging_policy"] if "retry_policy" in kwargs: config.retry_policy = kwargs["retry_policy"] if "custom_hook_policy" in kwargs: config.custom_hook_policy = kwargs["custom_hook_policy"] if "redirect_policy" in kwargs: config.redirect_policy = kwargs["redirect_policy"] return config
def _create_config(credential: "TokenCredential", api_version: str = None, **kwargs: "Any") -> Configuration: if api_version is None: api_version = KeyVaultClient.DEFAULT_API_VERSION config = KeyVaultClient.get_configuration_class(api_version, aio=True)(credential, **kwargs) config.authentication_policy = AsyncChallengeAuthPolicy(credential) # replace the autorest-generated UserAgentPolicy and its hard-coded user agent # https://github.com/Azure/azure-sdk-for-python/issues/6637 config.user_agent_policy = UserAgentPolicy(base_user_agent=USER_AGENT, **kwargs) # Override config policies if found in kwargs # TODO: should be unnecessary after next regeneration (written 2019-08-02) if "user_agent_policy" in kwargs: config.user_agent_policy = kwargs["user_agent_policy"] if "headers_policy" in kwargs: config.headers_policy = kwargs["headers_policy"] if "proxy_policy" in kwargs: config.proxy_policy = kwargs["proxy_policy"] if "logging_policy" in kwargs: config.logging_policy = kwargs["logging_policy"] if "retry_policy" in kwargs: config.retry_policy = kwargs["retry_policy"] if "custom_hook_policy" in kwargs: config.custom_hook_policy = kwargs["custom_hook_policy"] if "redirect_policy" in kwargs: config.redirect_policy = kwargs["redirect_policy"] return config
def create_configuration(**kwargs): # type: (**Any) -> Configuration config = Configuration(**kwargs) config.headers_policy = StorageHeadersPolicy(**kwargs) config.user_agent_policy = UserAgentPolicy( sdk_moniker="storage-{}/{}".format(kwargs.pop('storage_sdk'), VERSION), **kwargs) config.retry_policy = kwargs.get("retry_policy") or ExponentialRetry( **kwargs) config.logging_policy = StorageLoggingPolicy(**kwargs) config.proxy_policy = ProxyPolicy(**kwargs) # Storage settings config.max_single_put_size = kwargs.get("max_single_put_size", 64 * 1024 * 1024) config.copy_polling_interval = 15 # Block blob uploads config.max_block_size = kwargs.get("max_block_size", 4 * 1024 * 1024) config.min_large_block_upload_threshold = kwargs.get( "min_large_block_upload_threshold", 4 * 1024 * 1024 + 1) config.use_byte_buffer = kwargs.get("use_byte_buffer", False) # Page blob uploads config.max_page_size = kwargs.get("max_page_size", 4 * 1024 * 1024) # Blob downloads config.max_single_get_size = kwargs.get("max_single_get_size", 32 * 1024 * 1024) config.max_chunk_get_size = kwargs.get("max_chunk_get_size", 4 * 1024 * 1024) # File uploads config.max_range_size = kwargs.get("max_range_size", 4 * 1024 * 1024) 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
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 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)
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)
def _get_policies(config: "Configuration", **kwargs: "Any") -> "List[PolicyType]": return [ UserAgentPolicy(base_user_agent=USER_AGENT, **kwargs), config.proxy_policy, config.retry_policy, ArcChallengeAuthPolicy(), NetworkTraceLoggingPolicy(**kwargs), DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs), ]
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(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)
def _get_policies(config, **kwargs): return [ HeadersPolicy(**kwargs), UserAgentPolicy(base_user_agent=USER_AGENT, **kwargs), config.proxy_policy, config.retry_policy, NetworkTraceLoggingPolicy(**kwargs), DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs), ]
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
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_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 __init__(self, credentials, base_url, **kwargs): self.config = ConfigurationClientConfiguration(credentials, **kwargs) self.config.user_agent_policy = UserAgentPolicy( base_user_agent=USER_AGENT, **kwargs) self._impl = ConfigurationClient( credentials, base_url, pipeline=self._create_appconfig_pipeline(), )
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 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)
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 test_request_hook_policy_in_request(): def test_callback(response): raise ValueError() url = "https://bing.com" custom_hook_policy = CustomHookPolicy() policies = [UserAgentPolicy("myuseragent"), custom_hook_policy] client = PipelineClient(base_url=url, policies=policies) request = client.get(url) with pytest.raises(ValueError): client._pipeline.run(request, raw_request_hook=test_callback)