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); }
std::string header_value(const std::string& key) const { const char *val = zyre_event_header(m_self, key.c_str()); if(val == NULL) { return ""; } return val; }
JNIEXPORT jstring JNICALL Java_org_zeromq_zyre_ZyreEvent__1_1header (JNIEnv *env, jclass c, jlong self, jstring name) { char *name_ = (char *) (*env)->GetStringUTFChars (env, name, NULL); char *header_ = (char *) zyre_event_header ((zyre_event_t *) self, name_); jstring return_string_ = (*env)->NewStringUTF (env, header_); (*env)->ReleaseStringUTFChars (env, name, name_); return return_string_; }
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"); }
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"); }
/// // Returns value of a header from the message headers // obtained by ENTER. Return NULL if no value was found. const QString QZyreEvent::header (const QString &name) { const QString rv = QString (zyre_event_header (self, name.toUtf8().data())); return rv; }
/// // Returns value of a header from the message headers // obtained by ENTER. Return NULL if no value was found. const QString QmlZyreEvent::header (const QString &name) { return QString (zyre_event_header (self, name.toUtf8().data())); };
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; }
void ztask_run_manager_loop (ztask_run_manager_t *self) { assert (self); if (!self->packetizer) { zclock_log ("E: No packetizer set !!!"); return; } // Setting network interface if neede if (self->node_interface) zyre_set_interface(self->node, self->node_interface); zyre_set_header (self->node, "X-ZTASK-RUN", "ZTASK RUN"); zyre_start (self->node); zyre_dump (self->node); zclock_sleep (10); // ztask_packetizer_dump (self->packetizer); ztask_packet_t *packet; int request_sent = 0; zyre_event_t *event; while (!zsys_interrupted) { if (ztask_packetizer_is_finished (self->packetizer)) break; event = zyre_event_new (self->node); if (!event) break; if (zyre_event_type (event) == ZYRE_EVENT_ENTER) { // Ignoring nodes which don't have service X-ZTASK-NODE defined if (zyre_event_header (event, "X-ZTASK-NODE")) { zhash_insert (self->nodes, zyre_event_sender (event),""); ztask_log_debug (self->log, "Adding node -> workers=%ld", zhash_size (self->nodes)); } else { // TODO disconnect worker (zyre peer) somehow } } else if (zyre_event_type (event) == ZYRE_EVENT_EXIT) { if (zhash_lookup (self->nodes, zyre_event_sender (event))) { ztask_log_debug (self->log, "Removing node -> workers=%ld", zhash_size (self->nodes)); zhash_delete (self->nodes, zyre_event_sender (event)); // Cleanup packetizer in case ztask_node was killed request_sent -= ztask_packetizer_running_node_cleanup (self->packetizer, zyre_event_sender (event)); } } else if (zyre_event_type (event) == ZYRE_EVENT_WHISPER) { // Ingoring whispers when they are not from our nodes if (!zhash_lookup(self->nodes, zyre_event_sender (event))) { ztask_log_warning (self->log, "W: Ingoring whisper from %s", zyre_event_sender (event)); zyre_event_destroy (&event); continue; } zmsg_t *msg_report = zyre_event_msg(event); char *str_msg = zmsg_popstr (msg_report); if (streq(str_msg, "REQUEST")) { // Let's handle request packet = ztask_packetizer_next_packet (self->packetizer); if (packet) { char *cmd; if ( asprintf (&cmd, "%s", ztask_packet_cmd (packet)) < 0) cmd = NULL; assert (cmd); zmsg_t *msg = zmsg_new (); zmsg_addstr (msg, "REQUEST"); zmsg_addstrf (msg, "%s_%ld", zyre_uuid (self->node), ztask_packet_id (packet)); zmsg_addstr (msg, cmd); zyre_whisper (self->node, zyre_event_sender (event), &msg); ztask_packet_set_node (packet, zyre_event_sender (event)); request_sent++; ztask_packetizer_info (self->packetizer, request_sent); ztask_log_debug (self->log, "ID=%s_%ld cmd='%s' running=%d", zyre_uuid (self->node), ztask_packet_id (packet), cmd, request_sent); free (cmd); } else { zmsg_t *msg = zmsg_new (); zmsg_addstr (msg, "NO_PACKETS"); zyre_whisper (self->node, zyre_event_sender (event), &msg); } } else if (streq(str_msg, "REPORT")) { // It's report char *str_id = zmsg_popstr (msg_report); char *str_pid_rc = zmsg_popstr (msg_report); ztask_log_debug (self->log, "REPORT ID=%s rc=%s", str_id, str_pid_rc); ztask_packetizer_report (self->packetizer, str_id, str_pid_rc); request_sent--; ztask_packetizer_info (self->packetizer, request_sent); free (str_id); free (str_pid_rc); } else { ztask_log_error (self->log, "E: ztask_run_manager_loop : Wrong message %s", str_msg); assert (false); } free (str_msg); } zyre_event_destroy (&event); } // FIXME : simplify zhash_foreach() zlist_t *keys = zhash_keys (self->nodes); char *key = (char *) zlist_first (keys); while (key) { zmsg_t *msg = zmsg_new (); zmsg_addstr (msg, "END"); zyre_whisper (self->node, key, &msg); key = (char *) zlist_next (keys); } zlist_destroy (&keys); // wait for shout to be delivered zclock_sleep (100); ztask_packetizer_summary(self->packetizer, 0); zyre_stop (self->node); }