Merge pull request #13 from bgreen-litl/giveup_kwarg

Add giveup kwarg for exception inspection

Author: bgreen-litl

README.rst

@@ -46,6 +46,23 @@ you want the same backoff behavior for more than one exception type::
     def get_url(url):
         return requests.get(url)
 
+In some cases the raised exception instance itself may need to be
+inspected in order to determine if it is a retryable condition. The
+``giveup`` keyword arg can be used to specify a function which accepts
+the exception and returns a truthy value if the exception should not
+be retried::
+
+    def fatal_code(e):
+        return 400 <= e.response.status_code < 500
+
+    @backoff.on_exception(backoff.expo,
+                          requests.exceptions.RequestException,
+                          max_tries=8,
+                          giveup=fatal_code)
+    def get_url(url):
+        return requests.get(url)
+
+
 @backoff.on_predicate
 ---------------------
 

backoff.py

@@ -165,7 +165,7 @@ def retry(*args, **kwargs):
                 tries += 1
                 ret = target(*args, **kwargs)
                 if predicate(ret):
-                    if max_tries is not None and tries == max_tries:
+                    if tries == max_tries:
                         for hdlr in giveup_hdlrs:
                             hdlr({'target': target,
                                   'args': args,
@@ -216,6 +216,7 @@ def on_exception(wait_gen,
                  exception,
                  max_tries=None,
                  jitter=full_jitter,
+                 giveup=lambda e: False,
                  on_success=None,
                  on_backoff=None,
                  on_giveup=None,
@@ -237,6 +238,9 @@ def on_exception(wait_gen,
             concurrent clients. Wait times are jittered by default
             using the full_jitter function. Jittering may be disabled
             altogether by passing jitter=None.
+        giveup: Function accepting an exception instance and
+            returning whether or not to give up. Optional. The default
+            is to always continue.
         on_success: Callable (or iterable of callables) with a unary
             signature to be called in the event of success. The
             parameter is a dict containing details about the invocation.
@@ -265,8 +269,9 @@ def retry(*args, **kwargs):
                 try:
                     tries += 1
                     ret = target(*args, **kwargs)
-                except exception:
-                    if max_tries is not None and tries == max_tries:
+                except exception as e:
+                    if giveup(e) or tries == max_tries:
+
                         for hdlr in giveup_hdlrs:
                             hdlr({'target': target,
                                   'args': args,

backoff_tests.py

@@ -316,6 +316,26 @@ def exceptor(*args, **kwargs):
                        'tries': 3}
 
 
+def test_on_exception_giveup_predicate(monkeypatch):
+    monkeypatch.setattr('time.sleep', lambda x: None)
+
+    def on_baz(e):
+        return str(e) == "baz"
+
+    vals = ["baz", "bar", "foo"]
+
+    @backoff.on_exception(backoff.constant,
+                          ValueError,
+                          giveup=on_baz)
+    def foo_bar_baz():
+        raise ValueError(vals.pop())
+
+    with pytest.raises(ValueError):
+        foo_bar_baz()
+
+    assert not vals
+
+
 def test_on_predicate_success():
     log, log_success, log_backoff, log_giveup = _log_hdlrs()