void
zyre_node_actor (zsock_t *pipe, void *args)
{
// Create node instance to pass around
zyre_node_t *self = zyre_node_new (pipe, args);
if (!self) // Interrupted
return;
// Signal actor successfully initialized
zsock_signal (self->pipe, 0);
// Loop until the agent is terminated one way or another
int64_t reap_at = zclock_time () + REAP_INTERVAL;
while (!self->terminated) {
int timeout = (int) (reap_at - zclock_time ());
if (timeout > REAP_INTERVAL)
timeout = REAP_INTERVAL;
else
if (timeout < 0)
timeout = 0;
zsock_t *which = (zsock_t *) zpoller_wait (self->poller, timeout);
if (which == self->pipe)
zyre_node_recv_api (self);
else
if (which == self->inbox)
zyre_node_recv_peer (self);
else
if (self->beacon
&& (void *) which == self->beacon)
zyre_node_recv_beacon (self);
else
if (self->gossip
&& (zactor_t *) which == self->gossip)
zyre_node_recv_gossip (self);
else
if (zpoller_terminated (self->poller))
break; // Interrupted, check before expired
else
if (zpoller_expired (self->poller)) {
if (zclock_time () >= reap_at) {
reap_at = zclock_time () + REAP_INTERVAL;
// Ping all peers and reap any expired ones
zhash_foreach (self->peers, (zhash_foreach_fn *) zyre_node_ping_peer, self);
}
}
}
zyre_node_destroy (&self);
}
void
zyre_node_engine (void *args, zctx_t *ctx, void *pipe)
{
// Create node instance to pass around
zyre_node_t *self = zyre_node_new (ctx, pipe);
if (!self) // Interrupted
return;
zsocket_signal (self->pipe);
uint64_t reap_at = zclock_time () + REAP_INTERVAL;
zpoller_t *poller = zpoller_new (
self->pipe, self->inbox, zbeacon_socket (self->beacon), NULL);
while (!zpoller_terminated (poller)) {
if (self->terminated)
break;
int timeout = (int) (reap_at - zclock_time ());
assert (timeout <= REAP_INTERVAL);
if (timeout < 0)
timeout = 0;
void *which = zpoller_wait (poller, timeout);
if (which == self->pipe)
zyre_node_recv_api (self);
else
if (which == self->inbox)
zyre_node_recv_peer (self);
else
if (which == zbeacon_socket (self->beacon))
zyre_node_recv_beacon (self);
else
if (zpoller_expired(poller)) {
if (zclock_time () >= reap_at) {
reap_at = zclock_time () + REAP_INTERVAL;
// Ping all peers and reap any expired ones
zhash_foreach (self->peers, zyre_node_ping_peer, self);
}
}
else
if (zpoller_terminated(poller))
break;
else
// This should never happen
assert(false);
}
zpoller_destroy (&poller);
zyre_node_destroy (&self);
}
void
zyre_node_actor (zsock_t *pipe, void *args)
{
// Create node instance to pass around
zyre_node_t *self = zyre_node_new (pipe, args);
if (!self) // Interrupted
return;
// Signal actor successfully initialized
zsock_signal (self->pipe, 0);
// Loop until the agent is terminated one way or another
int64_t reap_at = zclock_mono () + REAP_INTERVAL;
while (!self->terminated) {
// Start beacon as soon as we can
if (self->beacon && self->port <= 0) {
// Our hostname is provided by zbeacon
zsock_send(self->beacon, "si", "CONFIGURE", self->beacon_port);
char *hostname = zstr_recv(self->beacon);
// Is UDP broadcast interface available?
if (!streq(hostname, "")) {
if (zsys_ipv6())
self->port = zsock_bind(self->inbox, "tcp://%s%%%s:*", zsys_ipv6_address(), zsys_interface());
else
self->port = zsock_bind(self->inbox, "tcp://%s:*", hostname);
if (self->port > 0) {
assert(!self->endpoint); // If caller set this, we'd be using gossip
if (streq(zsys_interface(), "*")) {
char *hostname = zsys_hostname();
self->endpoint = zsys_sprintf("tcp://%s:%d", hostname, self->port);
zstr_free(&hostname);
}
else {
self->endpoint = strdup(zsock_endpoint(self->inbox));
}
// Set broadcast/listen beacon
beacon_t beacon;
beacon.protocol[0] = 'Z';
beacon.protocol[1] = 'R';
beacon.protocol[2] = 'E';
beacon.version = BEACON_VERSION;
beacon.port = htons(self->port);
zuuid_export(self->uuid, beacon.uuid);
zsock_send(self->beacon, "sbi", "PUBLISH",
(byte *)&beacon, sizeof(beacon_t), self->interval);
zsock_send(self->beacon, "sb", "SUBSCRIBE", (byte *) "ZRE", 3);
zpoller_add(self->poller, self->beacon);
// Start polling on inbox
zpoller_add(self->poller, self->inbox);
}
}
zstr_free(&hostname);
}
int timeout = (int) (reap_at - zclock_mono ());
if (timeout > REAP_INTERVAL)
timeout = REAP_INTERVAL;
else
if (timeout < 0)
timeout = 0;
zsock_t *which = (zsock_t *) zpoller_wait (self->poller, timeout);
if (which == self->pipe)
zyre_node_recv_api (self);
else
if (which == self->inbox)
zyre_node_recv_peer (self);
else
if (self->beacon
&& (void *) which == self->beacon)
zyre_node_recv_beacon (self);
else
if (self->gossip
&& (zactor_t *) which == self->gossip)
zyre_node_recv_gossip (self);
else
if (zpoller_terminated (self->poller))
break; // Interrupted, check before expired
else
if (zpoller_expired (self->poller)) {
if (zclock_mono () >= reap_at) {
void *item;
reap_at = zclock_mono () + REAP_INTERVAL;
// Ping all peers and reap any expired ones
for (item = zhash_first (self->peers); item != NULL;
item = zhash_next (self->peers))
zyre_node_ping_peer (zhash_cursor (self->peers), item, self);
}
}
}
zyre_node_destroy (&self);
}
