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; }