def setUp(self): try: raise RuntimeError("error") except: self.exc = sys.exc_info()[1] self.traceback = sys.exc_info()[2] self.f = ImmediateExceptionFuture(self.exc, self.traceback)
def test_heartbeat_on_failure(self): reactor = self.mock_reactor() self.mock_request_new_session() self.manager._request_heartbeat = MagicMock( return_value=ImmediateExceptionFuture(SessionExpiredError())) m = MagicMock(side_effect=self.manager.invalidate_session) self.manager.invalidate_session = m self.manager.acquire_session(self.raft_group_id, 1).result() time.sleep(2) self.manager.shutdown() reactor.shutdown() self.assertGreater(self.context.reactor.add_timer.call_count, 1) # assert that the heartbeat task is executed m.assert_called_once_with(self.raft_group_id, self.session_id) self.assertEqual(0, len(self.manager._sessions))
def get_or_connect(self, address, authenticator=None): """ Gets the existing connection for a given address. If it does not exist, the system will try to connect asynchronously. In this case, it returns a Future. When the connection is established at some point in time, it can be retrieved by using the get_connection(:class:`~hazelcast.core.Address`) or from Future. :param address: (:class:`~hazelcast.core.Address`), the address to connect to. :param authenticator: (Function), function to be used for authentication (optional). :return: (:class:`~hazelcast.connection.Connection`), the existing connection or it returns a Future which includes asynchronously. """ if address in self.connections: return ImmediateFuture(self.connections[address]) else: with self._new_connection_mutex: if address in self._pending_connections: return self._pending_connections[address] else: authenticator = authenticator or self._cluster_authenticator try: translated_address = self._address_translator.translate( address) if translated_address is None: raise ValueError( "Address translator could not translate address: {}" .format(address)) connection = self._new_connection_func( translated_address, self._client.config.network_config. connection_timeout, self._client.config.network_config.socket_options, connection_closed_callback=self._connection_closed, message_callback=self._client.invoker. _handle_client_message, network_config=self._client.config.network_config) except IOError: return ImmediateExceptionFuture( sys.exc_info()[1], sys.exc_info()[2]) future = authenticator(connection).continue_with( self.on_auth, connection, address) if not future.done(): self._pending_connections[address] = future return future
def release(self, permits=1): check_true(permits > 0, "Permits must be positive") session_id = self._get_session_id() if session_id == _NO_SESSION_ID: return ImmediateExceptionFuture(self._new_illegal_state_error()) current_thread_id = thread_id() invocation_uuid = uuid.uuid4() def check_response(response): try: response.result() except SessionExpiredError as e: self._invalidate_session(session_id) raise self._new_illegal_state_error(e) finally: self._release_session(session_id, permits) return self._request_release(session_id, current_thread_id, invocation_uuid, permits).continue_with( check_response)
def get_or_connect(self, address, authenticator=None): if address in self.connections: return ImmediateFuture(self.connections[address]) else: with self._new_connection_mutex: if address in self._pending_connections: return self._pending_connections[address] else: authenticator = authenticator or self._cluster_authenticator try: connection = self._new_connection_func(address, self._client.config.network_config.connection_timeout, self._client.config.network_config.socket_options, connection_closed_callback=self._connection_closed, message_callback=self._client.invoker._handle_client_message) except IOError: return ImmediateExceptionFuture(sys.exc_info()[1], sys.exc_info()[2]) future = authenticator(connection).continue_with(self.on_auth, connection, address) if not future.done(): self._pending_connections[address] = future return future
def mock(*_, **__): if called.get_and_increment() == 0 and first_call_err: return ImmediateExceptionFuture(first_call_err) return ImmediateFuture(result)
class ImmediateExceptionFutureTest(unittest.TestCase): f = None def setUp(self): try: raise RuntimeError("error") except: self.exc = sys.exc_info()[1] self.traceback = sys.exc_info()[2] self.f = ImmediateExceptionFuture(self.exc, self.traceback) def test_result(self): with self.assertRaises(type(self.exc)): self.f.result() def test_exception(self): self.assertEqual(self.exc, self.f.exception()) def test_traceback(self): self.assertEqual(self.traceback, self.f.traceback()) def test_set_result(self): with self.assertRaises(NotImplementedError): self.f.set_result("done") def test_set_exception(self): with self.assertRaises(NotImplementedError): self.f.set_exception(RuntimeError()) def test_is_succcess(self): self.assertFalse(self.f.is_success()) def test_is_done(self): self.assertTrue(self.f.done()) def test_is_not_running(self): self.assertFalse(self.f.running()) def test_callback(self): n = [0] def callback(f): self.assertEqual(f, self.f) n[0] += 1 self.f.add_done_callback(callback) self.assertEqual(n[0], 1)
def mock(expected_round, invocation_uuid): if called_count.get_and_increment() < 2: return ImmediateExceptionFuture(OperationTimeoutError("xx")) return original(expected_round, invocation_uuid)
def execute(self, sql, params, cursor_buffer_size, timeout, expected_result_type, schema): """Constructs a statement and executes it. Args: sql (str): SQL string. params (tuple): Query parameters. cursor_buffer_size (int): Cursor buffer size. timeout (float): Timeout of the query. expected_result_type (SqlExpectedResultType): Expected result type of the query. schema (str or None): The schema name. Returns: hazelcast.future.Future[SqlResult]: The execution result. """ statement = _SqlStatement(sql, params, cursor_buffer_size, timeout, expected_result_type, schema) connection = None try: try: # Serialize the passed parameters. serialized_params = [ self._serialization_service.to_data(param) for param in statement.parameters ] except SchemaNotReplicatedError as e: return self._send_schema_and_retry_fn( e, self.execute, sql, params, cursor_buffer_size, timeout, expected_result_type, schema, ) connection = self._get_query_connection() # Create a new, unique query id. query_id = _SqlQueryId.from_uuid(connection.remote_uuid) request = sql_execute_codec.encode_request( statement.sql, serialized_params, # to_millis expects None to produce -1 to_millis(None if statement.timeout == -1 else statement.timeout), statement.cursor_buffer_size, statement.schema, statement.expected_result_type, query_id, False, ) invocation = Invocation( request, connection=connection, response_handler=sql_execute_codec.decode_response) self._invocation_service.invoke(invocation) return invocation.future.continue_with(lambda future: SqlResult( self, connection, query_id, statement.cursor_buffer_size, self._handle_execute_response(future, connection), )) except Exception as e: return ImmediateExceptionFuture(self.re_raise(e, connection))
def read_many_mock(*_): if next(counter) == 0: return ImmediateExceptionFuture(error) return Future()
def prepare_thread_id(self, thread_id, err=None): if err: value = ImmediateExceptionFuture(err) else: value = ImmediateFuture(thread_id) self.session_manager.get_or_create_unique_thread_id = MagicMock(return_value=value)