void assert_status (zactor_t *actor, int count)
{
zstr_sendx (actor, "STATUS", NULL);
// Get STATUS reply and check it
bool ready = false;
while (!ready) {
char *command, *status;
zstr_recvx (actor, &command, &status, NULL);
if (streq (command, "STATUS")) {
assert (atoi (status) == count);
ready = true;
}
free (command);
free (status);
}
}
static void
zyre_node_recv_gossip (zyre_node_t *self)
{
// Get IP address and beacon of peer
char *command = NULL, *uuidstr, *endpoint;
zstr_recvx (self->gossip, &command, &uuidstr, &endpoint, NULL);
if (command == NULL)
return; // Interrupted
// Any replies except DELIVER would signify an internal error; these
// messages come from zgossip, not an external source
assert (streq (command, "DELIVER"));
// Require peer, if it's not us
if (strneq (endpoint, self->endpoint)) {
zuuid_t *uuid = zuuid_new ();
zuuid_set_str (uuid, uuidstr);
zyre_node_require_peer (self, uuid, endpoint);
zuuid_destroy (&uuid);
}
zstr_free (&command);
zstr_free (&uuidstr);
zstr_free (&endpoint);
}
void
zbeacon_test (bool verbose)
{
printf (" * zbeacon: ");
if (verbose)
printf ("\n");
// @selftest
// Test 1 - two beacons, one speaking, one listening
// Create speaker beacon to broadcast our service
zactor_t *speaker = zactor_new (zbeacon, NULL);
assert (speaker);
if (verbose)
zstr_sendx (speaker, "VERBOSE", NULL);
zsock_send (speaker, "si", "CONFIGURE", 9999);
char *hostname = zstr_recv (speaker);
if (!*hostname) {
printf ("OK (skipping test, no UDP broadcasting)\n");
zactor_destroy (&speaker);
free (hostname);
return;
}
free (hostname);
// Create listener beacon on port 9999 to lookup service
zactor_t *listener = zactor_new (zbeacon, NULL);
assert (listener);
if (verbose)
zstr_sendx (listener, "VERBOSE", NULL);
zsock_send (listener, "si", "CONFIGURE", 9999);
hostname = zstr_recv (listener);
assert (*hostname);
free (hostname);
// We will broadcast the magic value 0xCAFE
byte announcement [2] = { 0xCA, 0xFE };
zsock_send (speaker, "sbi", "PUBLISH", announcement, 2, 100);
// We will listen to anything (empty subscription)
zsock_send (listener, "sb", "SUBSCRIBE", "", 0);
// Wait for at most 1/2 second if there's no broadcasting
zsock_set_rcvtimeo (listener, 500);
char *ipaddress = zstr_recv (listener);
if (ipaddress) {
zframe_t *content = zframe_recv (listener);
assert (zframe_size (content) == 2);
assert (zframe_data (content) [0] == 0xCA);
assert (zframe_data (content) [1] == 0xFE);
zframe_destroy (&content);
zstr_free (&ipaddress);
zstr_sendx (speaker, "SILENCE", NULL);
}
zactor_destroy (&listener);
zactor_destroy (&speaker);
// Test subscription filter using a 3-node setup
zactor_t *node1 = zactor_new (zbeacon, NULL);
assert (node1);
zsock_send (node1, "si", "CONFIGURE", 5670);
hostname = zstr_recv (node1);
assert (*hostname);
free (hostname);
zactor_t *node2 = zactor_new (zbeacon, NULL);
assert (node2);
zsock_send (node2, "si", "CONFIGURE", 5670);
hostname = zstr_recv (node2);
assert (*hostname);
free (hostname);
zactor_t *node3 = zactor_new (zbeacon, NULL);
assert (node3);
zsock_send (node3, "si", "CONFIGURE", 5670);
hostname = zstr_recv (node3);
assert (*hostname);
free (hostname);
zsock_send (node1, "sbi", "PUBLISH", "NODE/1", 6, 250);
zsock_send (node2, "sbi", "PUBLISH", "NODE/2", 6, 250);
zsock_send (node3, "sbi", "PUBLISH", "RANDOM", 6, 250);
zsock_send (node1, "sb", "SUBSCRIBE", "NODE", 4);
// Poll on three API sockets at once
zpoller_t *poller = zpoller_new (node1, node2, node3, NULL);
assert (poller);
int64_t stop_at = zclock_mono () + 1000;
while (zclock_mono () < stop_at) {
long timeout = (long) (stop_at - zclock_mono ());
if (timeout < 0)
timeout = 0;
void *which = zpoller_wait (poller, timeout * ZMQ_POLL_MSEC);
if (which) {
assert (which == node1);
char *ipaddress, *received;
zstr_recvx (node1, &ipaddress, &received, NULL);
assert (streq (received, "NODE/2"));
zstr_free (&ipaddress);
zstr_free (&received);
}
}
zpoller_destroy (&poller);
// Stop listening
zstr_sendx (node1, "UNSUBSCRIBE", NULL);
// Stop all node broadcasts
zstr_sendx (node1, "SILENCE", NULL);
zstr_sendx (node2, "SILENCE", NULL);
zstr_sendx (node3, "SILENCE", NULL);
// Destroy the test nodes
zactor_destroy (&node1);
zactor_destroy (&node2);
zactor_destroy (&node3);
// @end
printf ("OK\n");
}
void
mlm_server_test (bool verbose)
{
printf (" * mlm_server: ");
if (verbose)
printf ("\n");
// @selftest
zactor_t *server = zactor_new (mlm_server, "mlm_server_test");
if (verbose)
zstr_send (server, "VERBOSE");
zstr_sendx (server, "BIND", "tcp://127.0.0.1:*", NULL);
zstr_sendx (server, "PORT", NULL);
char *command, *port;
int rc = zstr_recvx (server, &command, &port, NULL);
assert (rc == 2);
assert (streq (command, "PORT"));
assert (strlen (port) > 0 && strlen (port) < 6);
assert (!streq (port, "-1"));
zsock_t *reader = zsock_new (ZMQ_DEALER);
assert (reader);
zsock_connect (reader, "tcp://127.0.0.1:%s", port);
zsock_set_rcvtimeo (reader, 500);
mlm_proto_t *proto = mlm_proto_new ();
// Server insists that connection starts properly
mlm_proto_set_id (proto, MLM_PROTO_STREAM_WRITE);
mlm_proto_send (proto, reader);
zclock_sleep (500); // to calm things down && make memcheck pass. Thanks @malanka
mlm_proto_recv (proto, reader);
zclock_sleep (500); // detto as above
assert (mlm_proto_id (proto) == MLM_PROTO_ERROR);
assert (mlm_proto_status_code (proto) == MLM_PROTO_COMMAND_INVALID);
// Now do a stream publish-subscribe test
zsock_t *writer = zsock_new (ZMQ_DEALER);
assert (writer);
zsock_connect (writer, "tcp://127.0.0.1:%s", port);
zsock_set_rcvtimeo (reader, 500);
// Open connections from both reader and writer
mlm_proto_set_id (proto, MLM_PROTO_CONNECTION_OPEN);
mlm_proto_send (proto, reader);
mlm_proto_recv (proto, reader);
assert (mlm_proto_id (proto) == MLM_PROTO_OK);
mlm_proto_set_id (proto, MLM_PROTO_CONNECTION_OPEN);
mlm_proto_send (proto, writer);
mlm_proto_recv (proto, writer);
assert (mlm_proto_id (proto) == MLM_PROTO_OK);
// Prepare to write and read a "weather" stream
mlm_proto_set_id (proto, MLM_PROTO_STREAM_WRITE);
mlm_proto_set_stream (proto, "weather");
mlm_proto_send (proto, writer);
mlm_proto_recv (proto, writer);
assert (mlm_proto_id (proto) == MLM_PROTO_OK);
mlm_proto_set_id (proto, MLM_PROTO_STREAM_READ);
mlm_proto_set_pattern (proto, "temp.*");
mlm_proto_send (proto, reader);
mlm_proto_recv (proto, reader);
assert (mlm_proto_id (proto) == MLM_PROTO_OK);
// Now send some weather data, with null contents
mlm_proto_set_id (proto, MLM_PROTO_STREAM_SEND);
mlm_proto_set_subject (proto, "temp.moscow");
mlm_proto_send (proto, writer);
mlm_proto_set_subject (proto, "rain.moscow");
mlm_proto_send (proto, writer);
mlm_proto_set_subject (proto, "temp.chicago");
mlm_proto_send (proto, writer);
mlm_proto_set_subject (proto, "rain.chicago");
mlm_proto_send (proto, writer);
mlm_proto_set_subject (proto, "temp.london");
mlm_proto_send (proto, writer);
mlm_proto_set_subject (proto, "rain.london");
mlm_proto_send (proto, writer);
// We should receive exactly three deliveries, in order
mlm_proto_recv (proto, reader);
assert (mlm_proto_id (proto) == MLM_PROTO_STREAM_DELIVER);
assert (streq (mlm_proto_subject (proto), "temp.moscow"));
mlm_proto_recv (proto, reader);
assert (mlm_proto_id (proto) == MLM_PROTO_STREAM_DELIVER);
assert (streq (mlm_proto_subject (proto), "temp.chicago"));
mlm_proto_recv (proto, reader);
assert (mlm_proto_id (proto) == MLM_PROTO_STREAM_DELIVER);
assert (streq (mlm_proto_subject (proto), "temp.london"));
mlm_proto_destroy (&proto);
// Finished, we can clean up
zsock_destroy (&writer);
zsock_destroy (&reader);
zactor_destroy (&server);
zstr_free (&port);
zstr_free (&command);
// Test Case:
// CLIENTLIST command
{
const char *endpoint = "inproc://mlm_server_clientlist_test";
zactor_t *server = zactor_new (mlm_server, "mlm_server_clientlist_test");
if (verbose)
zstr_send (server, "VERBOSE");
zstr_sendx (server, "BIND", endpoint, NULL);
mlm_client_t *client_1 = mlm_client_new ();
int rv = mlm_client_connect (client_1, endpoint, 1000, "Karol");
assert (rv >= 0);
mlm_client_t *client_2 = mlm_client_new ();
rv = mlm_client_connect (client_2, endpoint, 1000, "Tomas");
assert (rv >= 0);
mlm_client_t *client_3 = mlm_client_new ();
rv = mlm_client_connect (client_3, endpoint, 1000, "Alenka");
assert (rv >= 0);
zclock_sleep (500);
zstr_sendx (server, "CLIENTLIST", NULL);
zmsg_t *message = zmsg_recv (server);
assert (message);
assert (zmsg_size (message) == 4);
char *pop = zmsg_popstr (message);
assert (streq (pop, "CLIENTLIST"));
zstr_free (&pop);
zlistx_t *expected_names = zlistx_new ();
assert (expected_names);
zlistx_set_destructor (expected_names, (czmq_destructor *) zstr_free);
zlistx_set_duplicator (expected_names, (czmq_duplicator *) strdup);
zlistx_set_comparator (expected_names, (czmq_comparator *) strcmp);
zlistx_add_end (expected_names, (void *) "Karol");
zlistx_add_end (expected_names, (void *) "Tomas");
zlistx_add_end (expected_names, (void *) "Alenka");
pop = zmsg_popstr (message);
assert (pop);
void *handle = zlistx_find (expected_names, pop);
assert (handle);
rv = zlistx_delete (expected_names, handle);
assert (rv == 0);
zstr_free (&pop);
pop = zmsg_popstr (message);
assert (pop);
handle = zlistx_find (expected_names, pop);
assert (handle);
rv = zlistx_delete (expected_names, handle);
assert (rv == 0);
zstr_free (&pop);
pop = zmsg_popstr (message);
assert (pop);
handle = zlistx_find (expected_names, pop);
assert (handle);
rv = zlistx_delete (expected_names, handle);
assert (rv == 0);
zstr_free (&pop);
pop = zmsg_popstr (message);
assert (pop == NULL);
assert (zlistx_size (expected_names) == 0);
zmsg_destroy (&message);
// remove a client Karol
mlm_client_destroy (&client_1);
zlistx_add_end (expected_names, (void *) "Tomas");
zlistx_add_end (expected_names, (void *) "Alenka");
zstr_sendx (server, "CLIENTLIST", NULL);
zclock_sleep (100);
message = zmsg_recv (server);
assert (message);
assert (zmsg_size (message) == 3);
pop = zmsg_popstr (message);
assert (streq (pop, "CLIENTLIST"));
zstr_free (&pop);
pop = zmsg_popstr (message);
assert (pop);
handle = zlistx_find (expected_names, pop);
assert (handle);
rv = zlistx_delete (expected_names, handle);
assert (rv == 0);
zstr_free (&pop);
pop = zmsg_popstr (message);
assert (pop);
handle = zlistx_find (expected_names, pop);
assert (handle);
rv = zlistx_delete (expected_names, handle);
assert (rv == 0);
zstr_free (&pop);
pop = zmsg_popstr (message);
assert (pop == NULL);
assert (zlistx_size (expected_names) == 0);
zlistx_destroy (&expected_names);
zmsg_destroy (&message);
mlm_client_destroy (&client_2);
mlm_client_destroy (&client_3);
zactor_destroy (&server);
}
// Test Case:
// STREAMLIST command
{
const char *endpoint = "inproc://mlm_server_streamlist_test";
zactor_t *server = zactor_new (mlm_server, "mlm_server_streamlist_test");
if (verbose)
zstr_send (server, "VERBOSE");
zstr_sendx (server, "BIND", endpoint, NULL);
mlm_client_t *client_1 = mlm_client_new ();
int rv = mlm_client_connect (client_1, endpoint, 1000, "Karol");
assert (rv != -1);
rv = mlm_client_set_producer (client_1, "STREAM_1");
assert (rv != -1);
mlm_client_t *client_2 = mlm_client_new ();
rv = mlm_client_connect (client_2, endpoint, 1000, "Tomas");
assert (rv != -1);
rv = mlm_client_set_producer (client_2, "STREAM_2");
assert (rv != -1);
mlm_client_t *client_3 = mlm_client_new ();
rv = mlm_client_connect (client_3, endpoint, 1000, "Alenka");
assert (rv != -1);
rv = mlm_client_set_consumer (client_3, "STREAM_2", ".*");
assert (rv != -1);
zclock_sleep (100);
zlistx_t *expected_streams = zlistx_new ();
assert (expected_streams);
zlistx_set_destructor (expected_streams, (czmq_destructor *) zstr_free);
zlistx_set_duplicator (expected_streams, (czmq_duplicator *) strdup);
zlistx_set_comparator (expected_streams, (czmq_comparator *) strcmp);
zlistx_add_end (expected_streams, (void *) "STREAM_1");
zlistx_add_end (expected_streams, (void *) "STREAM_2");
zstr_sendx (server, "STREAMLIST", NULL);
zmsg_t *message = zmsg_recv (server);
assert (message);
assert (zmsg_size (message) == 3);
char *pop = zmsg_popstr (message);
assert (streq (pop, "STREAMLIST"));
zstr_free (&pop);
pop = zmsg_popstr (message);
assert (pop);
void *handle = zlistx_find (expected_streams, pop);
assert (handle);
rv = zlistx_delete (expected_streams, handle);
assert (rv == 0);
zstr_free (&pop);
pop = zmsg_popstr (message);
assert (pop);
handle = zlistx_find (expected_streams, pop);
assert (handle);
rv = zlistx_delete (expected_streams, handle);
assert (rv == 0);
zstr_free (&pop);
pop = zmsg_popstr (message);
assert (pop == NULL);
assert (zlistx_size (expected_streams) == 0);
zmsg_destroy (&message);
// NOTE: Currently when producer disconnects, malamute does not destroy the stream
// Therefore it doesn't make sense to test removal of streams, but addition
mlm_client_t *client_4 = mlm_client_new ();
rv = mlm_client_connect (client_4, endpoint, 1000, "Michal");
assert (rv >= 0);
rv = mlm_client_set_producer (client_4, "New stream");
assert (rv >= 0);
zlistx_add_end (expected_streams, (void *) "STREAM_1");
zlistx_add_end (expected_streams, (void *) "STREAM_2");
zlistx_add_end (expected_streams, (void *) "New stream");
zclock_sleep (100);
zstr_sendx (server, "STREAMLIST", NULL);
zclock_sleep (100);
message = zmsg_recv (server);
assert (message);
assert (zmsg_size (message) == 4);
pop = zmsg_popstr (message);
assert (streq (pop, "STREAMLIST"));
zstr_free (&pop);
pop = zmsg_popstr (message);
assert (pop);
handle = zlistx_find (expected_streams, pop);
assert (handle);
rv = zlistx_delete (expected_streams, handle);
assert (rv == 0);
zstr_free (&pop);
pop = zmsg_popstr (message);
assert (pop);
handle = zlistx_find (expected_streams, pop);
assert (handle);
rv = zlistx_delete (expected_streams, handle);
assert (rv == 0);
zstr_free (&pop);
pop = zmsg_popstr (message);
assert (pop);
handle = zlistx_find (expected_streams, pop);
assert (handle);
rv = zlistx_delete (expected_streams, handle);
assert (rv == 0);
zstr_free (&pop);
pop = zmsg_popstr (message);
assert (pop == NULL);
assert (zlistx_size (expected_streams) == 0);
zlistx_destroy (&expected_streams);
zmsg_destroy (&message);
mlm_client_destroy (&client_1);
mlm_client_destroy (&client_2);
mlm_client_destroy (&client_3);
mlm_client_destroy (&client_4);
zactor_destroy (&server);
}
// Regression Test Case:
// Segfault from deregistering zombie connection
{
const char *endpoint = "inproc://mlm_server_deregister_zombie_connection_test";
zactor_t *server = zactor_new (mlm_server, "mlm_server_deregister_zombie_connection_test");
if (verbose)
zstr_send (server, "VERBOSE");
zstr_sendx (server, "BIND", endpoint, NULL);
zstr_sendx (server, "SET", "server/timeout", "3000", NULL); // 3 second client timeout
zsock_t *reader = zsock_new (ZMQ_DEALER);
assert (reader);
zsock_connect (reader, "inproc://mlm_server_deregister_zombie_connection_test");
zsock_set_rcvtimeo (reader, 500);
mlm_proto_t *proto = mlm_proto_new ();
// If the malamute server is restarted and clients have queued
// up ping messages, the'll be sent before any
// CONNECTION_OPEN. The server eventually tries to deregister
// this and (previously) would derefence a null pointer for
// the client address.
mlm_proto_set_id (proto, MLM_PROTO_CONNECTION_PING);
mlm_proto_send (proto, reader);
printf("Regression test for segfault due to leftover client messages after restart...\n");
// Give the server more than 3 seconds to time out the client...
zclock_sleep (3100);
printf("passed\n");
mlm_proto_destroy (&proto);
zsock_destroy (&reader);
zactor_destroy (&server);
}
{
const char *endpoint = "inproc://mlm_server_disconnect_pending_stream_traffic";
zactor_t *server = zactor_new (mlm_server, "mlm_server_disconnect_pending_stream_traffic");
if (verbose) {
zstr_send (server, "VERBOSE");
printf("Regression test for use-after-free with pending stream traffic after disconnect\n");
}
zstr_sendx (server, "BIND", endpoint, NULL);
mlm_client_t *producer = mlm_client_new ();
assert (mlm_client_connect (producer, endpoint, 1000, "producer") >= 0);
assert (mlm_client_set_producer (producer, "STREAM_TEST") >= 0);
zstr_sendx (server, "SLOW_TEST_MODE", NULL);
mlm_client_t *consumer = mlm_client_new ();
assert (mlm_client_connect (consumer, endpoint, 1000, "consumer") >= 0);
assert (mlm_client_set_consumer (consumer, "STREAM_TEST", ".*") >= 0);
zmsg_t *msg = zmsg_new ();
zmsg_addstr (msg, "world");
assert (mlm_client_send (producer, "hello", &msg) >= 0);
mlm_client_destroy (&consumer);
zclock_sleep (2000);
mlm_client_destroy (&producer);
zactor_destroy (&server);
}
// @end
printf ("OK\n");
}
void
zproxy_test (bool verbose)
{
printf (" * zproxy: ");
if (verbose)
printf ("\n");
// @selftest
// Create and configure our proxy
zactor_t *proxy = zactor_new (zproxy, NULL);
assert (proxy);
if (verbose) {
zstr_sendx (proxy, "VERBOSE", NULL);
zsock_wait (proxy);
}
zstr_sendx (proxy, "FRONTEND", "PULL", "inproc://frontend", NULL);
zsock_wait (proxy);
zstr_sendx (proxy, "BACKEND", "PUSH", "inproc://backend", NULL);
zsock_wait (proxy);
// Connect application sockets to proxy
zsock_t *faucet = zsock_new_push (">inproc://frontend");
assert (faucet);
zsock_t *sink = zsock_new_pull (">inproc://backend");
assert (sink);
// Send some messages and check they arrived
char *hello, *world;
zstr_sendx (faucet, "Hello", "World", NULL);
zstr_recvx (sink, &hello, &world, NULL);
assert (streq (hello, "Hello"));
assert (streq (world, "World"));
zstr_free (&hello);
zstr_free (&world);
// Test pause/resume functionality
zstr_sendx (proxy, "PAUSE", NULL);
zsock_wait (proxy);
zstr_sendx (faucet, "Hello", "World", NULL);
zsock_set_rcvtimeo (sink, 100);
zstr_recvx (sink, &hello, &world, NULL);
assert (!hello && !world);
zstr_sendx (proxy, "RESUME", NULL);
zsock_wait (proxy);
zstr_recvx (sink, &hello, &world, NULL);
assert (streq (hello, "Hello"));
assert (streq (world, "World"));
zstr_free (&hello);
zstr_free (&world);
// Test capture functionality
zsock_t *capture = zsock_new_pull ("inproc://capture");
assert (capture);
// Switch on capturing, check that it works
zstr_sendx (proxy, "CAPTURE", "inproc://capture", NULL);
zsock_wait (proxy);
zstr_sendx (faucet, "Hello", "World", NULL);
zstr_recvx (sink, &hello, &world, NULL);
assert (streq (hello, "Hello"));
assert (streq (world, "World"));
zstr_free (&hello);
zstr_free (&world);
zstr_recvx (capture, &hello, &world, NULL);
assert (streq (hello, "Hello"));
assert (streq (world, "World"));
zstr_free (&hello);
zstr_free (&world);
zsock_destroy (&faucet);
zsock_destroy (&sink);
zsock_destroy (&capture);
zactor_destroy (&proxy);
// @end
printf ("OK\n");
}
///
// Receive a series of strings (until NULL) from multipart data.
// Each string is allocated and filled with string data; if there
// are not enough frames, unallocated strings are set to NULL.
// Returns -1 if the message could not be read, else returns the
// number of strings filled, zero or more. Free each returned string
// using zstr_free(). If not enough strings are provided, remaining
// multipart frames in the message are dropped.
int QmlZstrAttached::recvx (void *source, QString stringP) {
return zstr_recvx (source, stringP.toUtf8().data());
};
void
zgossip_test (bool verbose)
{
printf (" * zgossip: ");
if (verbose)
printf ("\n");
// @selftest
// Test basic client-to-server operation of the protocol
zactor_t *server = zactor_new (zgossip, "server");
assert (server);
if (verbose)
zstr_send (server, "VERBOSE");
zstr_sendx (server, "BIND", "inproc://zgossip", NULL);
zsock_t *client = zsock_new (ZMQ_DEALER);
assert (client);
zsock_set_rcvtimeo (client, 2000);
int rc = zsock_connect (client, "inproc://zgossip");
assert (rc == 0);
// Send HELLO, which gets no message
zgossip_msg_t *message = zgossip_msg_new ();
zgossip_msg_set_id (message, ZGOSSIP_MSG_HELLO);
zgossip_msg_send (message, client);
// Send PING, expect PONG back
zgossip_msg_set_id (message, ZGOSSIP_MSG_PING);
zgossip_msg_send (message, client);
zgossip_msg_recv (message, client);
assert (zgossip_msg_id (message) == ZGOSSIP_MSG_PONG);
zgossip_msg_destroy (&message);
zactor_destroy (&server);
zsock_destroy (&client);
// Test peer-to-peer operations
zactor_t *base = zactor_new (zgossip, "base");
assert (base);
if (verbose)
zstr_send (base, "VERBOSE");
// Set a 100msec timeout on clients so we can test expiry
zstr_sendx (base, "SET", "server/timeout", "100", NULL);
zstr_sendx (base, "BIND", "inproc://base", NULL);
zactor_t *alpha = zactor_new (zgossip, "alpha");
assert (alpha);
zstr_sendx (alpha, "CONNECT", "inproc://base", NULL);
zstr_sendx (alpha, "PUBLISH", "inproc://alpha-1", "service1", NULL);
zstr_sendx (alpha, "PUBLISH", "inproc://alpha-2", "service2", NULL);
zactor_t *beta = zactor_new (zgossip, "beta");
assert (beta);
zstr_sendx (beta, "CONNECT", "inproc://base", NULL);
zstr_sendx (beta, "PUBLISH", "inproc://beta-1", "service1", NULL);
zstr_sendx (beta, "PUBLISH", "inproc://beta-2", "service2", NULL);
// got nothing
zclock_sleep (200);
zstr_send (alpha, "STATUS");
char *command, *status, *key, *value;
zstr_recvx (alpha, &command, &key, &value, NULL);
assert (streq (command, "DELIVER"));
assert (streq (key, "inproc://alpha-1"));
assert (streq (value, "service1"));
zstr_free (&command);
zstr_free (&key);
zstr_free (&value);
zstr_recvx (alpha, &command, &key, &value, NULL);
assert (streq (command, "DELIVER"));
assert (streq (key, "inproc://alpha-2"));
assert (streq (value, "service2"));
zstr_free (&command);
zstr_free (&key);
zstr_free (&value);
zstr_recvx (alpha, &command, &key, &value, NULL);
assert (streq (command, "DELIVER"));
assert (streq (key, "inproc://beta-1"));
assert (streq (value, "service1"));
zstr_free (&command);
zstr_free (&key);
zstr_free (&value);
zstr_recvx (alpha, &command, &key, &value, NULL);
assert (streq (command, "DELIVER"));
assert (streq (key, "inproc://beta-2"));
assert (streq (value, "service2"));
zstr_free (&command);
zstr_free (&key);
zstr_free (&value);
zstr_recvx (alpha, &command, &status, NULL);
assert (streq (command, "STATUS"));
assert (atoi (status) == 4);
zstr_free (&command);
zstr_free (&status);
zactor_destroy (&base);
zactor_destroy (&alpha);
zactor_destroy (&beta);
#ifdef CZMQ_BUILD_DRAFT_API
// DRAFT-API: Security
// curve
if (zsys_has_curve()) {
if (verbose)
printf("testing CURVE support");
zclock_sleep (2000);
zactor_t *auth = zactor_new(zauth, NULL);
assert (auth);
if (verbose) {
zstr_sendx (auth, "VERBOSE", NULL);
zsock_wait (auth);
}
zstr_sendx(auth,"ALLOW","127.0.0.1",NULL);
zsock_wait(auth);
zstr_sendx (auth, "CURVE", CURVE_ALLOW_ANY, NULL);
zsock_wait (auth);
server = zactor_new (zgossip, "server");
if (verbose)
zstr_send (server, "VERBOSE");
assert (server);
zcert_t *client1_cert = zcert_new ();
zcert_t *server_cert = zcert_new ();
zstr_sendx (server, "SET PUBLICKEY", zcert_public_txt (server_cert), NULL);
zstr_sendx (server, "SET SECRETKEY", zcert_secret_txt (server_cert), NULL);
zstr_sendx (server, "ZAP DOMAIN", "TEST", NULL);
zstr_sendx (server, "BIND", "tcp://127.0.0.1:*", NULL);
zstr_sendx (server, "PORT", NULL);
zstr_recvx (server, &command, &value, NULL);
assert (streq (command, "PORT"));
int port = atoi (value);
zstr_free (&command);
zstr_free (&value);
char endpoint [32];
sprintf (endpoint, "tcp://127.0.0.1:%d", port);
zactor_t *client1 = zactor_new (zgossip, "client");
if (verbose)
zstr_send (client1, "VERBOSE");
assert (client1);
zstr_sendx (client1, "SET PUBLICKEY", zcert_public_txt (client1_cert), NULL);
zstr_sendx (client1, "SET SECRETKEY", zcert_secret_txt (client1_cert), NULL);
zstr_sendx (client1, "ZAP DOMAIN", "TEST", NULL);
const char *public_txt = zcert_public_txt (server_cert);
zstr_sendx (client1, "CONNECT", endpoint, public_txt, NULL);
zstr_sendx (client1, "PUBLISH", "tcp://127.0.0.1:9001", "service1", NULL);
zclock_sleep (500);
zstr_send (server, "STATUS");
zclock_sleep (500);
zstr_recvx (server, &command, &key, &value, NULL);
assert (streq (command, "DELIVER"));
assert (streq (value, "service1"));
zstr_free (&command);
zstr_free (&key);
zstr_free (&value);
zstr_sendx (client1, "$TERM", NULL);
zstr_sendx (server, "$TERM", NULL);
zclock_sleep(500);
zcert_destroy (&client1_cert);
zcert_destroy (&server_cert);
zactor_destroy (&client1);
zactor_destroy (&server);
zactor_destroy (&auth);
}
#endif
#if defined (__WINDOWS__)
zsys_shutdown();
#endif
// @end
printf ("OK\n");
}
int
main (int argn, char *argv [])
{
// Raise theoretical limit on how many ZeroMQ sockets we can create,
// though real limit will be set by the process file handle limit.
zsys_set_max_sockets (65535);
// Test case 1: two servers, bunch of clients.
printf ("Starting small test case: ");
fflush (stdout);
zactor_t *server1 = zactor_new (zgossip, "server1");
assert (server1);
zstr_sendx (server1, "SET", "server/animate", "0", NULL);
zstr_sendx (server1, "BIND", "inproc://server1", NULL);
zactor_t *server2 = zactor_new (zgossip, "server2");
assert (server2);
zstr_sendx (server2, "SET", "server/animate", "0", NULL);
zstr_sendx (server2, "BIND", "inproc://server2", NULL);
zstr_sendx (server2, "CONNECT", "inproc://server1", NULL);
zactor_t *client1 = zactor_new (zgossip, "client1");
assert (client1);
zstr_sendx (client1, "BIND", "inproc://client1", NULL);
zstr_sendx (client1, "PUBLISH", "client1-00", "0000", NULL);
zstr_sendx (client1, "PUBLISH", "client1-11", "1111", NULL);
zstr_sendx (client1, "PUBLISH", "client1-22", "2222", NULL);
zstr_sendx (client1, "CONNECT", "inproc://server1", NULL);
zactor_t *client2 = zactor_new (zgossip, "client2");
assert (client2);
zstr_sendx (client2, "BIND", "inproc://client2", NULL);
zstr_sendx (client2, "CONNECT", "inproc://server1", NULL);
zstr_sendx (client2, "PUBLISH", "client2-00", "0000", NULL);
zstr_sendx (client2, "PUBLISH", "client2-11", "1111", NULL);
zstr_sendx (client2, "PUBLISH", "client2-22", "2222", NULL);
zactor_t *client3 = zactor_new (zgossip, "client3");
assert (client3);
zstr_sendx (client3, "CONNECT", "inproc://server2", NULL);
zactor_t *client4 = zactor_new (zgossip, "client4");
assert (client4);
zstr_sendx (client4, "CONNECT", "inproc://server2", NULL);
zclock_sleep (100);
assert_status (server1, 6);
assert_status (server2, 6);
assert_status (client1, 6);
assert_status (client2, 6);
assert_status (client3, 6);
assert_status (client4, 6);
zactor_destroy (&server1);
zactor_destroy (&server2);
zactor_destroy (&client1);
zactor_destroy (&client2);
zactor_destroy (&client3);
zactor_destroy (&client4);
printf ("OK\n");
// Test case 2: swarm of peers
printf ("Starting swarm test case: ");
fflush (stdout);
// Default limit on file handles is 1024 (POSIX), and fixed setup
// costs 8 handles (3 standard I/O plus 5 for CZMQ/libzmq). So the
// most nodes we can test by default is (1024 - 8) / 4 = 254. To
// test more, run "ulimit -n xxx" beforehand and pass swarm size
// as argument to this program. With e.g. Ubuntu, ceiling is 4K
// file handles per process, so the largest swarm I've tested is
// 1022 nodes.
int swarm_size = 254;
if (argn >= 2)
swarm_size = atoi (argv [1]);
printf ("swarm_size=%d ", swarm_size);
// The set size defines the total number of properties we spread
// across the swarm. By default this is the swarm_size * 5. You can
// specify a different set size as second command line argument.
int set_size = swarm_size * 5;
if (argn >= 3)
set_size = atoi (argv [2]);
printf ("set_size=%d ", set_size);
// Swarm is an array of actors
zactor_t *nodes [swarm_size];
// We'll poll all actors for activity (actors act like sockets)
zpoller_t *poller = zpoller_new (NULL);
assert (poller);
// Create swarm
uint node_nbr;
for (node_nbr = 0; node_nbr < swarm_size; node_nbr++) {
nodes [node_nbr] = zactor_new (zgossip, NULL);
assert (nodes [node_nbr]);
zpoller_add (poller, nodes [node_nbr]);
}
printf (".");
fflush (stdout);
// Interconnect swarm; ever node connects to one arbitrary node to
// create a directed graph, then oldest node connects to youngest
// node to create a loop, to test we're robust against cycles.
for (node_nbr = 0; node_nbr < swarm_size; node_nbr++) {
zstr_sendm (nodes [node_nbr], "BIND");
zstr_sendf (nodes [node_nbr], "inproc://swarm-%d", node_nbr);
if (node_nbr > 0) {
zstr_sendm (nodes [node_nbr], "CONNECT");
zstr_sendf (nodes [node_nbr], "inproc://swarm-%d", randof (node_nbr));
}
}
zstr_sendm (nodes [0], "CONNECT");
zstr_sendf (nodes [0], "inproc://swarm-%d", node_nbr - 1);
printf (".");
fflush (stdout);
// Publish the data set randomly across the swarm
int item_nbr;
for (item_nbr = 0; item_nbr < set_size; item_nbr++) {
node_nbr = randof (swarm_size);
assert (node_nbr != swarm_size);
assert (node_nbr < swarm_size);
zstr_sendm (nodes [node_nbr], "PUBLISH");
zstr_sendfm (nodes [node_nbr], "key-%d", item_nbr);
zstr_send (nodes [node_nbr], "value");
}
printf (". ");
fflush (stdout);
// Each actor will deliver us tuples; count these until we're done
int total = set_size * swarm_size;
int pending = total;
int64_t ticker = zclock_mono () + 2000;
while (pending) {
zsock_t *which = (zsock_t *) zpoller_wait (poller, 100);
if (!which) {
puts (" - stuck test, aborting");
break;
}
char *command;
zstr_recvx (which, &command, NULL);
assert (streq (command, "DELIVER"));
pending--;
freen (command);
if (zclock_mono () > ticker) {
printf ("(%d%%)", (int) ((100 * (total - pending)) / total));
fflush (stdout);
ticker = zclock_mono () + 2000;
}
}
// Destroy swarm
for (node_nbr = 0; node_nbr < swarm_size; node_nbr++)
zactor_destroy (&nodes [node_nbr]);
printf ("(100%%) OK\n");
#if defined (__WINDOWS__)
zsys_shutdown();
#endif
return 0;
}
