static void s_check_directory (s_agent_t *self) { // Get latest snapshot and build a patches list for any changes // All patches are built using a virtual path starting at "/" zdir_t *dir = zdir_new (self->path, NULL); zlist_t *patches = zdir_diff (self->dir, dir, "/"); // Drop old directory and replace with latest version zdir_destroy (&self->dir); self->dir = dir; while (zlist_size (patches)) { zdir_patch_t *patch = (zdir_patch_t *) zlist_pop (patches); if (zdir_patch_op (patch) == patch_create) { // Shout new files to DROPS group // Stupidest possible approach: send whole file as one frame // Truncate file at arbitrary limit of 10MB zfile_t *file = zdir_patch_file (patch); if (zfile_input (file) == 0) { zchunk_t *chunk = zfile_read (file, 10 * 1024 * 1024, 0); assert (chunk); zmsg_t *msg = zmsg_new (); zmsg_addstr (msg, "CREATE"); zmsg_addstr (msg, zdir_patch_vpath (patch)); zmsg_add (msg, zframe_new (zchunk_data (chunk), zchunk_size (chunk))); zchunk_destroy (&chunk); zyre_shout (self->zyre, "DROPS", &msg); } } zdir_patch_destroy (&patch); } zlist_destroy (&patches); }
JNIEXPORT jint JNICALL Java_org_zeromq_zyre_Zyre__1_1shout (JNIEnv *env, jclass c, jlong self, jstring group, jlong msg_p) { char *group_ = (char *) (*env)->GetStringUTFChars (env, group, NULL); jint shout_ = (jint) zyre_shout ((zyre_t *) (intptr_t) self, group_, (zmsg_t **) (intptr_t) &msg_p); (*env)->ReleaseStringUTFChars (env, group, group_); return shout_; }
void zgtask_worker_loop (zgtask_worker_t *self) { assert (self); zyre_t *zyre = zgtask_net_get_zyre_parent (self->net); zmsg_t *msg; int j; for (j = 0; j < 10; ++j) { msg = zmsg_new (); zmsg_addstr (msg, "Hello world"); zyre_shout (zyre, "GLOBAL", &msg); } }
void zsync_node_recv_from_agent (zsync_node_t *self) { assert (self); zsync_msg_t *msg = zsync_msg_recv (self->zsync_pipe); switch (zsync_msg_id (msg)) { case ZSYNC_MSG_REQ_FILES: { char *receiver = zsync_msg_receiver (msg); char *zyre_uuid = zsync_node_zyre_uuid (self, receiver); if (zyre_uuid) { uint64_t size = zsync_msg_size (msg); printf("[ND] Recv Agent WHISPER REQUEST %s ; %s\n", zyre_uuid, receiver); zmsg_t *zyre_out = zmsg_new (); zs_msg_pack_request_files (zyre_out, zsync_msg_files (msg)); zyre_whisper (self->zyre, zyre_uuid, &zyre_out); zsync_credit_msg_send_request (self->credit_pipe, zyre_uuid, size); } break; } case ZSYNC_MSG_UPDATE: printf("[ND] Recv Agent SHOUT UPDATE\n"); zmsg_t *zyre_out = zsync_msg_update_msg (msg); zyre_shout (self->zyre, "ZSYNC", &zyre_out); break; case ZSYNC_MSG_TERMINATE: zyre_stop (self->zyre); // terminate file transfer manager zsync_ftm_msg_send_terminate (self->file_pipe); // terminate credit manager zsync_credit_msg_send_terminate (self->credit_pipe); // receive termination confirmation msg = zsync_msg_recv (self->file_pipe); zsync_msg_destroy (&msg); printf("OK ft\n"); msg = zsync_msg_recv (self->credit_pipe); zsync_msg_destroy (&msg); printf("OK cm\n"); // send shutdown confirmation to agent zsync_msg_send_terminate (self->zsync_pipe); self->terminated = true; break; } }
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 int pipe_attach_local_writer (pipe_t *self, client_t *writer) { assert (self); if (self->writer == NULL) { zsys_info ("%s: attach local writer", self->name); self->writer = writer; if (self->reader == NULL) { if (self->server->zyre) { // Announce that we have a new pipe writer so that readers // in the cluster may discover us zmsg_t *msg = zmsg_new (); zmsg_addstr (msg, "HAVE WRITER"); zmsg_addstr (msg, self->name); zyre_shout (self->server->zyre, "ZPIPES", &msg); zsys_info ("%s: broadcast we are now writer", self->name); } } else if (self->reader == REMOTE_NODE) { assert (self->server->zyre); // Tell remote node we would like to be writer zmsg_t *msg = zmsg_new (); zmsg_addstr (msg, "HAVE WRITER"); zmsg_addstr (msg, self->name); zyre_whisper (self->server->zyre, self->remote, &msg); zsys_info ("%s: tell peer we are now writer", self->name); } else engine_send_event (self->reader, have_writer_event); return 0; } zsys_info ("%s: pipe already has writer: ignored", self->name); return -1; }
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"); }
/// // Send message to a named group // Destroys message after sending int QmlZyre::shout (const QString &group, zmsg_t **msgP) { return zyre_shout (self, group.toUtf8().data(), msgP); };
/// // Send message to a named group // Destroys message after sending int QZyre::shout (const QString &group, QZmsg *msgP) { int rv = zyre_shout (self, group.toUtf8().data(), &msgP->self); return rv; }
/// // Send message to a named group // Destroys message after sending int QZyre::shout (const QString &group, zmsg_t **msgP) { int rv = zyre_shout (self, group.toUtf8().data(), msgP); return rv; }
void shout(const std::string& group, zmsg_t* msg) const { zyre_shout(m_self, group.c_str(), &msg); }