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, on_timeout=lambda: None):
94 self.timeout = timeout
95 self.on_timeout = on_timeout
98 def __call__(self, *args, **kwargs):
100 id = random.randrange(self.max_id)
101 if id not in self.map:
103 df = defer.Deferred()
106 df.errback(failure.Failure(defer.TimeoutError('in GenericDeferrer')))
108 timer = reactor.callLater(self.timeout, timeout)
109 self.func(id, *args, **kwargs)
110 self.map[id] = df, timer
113 def got_response(self, id, resp):
114 if id not in self.map:
116 df, timer = self.map.pop(id)
120 def respond_all(self, resp):
122 id, (df, timer) = self.map.popitem()
126 class NotNowError(Exception):
129 class DeferredCacher(object):
131 like memoize, but for functions that return Deferreds
138 @DeferredCacher.with_backing(bsddb.hashopen(...))
145 def with_backing(cls, backing):
146 return lambda func: cls(func, backing)
148 def __init__(self, func, backing=None):
153 self.backing = backing
156 @defer.inlineCallbacks
157 def __call__(self, key):
158 if key in self.waiting:
159 yield self.waiting[key]
161 if key in self.backing:
162 defer.returnValue(self.backing[key])
164 self.waiting[key] = defer.Deferred()
166 value = yield self.func(key)
168 self.waiting.pop(key).callback(None)
170 self.backing[key] = value
171 defer.returnValue(value)
174 def call_now(self, key, default=_nothing):
175 if key in self.backing:
176 return self.backing[key]
177 if key not in self.waiting:
178 self.waiting[key] = defer.Deferred()
180 self.backing[key] = value
181 self.waiting.pop(key).callback(None)
183 self.waiting.pop(key).callback(None)
184 if fail.check(RetrySilentlyException):
187 print 'Error when requesting noncached value:'
188 fail.printTraceback()
190 self.func(key).addCallback(cb).addErrback(eb)
191 if default is not self._nothing:
193 raise NotNowError(key)