void
drops_agent_main (void *args, zctx_t *ctx, void *pipe)
{
// Create agent instance to pass around
s_agent_t *self = s_agent_new (ctx, pipe);
if (!self) // Interrupted
return;
zstr_send (self->pipe, "OK");
// These are the sockets we will monitor for activity
zpoller_t *poller = zpoller_new (
self->pipe, zyre_socket (self->zyre), NULL);
while (!zpoller_terminated (poller)) {
// Check directory once a second; this is a pretty nasty way of
// doing it, but portable and simple. Later I'd like to use file
// system monitoring library and get events back over a socket.
void *which = zpoller_wait (poller, 1000);
if (which == self->pipe)
s_recv_from_api (self);
else
if (which == zyre_socket (self->zyre))
s_recv_from_zyre (self);
if (self->terminated)
break;
s_check_directory (self);
}
zpoller_destroy (&poller);
s_agent_destroy (&self);
}
static void
server_leave_cluster (server_t *self)
{
// Cancel reader for Zyre events
engine_handle_socket (self, zyre_socket (self->zyre), NULL);
zyre_destroy (&self->zyre);
}
int main (int argc, char *argv [])
{
zctx_t *ctx = zctx_new ();
// Use the CZMQ zbeacon class to make sure we listen on the
// same network interface as our peers
zbeacon_t *beacon = zbeacon_new (ctx, ZRE_DISCOVERY_PORT);
char *host = zbeacon_hostname (beacon);
// Bind to an ephemeral port
void *collector = zsocket_new (ctx, ZMQ_SUB);
int port = zsocket_bind (collector, "tcp://%s:*", host);
zsocket_set_subscribe (collector, "");
// Announce this to all peers we connect to
zyre_t *node = zyre_new (ctx);
zyre_set_header (node, "X-ZRELOG", "tcp://%s:%d", host, port);
zyre_start (node);
zpoller_t *poller = zpoller_new (collector, zyre_socket (node), NULL);
while (!zctx_interrupted) {
void *which = zpoller_wait (poller, -1);
if (which == collector)
s_print_log_msg (collector);
else if (which == zyre_socket (node)) {
zmsg_t *msg = zyre_recv (node);
if (!msg)
break; // Interrupted
zmsg_destroy (&msg);
}
else
break; // Interrupted
}
zyre_destroy (&node);
zbeacon_destroy (&beacon);
zctx_destroy (&ctx);
return 0;
}
static void
chat_task (void *args, zctx_t *ctx, void *pipe)
{
zyre_t *node = zyre_new (ctx);
zyre_start (node);
zyre_join (node, "CHAT");
zmq_pollitem_t items [] = {
{ pipe, 0, ZMQ_POLLIN, 0 },
{ zyre_socket (node), 0, ZMQ_POLLIN, 0 }
};
while (true) {
if (zmq_poll (items, 2, -1) == -1)
break; // Interrupted
// Activity on my pipe
if (items [0].revents & ZMQ_POLLIN) {
zmsg_t *msg = zmsg_recv (pipe);
zyre_shout (node, "CHAT", &msg);
}
// Activity on my node handle
if (items [1].revents & ZMQ_POLLIN) {
zmsg_t *msg = zyre_recv (node);
zmsg_dump (msg);
char *command = zmsg_popstr (msg);
if (streq (command, "SHOUT")) {
// Discard sender and group name
free (zmsg_popstr (msg));
free (zmsg_popstr (msg));
char *message = zmsg_popstr (msg);
printf ("%s", message);
free (message);
}
free (command);
zmsg_destroy (&msg);
}
}
zyre_destroy (&node);
}
static void
node_task (void *args, zctx_t *ctx, void *pipe)
{
zyre_t *node = zyre_new (ctx);
zyre_start (node);
int64_t counter = 0;
char *to_peer = NULL; // Either of these set,
char *to_group = NULL; // and we set a message
char *cookie = NULL; // received message
char *sending_cookie = NULL; // sending message
zmq_pollitem_t pollitems [] = {
{ pipe, 0, ZMQ_POLLIN, 0 },
{ zyre_socket (node), 0, ZMQ_POLLIN, 0 }
};
// all node joins GLOBAL
zyre_join (node, "GLOBAL");
while (!zctx_interrupted) {
if (zmq_poll (pollitems, 2, randof (1000) * ZMQ_POLL_MSEC) == -1)
break; // Interrupted
if (pollitems [0].revents & ZMQ_POLLIN)
break; // Any command from parent means EXIT
// Process an event from node
if (pollitems [1].revents & ZMQ_POLLIN) {
zmsg_t *incoming = zyre_recv (node);
if (!incoming)
break; // Interrupted
char *event = zmsg_popstr (incoming);
if (streq (event, "ENTER")) {
// Always say hello to new peer
to_peer = zmsg_popstr (incoming);
sending_cookie = "R:HELLO";
}
else
if (streq (event, "EXIT")) {
// Do nothing
}
else
if (streq (event, "WHISPER")) {
to_peer = zmsg_popstr (incoming);
cookie = zmsg_popstr (incoming);
// if a message comes from perf_local, send back a special response
if (streq (cookie, "S:WHISPER")) {
sending_cookie = "R:WHISPER";
}
else {
free (to_peer);
free (cookie);
to_peer = NULL;
cookie = NULL;
}
}
else
if (streq (event, "SHOUT")) {
to_peer = zmsg_popstr (incoming);
to_group = zmsg_popstr (incoming);
cookie = zmsg_popstr (incoming);
// if a message comes from perf_local, send back a special response
if (streq (cookie, "S:SHOUT")) {
free (to_peer);
to_peer = NULL;
sending_cookie = "R:SHOUT";
}
else {
free (to_peer);
free (to_group);
to_peer = NULL;
to_group = NULL;
}
}
free (event);
zmsg_destroy (&incoming);
// Send outgoing messages if needed
if (to_peer) {
zyre_whispers (node, to_peer, sending_cookie);
free (to_peer);
to_peer = NULL;
}
if (to_group) {
zyre_shouts (node, to_group, sending_cookie);
free (to_group);
to_group = NULL;
}
if (cookie) {
free (cookie);
cookie = NULL;
}
}
}
zyre_destroy (&node);
}
JNIEXPORT jlong JNICALL
Java_org_zeromq_zyre_Zyre__1_1socket (JNIEnv *env, jclass c, jlong self)
{
jlong socket_ = (jlong) (intptr_t) zyre_socket ((zyre_t *) (intptr_t) self);
return socket_;
}
///
// Return socket for talking to the Zyre node, for polling
zsock_t *QmlZyre::socket () {
return zyre_socket (self);
};
static void ipc_actor (zsock_t *pipe, void *args)
{
// Do some initialization
char* name = (char*) args;
node = zyre_new (name);
assert(node);
if (!node) // Could not create new node
{
sim_printf("Couldn't create IPC node ... %s\n", name);
return;
}
ipc_printf("Starting IPC node %s ...", name);
if (ipc_verbose)
zyre_set_verbose (node); // uncomment to watch the events
zyre_start (node);
zyre_join (node, fnpGroup);
zsock_signal (pipe, 0); // Signal "ready" to caller
terminated = false;
poller = zpoller_new (pipe, zyre_socket (node), NULL);
assert(poller);
ipc_printf(" done\n");
while (!terminated)
{
void *which = zpoller_wait (poller, -1); // no timeout
if (!terminated && which == pipe)
{
zmsg_t *msg = zmsg_recv (which);
if (!msg)
break; // Interrupted
char *command = zmsg_popstr (msg);
if (streq (command, "$TERM"))
{
terminated = true;
}
else
if (streq (command, "SHOUT"))
{
char *string = zmsg_popstr (msg);
zyre_shouts (node, fnpGroup, "%s", string);
}
else if (streq (command, "WHISPER"))
{
char *string = zmsg_popstr (msg);
zyre_whispers (node, lastPeer, "%s", string);
} else
{
sim_debug (DBG_IPCVERBOSE, &ipc_dev,"ipc_actor(): E: invalid message to actor");
//assert (false);
}
free (command);
zmsg_destroy (&msg);
}
else if (!terminated && which == zyre_socket (node))
{
zmsg_t *msg = zmsg_recv (which);
char *event = zmsg_popstr (msg);
char *peer = zmsg_popstr (msg);
char *name = zmsg_popstr (msg);
char *group = zmsg_popstr (msg);
char *message = zmsg_popstr (msg); // change to zmsg_popmsg (zmsg_t *self) later
if (streq (event, "ENTER"))
{
ipc(ipcEnter, name, peer, message, 0);
}
else if (streq (event, "EXIT"))
{
ipc(ipcExit, name, peer, 0, 0);
}
if (streq (event, "SHOUT"))
{
ipc(ipcShoutRx, name, peer, message, 0);
}
if (streq (event, "WHISPER"))
{
ipc(ipcWhisperRx, name, peer, group, 0);
}
if (ipc_verbose)
{
ipc_printf("Message from node\n");
ipc_printf("event: %s peer: %s name: %s group: %s message: %s\n", event, peer, name, group, message);
}
free (event);
free (peer);
free (name);
free (group);
free (message);
zmsg_destroy (&msg);
}
}
}
static void
zyre_bridge_actor (zsock_t *pipe, void *args)
{
// initialization
ubx_block_t *b = (ubx_block_t *) args;
struct zyre_bridge_info *inf = (struct zyre_bridge_info*) b->private_data;
printf("[zyre_bridge]: actor started.\n");
// send signal on pipe socket to acknowledge initialization
zsock_signal (pipe, 0);
bool terminated = false;
zpoller_t *poller = zpoller_new (pipe, zyre_socket (inf->node), NULL);
while (!terminated) {
void *which = zpoller_wait (poller, -1);
// handle msgs from main thread
if (which == pipe) {
zmsg_t *msg = zmsg_recv (which);
if (!msg)
break; // Interrupted
// only react to TERM signal
char *command = zmsg_popstr (msg);
if (streq (command, "$TERM"))
terminated = true;
else {
puts ("Invalid pipe message to actor");
}
free (command);
zmsg_destroy (&msg);
} else
// handle msgs from zyre network
if (which == zyre_socket (inf->node)) {
zmsg_t *msg = zmsg_recv (which);
if (!msg) {
printf("[zyre_bridge]: interrupted!\n");
}
char *event = zmsg_popstr (msg);
char *peer = zmsg_popstr (msg);
char *name = zmsg_popstr (msg);
if (streq (event, "ENTER"))
printf ("[zyre_bridge]: %s has entered\n", name);
else
if (streq (event, "EXIT"))
printf ("[zyre_bridge]: %s has exited\n", name);
else
if (streq (event, "SHOUT")) {
printf ("[zyre_bridge]: SHOUT received from %s.\n", name);
char *group = zmsg_popstr (msg);
char *message = zmsg_popstr (msg);
// load JSON msg
json_t *m;
json_error_t error;
m= json_loads(message,0,&error);
if(!m) {
printf("Error parsing JSON payload! line %d: %s\n", error.line, error.text);
json_decref(m);
return;
}
printf("%s\n",message);
if (json_object_get(m, "type")) {
std::string type = json_dumps(json_object_get(m, "type"), JSON_ENCODE_ANY);
type = type.substr(1, type.size()-2); // get rid of " characters
printf("type: %s\n",json_dumps(json_object_get(m, "type"), JSON_ENCODE_ANY));
for (int i=0; i < inf->input_type_list.size();i++)
{
//if (json_string_value(json_object_get(m, "type")) == inf->input_type_list[i]){
//printf("type list, type : %s, %s \n", inf->input_type_list[i].c_str(), type.c_str());
if (inf->input_type_list[i].compare(type) == 0) {
ubx_type_t* type = ubx_type_get(b->ni, "unsigned char");
ubx_data_t ubx_msg;
ubx_msg.data = (void *)json_dumps(json_object_get(m, "payload"), JSON_ENCODE_ANY);
printf("message: %s\n",json_dumps(json_object_get(m, "payload"), JSON_ENCODE_ANY));
ubx_msg.len = strlen(json_dumps(json_object_get(m, "payload"), JSON_ENCODE_ANY));
ubx_msg.type = type;
__port_write(inf->ports.zyre_in, &ubx_msg);
}
}
} else {
printf("Error parsing JSON string! Does not conform to msg model.\n");
}
free (group);
free (message);
}
else
if (streq (event, "WHISPER")){
char *message = zmsg_popstr (msg);
printf ("%s: WHISPER \n%s\n", name, message);
free (message);
}
else
if (streq (event, "EVASIVE"))
printf ("[zyre_bridge]: %s is being evasive\n", name);
free (event);
free (peer);
free (name);
zmsg_destroy (&msg);
}
}
zpoller_destroy (&poller);
//TODO: make parametrizable
zclock_sleep (100);
}
///
// Return socket for talking to the Zyre node, for polling
zsock_t * QZyre::socket ()
{
zsock_t * rv = zyre_socket (self);
return rv;
}
int main (int argc, char *argv [])
{
puts (PRODUCT);
puts (COPYRIGHT);
puts (NOWARRANTY);
int argn = 1;
bool verbose = false;
if (argn < argc && streq (argv [argn], "-h")) {
puts ("syntax: hydrad [ directory ]");
puts (" -- defaults to .hydra in current directory");
exit (0);
}
if (argn < argc && streq (argv [argn], "-v")) {
verbose = true;
argn++;
}
// By default, current node runs in .hydra directory; create this if
// it's missing (don't create directory passed as argument);
char *workdir = ".hydra";
if (argn < argc)
workdir = argv [argn++];
else
zsys_dir_create (workdir);
// ----------------------------------------------------------------------
// This code eventually goes into a reusable hydra actor class
// Switch to working directory
zsys_info ("hydrad: data store in %s directory", workdir);
if (zsys_dir_change (workdir)) {
zsys_error ("hydrad: cannot access %s: %s", workdir, strerror (errno));
return 1;
}
// Check we are the only process currently running here
if (zsys_run_as ("hydrad.lock", NULL, NULL)) {
zsys_error ("hydrad: cannot start process safely, exiting");
return 1;
}
// Get node identity from config file, or generate new identity
zconfig_t *config = zconfig_load ("hydra.cfg");
if (!config) {
// Set defaults for Hydra service
config = zconfig_new ("root", NULL);
zconfig_put (config, "/server/timeout", "5000");
zconfig_put (config, "/server/background", "0");
zconfig_put (config, "/server/verbose", "0");
}
char *identity = zconfig_resolve (config, "/hydra/identity", NULL);
if (!identity) {
zuuid_t *uuid = zuuid_new ();
zconfig_put (config, "/hydra/identity", zuuid_str (uuid));
zconfig_put (config, "/hydra/nickname", "Anonymous");
zconfig_save (config, "hydra.cfg");
zuuid_destroy (&uuid);
}
// Create store structure, if necessary
zsys_dir_create ("content");
zsys_dir_create ("posts");
// Start server and bind to ephemeral TCP port. We can run many
// servers on the same box, for testing.
zactor_t *server = zactor_new (hydra_server, NULL);
if (verbose)
zstr_send (server, "VERBOSE");
// Bind Hydra service to ephemeral port and get that port number
char *command;
int port_nbr;
zsock_send (server, "ss", "CONFIGURE", "hydra.cfg");
zsock_send (server, "ss", "BIND", "tcp://*:*");
zsock_send (server, "s", "PORT");
zsock_recv (server, "si", &command, &port_nbr);
zsys_info ("hydrad: TCP server started on port=%d", port_nbr);
assert (streq (command, "PORT"));
free (command);
// We're going to use Zyre for discovery and presence, and our own
// Hydra protocol for content exchange
zyre_t *zyre = zyre_new (NULL);
if (verbose)
zyre_set_verbose (zyre);
char *hostname = zsys_hostname ();
char *endpoint = zsys_sprintf ("tcp://%s:%d", hostname, port_nbr);
zyre_set_header (zyre, "X-HYDRA", "%s", endpoint);
zstr_free (&endpoint);
zstr_free (&hostname);
if (zyre_start (zyre)) {
zsys_info ("hydrad: can't start Zyre discovery service");
zactor_destroy (&server);
zyre_destroy (&zyre);
return 1;
}
// When we get a new peer, handle it
zpoller_t *poller = zpoller_new (zyre_socket (zyre), NULL);
while (!zpoller_terminated (poller)) {
void *which = zpoller_wait (poller, -1);
if (which == zyre_socket (zyre)) {
zyre_event_t *event = zyre_event_new (zyre);
if (zyre_event_type (event) == ZYRE_EVENT_ENTER) {
zsys_debug ("hydrad: new peer name=%s endpoint=%s",
zyre_event_name (event),
zyre_event_header (event, "X-HYDRA"));
s_handle_peer (zyre_event_header (event, "X-HYDRA"), verbose);
}
zyre_event_destroy (&event);
}
else
break;
}
zsys_info ("hydrad: shutting down...");
zpoller_destroy (&poller);
// Shutdown all services
zactor_destroy (&server);
zyre_destroy (&zyre);
zconfig_destroy (&config);
return 0;
}
zsock_t* socket() const
{
return zyre_socket(m_self);
}
void
ztask_monitor_api_loop (ztask_monitor_api_t *self)
{
zyre_t *node = zyre_new();
zyre_set_header(node, "X-ZTASK-MON", "TASK MON");
zyre_start(node);
zyre_dump(node);
if (self->pub_port >= 0)
zclock_log("Publisher is listening on port %d ...", self->pub_port);
zpoller_t *poller = zpoller_new (zyre_socket (node), NULL);
uint64_t reap_at = zclock_time () + self->pub_timeout;
zyre_event_t *event;
while (!zsys_interrupted) {
void *which = zpoller_wait (poller, self->pub_timeout);
if (zpoller_terminated (poller)) {
break;
}
if (which == zyre_socket (node)) {
event = zyre_event_new(node);
if (!event)
break;
if (zyre_event_type(event) == ZYRE_EVENT_ENTER) {
}
else
if (zyre_event_type(event) == ZYRE_EVENT_EXIT) {
char *data = (char *) zhash_lookup(self->nodes,
(const char *) zyre_event_sender(event));
if (data) {
zhash_delete(self->nodes,
(const char *) zyre_event_sender(event));
free(data);
}
}
else
if (zyre_event_type(event) == ZYRE_EVENT_WHISPER) {
zmsg_t *msg = zyre_event_msg(event);
char *cpu_str = zmsg_popstr(msg);
char *mem_rss_str = zmsg_popstr(msg);
if (self->pub_sock) {
char *data = (char *) zhash_lookup(self->nodes,
(const char *) zyre_event_sender(event));
if (data) {
zhash_delete(self->nodes,
(const char *) zyre_event_sender(event));
free(data);
}
if (asprintf(&data, "{\"id\":\"%s\",%s,%s}",
zyre_event_sender(event), cpu_str, mem_rss_str) < 0)
data = NULL;
zhash_insert(self->nodes,
(const char *) zyre_event_sender(event), data);
}
else {
zclock_log("From %s", zyre_event_sender(event));
zclock_log(" %s", cpu_str);
zclock_log(" %s", mem_rss_str);
}
free(cpu_str);
free(mem_rss_str);
}
zyre_event_destroy(&event);
}
if (zclock_time() >= reap_at) {
reap_at = zclock_time() + self->pub_timeout;
if (self->pub_sock) {
char *data = ztask_monitor_api_json (self);
if (data) {
zmsg_t *msg = zmsg_new();
zmsg_addstr(msg, data);
zclock_log("Sending %s ...", data);
zmsg_send(&msg, self->pub_sock);
free(data);
}
}
}
}
zyre_stop(node);
zpoller_destroy (&poller);
zyre_destroy(&node);
// Cleanup of self->nodes
// char *wk = (char *) zhash_first (self->nodes);
// while (wk) {
// zhash_delete (self->nodes, wk);
//// free (data);
// wk = (char *) zhash_first (self->nodes);
// }
}
static void
chat_actor (zsock_t *pipe, void *args)
{
zyre_t *node = zyre_new ((char *) args);
if (!node)
return; // Could not create new node
zyre_start (node);
zyre_join (node, "CHAT");
zsock_signal (pipe, 0); // Signal "ready" to caller
bool terminated = false;
zpoller_t *poller = zpoller_new (pipe, zyre_socket (node), NULL);
while (!terminated) {
void *which = zpoller_wait (poller, -1);
if (which == pipe) {
zmsg_t *msg = zmsg_recv (which);
if (!msg)
break; // Interrupted
char *command = zmsg_popstr (msg);
if (streq (command, "$TERM"))
terminated = true;
else
if (streq (command, "SHOUT")) {
char *string = zmsg_popstr (msg);
zyre_shouts (node, "CHAT", "%s", string);
}
else {
puts ("E: invalid message to actor");
assert (false);
}
free (command);
zmsg_destroy (&msg);
}
else
if (which == zyre_socket (node)) {
zmsg_t *msg = zmsg_recv (which);
char *event = zmsg_popstr (msg);
char *peer = zmsg_popstr (msg);
char *name = zmsg_popstr (msg);
char *group = zmsg_popstr (msg);
char *message = zmsg_popstr (msg);
if (streq (event, "ENTER"))
printf ("%s has joined the chat\n", name);
else
if (streq (event, "EXIT"))
printf ("%s has left the chat\n", name);
else
if (streq (event, "SHOUT"))
printf ("%s: %s\n", name, message);
else
if (streq (event, "EVASIVE"))
printf ("%s is being evasive\n", name);
free (event);
free (peer);
free (name);
free (group);
free (message);
zmsg_destroy (&msg);
}
}
zpoller_destroy (&poller);
zyre_stop (node);
zclock_sleep (100);
zyre_destroy (&node);
}
static void
node_task (void *args, zctx_t *ctx, void *pipe)
{
zyre_t *node = zyre_new (ctx);
if (!node)
return; // Could not create new node
zyre_set_verbose (node);
zyre_start (node);
int64_t counter = 0;
char *to_peer = NULL; // Either of these set,
char *to_group = NULL; // and we set a message
char *cookie = NULL;
zpoller_t *poller = zpoller_new (pipe, zyre_socket (node), NULL);
int64_t trigger = zclock_time () + 1000;
while (!zctx_interrupted) {
void *which = zpoller_wait (poller, randof (1000));
// Any command from parent means EXIT
if (which == pipe)
break;
// Process an event from node
if (which == zyre_socket (node)) {
zmsg_t *incoming = zyre_recv (node);
if (!incoming)
break; // Interrupted
char *event = zmsg_popstr (incoming);
if (streq (event, "ENTER")) {
// Always say hello to new peer
to_peer = zmsg_popstr (incoming);
}
else
if (streq (event, "EXIT")) {
// Always try talk to departed peer
to_peer = zmsg_popstr (incoming);
}
else
if (streq (event, "WHISPER")) {
// Send back response 1/2 the time
if (randof (2) == 0) {
to_peer = zmsg_popstr (incoming);
cookie = zmsg_popstr (incoming);
}
}
else
if (streq (event, "SHOUT")) {
to_peer = zmsg_popstr (incoming);
to_group = zmsg_popstr (incoming);
cookie = zmsg_popstr (incoming);
// Send peer response 1/3rd the time
if (randof (3) > 0) {
free (to_peer);
to_peer = NULL;
}
// Send group response 1/3rd the time
if (randof (3) > 0) {
free (to_group);
to_group = NULL;
}
}
else
if (streq (event, "JOIN")) {
char *from_peer = zmsg_popstr (incoming);
char *group = zmsg_popstr (incoming);
printf ("I: %s joined %s\n", from_peer, group);
free (from_peer);
free (group);
}
else
if (streq (event, "LEAVE")) {
char *from_peer = zmsg_popstr (incoming);
char *group = zmsg_popstr (incoming);
printf ("I: %s left %s\n", from_peer, group);
free (from_peer);
free (group);
}
else
if (streq (event, "DELIVER")) {
char *filename = zmsg_popstr (incoming);
char *fullname = zmsg_popstr (incoming);
printf ("I: received file %s\n", fullname);
free (fullname);
free (filename);
}
free (event);
zmsg_destroy (&incoming);
// Send outgoing messages if needed
if (to_peer) {
zyre_whispers (node, to_peer, "%lu", counter++);
free (to_peer);
to_peer = NULL;
}
if (to_group) {
zyre_shouts (node, to_group, "%lu", counter++);
free (to_group);
to_group = NULL;
}
if (cookie) {
free (cookie);
cookie = NULL;
}
}
if (zclock_time () >= trigger) {
trigger = zclock_time () + 1000;
char group [10];
sprintf (group, "GROUP%03d", randof (MAX_GROUP));
if (randof (4) == 0)
zyre_join (node, group);
else
if (randof (3) == 0)
zyre_leave (node, group);
}
}
zpoller_destroy (&poller);
zyre_destroy (&node);
}
///
// Return socket for talking to the Zyre node, for polling
QZsock * QZyre::socket ()
{
QZsock *rv = new QZsock (zyre_socket (self));
return rv;
}
int main() {
if (!getenv("ENDPOINT")) {
fprintf (stderr, "variable ENDPOINT must be declared\n");
exit (EXIT_FAILURE);
}
char *endpoint = strdup(getenv("ENDPOINT"));
//1. start malamute
zactor_t *broker = s_broker(endpoint);
//2. shout about it through zyre
zyre_t *node = zyre_new (getenv("USER"));
assert (node);
char * UUID = strdup (zyre_uuid (node));
zsys_info ("UUID: %s", UUID);
bool to_shout = true;
//zyre_set_verbose (node);
zyre_start (node);
zyre_join (node, "MALAMUTE");
zpoller_t *poller = zpoller_new(zyre_socket (node), NULL);
time_t last_leader_shout;
// 3. get the comments
while (!zsys_interrupted) {
zsock_t *which = zpoller_wait(poller, 1000);
if (time(NULL) - last_leader_shout > 5) {
to_shout = true;
zstr_free (&UUID);
UUID = strdup (zyre_uuid (node));
zstr_free (&endpoint);
endpoint = strdup (getenv("ENDPOINT"));
zactor_destroy (&broker);
broker = s_broker (endpoint);
}
if (!which && to_shout) {
zyre_shouts (node, "MALAMUTE", "%s", endpoint);
continue;
}
zyre_event_t *event = zyre_event_new (node);
if (!event)
continue;
switch (zyre_event_type (event)) {
case ZYRE_EVENT_SHOUT:
{
int r = strcmp (UUID, zyre_event_sender (event));
if (!r)
last_leader_shout = time(NULL);
if (r >= 0)
goto event_destroy;
zsys_debug ("UUID: %s, sender: %s, strcmp: %d",
UUID,
zyre_event_sender (event),
r
);
to_shout = false;
zstr_free (&UUID);
UUID = strdup (zyre_event_sender (event));
zstr_free (&endpoint);
zmsg_t *msg = zyre_event_msg (event);
endpoint = strdup (zmsg_popstr(msg));
zactor_destroy (&broker);
broker = s_broker (endpoint);
zclock_sleep(1000);
break;
}
}
event_destroy:
zyre_event_destroy (&event);
}
zpoller_destroy (&poller);
zstr_free (&UUID);
zstr_free (&endpoint);
zyre_destroy (&node);
zactor_destroy (&broker);
}
static int
server_join_cluster (server_t *self)
{
self->zyre = zyre_new (zconfig_resolve (self->config, "zyre/name", NULL));
// Get Zyre configuration properties
char *value = zconfig_resolve (self->config, "zyre/discovery", "beacon");
if (streq (value, "beacon")) {
// Set-up UDP beacon discovery
zsys_info ("using UDP beacon discovery service");
value = zconfig_resolve (self->config, "zyre/beacon/interface", "auto");
if (strneq (value, "auto")) {
zsys_info ("forcing cluster interface to %s", value);
zyre_set_interface (self->zyre, value);
}
value = zconfig_resolve (self->config, "zyre/beacon/interval", NULL);
if (value)
zyre_set_interval (self->zyre, atoi (value));
value = zconfig_resolve (self->config, "zyre/beacon/port", NULL);
if (value) {
zsys_info ("UDP beaconing on port %s", value);
zyre_set_port (self->zyre, atoi (value));
}
}
else
if (streq (value, "gossip")) {
// Set-up TCP gossip discovery
zsys_info ("using TCP gossip discovery service");
zconfig_t *section = zconfig_locate (self->config, "zyre/gossip");
if (!section) {
zsys_warning ("please configure zyre/gossip section");
return -1;
}
zconfig_t *entry = zconfig_child (section);
while (entry) {
char *name = zconfig_name (entry);
char *value = zconfig_value (entry);
if (streq (name, "endpoint")) {
zsys_info ("Zyre node endpoint=%s", value);
zyre_set_endpoint (self->zyre, "%s", value);
}
else
if (streq (name, "bind")) {
zsys_info ("gossip service bind to %s", value);
zyre_gossip_bind (self->zyre, "%s", value);
}
else
if (streq (name, "connect")) {
zsys_info ("gossip service connect to %s", value);
zyre_gossip_connect (self->zyre, "%s", value);
}
else
zsys_warning ("unknown zyre/gossip entry '%s' ignored", name);
entry = zconfig_next (entry);
}
}
else {
zsys_error ("bad zyre/discovery=%s (use beacon|gossip)", value);
assert (0);
}
if (zyre_start (self->zyre)) {
zsys_warning ("clustering not working");
return -1; // Can't join cluster
}
zyre_join (self->zyre, "ZPIPES");
// Get Zyre public name for logging
self->name = strdup (zyre_name (self->zyre));
zsys_info ("joining cluster as %s", self->name);
// Set-up reader for Zyre events
engine_handle_socket (self, zyre_socket (self->zyre), zyre_handler);
return 0;
}
static void
node_actor (zsock_t *pipe, void *args)
{
zyre_t *node = zyre_new (NULL);
if (!node)
return; // Could not create new node
zyre_set_verbose (node);
zyre_set_endpoint (node, "inproc://%s", (char *) args);
free (args);
// Connect to test hub
zyre_gossip_connect (node, "inproc://zyre-hub");
zyre_start (node);
zsock_signal (pipe, 0); // Signal "ready" to caller
int counter = 0;
char *to_peer = NULL; // Either of these set,
char *to_group = NULL; // and we set a message
char *cookie = NULL;
zpoller_t *poller = zpoller_new (pipe, zyre_socket (node), NULL);
int64_t trigger = zclock_mono () + 1000;
while (true) {
void *which = zpoller_wait (poller, randof (1000));
if (!which)
break; // Interrupted
// $TERM from parent means exit; anything else is breach of
// contract so we should assert
if (which == pipe) {
char *command = zstr_recv (pipe);
assert (streq (command, "$TERM"));
zstr_free (&command);
break; // Finished
}
// Process an event from node
if (which == zyre_socket (node)) {
zmsg_t *incoming = zyre_recv (node);
if (!incoming)
break; // Interrupted
char *event = zmsg_popstr (incoming);
char *peer = zmsg_popstr (incoming);
char *name = zmsg_popstr (incoming);
if (streq (event, "ENTER"))
// Always say hello to new peer
to_peer = strdup (peer);
else
if (streq (event, "EXIT"))
// Always try talk to departed peer
to_peer = strdup (peer);
else
if (streq (event, "WHISPER")) {
// Send back response 1/2 the time
if (randof (2) == 0) {
to_peer = strdup (peer);
cookie = zmsg_popstr (incoming);
}
}
else
if (streq (event, "SHOUT")) {
to_peer = strdup (peer);
to_group = zmsg_popstr (incoming);
cookie = zmsg_popstr (incoming);
// Send peer response 1/3rd the time
if (randof (3) > 0) {
free (to_peer);
to_peer = NULL;
}
// Send group response 1/3rd the time
if (randof (3) > 0) {
free (to_group);
to_group = NULL;
}
}
else
if (streq (event, "JOIN")) {
char *group = zmsg_popstr (incoming);
printf ("I: %s joined %s\n", name, group);
free (group);
}
else
if (streq (event, "LEAVE")) {
char *group = zmsg_popstr (incoming);
printf ("I: %s left %s\n", name, group);
free (group);
}
free (event);
free (peer);
free (name);
zmsg_destroy (&incoming);
// Send outgoing messages if needed
if (to_peer) {
zyre_whispers (node, to_peer, "%d", counter++);
free (to_peer);
to_peer = NULL;
}
if (to_group) {
zyre_shouts (node, to_group, "%d", counter++);
free (to_group);
to_group = NULL;
}
if (cookie) {
free (cookie);
cookie = NULL;
}
}
if (zclock_mono () >= trigger) {
trigger = zclock_mono () + 1000;
char group [10];
sprintf (group, "GROUP%03d", randof (MAX_GROUP));
if (randof (4) == 0)
zyre_join (node, group);
else
if (randof (3) == 0)
zyre_leave (node, group);
}
}
zpoller_destroy (&poller);
zyre_destroy (&node);
}
void
zsync_node_engine (void *args, zctx_t *ctx, void *pipe)
{
int rc;
zsync_node_t *self = zsync_node_new ();
self->ctx = ctx;
self->zyre = zyre_new (ctx);
self->zsync_pipe = pipe;
// Join group
rc = zyre_join (self->zyre, "ZSYNC");
assert (rc == 0);
// Give time to interconnect
zclock_sleep (250);
zpoller_t *poller = zpoller_new (zyre_socket (self->zyre), self->zsync_pipe, NULL);
// Create thread for file management
self->file_pipe = zthread_fork (self->ctx, zsync_ftmanager_engine, NULL);
zpoller_add (poller, self->file_pipe);
// Create thread for credit management
self->credit_pipe = zthread_fork (self->ctx, zsync_credit_manager_engine, NULL);
zpoller_add (poller, self->credit_pipe);
// Start receiving messages
printf("[ND] started\n");
while (!zpoller_terminated (poller)) {
void *which = zpoller_wait (poller, -1);
if (which == zyre_socket (self->zyre)) {
zsync_node_recv_from_zyre (self);
}
else
if (which == self->zsync_pipe) {
printf("[ND] Recv Agent\n");
zsync_node_recv_from_agent (self);
}
else
if (which == self->file_pipe) {
printf("[ND] Recv FT Manager\n");
zsync_ftm_msg_t *msg = zsync_ftm_msg_recv (self->file_pipe);
char *receiver = zsync_ftm_msg_receiver (msg);
char *zyre_uuid = zsync_node_zyre_uuid (self, receiver);
if (zyre_uuid) {
char *path = zsync_ftm_msg_path (msg);
uint64_t sequence = zsync_ftm_msg_sequence (msg);
uint64_t chunk_size = zsync_ftm_msg_chunk_size (msg);
uint64_t offset = zsync_ftm_msg_offset (msg);
zsync_msg_send_req_chunk (pipe, path, chunk_size, offset);
zsync_msg_t *zsmsg = zsync_msg_recv (pipe);
zchunk_t *chunk = zsync_msg_chunk (zsmsg);
zframe_t *frame = zframe_new (zchunk_data (chunk), zchunk_size (chunk));
zmsg_t *zmsg = zmsg_new ();
zs_msg_pack_chunk (zmsg, sequence, path, offset, frame);
zyre_whisper (self->zyre, zyre_uuid, &zmsg);
zsync_ftm_msg_destroy (&msg);
zsync_msg_destroy (&zsmsg);
}
}
else
if (which == self->credit_pipe) {
printf("[ND] Recv Credit Manager\n");
zsync_credit_msg_t *cmsg = zsync_credit_msg_recv (self->credit_pipe);
char *receiver = zsync_credit_msg_receiver (cmsg);
char *zyre_uuid = zsync_node_zyre_uuid (self, receiver);
if (zyre_uuid) {
zmsg_t *credit_msg = zsync_credit_msg_credit (cmsg);
assert (rc == 0);
zyre_whisper (self->zyre, zyre_uuid, &credit_msg);
}
zsync_credit_msg_destroy (&cmsg);
}
if (self->terminated) {
break;
}
}
zpoller_destroy (&poller);
zsync_node_destroy (&self);
printf("[ND] stopped\n");
}
