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:
104 df, timer = self.map.pop(id)
106 df = defer.Deferred(cancel)
109 df.errback(failure.Failure(defer.TimeoutError('in GenericDeferrer')))
111 timer = reactor.callLater(self.timeout, timeout)
112 self.map[id] = df, timer
113 self.func(id, *args, **kwargs)
116 def got_response(self, id, resp):
117 if id not in self.map:
119 df, timer = self.map.pop(id)
123 def respond_all(self, resp):
125 id, (df, timer) = self.map.popitem()
129 class NotNowError(Exception):
132 class DeferredCacher(object):
134 like memoize, but for functions that return Deferreds
141 @DeferredCacher.with_backing(bsddb.hashopen(...))
148 def with_backing(cls, backing):
149 return lambda func: cls(func, backing)
151 def __init__(self, func, backing=None):
156 self.backing = backing
159 @defer.inlineCallbacks
160 def __call__(self, key):
161 if key in self.waiting:
162 yield self.waiting[key]
164 if key in self.backing:
165 defer.returnValue(self.backing[key])
167 self.waiting[key] = defer.Deferred()
169 value = yield self.func(key)
171 self.waiting.pop(key).callback(None)
173 self.backing[key] = value
174 defer.returnValue(value)
177 def call_now(self, key, default=_nothing):
178 if key in self.backing:
179 return self.backing[key]
180 if key not in self.waiting:
181 self.waiting[key] = defer.Deferred()
183 self.backing[key] = value
184 self.waiting.pop(key).callback(None)
186 self.waiting.pop(key).callback(None)
187 if fail.check(RetrySilentlyException):
190 print 'Error when requesting noncached value:'
191 fail.printTraceback()
193 self.func(key).addCallback(cb).addErrback(eb)
194 if default is not self._nothing:
196 raise NotNowError(key)