async def send(self, request: HttpRequest, **kwargs: Any) -> AsyncHttpResponse: # type: ignore # pylint:disable=invalid-overridden-method
"""Send the request using this HTTP sender.
:param request: The HttpRequest
:type request: ~azure.core.pipeline.transport.HttpRequest
:return: The AsyncHttpResponse
:rtype: ~azure.core.pipeline.transport.AsyncHttpResponse
:keyword requests.Session session: will override the driver session and use yours.
Should NOT be done unless really required. Anything else is sent straight to requests.
:keyword dict proxies: will define the proxy to use. Proxy is a dict (protocol, url)
"""
self.open()
loop = kwargs.get("loop", _get_running_loop())
response = None
error = None # type: Optional[Union[ServiceRequestError, ServiceResponseError]]
data_to_send = await self._retrieve_request_data(request)
try:
response = await loop.run_in_executor(
None,
functools.partial(
self.session.request,
request.method,
request.url,
headers=request.headers,
data=data_to_send,
files=request.files,
verify=kwargs.pop('connection_verify', self.connection_config.verify),
timeout=kwargs.pop('connection_timeout', self.connection_config.timeout),
cert=kwargs.pop('connection_cert', self.connection_config.cert),
allow_redirects=False,
**kwargs))
except urllib3.exceptions.NewConnectionError as err:
error = ServiceRequestError(err, error=err)
except requests.exceptions.ReadTimeout as err:
error = ServiceResponseError(err, error=err)
except requests.exceptions.ConnectionError as err:
if err.args and isinstance(err.args[0], urllib3.exceptions.ProtocolError):
error = ServiceResponseError(err, error=err)
else:
error = ServiceRequestError(err, error=err)
except requests.RequestException as err:
error = ServiceRequestError(err, error=err)
if error:
raise error
return AsyncioRequestsTransportResponse(request, response, self.connection_config.data_block_size)
def send(self, request, **kwargs): # type: ignore
# type: (HttpRequest, Any) -> HttpResponse
"""Send request object according to configuration.
Allowed kwargs are:
- session : will override the driver session and use yours. Should NOT be done unless really required.
- anything else is sent straight to requests.
:param HttpRequest request: The request object to be sent.
"""
self.open()
response = None
error = None # type: Optional[Union[ServiceRequestError, ServiceResponseError]]
if self.config.proxy_policy and 'proxies' not in kwargs:
kwargs['proxies'] = self.config.proxy_policy.proxies
try:
response = self.session.request( # type: ignore
request.method,
request.url,
headers=request.headers,
data=request.data,
files=request.files,
verify=kwargs.get('connection_verify',
self.config.connection.verify),
timeout=kwargs.get('connection_timeout',
self.config.connection.timeout),
cert=kwargs.get('connection_cert',
self.config.connection.cert),
allow_redirects=False,
**kwargs)
except urllib3.exceptions.NewConnectionError as err:
error = ServiceRequestError(err, error=err)
except requests.exceptions.ReadTimeout as err:
error = ServiceResponseError(err, error=err)
except requests.exceptions.ConnectionError as err:
if err.args and isinstance(err.args[0],
urllib3.exceptions.ProtocolError):
error = ServiceResponseError(err, error=err)
else:
error = ServiceRequestError(err, error=err)
except requests.RequestException as err:
error = ServiceRequestError(err, error=err)
if error:
raise error
return RequestsTransportResponse(
request, response, self.config.connection.data_block_size)
async def send(self, request: HttpRequest,
**config: Any) -> Optional[AsyncHttpResponse]:
"""Send the request using this HTTP sender.
Will pre-load the body into memory to be available with a sync method.
pass stream=True to avoid this behavior.
"""
await self.open()
error = None
response = None
config['ssl'] = self._build_ssl_config(**config)
try:
stream_response = config.pop("stream", False)
result = await self.session.request(
request.method,
request.url,
headers=request.headers,
data=self._get_request_data(request),
timeout=config.get('connection_timeout',
self.config.connection.timeout),
allow_redirects=False,
**config)
response = AioHttpTransportResponse(
request, result, self.config.connection.data_block_size)
if not stream_response:
await response.load_body()
except aiohttp.client_exceptions.ClientConnectorError as err:
error = ServiceRequestError(err, error=err)
if error:
raise error
return response
async def test_retries_token_requests():
"""The client should retry token requests"""
message = "can't connect"
transport = Mock(send=Mock(side_effect=ServiceRequestError(message)),
sleep=get_completed_future)
client = AadClient("tenant-id", "client-id", transport=transport)
with pytest.raises(ServiceRequestError, match=message):
await client.obtain_token_by_authorization_code("", "", "")
assert transport.send.call_count > 1
transport.send.reset_mock()
with pytest.raises(ServiceRequestError, match=message):
await client.obtain_token_by_client_certificate(
"", AadClientCertificate(open(PEM_CERT_PATH, "rb").read()))
assert transport.send.call_count > 1
transport.send.reset_mock()
with pytest.raises(ServiceRequestError, match=message):
await client.obtain_token_by_client_secret("", "")
assert transport.send.call_count > 1
transport.send.reset_mock()
with pytest.raises(ServiceRequestError, match=message):
await client.obtain_token_by_jwt_assertion("", "")
assert transport.send.call_count > 1
transport.send.reset_mock()
with pytest.raises(ServiceRequestError, match=message):
await client.obtain_token_by_refresh_token("", "")
assert transport.send.call_count > 1
async def send(self, request: HttpRequest, **config: Any) -> Optional[AsyncHttpResponse]:
"""Send the request using this HTTP sender.
Will pre-load the body into memory to be available with a sync method.
Pass stream=True to avoid this behavior.
:param request: The HttpRequest object
:type request: ~azure.core.pipeline.transport.HttpRequest
:param config: Any keyword arguments
:return: The AsyncHttpResponse
:rtype: ~azure.core.pipeline.transport.AsyncHttpResponse
:keyword bool stream: Defaults to False.
:keyword dict proxies: dict of proxy to used based on protocol. Proxy is a dict (protocol, url)
:keyword str proxy: will define the proxy to use all the time
"""
await self.open()
proxies = config.pop('proxies', None)
if proxies and 'proxy' not in config:
# aiohttp needs a single proxy, so iterating until we found the right protocol
# Sort by longest string first, so "http" is not used for "https" ;-)
for protocol in sorted(proxies.keys(), reverse=True):
if request.url.startswith(protocol):
config['proxy'] = proxies[protocol]
break
error = None # type: Optional[AzureError]
response = None
config['ssl'] = self._build_ssl_config(
cert=config.pop('connection_cert', self.connection_config.cert),
verify=config.pop('connection_verify', self.connection_config.verify)
)
# If we know for sure there is not body, disable "auto content type"
# Otherwise, aiohttp will send "application/octect-stream" even for empty POST request
# and that break services like storage signature
if not request.data and not request.files:
config['skip_auto_headers'] = ['Content-Type']
try:
stream_response = config.pop("stream", False)
result = await self.session.request(
request.method,
request.url,
headers=request.headers,
data=self._get_request_data(request),
timeout=config.pop('connection_timeout', self.connection_config.timeout),
allow_redirects=False,
**config
)
response = AioHttpTransportResponse(request, result, self.connection_config.data_block_size)
if not stream_response:
await response.load_body()
except aiohttp.client_exceptions.ClientConnectorError as err:
error = ServiceRequestError(err, error=err)
except asyncio.TimeoutError as err:
error = ServiceResponseError(err, error=err)
if error:
raise error
return response
async def send(self, request: HttpRequest,
**kwargs: Any) -> AsyncHttpResponse: # type: ignore
"""Send the request using this HTTP sender.
"""
self.open()
loop = kwargs.get("loop", _get_running_loop())
response = None
error = None # type: Optional[Union[ServiceRequestError, ServiceResponseError]]
if self.config.proxy_policy and 'proxies' not in kwargs:
kwargs['proxies'] = self.config.proxy_policy.proxies
try:
response = await loop.run_in_executor(
None,
functools.partial(
self.session.request, # type: ignore
request.method,
request.url,
headers=request.headers,
data=request.data,
files=request.files,
verify=kwargs.get('connection_verify',
self.config.connection.verify),
timeout=kwargs.get('connection_timeout',
self.config.connection.timeout),
cert=kwargs.get('connection_cert',
self.config.connection.cert),
allow_redirects=False,
**kwargs))
except urllib3.exceptions.NewConnectionError as err:
error = ServiceRequestError(err, error=err)
except requests.exceptions.ReadTimeout as err:
error = ServiceResponseError(err, error=err)
except requests.exceptions.ConnectionError as err:
if err.args and isinstance(err.args[0],
urllib3.exceptions.ProtocolError):
error = ServiceResponseError(err, error=err)
else:
error = ServiceRequestError(err, error=err)
except requests.RequestException as err:
error = ServiceRequestError(err, error=err)
if error:
raise error
return AsyncioRequestsTransportResponse(
request, response, self.config.connection.data_block_size)
def send(self, request, **kwargs): # type: ignore
# type: (HttpRequest, Any) -> HttpResponse
"""Send request object according to configuration.
:param request: The request object to be sent.
:type request: ~azure.core.pipeline.transport.HttpRequest
:return: An HTTPResponse object.
:rtype: ~azure.core.pipeline.transport.HttpResponse
**Keyword arguments:**
*session* - will override the driver session and use yours. Should NOT be done unless really required.
Anything else is sent straight to requests.
*proxies* - will define the proxy to use. Proxy is a dict (protocol, url)
"""
self.open()
response = None
error = None # type: Optional[Union[ServiceRequestError, ServiceResponseError]]
try:
response = self.session.request( # type: ignore
request.method,
request.url,
headers=request.headers,
data=request.data,
files=request.files,
verify=kwargs.pop('connection_verify', self.connection_config.verify),
timeout=kwargs.pop('connection_timeout', self.connection_config.timeout),
cert=kwargs.pop('connection_cert', self.connection_config.cert),
allow_redirects=False,
**kwargs)
except urllib3.exceptions.NewConnectionError as err:
error = ServiceRequestError(err, error=err)
except requests.exceptions.ReadTimeout as err:
error = ServiceResponseError(err, error=err)
except requests.exceptions.ConnectionError as err:
if err.args and isinstance(err.args[0], urllib3.exceptions.ProtocolError):
error = ServiceResponseError(err, error=err)
else:
error = ServiceRequestError(err, error=err)
except requests.RequestException as err:
error = ServiceRequestError(err, error=err)
if error:
raise error
return RequestsTransportResponse(request, response, self.connection_config.data_block_size)
def test_get_state_store_status_not_responding(cosmos_client_mock, get_store_key_mock) -> None:
get_store_key_mock.return_value = None
cosmos_client_mock.return_value = None
cosmos_client_mock.side_effect = ServiceRequestError(message="some message")
status, message = health_checker.create_state_store_status()
assert status == StatusEnum.not_ok
assert message == strings.STATE_STORE_ENDPOINT_NOT_RESPONDING
async def send(self, request: HttpRequest, **config: Any) -> Optional[AsyncHttpResponse]:
"""Send the request using this HTTP sender.
Will pre-load the body into memory to be available with a sync method.
Pass stream=True to avoid this behavior.
:param request: The HttpRequest object
:type request: ~azure.core.pipeline.transport.HttpRequest
:param config: Any keyword arguments
:return: The AsyncHttpResponse
:rtype: ~azure.core.pipeline.transport.AsyncHttpResponse
**Keyword argument:**
*stream (bool)* - Defaults to False.
*proxies* - dict of proxy to used based on protocol. Proxy is a dict (protocol, url)
*proxy* - will define the proxy to use all the time
"""
await self.open()
proxies = config.pop('proxies', None)
if proxies and 'proxy' not in config:
# aiohttp needs a single proxy, so iterating until we found the right protocol
# Sort by longest string first, so "http" is not used for "https" ;-)
for protocol in sorted(proxies.keys(), reverse=True):
if request.url.startswith(protocol):
config['proxy'] = proxies[protocol]
break
error = None
response = None
config['ssl'] = self._build_ssl_config(
cert=config.pop('connection_cert', self.connection_config.cert),
verify=config.pop('connection_verify', self.connection_config.verify)
)
try:
stream_response = config.pop("stream", False)
result = await self.session.request(
request.method,
request.url,
headers=request.headers,
data=self._get_request_data(request),
timeout=config.pop('connection_timeout', self.connection_config.timeout),
allow_redirects=False,
**config
)
response = AioHttpTransportResponse(request, result, self.connection_config.data_block_size)
if not stream_response:
await response.load_body()
except aiohttp.client_exceptions.ClientConnectorError as err:
error = ServiceRequestError(err, error=err)
if error:
raise error
return response
def _enforce_https(request):
# move 'enforce_https' from options to context so it persists
# across retries but isn't passed to a transport implementation
option = request.context.options.pop("enforce_https", None)
# True is the default setting; we needn't preserve an explicit opt in to the default behavior
if option is False:
request.context["enforce_https"] = option
enforce_https = request.context.get("enforce_https", True)
if enforce_https and not request.http_request.url.lower().startswith("https"):
raise ServiceRequestError(
"Bearer token authentication is not permitted for non-TLS protected (non-https) URLs."
)
def test_retries_requests():
"""The client should retry token requests"""
message = "can't connect"
transport = mock.Mock(send=mock.Mock(side_effect=ServiceRequestError(message)))
client = MsalClient(transport=transport)
with pytest.raises(ServiceRequestError, match=message):
client.post("https://localhost")
assert transport.send.call_count > 1
transport.send.reset_mock()
with pytest.raises(ServiceRequestError, match=message):
client.get("https://localhost")
assert transport.send.call_count > 1
def test_managed_identity_client_retry():
"""ManagedIdentityClient should retry token requests"""
message = "can't connect"
transport = mock.Mock(send=mock.Mock(side_effect=ServiceRequestError(message)))
request_factory = mock.Mock()
client = ManagedIdentityClient(request_factory, transport=transport)
for method in ("GET", "POST"):
request_factory.return_value = HttpRequest(method, "https://localhost")
with pytest.raises(ServiceRequestError, match=message):
client.request_token("scope")
assert transport.send.call_count > 1
transport.send.reset_mock()
def _read_raw_stream(response, chunk_size=1):
# Special case for urllib3.
if hasattr(response.raw, 'stream'):
try:
for chunk in response.raw.stream(chunk_size, decode_content=False):
yield chunk
except ProtocolError as e:
raise ServiceResponseError(e, error=e)
except CoreDecodeError as e:
raise DecodeError(e, error=e)
except ReadTimeoutError as e:
raise ServiceRequestError(e, error=e)
else:
# Standard file-like object.
while True:
chunk = response.raw.read(chunk_size)
if not chunk:
break
yield chunk
# following behavior from requests iter_content, we set content consumed to True
# https://github.com/psf/requests/blob/master/requests/models.py#L774
response._content_consumed = True # pylint: disable=protected-access
def send(self, request, **kwargs): # type: ignore
# type: (HttpRequest, Any) -> HttpResponse
"""Send request object according to configuration.
:param request: The request object to be sent.
:type request: ~azure.core.pipeline.transport.HttpRequest
:return: An HTTPResponse object.
:rtype: ~azure.core.pipeline.transport.HttpResponse
:keyword requests.Session session: will override the driver session and use yours.
Should NOT be done unless really required. Anything else is sent straight to requests.
:keyword dict proxies: will define the proxy to use. Proxy is a dict (protocol, url)
"""
self.open()
response = None
error = None # type: Optional[Union[ServiceRequestError, ServiceResponseError]]
try:
connection_timeout = kwargs.pop('connection_timeout',
self.connection_config.timeout)
if isinstance(connection_timeout, tuple):
if 'read_timeout' in kwargs:
raise ValueError(
'Cannot set tuple connection_timeout and read_timeout together'
)
_LOGGER.warning("Tuple timeout setting is deprecated")
timeout = connection_timeout
else:
read_timeout = kwargs.pop('read_timeout',
self.connection_config.read_timeout)
timeout = (connection_timeout, read_timeout)
response = self.session.request( # type: ignore
request.method,
request.url,
headers=request.headers,
data=request.data,
files=request.files,
verify=kwargs.pop('connection_verify',
self.connection_config.verify),
timeout=timeout,
cert=kwargs.pop('connection_cert',
self.connection_config.cert),
allow_redirects=False,
**kwargs)
except (urllib3.exceptions.NewConnectionError,
urllib3.exceptions.ConnectTimeoutError) as err:
error = ServiceRequestError(err, error=err)
except requests.exceptions.ReadTimeout as err:
error = ServiceResponseError(err, error=err)
except requests.exceptions.ConnectionError as err:
if err.args and isinstance(err.args[0],
urllib3.exceptions.ProtocolError):
error = ServiceResponseError(err, error=err)
else:
error = ServiceRequestError(err, error=err)
except requests.RequestException as err:
error = ServiceRequestError(err, error=err)
if error:
raise error
return RequestsTransportResponse(
request, response, self.connection_config.data_block_size)
def _enforce_tls(request):
# type: (PipelineRequest) -> None
if not request.http_request.url.lower().startswith("https"):
raise ServiceRequestError(
"Bearer token authentication is not permitted for non-TLS protected (non-https) URLs."
)
async def send(self, request: HttpRequest,
**kwargs: Any) -> AsyncHttpResponse: # type: ignore
"""Send the request using this HTTP sender.
:param request: The HttpRequest
:type request: ~azure.core.pipeline.transport.HttpRequest
:return: The AsyncHttpResponse
:rtype: ~azure.core.pipeline.transport.AsyncHttpResponse
:keyword requests.Session session: will override the driver session and use yours.
Should NOT be done unless really required. Anything else is sent straight to requests.
:keyword dict proxies: will define the proxy to use. Proxy is a dict (protocol, url)
"""
self.open()
trio_limiter = kwargs.get("trio_limiter", None)
response = None
error = None # type: Optional[Union[ServiceRequestError, ServiceResponseError]]
try:
try:
response = await trio.to_thread.run_sync(
functools.partial(
self.session.request, # type: ignore
request.method,
request.url,
headers=request.headers,
data=request.data,
files=request.files,
verify=kwargs.pop('connection_verify',
self.connection_config.verify),
timeout=kwargs.pop('connection_timeout',
self.connection_config.timeout),
cert=kwargs.pop('connection_cert',
self.connection_config.cert),
allow_redirects=False,
**kwargs),
limiter=trio_limiter)
except AttributeError: # trio < 0.12.1
response = await trio.run_sync_in_worker_thread( # pylint: disable=no-member
functools.partial(
self.session.request, # type: ignore
request.method,
request.url,
headers=request.headers,
data=request.data,
files=request.files,
verify=kwargs.pop('connection_verify',
self.connection_config.verify),
timeout=kwargs.pop('connection_timeout',
self.connection_config.timeout),
cert=kwargs.pop('connection_cert',
self.connection_config.cert),
allow_redirects=False,
**kwargs),
limiter=trio_limiter)
except urllib3.exceptions.NewConnectionError as err:
error = ServiceRequestError(err, error=err)
except requests.exceptions.ReadTimeout as err:
error = ServiceResponseError(err, error=err)
except requests.exceptions.ConnectionError as err:
if err.args and isinstance(err.args[0],
urllib3.exceptions.ProtocolError):
error = ServiceResponseError(err, error=err)
else:
error = ServiceRequestError(err, error=err)
except requests.RequestException as err:
error = ServiceRequestError(err, error=err)
if error:
raise error
return TrioRequestsTransportResponse(
request, response, self.connection_config.data_block_size)
async def send(self, request: HttpRequest,
**kwargs: Any) -> AsyncHttpResponse: # type: ignore
"""Send the request using this HTTP sender.
:param request: The HttpRequest
:type request: ~azure.core.pipeline.transport.HttpRequest
:param kwargs: Any keyword arguments
:return: The AsyncHttpResponse
:rtype: ~azure.core.pipeline.transport.AsyncHttpResponse
**Keyword arguments:**
*session* - will override the driver session and use yours. Should NOT be done unless really required.
Anything else is sent straight to requests.
*proxies* - will define the proxy to use. Proxy is a dict (protocol, url)
"""
self.open()
loop = kwargs.get("loop", _get_running_loop())
response = None
error = None # type: Optional[Union[ServiceRequestError, ServiceResponseError]]
if hasattr(request.data, '__aiter__'):
# Need to consume that async generator, since requests can't do anything with it
# That's not ideal, but a list is our only choice. Memory not optimal here,
# but providing an async generator to a requests based transport is not optimal too
new_data = []
async for part in request.data:
new_data.append(part)
data_to_send = iter(new_data)
else:
data_to_send = request.data
try:
response = await loop.run_in_executor(
None,
functools.partial(
self.session.request, # type: ignore
request.method,
request.url,
headers=request.headers,
data=data_to_send,
files=request.files,
verify=kwargs.pop('connection_verify',
self.connection_config.verify),
timeout=kwargs.pop('connection_timeout',
self.connection_config.timeout),
cert=kwargs.pop('connection_cert',
self.connection_config.cert),
allow_redirects=False,
**kwargs))
except urllib3.exceptions.NewConnectionError as err:
error = ServiceRequestError(err, error=err)
except requests.exceptions.ReadTimeout as err:
error = ServiceResponseError(err, error=err)
except requests.exceptions.ConnectionError as err:
if err.args and isinstance(err.args[0],
urllib3.exceptions.ProtocolError):
error = ServiceResponseError(err, error=err)
else:
error = ServiceRequestError(err, error=err)
except requests.RequestException as err:
error = ServiceRequestError(err, error=err)
if error:
raise error
return AsyncioRequestsTransportResponse(
request, response, self.connection_config.data_block_size)
async def send(self, request, **kwargs: Any): # pylint:disable=invalid-overridden-method
"""Send the request using this HTTP sender.
:param request: The HttpRequest
:type request: ~azure.core.pipeline.transport.HttpRequest
:return: The AsyncHttpResponse
:rtype: ~azure.core.pipeline.transport.AsyncHttpResponse
:keyword requests.Session session: will override the driver session and use yours.
Should NOT be done unless really required. Anything else is sent straight to requests.
:keyword dict proxies: will define the proxy to use. Proxy is a dict (protocol, url)
"""
self.open()
trio_limiter = kwargs.get("trio_limiter", None)
response = None
error = None # type: Optional[AzureErrorUnion]
data_to_send = await self._retrieve_request_data(request)
try:
try:
response = await trio.to_thread.run_sync(functools.partial(
self.session.request,
request.method,
request.url,
headers=request.headers,
data=data_to_send,
files=request.files,
verify=kwargs.pop('connection_verify',
self.connection_config.verify),
timeout=kwargs.pop('connection_timeout',
self.connection_config.timeout),
cert=kwargs.pop('connection_cert',
self.connection_config.cert),
allow_redirects=False,
**kwargs),
limiter=trio_limiter)
except AttributeError: # trio < 0.12.1
response = await trio.run_sync_in_worker_thread( # pylint: disable=no-member
functools.partial(
self.session.request,
request.method,
request.url,
headers=request.headers,
data=request.data,
files=request.files,
verify=kwargs.pop('connection_verify',
self.connection_config.verify),
timeout=kwargs.pop('connection_timeout',
self.connection_config.timeout),
cert=kwargs.pop('connection_cert',
self.connection_config.cert),
allow_redirects=False,
**kwargs),
limiter=trio_limiter)
response.raw.enforce_content_length = True
except urllib3.exceptions.NewConnectionError as err:
error = ServiceRequestError(err, error=err)
except requests.exceptions.ReadTimeout as err:
error = ServiceResponseError(err, error=err)
except requests.exceptions.ConnectionError as err:
if err.args and isinstance(err.args[0],
urllib3.exceptions.ProtocolError):
error = ServiceResponseError(err, error=err)
else:
error = ServiceRequestError(err, error=err)
except requests.exceptions.ChunkedEncodingError as err:
msg = err.__str__()
if 'IncompleteRead' in msg:
_LOGGER.warning("Incomplete download: %s", err)
error = IncompleteReadError(err, error=err)
else:
_LOGGER.warning("Unable to stream download: %s", err)
error = HttpResponseError(err, error=err)
except requests.RequestException as err:
error = ServiceRequestError(err, error=err)
if error:
raise error
if _is_rest(request):
from azure.core.rest._requests_trio import RestTrioRequestsTransportResponse
retval = RestTrioRequestsTransportResponse(
request=request,
internal_response=response,
block_size=self.connection_config.data_block_size,
)
if not kwargs.get("stream"):
await _handle_no_stream_rest_response(retval)
return retval
return TrioRequestsTransportResponse(
request, response, self.connection_config.data_block_size)
def send(self, request, **kwargs): # type: ignore
"""Send request object according to configuration.
:param request: The request object to be sent.
:type request: ~azure.core.pipeline.transport.HttpRequest
:return: An HTTPResponse object.
:rtype: ~azure.core.pipeline.transport.HttpResponse
:keyword requests.Session session: will override the driver session and use yours.
Should NOT be done unless really required. Anything else is sent straight to requests.
:keyword dict proxies: will define the proxy to use. Proxy is a dict (protocol, url)
"""
self.open()
response = None
error = None # type: Optional[AzureErrorUnion]
try:
connection_timeout = kwargs.pop('connection_timeout', self.connection_config.timeout)
if isinstance(connection_timeout, tuple):
if 'read_timeout' in kwargs:
raise ValueError('Cannot set tuple connection_timeout and read_timeout together')
_LOGGER.warning("Tuple timeout setting is deprecated")
timeout = connection_timeout
else:
read_timeout = kwargs.pop('read_timeout', self.connection_config.read_timeout)
timeout = (connection_timeout, read_timeout)
response = self.session.request( # type: ignore
request.method,
request.url,
headers=request.headers,
data=request.data,
files=request.files,
verify=kwargs.pop('connection_verify', self.connection_config.verify),
timeout=timeout,
cert=kwargs.pop('connection_cert', self.connection_config.cert),
allow_redirects=False,
**kwargs)
response.raw.enforce_content_length = True
except (urllib3.exceptions.NewConnectionError, urllib3.exceptions.ConnectTimeoutError) as err:
error = ServiceRequestError(err, error=err)
except requests.exceptions.ReadTimeout as err:
error = ServiceResponseError(err, error=err)
except requests.exceptions.ConnectionError as err:
if err.args and isinstance(err.args[0], urllib3.exceptions.ProtocolError):
error = ServiceResponseError(err, error=err)
else:
error = ServiceRequestError(err, error=err)
except requests.exceptions.ChunkedEncodingError as err:
msg = err.__str__()
if 'IncompleteRead' in msg:
_LOGGER.warning("Incomplete download: %s", err)
error = IncompleteReadError(err, error=err)
else:
_LOGGER.warning("Unable to stream download: %s", err)
error = HttpResponseError(err, error=err)
except requests.RequestException as err:
error = ServiceRequestError(err, error=err)
if error:
raise error
if _is_rest(request):
from azure.core.rest._requests_basic import RestRequestsTransportResponse
retval = RestRequestsTransportResponse(
request=request,
internal_response=response,
block_size=self.connection_config.data_block_size
)
if not kwargs.get('stream'):
_handle_non_stream_rest_response(retval)
return retval
return RequestsTransportResponse(request, response, self.connection_config.data_block_size)
def test_service_request_error(self):
azure_error = ServiceRequestError("test_error_msg")
cli_error = helpers.map_azure_error_to_cli_error(azure_error)
mock_error = ClientRequestError("test_error_msg")
self.check_error_equality(cli_error, mock_error)
