static void
zyre_node_remove_peer (zyre_node_t *self, zyre_peer_t *peer)
{
// Tell the calling application the peer has gone
zstr_sendm (self->pipe, "EXIT");
zstr_send (self->pipe, zyre_peer_identity (peer));
// Send a log event
zyre_log_info (self->log, ZRE_LOG_MSG_EVENT_EXIT,
zyre_peer_endpoint (peer),
zyre_peer_endpoint (peer));
// Remove peer from any groups we've got it in
zhash_foreach (self->peer_groups, zyre_node_delete_peer, peer);
// To destroy peer, we remove from peers hash table
zhash_delete (self->peers, zyre_peer_identity (peer));
}
static int
zyre_node_ping_peer (const char *key, void *item, void *argument)
{
zyre_peer_t *peer = (zyre_peer_t *) item;
zyre_node_t *self = (zyre_node_t *) argument;
if (zclock_mono () >= zyre_peer_expired_at (peer)) {
if (self->verbose)
zsys_info ("(%s) peer expired name=%s endpoint=%s",
self->name, zyre_peer_name (peer), zyre_peer_endpoint (peer));
zyre_node_remove_peer (self, peer);
}
else
if (zclock_mono () >= zyre_peer_evasive_at (peer)) {
// If peer is being evasive, force a TCP ping.
// TODO: do this only once for a peer in this state;
// it would be nicer to use a proper state machine
// for peer management.
if (self->verbose)
zsys_info ("(%s) peer seems dead/slow name=%s endpoint=%s",
self->name, zyre_peer_name (peer), zyre_peer_endpoint (peer));
zre_msg_t *msg = zre_msg_new (ZRE_MSG_PING);
zyre_peer_send (peer, &msg);
// Inform the calling application this peer is being evasive
zstr_sendm (self->outbox, "EVASIVE");
zstr_sendm (self->outbox, zyre_peer_identity (peer));
zstr_send (self->outbox, zyre_peer_name (peer));
}
return 0;
}
static void
zyre_node_remove_peer (zyre_node_t *self, zyre_peer_t *peer)
{
// Tell the calling application the peer has gone
zstr_sendm (self->outbox, "EXIT");
zstr_sendm (self->outbox, zyre_peer_identity (peer));
zstr_send (self->outbox, zyre_peer_name (peer));
if (self->verbose)
zsys_info ("(%s) EXIT name=%s endpoint=%s",
self->name, zyre_peer_name (peer), zyre_peer_endpoint (peer));
// Remove peer from any groups we've got it in
zhash_foreach (self->peer_groups, (zhash_foreach_fn *) zyre_node_delete_peer, peer);
// To destroy peer, we remove from peers hash table
zhash_delete (self->peers, zyre_peer_identity (peer));
}
void
zyre_group_join (zyre_group_t *self, zyre_peer_t *peer)
{
assert (self);
assert (peer);
zhash_insert (self->peers, zyre_peer_identity (peer), peer);
zyre_peer_set_status (peer, zyre_peer_status (peer) + 1);
}
void
zyre_group_leave (zyre_group_t *self, zyre_peer_t *peer)
{
assert (self);
assert (peer);
zhash_delete (self->peers, zyre_peer_identity (peer));
zyre_peer_set_status (peer, zyre_peer_status (peer) + 1);
}
static void
zyre_node_remove_peer (zyre_node_t *self, zyre_peer_t *peer)
{
void *item;
// Tell the calling application the peer has gone
zstr_sendm (self->outbox, "EXIT");
zstr_sendm (self->outbox, zyre_peer_identity (peer));
zstr_send (self->outbox, zyre_peer_name (peer));
if (self->verbose)
zsys_info ("(%s) EXIT name=%s endpoint=%s",
self->name, zyre_peer_name (peer), zyre_peer_endpoint (peer));
// Remove peer from any groups we've got it in
for (item = zhash_first (self->peer_groups); item != NULL;
item = zhash_next (self->peer_groups))
zyre_node_delete_peer (zhash_cursor (self->peer_groups), item, peer);
// To destroy peer, we remove from peers hash table
zhash_delete (self->peers, zyre_peer_identity (peer));
}
static zyre_group_t *
zyre_node_leave_peer_group (zyre_node_t *self, zyre_peer_t *peer, char *name)
{
zyre_group_t *group = zyre_node_require_peer_group (self, name);
zyre_group_leave (group, peer);
// Now tell the caller about the peer left group
zstr_sendm (self->pipe, "LEAVE");
zstr_sendm (self->pipe, zyre_peer_identity (peer));
zstr_send (self->pipe, name);
return group;
}
static zyre_group_t *
zyre_node_join_peer_group (zyre_node_t *self, zyre_peer_t *peer, char *name)
{
zyre_group_t *group = zyre_node_require_peer_group (self, name);
zyre_group_join (group, peer);
// Now tell the caller about the peer joined group
zstr_sendm (self->pipe, "JOIN");
zstr_sendm (self->pipe, zyre_peer_identity (peer));
zstr_send (self->pipe, name);
return group;
}
static zyre_group_t *
zyre_node_leave_peer_group (zyre_node_t *self, zyre_peer_t *peer, const char *name)
{
zyre_group_t *group = zyre_node_require_peer_group (self, name);
zyre_group_leave (group, peer);
// Now tell the caller about the peer left group
zstr_sendm (self->outbox, "LEAVE");
zstr_sendm (self->outbox, zyre_peer_identity (peer));
zstr_sendm (self->outbox, zyre_peer_name (peer));
zstr_send (self->outbox, name);
if (self->verbose)
zsys_info ("(%s) LEAVE name=%s group=%s",
self->name, zyre_peer_name (peer), name);
return group;
}
static void
zyre_node_recv_peer (zyre_node_t *self)
{
// Router socket tells us the identity of this peer
zre_msg_t *msg = zre_msg_recv (self->inbox);
if (!msg)
return; // Interrupted
// First frame is sender identity
byte *peerid_data = zframe_data (zre_msg_routing_id (msg));
size_t peerid_size = zframe_size (zre_msg_routing_id (msg));
// Identity must be [1] followed by 16-byte UUID
if (peerid_size != ZUUID_LEN + 1) {
zre_msg_destroy (&msg);
return;
}
zuuid_t *uuid = zuuid_new ();
zuuid_set (uuid, peerid_data + 1);
// On HELLO we may create the peer if it's unknown
// On other commands the peer must already exist
zyre_peer_t *peer = (zyre_peer_t *) zhash_lookup (self->peers, zuuid_str (uuid));
if (zre_msg_id (msg) == ZRE_MSG_HELLO) {
if (peer) {
// Remove fake peers
if (zyre_peer_ready (peer)) {
zyre_node_remove_peer (self, peer);
assert (!(zyre_peer_t *) zhash_lookup (self->peers, zuuid_str (uuid)));
}
else
if (streq (zyre_peer_endpoint (peer), self->endpoint)) {
// We ignore HELLO, if peer has same endpoint as current node
zre_msg_destroy (&msg);
zuuid_destroy (&uuid);
return;
}
}
peer = zyre_node_require_peer (self, uuid, zre_msg_endpoint (msg));
assert (peer);
zyre_peer_set_ready (peer, true);
}
// Ignore command if peer isn't ready
if (peer == NULL || !zyre_peer_ready (peer)) {
zre_msg_destroy (&msg);
zuuid_destroy (&uuid);
return;
}
if (zyre_peer_messages_lost (peer, msg)) {
zsys_warning ("(%s) messages lost from %s", self->name, zyre_peer_name (peer));
zyre_node_remove_peer (self, peer);
zre_msg_destroy (&msg);
zuuid_destroy (&uuid);
return;
}
// Now process each command
if (zre_msg_id (msg) == ZRE_MSG_HELLO) {
// Store properties from HELLO command into peer
zyre_peer_set_name (peer, zre_msg_name (msg));
zyre_peer_set_headers (peer, zre_msg_headers (msg));
// Tell the caller about the peer
zstr_sendm (self->outbox, "ENTER");
zstr_sendm (self->outbox, zyre_peer_identity (peer));
zstr_sendm (self->outbox, zyre_peer_name (peer));
zframe_t *headers = zhash_pack (zyre_peer_headers (peer));
zframe_send (&headers, self->outbox, ZFRAME_MORE);
zstr_send (self->outbox, zre_msg_endpoint (msg));
if (self->verbose)
zsys_info ("(%s) ENTER name=%s endpoint=%s",
self->name, zyre_peer_name (peer), zyre_peer_endpoint (peer));
// Join peer to listed groups
const char *name = zre_msg_groups_first (msg);
while (name) {
zyre_node_join_peer_group (self, peer, name);
name = zre_msg_groups_next (msg);
}
// Now take peer's status from HELLO, after joining groups
zyre_peer_set_status (peer, zre_msg_status (msg));
}
else
if (zre_msg_id (msg) == ZRE_MSG_WHISPER) {
// Pass up to caller API as WHISPER event
zstr_sendm (self->outbox, "WHISPER");
zstr_sendm (self->outbox, zuuid_str (uuid));
zstr_sendm (self->outbox, zyre_peer_name (peer));
zmsg_t *content = zmsg_dup (zre_msg_content (msg));
zmsg_send (&content, self->outbox);
}
else
if (zre_msg_id (msg) == ZRE_MSG_SHOUT) {
// Pass up to caller as SHOUT event
zstr_sendm (self->outbox, "SHOUT");
zstr_sendm (self->outbox, zuuid_str (uuid));
zstr_sendm (self->outbox, zyre_peer_name (peer));
zstr_sendm (self->outbox, zre_msg_group (msg));
zmsg_t *content = zmsg_dup (zre_msg_content (msg));
zmsg_send (&content, self->outbox);
}
else
if (zre_msg_id (msg) == ZRE_MSG_PING) {
zre_msg_t *msg = zre_msg_new (ZRE_MSG_PING_OK);
zyre_peer_send (peer, &msg);
}
else
if (zre_msg_id (msg) == ZRE_MSG_JOIN) {
zyre_node_join_peer_group (self, peer, zre_msg_group (msg));
assert (zre_msg_status (msg) == zyre_peer_status (peer));
}
else
if (zre_msg_id (msg) == ZRE_MSG_LEAVE) {
zyre_node_leave_peer_group (self, peer, zre_msg_group (msg));
assert (zre_msg_status (msg) == zyre_peer_status (peer));
}
zuuid_destroy (&uuid);
zre_msg_destroy (&msg);
// Activity from peer resets peer timers
zyre_peer_refresh (peer, self->evasive_timeout, self->expired_timeout);
}
