JNIEXPORT jstring JNICALL Java_org_zeromq_zyre_Zyre__1_1name (JNIEnv *env, jclass c, jlong self) { char *name_ = (char *) zyre_name ((zyre_t *) (intptr_t) self); jstring return_string_ = (*env)->NewStringUTF (env, name_); return return_string_; }
static void generate_chat_message (client_t *self) { example_peer_msg_set_name(self->message,zyre_name(self->zyre)); example_peer_msg_set_uuid(self->message,zyre_uuid(self->zyre)); example_peer_msg_set_message(self->message,self->args->message); }
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_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"); }
/// // Return our node name, after successful initialization const QString QmlZyre::name () { return QString (zyre_name (self)); };
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; }
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 }
/// // Return our node name, after successful initialization const QString QZyre::name () { const QString rv = QString (zyre_name (self)); return rv; }
std::string name() const { return zyre_name(m_self); }
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; }