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);
}
