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)