def _detect_membership_events(self, old, new):
new_members = []
dead_members = set(six.itervalues(old.members))
for member in six.itervalues(new.members):
try:
dead_members.remove(member)
except KeyError:
new_members.append(member)
for dead_member in dead_members:
connection = self._connection_manager.get_connection(
dead_member.uuid)
if connection:
connection.close(
None,
TargetDisconnectedError(
"The client has closed the connection to this member, "
"after receiving a member left event from the cluster. "
"%s" % connection),
)
if (len(new_members) + len(dead_members)) > 0:
if len(new.members) > 0:
_logger.info(self._members_string(new))
return dead_members, new_members
def shutdown(self):
if not self.live:
return
self.live = False
if self._connect_all_members_timer:
self._connect_all_members_timer.cancel()
self._heartbeat_manager.shutdown()
with self._lock:
for connection_future in six.itervalues(self._pending_connections):
connection_future.set_exception(
HazelcastClientNotActiveError(
"Hazelcast client is shutting down"))
# Need to create copy of connection values to avoid modification errors on runtime
for connection in list(six.itervalues(self.active_connections)):
connection.close("Hazelcast client is shutting down", None)
self.active_connections.clear()
self._addresses_to_connections.clear()
self._pending_connections.clear()
del self._connection_listeners[:]
def register_listener(self, registration_request, decode_register_response,
encode_deregister_request, handler):
with self._registration_lock:
registration_id = str(uuid4())
registration = _ListenerRegistration(registration_request,
decode_register_response,
encode_deregister_request,
handler)
self._active_registrations[registration_id] = registration
futures = []
for connection in list(
six.itervalues(
self._connection_manager.active_connections)):
future = self._register_on_connection(registration_id,
registration, connection)
futures.append(future)
def handler(f):
try:
f.result()
return registration_id
except:
self.deregister_listener(registration_id)
raise HazelcastError("Listener cannot be added")
return combine_futures(futures).continue_with(handler)
def _connection_removed(self, connection, _):
with self._registration_lock:
for listener_registration in six.itervalues(self._active_registrations):
event_registration = listener_registration.connection_registrations.pop(
connection, None
)
if event_registration:
self.remove_event_handler(event_registration.correlation_id)
def _fire_membership_events(self, dead_members, new_members):
# Removal events should be fired first
for dead_member in dead_members:
for _, handler in six.itervalues(self._listeners):
if handler:
try:
handler(dead_member)
except:
_logger.exception("Exception in membership listener")
for new_member in new_members:
for handler, _ in six.itervalues(self._listeners):
if handler:
try:
handler(new_member)
except:
_logger.exception("Exception in membership listener")
def shutdown(self):
if self._shutdown:
return
self._shutdown = True
if self._clean_resources_timer:
self._clean_resources_timer.cancel()
for invocation in list(six.itervalues(self._pending)):
self._notify_error(invocation, HazelcastClientNotActiveError())
def _heartbeat():
conn_manager = self._connection_manager
if not conn_manager.live:
return
now = time.time()
for connection in list(six.itervalues(conn_manager.active_connections)):
self._check_connection(now, connection)
self._heartbeat_timer = self._reactor.add_timer(self._heartbeat_interval, _heartbeat)
def add_listener(self, member_added=None, member_removed=None, fire_for_existing=False):
registration_id = str(uuid.uuid4())
self._listeners[registration_id] = (member_added, member_removed)
if fire_for_existing and member_added:
snapshot = self._member_list_snapshot
for member in six.itervalues(snapshot.members):
member_added(member)
return registration_id
def get_members(self, member_selector=None):
snapshot = self._member_list_snapshot
if not member_selector:
return list(snapshot.members.values())
members = []
for member in six.itervalues(snapshot.members):
if member_selector(member):
members.append(member)
return members
def get_members(self, member_selector=None):
# type: (Callable[[MemberInfo], bool]) -> List[MemberInfo]
snapshot = self._member_list_snapshot
if not member_selector:
return list(snapshot.members.values())
members = []
for member in six.itervalues(snapshot.members):
if member_selector(member):
members.append(member)
return members
def _apply_new_state_and_fire_events(self, current, snapshot):
self._member_list_snapshot = snapshot
removals, additions = self._detect_membership_events(current, snapshot)
# Removal events should be fired first
for removed_member in removals:
for _, handler in six.itervalues(self._listeners):
if handler:
try:
handler(removed_member)
except:
_logger.exception("Exception in membership listener")
for added_member in additions:
for handler, _ in six.itervalues(self._listeners):
if handler:
try:
handler(added_member)
except:
_logger.exception("Exception in membership listener")
def fire_lifecycle_event(self, new_state):
self.logger.info(self._git_info + "HazelcastClient is %s",
new_state,
extra=self._logger_extras)
for on_state_change in six.itervalues(self._listeners):
if on_state_change:
try:
on_state_change(new_state)
except:
self.logger.exception("Exception in lifecycle listener",
extra=self._logger_extras)
def get_field(self, field_name_or_index):
if isinstance(field_name_or_index, int):
index = field_name_or_index
count = self.get_field_count()
if 0 <= index < count:
for field in six.itervalues(self.field_defs):
if field.index == index:
return field
raise IndexError("Index is out of bound. Index: {} and size: {}".format(index, count))
else:
return self.field_defs.get(field_name_or_index, None)
def _get_or_connect_to_address(self, address):
for connection in list(six.itervalues(self.active_connections)):
if connection.remote_address == address:
return ImmediateFuture(connection)
try:
translated = self._translate(address)
connection = self._create_connection(translated)
return self._authenticate(connection).continue_with(self._on_auth, connection)
except Exception as e:
return ImmediateExceptionFuture(e)
def get_random_connection(self):
if self._smart_routing_enabled:
member = self._load_balancer.next()
if member:
connection = self.get_connection(member.uuid)
if connection:
return connection
for connection in six.itervalues(self.active_connections):
return connection
return None
def destroy(self):
"""
Destroys underlying Proxy and RingBuffer instances.
"""
for runner in list(six.itervalues(self._runners)):
runner.cancel()
self._runners.clear()
super(ReliableTopic, self).destroy()
return self._ringbuffer.destroy()
def fire_lifecycle_event(self, new_state):
"""Called when instance's state changes.
Args:
new_state (str): The new state of the instance.
"""
_logger.info("HazelcastClient %s is %s", __version__, new_state)
for on_state_change in six.itervalues(self._listeners):
if on_state_change:
try:
on_state_change(new_state)
except:
_logger.exception("Exception in lifecycle listener")
def get_random_connection(self):
if self._smart_routing_enabled:
member = self._load_balancer.next()
if member:
connection = self.get_connection(member.uuid)
if connection:
return connection
# We should not get to this point under normal circumstances.
# Therefore, copying the list should be OK.
for connection in list(six.itervalues(self.active_connections)):
return connection
return None
def shutdown(self):
if not self.live:
return
self.live = False
if self._connect_all_members_timer:
self._connect_all_members_timer.cancel()
self._heartbeat_manager.shutdown()
# Need to create copy of connection values to avoid modification errors on runtime
for connection in list(six.itervalues(self.active_connections)):
connection.close("Hazelcast client is shutting down", None)
self.active_connections.clear()
del self._connection_listeners[:]
def _members_string(snapshot):
members = snapshot.members
n = len(members)
return "\n\nMembers [%s] {\n\t%s\n}\n" % (n, "\n\t".join(
map(str, six.itervalues(members))))
def get_connection_from_address(self, address):
for connection in six.itervalues(self.active_connections):
if address == connection.remote_address:
return connection
return None
def clear_near_caches(self):
for cache in six.itervalues(self._caches):
cache._clear()
def _members_string(members):
n = len(members)
return "\n\nMembers [%s] {\n\t%s\n}\n" % (n, "\n\t".join(map(str, six.itervalues(members))))
def shutdown(self):
self._shutdown = True
for invocation in list(six.itervalues(self._pending)):
self._handle_exception(invocation, HazelcastClientNotActiveError())
