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))
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.sent_connection = None
self.response_handler = response_handler
self.backup_acks_received = 0
self.backup_acks_expected = -1
self.pending_response = None
self.pending_response_received_time = -1
def test_set_result(self):
f = Future()
def set_result():
f.set_result("done")
Thread(target=set_result).start()
self.assertEqual(f.result(), "done")
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 test_set_result(self):
f = Future()
def set_result():
f.set_result("done")
Thread(target=set_result).start()
self.assertEqual(f.result(), "done")
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_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 __init__(self, invocation_service, request, partition_id=-1, address=None, connection=None):
self._event = threading.Event()
self._invocation_timeout = invocation_service.invocation_timeout
self.timeout = self._invocation_timeout + time.time()
self.address = address
self.connection = connection
self.partition_id = partition_id
self.request = request
self.future = Future()
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_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_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_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_continue_with_on_failure(self):
f = Future()
f.set_exception(RuntimeError("error"))
def continuation(future):
if future.is_success():
return 0
else:
return 1
result = f.continue_with(continuation).result()
self.assertEqual(1, result)
def test_continue_with_on_failure(self):
f = Future()
f.set_exception(RuntimeError("error"))
def continuation(future):
if future.is_success():
return 0
else:
return 1
result = f.continue_with(continuation).result()
self.assertEqual(1, result)
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_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_add_callback_after_completion_with_error(self):
f = Future()
error = RuntimeError("error")
f.set_exception(error, None)
counter = [0]
def callback(future):
counter[0] += 1
self.assertEqual(future.exception(), error)
f.add_done_callback(callback)
self.assertEqual(counter[0], 1)
def close(self):
"""Release the resources associated with the query result.
The query engine delivers the rows asynchronously. The query may
become inactive even before all rows are consumed. The invocation
of this command will cancel the execution of the query on all members
if the query is still active. Otherwise it is no-op. For a result
with an update count it is always no-op.
The returned Future results with:
- :class:`HazelcastSqlError`: In case there is an error closing the
result.
Returns:
Future[None]:
"""
with self._lock:
if self._closed:
# Do nothing if the result is already closed.
return ImmediateFuture(None)
error = HazelcastSqlError(
self._sql_service.get_client_id(),
_SqlErrorCode.CANCELLED_BY_USER,
"Query was cancelled by the user",
None,
)
if not self._fetch_future:
# Make sure that all subsequent fetches will fail.
self._fetch_future = Future()
self._on_fetch_error(error)
def wrap_error_on_failure(f):
# If the close request is failed somehow,
# wrap it in a HazelcastSqlError.
try:
return f.result()
except Exception as e:
raise self._sql_service.re_raise(e, self._connection)
self._closed = True
# Send the close request
return self._sql_service.close(
self._connection,
self._query_id).continue_with(wrap_error_on_failure)
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_add_callback_with_success(self):
f = Future()
e = Event()
def set_result():
f.set_result("done")
def callback(future):
self.assertEqual(future.result(), "done")
e.set()
f.add_done_callback(callback)
Thread(target=set_result).start()
self.assertTrue(e.wait(timeout=5))
def test_add_callback_with_success(self):
f = Future()
e = Event()
def set_result():
f.set_result("done")
def callback(future):
self.assertEqual(future.result(), "done")
e.set()
f.add_done_callback(callback)
Thread(target=set_result).start()
self.assertTrue(e.wait(timeout=5))
def _fetch_next_page(self):
"""Fetches the next page, if there is no fetch request
in-flight.
Returns:
Future[_SqlPage]:
"""
with self._lock:
if self._fetch_future:
# A fetch request is already in-flight, return it.
return self._fetch_future
future = Future()
self._fetch_future = future
self._sql_service.fetch(
self._connection, self._query_id,
self._cursor_buffer_size).add_done_callback(
self._handle_fetch_response)
# Need to return future, not self._fetch_future, because through
# some unlucky timing, we might call _handle_fetch_response
# before returning, which could set self._fetch_future to
# None.
return future
def test_set_exception(self):
f = Future()
exc = []
def set_exception():
try:
{}["invalid_key"]
except KeyError as e:
exc.append(sys.exc_info())
f.set_exception(e, sys.exc_info()[2])
Thread(target=set_exception).start()
exception = f.exception()
traceback = f.traceback()
exc = exc[0]
self.assertEqual(exc[1], exception)
self.assertEqual(exc[2], traceback)
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 test_set_exception(self):
f = Future()
exc = []
def set_exception():
try:
{}["invalid_key"]
except KeyError as e:
exc.append(sys.exc_info())
f.set_exception(e, sys.exc_info()[2])
Thread(target=set_exception).start()
exception = f.exception()
traceback = f.traceback()
exc = exc[0]
self.assertEqual(exc[1], exception)
self.assertEqual(exc[2], traceback)
def test_callback_called_exactly_once_when_exception(self):
for _ in range(0, 10000):
f = Future()
def set_exception():
f.set_exception(RuntimeError("error"))
t = Thread(target=set_exception)
t.start()
i = [0]
def callback(c):
i[0] += 1
f.add_done_callback(callback)
t.join()
self.assertEqual(i[0], 1)
def test_callback_called_exactly_once(self):
for _ in range(0, 10000):
f = Future()
def set_result():
f.set_result("done")
t = Thread(target=set_result)
t.start()
i = [0]
def callback(c):
i[0] += 1
f.add_done_callback(callback)
t.join()
self.assertEqual(i[0], 1)
def test_callback_called_exactly_once(self):
for _ in xrange(0, 10000):
f = Future()
def set_result():
f.set_result("done")
t = Thread(target=set_result)
t.start()
i = [0]
def callback(c):
i[0] += 1
f.add_done_callback(callback)
t.join()
self.assertEqual(i[0], 1)
def test_callback_called_exactly_once_when_exception(self):
for _ in xrange(0, 10000):
f = Future()
def set_exception():
f.set_exception(RuntimeError("error"))
t = Thread(target=set_exception)
t.start()
i = [0]
def callback(c):
i[0] += 1
f.add_done_callback(callback)
t.join()
self.assertEqual(i[0], 1)
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 test_result_raises_exception_with_traceback(self):
f = Future()
exc_info = None
try:
{}["invalid_key"]
except KeyError as e:
exc_info = sys.exc_info()
f.set_exception(e, sys.exc_info()[2])
try:
f.result()
self.fail("Future.result() should raise exception")
except:
info = sys.exc_info()
self.assertEqual(info[1], exc_info[1])
original_tb = traceback.extract_tb(exc_info[2])
# shift traceback by one to discard the last frame
actual_tb = traceback.extract_tb(info[2])[1:]
self.assertEqual(original_tb, actual_tb)
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 read_many(self, start_sequence, min_count, max_count):
"""Reads a batch of items from the Ringbuffer.
If the number of available items after the first read item is smaller than the max_count,
these items are returned. So it could be the number of items read is smaller than the max_count.
If there are less items available than min_count, then this call blocks. Reading a batch of items
is likely to perform better because less overhead is involved.
Args:
start_sequence (int): The start_sequence of the first item to read.
min_count (int): The minimum number of items to read.
max_count (int): The maximum number of items to read.
Returns:
hazelcast.future.Future[list]: The list of read items.
"""
check_not_negative(start_sequence, "sequence can't be smaller than 0")
check_true(max_count >= min_count,
"max count should be greater or equal to min count")
check_true(max_count < MAX_BATCH_SIZE,
"max count can't be greater than %d" % MAX_BATCH_SIZE)
future = Future()
request = ringbuffer_read_many_codec.encode_request(
self.name, start_sequence, min_count, max_count, None)
def handler(message):
return ImmutableLazyDataList(
ringbuffer_read_many_codec.decode_response(message)["items"],
self._to_object)
def check_capacity(capacity):
try:
capacity = capacity.result()
check_true(
min_count <= capacity,
"min count: %d should be smaller or equal to capacity: %d"
% (min_count, capacity),
)
f = self._invoke(request, handler)
f.add_done_callback(set_result)
except Exception as e:
future.set_exception(e)
def set_result(f):
try:
future.set_result(f.result())
except Exception as e:
future.set_exception(e)
self.capacity().add_done_callback(check_capacity)
return future
def test_get_exception_from_reactor_thread(self):
f = Future()
e = Event()
def get_result():
f._threading_locals.is_reactor_thread = True
try:
f.exception()
except RuntimeError:
e.set()
Thread(target=get_result).start()
self.assertTrue(e.wait(5), "event was not set")
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_add_callback_with_failure(self):
f = Future()
e = Event()
exc = []
def set_exception():
map = {}
try:
a = map["invalid_key"]
except KeyError as e:
exc.append(sys.exc_info())
f.set_exception(e, sys.exc_info()[2])
def callback(future):
exc_info = exc[0]
self.assertEqual(exc_info[1], future.exception())
self.assertEqual(exc_info[2], future.traceback())
e.set()
f.add_done_callback(callback)
Thread(target=set_exception).start()
self.assertTrue(e.wait(timeout=5))
def test_add_callback_with_failure(self):
f = Future()
e = Event()
exc = []
def set_exception():
map = {}
try:
a = map["invalid_key"]
except KeyError as e:
exc.append(sys.exc_info())
f.set_exception(e, sys.exc_info()[2])
def callback(future):
exc_info = exc[0]
self.assertEqual(exc_info[1], future.exception())
self.assertEqual(exc_info[2], future.traceback())
e.set()
f.add_done_callback(callback)
Thread(target=set_exception).start()
self.assertTrue(e.wait(timeout=5))
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_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 new_id(self):
while True:
block = self._block
next_id = block.next_id()
if next_id is not None:
return ImmediateFuture(next_id)
with self._lock:
# new block was assigned in the meantime
if block is not self._block:
continue
future = Future()
self._id_queue.append(future)
if not self._request_in_air:
self._request_in_air = True
self._request_new_batch()
return future
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_set_exception_with_non_exception(self):
f = Future()
with self.assertRaises(RuntimeError):
f.set_exception("non-exception")
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
