1 from __future__ import division
7 from twisted.internet import defer, reactor
8 from twisted.python import failure, log
12 reactor.callLater(t, d.callback, None)
15 def run_repeatedly(f, *args, **kwargs):
18 delay = f(*args, **kwargs)
19 current_dc[0] = reactor.callLater(delay, step)
22 current_dc[0].cancel()
25 class RetrySilentlyException(Exception):
28 def retry(message='Error:', delay=3, max_retries=None, traceback=True):
30 @retry('Error getting block:', 1)
31 @defer.inlineCallbacks
37 @defer.inlineCallbacks
38 def f(*args, **kwargs):
39 for i in itertools.count():
41 result = yield func(*args, **kwargs)
45 if not isinstance(e, RetrySilentlyException):
47 log.err(None, message)
49 print >>sys.stderr, message, e
52 defer.returnValue(result)
56 class ReplyMatcher(object):
58 Converts request/got response interface to deferred interface
61 def __init__(self, func, timeout=5):
63 self.timeout = timeout
66 def __call__(self, id):
67 if id not in self.map:
71 self.map[id].remove((df, timer))
74 df.errback(failure.Failure(defer.TimeoutError('in ReplyMatcher')))
75 timer = reactor.callLater(self.timeout, timeout)
76 self.map.setdefault(id, set()).add((df, timer))
79 def got_response(self, id, resp):
80 if id not in self.map:
82 for df, timer in self.map.pop(id):
86 class GenericDeferrer(object):
88 Converts query with identifier/got response interface to deferred interface
91 def __init__(self, max_id, func, timeout=5):
94 self.timeout = timeout
97 def __call__(self, *args, **kwargs):
99 id = random.randrange(self.max_id)
100 if id not in self.map:
102 df = defer.Deferred()
105 df.errback(failure.Failure(defer.TimeoutError('in GenericDeferrer')))
106 timer = reactor.callLater(self.timeout, timeout)
107 self.func(id, *args, **kwargs)
108 self.map[id] = df, timer
111 def got_response(self, id, resp):
112 if id not in self.map:
114 df, timer = self.map.pop(id)
118 def respond_all(self, resp):
120 df, timer = self.map.popitem()
124 class NotNowError(Exception):
127 class DeferredCacher(object):
129 like memoize, but for functions that return Deferreds
136 @DeferredCacher.with_backing(bsddb.hashopen(...))
143 def with_backing(cls, backing):
144 return lambda func: cls(func, backing)
146 def __init__(self, func, backing=None):
151 self.backing = backing
154 @defer.inlineCallbacks
155 def __call__(self, key):
156 if key in self.waiting:
157 yield self.waiting[key]
159 if key in self.backing:
160 defer.returnValue(self.backing[key])
162 self.waiting[key] = defer.Deferred()
164 value = yield self.func(key)
166 self.waiting.pop(key).callback(None)
168 self.backing[key] = value
169 defer.returnValue(value)
172 def call_now(self, key, default=_nothing):
173 if key in self.backing:
174 return self.backing[key]
175 if key not in self.waiting:
176 self.waiting[key] = defer.Deferred()
178 self.backing[key] = value
179 self.waiting.pop(key).callback(None)
181 self.waiting.pop(key).callback(None)
182 if fail.check(RetrySilentlyException):
185 print 'Error when requesting noncached value:'
186 fail.printTraceback()
188 self.func(key).addCallback(cb).addErrback(eb)
189 if default is not self._nothing:
191 raise NotNowError(key)