def test_done_callback_already_cancelled(self):
self.was_cancelled = None
def fn(callback_future):
self.was_cancelled = callback_future.cancelled()
f = Future()
self.assertTrue(f.cancel())
f.add_done_callback(fn)
self.assertTrue(self.was_cancelled)
def test_done_callback_already_failed(self):
self.callback_exception = None
def fn(callback_future):
self.callback_exception = callback_future.exception()
f = Future()
f.set_exception(Exception('test'))
f.add_done_callback(fn)
self.assertEquals(('test',), self.callback_exception.args)
def test_done_callback_with_result(self):
callback_result = [None]
def fn(callback_future):
callback_result[0] = callback_future.result()
f = Future()
f.add_done_callback(fn)
f.set_result(5)
self.assertEqual(5, callback_result[0])
def test_done_callback_with_result(self):
self.callback_result = None
def fn(callback_future):
self.callback_result = callback_future.result()
f = Future()
f.add_done_callback(fn)
f.set_result(5)
self.assertEquals(5, self.callback_result)
def test_done_callback_already_successful(self):
callback_result = [None]
def fn(callback_future):
callback_result[0] = callback_future.result()
f = Future()
f.set_result(5)
f.add_done_callback(fn)
self.assertEqual(5, callback_result[0])
def test_done_callback_already_failed(self):
callback_exception = [None]
def fn(callback_future):
callback_exception[0] = callback_future.exception()
f = Future()
f.set_exception(Exception('test'))
f.add_done_callback(fn)
self.assertEqual(('test',), callback_exception[0].args)
def test_done_callback_already_cancelled(self):
was_cancelled = [None]
def fn(callback_future):
was_cancelled[0] = callback_future.cancelled()
f = Future()
self.assertTrue(f.cancel())
f.add_done_callback(fn)
self.assertTrue(was_cancelled[0])
def test_done_callback_already_successful(self):
self.callback_result = None
def fn(callback_future):
self.callback_result = callback_future.result()
f = Future()
f.set_result(5)
f.add_done_callback(fn)
self.assertEquals(5, self.callback_result)
def test_done_callback_with_exception(self):
callback_exception = [None]
def fn(callback_future):
callback_exception[0] = callback_future.exception()
f = Future()
f.add_done_callback(fn)
f.set_exception(Exception("test"))
self.assertEqual(("test",), callback_exception[0].args)
def test_done_callback_with_exception(self):
callback_exception = None
def fn(callback_future):
nonlocal callback_exception
callback_exception = callback_future.exception()
f = Future()
f.add_done_callback(fn)
f.set_exception(Exception('test'))
self.assertEqual(('test',), callback_exception.args)
def test_done_callback_with_cancel(self):
was_cancelled = None
def fn(callback_future):
nonlocal was_cancelled
was_cancelled = callback_future.cancelled()
f = Future()
f.add_done_callback(fn)
self.assertTrue(f.cancel())
self.assertTrue(was_cancelled)
def test_done_callback_raises(self):
with captured_stderr() as stderr:
raising_was_called = [False]
raising_old_style_was_called = [False]
fn_was_called = [False]
def raising_fn(callback_future):
raising_was_called[0] = True
raise Exception('doh!')
def raising_old_style_fn(callback_future):
raising_old_style_was_called[0] = True
class OldStyle: # Does not inherit from object
def __str__(self):
return 'doh!'
raise OldStyle()
def fn(callback_future):
fn_was_called[0] = True
f = Future()
f.add_done_callback(raising_fn)
f.add_done_callback(raising_old_style_fn)
f.add_done_callback(fn)
f.set_result(5)
self.assertTrue(raising_was_called)
self.assertTrue(raising_old_style_was_called)
self.assertTrue(fn_was_called)
self.assertIn('Exception: doh!', stderr.getvalue())
self.assertIn('OldStyle: doh!', stderr.getvalue())
def test_done_callback_already_failed(self):
callback_exception = None
def fn(callback_future):
nonlocal callback_exception
callback_exception = callback_future.exception()
f = Future()
f.set_exception(Exception("test"))
f.add_done_callback(fn)
self.assertEqual(("test",), callback_exception.args)
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
def test_old_style_exception(self):
class OldStyle: # Does not inherit from object
def __str__(self):
return 'doh!'
callback_exc_info = [None]
def fn(callback_future):
callback_exc_info[0] = callback_future.exception_info()
f = Future()
f.add_done_callback(fn)
try:
raise OldStyle()
except OldStyle:
want_exc_info = sys.exc_info()
f.set_exception_info(*want_exc_info[1:])
self.assertEqual(f.exception_info(), want_exc_info[1:])
self.assertEqual(callback_exc_info[0], want_exc_info[1:])
try:
f.result()
except OldStyle:
got_exc_info = sys.exc_info()
else:
self.fail('OldStyle exception not raised')
self.assertEqual(got_exc_info[:2], want_exc_info[:2])
got_tb = traceback.extract_tb(got_exc_info[2])
want_tb = traceback.extract_tb(want_exc_info[2])
self.assertEqual(got_tb[-len(want_tb):], want_tb)
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)
def test_done_callback_raises(self):
LOGGER.removeHandler(STDERR_HANDLER)
logging_stream = io.StringIO()
handler = logging.StreamHandler(logging_stream)
LOGGER.addHandler(handler)
try:
raising_was_called = False
fn_was_called = False
def raising_fn(callback_future):
nonlocal raising_was_called
raising_was_called = True
raise Exception('doh!')
def fn(callback_future):
nonlocal fn_was_called
fn_was_called = True
f = Future()
f.add_done_callback(raising_fn)
f.add_done_callback(fn)
f.set_result(5)
self.assertTrue(raising_was_called)
self.assertTrue(fn_was_called)
self.assertIn('Exception: doh!', logging_stream.getvalue())
finally:
LOGGER.removeHandler(handler)
LOGGER.addHandler(STDERR_HANDLER)
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 __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 test_done_callback_raises(self):
with captured_stderr() as stderr:
raising_was_called = [False]
fn_was_called = [False]
def raising_fn(callback_future):
raising_was_called[0] = True
raise Exception("doh!")
def fn(callback_future):
fn_was_called[0] = True
f = Future()
f.add_done_callback(raising_fn)
f.add_done_callback(fn)
f.set_result(5)
self.assertTrue(raising_was_called)
self.assertTrue(fn_was_called)
self.assertIn("Exception: doh!", stderr.getvalue())
def test_free_reference_yielded_future(self):
# Issue #14406: Generator should not keep references
# to finished futures.
futures_list = [Future() for _ in range(8)]
futures_list.append(create_future(state=CANCELLED_AND_NOTIFIED))
futures_list.append(create_future(state=FINISHED, result=42))
with self.assertRaises(futures.TimeoutError):
for future in futures.as_completed(futures_list, timeout=0):
futures_list.remove(future)
wr = weakref.ref(future)
del future
self.assertIsNone(wr())
futures_list[0].set_result("test")
for future in futures.as_completed(futures_list):
futures_list.remove(future)
wr = weakref.ref(future)
del future
self.assertIsNone(wr())
if futures_list:
futures_list[0].set_result("test")
def test_done_callback_raises(self):
with test.support.captured_stderr() as stderr:
raising_was_called = False
fn_was_called = False
def raising_fn(callback_future):
nonlocal raising_was_called
raising_was_called = True
raise Exception('doh!')
def fn(callback_future):
nonlocal fn_was_called
fn_was_called = True
f = Future()
f.add_done_callback(raising_fn)
f.add_done_callback(fn)
f.set_result(5)
self.assertTrue(raising_was_called)
self.assertTrue(fn_was_called)
self.assertIn('Exception: doh!', stderr.getvalue())
def __init__(self,
level: int = logging.NOTSET,
maxlen: Optional[int] = None) -> None:
super().__init__(level=level)
self.cached_records = deque([], maxlen)
self._emit_future = Future()
def submit(self, fn, *args, **kwargs):
future = Future()
future.set_result(fn(*args, **kwargs))
return future
def create_future(state=PENDING, exception=None, result=None):
f = Future()
f._state = state
f._exception = exception
f._result = result
return f
def append_stage(stage_future: Future):
stage = stage_future.result()
container = self._build_container(name, stage, concurrency,
parallel)
self._wait_for_previous(container, last_stage_name)
self._containers[name] = container
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 submit(self, fn):
result = fn()
future = Future()
future.set_result(result)
return future
class CachedHandler(logging.Handler):
"""Handler which stores past records
This is used to populate Maestral's status and error interfaces. The method
:meth:`wait_for_emit` can be used from another thread to block until a new record is
emitted, for instance to react to state changes.
:param level: Initial log level. Defaults to NOTSET.
:param maxlen: Maximum number of records to store. If ``None``, all records will be
stored. Defaults to ``None``.
"""
cached_records: Deque[logging.LogRecord]
_emit_future: Future
def __init__(self,
level: int = logging.NOTSET,
maxlen: Optional[int] = None) -> None:
super().__init__(level=level)
self.cached_records = deque([], maxlen)
self._emit_future = Future()
def emit(self, record: logging.LogRecord) -> None:
"""
Logs the specified log record and saves it to the cache.
:param record: Log record.
"""
self.cached_records.append(record)
# notify any waiting coroutines that we have a status change
try:
self._emit_future.set_result(True)
except InvalidStateError:
pass
def wait_for_emit(self, timeout: Optional[float]) -> bool:
"""
Blocks until a new record is emitted.
:param timeout: Maximum time to block before returning.
:returns: ``True`` if there was a status change, ``False`` in case of a timeout.
"""
done, not_done = wait([self._emit_future], timeout=timeout)
self._emit_future = Future() # reset future
return len(done) == 1
def getLastMessage(self) -> str:
"""
:returns: The log message of the last record or an empty string.
"""
try:
last_record = self.cached_records[-1]
return last_record.getMessage()
except IndexError:
return ""
def getAllMessages(self) -> List[str]:
"""
:returns: A list of all record messages.
"""
return [r.getMessage() for r in self.cached_records]
def clear(self) -> None:
"""
Clears all cached records.
"""
self.cached_records.clear()
