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)