int zmq_disconnect_x(void* s, const char* addr)
{
const char* endpoint = 0;
if (is_x_addr(addr)) {
endpoint = zmq_endpoint_x(addr);
if (!endpoint)
return -1; // not bound yet
else
return zmq_disconnect(s, endpoint);
} else {
return zmq_disconnect(s, addr);
}
}
/**
* Called by Java's Socket::disconnect(String addr).
*/
JNIEXPORT void JNICALL Java_org_zeromq_ZMQ_00024Socket_disconnect (JNIEnv *env,
jobject obj,
jstring addr)
{
#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(3,2,0)
void *s = get_socket (env, obj);
if (addr == NULL) {
raise_exception (env, EINVAL);
return;
}
const char *c_addr = env->GetStringUTFChars (addr, NULL);
if (c_addr == NULL) {
raise_exception (env, EINVAL);
return;
}
int rc = zmq_disconnect (s, c_addr);
int err = zmq_errno();
env->ReleaseStringUTFChars (addr, c_addr);
if (rc != 0) {
raise_exception (env, err);
return;
}
#endif
}
unsigned short ZmqSocket::disconnect(const char* endpoint)
{
CHECK_RET_CODE(sock != 0, ERR_CLOSE);
CHECK_API_RET(zmq_disconnect(sock, endpoint) != -1);
onDisconnect();
return NO_ERR;
}
void test_single_connect_ipv4 (void)
{
void *ctx = zmq_ctx_new ();
assert (ctx);
void *sb = zmq_socket (ctx, ZMQ_REP);
assert (sb);
int rc = zmq_bind (sb, "tcp://127.0.0.1:5560");
assert (rc == 0);
void *sc = zmq_socket (ctx, ZMQ_REQ);
assert (sc);
rc = zmq_connect (sc, "tcp://127.0.0.1:5560");
assert (rc == 0);
bounce (sb, sc);
rc = zmq_disconnect (sc, "tcp://127.0.0.1:5560");
assert (rc == 0);
rc = zmq_unbind (sb, "tcp://127.0.0.1:5560");
assert (rc == 0);
rc = zmq_close (sc);
assert (rc == 0);
rc = zmq_close (sb);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
}
OpenEphysNetworkEventsClient::~OpenEphysNetworkEventsClient() {
if (zmqSocket) {
if (0 != zmq_disconnect(zmqSocket.get(), endpoint.c_str()) &&
ENOENT != zmq_errno())
{
logZMQError("Unable to disconnect from Open Ephys network events module");
}
}
}
/**
* Disconnects from a given object key
*/
void subscribe_socket::disconnect(std::string objectkey) {
boost::lock_guard<boost::recursive_mutex> guard(lock);
for (size_t i = 0;i < publishers.size(); ++i) {
if (publishers[i].key == objectkey) {
zmq_disconnect(z_socket, publishers[i].connected_server.c_str());
publishers.erase(publishers.begin() + i);
break;
}
}
}
void Chat::leave(const std::string& peer_id, const std::string& peer_ip)
{
std::string peer_ep;
unsigned short peer_port = create_port(peer_id);
// peer_ep = std::string("tcp://*:") + boost::lexical_cast<std::string>(peer_port);
peer_ep = (boost::format("tcp://%s:%d") % peer_ip % peer_port).str();
if (zmq_disconnect(subscriber_, peer_ep.c_str()) < 0)
{
zmq_strerror(errno);
}
}
void test_single_connect (const char *address)
{
size_t len = MAX_SOCKET_STRING;
char my_endpoint[MAX_SOCKET_STRING];
void *ctx = zmq_ctx_new ();
assert (ctx);
int ipv6;
if (streq (address, "tcp://127.0.0.1:*"))
ipv6 = 0;
else if (streq (address, "tcp://[::1]:*"))
ipv6 = 1;
else
assert (false);
if (ipv6 && !is_ipv6_available ()) {
zmq_ctx_term (ctx);
return;
}
void *sb = zmq_socket (ctx, ZMQ_REP);
assert (sb);
int rc = zmq_setsockopt (sb, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_bind (sb, address);
assert (rc == 0);
rc = zmq_getsockopt (sb, ZMQ_LAST_ENDPOINT, my_endpoint, &len);
assert (rc == 0);
void *sc = zmq_socket (ctx, ZMQ_REQ);
assert (sc);
rc = zmq_setsockopt (sc, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_connect (sc, my_endpoint);
assert (rc == 0);
bounce (sb, sc);
rc = zmq_disconnect (sc, my_endpoint);
assert (rc == 0);
rc = zmq_unbind (sb, my_endpoint);
assert (rc == 0);
rc = zmq_close (sc);
assert (rc == 0);
rc = zmq_close (sb);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
}
int main(int argc, char *argv[])
{
void *ctx, *handler, *thread, *server, *client;
const char *domain, *connect_addr;
int optval;
domain = argc > 1 ? argv[1] : "test";
connect_addr = strcmp(domain, "fail") ? "tcp://127.0.0.1:9000" : "tcp://127.0.0.1:9001";
assert((ctx = zmq_ctx_new()));
/* Start ZAP handler thread. */
assert((handler = zmq_socket(ctx, ZMQ_REP)));
assert(!(zmq_bind(handler, "inproc://zeromq.zap.01")));
assert((thread = zmq_threadstart(zap_handler, handler)));
/* Bind server. */
assert((server = zmq_socket(ctx, ZMQ_DEALER)));
assert(!(zmq_setsockopt(server, ZMQ_ZAP_DOMAIN, domain, strlen(domain))));
assert(!zmq_bind(server, "tcp://127.0.0.1:9000"));
/* Connect client. */
assert((client = zmq_socket(ctx, ZMQ_DEALER)));
optval = 200;
assert(!(zmq_setsockopt(client, ZMQ_RECONNECT_IVL, &optval, sizeof(optval))));
optval = 5000;
assert(!(zmq_setsockopt(client, ZMQ_RECONNECT_IVL_MAX, &optval, sizeof(optval))));
optval = 30000;
assert(!(zmq_setsockopt(client, ZMQ_SNDTIMEO, &optval, sizeof(optval))));
optval = 1;
assert(!(zmq_setsockopt(client, ZMQ_IMMEDIATE, &optval, sizeof(optval))));
assert(!zmq_connect(client, connect_addr));
/* Bounce test. */
s_send(client, "Hello, Server!");
assert(!strcmp(s_recv(server), "Hello, Server!"));
s_send(server, "Hello, Client!");
assert(!strcmp(s_recv(client), "Hello, Client!"));
/* Cleanup. */
assert(!zmq_disconnect(client, connect_addr));
assert(!zmq_close(client));
assert(!zmq_unbind(server, "tcp://127.0.0.1:9000"));
assert(!zmq_close(server));
assert(!zmq_term(ctx));
zmq_threadclose(thread);
return 0;
}
int
zsocket_disconnect (void *self, const char *format, ...)
{
#if (ZMQ_VERSION >= ZMQ_MAKE_VERSION (3, 2, 0))
char endpoint [256];
va_list argptr;
va_start (argptr, format);
vsnprintf (endpoint, 256, format, argptr);
va_end (argptr);
return zmq_disconnect (self, endpoint);
#else
return -1;
#endif
}
void* ZmqClient::createSocket()
{
int timeout = 100;
int result = 0;
void *context = zmq_ctx_new();
void *backend = zmq_socket(context, ZMQ_PUSH);
if (!backend)
{
return NULL;
}
result = zmq_connect(backend, ZBROKER_FRONTEND_SOCKET);
if (result != 0)
{
zmq_close(backend);
return NULL;
}
result = zmq_setsockopt(backend, ZMQ_SNDTIMEO, &timeout, sizeof(int));
if (result != 0)
{
zmq_disconnect(backend, ZBROKER_FRONTEND_SOCKET);
zmq_close(backend);
return NULL;
}
result = zmq_setsockopt(backend, ZMQ_RCVTIMEO, &timeout, sizeof(int));
if (result != 0)
{
zmq_disconnect(backend, ZBROKER_FRONTEND_SOCKET);
zmq_close(backend);
return NULL;
}
return backend;
}
void ZmqClientProcess::shutdown() {
isFree = true;
m_isAlive = false;
m_zmqMutex.lock();
send_string(SOCKET, TYPE_SHUTDOWN, 0);
EventHandler temp(this);
listenToEvents(temp);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
m_zmqClient->kill();
m_zmqClient->waitForFinished(1000);
zmq_disconnect(SOCKET, "172.0.0.1:5556");
zmq_close(SOCKET);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
m_zmqMutex.unlock();
}
/**
* disconnect from specified endpoint
*/
static void _zmq_disconnect(t_zmq *x, t_symbol *s) {
if(! x->zmq_socket) {
error("no socket");
return;
}
if(x->socket_state != CONNECTED) {
error("socket not connected");
return;
}
int r = zmq_disconnect(x->zmq_socket, s->s_name);
if(r==0) {
x->socket_state = NONE;
post("socket discconnected");
}
else _zmq_error(zmq_errno());
}
SEXP R_zmq_disconnect(SEXP R_socket, SEXP R_endpoint){
int C_ret = -1, C_errno;
void *C_socket = R_ExternalPtrAddr(R_socket);
const char *C_endpoint = CHARPT(R_endpoint, 0);
if(C_socket != NULL){
C_ret = zmq_disconnect(C_socket, C_endpoint);
if(C_ret == -1){
C_errno = zmq_errno();
warning("R_zmq_disconnect errno: %d strerror: %s\n",
C_errno, zmq_strerror(C_errno));
}
} else{
warning("R_zmq_disconnect: C_socket is not available.\n");
}
return(AsInt(C_ret));
} /* End of R_zmq_disconnect(). */
int
zsock_disconnect (zsock_t *self, const char *format, ...)
{
assert (self);
assert (zsock_is (self));
#if (ZMQ_VERSION >= ZMQ_MAKE_VERSION (3,2,0))
// Expand format to get full endpoint
va_list argptr;
va_start (argptr, format);
char *endpoint = zsys_vprintf (format, argptr);
va_end (argptr);
int rc = zmq_disconnect (self->handle, endpoint);
free (endpoint);
return rc;
#else
return -1;
#endif
}
void test_single_connect_ipv6 (void)
{
void *ctx = zmq_ctx_new ();
assert (ctx);
if (!is_ipv6_available ()) {
zmq_ctx_term (ctx);
return;
}
void *sb = zmq_socket (ctx, ZMQ_REP);
assert (sb);
int ipv6 = 1;
int rc = zmq_setsockopt (sb, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_bind (sb, "tcp://[::1]:5560");
assert (rc == 0);
void *sc = zmq_socket (ctx, ZMQ_REQ);
assert (sc);
rc = zmq_setsockopt (sc, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_connect (sc, "tcp://[::1]:5560");
assert (rc == 0);
bounce (sb, sc);
rc = zmq_disconnect (sc, "tcp://[::1]:5560");
assert (rc == 0);
rc = zmq_unbind (sb, "tcp://[::1]:5560");
assert (rc == 0);
rc = zmq_close (sc);
assert (rc == 0);
rc = zmq_close (sb);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
}
void subscribe_socket::timer_callback(socket_receive_pollset* unused,
const zmq_pollitem_t& unused2) {
if (publisher_info_changed == false) return;
else {
// loop though all the subscriptions and check for server changes.
// disconnecting, and reconnecting if necessary
boost::lock_guard<boost::recursive_mutex> guard(lock);
for(size_t i = 0;i < publishers.size(); ++i) {
if (publishers[i].server_changed &&
!publishers[i].connected_server.empty()) {
zmq_disconnect(z_socket, publishers[i].connected_server.c_str());
publishers[i].connected_server.clear();
}
if (!publishers[i].server.empty()) {
std::string local_address = normalize_address(publishers[i].server);
zmq_connect(z_socket, local_address.c_str());
publishers[i].connected_server = publishers[i].server;
}
publishers[i].server_changed = false;
}
publisher_info_changed = false;
}
}
inline void disconnect (const char *addr_)
{
int rc = zmq_disconnect (ptr, addr_);
if (rc != 0)
throw error_t ();
}
void test_multi_connect_ipv6 (void)
{
void *ctx = zmq_ctx_new ();
assert (ctx);
if (!is_ipv6_available ()) {
zmq_ctx_term (ctx);
return;
}
void *sb0 = zmq_socket (ctx, ZMQ_REP);
assert (sb0);
int ipv6 = 1;
int rc = zmq_setsockopt (sb0, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_bind (sb0, "tcp://[::1]:5560");
assert (rc == 0);
void *sb1 = zmq_socket (ctx, ZMQ_REP);
assert (sb1);
rc = zmq_setsockopt (sb1, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_bind (sb1, "tcp://[::1]:5561");
assert (rc == 0);
void *sb2 = zmq_socket (ctx, ZMQ_REP);
assert (sb2);
rc = zmq_setsockopt (sb2, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_bind (sb2, "tcp://[::1]:5562");
assert (rc == 0);
void *sc = zmq_socket (ctx, ZMQ_REQ);
assert (sc);
rc = zmq_setsockopt (sc, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_connect (sc, "tcp://[::1]:5560");
assert (rc == 0);
rc = zmq_connect (sc, "tcp://[::1]:5561");
assert (rc == 0);
rc = zmq_connect (sc, "tcp://[::1]:5564;[::1]:5562");
assert (rc == 0);
bounce (sb0, sc);
bounce (sb1, sc);
bounce (sb2, sc);
bounce (sb0, sc);
bounce (sb1, sc);
bounce (sb2, sc);
bounce (sb0, sc);
rc = zmq_disconnect (sc, "tcp://[::1]:5560");
assert (rc == 0);
rc = zmq_disconnect (sc, "tcp://[::1]:5564;[::1]:5562");
assert (rc == 0);
rc = zmq_disconnect (sc, "tcp://[::1]:5561");
assert (rc == 0);
rc = zmq_unbind (sb0, "tcp://[::1]:5560");
assert (rc == 0);
rc = zmq_unbind (sb1, "tcp://[::1]:5561");
assert (rc == 0);
rc = zmq_unbind (sb2, "tcp://[::1]:5562");
assert (rc == 0);
rc = zmq_close (sc);
assert (rc == 0);
rc = zmq_close (sb0);
assert (rc == 0);
rc = zmq_close (sb1);
assert (rc == 0);
rc = zmq_close (sb2);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
}
void test_destroy_queue_on_disconnect (void *ctx)
{
void *A = zmq_socket (ctx, ZMQ_DEALER);
assert (A);
int rc = zmq_bind (A, bind_address);
assert (rc == 0);
void *B = zmq_socket (ctx, ZMQ_DEALER);
assert (B);
rc = zmq_connect (B, connect_address);
assert (rc == 0);
// Send a message in both directions
s_send_seq (A, "ABC", SEQ_END);
s_send_seq (B, "DEF", SEQ_END);
rc = zmq_disconnect (B, connect_address);
assert (rc == 0);
// Disconnect may take time and need command processing.
zmq_pollitem_t poller [2] = { { A, 0, 0, 0 }, { B, 0, 0, 0 } };
rc = zmq_poll (poller, 2, 100);
assert (rc == 0);
rc = zmq_poll (poller, 2, 100);
assert (rc == 0);
// No messages should be available, sending should fail.
zmq_msg_t msg;
zmq_msg_init (&msg);
rc = zmq_send (A, 0, 0, ZMQ_DONTWAIT);
assert (rc == -1);
assert (errno == EAGAIN);
rc = zmq_msg_recv (&msg, A, ZMQ_DONTWAIT);
assert (rc == -1);
assert (errno == EAGAIN);
// After a reconnect of B, the messages should still be gone
rc = zmq_connect (B, connect_address);
assert (rc == 0);
rc = zmq_msg_recv (&msg, A, ZMQ_DONTWAIT);
assert (rc == -1);
assert (errno == EAGAIN);
rc = zmq_msg_recv (&msg, B, ZMQ_DONTWAIT);
assert (rc == -1);
assert (errno == EAGAIN);
rc = zmq_msg_close (&msg);
assert (rc == 0);
close_zero_linger (A);
close_zero_linger (B);
// Wait for disconnects.
rc = zmq_poll (0, 0, 100);
assert (rc == 0);
}
void test_multi_connect_ipv4 (void)
{
void *ctx = zmq_ctx_new ();
assert (ctx);
void *sb0 = zmq_socket (ctx, ZMQ_REP);
assert (sb0);
int rc = zmq_bind (sb0, "tcp://127.0.0.1:5560");
assert (rc == 0);
void *sb1 = zmq_socket (ctx, ZMQ_REP);
assert (sb1);
rc = zmq_bind (sb1, "tcp://127.0.0.1:5561");
assert (rc == 0);
void *sb2 = zmq_socket (ctx, ZMQ_REP);
assert (sb2);
rc = zmq_bind (sb2, "tcp://127.0.0.1:5562");
assert (rc == 0);
void *sc = zmq_socket (ctx, ZMQ_REQ);
assert (sc);
rc = zmq_connect (sc, "tcp://127.0.0.1:5560");
assert (rc == 0);
rc = zmq_connect (sc, "tcp://127.0.0.1:5561");
assert (rc == 0);
rc = zmq_connect (sc, "tcp://127.0.0.1:5564;127.0.0.1:5562");
assert (rc == 0);
bounce (sb0, sc);
bounce (sb1, sc);
bounce (sb2, sc);
bounce (sb0, sc);
bounce (sb1, sc);
bounce (sb2, sc);
bounce (sb0, sc);
rc = zmq_disconnect (sc, "tcp://127.0.0.1:5560");
assert (rc == 0);
rc = zmq_disconnect (sc, "tcp://127.0.0.1:5564;127.0.0.1:5562");
assert (rc == 0);
rc = zmq_disconnect (sc, "tcp://127.0.0.1:5561");
assert (rc == 0);
rc = zmq_unbind (sb0, "tcp://127.0.0.1:5560");
assert (rc == 0);
rc = zmq_unbind (sb1, "tcp://127.0.0.1:5561");
assert (rc == 0);
rc = zmq_unbind (sb2, "tcp://127.0.0.1:5562");
assert (rc == 0);
rc = zmq_close (sc);
assert (rc == 0);
rc = zmq_close (sb0);
assert (rc == 0);
rc = zmq_close (sb1);
assert (rc == 0);
rc = zmq_close (sb2);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
}
int main(int, char**) {
setup_test_environment();
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://127.0.0.1:30010") && printf("zmq_bind: %s\n", zmq_strerror(errno));
int 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
};
int rc = zmq_poll (items, 2, 100);
if (items [1].revents & ZMQ_POLLIN) {
while (1) {
zmq_msg_t msg;
zmq_msg_init (&msg);
zmq_msg_recv (&msg, pubSocket, 0);
char* buffer = (char*)zmq_msg_data(&msg);
if (buffer[0] == 0) {
assert(isSubscribed);
isSubscribed = false;
}
else {
assert(!isSubscribed);
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);
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));
msleep (SETTLE_TIME);
}
if (iteration == 4) {
zmq_disconnect(subSocket, "inproc://someInProcDescriptor") && printf("zmq_disconnect(%d): %s\n", errno, zmq_strerror(errno));
}
if (iteration > 4 && rc == 0)
break;
zmq_msg_t channelEnvlp;
ZMQ_PREPARE_STRING(channelEnvlp, "foo", 3);
zmq_msg_send (&channelEnvlp, pubSocket, ZMQ_SNDMORE) >= 0 || printf("zmq_msg_send: %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_msg_send (&message, pubSocket, 0) >= 0 || printf("zmq_msg_send: %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_term(context);
return 0;
}
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;
}
void ZmqClient::destorySocket(void *backend)
{
zmq_disconnect(backend, ZBROKER_FRONTEND_SOCKET);
zmq_close(backend);
}
void test_destroy_queue_on_disconnect (void *ctx)
{
void *A = zmq_socket (ctx, ZMQ_PUSH);
assert (A);
int hwm = 1;
int rc = zmq_setsockopt (A, ZMQ_SNDHWM, &hwm, sizeof (hwm));
assert (rc == 0);
rc = zmq_bind (A, bind_address);
assert (rc == 0);
void *B = zmq_socket (ctx, ZMQ_PULL);
assert (B);
rc = zmq_setsockopt (B, ZMQ_RCVHWM, &hwm, sizeof (hwm));
assert (rc == 0);
rc = zmq_connect (B, connect_address);
assert (rc == 0);
// Send two messages, one should be stuck in A's outgoing queue, the other
// arrives at B.
s_send_seq (A, "ABC", SEQ_END);
s_send_seq (A, "DEF", SEQ_END);
// Both queues should now be full, indicated by A blocking on send.
rc = zmq_send (A, 0, 0, ZMQ_DONTWAIT);
assert (rc == -1);
assert (errno == EAGAIN);
rc = zmq_disconnect (B, connect_address);
assert (rc == 0);
// Disconnect may take time and need command processing.
zmq_pollitem_t poller [2] = { { A, 0, 0, 0 }, { B, 0, 0, 0 } };
rc = zmq_poll (poller, 2, 100);
assert (rc == 0);
rc = zmq_poll (poller, 2, 100);
assert (rc == 0);
zmq_msg_t msg;
rc = zmq_msg_init (&msg);
assert (rc == 0);
// Can't receive old data on B.
rc = zmq_msg_recv (&msg, B, ZMQ_DONTWAIT);
assert (rc == -1);
assert (errno == EAGAIN);
// Sending fails.
rc = zmq_send (A, 0, 0, ZMQ_DONTWAIT);
assert (rc == -1);
assert (errno == EAGAIN);
// Reconnect B
rc = zmq_connect (B, connect_address);
assert (rc == 0);
// Still can't receive old data on B.
rc = zmq_msg_recv (&msg, B, ZMQ_DONTWAIT);
assert (rc == -1);
assert (errno == EAGAIN);
// two messages should be sendable before the queues are filled up.
s_send_seq (A, "ABC", SEQ_END);
s_send_seq (A, "DEF", SEQ_END);
rc = zmq_send (A, 0, 0, ZMQ_DONTWAIT);
assert (rc == -1);
assert (errno == EAGAIN);
rc = zmq_msg_close (&msg);
assert (rc == 0);
close_zero_linger (A);
close_zero_linger (B);
// Wait for disconnects.
msleep (SETTLE_TIME);
}
void test_destroy_queue_on_disconnect (void *ctx)
{
void *A = zmq_socket (ctx, ZMQ_ROUTER);
assert (A);
int enabled = 1;
int rc = zmq_setsockopt (A, ZMQ_ROUTER_MANDATORY, &enabled, sizeof(enabled));
assert (rc == 0);
rc = zmq_bind (A, "inproc://d");
assert (rc == 0);
void *B = zmq_socket (ctx, ZMQ_DEALER);
assert (B);
rc = zmq_setsockopt (B, ZMQ_IDENTITY, "B", 2);
assert (rc == 0);
rc = zmq_connect (B, "inproc://d");
assert (rc == 0);
// Send a message in both directions
s_send_seq (A, "B", "ABC", SEQ_END);
s_send_seq (B, "DEF", SEQ_END);
rc = zmq_disconnect (B, "inproc://d");
assert (rc == 0);
// Disconnect may take time and need command processing.
zmq_pollitem_t poller[2] = { { A, 0, 0, 0 }, { B, 0, 0, 0 } };
rc = zmq_poll (poller, 2, 100);
assert (rc == 0);
// No messages should be available, sending should fail.
zmq_msg_t msg;
zmq_msg_init (&msg);
rc = zmq_send (A, "B", 2, ZMQ_SNDMORE | ZMQ_DONTWAIT);
assert (rc == -1);
assert (errno == EHOSTUNREACH);
rc = zmq_msg_recv (&msg, A, ZMQ_DONTWAIT);
assert (rc == -1);
assert (errno == EAGAIN);
// After a reconnect of B, the messages should still be gone
rc = zmq_connect (B, "inproc://d");
assert (rc == 0);
rc = zmq_msg_recv (&msg, A, ZMQ_DONTWAIT);
assert (rc == -1);
assert (errno == EAGAIN);
rc = zmq_msg_recv (&msg, B, ZMQ_DONTWAIT);
assert (rc == -1);
assert (errno == EAGAIN);
rc = zmq_msg_close (&msg);
assert (rc == 0);
rc = zmq_close (A);
assert (rc == 0);
rc = zmq_close (B);
assert (rc == 0);
}
int main (void)
{
int rc;
char buf[32];
const char *ep = "tcp://127.0.0.1:5560";
fprintf (stderr, "unbind endpoint test running...\n");
// Create infrastructure.
void *ctx = zmq_init (1);
assert (ctx);
void *push = zmq_socket (ctx, ZMQ_PUSH);
assert (push);
rc = zmq_bind (push, ep);
assert (rc == 0);
void *pull = zmq_socket (ctx, ZMQ_PULL);
assert (pull);
rc = zmq_connect (pull, ep);
assert (rc == 0);
// Pass one message through to ensure the connection is established.
rc = zmq_send (push, "ABC", 3, 0);
assert (rc == 3);
rc = zmq_recv (pull, buf, sizeof (buf), 0);
assert (rc == 3);
// Unbind the lisnening endpoint
rc = zmq_unbind (push, ep);
assert (rc == 0);
// Let events some time
zmq_sleep (1);
// Check that sending would block (there's no outbound connection).
rc = zmq_send (push, "ABC", 3, ZMQ_DONTWAIT);
assert (rc == -1 && zmq_errno () == EAGAIN);
// Clean up.
rc = zmq_close (pull);
assert (rc == 0);
rc = zmq_close (push);
assert (rc == 0);
rc = zmq_term (ctx);
assert (rc == 0);
// Now the other way round.
fprintf (stderr, "disconnect endpoint test running...\n");
// Create infrastructure.
ctx = zmq_init (1);
assert (ctx);
push = zmq_socket (ctx, ZMQ_PUSH);
assert (push);
rc = zmq_connect (push, ep);
assert (rc == 0);
pull = zmq_socket (ctx, ZMQ_PULL);
assert (pull);
rc = zmq_bind (pull, ep);
assert (rc == 0);
// Pass one message through to ensure the connection is established.
rc = zmq_send (push, "ABC", 3, 0);
assert (rc == 3);
rc = zmq_recv (pull, buf, sizeof (buf), 0);
assert (rc == 3);
// Disconnect the bound endpoint
rc = zmq_disconnect (push, ep);
assert (rc == 0);
// Let events some time
zmq_sleep (1);
// Check that sending would block (there's no inbound connections).
rc = zmq_send (push, "ABC", 3, ZMQ_DONTWAIT);
assert (rc == -1 && zmq_errno () == EAGAIN);
// Clean up.
rc = zmq_close (pull);
assert (rc == 0);
rc = zmq_close (push);
assert (rc == 0);
rc = zmq_term (ctx);
assert (rc == 0);
return 0;
}
int main (void)
{
setup_test_environment();
void *ctx = zmq_ctx_new ();
assert (ctx);
int ipv6 = is_ipv6_available ();
/* Address wildcard, IPv6 disabled */
void *sb = zmq_socket (ctx, ZMQ_REP);
assert (sb);
void *sc = zmq_socket (ctx, ZMQ_REQ);
assert (sc);
int rc = zmq_bind (sb, "tcp://*:*");
assert (rc == 0);
char bindEndpoint[256];
char connectEndpoint[256];
size_t endpoint_len = sizeof (bindEndpoint);
rc = zmq_getsockopt (sb, ZMQ_LAST_ENDPOINT, bindEndpoint, &endpoint_len);
assert (rc == 0);
// Apparently Windows can't connect to 0.0.0.0. A better fix would be welcome.
#ifdef ZMQ_HAVE_WINDOWS
sprintf (connectEndpoint, "tcp://127.0.0.1:%s",
strrchr(bindEndpoint, ':') + 1);
#else
strcpy (connectEndpoint, bindEndpoint);
#endif
rc = zmq_connect (sc, connectEndpoint);
assert (rc == 0);
bounce (sb, sc);
rc = zmq_disconnect (sc, connectEndpoint);
assert (rc == 0);
rc = zmq_unbind (sb, bindEndpoint);
assert (rc == 0);
rc = zmq_close (sc);
assert (rc == 0);
rc = zmq_close (sb);
assert (rc == 0);
/* Address wildcard, IPv6 enabled */
sb = zmq_socket (ctx, ZMQ_REP);
assert (sb);
sc = zmq_socket (ctx, ZMQ_REQ);
assert (sc);
rc = zmq_setsockopt (sb, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_setsockopt (sc, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_bind (sb, "tcp://*:*");
assert (rc == 0);
endpoint_len = sizeof (bindEndpoint);
memset(bindEndpoint, 0, endpoint_len);
rc = zmq_getsockopt (sb, ZMQ_LAST_ENDPOINT, bindEndpoint, &endpoint_len);
assert (rc == 0);
#ifdef ZMQ_HAVE_WINDOWS
if (ipv6)
sprintf (connectEndpoint, "tcp://[::1]:%s",
strrchr(bindEndpoint, ':') + 1);
else
sprintf (connectEndpoint, "tcp://127.0.0.1:%s",
strrchr(bindEndpoint, ':') + 1);
#else
strcpy (connectEndpoint, bindEndpoint);
#endif
rc = zmq_connect (sc, connectEndpoint);
assert (rc == 0);
bounce (sb, sc);
rc = zmq_disconnect (sc, connectEndpoint);
assert (rc == 0);
rc = zmq_unbind (sb, bindEndpoint);
assert (rc == 0);
rc = zmq_close (sc);
assert (rc == 0);
rc = zmq_close (sb);
assert (rc == 0);
/* Port wildcard, IPv4 address, IPv6 disabled */
sb = zmq_socket (ctx, ZMQ_REP);
assert (sb);
sc = zmq_socket (ctx, ZMQ_REQ);
assert (sc);
rc = zmq_bind (sb, "tcp://127.0.0.1:*");
assert (rc == 0);
char endpoint[256];
endpoint_len = sizeof (endpoint);
memset(endpoint, 0, endpoint_len);
rc = zmq_getsockopt (sb, ZMQ_LAST_ENDPOINT, endpoint, &endpoint_len);
assert (rc == 0);
rc = zmq_connect (sc, endpoint);
assert (rc == 0);
bounce (sb, sc);
rc = zmq_disconnect (sc, endpoint);
assert (rc == 0);
rc = zmq_unbind (sb, endpoint);
assert (rc == 0);
rc = zmq_close (sc);
assert (rc == 0);
rc = zmq_close (sb);
assert (rc == 0);
/* Port wildcard, IPv4 address, IPv6 enabled */
sb = zmq_socket (ctx, ZMQ_REP);
assert (sb);
sc = zmq_socket (ctx, ZMQ_REQ);
assert (sc);
rc = zmq_setsockopt (sb, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_setsockopt (sc, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_bind (sb, "tcp://127.0.0.1:*");
assert (rc == 0);
endpoint_len = sizeof (endpoint);
memset(endpoint, 0, endpoint_len);
rc = zmq_getsockopt (sb, ZMQ_LAST_ENDPOINT, endpoint, &endpoint_len);
assert (rc == 0);
rc = zmq_connect (sc, endpoint);
assert (rc == 0);
bounce (sb, sc);
rc = zmq_disconnect (sc, endpoint);
assert (rc == 0);
rc = zmq_unbind (sb, endpoint);
assert (rc == 0);
rc = zmq_close (sc);
assert (rc == 0);
rc = zmq_close (sb);
assert (rc == 0);
if (ipv6) {
/* Port wildcard, IPv6 address, IPv6 enabled */
sb = zmq_socket (ctx, ZMQ_REP);
assert (sb);
sc = zmq_socket (ctx, ZMQ_REQ);
assert (sc);
rc = zmq_setsockopt (sb, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_setsockopt (sc, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_bind (sb, "tcp://[::1]:*");
assert (rc == 0);
endpoint_len = sizeof (endpoint);
memset(endpoint, 0, endpoint_len);
rc = zmq_getsockopt (sb, ZMQ_LAST_ENDPOINT, endpoint, &endpoint_len);
assert (rc == 0);
rc = zmq_connect (sc, endpoint);
assert (rc == 0);
bounce (sb, sc);
rc = zmq_disconnect (sc, endpoint);
assert (rc == 0);
rc = zmq_unbind (sb, endpoint);
assert (rc == 0);
rc = zmq_close (sc);
assert (rc == 0);
rc = zmq_close (sb);
assert (rc == 0);
}
rc = zmq_ctx_term (ctx);
assert (rc == 0);
return 0;
}
int main (void)
{
setup_test_environment();
int rc;
char buf[BUF_SIZE];
size_t buf_size;
const char *ep = "tcp://127.0.0.1:5560";
const char *ep_wc_tcp = "tcp://127.0.0.1:*";
#if !defined ZMQ_HAVE_WINDOWS && !defined ZMQ_HAVE_OPENVMS
const char *ep_wc_ipc = "ipc://*";
#endif
#if defined ZMQ_HAVE_VMCI
const char *ep_wc_vmci = "vmci://*:*";
#endif
// Create infrastructure.
void *ctx = zmq_ctx_new ();
assert (ctx);
void *push = zmq_socket (ctx, ZMQ_PUSH);
assert (push);
rc = zmq_bind (push, ep);
assert (rc == 0);
void *pull = zmq_socket (ctx, ZMQ_PULL);
assert (pull);
rc = zmq_connect (pull, ep);
assert (rc == 0);
// Pass one message through to ensure the connection is established
rc = zmq_send (push, "ABC", 3, 0);
assert (rc == 3);
rc = zmq_recv (pull, buf, sizeof (buf), 0);
assert (rc == 3);
// Unbind the listening endpoint
rc = zmq_unbind (push, ep);
assert (rc == 0);
// Allow unbind to settle
msleep (SETTLE_TIME);
// Check that sending would block (there's no outbound connection)
rc = zmq_send (push, "ABC", 3, ZMQ_DONTWAIT);
assert (rc == -1 && zmq_errno () == EAGAIN);
// Clean up
rc = zmq_close (pull);
assert (rc == 0);
rc = zmq_close (push);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
// Create infrastructure
ctx = zmq_ctx_new ();
assert (ctx);
push = zmq_socket (ctx, ZMQ_PUSH);
assert (push);
rc = zmq_connect (push, ep);
assert (rc == 0);
pull = zmq_socket (ctx, ZMQ_PULL);
assert (pull);
rc = zmq_bind (pull, ep);
assert (rc == 0);
// Pass one message through to ensure the connection is established.
rc = zmq_send (push, "ABC", 3, 0);
assert (rc == 3);
rc = zmq_recv (pull, buf, sizeof (buf), 0);
assert (rc == 3);
// Disconnect the bound endpoint
rc = zmq_disconnect (push, ep);
assert (rc == 0);
// Allow disconnect to settle
msleep (SETTLE_TIME);
// Check that sending would block (there's no inbound connections).
rc = zmq_send (push, "ABC", 3, ZMQ_DONTWAIT);
assert (rc == -1 && zmq_errno () == EAGAIN);
// Clean up.
rc = zmq_close (pull);
assert (rc == 0);
rc = zmq_close (push);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
// Create infrastructure (wild-card binding)
ctx = zmq_ctx_new ();
assert (ctx);
push = zmq_socket (ctx, ZMQ_PUSH);
assert (push);
rc = zmq_bind (push, ep_wc_tcp);
assert (rc == 0);
pull = zmq_socket(ctx, ZMQ_PULL);
assert(pull);
#if !defined ZMQ_HAVE_WINDOWS && !defined ZMQ_HAVE_OPENVMS
rc = zmq_bind (pull, ep_wc_ipc);
assert (rc == 0);
#endif
#if defined ZMQ_HAVE_VMCI
void *req = zmq_socket (ctx, ZMQ_REQ);
assert (req);
rc = zmq_bind (req, ep_wc_vmci);
assert (rc == 0);
#endif
// Unbind sockets binded by wild-card address
buf_size = sizeof(buf);
rc = zmq_getsockopt (push, ZMQ_LAST_ENDPOINT, buf, &buf_size);
assert (rc == 0);
rc = zmq_unbind (push, buf);
assert (rc == 0);
#if !defined ZMQ_HAVE_WINDOWS && !defined ZMQ_HAVE_OPENVMS
buf_size = sizeof(buf);
rc = zmq_getsockopt (pull, ZMQ_LAST_ENDPOINT, buf, &buf_size);
assert (rc == 0);
rc = zmq_unbind (pull, buf);
assert (rc == 0);
#endif
#if defined ZMQ_HAVE_VMCI
buf_size = sizeof(buf);
rc = zmq_getsockopt (req, ZMQ_LAST_ENDPOINT, buf, &buf_size);
assert (rc == 0);
rc = zmq_unbind(req, buf);
assert (rc == 0);
#endif
// Clean up.
rc = zmq_close (pull);
assert (rc == 0);
rc = zmq_close (push);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
// Create infrastructure (wild-card binding)
ctx = zmq_ctx_new ();
assert (ctx);
push = zmq_socket (ctx, ZMQ_PUSH);
assert (push);
rc = zmq_bind (push, ep_wc_tcp);
assert (rc == 0);
pull = zmq_socket(ctx, ZMQ_PULL);
assert(pull);
#if !defined ZMQ_HAVE_WINDOWS && !defined ZMQ_HAVE_OPENVMS
rc = zmq_bind (pull, ep_wc_ipc);
assert (rc == 0);
#endif
#if defined ZMQ_HAVE_VMCI
req = zmq_socket (ctx, ZMQ_REQ);
assert (req);
rc = zmq_bind (req, ep_wc_vmci);
assert (rc == 0);
#endif
// Sockets binded by wild-card address can't be unbinded by wild-card address
rc = zmq_unbind (push, ep_wc_tcp);
assert (rc == -1 && zmq_errno () == ENOENT);
#if !defined ZMQ_HAVE_WINDOWS && !defined ZMQ_HAVE_OPENVMS
rc = zmq_unbind (pull, ep_wc_ipc);
assert (rc == -1 && zmq_errno () == ENOENT);
#endif
#if defined ZMQ_HAVE_VMCI
rc = zmq_unbind (req, ep_wc_vmci);
assert (rc == -1 && zmq_errno () == ENOENT);
#endif
// Clean up.
rc = zmq_close (pull);
assert (rc == 0);
rc = zmq_close (push);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
return 0;
}
void LastValueCache::run()
{
// One for each internal statistic (0.._statcount-1) and one for the publisher.
zmq_pollitem_t items[_statcount + 1];
for (int ii = 0; ii < _statcount; ii++)
{
_subscriber[ii] = zmq_socket(_context, ZMQ_SUB);
LOG_DEBUG("Initializing inproc://%s statistic listener", _statnames[ii].c_str());
zmq_connect(_subscriber[ii], ("inproc://" + _statnames[ii]).c_str());
zmq_setsockopt(_subscriber[ii], ZMQ_SUBSCRIBE, "", 0);
}
_publisher = zmq_socket(_context, ZMQ_XPUB);
zmq_bind(_publisher, "tcp://*:6666");
while (!_terminate)
{
// Reset the poll items
for (int ii = 0; ii < _statcount; ii++)
{
items[ii].socket = _subscriber[ii];
items[ii].fd = 0;
items[ii].events = ZMQ_POLLIN;
items[ii].revents = 0;
}
items[_statcount].socket = _publisher;
items[_statcount].fd = 0;
items[_statcount].events = ZMQ_POLLIN;
items[_statcount].revents = 0;
// Poll for an event
//LOG_DEBUG("Poll for %d items", _statcount + 1);
int rc = zmq_poll(items, _statcount + 1, _poll_timeout_ms);
assert(rc >= 0 || errno == EINTR);
for (int ii = 0; ii < _statcount; ii++)
{
if (items[ii].revents & ZMQ_POLLIN)
{
LOG_DEBUG("Update to %s statistic", _statnames[ii].c_str());
clear_cache(_subscriber[ii]);
while (1)
{
zmq_msg_t message;
zmq_msg_t *cached_message = (zmq_msg_t *)malloc(sizeof(zmq_msg_t));
int more;
size_t more_size = sizeof (more);
zmq_msg_init(&message);
zmq_msg_init(cached_message);
zmq_msg_recv(&message, _subscriber[ii], 0);
zmq_msg_copy(cached_message, &message);
_cache[_subscriber[ii]].push_back(cached_message);
zmq_getsockopt(_subscriber[ii], ZMQ_RCVMORE, &more, &more_size);
zmq_msg_send(&message, _publisher, more ? ZMQ_SNDMORE : 0);
zmq_msg_close(&message);
if (!more)
break; // Last message frame
}
}
}
// Recognize incoming subscription events
if (items[_statcount].revents & ZMQ_POLLIN)
{
zmq_msg_t message;
zmq_msg_init(&message);
zmq_msg_recv(&message, _publisher, 0);
char *msg_body = (char *)zmq_msg_data(&message);
if (msg_body[0] == ZMQ_NEW_SUBSCRIPTION_MARKER)
{
// This is a new subscription
std::string topic = std::string(msg_body + 1, zmq_msg_size(&message) - 1);
LOG_DEBUG("New subscription for %s", topic.c_str());
bool recognized = false;
for (int ii = 0; ii < _statcount; ii++)
{
if (topic == _statnames[ii])
{
LOG_DEBUG("Statistic found, check for cached value");
recognized = true;
// Replay the cached message if one exists
if (_cache.find(_subscriber[ii]) != _cache.end())
{
replay_cache(_subscriber[ii]);
}
else
{
LOG_DEBUG("No cached record found, reporting empty statistic");
std::string status = "OK";
zmq_send(_publisher, _statnames[ii].c_str(), _statnames[ii].length(), ZMQ_SNDMORE);
zmq_send(_publisher, status.c_str(), status.length(), 0);
}
}
}
if (!recognized)
{
LOG_DEBUG("Subscription for unknown stat %s", topic.c_str());
std::string status = "Unknown";
zmq_send(_publisher, topic.c_str(), topic.length(), ZMQ_SNDMORE);
zmq_send(_publisher, status.c_str(), status.length(), 0);
}
}
zmq_msg_close(&message);
}
}
for (int ii = 0; ii < _statcount; ii++)
{
zmq_disconnect(_subscriber[ii], ("inproc://" + _statnames[ii]).c_str());
zmq_close(_subscriber[ii]);
clear_cache(_subscriber[ii]);
}
zmq_unbind(_publisher, "tcp://*:6666");
zmq_close(_publisher);
}
