rbczmq 1.6.2 → 1.6.4

data/ext/zeromq/src/zmq_utils.cpp

@@ -0,0 +1,61 @@
+/*
+    Copyright (c) 2009-2011 250bpm s.r.o.
+    Copyright (c) 2007-2009 iMatix Corporation
+    Copyright (c) 2007-2011 Other contributors as noted in the AUTHORS file
+
+    This file is part of 0MQ.
+
+    0MQ is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    0MQ is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "platform.hpp"
+
+#include "../include/zmq_utils.h"
+
+#include <stdlib.h>
+
+#include "stdint.hpp"
+#include "clock.hpp"
+#include "err.hpp"
+
+#if !defined ZMQ_HAVE_WINDOWS
+#include <unistd.h>
+#else
+#include "windows.hpp"
+#endif
+
+void zmq_sleep (int seconds_)
+{
+#if defined ZMQ_HAVE_WINDOWS
+    Sleep (seconds_ * 1000);
+#else
+    sleep (seconds_);
+#endif
+}
+
+void *zmq_stopwatch_start ()
+{
+    uint64_t *watch = (uint64_t*) malloc (sizeof (uint64_t));
+    alloc_assert (watch);
+    *watch = zmq::clock_t::now_us ();
+    return (void*) watch;
+}
+
+unsigned long zmq_stopwatch_stop (void *watch_)
+{
+    uint64_t end = zmq::clock_t::now_us ();
+    uint64_t start = *(uint64_t*) watch_;
+    free (watch_);
+    return (unsigned long) (end - start);
+}

data/ext/zeromq/tests/Makefile.am

@@ -0,0 +1,55 @@
+INCLUDES = -I$(top_builddir)/include \
+           -I$(top_srcdir)/include
+
+LDADD = $(top_builddir)/src/libzmq.la
+
+noinst_PROGRAMS = test_pair_inproc \
+                  test_pair_tcp \
+                  test_reqrep_inproc \
+                  test_reqrep_tcp \
+                  test_hwm \
+                  test_reqrep_device \
+                  test_sub_forward \
+                  test_invalid_rep \
+                  test_msg_flags \
+                  test_connect_resolve \
+                  test_connect_delay \
+                  test_last_endpoint \
+                  test_term_endpoint \
+                  test_monitor \
+                  test_router_mandatory \
+                  test_disconnect_inproc
+
+
+if !ON_MINGW
+noinst_PROGRAMS += test_shutdown_stress \
+                   test_pair_ipc \
+                   test_reqrep_ipc \
+                   test_timeo
+endif
+
+test_pair_inproc_SOURCES = test_pair_inproc.cpp testutil.hpp
+test_pair_tcp_SOURCES = test_pair_tcp.cpp testutil.hpp
+test_reqrep_inproc_SOURCES = test_reqrep_inproc.cpp testutil.hpp
+test_reqrep_tcp_SOURCES = test_reqrep_tcp.cpp testutil.hpp
+test_hwm_SOURCES = test_hwm.cpp
+test_reqrep_device_SOURCES = test_reqrep_device.cpp
+test_sub_forward_SOURCES = test_sub_forward.cpp
+test_invalid_rep_SOURCES = test_invalid_rep.cpp
+test_msg_flags_SOURCES = test_msg_flags.cpp
+test_connect_resolve_SOURCES = test_connect_resolve.cpp
+test_connect_delay_SOURCES = test_connect_delay.cpp
+test_last_endpoint_SOURCES = test_last_endpoint.cpp
+test_term_endpoint_SOURCES = test_term_endpoint.cpp
+test_monitor_SOURCES = test_monitor.cpp
+test_disconnect_inproc_SOURCES = test_disconnect_inproc.cpp
+test_router_mandatory_SOURCES = test_router_mandatory.cpp
+
+if !ON_MINGW
+test_shutdown_stress_SOURCES = test_shutdown_stress.cpp
+test_pair_ipc_SOURCES = test_pair_ipc.cpp testutil.hpp
+test_reqrep_ipc_SOURCES = test_reqrep_ipc.cpp testutil.hpp
+test_timeo_SOURCES = test_timeo.cpp
+endif
+
+TESTS = $(noinst_PROGRAMS)

data/ext/zeromq/tests/test_connect_delay.cpp

@@ -0,0 +1,260 @@
+/*
+Copyright (c) 2012 Ian Barber
+Copyright (c) 2012 Other contributors as noted in the AUTHORS file
+
+This file is part of 0MQ.
+
+0MQ is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+(at your option) any later version.
+
+0MQ is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "../include/zmq.h"
+#include "../include/zmq_utils.h"
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <string>
+
+#undef NDEBUG
+#include <assert.h>
+
+int main (void)
+{
+    fprintf (stderr, "test_connect_delay running...\n");
+    int val;
+    int rc;
+    char buffer[16];
+    int seen = 0;
+
+    // TEST 1. 
+    // First we're going to attempt to send messages to two
+    // pipes, one connected, the other not. We should see
+    // the PUSH load balancing to both pipes, and hence half
+    // of the messages getting queued, as connect() creates a
+    // pipe immediately. 
+    
+    void *context = zmq_ctx_new();
+    assert (context);
+    void *to = zmq_socket(context, ZMQ_PULL);
+    assert (to);
+
+    // Bind the one valid receiver
+    val = 0;
+    rc = zmq_setsockopt(to, ZMQ_LINGER, &val, sizeof(val));
+    assert (rc == 0);
+    rc = zmq_bind(to, "tcp://*:5555");
+    assert (rc == 0);
+
+    // Create a socket pushing to two endpoints - only 1 message should arrive.
+    void *from = zmq_socket (context, ZMQ_PUSH);
+    assert(from);
+
+    val = 0;
+    zmq_setsockopt (from, ZMQ_LINGER, &val, sizeof(val));
+    // This pipe will not connect
+    rc = zmq_connect (from, "tcp://localhost:5556");
+    assert (rc == 0);
+    // This pipe will 
+    rc = zmq_connect (from, "tcp://localhost:5555");
+    assert (rc == 0);
+
+    // We send 10 messages, 5 should just get stuck in the queue
+    // for the not-yet-connected pipe
+    for (int i = 0; i < 10; ++i)
+    {
+        std::string message("message ");
+        message += ('0' + i);
+        rc = zmq_send (from, message.data(), message.size(), 0);
+        assert(rc >= 0);
+    }
+
+    // Sleep to allow the messages to be delivered
+    zmq_sleep (1);
+    
+    // We now consume from the connected pipe
+    // - we should see just 5
+    seen = 0;
+    for (int i = 0; i < 10; ++i)
+    {
+        memset (&buffer, 0, sizeof(buffer));
+        rc = zmq_recv (to, &buffer, sizeof(buffer), ZMQ_DONTWAIT);
+        if( rc == -1)
+            break;
+        seen++;
+    }
+    assert (seen == 5);
+
+    rc = zmq_close (from);
+    assert (rc == 0);
+
+    rc = zmq_close (to);
+    assert (rc == 0);
+
+    rc = zmq_ctx_destroy(context);
+    assert (rc == 0);
+
+    // TEST 2
+    // This time we will do the same thing, connect two pipes, 
+    // one of which will succeed in connecting to a bound 
+    // receiver, the other of which will fail. However, we will 
+    // also set the delay attach on connect flag, which should 
+    // cause the pipe attachment to be delayed until the connection
+    // succeeds. 
+    context = zmq_ctx_new();
+    fprintf (stderr, " Rerunning with DELAY_ATTACH_ON_CONNECT\n");
+
+    // Bind the valid socket
+    to = zmq_socket (context, ZMQ_PULL);
+    assert (to);
+    rc = zmq_bind (to, "tcp://*:5560");
+    assert (rc == 0);
+
+    val = 0;
+    rc = zmq_setsockopt (to, ZMQ_LINGER, &val, sizeof(val));
+    assert (rc == 0);
+
+    // Create a socket pushing to two endpoints - all messages should arrive.
+    from = zmq_socket (context, ZMQ_PUSH);
+    assert (from);
+
+    val = 0;
+    rc = zmq_setsockopt (from, ZMQ_LINGER, &val, sizeof(val));
+    assert (rc == 0);
+
+    // Set the key flag
+    val = 1;
+    rc = zmq_setsockopt (from, ZMQ_DELAY_ATTACH_ON_CONNECT, &val, sizeof(val));
+    assert (rc == 0);
+
+    // Connect to the invalid socket
+    rc = zmq_connect (from, "tcp://localhost:5561");
+    assert (rc == 0);
+    // Connect to the valid socket
+    rc = zmq_connect (from, "tcp://localhost:5560");
+    assert (rc == 0);
+
+    // Send 10 messages, all should be routed to the connected pipe
+    for (int i = 0; i < 10; ++i)
+    {
+        std::string message("message ");
+        message += ('0' + i);
+        rc = zmq_send (from, message.data(), message.size(), 0);
+        assert (rc >= 0);
+    }
+
+    // Sleep to allow the messages to be delivered
+    zmq_sleep (1);
+
+    // Send 10 messages, all should arrive. 
+    seen = 0;
+    for (int i = 0; i < 10; ++i)
+    {
+        memset(&buffer, 0, sizeof(buffer));
+        rc = zmq_recv (to, &buffer, sizeof(buffer), ZMQ_DONTWAIT);
+        // If there is a failed delivery, assert!
+        assert (rc != -1);
+    }
+
+    rc = zmq_close (from);
+    assert (rc == 0);
+
+    rc = zmq_close (to);
+    assert (rc == 0);
+    
+    rc = zmq_ctx_destroy(context);
+    assert (rc == 0);
+
+    // TEST 3
+    // This time we want to validate that the same blocking behaviour
+    // occurs with an existing connection that is broken. We will send
+    // messaages to a connected pipe, disconnect and verify the messages
+    // block. Then we reconnect and verify messages flow again.
+    context = zmq_ctx_new();
+    void *context2 = zmq_ctx_new();
+    fprintf (stderr, " Running DELAY_ATTACH_ON_CONNECT with disconnect\n");
+
+    to = zmq_socket (context2, ZMQ_PULL);
+    assert (to);
+    rc = zmq_bind (to, "tcp://*:5560");
+    assert (rc == 0);
+
+    val = 0;
+    rc = zmq_setsockopt (to, ZMQ_LINGER, &val, sizeof(val));
+    assert (rc == 0);
+
+    // Create a socket pushing 
+    from = zmq_socket (context, ZMQ_PUSH);
+    assert (from);
+
+    val = 0;
+    rc = zmq_setsockopt (from, ZMQ_LINGER, &val, sizeof(val));
+    assert (rc == 0);
+    val = 1;
+    rc = zmq_setsockopt (from, ZMQ_DELAY_ATTACH_ON_CONNECT, &val, sizeof(val));
+    assert (rc == 0);
+
+    // Connect to the valid socket socket
+    rc = zmq_connect (from, "tcp://localhost:5560");
+    assert (rc == 0);
+    
+    // Allow connections to stabilise
+    zmq_sleep(1);
+    
+    // Send a message, should succeed
+    std::string message("message ");
+    rc = zmq_send (from, message.data(), message.size(), 0);
+    assert (rc >= 0);
+    
+    rc = zmq_close (to);
+    assert (rc == 0);
+    
+    rc = zmq_ctx_destroy(context2);
+    assert (rc == 0);
+    
+    // Give time to process disconnect
+    zmq_sleep(1);
+    
+    // Send a message, should fail
+    rc = zmq_send (from, message.data(), message.size(), ZMQ_DONTWAIT);
+    assert (rc == -1);
+    
+    context2 = zmq_ctx_new();
+    to = zmq_socket (context2, ZMQ_PULL);
+    assert (to);
+    rc = zmq_bind (to, "tcp://*:5560");
+    assert (rc == 0);
+
+    val = 0;
+    rc = zmq_setsockopt (to, ZMQ_LINGER, &val, sizeof(val));
+    assert (rc == 0);
+    
+    // Allow connections to stabilise
+    zmq_sleep(1);
+    
+    // After the reconnect, should succeed
+    rc = zmq_send (from, message.data(), message.size(), 0);
+    assert (rc >= 0);
+    
+    rc = zmq_close (to);
+    assert (rc == 0);
+    
+    rc = zmq_close (from);
+    assert (rc == 0);
+
+    rc = zmq_ctx_destroy(context);
+    assert (rc == 0);
+    
+    rc = zmq_ctx_destroy(context2);
+    assert (rc == 0);
+}

data/ext/zeromq/tests/test_connect_resolve.cpp

@@ -0,0 +1,54 @@
+/*
+    Copyright (c) 2012 Spotify AB
+    Copyright (c) 2012 Other contributors as noted in the AUTHORS file
+
+    This file is part of 0MQ.
+
+    0MQ is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    0MQ is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "../include/zmq.h"
+#include <stdio.h>
+#include <errno.h>
+
+#undef NDEBUG
+#include <assert.h>
+
+int main (void)
+{
+    fprintf (stderr, "test_connect_resolve running...\n");
+
+    void *ctx = zmq_init (1);
+    assert (ctx);
+
+    //  Create pair of socket, each with high watermark of 2. Thus the total
+    //  buffer space should be 4 messages.
+    void *sock = zmq_socket (ctx, ZMQ_PUB);
+    assert (sock);
+
+    int rc = zmq_connect (sock, "tcp://localhost:1234");
+    assert (rc == 0);
+
+    rc = zmq_connect (sock, "tcp://0mq.is.teh.best:1234");
+    assert (rc == -1);
+    assert (errno == EINVAL);
+
+    rc = zmq_close (sock);
+    assert (rc == 0);
+
+    rc = zmq_term (ctx);
+    assert (rc == 0);
+
+    return 0;
+}

data/ext/zeromq/tests/test_disconnect_inproc.cpp

@@ -0,0 +1,120 @@
+#include <zmq.h>
+#include <inttypes.h>
+#include <string.h>
+#include <assert.h>
+
+/// Initialize a zeromq message with a given null-terminated string
+#define ZMQ_PREPARE_STRING(msg, data, size) \
+zmq_msg_init(&msg) && printf("zmq_msg_init: %s\n", zmq_strerror(errno)); \
+zmq_msg_init_size (&msg, size + 1) && printf("zmq_msg_init_size: %s\n",zmq_strerror(errno)); \
+memcpy(zmq_msg_data(&msg), data, size + 1);
+
+int publicationsReceived = 0;
+bool isSubscribed = false;
+
+int main(int argc, char** argv) {
+    void* context = zmq_ctx_new();
+    void* pubSocket;
+    void* subSocket;
+
+    (pubSocket = zmq_socket(context, ZMQ_XPUB))         || printf("zmq_socket: %s\n", zmq_strerror(errno));
+    (subSocket = zmq_socket(context, ZMQ_SUB))          || printf("zmq_socket: %s\n", zmq_strerror(errno));
+    zmq_setsockopt(subSocket, ZMQ_SUBSCRIBE, "foo", 3)  && printf("zmq_setsockopt: %s\n",zmq_strerror(errno));
+  
+    zmq_bind(pubSocket, "inproc://someInProcDescriptor") && printf("zmq_bind: %s\n", zmq_strerror(errno));
+    //zmq_bind(pubSocket, "tcp://*:30010") && printf("zmq_bind: %s\n", zmq_strerror(errno));
+  
+    int32_t more;
+    size_t more_size = sizeof(more);
+    int iteration = 0;
+  
+    while(1) {
+        zmq_pollitem_t items [] = {
+            { subSocket,    0, ZMQ_POLLIN, 0 }, // read publications
+            { pubSocket,    0, ZMQ_POLLIN, 0 }, // read subscriptions
+        };
+        zmq_poll(items, 2, 500);
+    
+        if (items[1].revents & ZMQ_POLLIN) {
+            while (1) {
+                zmq_msg_t msg;
+                zmq_msg_init (&msg);
+                zmq_msg_recv (&msg, pubSocket, 0);
+                int msgSize = zmq_msg_size(&msg);
+                char* buffer = (char*)zmq_msg_data(&msg);
+
+                if (buffer[0] == 0) {
+                    assert(isSubscribed);
+                    printf("unsubscribing from '%s'\n", strndup(buffer + 1, msgSize - 1));
+                    isSubscribed = false;
+                } else {
+                    assert(!isSubscribed);
+                    printf("subscribing on '%s'\n", strndup(buffer + 1, msgSize - 1));
+                    isSubscribed = true;
+                }
+
+                zmq_getsockopt (pubSocket, ZMQ_RCVMORE, &more, &more_size);
+                zmq_msg_close (&msg);
+
+                if (!more)
+                    break;      //  Last message part
+            }
+        }
+
+        if (items[0].revents & ZMQ_POLLIN) {
+            while (1) {
+                zmq_msg_t msg;
+                zmq_msg_init (&msg);
+                zmq_msg_recv (&msg, subSocket, 0);
+                int msgSize = zmq_msg_size(&msg);
+                char* buffer = (char*)zmq_msg_data(&msg);
+        
+                printf("received on subscriber '%s'\n", strndup(buffer, msgSize));
+        
+                zmq_getsockopt (subSocket, ZMQ_RCVMORE, &more, &more_size);
+                zmq_msg_close (&msg);
+        
+                if (!more) {
+                    publicationsReceived++;
+                    break;      //  Last message part
+                }
+            }
+        }
+
+        if (iteration == 1) {
+            zmq_connect(subSocket, "inproc://someInProcDescriptor") && printf("zmq_connect: %s\n", zmq_strerror(errno));
+            //zmq_connect(subSocket, "tcp://127.0.0.1:30010") && printf("zmq_connect: %s\n", zmq_strerror(errno));
+        }
+    
+        if (iteration == 4) {
+            zmq_disconnect(subSocket, "inproc://someInProcDescriptor") && printf("zmq_disconnect(%d): %s\n", errno, zmq_strerror(errno));
+            //zmq_disconnect(subSocket, "tcp://127.0.0.1:30010") && printf("zmq_disconnect: %s\n", zmq_strerror(errno));
+        }
+    
+        if (iteration == 10) {
+            break;
+        }
+    
+        zmq_msg_t channelEnvlp;
+        ZMQ_PREPARE_STRING(channelEnvlp, "foo", 3);
+        zmq_sendmsg(pubSocket, &channelEnvlp, ZMQ_SNDMORE) >= 0 || printf("zmq_sendmsg: %s\n",zmq_strerror(errno));
+        zmq_msg_close(&channelEnvlp) && printf("zmq_msg_close: %s\n",zmq_strerror(errno));
+
+        zmq_msg_t message;
+        ZMQ_PREPARE_STRING(message, "this is foo!", 12);
+        zmq_sendmsg(pubSocket, &message, 0) >= 0 || printf("zmq_sendmsg: %s\n",zmq_strerror(errno));
+        zmq_msg_close(&message) && printf("zmq_msg_close: %s\n",zmq_strerror(errno));
+
+        iteration++;
+    }
+  
+    assert(publicationsReceived == 3);
+    assert(!isSubscribed);
+
+    zmq_close(pubSocket) && printf("zmq_close: %s", zmq_strerror(errno));
+    zmq_close(subSocket) && printf("zmq_close: %s", zmq_strerror(errno));
+  
+    zmq_ctx_destroy(context);
+    return 0;
+}
+