#example 7
def retry_if_io_error(exception):"""Return True if we should retry (in this case when it's an IOError), False otherwise"""return isinstance(exception, IOError)@retry(retry_on_exception=retry_if_io_error)
def might_io_error():print "IO异常则重试，并且将其它异常抛出"@retry(retry_on_exception=retry_if_io_error, wrap_exception=True)
def only_raise_retry_error_when_not_io_error():print "IO异常则重试，并且将其它异常用RetryError对象包裹"

#exampe 8，根据返回结果判断是否重试
def retry_if_result_none(result):"""Return True if we should retry (in this case when result is None), False otherwise"""return result is None@retry(retry_on_result=retry_if_result_none)
def might_return_none():print "若返回结果为None则重试"

 1 #装饰器模式,对需要重试的函数,利用retry注解返回
 2 def retry(*dargs, **dkw):
 3     """
 4     Decorator function that instantiates the Retrying object
 5     @param *dargs: positional arguments passed to Retrying object
 6     @param **dkw: keyword arguments passed to the Retrying object
 7     """
 8     # support both @retry and @retry() as valid syntax
 9     #当用法为@retry不带括号时走这条路径,dargs[0]为retry注解的函数,返回函数对象wrapped_f
10     if len(dargs) == 1 and callable(dargs[0]):
11         def wrap_simple(f):
12
13             @six.wraps(f)#注解用于将函数f的签名复制到新函数wrapped_f
14             def wrapped_f(*args, **kw):
15                 return Retrying().call(f, *args, **kw)
16
17             return wrapped_f
18
19         return wrap_simple(dargs[0])
20
21     else:#当用法为@retry()带括号时走这条路径，返回函数对象wrapped_f
22         def wrap(f):
23
24             @six.wraps(f)#注解用于将函数f的签名复制到新函数wrapped_f
25             def wrapped_f(*args, **kw):
26                 return Retrying(*dargs, **dkw).call(f, *args, **kw)
27
28             return wrapped_f
29
30         return wrap

never_give_up_never_surrender = retry(never_give_up_never_surrender)

stop_after_7_attempts = retry(stop_max_attempt_number)(stop_after_7_attempts)

 1 def call(self, fn, *args, **kwargs):
 2         start_time = int(round(time.time() * 1000))
 3         attempt_number = 1
 4         while True:
 5             #_before_attempts为@retry传进来的before_attempts，在每次调用函数前执行一些操作
 6             if self._before_attempts:
 7                 self._before_attempts(attempt_number)
 8
 9             try:#Attempt将函数执行结果或者异常信息以及执行次数作为内部状态,用True或False标记是内部存的值正常执行结果还是异常
10                 attempt = Attempt(fn(*args, **kwargs), attempt_number, False)
11             except:
12                 tb = sys.exc_info()#获取异常堆栈信息，sys.exc_info()返回type(异常类型), value(异常说明), traceback(traceback对象，包含更丰富的信息)
13                 attempt = Attempt(tb, attempt_number, True)
14
15             if not self.should_reject(attempt):#根据本次执行结果或异常类型判断是否应该停止
16                 return attempt.get(self._wrap_exception)
17
18             if self._after_attempts:#_after_attempts为@retry传进来的after_attempts，在每次调用函数后执行一些操作
19                 self._after_attempts(attempt_number)
20
21             delay_since_first_attempt_ms = int(round(time.time() * 1000)) - start_time
22             if self.stop(attempt_number, delay_since_first_attempt_ms):#根据重试次数和延迟判断是否应该停止
23                 if not self._wrap_exception and attempt.has_exception:
24                     # get() on an attempt with an exception should cause it to be raised, but raise just in case
25                     raise attempt.get()
26                 else:
27                     raise RetryError(attempt)
28             else:#不停止则等待一定时间，延迟时间根据wait函数返回值和_wait_jitter_max计算
29                 sleep = self.wait(attempt_number, delay_since_first_attempt_ms)
30                 if self._wait_jitter_max:
31                     jitter = random.random() * self._wait_jitter_max
32                     sleep = sleep + max(0, jitter)
33                 time.sleep(sleep / 1000.0)
34
35             attempt_number += 1 #进行下一轮重试

class Attempt(object):"""An Attempt encapsulates a call to a target function that may end as anormal return value from the function or an Exception depending on whatoccurred during the execution."""#value值为函数返回结果或异常，根据has_exception判断def __init__(self, value, attempt_number, has_exception):self.value = valueself.attempt_number = attempt_numberself.has_exception = has_exception#返回函数执行结果或异常，并根据wrap_exception参数对异常用RetryError包裹def get(self, wrap_exception=False):"""Return the return value of this Attempt instance or raise an Exception.If wrap_exception is true, this Attempt is wrapped inside of aRetryError before being raised."""if self.has_exception:if wrap_exception:raise RetryError(self)else:#重新构造原异常抛出six.reraise(self.value[0], self.value[1], self.value[2])else:return self.valuedef __repr__(self):if self.has_exception:return "Attempts: {0}, Error:\n{1}".format(self.attempt_number, "".join(traceback.format_tb(self.value[2])))else:return "Attempts: {0}, Value: {1}".format(self.attempt_number, self.value)