class Runner(object):
"""
This class waits for dependencies to finish and submits itself to the job scheduler
"""
def __init__(self, task):
self.future = Future()
# a list of Runners to wait for
self.waiting_for = []
# the callable to run
self.task = task
super(Runner, self).__init__()
def schedule(self, executor, _reschedule=False):
"""
Try to schedule this Runner with the executor or wait for dependencies
"""
if self.future.done():
return
if False not in [r.future.done() for r in self.waiting_for]:
if any(r.future.exception() for r in self.waiting_for):
# a dependency failed. done() is True but an exception is set
return
executor.submit(self)
return
def dep_finished_callback(future):
self.schedule(executor, _reschedule=True)
if not _reschedule:
for runner in self.waiting_for:
runner.future.add_done_callback(dep_finished_callback)
class Search(object):
def __init__(self, key, routing_tables, network_node, nb_parallel=3, nb_pool=10):
self.key = key
self.routing_tables = routing_tables
self.network_node = network_node
self.key = key
self.request_in_progress = {}
self.nb_parallel = nb_parallel
self.completed = Future()
self.canditate_peers = set()
self.requested_peers = set()
self.nb_pool = nb_pool
def start(self):
self.fillpeers()
self.process_search()
return self.completed
def fillpeers(self):
closest = self.routing_tables.find_closest(self.key, self.nb_pool, excluding=self.requested_peers | self.canditate_peers)
self.canditate_peers |= set(closest)
def process_search(self):
if not self.completed.done() and len(self.canditate_peers) == 0 and len(self.request_in_progress) == 0:
self.completed.set_exception(ValueNotFound("unable to find value"))
return
while self.canditate_peers and len(self.request_in_progress) <= self.nb_parallel:
p = self.canditate_peers.pop()
self.requested_peers.add(p)
future = self.network_node.request(p.addr, {"method" : "find_node", "params": str(self.key)})
self.request_in_progress[future] = p
#then(future, self.on_reply)
future.add_done_callback(self.on_reply)
def on_reply(self, future):
del self.request_in_progress[future]
exception = future.exception()
if exception is None:
result = future.result()
if 'value' in result:
self.completed.set_result(result['value'])
elif 'peers' in result:
for id, addr in result["peers"]:
peer = Peer(Id(id), addr)
if peer not in self.requested_peers:
self.canditate_peers.add(Peer(Id(id), addr))
self.process_search()
def __eq__(self, other):
return self.key == other.key
class AssertCondition(object):
def __init__(self) -> None:
super().__init__()
self.completable_feature = Future()
self.test_count = 0
self.test_method = self.test
self.test_method_with_sleep = self.test_with_sleep
def test(self, max_count):
print('[{thread}] Next count: {test_count}'.format(
thread=currentThread().name, test_count=self.test_count))
self.test_count += 1
if self.test_count >= max_count:
self.completable_feature.set_result(self.test_count)
self.completable_feature.done()
def test_with_sleep(self, max_count, sleep_time):
print('[{thread}] test_with_sleep'.format(thread=currentThread().name))
time.sleep(sleep_time)
self.test(max_count)
def result(self):
print('[{thread}] result'.format(thread=currentThread().name))
return self.completable_feature.result()
