void GroupNodeImpl::update_groups() { #ifndef _WIN32 sigset_t signal_set; sigaddset(&signal_set, SIGINT); sigaddset(&signal_set, SIGTERM); sigaddset(&signal_set, SIGHUP); sigaddset(&signal_set, SIGPIPE); pthread_sigmask(SIG_BLOCK, &signal_set, NULL); #endif // called by a thread in an infinite loop at a fixed rate (i.e. 1s) while (ok()) { auto start = std::chrono::high_resolution_clock::now(); zlist_t* all_groups = zyre_peer_groups(node_); void* item = zlist_first(all_groups); while (item != NULL) { char* grp = static_cast<char*>(item); // zyre only joins the group if we are not ALREADY in the group // so it does a hash lookup - we would be duplicating work zyre_join(node_, grp); item = zlist_next(all_groups); } std::chrono::duration<double,std::milli> period(1000); std::this_thread::sleep_until(start + period); } }
JNIEXPORT jint JNICALL Java_org_zeromq_zyre_Zyre__1_1join (JNIEnv *env, jclass c, jlong self, jstring group) { char *group_ = (char *) (*env)->GetStringUTFChars (env, group, NULL); jint join_ = (jint) zyre_join ((zyre_t *) (intptr_t) self, group_); (*env)->ReleaseStringUTFChars (env, group, group_); return join_; }
void zgtask_worker_start (zgtask_worker_t *self) { assert (self); zyre_t *zyre = zgtask_net_init_zyre_parent (self->net); zyre_gossip_connect (zyre, self->url_parent); zyre_start (zyre); zyre_join (zyre, "GLOBAL"); zclock_sleep (250); }
void GroupNodeImpl::join(const std::string& group) { { basic_lock lk(join_mutex_); joins_[group] = 0; } if (zyre_join(node_, group.c_str())) { throw std::runtime_error("Error joining group: " + group); } // we should WAIT to get an enter event? }
static s_agent_t * s_agent_new (zctx_t *ctx, void *pipe) { s_agent_t *self = (s_agent_t *) zmalloc (sizeof (s_agent_t)); self->ctx = ctx; self->pipe = pipe; self->path = zstr_recv (self->pipe); self->dir = zdir_new (self->path, NULL); self->zyre = zyre_new (NULL); zyre_start (self->zyre); zyre_join (self->zyre, "DROPS"); return self; }
int main(int argc, char** argv) { if(argc != 2) { fprintf(stderr, "Usage: %s ups_name\n", argv[0]); exit(1); } char *addr = NULL; zyre_t *n = zyre_new(argv[1]); zyre_start(n); zyre_join(n, "BIOS"); while(!zsys_interrupted && addr == NULL) { zyre_event_t *e = zyre_event_new(n); if(!e) break; if(zyre_event_headers(e) && zyre_event_header(e, "HAP_SERVER") != NULL) { addr = strdup(zyre_event_header(e, "HAP_SERVER")); printf("Address: %s\n", addr); } zyre_event_destroy(&e); } zyre_destroy(&n); if(addr == NULL) exit(1); zsock_t * sc = zsock_new(ZMQ_PUB); zsock_connect(sc, "%s", addr); bool state = random()%2; int timeout = 0; while(!zsys_interrupted) { if(timeout == 0) { state = !state; timeout = 5 + random()%20; } timeout--; if(state) { zstr_sendx(sc, argv[1], "ON", NULL); zsys_debug("UPS %s ON", argv[1]); } else { zstr_sendx(sc, argv[1], "OFF", NULL); zsys_debug("UPS %s OFF", argv[1]); } sleep(1); } zsock_destroy(&sc); }
int main (int argc, char *argv []) { zyre_t *node = zyre_new (NULL); zyre_start (node); zyre_join (node, "GLOBAL"); while (true) { zmsg_t *incoming = zyre_recv (node); if (!incoming) break; // Interrupted // If new peer, say hello to it and wait for it to answer us char *event = zmsg_popstr (incoming); char *peer = zmsg_popstr (incoming); char *name = zmsg_popstr (incoming); if (streq (event, "ENTER")) { printf ("I: [%s] peer entered\n", name); zyre_whispers (node, peer, "Hello"); } else if (streq (event, "EXIT")) { printf ("I: [%s] peer exited\n", name); } else if (streq (event, "WHISPER")) { printf ("I: [%s] received ping (WHISPER)\n", name); zyre_shouts (node, "GLOBAL", "Hello"); } else if (streq (event, "SHOUT")) { char *group = zmsg_popstr (incoming); printf ("I: [%s](%s) received ping (SHOUT)\n", name, group); free (group); } free (event); free (peer); free (name); zmsg_destroy (&incoming); } zyre_destroy (&node); 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); }
GroupNodeImpl::GroupNodeImpl(const std::string& desc, bool promiscuous) : event_thread_(NULL), prom_thread_(NULL), promiscuous_(promiscuous), stopped_(false) { // create the zyre node node_ = zyre_new((GroupNode::name() + "/" + desc).c_str()); // verbose output zyre_set_verbose(node_); // set the interface to use, otherwise zyre just guesses (default "") zyre_set_interface(node_, GroupNode::iface().c_str()); // set the headers zyre_set_header(node_, "desc", "%s", desc.c_str()); // access our uuid std::string uuid = zyre_uuid(node_); // access our name node_name_ = zyre_name(node_); // start the node if (zyre_start(node_)) { throw std::runtime_error("Could not start the zyre node"); } // join the control group - too heavy if (zyre_join(node_, GroupNode::control_.c_str())) { throw std::runtime_error("Error joining CONTROL group"); } // create our self peer self_.reset(new Peer(uuid, desc)); /* we want to minimize the groups joined and messages sent - especially by other non-promiscuous components; in order to do so, we need to periodically join all the known groups. */ if (promiscuous_) { prom_thread_ = new std::thread(&GroupNodeImpl::update_groups, this); BOOST_LOG_TRIVIAL(debug) << "Started promiscuous group thread..." << std::endl; } }
void zyre_event_test (bool verbose) { printf (" * zyre_event: "); // @selftest // Create two nodes zyre_t *node1 = zyre_new ("node1"); assert (node1); zyre_set_header (node1, "X-HELLO", "World"); int rc = zyre_set_endpoint (node1, "inproc://zyre-node1"); assert (rc == 0); // use gossiping instead of beaconing, suits Travis better zyre_gossip_bind (node1, "inproc://gossip-hub"); if (verbose) zyre_set_verbose (node1); if (zyre_start (node1)) { zyre_destroy (&node1); printf ("OK (skipping test, no UDP discovery)\n"); return; } zyre_join (node1, "GLOBAL"); zyre_t *node2 = zyre_new ("node2"); assert (node2); if (verbose) zyre_set_verbose (node2); rc = zyre_set_endpoint (node2, "inproc://zyre-node2"); assert (rc == 0); // use gossiping instead of beaconing, suits Travis better zyre_gossip_connect (node2, "inproc://gossip-hub"); rc = zyre_start (node2); assert (rc == 0); zyre_join (node2, "GLOBAL"); // Give time for them to interconnect zclock_sleep (250); // One node shouts to GLOBAL zmsg_t *msg = zmsg_new (); zmsg_addstr (msg, "Hello, World"); zyre_shout (node1, "GLOBAL", &msg); zclock_sleep (100); // Parse ENTER zyre_event_t *event = zyre_event_new (node2); assert (streq (zyre_event_type (event), "ENTER")); const char *sender = zyre_event_peer_uuid (event); assert (sender); const char *name = zyre_event_peer_name (event); assert (name); assert (streq (name, "node1")); const char *address = zyre_event_peer_addr (event); assert (address); const char *header = zyre_event_header (event, "X-HELLO"); assert (header); zyre_event_destroy (&event); // Parse JOIN // We tolerate other events, which we can get if there are instances // of Zyre running somewhere on the network. event = zyre_event_new (node2); if (streq (zyre_event_type (event), "JOIN")) { // Parse SHOUT zyre_event_destroy (&event); event = zyre_event_new (node2); if (streq (zyre_event_type (event), "SHOUT")) { assert (streq (zyre_event_group (event), "GLOBAL")); zmsg_t *msg = zyre_event_get_msg (event); char *string = zmsg_popstr (msg); zmsg_destroy (&msg); assert (streq (string, "Hello, World")); free (string); } zyre_event_destroy (&event); } zyre_destroy (&node1); zyre_destroy (&node2); // @end printf ("OK\n"); }
int main(int argc, char** argv) { if(argc != 2) { fprintf(stderr, "Usage: %s ups_name\n", argv[0]); exit(1); } char *addr = NULL; zyre_t *n = zyre_new(argv[1]); zyre_start(n); zyre_join(n, "MONITORS"); char *hap_server = NULL; while (!zsys_interrupted) { zmsg_t *zyre_msg = zyre_recv (n); zmsg_print (zyre_msg); char *command = zmsg_popstr (zyre_msg); if (!streq (command, "SHOUT")) continue; char *uuid = zmsg_popstr (zyre_msg); char *name = zmsg_popstr (zyre_msg); char *channel = zmsg_popstr (zyre_msg); hap_server = zmsg_popstr (zyre_msg); free (uuid); free (name); free (channel); free (command); break; } zsys_debug ("initial HAP server: %s", hap_server); addr = hap_server; if(addr == NULL) exit(1); zsock_t * sc = zsock_new(ZMQ_PUB); zsock_connect(sc, "%s", addr); zsys_debug ("socket created, connected."); bool state = random()%2; int timeout = 0; int cummulative = 0; while(!zsys_interrupted) { if(timeout == 0) { state = !state; timeout = 5 + random()%20; } timeout--; if(state) { zstr_sendx(sc, argv[1], "ON", NULL); zsys_debug("UPS %s ON", argv[1]); } else { zstr_sendx(sc, argv[1], "OFF", NULL); zsys_debug("UPS %s OFF", argv[1]); } sleep(1); cummulative++; if (cummulative == 5) { char *new_hap; while (!zsys_interrupted) { zmsg_t *zyre_msg = zyre_recv (n); zmsg_print (zyre_msg); char *command = zmsg_popstr (zyre_msg); if (!streq (command, "SHOUT")) continue; char *uuid = zmsg_popstr (zyre_msg); char *name = zmsg_popstr (zyre_msg); char *channel = zmsg_popstr (zyre_msg); new_hap = zmsg_popstr (zyre_msg); free (uuid); free (name); free (channel); free (command); break; } if (!streq (new_hap, hap_server)) { free (hap_server); hap_server = new_hap; zsock_connect(sc, "%s", addr); } cummulative = 0; } } if (hap_server) free (hap_server); zsock_destroy(&sc); }
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"); }
void zyre_test (bool verbose) { printf (" * zyre: "); // @selftest // We'll use inproc gossip discovery so that this works without networking int major, minor, patch; zyre_version (&major, &minor, &patch); assert (major == ZYRE_VERSION_MAJOR); assert (minor == ZYRE_VERSION_MINOR); assert (patch == ZYRE_VERSION_PATCH); // Create two nodes zyre_t *node1 = zyre_new ("node1"); assert (node1); assert (streq (zyre_name (node1), "node1")); zyre_set_header (node1, "X-HELLO", "World"); zyre_set_verbose (node1); // Set inproc endpoint for this node zyre_set_endpoint (node1, "inproc://zyre-node1"); // Set up gossip network for this node zyre_gossip_bind (node1, "inproc://gossip-hub"); int rc = zyre_start (node1); assert (rc == 0); zyre_t *node2 = zyre_new ("node2"); assert (node2); assert (streq (zyre_name (node2), "node2")); zyre_set_verbose (node2); // Set inproc endpoint for this node // First, try to use existing name, it'll fail zyre_set_endpoint (node2, "inproc://zyre-node1"); assert (streq (zyre_endpoint (node2), "")); // Now use available name and confirm that it succeeds zyre_set_endpoint (node2, "inproc://zyre-node2"); assert (streq (zyre_endpoint (node2), "inproc://zyre-node2")); // Set up gossip network for this node zyre_gossip_connect (node2, "inproc://gossip-hub"); rc = zyre_start (node2); assert (rc == 0); assert (strneq (zyre_uuid (node1), zyre_uuid (node2))); zyre_join (node1, "GLOBAL"); zyre_join (node2, "GLOBAL"); // Give time for them to interconnect zclock_sleep (100); // One node shouts to GLOBAL zyre_shouts (node1, "GLOBAL", "Hello, World"); // Second node should receive ENTER, JOIN, and SHOUT zmsg_t *msg = zyre_recv (node2); assert (msg); char *command = zmsg_popstr (msg); assert (streq (command, "ENTER")); zstr_free (&command); assert (zmsg_size (msg) == 4); char *peerid = zmsg_popstr (msg); zstr_free (&peerid); char *name = zmsg_popstr (msg); assert (streq (name, "node1")); zstr_free (&name); zframe_t *headers_packed = zmsg_pop (msg); char *peeraddress = zmsg_popstr (msg); zstr_free (&peeraddress); assert (headers_packed); zhash_t *headers = zhash_unpack (headers_packed); assert (headers); zframe_destroy (&headers_packed); assert (streq ((char*)zhash_lookup (headers, "X-HELLO"), "World")); zhash_destroy (&headers); zmsg_destroy (&msg); msg = zyre_recv (node2); assert (msg); command = zmsg_popstr (msg); assert (streq (command, "JOIN")); zstr_free (&command); assert (zmsg_size (msg) == 3); zmsg_destroy (&msg); msg = zyre_recv (node2); assert (msg); command = zmsg_popstr (msg); assert (streq (command, "SHOUT")); zstr_free (&command); zmsg_destroy (&msg); zyre_stop (node1); zyre_stop (node2); zyre_destroy (&node1); zyre_destroy (&node2); // @end printf ("OK\n"); }
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 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); }
int main (int argc, char *argv []) { int argn = 1; if (argn == argc || streq (argv [argn], "-h") || streq (argv [argn], "--help")) { puts ("midicast [-v] [-p port] [-i interface]"); puts ("Reads MIDI events from port and sends to Zyre MIDI group"); puts (" -h, --help: this help"); puts (" -v, --verbose: trace events as they happen"); puts (" -p, --port: specify port name, e.g. '-p hw:1,0,0'"); puts (" -i, --interface: specify WiFi interface, e.g. '-i wlan0'"); return 0; } char *midi_port_name = "hw:2,0"; char *wifi_interface = NULL; bool verbose = false; while (argn < argc) { if (streq (argv [argn], "-p") || streq (argv [argn], "--port")) midi_port_name = argv [++argn]; else if (streq (argv [argn], "-i") || streq (argv [argn], "--interface")) wifi_interface = argv [++argn]; else if (streq (argv [argn], "-v") || streq (argv [argn], "--verbose")) verbose = true; argn++; } snd_rawmidi_t *output; int rc = snd_rawmidi_open (NULL, &output, midi_port_name, SND_RAWMIDI_SYNC); if (rc < 0) { zsys_error ("cannot open port \"%s\": %s", midi_port_name, snd_strerror (rc)); return 0; } zsys_info ("forwarding MIDI cast to %s", midi_port_name); zyre_t *zyre = zyre_new (NULL); if (wifi_interface) zyre_set_interface (zyre, wifi_interface); zyre_start (zyre); zyre_join (zyre, "MIDI"); zsys_info ("this player is %s", zyre_name (zyre)); while (!zsys_interrupted) { zyre_event_t *event = zyre_event_new (zyre); if (!event) { printf (" interrupted\n"); break; } if (zyre_event_type (event) == ZYRE_EVENT_JOIN) zsys_info ("[%s] player joined", zyre_event_peer_name (event)); else if (zyre_event_type (event) == ZYRE_EVENT_LEAVE) zsys_info ("[%s] player left", zyre_event_peer_name (event)); else if (zyre_event_type (event) == ZYRE_EVENT_SHOUT) { if (streq (zyre_event_group (event), "MIDI")) { zframe_t *frame = zmsg_first (zyre_event_msg (event)); // Forward the MIDI event snd_rawmidi_write (output, zframe_data (frame), zframe_size (frame)); if (verbose) { printf ("%zd:", zframe_size (frame)); int byte_nbr; for (byte_nbr = 0; byte_nbr < zframe_size (frame); byte_nbr++) printf (" %02X", zframe_data (frame) [byte_nbr]); printf ("\n"); } } } zyre_event_destroy (&event); } snd_rawmidi_close (output); zyre_destroy (&zyre); return 0; }
/// // Join a named group; after joining a group you can send messages to // the group and all Zyre nodes in that group will receive them. int QmlZyre::join (const QString &group) { return zyre_join (self, group.toUtf8().data()); };
void zyre_event_test (bool verbose) { printf (" * zyre_event: "); // @selftest // Create two nodes zyre_t *node1 = zyre_new ("node1"); assert (node1); zyre_set_header (node1, "X-HELLO", "World"); zyre_set_verbose (node1); if (zyre_start (node1)) { zyre_destroy (&node1); printf ("OK (skipping test, no UDP discovery)\n"); return; } zyre_join (node1, "GLOBAL"); zyre_t *node2 = zyre_new ("node2"); assert (node2); zyre_set_verbose (node2); int rc = zyre_start (node2); assert (rc == 0); zyre_join (node2, "GLOBAL"); // Give time for them to interconnect zclock_sleep (250); // One node shouts to GLOBAL zmsg_t *msg = zmsg_new (); zmsg_addstr (msg, "Hello, World"); zyre_shout (node1, "GLOBAL", &msg); zclock_sleep (100); // Parse ENTER zyre_event_t *event = zyre_event_new (node2); assert (zyre_event_type (event) == ZYRE_EVENT_ENTER); char *sender = zyre_event_sender (event); assert (sender); char *name = zyre_event_name (event); assert (name); assert (streq (name, "node1")); char *address = zyre_event_address (event); assert (address); char *header = zyre_event_header (event, "X-HELLO"); assert (header); zyre_event_destroy (&event); // Parse JOIN event = zyre_event_new (node2); assert (zyre_event_type (event) == ZYRE_EVENT_JOIN); zyre_event_destroy (&event); // Parse SHOUT event = zyre_event_new (node2); assert (zyre_event_type (event) == ZYRE_EVENT_SHOUT); assert (streq (zyre_event_group (event), "GLOBAL")); msg = zyre_event_msg (event); char *string = zmsg_popstr (msg); assert (streq (string, "Hello, World")); free (string); zyre_event_destroy (&event); zyre_destroy (&node1); zyre_destroy (&node2); // @end printf ("OK\n"); }
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 mrb_actor_pipe_reader(zloop_t* reactor, zsock_t* pipe, void* args) { errno = 0; self_t* self = (self_t*)args; int rc = 0; zmsg_t* msg = zmsg_recv(pipe); if (!msg) return -1; char* command = zmsg_popstr(msg); zsys_debug("command: %s", command); if (streq(command, "$TERM")) { rc = -1; } else if (streq(command, "BIND ROUTER")) { char* endpoint = zmsg_popstr(msg); if (zsock_bind(self->router, "%s", endpoint) >= 0) { const char* boundendpoint = zsock_endpoint(self->router); zyre_set_header(self->discovery, "mrb-actor-v1-router", "%s", boundendpoint); zsock_signal(pipe, 0); zsock_send(pipe, "s", boundendpoint); } else { zsock_signal(pipe, 1); zsock_send(pipe, "i", errno); } zstr_free(&endpoint); } else if (streq(command, "BIND PULL")) { char* endpoint = zmsg_popstr(msg); if (zsock_bind(self->pull, "%s", endpoint) >= 0) { const char* boundendpoint = zsock_endpoint(self->pull); zyre_set_header(self->discovery, "mrb-actor-v1-pull", "%s", boundendpoint); zsock_signal(pipe, 0); zsock_send(pipe, "s", boundendpoint); } else { zsock_signal(pipe, 1); zsock_send(pipe, "i", errno); } zstr_free(&endpoint); } else if (streq(command, "ZYRE SET ENDPOINT")) { char* endpoint = zmsg_popstr(msg); if (zyre_set_endpoint(self->discovery, "%s", endpoint) == -1) { zsock_signal(pipe, 1); } else { zsock_signal(pipe, 0); } zstr_free(&endpoint); } else if (streq(command, "ZYRE GOSSIP BIND")) { char* endpoint = zmsg_popstr(msg); zyre_gossip_bind(self->discovery, "%s", endpoint); zstr_free(&endpoint); } else if (streq(command, "ZYRE GOSSIP CONNECT")) { char* endpoint = zmsg_popstr(msg); zyre_gossip_connect(self->discovery, "%s", endpoint); zstr_free(&endpoint); } else if (streq(command, "ZYRE START")) { if (zyre_start(self->discovery) == -1) { zsock_signal(pipe, 1); } else { zyre_join(self->discovery, "mrb-actor-v1"); zsock_signal(pipe, 0); } } else if (streq(command, "LOAD IREP FILE")) { char* mrb_file = zmsg_popstr(msg); mrb_state* mrb = self->mrb; int ai = mrb_gc_arena_save(mrb); struct mrb_jmpbuf* prev_jmp = mrb->jmp; struct mrb_jmpbuf c_jmp; MRB_TRY(&c_jmp) { mrb->jmp = &c_jmp; FILE* fp = fopen(mrb_file, "rb"); if (!fp) { mrb_sys_fail(mrb, "fopen"); } mrb_load_irep_file(mrb, fp); fclose(fp); if (mrb->exc) { mrb_exc_raise(mrb, mrb_obj_value(mrb->exc)); } zsock_signal(pipe, 0); mrb->jmp = prev_jmp; } MRB_CATCH(&c_jmp) { mrb->jmp = prev_jmp; mrb_print_error(mrb); zsock_signal(pipe, 1); mrb->exc = NULL; } MRB_END_EXC(&c_jmp); mrb_gc_arena_restore(mrb, ai); zstr_free(&mrb_file); }
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); }
void join(const std::string& group) const { zyre_join(m_self, group.c_str()); }
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); }
/// // Join a named group; after joining a group you can send messages to // the group and all Zyre nodes in that group will receive them. int QZyre::join (const QString &group) { int rv = zyre_join (self, group.toUtf8().data()); return rv; }
/* init */ int zyre_bridge_init(ubx_block_t *b) { int ret = -1; struct zyre_bridge_info *inf; unsigned int tmplen; /* allocate memory for the block local state */ if ((inf = (struct zyre_bridge_info*)calloc(1, sizeof(struct zyre_bridge_info)))==NULL) { ERR("zyre_bridge: failed to alloc memory"); ret=EOUTOFMEM; return ret; } update_port_cache(b, &inf->ports); //If the following code is used, do not forget to also use the code freeing the memory in the cleanup. And also to put it into the bridge_info struct // inf->msg_buffer = (unsigned char*) malloc(inf->max_msg_length*sizeof(unsigned char*)); // if (!inf->msg_buffer){ // printf("%s: Could not allocate memory for msg buffer. \n", b->name); // goto out; // } int *max_msg_length; max_msg_length = (int*) ubx_config_get_data_ptr(b, "max_msg_length", &tmplen); printf("max_msg_length value for block %s is %d\n", b->name, *max_msg_length); inf->max_msg_length = *max_msg_length; if (inf->max_msg_length <=0){ printf("ERR: %s: max_msg_length must be >0!\n",b->name); return ret; } int *max_send; max_send = (int*) ubx_config_get_data_ptr(b, "max_send", &tmplen); printf("max_send value for block %s is %d\n", b->name, *max_send); inf->max_send = *max_send; // ///TODO: need to get a list of type names in here // char *type_list; // type_list = (char*) ubx_config_get_data_ptr(b, "type_list", &tmplen); // printf("List of types for block %s is %s\n", b->name, type_list); // inf->type_list = type_list; ///TODO: for now hardcoded list -> fix, read from comma separated string inf->input_type_list.push_back("RSGUpdate_global"); inf->input_type_list.push_back("RSGUpdate_local"); inf->input_type_list.push_back("RSGUpdate_both"); inf->input_type_list.push_back("RSGUpdate"); inf->input_type_list.push_back("RSGQuery"); inf->input_type_list.push_back("RSGFunctionBlock"); inf->output_type_list.push_back("RSGUpdate"); //updates generated for updating other RSG agents, will be mapped to RSGUpdate_global inf->output_type_list.push_back("RSGUpdateResult"); inf->output_type_list.push_back("RSGQueryResult"); inf->output_type_list.push_back("RSGFunctionBlockResult"); int major, minor, patch; zyre_version (&major, &minor, &patch); if (major != ZYRE_VERSION_MAJOR) return ret; if (minor != ZYRE_VERSION_MINOR) return ret; if (patch != ZYRE_VERSION_PATCH) return ret; char *wm_name; wm_name = (char*) ubx_config_get_data_ptr(b, "wm_name", &tmplen); printf("zyre name for block %s is %s\n", b->name, wm_name); zyre_t *node; node = zyre_new (wm_name); if (!node){ printf("Could not create a zyre node!"); return ret; } inf->node = node; int rc; //char *loc_ep; char *gos_ep; ///TODO: remove superfluous local endpoint //loc_ep = (char*) ubx_config_get_data_ptr(b, "local_endpoint", &tmplen); gos_ep = (char*) ubx_config_get_data_ptr(b, "gossip_endpoint", &tmplen); //printf("local and gossip endpoint for block %s is %s and %s\n", b->name, loc_ep, gos_ep); //rc = zyre_set_endpoint (node, "%s",loc_ep); //assert (rc == 0); // check if zyre or gossip shall be used ubx_data_t *tmp; tmp = ubx_config_get_data(b, "gossip_flag"); int gossip_flag; gossip_flag = *(int*) tmp->data; if (gossip_flag == 1){ // Set up gossip network for this node ubx_data_t *dmy; dmy = ubx_config_get_data(b, "bind"); int bind; bind = *(int*) dmy->data; if (bind == 1) { printf("%s: This block will bind to gossip endpoint '%s'\n", b->name,gos_ep); zyre_gossip_bind (node, "%s", gos_ep); } else if (bind == 0) { printf("%s: This block will connect to gossip endpoint '%s' \n", b->name,gos_ep); zyre_gossip_connect (node, "%s",gos_ep); } else { printf("%s: Wrong value for bind configuration. Must be 0 or 1. \n", b->name); return ret; } } else if (gossip_flag == 0) { //nothing to do here. if no gossip port was set, zyre will use UDP beacons automatically } else { printf("%s: Wrong value for gossip_flag configuration. Must be 0 or 1. \n", b->name); return ret; } rc = zyre_start (node); assert (rc == 0); ///TODO: enable list of group names char *group; group = (char*) ubx_config_get_data_ptr(b, "group", &tmplen); zyre_join (node, group); inf->group = group; // Give time for them to interconnect zclock_sleep (100); b->private_data=inf; ret=0; return ret; }
void zyre_test (bool verbose) { printf (" * zyre: "); if (verbose) printf ("\n"); // @selftest // We'll use inproc gossip discovery so that this works without networking uint64_t version = zyre_version (); assert ((version / 10000) % 100 == ZYRE_VERSION_MAJOR); assert ((version / 100) % 100 == ZYRE_VERSION_MINOR); assert (version % 100 == ZYRE_VERSION_PATCH); // Create two nodes zyre_t *node1 = zyre_new ("node1"); assert (node1); assert (streq (zyre_name (node1), "node1")); zyre_set_header (node1, "X-HELLO", "World"); if (verbose) zyre_set_verbose (node1); // Set inproc endpoint for this node int rc = zyre_set_endpoint (node1, "inproc://zyre-node1"); assert (rc == 0); // Set up gossip network for this node zyre_gossip_bind (node1, "inproc://gossip-hub"); rc = zyre_start (node1); assert (rc == 0); zyre_t *node2 = zyre_new ("node2"); assert (node2); assert (streq (zyre_name (node2), "node2")); if (verbose) zyre_set_verbose (node2); // Set inproc endpoint for this node // First, try to use existing name, it'll fail rc = zyre_set_endpoint (node2, "inproc://zyre-node1"); assert (rc == -1); // Now use available name and confirm that it succeeds rc = zyre_set_endpoint (node2, "inproc://zyre-node2"); assert (rc == 0); // Set up gossip network for this node zyre_gossip_connect (node2, "inproc://gossip-hub"); rc = zyre_start (node2); assert (rc == 0); assert (strneq (zyre_uuid (node1), zyre_uuid (node2))); zyre_join (node1, "GLOBAL"); zyre_join (node2, "GLOBAL"); // Give time for them to interconnect zclock_sleep (250); if (verbose) zyre_dump (node1); zlist_t *peers = zyre_peers (node1); assert (peers); assert (zlist_size (peers) == 1); zlist_destroy (&peers); zyre_join (node1, "node1 group of one"); zyre_join (node2, "node2 group of one"); // Give them time to join their groups zclock_sleep (250); zlist_t *own_groups = zyre_own_groups (node1); assert (own_groups); assert (zlist_size (own_groups) == 2); zlist_destroy (&own_groups); zlist_t *peer_groups = zyre_peer_groups (node1); assert (peer_groups); assert (zlist_size (peer_groups) == 2); zlist_destroy (&peer_groups); char *value = zyre_peer_header_value (node2, zyre_uuid (node1), "X-HELLO"); assert (streq (value, "World")); zstr_free (&value); // One node shouts to GLOBAL zyre_shouts (node1, "GLOBAL", "Hello, World"); // Second node should receive ENTER, JOIN, and SHOUT zmsg_t *msg = zyre_recv (node2); assert (msg); char *command = zmsg_popstr (msg); assert (streq (command, "ENTER")); zstr_free (&command); assert (zmsg_size (msg) == 4); char *peerid = zmsg_popstr (msg); char *name = zmsg_popstr (msg); assert (streq (name, "node1")); zstr_free (&name); zframe_t *headers_packed = zmsg_pop (msg); char *address = zmsg_popstr (msg); char *endpoint = zyre_peer_address (node2, peerid); assert (streq (address, endpoint)); zstr_free (&peerid); zstr_free (&endpoint); zstr_free (&address); assert (headers_packed); zhash_t *headers = zhash_unpack (headers_packed); assert (headers); zframe_destroy (&headers_packed); assert (streq ((char *) zhash_lookup (headers, "X-HELLO"), "World")); zhash_destroy (&headers); zmsg_destroy (&msg); msg = zyre_recv (node2); assert (msg); command = zmsg_popstr (msg); assert (streq (command, "JOIN")); zstr_free (&command); assert (zmsg_size (msg) == 3); zmsg_destroy (&msg); msg = zyre_recv (node2); assert (msg); command = zmsg_popstr (msg); assert (streq (command, "JOIN")); zstr_free (&command); assert (zmsg_size (msg) == 3); zmsg_destroy (&msg); msg = zyre_recv (node2); assert (msg); command = zmsg_popstr (msg); assert (streq (command, "SHOUT")); zstr_free (&command); zmsg_destroy (&msg); zyre_stop (node2); msg = zyre_recv (node2); assert (msg); command = zmsg_popstr (msg); assert (streq (command, "STOP")); zstr_free (&command); zmsg_destroy (&msg); zyre_stop (node1); zyre_destroy (&node1); zyre_destroy (&node2); printf ("OK\n"); #ifdef ZYRE_BUILD_DRAFT_API if (zsys_has_curve()){ printf (" * zyre-curve: "); if (verbose) printf ("\n"); if (verbose) zsys_debug("----------------TESTING CURVE --------------"); zactor_t *speaker = zactor_new (zbeacon, NULL); assert (speaker); if (verbose) zstr_sendx (speaker, "VERBOSE", NULL); // ensuring we have a broadcast address zsock_send (speaker, "si", "CONFIGURE", 9999); char *hostname = zstr_recv (speaker); if (!*hostname) { printf ("OK (skipping test, no UDP broadcasting)\n"); zactor_destroy (&speaker); freen (hostname); return; } freen (hostname); zactor_destroy (&speaker); // zap setup zactor_t *auth = zactor_new(zauth, NULL); assert (auth); if (verbose) { zstr_sendx(auth, "VERBOSE", NULL); zsock_wait(auth); } zstr_sendx (auth, "CURVE", CURVE_ALLOW_ANY, NULL); zsock_wait (auth); zyre_t *node3 = zyre_new ("node3"); zyre_t *node4 = zyre_new ("node4"); assert (node3); assert (node4); zyre_set_verbose (node3); zyre_set_verbose (node4); zyre_set_zap_domain(node3, "TEST"); zyre_set_zap_domain(node4, "TEST"); zsock_set_rcvtimeo(node3->inbox, 10000); zsock_set_rcvtimeo(node4->inbox, 10000); zcert_t *node3_cert = zcert_new (); zcert_t *node4_cert = zcert_new (); assert (node3_cert); assert (node4_cert); zyre_set_zcert(node3, node3_cert); zyre_set_zcert(node4, node4_cert); zyre_set_header(node3, "X-PUBLICKEY", "%s", zcert_public_txt(node3_cert)); zyre_set_header(node4, "X-PUBLICKEY", "%s", zcert_public_txt(node4_cert)); // test beacon if (verbose) zsys_debug ("----------------TESTING BEACON----------------"); rc = zyre_start(node3); assert (rc == 0); rc = zyre_start(node4); assert (rc == 0); zyre_join (node3, "GLOBAL"); zyre_join (node4, "GLOBAL"); zclock_sleep (1500); if (verbose) { zyre_dump (node3); zyre_dump (node4); } zyre_shouts (node3, "GLOBAL", "Hello, World"); // Second node should receive ENTER, JOIN, and SHOUT msg = zyre_recv (node4); assert (msg); command = zmsg_popstr (msg); assert (streq (command, "ENTER")); zstr_free (&command); char *peerid = zmsg_popstr (msg); assert (peerid); name = zmsg_popstr (msg); assert (streq (name, "node3")); zmsg_destroy (&msg); msg = zyre_recv (node4); assert (msg); command = zmsg_popstr (msg); assert (streq (command, "JOIN")); zstr_free (&command); zmsg_destroy(&msg); msg = zyre_recv (node4); assert (msg); command = zmsg_popstr (msg); assert (streq (command, "SHOUT")); zstr_free (&command); zmsg_destroy(&msg); zyre_leave(node3, "GLOBAL"); zyre_leave(node4, "GLOBAL"); zstr_free (&name); zstr_free (&peerid); zstr_free (&command); zyre_stop (node3); zyre_stop (node4); // give things a chance to settle... zclock_sleep (250); zyre_destroy(&node3); zyre_destroy(&node4); zcert_destroy(&node3_cert); zcert_destroy(&node4_cert); // test gossip if (verbose) zsys_debug ("----------------TESTING GOSSIP----------------"); zyre_t *node5 = zyre_new ("node5"); zyre_t *node6 = zyre_new ("node6"); assert (node5); assert (node6); if (verbose) { zyre_set_verbose (node5); zyre_set_verbose (node6); } // if it takes more than 10s, something probably went terribly wrong zsock_set_rcvtimeo(node5->inbox, 10000); zsock_set_rcvtimeo(node6->inbox, 10000); zcert_t *node5_cert = zcert_new (); zcert_t *node6_cert = zcert_new (); assert (node5_cert); assert (node6_cert); zyre_set_zcert(node5, node5_cert); zyre_set_zcert(node6, node6_cert); zyre_set_header(node5, "X-PUBLICKEY", "%s", zcert_public_txt(node5_cert)); zyre_set_header(node6, "X-PUBLICKEY", "%s", zcert_public_txt(node6_cert)); const char *gossip_cert = zcert_public_txt (node5_cert); // TODO- need to add zyre_gossip_port functions to get port from gossip bind(?) zyre_gossip_bind(node5, "tcp://127.0.0.1:9001"); zyre_gossip_connect_curve(node6, gossip_cert, "tcp://127.0.0.1:9001"); zyre_start(node5); zsock_wait(node5); zyre_start(node6); zsock_wait(node6); zyre_join (node5, "GLOBAL"); zyre_join (node6, "GLOBAL"); // give things a chance to settle... zclock_sleep (1500); if (verbose) { zyre_dump (node5); zyre_dump (node6); } zyre_shouts (node5, "GLOBAL", "Hello, World"); // Second node should receive ENTER, JOIN, and SHOUT msg = zyre_recv (node6); assert (msg); command = zmsg_popstr (msg); zsys_info(command); assert (streq (command, "ENTER")); zstr_free (&command); peerid = zmsg_popstr (msg); assert (peerid); name = zmsg_popstr (msg); zmsg_destroy (&msg); assert (streq (name, "node5")); zstr_free (&name); zyre_leave(node5, "GLOBAL"); zyre_leave(node6, "GLOBAL"); zyre_stop (node5); zyre_stop (node6); // give things a chance to settle... zclock_sleep (250); zstr_free (&peerid); zcert_destroy (&node5_cert); zcert_destroy (&node6_cert); zyre_destroy(&node5); zyre_destroy(&node6); zactor_destroy(&auth); printf ("OK\n"); } #endif }
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); }
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; }