static engine_t *
s_engine_new (char *broker, char *service, int verbose)
{
engine_t *self = (engine_t *) zmalloc (sizeof *self);
// Initialize engine state
self->worker = mdp_worker_new (NULL, broker, service, verbose);
self->sell_orders = zlist_new ();
self->buy_orders = zlist_new ();
return self;
}
int main (int argc, char *argv [])
{
int verbose = (argc > 1 && streq (argv [1], "-v"));
mdp_worker_t *session = mdp_worker_new (
NULL, "tcp://localhost:5555", "echo", verbose);
while (1) {
zframe_t *reply_to;
zmsg_t *request = mdp_worker_recv (session, &reply_to);
if (request == NULL)
break; // Worker was interrupted
// Echo message
mdp_worker_send (session, &request, reply_to);
zframe_destroy (&reply_to);
}
mdp_worker_destroy (&session);
return 0;
}
mdp_worker_t *
mdp_worker_recv (void *socket)
{
// Read all frames off socket
assert (socket);
zmsg_t *msg = zmsg_recv (socket);
if (!msg)
return NULL; // Interrupted
// Create and populate new mdp_worker instance
mdp_worker_t *self = mdp_worker_new (0);
// If we're reading from a ROUTER socket, get address
if (zsockopt_type (socket) == ZMQ_ROUTER) {
self->address = zmsg_pop (msg);
if (!self->address)
goto empty; // Interrupted
}
// Read and check header
zframe_t *empty_frame = zmsg_pop (msg);
if (!empty_frame || !zframe_streq (empty_frame, ""))
goto malformed;
zframe_destroy (&empty_frame);
zframe_t *protocol_frame = zmsg_pop (msg);
if (!protocol_frame || !zframe_streq (protocol_frame, "MDPW01"))
goto malformed;
zframe_destroy (&protocol_frame);
zframe_t *id_frame = zmsg_pop (msg);
if (!id_frame)
goto malformed;
self->id = zframe_data (id_frame) [0];
zframe_destroy (&id_frame);
// Read and parse fields per-message
switch (self->id) {
case MDP_WORKER_READY:
self->service = zmsg_popstr (msg);
if (!self->service)
goto malformed;
break;
case MDP_WORKER_REQUEST:
self->client = zmsg_pop (msg);
if (!self->client)
goto malformed;
self->body = zmsg_pop (msg);
if (!self->body)
goto malformed;
break;
case MDP_WORKER_REPLY:
self->client = zmsg_pop (msg);
if (!self->client)
goto malformed;
self->body = zmsg_pop (msg);
if (!self->body)
goto malformed;
break;
case MDP_WORKER_HEARBEAT:
break;
case MDP_WORKER_DISCONNECT:
break;
default:
goto malformed;
}
// Successful return
zmsg_destroy (&msg);
return self;
// Error returns
malformed:
printf ("E: malformed message '%d'\n", self->id);
empty:
zmsg_destroy (&msg);
mdp_worker_destroy (&self);
return (NULL);
}
int
mdp_worker_test (bool verbose)
{
printf (" * mdp_worker: ");
// Simple create/destroy test
mdp_worker_t *self = mdp_worker_new (0);
assert (self);
mdp_worker_destroy (&self);
// Create pair of sockets we can send through
zctx_t *ctx = zctx_new ();
assert (ctx);
void *output = zsocket_new (ctx, ZMQ_DEALER);
assert (output);
zsocket_bind (output, "inproc://selftest");
void *input = zsocket_new (ctx, ZMQ_ROUTER);
assert (input);
zsocket_connect (input, "inproc://selftest");
// Encode/send/decode and verify each message type
self = mdp_worker_new (MDP_WORKER_READY);
mdp_worker_service_set (self, "Life is short but Now lasts for ever");
mdp_worker_send (&self, output);
self = mdp_worker_recv (input);
assert (self);
assert (streq (mdp_worker_service (self), "Life is short but Now lasts for ever"));
mdp_worker_destroy (&self);
self = mdp_worker_new (MDP_WORKER_REQUEST);
mdp_worker_client_set (self, zframe_new ("Captcha Diem", 12));
mdp_worker_body_set (self, zframe_new ("Captcha Diem", 12));
mdp_worker_send (&self, output);
self = mdp_worker_recv (input);
assert (self);
assert (zframe_streq (mdp_worker_client (self), "Captcha Diem"));
assert (zframe_streq (mdp_worker_body (self), "Captcha Diem"));
mdp_worker_destroy (&self);
self = mdp_worker_new (MDP_WORKER_REPLY);
mdp_worker_client_set (self, zframe_new ("Captcha Diem", 12));
mdp_worker_body_set (self, zframe_new ("Captcha Diem", 12));
mdp_worker_send (&self, output);
self = mdp_worker_recv (input);
assert (self);
assert (zframe_streq (mdp_worker_client (self), "Captcha Diem"));
assert (zframe_streq (mdp_worker_body (self), "Captcha Diem"));
mdp_worker_destroy (&self);
self = mdp_worker_new (MDP_WORKER_HEARBEAT);
mdp_worker_send (&self, output);
self = mdp_worker_recv (input);
assert (self);
mdp_worker_destroy (&self);
self = mdp_worker_new (MDP_WORKER_DISCONNECT);
mdp_worker_send (&self, output);
self = mdp_worker_recv (input);
assert (self);
mdp_worker_destroy (&self);
zctx_destroy (&ctx);
printf ("OK\n");
return 0;
}
