mdcli_t *
mdcli_new (char *broker, int verbose)
{
assert (broker);
mdcli_t *self = (mdcli_t *) zmalloc (sizeof (mdcli_t));
self->ctx = zctx_new ();
self->broker = strdup (broker);
self->verbose = verbose;
self->timeout = 2500; // msecs
s_mdcli_connect_to_broker (self);
return self;
}
mdcli_t *
mdcli_new (char *broker, int verbose)
{
assert (broker);
s_version_assert (2, 1);
mdcli_t *self = (mdcli_t *) calloc (1, sizeof (mdcli_t));
self->broker = strdup (broker);
self->context = zmq_init (1);
self->verbose = verbose;
self->timeout = 2500; // msecs
s_catch_signals ();
s_mdcli_connect_to_broker (self);
return self;
}
zmsg_t *
mdcli_send (mdcli_t *self, char *service, zmsg_t **request_p)
{
assert (self);
assert (request_p);
zmsg_t *request = *request_p;
// Prefix request with protocol frames
// Frame 1: "MDPCxy" (six bytes, MDP/Client x.y)
// Frame 2: Service name (printable string)
zmsg_push (request, service);
zmsg_push (request, MDPC_CLIENT);
if (self->verbose) {
s_console ("I: send request to '%s' service:", service);
zmsg_dump (request);
}
int retries_left = self->retries;
while (retries_left && !s_interrupted) {
zmsg_t *msg = zmsg_dup (request);
zmsg_send (&msg, self->client);
while (!s_interrupted) {
// Poll socket for a reply, with timeout
zmq_pollitem_t items [] = {
{ self->client, 0, ZMQ_POLLIN, 0 } };
zmq_poll (items, 1, self->timeout * 1000);
// If we got a reply, process it
if (items [0].revents & ZMQ_POLLIN) {
zmsg_t *msg = zmsg_recv (self->client);
if (self->verbose) {
s_console ("I: received reply:");
zmsg_dump (msg);
}
// Don't try to handle errors, just assert noisily
assert (zmsg_parts (msg) >= 3);
char *header = zmsg_pop (msg);
assert (streq (header, MDPC_CLIENT));
free (header);
char *reply_service = zmsg_pop (msg);
assert (streq (reply_service, service));
free (reply_service);
zmsg_destroy (&request);
return msg; // Success
}
else
if (--retries_left) {
if (self->verbose)
s_console ("W: no reply, reconnecting...");
// Reconnect, and resend message
s_mdcli_connect_to_broker (self);
zmsg_t *msg = zmsg_dup (request);
zmsg_send (&msg, self->client);
}
else {
if (self->verbose)
s_console ("W: permanent error, abandoning request");
break; // Give up
}
}
}
if (s_interrupted)
printf ("W: interrupt received, killing client...\n");
zmsg_destroy (&request);
return NULL;
}
zmsg_t *
mdcli_send(mdcli_t *self, char *service, zmsg_t **request_p)
{
assert(self);
assert(request_p);
zmsg_t *request = *request_p;
zmsg_pushstr(request, service);
zmsg_pushstr(request, MDPC_CLIENT);
if (self->verbose){
zclock_log("I: send request to '%s' service:", service);
zmsg_dump(request);
}
int retries_left = self->retries;
while (retries_left && !zctx_interrupted){
zmsg_t *msg = zmsg_dup(request);
zmsg_send(&msg, self->client);
zmq_pollitem_t items [] = {
{self->client, 0, ZMQ_POLLIN, 0}
};
int rc = zmq_poll(items, 1, self->timeout * ZMQ_POLL_MSEC);
if (rc == -1)
break;
if (items[0].revents & ZMQ_POLLIN){
zmsg_t *msg = zmsg_recv(self->client);
if (self->verbose){
zclock_log("I: received reply:");
zmsg_dump(msg);
}
assert(zmsg_size(msg) >= 3);
zframe_t *header = zmsg_pop(msg);
assert(zframe_streq(header, MDPC_CLIENT));
zframe_destroy(&header);
zframe_t *reply_service = zmsg_pop(msg);
assert(zframe_streq(reply_service, service));
zframe_destroy(&reply_service);
zmsg_destroy(&request);
return msg;
}
else
if (--retries_left){
if (self->verbose)
zclock_log("W: no reply, reconnecting...");
s_mdcli_connect_to_broker(self);
}
else {
if (self->verbose)
zclock_log("W: permanent error, abandoning");
break;
}
}
if (zctx_interrupted)
printf("W: interrupt received, killing client...\n");
zmsg_destroy(&request);
return NULL;
}
