remove MAX_DURATION

unit/api/base_resource.py

@@ -5,12 +5,32 @@
 from unit.models.codecs import UnitEncoder
 
 retries = 0
-MAX_DURATION = 300
 
 
-def fatal_code(e):
+def backoff_handler(e):
     code = e.status_code
-    return 500 <= code < 600 or code == 408 or code == 429
+    status = is_timeout(code) or is_rete_limit(code) or is_server_error(code)
+    return status and idempotency_key_is_not_present(e)
+
+
+def is_timeout(code):
+    return code == 408
+
+
+def is_rete_limit(code):
+    return code == 429
+
+
+def is_server_error(code):
+    return 500 <= code <= 599
+
+
+def idempotency_key_is_not_present(e):
+    body = json.loads(e.request.body)
+    if body is None:
+        return True
+
+    return body["data"]["attributes"].get("idempotencyKey") is None
 
 
 class BaseResource(object):
@@ -27,44 +47,39 @@ def __init__(self, api_url, token, retries_amount):
         retries = retries_amount
 
     @backoff.on_predicate(backoff.expo,
-                          fatal_code,
+                          backoff_handler,
                           max_tries=retries,
-                          max_time=MAX_DURATION,
                           jitter=backoff.random_jitter)
     def get(self, resource: str, params: Dict = None, headers: Optional[Dict[str, str]] = None):
         return requests.get(f"{self.api_url}/{resource}", params=params, headers=self.__merge_headers(headers))
 
     @backoff.on_predicate(backoff.expo,
-                          fatal_code,
+                          backoff_handler,
                           max_tries=retries,
-                          max_time=MAX_DURATION,
                           jitter=backoff.random_jitter)
     def post(self, resource: str, data: Optional[Dict] = None, headers: Optional[Dict[str, str]] = None):
         data = json.dumps(data, cls=UnitEncoder) if data is not None else None
         return requests.post(f"{self.api_url}/{resource}", data=data, headers=self.__merge_headers(headers))
 
     @backoff.on_predicate(backoff.expo,
-                          fatal_code,
+                          backoff_handler,
                           max_tries=retries,
-                          max_time="",
                           jitter=backoff.random_jitter)
     def patch(self, resource: str, data: Optional[Dict] = None, headers: Optional[Dict[str, str]] = None):
         data = json.dumps(data, cls=UnitEncoder) if data is not None else None
         return requests.patch(f"{self.api_url}/{resource}", data=data, headers=self.__merge_headers(headers))
 
     @backoff.on_predicate(backoff.expo,
-                          fatal_code,
+                          backoff_handler,
                           max_tries=retries,
-                          max_time=MAX_DURATION,
                           jitter=backoff.random_jitter)
     def delete(self, resource: str, data: Dict = None, headers: Optional[Dict[str, str]] = None):
         data = json.dumps(data, cls=UnitEncoder) if data is not None else None
         return requests.delete(f"{self.api_url}/{resource}", data=data, headers=self.__merge_headers(headers))
 
     @backoff.on_predicate(backoff.expo,
-                          fatal_code,
+                          backoff_handler,
                           max_tries=retries,
-                          max_time=MAX_DURATION,
                           jitter=backoff.random_jitter)
     def put(self, resource: str, data: Optional[Dict] = None, headers: Optional[Dict[str, str]] = None):
         return requests.put(f"{self.api_url}/{resource}", data=data, headers=self.__merge_headers(headers))