class Invocation(object):
sent_connection = None
timer = None
def __init__(self, request, partition_id=-1, address=None, connection=None, timeout=INVOCATION_TIMEOUT):
self._event = threading.Event()
self.timeout = timeout + time.time()
self.address = address
self.connection = connection
self.partition_id = partition_id
self.request = request
self.future = Future()
def has_connection(self):
return self.connection is not None
def has_partition_id(self):
return self.partition_id >= 0
def has_address(self):
return self.address is not None
def set_response(self, response):
if self.timer:
self.timer.cancel()
self.future.set_result(response)
def set_exception(self, exception, traceback=None):
if self.timer:
self.timer.cancel()
self.future.set_exception(exception, traceback)
def on_timeout(self):
self.set_exception(TimeoutError("Request timed out after %d seconds." % INVOCATION_TIMEOUT))
class Invocation(object):
sent_connection = None
timer = None
def __init__(self, request, partition_id=-1, address=None, connection=None, timeout=INVOCATION_TIMEOUT):
self._event = threading.Event()
self.timeout = timeout + time.time()
self.address = address
self.connection = connection
self.partition_id = partition_id
self.request = request
self.future = Future()
def has_connection(self):
return self.connection is not None
def has_partition_id(self):
return self.partition_id >= 0
def has_address(self):
return self.address is not None
def set_response(self, response):
if self.timer:
self.timer.cancel()
self.future.set_result(response)
def set_exception(self, exception, traceback=None):
if self.timer:
self.timer.cancel()
self.future.set_exception(exception, traceback)
def on_timeout(self):
self.set_exception(TimeoutError("Request timed out after %d seconds." % INVOCATION_TIMEOUT))
class Invocation(object):
__slots__ = ("request", "timeout", "partition_id", "uuid", "connection",
"event_handler", "future", "sent_connection", "urgent",
"response_handler")
def __init__(self,
request,
partition_id=-1,
uuid=None,
connection=None,
event_handler=None,
urgent=False,
timeout=None,
response_handler=_no_op_response_handler):
self.request = request
self.partition_id = partition_id
self.uuid = uuid
self.connection = connection
self.event_handler = event_handler
self.urgent = urgent
self.timeout = timeout
self.future = Future()
self.timeout = None
self.sent_connection = None
self.response_handler = response_handler
def set_response(self, response):
try:
result = self.response_handler(response)
self.future.set_result(result)
except Exception as e:
self.future.set_exception(e)
def set_exception(self, exception, traceback=None):
self.future.set_exception(exception, traceback)
def test_continue_with_with_resolved_future(self):
f1 = Future()
f2 = Future()
f3 = f1.continue_with(lambda _: f2)
f1.set_result(0)
f2.set_result(1)
self.assertEqual(1, f3.result())
def test_done(self):
f = Future()
self.assertFalse(f.done())
f.set_result("done")
self.assertTrue(f.done())
def test_callback_throws_exception(self):
f = Future()
def invalid_func():
raise RuntimeError("error!")
f.add_done_callback(invalid_func)
f.set_result("done") # should not throw exception
def test_running(self):
f = Future()
self.assertTrue(f.running())
f.set_result("done")
self.assertFalse(f.running())
def test_done(self):
f = Future()
self.assertFalse(f.done())
f.set_result("done")
self.assertTrue(f.done())
def test_running(self):
f = Future()
self.assertTrue(f.running())
f.set_result("done")
self.assertFalse(f.running())
def test_callback_throws_exception(self):
f = Future()
def invalid_func(_):
raise RuntimeError("error!")
f.add_done_callback(invalid_func)
f.set_result("done") # should not throw exception
def test_continue_with_with_rejected_future(self):
f1 = Future()
f2 = Future()
f3 = f1.continue_with(lambda _: f2)
f1.set_result(0)
f2.set_exception(RuntimeError("error"))
with self.assertRaises(RuntimeError):
f3.result()
def test_continue_with_on_success(self):
f = Future()
f.set_result(1)
def continuation(future):
return future.result() + 1
result = f.continue_with(continuation).result()
self.assertEqual(2, result)
def test_continue_with_on_success(self):
f = Future()
f.set_result(1)
def continuation(future):
return future.result() + 1
result = f.continue_with(continuation).result()
self.assertEqual(2, result)
def test_combine_futures_exception(self):
f1, f2, f3 = Future(), Future(), Future()
combined = combine_futures(f1, f2, f3)
e = RuntimeError("error")
f1.set_result("done")
f2.set_result("done")
f3.set_exception(e)
self.assertEqual(e, combined.exception())
def test_combine_futures_exception(self):
f1, f2, f3 = Future(), Future(), Future()
combined = combine_futures([f1, f2, f3])
e = RuntimeError("error")
f1.set_result("done")
f2.set_result("done")
f3.set_exception(e)
self.assertEqual(e, combined.exception())
def test_continue_with_throws_exception(self):
f = Future()
e = RuntimeError("error")
def continue_func(f):
raise e
n = f.continue_with(continue_func)
f.set_result("done")
self.assertFalse(n.is_success())
self.assertEqual(n.exception(), e)
def test_continue_with_throws_exception(self):
f = Future()
e = RuntimeError("error")
def continue_func(_):
raise e
n = f.continue_with(continue_func)
f.set_result("done")
self.assertFalse(n.is_success())
self.assertEqual(n.exception(), e)
def test_add_callback_after_completion_with_success(self):
f = Future()
f.set_result("done")
counter = [0]
def callback(future):
counter[0] += 1
self.assertEqual(future.result(), "done")
f.add_done_callback(callback)
self.assertEqual(counter[0], 1)
def test_completion_order(self):
# Verifies that the returned list order is
# consistent with the order of input futures
# regardless of the completion order of futures.
f1, f2, f3 = Future(), Future(), Future()
combined = combine_futures([f1, f2, f3])
f3.set_result(3)
f1.set_result(1)
f2.set_result(2)
self.assertEqual([1, 2, 3], combined.result())
def test_add_callback_after_completion_with_success(self):
f = Future()
f.set_result("done")
counter = [0]
def callback(future):
counter[0] += 1
self.assertEqual(future.result(), "done")
f.add_done_callback(callback)
self.assertEqual(counter[0], 1)
def test_combine_futures(self):
f1, f2, f3 = Future(), Future(), Future()
combined = combine_futures([f1, f2, f3])
f1.set_result("done1")
self.assertFalse(combined.done())
f2.set_result("done2")
self.assertFalse(combined.done())
f3.set_result("done3")
self.assertEqual(combined.result(), ["done1", "done2", "done3"])
def test_combine_futures(self):
f1, f2, f3 = Future(), Future(), Future()
combined = combine_futures(f1, f2, f3)
f1.set_result("done1")
self.assertFalse(combined.done())
f2.set_result("done2")
self.assertFalse(combined.done())
f3.set_result("done3")
self.assertEqual(combined.result(), ["done1", "done2", "done3"])
class Invocation(object):
sent_connection = None
timer = None
def __init__(self,
invocation_service,
request,
partition_id=-1,
address=None,
connection=None,
event_handler=None):
self._event = threading.Event()
self._invocation_timeout = invocation_service.invocation_timeout
self._client = invocation_service._client
self.timeout = self._invocation_timeout + time.time()
self.address = address
self.connection = connection
self.partition_id = partition_id
self.request = request
self.future = Future()
self.event_handler = event_handler
def has_connection(self):
return self.connection is not None
def has_partition_id(self):
return self.partition_id >= 0
def has_address(self):
return self.address is not None
def set_response(self, response):
if self.timer:
self._client.reactor.stop_timer(self.timer)
self.future.set_result(response)
def set_exception(self, exception, traceback=None):
if self.timer:
self._client.reactor.stop_timer(self.timer)
self.future.set_exception(exception, traceback)
def set_timeout(self, timeout):
self._invocation_timeout = timeout
self.timeout = self._invocation_timeout + time.time()
def on_timeout(self):
self.set_exception(
TimeoutError("Request timed out after %d seconds." %
self._invocation_timeout))
def test_continue_with_future_returning_future(self):
f1 = Future()
f2 = Future()
f3 = Future()
f4 = f1.continue_with(lambda _: f2)
f1.set_result(0)
f2.set_result(f3)
f3.set_result(1)
self.assertEqual(1, f4.result())
def add_one(self, x):
f = Future()
f.set_result(x + 1)
return f
def add_one(self, x):
f = Future()
f.set_result(x + 1)
return f
def multiply(self, x, y):
f = Future()
f.set_result(x * y)
return f
def multiply(self, x, y):
f = Future()
f.set_result(x * y)
return f
