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())