class ReactiveQueueTask(object):
def __init__(self, func, args, kwargs):
self.func = func
self.args = args
self.kwargs = kwargs
self.deferred = Deferred()
def __call__(self):
return self.func(*self.args, **self.kwargs)
def resolve(self, ret):
self.deferred.callback(ret)
def reject(self, error):
self.deferred.errback(error)
def findNode(self, id, callback, errback = None):
"""
Returns the the k closest nodes to that ID from the global table
"""
# get K nodes out of local table/cache
nodes = self.table.findNodes(id)
d = Deferred()
if errback:
d.addCallbacks(callback, errback)
else:
d.addCallback(callback)
# create our search state
state = FindNode(self, id, d.callback)
self.rawserver.add_task(state.goWithNodes, 0, [nodes])
def _check_authorization(subject, action_id, timeout, bus, flags=None):
def policykit_done(xxx_todo_changeme):
(authorized, challenged, auth_details) = xxx_todo_changeme
if authorized:
deferred.callback(auth_details)
elif challenged:
deferred.errback(AuthorizationFailed(subject, action_id))
else:
deferred.errback(NotAuthorizedError(subject, action_id))
if not bus:
bus = dbus.SystemBus()
# Set the default flags
if flags is None:
flags = CHECK_AUTH_ALLOW_USER_INTERACTION
deferred = Deferred()
pk = bus.get_object("org.freedesktop.PolicyKit1",
"/org/freedesktop/PolicyKit1/Authority")
details = {}
pk.CheckAuthorization(
subject, action_id, details, flags, "",
dbus_interface="org.freedesktop.PolicyKit1.Authority",
timeout=timeout,
reply_handler=policykit_done,
error_handler=deferred.errback)
return deferred
def get_dbus_property(proxy, interface, property):
"""Small helper to get the property value of a dbus object."""
props = dbus.Interface(proxy, "org.freedesktop.DBus.Properties")
deferred = Deferred()
props.Get(interface, property,
reply_handler=deferred.callback,
error_handler=deferred.errback)
return deferred
def sendRequest(self, method, args):
# make message
# send it
msg = {TID : chr(self.mtid), TYP : REQ, REQ : method, ARG : args}
self.mtid = (self.mtid + 1) % 256
s = bencode(msg)
d = Deferred()
self.tids[msg[TID]] = d
self.call_later(KRPC_TIMEOUT, self.timeOut, msg[TID])
self.call_later(0, self._send, s, d)
return d
def get_pid_from_dbus_name(dbus_name, bus=None):
"""Return a deferred that gets the id of process owning the given
system D-Bus name.
"""
if not bus:
bus = dbus.SystemBus()
deferred = Deferred()
bus_obj = bus.get_object("org.freedesktop.DBus",
"/org/freedesktop/DBus/Bus")
bus_obj.GetConnectionUnixProcessID(dbus_name,
dbus_interface="org.freedesktop.DBus",
reply_handler=deferred.callback,
error_handler=deferred.errback)
return deferred
def _run_synaptic(self, xid, opt, tempf, interaction):
deferred = Deferred()
if tempf:
opt.extend(["--set-selections-file", "%s" % tempf.name])
#FIXME: Take interaction into account
opt.extend(["-o", "Synaptic::closeZvt=true"])
if xid:
opt.extend(["--parent-window-id", "%s" % (xid)])
cmd = ["/usr/bin/gksu",
"--desktop", "/usr/share/applications/update-manager.desktop",
"--", "/usr/sbin/synaptic", "--hide-main-window",
"--non-interactive"]
cmd.extend(opt)
flags = GObject.SPAWN_DO_NOT_REAP_CHILD
(pid, stdin, stdout, stderr) = GObject.spawn_async(cmd, flags=flags)
GObject.child_watch_add(pid, self._on_synaptic_exit, (tempf, deferred))
return deferred
def findNode(self, id, callback, errback=None):
""" returns the contact info for node, or the k closest nodes, from the global table """
# get K nodes out of local table/cache, or the node we want
nodes = self.table.findNodes(id, invalid=True)
l = [x for x in nodes if x.invalid]
if len(l) > 4:
nodes = sample(l, 4) + self.table.findNodes(id, invalid=False)[:4]
d = Deferred()
if errback:
d.addCallbacks(callback, errback)
else:
d.addCallback(callback)
if len(nodes) == 1 and nodes[0].id == id:
d.callback(nodes)
else:
# create our search state
state = FindNode(self, id, d.callback, self.rawserver.add_task)
self.rawserver.external_add_task(0, state.goWithNodes, nodes)
def findNode(self, id, callback, errback=None):
""" returns the contact info for node, or the k closest nodes, from the global table """
# get K nodes out of local table/cache, or the node we want
nodes = self.table.findNodes(id, invalid=True)
l = [x for x in nodes if x.invalid]
if len(l) > 4:
nodes = sample(l , 4) + self.table.findNodes(id, invalid=False)[:4]
d = Deferred()
if errback:
d.addCallbacks(callback, errback)
else:
d.addCallback(callback)
if len(nodes) == 1 and nodes[0].id == id :
d.callback(nodes)
else:
# create our search state
state = FindNode(self, id, d.callback, self.rawserver.add_task)
self.rawserver.external_add_task(0, state.goWithNodes, nodes)
def _run():
TTL = 1
SET_TTL = 2 # TTL used when explicitly setting TTL using "def set."
EXPIRE_INTERVAL = .3
EPSILON = .5
###
# BoundedCacheSet correctness tests.
c = _BoundedCacheSet(2)
c.add(10)
assert 10 in c
c.add(15)
assert 15 in c
c.add(16)
assert 16 in c
assert 10 not in c
assert 15 in c
c.remove(15)
assert 15 not in c
try:
c.remove(23)
assert False
except KeyError:
pass
###
# basic CacheMap correctness tests.
c = CacheMap(default_ttl=TTL,expire_interval=EPSILON)
class K(object):
def __init__(self):
self.x = range(10000)
class V(object):
def __init__(self):
self.x = range(10000)
k = K()
v = V()
t = time()
c.set(k, v, SET_TTL)
assert len(c) == 1
assert c.num_unexpired() == 1
assert c._exp.begin().key() < t + SET_TTL + EPSILON and \
c._exp.begin().key() > t + SET_TTL - EPSILON, \
"First item in c._exp should have expiration time that is close to the " \
"current time + SET_TTL which is %s, but the expiration time is %s." \
% (t+SET_TTL, c._exp.begin().key())
assert c.has_key(k)
assert not c.has_key( "blah" )
assert c[k] == v
c._expire2() # should not expire anything because little time has passed.
assert len(c) == 1
assert c.num_unexpired() == 1
try:
y = c[10]
assert False, "should've raised KeyError."
except KeyError:
pass
v2 = V()
c[k] = v2
assert c._exp.begin().key() < t + SET_TTL + EPSILON and \
c._exp.begin().key() > t + SET_TTL - EPSILON, \
"First item in c._exp should have expiration time that is close to the " \
"current time + SET_TTL, but the expiration time is %s." % c._exp.begin().key()
assert not c[k] == v
assert c[k] == v2
assert len(c) == 1
assert c.num_unexpired() == 1
k2 = K()
t = time()
c[k2] = v2
assert c._exp.begin().key() < t + TTL + EPSILON and \
c._exp.begin().key() > t + TTL - EPSILON, \
"First item in c._exp should have expiration time that is close to the " \
"current time + TTL, but the expiration time is %s." % c._exp.begin().key()
assert c[k2] == v2
assert not c[k] == v # shouldn't be a problem with two items having the same value.
assert len(c) == 2
assert c.num_unexpired() == 2
# wait long enough for the cache entries to expire.
df = Deferred()
reactor.callLater(SET_TTL+EPSILON, df.callback, None)
yield df
df.getResult()
assert c.num_unexpired() == 0, "Should have expired all entries, but there are %d " \
"unexpired items and %d items in c._data. " % (c.num_unexpired(), len(c._data))
assert len(c) == 0
assert len(c._exp) == 0
assert len(c._data) == 0
assert k not in c
assert k2 not in c
# basic correctness of bounded-size cache map.
c = CacheMap(default_ttl=TTL,expire_interval=1000,max_items = 2)
c[k] = v
assert len(c) == 1
assert c[k] == v
c[k2] = v2
assert len(c) == 2
assert c[k2] == v2
c[10] = 15
assert len(c) == 2
assert c[10] == 15
assert c[k2] == v2 # order from most recent access is now [(k2,v2), (10,15), (k,v)].
try:
a = c[k]
assert False, "when cache with size bound of 2 exceeded 2 elements, " \
"the oldest should've been removed."
except KeyError:
pass
c[56] = 1 # order from most recent access ...
assert len(c) == 2
assert 56 in c
assert 10 not in c
###
# test expirations and for memory leaks.
# Watch memory consumption (e.g., using top) and see if it grows.
if LEAK_TEST:
c = CacheMap(default_ttl=TTL,expire_interval=EPSILON)
i = 0
while True:
for x in xrange(100):
i += 1
if i % 20 == 0:
print len(c)
c[i] = K()
if i % 5 == 0:
try:
l = len(c)
del c[i]
assert len(c) == l-1
except KeyError:
pass
# allow time for expirations.
df = Deferred()
reactor.callLater(TTL+EPSILON,df.callback,None)
yield df
df.getResult()
from defer import Deferred
__author__ = 'cqh'
def myCallback(result):
print result
def myErrback(err):
print err
d=Deferred()
d.add_callback(myCallback)
#d.add_errback(myErrback)
d.callback("Trigger callback.")
def _run():
TTL = 1
SET_TTL = 2 # TTL used when explicitly setting TTL using "def set."
EXPIRE_INTERVAL = .3
EPSILON = .5
###
# BoundedCacheSet correctness tests.
c = _BoundedCacheSet(2)
c.add(10)
assert 10 in c
c.add(15)
assert 15 in c
c.add(16)
assert 16 in c
assert 10 not in c
assert 15 in c
c.remove(15)
assert 15 not in c
try:
c.remove(23)
assert False
except KeyError:
pass
###
# basic CacheMap correctness tests.
c = CacheMap(default_ttl=TTL, expire_interval=EPSILON)
class K(object):
def __init__(self):
self.x = range(10000)
class V(object):
def __init__(self):
self.x = range(10000)
k = K()
v = V()
t = time()
c.set(k, v, SET_TTL)
assert len(c) == 1
assert c.num_unexpired() == 1
assert c._exp.begin().key() < t + SET_TTL + EPSILON and \
c._exp.begin().key() > t + SET_TTL - EPSILON, \
"First item in c._exp should have expiration time that is close to the " \
"current time + SET_TTL which is %s, but the expiration time is %s." \
% (t+SET_TTL, c._exp.begin().key())
assert c.has_key(k)
assert not c.has_key("blah")
assert c[k] == v
c._expire2(
) # should not expire anything because little time has passed.
assert len(c) == 1
assert c.num_unexpired() == 1
try:
y = c[10]
assert False, "should've raised KeyError."
except KeyError:
pass
v2 = V()
c[k] = v2
assert c._exp.begin().key() < t + SET_TTL + EPSILON and \
c._exp.begin().key() > t + SET_TTL - EPSILON, \
"First item in c._exp should have expiration time that is close to the " \
"current time + SET_TTL, but the expiration time is %s." % c._exp.begin().key()
assert not c[k] == v
assert c[k] == v2
assert len(c) == 1
assert c.num_unexpired() == 1
k2 = K()
t = time()
c[k2] = v2
assert c._exp.begin().key() < t + TTL + EPSILON and \
c._exp.begin().key() > t + TTL - EPSILON, \
"First item in c._exp should have expiration time that is close to the " \
"current time + TTL, but the expiration time is %s." % c._exp.begin().key()
assert c[k2] == v2
assert not c[
k] == v # shouldn't be a problem with two items having the same value.
assert len(c) == 2
assert c.num_unexpired() == 2
# wait long enough for the cache entries to expire.
df = Deferred()
reactor.callLater(SET_TTL + EPSILON, df.callback, None)
yield df
df.getResult()
assert c.num_unexpired() == 0, "Should have expired all entries, but there are %d " \
"unexpired items and %d items in c._data. " % (c.num_unexpired(), len(c._data))
assert len(c) == 0
assert len(c._exp) == 0
assert len(c._data) == 0
assert k not in c
assert k2 not in c
# basic correctness of bounded-size cache map.
c = CacheMap(default_ttl=TTL, expire_interval=1000, max_items=2)
c[k] = v
assert len(c) == 1
assert c[k] == v
c[k2] = v2
assert len(c) == 2
assert c[k2] == v2
c[10] = 15
assert len(c) == 2
assert c[10] == 15
assert c[
k2] == v2 # order from most recent access is now [(k2,v2), (10,15), (k,v)].
try:
a = c[k]
assert False, "when cache with size bound of 2 exceeded 2 elements, " \
"the oldest should've been removed."
except KeyError:
pass
c[56] = 1 # order from most recent access ...
assert len(c) == 2
assert 56 in c
assert 10 not in c
###
# test expirations and for memory leaks.
# Watch memory consumption (e.g., using top) and see if it grows.
if LEAK_TEST:
c = CacheMap(default_ttl=TTL, expire_interval=EPSILON)
i = 0
while True:
for x in xrange(100):
i += 1
if i % 20 == 0:
print len(c)
c[i] = K()
if i % 5 == 0:
try:
l = len(c)
del c[i]
assert len(c) == l - 1
except KeyError:
pass
# allow time for expirations.
df = Deferred()
reactor.callLater(TTL + EPSILON, df.callback, None)
yield df
df.getResult()
def __init__(self, func, args, kwargs):
self.func = func
self.args = args
self.kwargs = kwargs
self.deferred = Deferred()
from defer import Deferred
__author__ = 'cqh'
def callback1(result):
print "Callback 1 said:",result
return result
def callback2(result):
print "Callback2 said:",result
def callback3(result):
raise Exception("Callback 3")
def errback1(failure):
print "Errback 1 had an an error on ,",failure
return failure
def errback2(failure):
raise Exception("Errback 2")
def errback3(failure):
print "Errback3 took care of ",failure
return "Everything is fine now."
d=Deferred()
d.add_callback(callback1)
d.add_callback(callback2)
d.add_callbacks(callback3,errback1)
d.add_errback(errback3)
d.callback("Test")
def append_task(self, task): deferred = Deferred(task) self.deferred_queue.put_nowait(deferred) self.pending_tasks_event.set() return deferred