fix: Renew connection when Connection reset error occurs (#771)

Closes: SDK-2732
Fixes: #756, fixes: #757, fixes: #763, fixes: #765, fixes: #766, fixes: #770

Author: lukaszsocha2

boxsdk/session/box_request.py

@@ -20,6 +20,7 @@ class BoxRequest:
     headers: Optional[dict] = attr.ib(default=attr.Factory(dict))
     auto_session_renewal: Optional[bool] = attr.ib(default=True)
     expect_json_response: Optional[bool] = attr.ib(default=True)
+    access_token: Optional[str] = attr.ib(default=None)
 
     def __repr__(self) -> str:
         return f'<BoxRequest for {self.method} {self.url} with headers {sanitize_dictionary(self.headers)}'

boxsdk/session/session.py

@@ -4,8 +4,9 @@
 from functools import partial
 from logging import getLogger
 from numbers import Number
-from typing import TYPE_CHECKING, Optional, Any, Type, Callable
+from typing import TYPE_CHECKING, Optional, Any, Type, Callable, Set
 
+from requests.exceptions import RequestException, SSLError
 from boxsdk.exception import BoxException
 from .box_request import BoxRequest as _BoxRequest
 from .box_response import BoxResponse as _BoxResponse
@@ -301,9 +302,9 @@ def _prepare_and_send_request(
         :param headers:
             Headers to include with the request.
         :param auto_session_renewal:
-            Whether or not to automatically renew the session if the request fails due to an expired access token.
+            Whether to automatically renew the session if the request fails due to an expired access token.
         :param expect_json_response:
-            Whether or not the response content should be json.
+            Whether the response content should be json.
         """
         files = kwargs.get('files')
         kwargs['file_stream_positions'] = None
@@ -322,27 +323,47 @@ def _prepare_and_send_request(
         )
 
         skip_retry_codes = kwargs.pop('skip_retry_codes', set())
-        network_response = self._send_request(request, **kwargs)
+
+        session_renewal_needed = False
+        try:
+            network_response = self._send_request(request, **kwargs)
+            session_renewal_needed = network_response.status_code == 401
+        except SSLError as ssl_exc:
+            if 'EOF occurred in violation of protocol' in str(ssl_exc):
+                session_renewal_needed = True
+            network_response = None
+        except RequestException:
+            network_response = None
 
         while True:
-            retry = self._get_retry_request_callable(network_response, attempt_number, request, **kwargs)
+            retry = self._get_retry_request_callable(
+                network_response, attempt_number, request, skip_retry_codes, session_renewal_needed, **kwargs
+            )
 
-            if retry is None or attempt_number >= API.MAX_RETRY_ATTEMPTS or network_response.status_code in skip_retry_codes:
+            if retry is None or attempt_number >= API.MAX_RETRY_ATTEMPTS:
                 break
 
             attempt_number += 1
             self._logger.debug('Retrying request')
-            network_response = retry(request, **kwargs)
+
+            try:
+                network_response = retry(request, **kwargs)
+            except RequestException:
+                if attempt_number >= API.MAX_RETRY_ATTEMPTS:
+                    raise
+                network_response = None
 
         self._raise_on_unsuccessful_request(network_response, request)
 
         return network_response
 
     def _get_retry_request_callable(
             self,
-            network_response: 'NetworkResponse',
+            network_response: Optional['NetworkResponse'],
             attempt_number: int,
             request: '_BoxRequest',
+            skip_retry_codes: Set[int],
+            session_renewal_needed: bool = False,
             **kwargs: Any
     ) -> Optional[Callable]:
         """
@@ -364,6 +385,12 @@ def _get_retry_request_callable(
             Callable that, when called, will retry the request. Takes the same parameters as :meth:`_send_request`.
         """
         # pylint:disable=unused-argument
+        if network_response is None:
+            return partial(
+                self._network_layer.retry_after,
+                self.get_retry_after_time(attempt_number, None),
+                self._send_request,
+            )
         data = kwargs.get('data', {})
         grant_type = None
         try:
@@ -372,7 +399,7 @@ def _get_retry_request_callable(
         except TypeError:
             pass
         code = network_response.status_code
-        if (code in (202, 429) or code >= 500) and grant_type != self._JWT_GRANT_TYPE:
+        if (code in (202, 429) or code >= 500) and code not in skip_retry_codes and grant_type != self._JWT_GRANT_TYPE:
             return partial(
                 self._network_layer.retry_after,
                 self.get_retry_after_time(attempt_number, network_response.headers.get('Retry-After', None)),
@@ -431,12 +458,13 @@ def _send_request(self, request: '_BoxRequest', **kwargs: Any) -> 'NetworkRespon
             request_kwargs['data'] = multipart_stream
             del request_kwargs['files']
             request.headers['Content-Type'] = multipart_stream.content_type
+        request.access_token = request_kwargs.pop('access_token', None)
 
         # send the request
         network_response = self._network_layer.request(
             request.method,
             request.url,
-            access_token=request_kwargs.pop('access_token', None),
+            access_token=request.access_token,
             headers=request.headers,
             log_response_content=request.expect_json_response,
             **request_kwargs
@@ -477,9 +505,11 @@ def _renew_session(self, access_token_used: Optional[str]) -> str:
 
     def _get_retry_request_callable(
             self,
-            network_response: 'NetworkResponse',
+            network_response: Optional['NetworkResponse'],
             attempt_number: int,
             request: '_BoxRequest',
+            skip_retry_codes: Set[int],
+            session_renewal_needed: bool = False,
             **kwargs: Any
     ) -> Callable:
         """
@@ -498,15 +528,16 @@ def _get_retry_request_callable(
         :return:
             Callable that, when called, will retry the request. Takes the same parameters as :meth:`_send_request`.
         """
-        code = network_response.status_code
-        if code == 401 and request.auto_session_renewal:
-            self._renew_session(network_response.access_token_used)
+        if request.auto_session_renewal and session_renewal_needed:
+            self._renew_session(request.access_token)
             request.auto_session_renewal = False
             return self._send_request
         return super()._get_retry_request_callable(
             network_response,
             attempt_number,
             request,
+            skip_retry_codes,
+            session_renewal_needed,
             **kwargs
         )
 

test/unit/session/test_session.py

@@ -2,6 +2,7 @@
 from io import IOBase
 from numbers import Number
 from unittest.mock import MagicMock, Mock, PropertyMock, call, patch, ANY
+from requests.exceptions import RequestException, SSLError
 
 import pytest
 
@@ -221,6 +222,42 @@ def test_box_session_raises_for_failed_response(box_session, mock_network_layer,
         box_session.get(url=test_url)
 
 
+def test_box_session_retries_requests_library_exceptions(box_session, mock_network_layer, generic_successful_request_response, test_url):
+    mock_network_layer.request.side_effect = [RequestException(), generic_successful_request_response]
+    mock_network_layer.retry_after.side_effect = lambda delay, request, *args, **kwargs: request(*args, **kwargs)
+
+    box_response = box_session.get(url=test_url)
+    assert box_response.status_code == 200
+
+
+def test_box_session_raises_requests_library_exception_when_max_retries_limit_is_reached(box_session, mock_network_layer, test_url):
+    mock_network_layer.request.side_effect = [RequestException()] * (API.MAX_RETRY_ATTEMPTS + 1)
+    mock_network_layer.retry_after.side_effect = lambda delay, request, *args, **kwargs: request(*args, **kwargs)
+
+    with pytest.raises(RequestException):
+        box_session.get(url=test_url)
+
+
+def test_box_session_raises_requests_s(box_session, mock_oauth, mock_network_layer, generic_successful_request_response, test_url):
+    def refresh(access_token_used):
+        assert access_token_used == mock_oauth.access_token
+        mock_oauth.access_token = 'fake_new_access_token'
+        return (mock_oauth.access_token, None)
+
+    mock_network_layer.request.side_effect = [
+        SSLError("SSLError(SSLEOFError(8, 'EOF occurred in violation of protocol (_ssl.c:2396)')))"),
+        generic_successful_request_response
+    ]
+    mock_network_layer.retry_after.side_effect = lambda delay, request, *args, **kwargs: request(*args, **kwargs)
+    mock_oauth.refresh.side_effect = refresh
+
+    box_session.get(url=test_url)
+
+    assert mock_network_layer.request.call_count == 2
+    assert mock_network_layer.request.mock_calls[0][2]['access_token'] == 'fake_access_token'
+    assert mock_network_layer.request.mock_calls[1][2]['access_token'] == 'fake_new_access_token'
+
+
 def test_box_session_raises_for_failed_response_with_error_and_error_description(box_session, mock_network_layer, bad_network_response_400, test_url):
     mock_network_layer.request.side_effect = [bad_network_response_400]
     try: