static int
zyre_node_stop (zyre_node_t *self)
{
if (self->beacon) {
// Stop broadcast/listen beacon
beacon_t beacon;
beacon.protocol [0] = 'Z';
beacon.protocol [1] = 'R';
beacon.protocol [2] = 'E';
beacon.version = BEACON_VERSION;
beacon.port = 0; // Zero means we're stopping
zuuid_export (self->uuid, beacon.uuid);
zsock_send (self->beacon, "sbi", "PUBLISH",
(byte *) &beacon, sizeof (beacon_t), self->interval);
zclock_sleep (1); // Allow 1 msec for beacon to go out
zpoller_remove (self->poller, self->beacon);
zactor_destroy (&self->beacon);
}
// Stop polling on inbox
zpoller_remove (self->poller, self->inbox);
zstr_sendm (self->outbox, "STOP");
zstr_sendm (self->outbox, zuuid_str (self->uuid));
zstr_send (self->outbox, self->name);
return 0;
}
MessageProcessor::~MessageProcessor()
{
zpoller_remove(zmqPoller_, zmqSocket_);
zpoller_destroy(&zmqPoller_);
zactor_destroy(&zmqAuth_);
zsock_destroy(&zmqSocket_);
}
int maltcp_ctx_poller_del_endpoint(
void *self,
mal_poller_t *mal_poller,
mal_endpoint_t *mal_endpoint) {
maltcp_poller_data_t *poller_data = (maltcp_poller_data_t *) mal_poller_get_poller_data(mal_poller);
maltcp_endpoint_data_t *endpoint_data = (maltcp_endpoint_data_t *) mal_endpoint_get_endpoint_data(mal_endpoint);
int rc = 0;
clog_debug(maltcp_logger, "maltcp_ctx_poller_del_endpoint(): %s\n", mal_endpoint_get_uri(mal_endpoint));
if (poller_data->poller == NULL) {
clog_error(maltcp_logger, "");
return -1;
}
rc = zpoller_remove(poller_data->poller, endpoint_data->socket);
if (rc != 0) {
clog_error(maltcp_logger, "maltcp_ctx_poller_del_endpoint(): zpoller null\n");
return rc;
}
rc = maltcp_del_endpoint(poller_data, mal_endpoint);
clog_debug(maltcp_logger, "maltcp_ctx_poller_del_endpoint: return %d\n",rc);
return rc;
}
void
zpoller_test (bool verbose)
{
printf (" * zpoller: ");
// @selftest
// Create a few sockets
zsock_t *vent = zsock_new (ZMQ_PUSH);
assert (vent);
int port_nbr = zsock_bind (vent, "tcp://127.0.0.1:*");
assert (port_nbr != -1);
zsock_t *sink = zsock_new (ZMQ_PULL);
assert (sink);
int rc = zsock_connect (sink, "tcp://127.0.0.1:%d", port_nbr);
assert (rc != -1);
zsock_t *bowl = zsock_new (ZMQ_PULL);
assert (bowl);
zsock_t *dish = zsock_new (ZMQ_PULL);
assert (dish);
// Set up poller
zpoller_t *poller = zpoller_new (bowl, dish, NULL);
assert (poller);
// Add a reader to the existing poller
rc = zpoller_add (poller, sink);
assert (rc == 0);
zstr_send (vent, "Hello, World");
// We expect a message only on the sink
zsock_t *which = (zsock_t *) zpoller_wait (poller, -1);
assert (which == sink);
assert (zpoller_expired (poller) == false);
assert (zpoller_terminated (poller) == false);
char *message = zstr_recv (which);
assert (streq (message, "Hello, World"));
zstr_free (&message);
// Stop polling reader
rc = zpoller_remove (poller, sink);
assert (rc == 0);
// Removing a non-existent reader shall fail
rc = zpoller_remove (poller, sink);
assert (rc == -1);
assert (errno == EINVAL);
// Check we can poll an FD
rc = zsock_connect (bowl, "tcp://127.0.0.1:%d", port_nbr);
assert (rc != -1);
SOCKET fd = zsock_fd (bowl);
rc = zpoller_add (poller, (void *) &fd);
assert (rc != -1);
zstr_send (vent, "Hello again, world");
assert (zpoller_wait (poller, 500) == &fd);
// Check zpoller_set_nonstop ()
zsys_interrupted = 1;
zpoller_wait (poller, 0);
assert (zpoller_terminated (poller));
zpoller_set_nonstop (poller, true);
zpoller_wait (poller, 0);
assert (!zpoller_terminated (poller));
zsys_interrupted = 0;
zpoller_destroy (&poller);
zsock_destroy (&vent);
zsock_destroy (&sink);
zsock_destroy (&bowl);
zsock_destroy (&dish);
#ifdef ZMQ_SERVER
// Check thread safe sockets
zpoller_destroy (&poller);
zsock_t *client = zsock_new (ZMQ_CLIENT);
assert (client);
zsock_t *server = zsock_new (ZMQ_SERVER);
assert (server);
poller = zpoller_new (client, server, NULL);
assert (poller);
port_nbr = zsock_bind (server, "tcp://127.0.0.1:*");
assert (port_nbr != -1);
rc = zsock_connect (client, "tcp://127.0.0.1:%d", port_nbr);
assert (rc != -1);
zstr_send (client, "Hello, World");
// We expect a message only on the server
which = (zsock_t *) zpoller_wait (poller, -1);
assert (which == server);
assert (zpoller_expired (poller) == false);
assert (zpoller_terminated (poller) == false);
message = zstr_recv (which);
assert (streq (message, "Hello, World"));
zstr_free (&message);
zpoller_destroy (&poller);
zsock_destroy (&client);
zsock_destroy (&server);
#endif
#if defined (__WINDOWS__)
zsys_shutdown();
#endif
// @end
printf ("OK\n");
}
///
// Remove a reader from the poller; returns 0 if OK, -1 on failure. The
// reader may be a libzmq void * socket, a zsock_t instance, or a zactor_t
// instance.
int QmlZpoller::remove (void *reader) {
return zpoller_remove (self, reader);
};
void
broker_run (broker_t *self)
{
// Only accepting requests when executors available.
bool accepting_requests = false;
while (1) {
zsock_t *which = (zsock_t *) zpoller_wait (self->poller, 10);
if (which == self->contexts) {
puts ("[BROKER] which == self->contexts");
// [context] [request]
zmsg_t *msg = zmsg_recv (self->contexts);
assert (msg);
if (0 != broker_send_to_executor (self, msg))
zlist_append (self->backlog, msg);
// Remove contexts from poller if no executors
if (zlist_size (self->executor_lb) == 0) {
zpoller_remove (self->poller, self->contexts);
accepting_requests = false;
}
}
else if (which == self->executors) {
puts ("[BROKER] which == self->executors");
// EITHER:
// [executor] ["READY"]
// [executor] [context] [response]
zmsg_t *msg = zmsg_recv (self->executors);
assert (msg);
zframe_t *executor_addr = zmsg_pop (msg);
assert (executor_addr);
zframe_t *ctx_or_ready = zmsg_pop (msg);
char *context_addr = zframe_strdup (ctx_or_ready);
if (strcmp (context_addr, "READY") != 0) {
// Forward the response to the correct context addr.
// [context] [0] [response]
zmsg_prepend (msg, &ctx_or_ready);
zmsg_send (&msg, self->contexts);
} else {
// Got a READY message
// Put the executor ID back in the available queue
zlist_append (self->executor_lb, executor_addr);
// We know at least one executor is now available,
// so check and assign backlog tasks.
broker_check_backlog (self);
// If we now have executors but not accepting requests,
// then start polling on the frontend socket.
if (!accepting_requests && zlist_size (self->executor_lb)) {
zpoller_add (self->poller, self->contexts);
accepting_requests = true;
}
// Destroy the READY message.
zmsg_destroy (&msg);
}
}
else if (zpoller_terminated (self->poller))
break;
}
}
JNIEXPORT jint JNICALL
Java_org_zeromq_czmq_Zpoller__1_1remove (JNIEnv *env, jclass c, jlong self, jlong reader)
{
jint remove_ = (jint) zpoller_remove ((zpoller_t *) (intptr_t) self, (void *) (intptr_t) reader);
return remove_;
}
///
// Remove a reader from the poller; returns 0 if OK, -1 on failure. The
// reader may be a libzmq void * socket, a zsock_t instance, or a zactor_t
// instance.
int QZpoller::remove (void *reader)
{
int rv = zpoller_remove (self, reader);
return rv;
}
