def _build_pipeline(self, **kwargs): # pylint: disable=no-self-use
transport = kwargs.get('transport')
policies = kwargs.get('policies')
credential_policy = ServiceBusSharedKeyCredentialPolicy(self._endpoint, self._credential, "Authorization") \
if isinstance(self._credential, ServiceBusSharedKeyCredential) \
else BearerTokenCredentialPolicy(self._credential, JWT_TOKEN_SCOPE)
if policies is None: # [] is a valid policy list
policies = [
RequestIdPolicy(**kwargs),
self._config.headers_policy,
self._config.user_agent_policy,
self._config.proxy_policy,
ContentDecodePolicy(**kwargs),
self._config.redirect_policy,
self._config.retry_policy,
credential_policy,
self._config.logging_policy,
DistributedTracingPolicy(**kwargs),
HttpLoggingPolicy(**kwargs),
]
if not transport:
transport = RequestsTransport(**kwargs)
return Pipeline(transport, policies)
def test_http_logger_with_generator_body(http_request, http_response):
class MockHandler(logging.Handler):
def __init__(self):
super(MockHandler, self).__init__()
self.messages = []
def reset(self):
self.messages = []
def emit(self, record):
self.messages.append(record)
mock_handler = MockHandler()
logger = logging.getLogger("testlogger")
logger.addHandler(mock_handler)
logger.setLevel(logging.DEBUG)
policy = HttpLoggingPolicy(logger=logger)
universal_request = http_request('GET', 'http://localhost/')
mock = Mock()
mock.__class__ = types.AsyncGeneratorType
universal_request.body = mock
http_response = create_http_response(http_response, universal_request,
None)
http_response.status_code = 202
request = PipelineRequest(universal_request, PipelineContext(None))
policy.on_request(request)
response = PipelineResponse(request, http_response, request.context)
policy.on_response(request, response)
assert all(m.levelname == 'INFO' for m in mock_handler.messages)
assert len(mock_handler.messages) == 2
messages_request = mock_handler.messages[0].message.split("\n")
messages_response = mock_handler.messages[1].message.split("\n")
assert messages_request[0] == "Request URL: 'http://localhost/'"
assert messages_request[1] == "Request method: 'GET'"
assert messages_request[2] == 'Request headers:'
assert messages_request[3] == 'File upload'
assert messages_response[0] == 'Response status: 202'
assert messages_response[1] == 'Response headers:'
mock_handler.reset()
def _create_appconfig_pipeline(self, **kwargs):
transport = kwargs.get('transport')
policies = kwargs.get('policies')
if policies is None: # [] is a valid policy list
policies = [
self._config.headers_policy,
self._config.user_agent_policy,
AppConfigRequestsCredentialsPolicy(self._config.credentials),
SyncTokenPolicy(),
self._config.retry_policy,
self._config.logging_policy, # HTTP request/response log
DistributedTracingPolicy(**kwargs),
HttpLoggingPolicy(**kwargs),
]
if not transport:
transport = AsyncioRequestsTransport(**kwargs)
return AsyncPipeline(
transport,
policies,
)
def _build_pipeline(config: Configuration, transport: AsyncHttpTransport,
**kwargs: "Any") -> AsyncPipeline:
logging_policy = HttpLoggingPolicy(**kwargs)
logging_policy.allowed_header_names.add("x-ms-keyvault-network-info")
policies = [
config.headers_policy,
config.user_agent_policy,
config.proxy_policy,
ContentDecodePolicy(),
config.redirect_policy,
config.retry_policy,
config.authentication_policy,
config.logging_policy,
DistributedTracingPolicy(**kwargs),
logging_policy,
]
if transport is None:
from azure.core.pipeline.transport import AioHttpTransport
transport = AioHttpTransport(**kwargs)
return AsyncPipeline(transport, policies=policies)
def __init__(
self,
config=None, # type: Optional[Configuration]
policies=None, # type: Optional[PolicyListType]
transport=None, # type: Optional[HttpTransport]
**kwargs # type: Any
):
# type: (...) -> None
config = config or self._create_config(**kwargs)
policies = policies or [
ContentDecodePolicy(),
config.user_agent_policy,
config.proxy_policy,
config.retry_policy,
config.logging_policy,
DistributedTracingPolicy(**kwargs),
HttpLoggingPolicy(**kwargs),
]
if not transport:
transport = RequestsTransport(**kwargs)
self._pipeline = Pipeline(transport=transport,
policies=policies) # type: Pipeline
super(AuthnClient, self).__init__(**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, TextAnalyticsAPIKeyCredential):
credential_policy = CognitiveServicesCredentialPolicy(credential)
elif credential is not None:
raise TypeError(
"Unsupported credential: {}. Use an instance of TextAnalyticsAPIKeyCredential "
"or a token credential from azure.identity".format(
type(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)
def __init__(self, endpoint, credential, **kwargs):
http_logging_policy = HttpLoggingPolicy(**kwargs)
http_logging_policy.allowed_header_names.update({
"Operation-Location",
"apim-request-id",
"x-envoy-upstream-service-time",
"Strict-Transport-Security",
"x-content-type-options",
})
http_logging_policy.allowed_query_params.update({
"model-version",
"showStats",
"loggingOptOut",
"domain",
"stringIndexType",
"piiCategories",
"$top",
"$skip",
"opinionMining",
})
try:
endpoint = endpoint.rstrip("/")
except AttributeError:
raise ValueError("Parameter 'endpoint' must be a string.")
self._client = _TextAnalyticsClient(
endpoint=endpoint,
credential=credential,
api_version=kwargs.pop("api_version", DEFAULT_API_VERSION),
sdk_moniker=USER_AGENT,
authentication_policy=kwargs.pop(
"authentication_policy", _authentication_policy(credential)),
custom_hook_policy=kwargs.pop(
"custom_hook_policy",
TextAnalyticsResponseHookPolicy(**kwargs)),
http_logging_policy=kwargs.pop("http_logging_policy",
http_logging_policy),
**kwargs)
def _create_appconfig_pipeline(self,
credential,
base_url=None,
aad_mode=False,
**kwargs):
transport = kwargs.get("transport")
policies = kwargs.get("policies")
if policies is None: # [] is a valid policy list
if aad_mode:
scope = base_url.strip("/") + "/.default"
if hasattr(credential, "get_token"):
credential_policy = BearerTokenCredentialPolicy(
credential, scope)
else:
raise TypeError(
"Please provide an instance from azure-identity "
"or a class that implement the 'get_token protocol")
else:
credential_policy = AppConfigRequestsCredentialsPolicy(
credential)
policies = [
self._config.headers_policy,
self._config.user_agent_policy,
self._config.retry_policy,
self._sync_token_policy,
credential_policy,
self._config.logging_policy, # HTTP request/response log
DistributedTracingPolicy(**kwargs),
HttpLoggingPolicy(**kwargs),
ContentDecodePolicy(**kwargs),
]
if not transport:
transport = RequestsTransport(**kwargs)
return Pipeline(transport, policies)
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 = [
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),
]
return config, Pipeline(config.transport, policies=policies)
def get_http_logging_policy(**kwargs):
http_logging_policy = HttpLoggingPolicy(**kwargs)
http_logging_policy.allowed_header_names.update({
"Operation-Location",
"Content-Encoding",
"Vary",
"apim-request-id",
"X-RequestId",
"Set-Cookie",
"X-Powered-By",
"Strict-Transport-Security",
"x-content-type-options",
})
http_logging_policy.allowed_query_params.update({
"$top",
"$skip",
"$maxpagesize",
"ids",
"statuses",
"createdDateTimeUtcStart",
"createdDateTimeUtcEnd",
"$orderBy",
})
return http_logging_policy
def test_http_logger_with_body():
class MockHandler(logging.Handler):
def __init__(self):
super(MockHandler, self).__init__()
self.messages = []
def reset(self):
self.messages = []
def emit(self, record):
self.messages.append(record)
mock_handler = MockHandler()
logger = logging.getLogger("testlogger")
logger.addHandler(mock_handler)
logger.setLevel(logging.DEBUG)
policy = HttpLoggingPolicy(logger=logger)
universal_request = HttpRequest('GET', 'http://127.0.0.1/')
universal_request.body = "testbody"
http_response = HttpResponse(universal_request, None)
http_response.status_code = 202
request = PipelineRequest(universal_request, PipelineContext(None))
policy.on_request(request)
response = PipelineResponse(request, http_response, request.context)
policy.on_response(request, response)
assert all(m.levelname == 'INFO' for m in mock_handler.messages)
assert len(mock_handler.messages) == 6
assert mock_handler.messages[
0].message == "Request URL: 'http://127.0.0.1/'"
assert mock_handler.messages[1].message == "Request method: 'GET'"
assert mock_handler.messages[2].message == 'Request headers:'
assert mock_handler.messages[
3].message == 'A body is sent with the request'
assert mock_handler.messages[4].message == 'Response status: 202'
assert mock_handler.messages[5].message == 'Response headers:'
mock_handler.reset()
def test_http_logger_operation_level(http_request, http_response):
class MockHandler(logging.Handler):
def __init__(self):
super(MockHandler, self).__init__()
self.messages = []
def reset(self):
self.messages = []
def emit(self, record):
self.messages.append(record)
mock_handler = MockHandler()
logger = logging.getLogger("testlogger")
logger.addHandler(mock_handler)
logger.setLevel(logging.DEBUG)
policy = HttpLoggingPolicy()
kwargs = {'logger': logger}
universal_request = http_request('GET', 'http://localhost/')
http_response = create_http_response(http_response, universal_request,
None)
http_response.status_code = 202
request = PipelineRequest(universal_request,
PipelineContext(None, **kwargs))
# Basics
policy.on_request(request)
response = PipelineResponse(request, http_response, request.context)
policy.on_response(request, response)
assert all(m.levelname == 'INFO' for m in mock_handler.messages)
assert len(mock_handler.messages) == 2
messages_request = mock_handler.messages[0].message.split("\n")
messages_response = mock_handler.messages[1].message.split("\n")
assert messages_request[0] == "Request URL: 'http://localhost/'"
assert messages_request[1] == "Request method: 'GET'"
assert messages_request[2] == 'Request headers:'
assert messages_request[3] == 'No body was attached to the request'
assert messages_response[0] == 'Response status: 202'
assert messages_response[1] == 'Response headers:'
mock_handler.reset()
# Let's make this request a failure, retried twice
request = PipelineRequest(universal_request,
PipelineContext(None, **kwargs))
policy.on_request(request)
response = PipelineResponse(request, http_response, request.context)
policy.on_response(request, response)
policy.on_request(request)
response = PipelineResponse(request, http_response, request.context)
policy.on_response(request, response)
assert all(m.levelname == 'INFO' for m in mock_handler.messages)
assert len(mock_handler.messages) == 4
messages_request1 = mock_handler.messages[0].message.split("\n")
messages_response1 = mock_handler.messages[1].message.split("\n")
messages_request2 = mock_handler.messages[2].message.split("\n")
messages_response2 = mock_handler.messages[3].message.split("\n")
assert messages_request1[0] == "Request URL: 'http://localhost/'"
assert messages_request1[1] == "Request method: 'GET'"
assert messages_request1[2] == 'Request headers:'
assert messages_request1[3] == 'No body was attached to the request'
assert messages_response1[0] == 'Response status: 202'
assert messages_response1[1] == 'Response headers:'
assert messages_request2[0] == "Request URL: 'http://localhost/'"
assert messages_request2[1] == "Request method: 'GET'"
assert messages_request2[2] == 'Request headers:'
assert messages_request2[3] == 'No body was attached to the request'
assert messages_response2[0] == 'Response status: 202'
assert messages_response2[1] == 'Response headers:'
mock_handler.reset()
def __init__(
self,
endpoint: str,
credential: Union["AzureKeyCredential", "AsyncTokenCredential"],
**kwargs: Any
) -> None:
try:
endpoint = endpoint.rstrip("/")
except AttributeError:
raise ValueError("Parameter 'endpoint' must be a string.")
self._endpoint = endpoint
self._credential = credential
self._api_version = kwargs.pop("api_version", None)
if not self._api_version:
raise ValueError("'api_version' must be specified.")
if self._api_version.startswith("v"): # v2.0 released with this option
self._api_version = self._api_version[1:]
client_kind = kwargs.pop("client_kind")
validate_api_version(self._api_version, client_kind)
authentication_policy = get_authentication_policy(credential)
polling_interval = kwargs.pop("polling_interval", POLLING_INTERVAL)
http_logging_policy = HttpLoggingPolicy(**kwargs)
http_logging_policy.allowed_header_names.update(
{
"Operation-Location",
"Location",
"x-envoy-upstream-service-time",
"apim-request-id",
"Strict-Transport-Security",
"x-content-type-options",
"ms-azure-ai-errorcode",
"x-ms-cs-error-code",
}
)
http_logging_policy.allowed_query_params.update(
{
"includeTextDetails",
"locale",
"language",
"includeKeys",
"op",
"pages",
"readingOrder",
"stringIndexType",
"api-version",
}
)
self._client = FormRecognizer(
endpoint=endpoint,
credential=credential, # type: ignore
api_version=self._api_version,
sdk_moniker=USER_AGENT,
authentication_policy=kwargs.get(
"authentication_policy", authentication_policy
),
http_logging_policy=kwargs.get("http_logging_policy", http_logging_policy),
per_retry_policies=kwargs.get("per_retry_policies", QuotaExceededPolicy()),
polling_interval=polling_interval,
**kwargs
)
self._deserialize = _get_deserialize(self._api_version)
self._generated_models = self._client.models(self._api_version)
def __init__(self, endpoint, credential, ledger_certificate_path,
**kwargs):
# type: (str, Union[ConfidentialLedgerCertificateCredential, TokenCredential], str, Any) -> None
client = kwargs.get("generated_client")
if client:
# caller provided a configured client -> nothing left to initialize
self._client = client
return
if not endpoint:
raise ValueError("Expected endpoint to be a non-empty string")
if not credential:
raise ValueError("Expected credential to not be None")
if not isinstance(ledger_certificate_path, str):
raise TypeError("ledger_certificate_path must be a string")
if ledger_certificate_path == "":
raise ValueError(
"If not None, ledger_certificate_path must be a non-empty string"
)
try:
endpoint = endpoint.strip(" /")
if not endpoint.startswith("https://"):
self._endpoint = "https://" + endpoint
else:
self._endpoint = endpoint
except AttributeError:
raise ValueError("Confidential Ledger URL must be a string.")
self.api_version = kwargs.pop("api_version", DEFAULT_VERSION)
pipeline = kwargs.pop("pipeline", None)
transport = kwargs.pop("transport", None)
if transport is None:
# Customize the transport layer to use client certificate authentication and validate
# a self-signed TLS certificate.
if isinstance(credential, ConfidentialLedgerCertificateCredential):
kwargs["connection_cert"] = credential.certificate_path
kwargs["connection_verify"] = ledger_certificate_path
transport = RequestsTransport(**kwargs)
http_logging_policy = HttpLoggingPolicy(**kwargs)
http_logging_policy.allowed_header_names.update({
"x-ms-keyvault-network-info",
"x-ms-keyvault-region",
"x-ms-keyvault-service-version",
})
if not isinstance(credential, ConfidentialLedgerCertificateCredential):
kwargs["authentication_policy"] = kwargs.pop(
"authentication_policy",
BearerTokenCredentialPolicy(
credential,
"https://confidential-ledger.azure.com/.default",
**kwargs),
)
try:
self._client = _ConfidentialLedgerClient(
self._endpoint,
api_version=self.api_version,
pipeline=pipeline,
transport=transport,
http_logging_policy=http_logging_policy,
**kwargs)
except NotImplementedError:
raise NotImplementedError(
"This package doesn't support API version '{}'. ".format(
self.api_version) + "Supported versions: 0.1-preview")
def __init__(
self,
*,
endpoint: str,
credential: Union[ConfidentialLedgerCertificateCredential, "TokenCredential"],
ledger_certificate_path: str,
**kwargs: Any
) -> None:
client = kwargs.get("generated_client")
if client:
# caller provided a configured client -> nothing left to initialize
self._client = client
return
if not endpoint:
raise ValueError("Expected endpoint to be a non-empty string")
if not credential:
raise ValueError("Expected credential to not be None")
if not isinstance(ledger_certificate_path, str):
raise TypeError("ledger_certificate_path must be a string")
if ledger_certificate_path == "":
raise ValueError(
"If not None, ledger_certificate_path must be a non-empty string"
)
endpoint = endpoint.strip(" /")
try:
if not endpoint.startswith("https://"):
self._endpoint = "https://" + endpoint
else:
self._endpoint = endpoint
except AttributeError:
raise ValueError("Confidential Ledger URL must be a string.")
self.api_version = kwargs.pop("api_version", DEFAULT_VERSION)
if not kwargs.get("transport", None):
# Customize the transport layer to use client certificate authentication and validate
# a self-signed TLS certificate.
if isinstance(credential, ConfidentialLedgerCertificateCredential):
# The async version of the client seems to expect a sequence of filenames.
# azure/core/pipeline/transport/_aiohttp.py:163
# > ssl_ctx.load_cert_chain(*cert)
kwargs["connection_cert"] = (credential.certificate_path,)
kwargs["connection_verify"] = ledger_certificate_path
http_logging_policy = HttpLoggingPolicy(**kwargs)
http_logging_policy.allowed_header_names.update(
{
"x-ms-keyvault-network-info",
"x-ms-keyvault-region",
"x-ms-keyvault-service-version",
}
)
if not isinstance(credential, ConfidentialLedgerCertificateCredential):
kwargs["authentication_policy"] = kwargs.pop(
"authentication_policy",
AsyncBearerTokenCredentialPolicy(
credential,
"https://confidential-ledger.azure.com/.default",
**kwargs
),
)
try:
self._client = _ConfidentialLedgerClient(
self._endpoint,
api_version=self.api_version,
http_logging_policy=http_logging_policy,
sdk_moniker=USER_AGENT,
**kwargs
)
except NotImplementedError:
raise NotImplementedError(
"This package doesn't support API version '{}'. ".format(
self.api_version
)
+ "Supported versions: 0.1-preview"
)
def test_http_logger_operation_level():
class MockHandler(logging.Handler):
def __init__(self):
super(MockHandler, self).__init__()
self.messages = []
def reset(self):
self.messages = []
def emit(self, record):
self.messages.append(record)
mock_handler = MockHandler()
logger = logging.getLogger("testlogger")
logger.addHandler(mock_handler)
logger.setLevel(logging.DEBUG)
policy = HttpLoggingPolicy()
kwargs = {'logger': logger}
universal_request = HttpRequest('GET', 'http://127.0.0.1/')
http_response = HttpResponse(universal_request, None)
http_response.status_code = 202
request = PipelineRequest(universal_request,
PipelineContext(None, **kwargs))
# Basics
policy.on_request(request)
response = PipelineResponse(request, http_response, request.context)
policy.on_response(request, response)
assert all(m.levelname == 'INFO' for m in mock_handler.messages)
assert len(mock_handler.messages) == 5
assert mock_handler.messages[
0].message == "Request URL: 'http://127.0.0.1/'"
assert mock_handler.messages[1].message == "Request method: 'GET'"
assert mock_handler.messages[2].message == 'Request headers:'
assert mock_handler.messages[3].message == 'Response status: 202'
assert mock_handler.messages[4].message == 'Response headers:'
mock_handler.reset()
# Let's make this request a failure, retried twice
request = PipelineRequest(universal_request,
PipelineContext(None, **kwargs))
policy.on_request(request)
response = PipelineResponse(request, http_response, request.context)
policy.on_response(request, response)
policy.on_request(request)
response = PipelineResponse(request, http_response, request.context)
policy.on_response(request, response)
assert all(m.levelname == 'INFO' for m in mock_handler.messages)
assert len(mock_handler.messages) == 10
assert mock_handler.messages[
0].message == "Request URL: 'http://127.0.0.1/'"
assert mock_handler.messages[1].message == "Request method: 'GET'"
assert mock_handler.messages[2].message == 'Request headers:'
assert mock_handler.messages[3].message == 'Response status: 202'
assert mock_handler.messages[4].message == 'Response headers:'
assert mock_handler.messages[
0].message == "Request URL: 'http://127.0.0.1/'"
assert mock_handler.messages[1].message == "Request method: 'GET'"
assert mock_handler.messages[2].message == 'Request headers:'
assert mock_handler.messages[3].message == 'Response status: 202'
assert mock_handler.messages[4].message == 'Response headers:'
mock_handler.reset()
def test_http_logger():
class MockHandler(logging.Handler):
def __init__(self):
super(MockHandler, self).__init__()
self.messages = []
def reset(self):
self.messages = []
def emit(self, record):
self.messages.append(record)
mock_handler = MockHandler()
logger = logging.getLogger("testlogger")
logger.addHandler(mock_handler)
logger.setLevel(logging.DEBUG)
policy = HttpLoggingPolicy(logger=logger)
universal_request = HttpRequest('GET', 'http://127.0.0.1/')
http_response = HttpResponse(universal_request, None)
http_response.status_code = 202
request = PipelineRequest(universal_request, PipelineContext(None))
# Basics
policy.on_request(request)
response = PipelineResponse(request, http_response, request.context)
policy.on_response(request, response)
assert all(m.levelname == 'INFO' for m in mock_handler.messages)
assert len(mock_handler.messages) == 5
assert mock_handler.messages[
0].message == "Request URL: 'http://127.0.0.1/'"
assert mock_handler.messages[1].message == "Request method: 'GET'"
assert mock_handler.messages[2].message == 'Request headers:'
assert mock_handler.messages[3].message == 'Response status: 202'
assert mock_handler.messages[4].message == 'Response headers:'
mock_handler.reset()
# Let's make this request a failure, retried twice
policy.on_request(request)
response = PipelineResponse(request, http_response, request.context)
policy.on_response(request, response)
policy.on_request(request)
response = PipelineResponse(request, http_response, request.context)
policy.on_response(request, response)
assert all(m.levelname == 'INFO' for m in mock_handler.messages)
assert len(mock_handler.messages) == 10
assert mock_handler.messages[
0].message == "Request URL: 'http://127.0.0.1/'"
assert mock_handler.messages[1].message == "Request method: 'GET'"
assert mock_handler.messages[2].message == 'Request headers:'
assert mock_handler.messages[3].message == 'Response status: 202'
assert mock_handler.messages[4].message == 'Response headers:'
assert mock_handler.messages[
0].message == "Request URL: 'http://127.0.0.1/'"
assert mock_handler.messages[1].message == "Request method: 'GET'"
assert mock_handler.messages[2].message == 'Request headers:'
assert mock_handler.messages[3].message == 'Response status: 202'
assert mock_handler.messages[4].message == 'Response headers:'
mock_handler.reset()
# Headers and query parameters
policy.allowed_query_params = ['country']
universal_request.headers = {
"Accept": "Caramel",
"Hate": "Chocolat",
}
http_response.headers = {
"Content-Type": "Caramel",
"HateToo": "Chocolat",
}
universal_request.url = "http://127.0.0.1/?country=france&city=aix"
policy.on_request(request)
response = PipelineResponse(request, http_response, request.context)
policy.on_response(request, response)
assert all(m.levelname == 'INFO' for m in mock_handler.messages)
assert len(mock_handler.messages) == 9
assert mock_handler.messages[
0].message == "Request URL: 'http://127.0.0.1/?country=france&city=REDACTED'"
assert mock_handler.messages[1].message == "Request method: 'GET'"
assert mock_handler.messages[2].message == "Request headers:"
# Dict not ordered in Python, exact logging order doesn't matter
assert set([
mock_handler.messages[3].message, mock_handler.messages[4].message
]) == set([" 'Accept': 'Caramel'", " 'Hate': 'REDACTED'"])
assert mock_handler.messages[5].message == "Response status: 202"
assert mock_handler.messages[6].message == "Response headers:"
# Dict not ordered in Python, exact logging order doesn't matter
assert set([
mock_handler.messages[7].message, mock_handler.messages[8].message
]) == set([" 'Content-Type': 'Caramel'", " 'HateToo': 'REDACTED'"])
mock_handler.reset()
def __init__(
self,
parsed_url, # type: Any
service, # type: str
credential=None, # type: Optional[Any]
**kwargs # type: Any
):
# type: (...) -> None
self._location_mode = kwargs.get("_location_mode",
LocationMode.PRIMARY)
self._hosts = kwargs.get("_hosts")
self.scheme = parsed_url.scheme
if service not in ["blob", "queue", "file-share", "dfs", "table"]:
raise ValueError("Invalid service: {}".format(service))
service_name = service.split("-")[0]
account = parsed_url.netloc.split(".{}.core.".format(service_name))
if "cosmos" in parsed_url.netloc:
account = parsed_url.netloc.split(
".{}.cosmos.".format(service_name))
self.account_name = account[0] if len(account) > 1 else None
secondary_hostname = None
self.credential = format_shared_key_credential(account, credential)
if self.scheme.lower() != "https" and hasattr(self.credential,
"get_token"):
raise ValueError("Token credential is only supported with HTTPS.")
if hasattr(self.credential, "account_name"):
self.account_name = self.credential.account_name
secondary_hostname = "{}-secondary.{}.{}".format(
self.credential.account_name, service_name, SERVICE_HOST_BASE)
if not self._hosts:
if len(account) > 1:
secondary_hostname = parsed_url.netloc.replace(
account[0], account[0] + "-secondary")
if kwargs.get("secondary_hostname"):
secondary_hostname = kwargs["secondary_hostname"]
primary_hostname = (parsed_url.netloc +
parsed_url.path).rstrip("/")
self._hosts = {
LocationMode.PRIMARY: primary_hostname,
LocationMode.SECONDARY: secondary_hostname,
}
self.require_encryption = kwargs.get("require_encryption", False)
self.key_encryption_key = kwargs.get("key_encryption_key")
self.key_resolver_function = kwargs.get("key_resolver_function")
self._configure_credential(self.credential)
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"),
RedirectPolicy(**kwargs),
StorageHosts(hosts=self._hosts, **kwargs),
kwargs.get("retry_policy") or TablesRetryPolicy(**kwargs),
StorageLoggingPolicy(**kwargs),
StorageResponseHook(**kwargs),
DistributedTracingPolicy(**kwargs),
HttpLoggingPolicy(**kwargs),
]
def get_http_logging_policy(**kwargs):
http_logging_policy = HttpLoggingPolicy(**kwargs)
http_logging_policy.allowed_header_names.update({"MS-CV"})
return http_logging_policy
