static bpm_client_err_e _bpm_data_acquire (bpm_client_t *self, char *service,
acq_req_t *acq_req)
{
assert (self);
assert (service);
assert (acq_req);
bpm_client_err_e err = BPM_CLIENT_SUCCESS;
ACQ_OPCODE_TYPE operation = ACQ_OPCODE_DATA_ACQUIRE;
/* Message is:
* frame 0: operation code
* frame 1: number of samples
* frame 2: channel */
zmsg_t *request = zmsg_new ();
zmsg_addmem (request, &operation, sizeof (operation));
zmsg_addmem (request, &acq_req->num_samples, sizeof (acq_req->num_samples));
zmsg_addmem (request, &acq_req->chan, sizeof (acq_req->chan));
mdp_client_send (self->mdp_client, service, &request);
/* Receive report */
zmsg_t *report = mdp_client_recv (self->mdp_client, NULL, NULL);
ASSERT_TEST(report != NULL, "Report received is NULL", err_null_report);
assert (zmsg_size (report) == 1);
/* Message is:
* frame 0: error code */
zframe_t *err_code = zmsg_pop(report);
ASSERT_TEST(err_code != NULL, "Could not receive error code", err_null_code);
if ( *(ACQ_REPLY_TYPE *) zframe_data(err_code) != ACQ_OK) {
DBE_DEBUG (DBG_LIB_CLIENT | DBG_LVL_TRACE, "[libclient] bpm_data_acquire: "
"Data acquire was not required correctly\n");
err = BPM_CLIENT_ERR_AGAIN;
goto err_data_acquire;
}
DBE_DEBUG (DBG_LIB_CLIENT | DBG_LVL_TRACE, "[libclient] bpm_data_acquire: "
"Data acquire was successfully required\n");
err_data_acquire:
zframe_destroy (&err_code);
err_null_code:
zmsg_destroy (&report);
err_null_report:
return err;
}
int main (int argc, char *argv [])
{
int verbose = (argc > 1 && streq (argv [1], "-v"));
mdp_client_t *client = mdp_client_new ("tcp://localhost:5555", verbose);
// Send 100 sell orders
int count;
for (count = 0; count < 5; count++) {
zmsg_t *request = zmsg_new ();
zmsg_pushstr (request, "8"); // volume
zmsg_pushstr (request, "%d", count + 1000); // price
zmsg_pushstr (request, "SELL");
mdp_client_send (client, "NYSE", &request);
}
// Send 1 buy order.
// This order will match all sell orders.
zmsg_t *request = zmsg_new ();
zmsg_pushstr (request, "800"); // volume
zmsg_pushstr (request, "2000"); // price
zmsg_pushstr (request, "BUY");
mdp_client_send (client, "NYSE", &request);
// Wait for all trading reports
while (1) {
char *service = NULL;
zmsg_t *report = mdp_client_recv (client, &service);
if (report == NULL)
break;
assert (zmsg_size (report) >= 2);
zframe_t *report_type = zmsg_pop (report);
char *report_type_str = zframe_strdup (report_type);
zframe_t *volume = zmsg_pop (report);
char *volume_str = zframe_strdup (volume);
printf ("%s: %s %s shares\n", service, report_type_str, volume_str);
free (service);
free (report_type_str);
free (volume_str);
}
mdp_client_destroy (&client);
return 0;
}
int main (int argc, char *argv [])
{
int verbose = (argc > 1 && streq (argv [1], "-v"));
mdp_client_t *session = mdp_client_new ("tcp://localhost:5555", verbose);
int count;
for (count = 0; count < 100000; count++) {
zmsg_t *request = zmsg_new ();
zmsg_pushstr (request, "Hello world");
mdp_client_send (session, "echo", &request);
zmsg_t *reply = mdp_client_recv (session, NULL, NULL);
if (reply)
zmsg_destroy (&reply);
else
break; // Interrupt or failure
}
printf ("%d requests/replies processed\n", count);
mdp_client_destroy (&session);
return 0;
}
static bpm_client_err_e _bpm_check_data_acquire (bpm_client_t *self, char *service)
{
assert (self);
assert (service);
int err = BPM_CLIENT_SUCCESS;
ACQ_OPCODE_TYPE operation = ACQ_OPCODE_CHECK_DATA_ACQUIRE;
/* Message is:
* frame 0: operation code */
zmsg_t *request = zmsg_new ();
zmsg_addmem (request, &operation, sizeof (operation));
mdp_client_send (self->mdp_client, service, &request);
/* Receive report */
zmsg_t *report = mdp_client_recv (self->mdp_client, NULL, NULL);
ASSERT_TEST(report != NULL, "Report received is NULL", err_null_report);
assert (zmsg_size (report) == 1);
/* Message is:
* frame 0: error code */
zframe_t *err_code = zmsg_pop(report);
ASSERT_TEST(err_code != NULL, "Could not receive error code", err_null_code);
if ( *(ACQ_REPLY_TYPE *) zframe_data(err_code) != ACQ_OK) {
DBE_DEBUG (DBG_LIB_CLIENT | DBG_LVL_TRACE, "[libclient] bpm_check_data_acquire: "
"Check fail: data acquire was not completed\n");
err = BPM_CLIENT_ERR_SERVER;
goto err_check_data_acquire;
}
DBE_DEBUG (DBG_LIB_CLIENT | DBG_LVL_TRACE, "[libclient] bpm_check_data_acquire: "
"Check ok: data acquire was successfully completed\n");
err_check_data_acquire:
zframe_destroy (&err_code);
err_null_code:
zmsg_destroy (&report);
err_null_report:
return err;
}
int
mdp_client_test (bool verbose)
{
printf (" * mdp_client: ");
// Simple create/destroy test
mdp_client_t *self = mdp_client_new ();
assert (self);
mdp_client_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_client_new ();
mdp_client_service_set (self, "Life is short but Now lasts for ever");
mdp_client_body_set (self, zframe_new ("Captcha Diem", 12));
mdp_client_send (&self, output);
self = mdp_client_recv (input);
assert (self);
assert (streq (mdp_client_service (self), "Life is short but Now lasts for ever"));
assert (zframe_streq (mdp_client_body (self), "Captcha Diem"));
mdp_client_destroy (&self);
zctx_destroy (&ctx);
printf ("OK\n");
return 0;
}
static bpm_client_err_e _bpm_get_data_block (bpm_client_t *self, char *service,
acq_trans_t *acq_trans)
{
assert (self);
assert (service);
assert (acq_trans);
assert (acq_trans->block.data);
bpm_client_err_e err = BPM_CLIENT_SUCCESS;
ACQ_OPCODE_TYPE operation = ACQ_OPCODE_GET_DATA_BLOCK;
/* Message is:
* frame 0: operation code
* frame 1: channel
* frame 2: block required */
zmsg_t *request = zmsg_new ();
zmsg_addmem (request, &operation, sizeof (operation));
zmsg_addmem (request, &acq_trans->req.chan, sizeof (acq_trans->req.chan));
zmsg_addmem (request, &acq_trans->block.idx, sizeof (acq_trans->block.idx));
mdp_client_send (self->mdp_client, service, &request);
/* Receive report */
zmsg_t *report = mdp_client_recv (self->mdp_client, NULL, NULL);
ASSERT_TEST(report != NULL, "Report received is NULL", err_null_report);
assert (zmsg_size (report) == 3);
/* Message is:
* frame 0: error code
* frame 1: data size
* frame 2: data block */
zframe_t *err_code = zmsg_pop (report);
ASSERT_TEST(err_code != NULL, "Could not receive error code", err_null_code);
zframe_t *data_size_frm = zmsg_pop (report);
ASSERT_TEST(data_size_frm != NULL, "Could not receive data size", err_null_data_size);
uint32_t data_size = *(uint32_t *) zframe_data(data_size_frm);
zframe_t *data = zmsg_pop (report);
ASSERT_TEST(data != NULL, "Could not receive data", err_null_data);
if ( *(ACQ_REPLY_TYPE *) zframe_data (err_code) != ACQ_OK) {
DBE_DEBUG (DBG_LIB_CLIENT | DBG_LVL_TRACE, "[libclient] bpm_get_data_block: "
"Data block was not acquired\n");
err = BPM_CLIENT_ERR_SERVER;
goto err_get_data_block;
}
/* Data size effectively returned */
uint32_t read_size = (acq_trans->block.data_size < data_size) ?
acq_trans->block.data_size : data_size;
memcpy (acq_trans->block.data, (uint32_t *) zframe_data (data), read_size);
/* Print some debug messages */
DBE_DEBUG (DBG_LIB_CLIENT | DBG_LVL_TRACE, "[libclient] bpm_get_data_block: "
"read_size: %u\n", read_size);
DBE_DEBUG (DBG_LIB_CLIENT | DBG_LVL_TRACE, "[libclient] bpm_get_data_block: "
"acq_trans->block.data: %p\n", acq_trans->block.data);
acq_trans->block.bytes_read = read_size;
err_get_data_block:
zframe_destroy (&data);
err_null_data:
zframe_destroy (&data_size_frm);
err_null_data_size:
zframe_destroy (&err_code);
err_null_code:
zmsg_destroy (&report);
err_null_report:
return err;
}
