JNIEXPORT jstring JNICALL
Java_org_zeromq_czmq_Zsock__1_1typeStr (JNIEnv *env, jclass c, jlong self)
{
char *type_str_ = (char *) zsock_type_str ((zsock_t *) (intptr_t) self);
jstring return_string_ = (*env)->NewStringUTF (env, type_str_);
return return_string_;
}
void
zloop_reader_end (zloop_t *self, zsock_t *sock)
{
assert (self);
assert (sock);
s_reader_t *reader = (s_reader_t *) zlistx_first (self->readers);
while (reader) {
if (reader->sock == sock) {
zlistx_delete (self->readers, reader->list_handle);
self->need_rebuild = true;
}
reader = (s_reader_t *) zlistx_next (self->readers);
}
if (self->verbose)
zsys_debug ("zloop: cancel %s reader", zsock_type_str (sock));
}
void
zloop_reader_end (zloop_t *self, zsock_t *sock)
{
assert (self);
assert (sock);
s_reader_t *reader = (s_reader_t *) zlist_first (self->readers);
while (reader) {
if (reader->sock == sock) {
zlist_remove (self->readers, reader);
free (reader);
self->need_rebuild = true;
}
reader = (s_reader_t *) zlist_next (self->readers);
}
if (self->verbose)
zclock_log ("I: zloop: cancel %s reader", zsock_type_str (sock));
}
int
zloop_reader (zloop_t *self, zsock_t *sock, zloop_reader_fn handler, void *arg)
{
assert (self);
assert (sock);
s_reader_t *reader = s_reader_new (sock, handler, arg);
if (reader) {
reader->list_handle = zlistx_add_end (self->readers, reader);
assert (reader->list_handle);
self->need_rebuild = true;
if (self->verbose)
zsys_debug ("zloop: register %s reader", zsock_type_str (sock));
return 0;
}
else
return -1;
}
int
zloop_reader (zloop_t *self, zsock_t *sock, zloop_reader_fn handler, void *arg)
{
assert (self);
assert (sock);
s_reader_t *reader = s_reader_new (sock, handler, arg);
if (reader) {
if (zlist_append (self->readers, reader))
return -1;
self->need_rebuild = true;
if (self->verbose)
zclock_log ("I: zloop: register %s reader", zsock_type_str (sock));
return 0;
}
else
return -1;
}
///
// Returns socket type as printable constant string.
const QString QZsock::typeStr ()
{
const QString rv = QString (zsock_type_str (self));
return rv;
}
int
zloop_start (zloop_t *self)
{
assert (self);
int rc = 0;
// Main reactor loop
while (!zsys_interrupted) {
if (self->need_rebuild) {
// If s_rebuild_pollset() fails, break out of the loop and
// return its error
rc = s_rebuild_pollset (self);
if (rc)
break;
}
rc = zmq_poll (self->pollset, (int) self->poll_size, s_tickless (self));
if (rc == -1 || zsys_interrupted) {
if (self->verbose)
zsys_debug ("zloop: interrupted");
rc = 0;
break; // Context has been shut down
}
// Handle any timers that have now expired
int64_t time_now = zclock_mono ();
s_timer_t *timer = (s_timer_t *) zlistx_first (self->timers);
while (timer) {
if (time_now >= timer->when) {
if (self->verbose)
zsys_debug ("zloop: call timer handler id=%d", timer->timer_id);
rc = timer->handler (self, timer->timer_id, timer->arg);
if (rc == -1)
break; // Timer handler signaled break
if (timer->times && --timer->times == 0)
zlistx_delete (self->timers, timer->list_handle);
else
timer->when += timer->delay;
}
timer = (s_timer_t *) zlistx_next (self->timers);
}
// Handle any tickets that have now expired
s_ticket_t *ticket = (s_ticket_t *) zlistx_first (self->tickets);
while (ticket && time_now >= ticket->when) {
if (self->verbose)
zsys_debug ("zloop: call ticket handler");
rc = ticket->handler (self, 0, ticket->arg);
if (rc == -1)
break; // Timer handler signaled break
zlistx_delete (self->tickets, ticket->list_handle);
ticket = (s_ticket_t *) zlistx_next (self->tickets);
}
// Handle any readers and pollers that are ready
size_t item_nbr;
for (item_nbr = 0; item_nbr < self->poll_size && rc >= 0; item_nbr++) {
s_reader_t *reader = &self->readact [item_nbr];
if (reader->handler) {
if ((self->pollset [item_nbr].revents & ZMQ_POLLERR)
&& !reader->tolerant) {
if (self->verbose)
zsys_warning ("zloop: can't read %s socket: %s",
zsock_type_str (reader->sock),
zmq_strerror (zmq_errno ()));
// Give handler one chance to handle error, then kill
// reader because it'll disrupt the reactor otherwise.
if (reader->errors++) {
zloop_reader_end (self, reader->sock);
self->pollset [item_nbr].revents = 0;
}
}
else
reader->errors = 0; // A non-error happened
if (self->pollset [item_nbr].revents) {
if (self->verbose)
zsys_debug ("zloop: call %s socket handler",
zsock_type_str (reader->sock));
rc = reader->handler (self, reader->sock, reader->arg);
if (rc == -1 || self->need_rebuild)
break;
}
}
else {
s_poller_t *poller = &self->pollact [item_nbr];
assert (self->pollset [item_nbr].socket == poller->item.socket);
if ((self->pollset [item_nbr].revents & ZMQ_POLLERR)
&& !poller->tolerant) {
if (self->verbose)
zsys_warning ("zloop: can't poll %s socket (%p, %d): %s",
poller->item.socket ?
zsys_sockname (zsock_type (poller->item.socket)) : "FD",
poller->item.socket, poller->item.fd,
zmq_strerror (zmq_errno ()));
// Give handler one chance to handle error, then kill
// poller because it'll disrupt the reactor otherwise.
if (poller->errors++) {
zloop_poller_end (self, &poller->item);
self->pollset [item_nbr].revents = 0;
}
}
else
poller->errors = 0; // A non-error happened
if (self->pollset [item_nbr].revents) {
if (self->verbose)
zsys_debug ("zloop: call %s socket handler (%p, %d)",
poller->item.socket ?
zsys_sockname (zsock_type (poller->item.socket)) : "FD",
poller->item.socket, poller->item.fd);
rc = poller->handler (self, &self->pollset [item_nbr], poller->arg);
if (rc == -1 || self->need_rebuild)
break;
}
}
}
// Now handle any timer zombies
// This is going to be slow if we have many timers; we might use
// a faster lookup on the timer list.
while (zlistx_first (self->zombies)) {
// Get timer_id back from pointer
int timer_id = (byte *) zlistx_detach (self->zombies, NULL) - (byte *) NULL;
s_timer_remove (self, timer_id);
}
if (rc == -1)
break;
}
self->terminated = true;
return rc;
}
void
zsock_test (bool verbose)
{
printf (" * zsock: ");
// @selftest
zsock_t *writer = zsock_new_push ("@tcp://127.0.0.1:5560");
assert (writer);
assert (zsock_resolve (writer) != writer);
assert (streq (zsock_type_str (writer), "PUSH"));
int rc;
#if (ZMQ_VERSION >= ZMQ_MAKE_VERSION (3,2,0))
// Check unbind
rc = zsock_unbind (writer, "tcp://127.0.0.1:%d", 5560);
assert (rc == 0);
// In some cases and especially when running under Valgrind, doing
// a bind immediately after an unbind causes an EADDRINUSE error.
// Even a short sleep allows the OS to release the port for reuse.
zclock_sleep (100);
// Bind again
rc = zsock_bind (writer, "tcp://127.0.0.1:%d", 5560);
assert (rc == 5560);
assert (streq (zsock_endpoint (writer), "tcp://127.0.0.1:5560"));
#endif
zsock_t *reader = zsock_new_pull (">tcp://127.0.0.1:5560");
assert (reader);
assert (zsock_resolve (reader) != reader);
assert (streq (zsock_type_str (reader), "PULL"));
zstr_send (writer, "Hello, World");
zmsg_t *msg = zsock_recv (reader);
assert (msg);
char *string = zmsg_popstr (msg);
assert (streq (string, "Hello, World"));
free (string);
zmsg_destroy (&msg);
// Test binding to ephemeral ports, sequential and random
int port = zsock_bind (writer, "tcp://127.0.0.1:*");
assert (port >= DYNAMIC_FIRST && port <= DYNAMIC_LAST);
port = zsock_bind (writer, "tcp://127.0.0.1:*[50000-]");
assert (port >= 50000 && port <= DYNAMIC_LAST);
port = zsock_bind (writer, "tcp://127.0.0.1:*[-50001]");
assert (port >= DYNAMIC_FIRST && port <= 50001);
port = zsock_bind (writer, "tcp://127.0.0.1:*[60000-60010]");
assert (port >= 60000 && port <= 60010);
port = zsock_bind (writer, "tcp://127.0.0.1:!");
assert (port >= DYNAMIC_FIRST && port <= DYNAMIC_LAST);
port = zsock_bind (writer, "tcp://127.0.0.1:![50000-]");
assert (port >= 50000 && port <= DYNAMIC_LAST);
port = zsock_bind (writer, "tcp://127.0.0.1:![-50001]");
assert (port >= DYNAMIC_FIRST && port <= 50001);
port = zsock_bind (writer, "tcp://127.0.0.1:![60000-60010]");
assert (port >= 60000 && port <= 60010);
// Test zsock_endpoint method
rc = zsock_bind (writer, "inproc://test.%s", "writer");
assert (rc == 0);
assert (streq (zsock_endpoint (writer), "inproc://test.writer"));
// Test error state when connecting to an invalid socket type
// ('txp://' instead of 'tcp://', typo intentional)
rc = zsock_connect (reader, "txp://127.0.0.1:5560");
assert (rc == -1);
rc = zsock_signal (writer, 123);
assert (rc == 0);
rc = zsock_wait (reader);
assert (rc == 123);
zsock_destroy (&reader);
zsock_destroy (&writer);
// Test zsock_attach method
zsock_t *server = zsock_new (ZMQ_DEALER);
rc = zsock_attach (server, "@inproc://myendpoint,tcp://127.0.0.1:5556,inproc://others", true);
assert (rc == 0);
rc = zsock_attach (server, "", false);
assert (rc == 0);
rc = zsock_attach (server, NULL, true);
assert (rc == 0);
rc = zsock_attach (server, ">a,@b, c,, ", false);
assert (rc == -1);
zsock_destroy (&server);
// @end
printf ("OK\n");
}
Z K1(zsocktypestr){PC(x); R ks((const S)zsock_type_str(VSK(x)));}
///
// Returns socket type as printable constant string.
const QString QmlZsock::typeStr () {
return QString (zsock_type_str (self));
};
