static void s_destroy(client_proxy_t **self_p) {
assert(self_p);
if (*self_p) {
client_proxy_t *self = *self_p;
if (self->ticket_store_req != NULL) {
zsock_destroy(&self->ticket_store_req);
}
if (self->ticket_store_sub != NULL) {
zsock_destroy(&self->ticket_store_sub);
}
if (self->printer_store_req != NULL) {
zsock_destroy(&self->printer_store_req);
}
if (self->pub != NULL) {
zsock_destroy(&self->pub);
}
if (self->rep != NULL) {
zsock_destroy(&self->rep);
}
if (self->printer_store_sub != NULL) {
zsock_destroy(&self->printer_store_sub);
}
zloop_destroy(&self->loop);
free(self);
*self_p = NULL;
}
}
int main (void)
{
clonesrv_t *self = (clonesrv_t *) zmalloc (sizeof (clonesrv_t));
self->port = 5556;
self->ctx = zctx_new ();
self->kvmap = zhash_new ();
self->loop = zloop_new ();
zloop_set_verbose (self->loop, FALSE);
// Set up our clone server sockets
self->snapshot = zsocket_new (self->ctx, ZMQ_ROUTER);
self->publisher = zsocket_new (self->ctx, ZMQ_PUB);
self->collector = zsocket_new (self->ctx, ZMQ_PULL);
zsocket_bind (self->snapshot, "tcp://*:%d", self->port);
zsocket_bind (self->publisher, "tcp://*:%d", self->port + 1);
zsocket_bind (self->collector, "tcp://*:%d", self->port + 2);
// Register our handlers with reactor
zmq_pollitem_t poller = { self->snapshot, 0, ZMQ_POLLIN };
zloop_poller (self->loop, &poller, s_snapshots, self);
poller.socket = self->collector;
zloop_poller (self->loop, &poller, s_collector, self);
zloop_timer (self->loop, 1000, 0, s_flush_ttl, self);
// Run reactor until process interrupted
zloop_start (self->loop);
zloop_destroy (&self->loop);
zhash_destroy (&self->kvmap);
zctx_destroy (&self->ctx);
free (self);
return 0;
}
zloop_t *
zloop_new (void)
{
zloop_t
*self;
self = (zloop_t *) zmalloc (sizeof (zloop_t));
if (!self)
return NULL;
self->readers = zlistx_new ();
if (self->readers)
self->pollers = zlistx_new ();
if (self->pollers)
self->timers = zlistx_new ();
if (self->timers)
self->zombies = zlistx_new ();
if (self->zombies)
self->tickets = zlistx_new ();
if (self->tickets) {
self->last_timer_id = 0;
zlistx_set_destructor (self->readers, (czmq_destructor *) s_reader_destroy);
zlistx_set_destructor (self->pollers, (czmq_destructor *) s_poller_destroy);
zlistx_set_destructor (self->timers, (czmq_destructor *) s_timer_destroy);
zlistx_set_comparator (self->timers, (czmq_comparator *) s_timer_comparator);
zlistx_set_destructor (self->tickets, (czmq_destructor *) s_ticket_destroy);
zlistx_set_comparator (self->tickets, (czmq_comparator *) s_ticket_comparator);
}
else
zloop_destroy (&self);
return self;
}
int main (void) {
zsys_set_ipv6 (1);
zactor_t *root = zactor_new (zgossip, "root");
assert (root);
int rc = 0;
rc = zstr_sendx (root, "BIND", "tcp://*:5670", NULL);
assert (rc == 0);
zloop_t *reactor = zloop_new ();
assert (reactor);
zloop_set_verbose (reactor, true);
rc = zloop_reader (reactor, root, handle_pipe, NULL);
assert (rc == 0);
zloop_start (reactor);
zloop_destroy (&reactor);
zactor_destroy (&root);
return 0;
}
/* url subtitle arguments */
int main (int argc, char *argv []) {
void *context = zmq_init (1);
void *subscriber = zmq_socket (context, ZMQ_SUB);
size_t title_len = 0;
assert(zmq_connect (subscriber, argv[1]) == 0);
assert(title_len = strlen(argv[2]) > 1);
assert(zmq_setsockopt (subscriber, ZMQ_SUBSCRIBE, argv[2], title_len) == 0);
Bool verbose = 0;
zloop_t *loop = zloop_new ();
assert (loop);
zloop_set_verbose (loop, verbose);
zmq_pollitem_t sub_event = { subscriber, 0, ZMQ_POLLIN };
if ( argc > 3 ) {
assert(zloop_poller (loop, &sub_event, subscriber_cb, (void*)(argv + 3)) == 0);
} else {
assert(zloop_poller (loop, &sub_event, subscriber_cb, NULL) == 0);
}
zloop_start (loop);
zloop_destroy (&loop);
assert (loop == NULL);
zmq_close (subscriber);
zmq_term (context);
return 0;
}
void subscriber(zsock_t *pipe, void *args)
{
set_thread_name("subscriber[0]");
int rc;
zconfig_t* config = args;
subscriber_state_t *state = subscriber_state_new(pipe, config, hosts);
// signal readyiness after sockets have been created
zsock_signal(pipe, 0);
// subscribe to either all messages, or a subset
setup_subscriptions(state);
// set up event loop
zloop_t *loop = zloop_new();
assert(loop);
zloop_set_verbose(loop, 0);
// setup handler for actor messages
rc = zloop_reader(loop, state->pipe, actor_command, state);
assert(rc == 0);
// setup handler for the sub socket
rc = zloop_reader(loop, state->sub_socket, read_request_and_forward, state);
assert(rc == 0);
// setup handler for the router socket
rc = zloop_reader(loop, state->router_socket, read_router_request_forward, state);
assert(rc == 0);
// setup handler for the pull socket
rc = zloop_reader(loop, state->pull_socket, read_request_and_forward, state);
assert(rc == 0);
// run the loop
if (!quiet)
fprintf(stdout, "[I] subscriber: listening\n");
bool should_continue_to_run = getenv("CPUPROFILE") != NULL;
do {
rc = zloop_start(loop);
should_continue_to_run &= errno == EINTR;
log_zmq_error(rc, __FILE__, __LINE__);
} while (should_continue_to_run);
if (!quiet)
fprintf(stdout, "[I] subscriber: shutting down\n");
// shutdown
subscriber_state_destroy(&state);
zloop_destroy(&loop);
assert(loop == NULL);
if (!quiet)
fprintf(stdout, "[I] subscriber: terminated\n");
}
int main(int argc, char const * const *argv)
{
int rc;
zsys_set_sndhwm(1);
zsys_set_linger(100);
void *pusher = zsock_new(ZMQ_PUSH);
assert(pusher);
zsock_set_sndhwm(pusher, 1000);
zsock_set_linger(pusher, 500);
rc = zsock_connect(pusher, "tcp://localhost:12345");
assert(rc==0);
void *puller = zsock_new(ZMQ_PULL);
assert(puller);
zsock_set_rcvhwm(puller, 1000);
zsock_set_linger(puller, 500);
rc = zsock_bind(puller, "tcp://*:12345");
if (rc != 12345){
printf("bind failed: %s\n", zmq_strerror(errno));
}
assert(rc == 12345);
void *publisher = zsock_new(ZMQ_PUB);
assert(publisher);
zsock_set_sndhwm(publisher, 1000);
zsock_set_linger(publisher, 500);
rc = zsock_bind(publisher, "tcp://*:12346");
assert(rc==12346);
// set up event loop
zloop_t *loop = zloop_new();
assert(loop);
zloop_set_verbose(loop, 0);
// push data every 10 ms
rc = zloop_timer(loop, 1, 0, timer_event, pusher);
assert(rc != -1);
zmq_pollitem_t item;
item.socket = puller;
item.events = ZMQ_POLLIN;
rc = zloop_poller(loop, &item, forward, publisher);
assert(rc == 0);
rc = zloop_start(loop);
printf("zloop return: %d", rc);
zloop_destroy(&loop);
assert(loop == NULL);
return 0;
}
void
bstar_destroy(bstar_t **self_p)
{
assert(self_p);
if (*self_p){
bstar_t *self = *self_p;
zloop_destroy(&self->loop);
zctx_destroy(&self->ctx);
free(self);
*self_p = NULL;
}
}
int main (int argc, char** argv)
{
int port = 5556;
#ifdef FF_USE_LIBGC
GC_INIT();
set_program_name (argv[0]);
#endif
if( argc >= 2 )
port = atoi( argv[1] );
clonesrv_t *self = (clonesrv_t *) zmalloc (sizeof (clonesrv_t));
self->port = port;
self->ctx = zctx_new ();
self->kvmap = zhash_new ();
self->loop = zloop_new ();
zloop_set_verbose (self->loop, false);
// Set up our clone server sockets
self->snapshot = zsocket_new (self->ctx, ZMQ_ROUTER);
zsocket_bind (self->snapshot, "tcp://*:%d", self->port + socket_srv_offset_snapshot );
self->publisher = zsocket_new (self->ctx, ZMQ_PUB);
zsocket_bind (self->publisher, "tcp://*:%d", self->port + socket_srv_offset_publisher );
self->collector = zsocket_new (self->ctx, ZMQ_PULL);
zsocket_bind (self->collector, "tcp://*:%d", self->port + socket_srv_offset_collector );
self->ping = zsocket_new (self->ctx, ZMQ_REP);
zsocket_bind (self->ping, "tcp://*:%d", self->port + socket_srv_offset_ping );
// Register our handlers with reactor
zmq_pollitem_t poller = { 0, 0, ZMQ_POLLIN };
poller.socket = self->snapshot;
zloop_poller (self->loop, &poller, s_snapshots, self);
poller.socket = self->collector;
zloop_poller (self->loop, &poller, s_collector, self);
zloop_timer (self->loop, 1000, 0, s_flush_ttl, self);
poller.socket = self->ping;
zloop_poller (self->loop, &poller, s_ping, self);
DEBUG ("I: server up and running on port:%d...", port );
// Run reactor until process interrupted
zloop_start (self->loop);
zloop_destroy (&self->loop);
zhash_destroy (&self->kvmap);
zctx_destroy (&self->ctx);
free (self);
return 0;
}
static void
s_zdir_watch_destroy (zdir_watch_t **watch_p)
{
assert (watch_p);
if (*watch_p) {
zdir_watch_t *watch = *watch_p;
zloop_destroy (&watch->loop);
zhash_destroy (&watch->subs);
freen (watch);
*watch_p = NULL;
}
}
void
zloop_test (bool verbose)
{
printf (" * zloop: ");
int rc = 0;
// @selftest
// Create two PAIR sockets and connect over inproc
zsock_t *output = zsock_new (ZMQ_PAIR);
assert (output);
zsock_bind (output, "inproc://zloop.test");
zsock_t *input = zsock_new (ZMQ_PAIR);
assert (input);
zsock_connect (input, "inproc://zloop.test");
zloop_t *loop = zloop_new ();
assert (loop);
zloop_set_verbose (loop, verbose);
// Create a timer that will be cancelled
int timer_id = zloop_timer (loop, 1000, 1, s_timer_event, NULL);
zloop_timer (loop, 5, 1, s_cancel_timer_event, &timer_id);
// After 20 msecs, send a ping message to output3
zloop_timer (loop, 20, 1, s_timer_event, output);
// Set up some tickets that will never expire
zloop_set_ticket_delay (loop, 10000);
void *ticket1 = zloop_ticket (loop, s_timer_event, NULL);
void *ticket2 = zloop_ticket (loop, s_timer_event, NULL);
void *ticket3 = zloop_ticket (loop, s_timer_event, NULL);
// When we get the ping message, end the reactor
rc = zloop_reader (loop, input, s_socket_event, NULL);
assert (rc == 0);
zloop_reader_set_tolerant (loop, input);
zloop_start (loop);
zloop_ticket_delete (loop, ticket1);
zloop_ticket_delete (loop, ticket2);
zloop_ticket_delete (loop, ticket3);
zloop_destroy (&loop);
assert (loop == NULL);
zsock_destroy (&input);
zsock_destroy (&output);
// @end
printf ("OK\n");
}
int graylog_forwarder_run_controller_loop(zconfig_t* config, zlist_t* devices, zlist_t *subscriptions, int rcv_hwm, int send_hwm)
{
set_thread_name("controller");
zsys_init();
controller_state_t state = {.config = config};
bool start_up_complete = controller_create_actors(&state, devices, subscriptions, rcv_hwm, send_hwm);
if (!start_up_complete)
goto exit;
// set up event loop
zloop_t *loop = zloop_new();
assert(loop);
zloop_set_verbose(loop, 0);
// send tick commands every second
int rc = zloop_timer(loop, 1000, 1, send_tick_commands, &state);
assert(rc != -1);
// run the loop
// when running under the google profiler, zmq_poll terminates with EINTR
// so we keep the loop running in this case
if (!zsys_interrupted) {
bool should_continue_to_run = getenv("CPUPROFILE") != NULL;
do {
rc = zloop_start(loop);
should_continue_to_run &= errno == EINTR && !zsys_interrupted;
log_zmq_error(rc, __FILE__, __LINE__);
} while (should_continue_to_run);
}
printf("[I] controller: shutting down\n");
// shutdown
zloop_destroy(&loop);
assert(loop == NULL);
exit:
printf("[I] controller: destroying actor threads\n");
controller_destroy_actors(&state);
printf("[I] controller: calling zsys_shutdown\n");
zsys_shutdown();
printf("[I] controller: terminated\n");
return 0;
}
void rabbitmq_listener(zsock_t *pipe, void* args)
{
set_thread_name("rabbit-consumer");
// signal readyiness immediately so that zmq publishers are already processed
// while the rabbitmq exchanges/queues/bindings are created
zsock_signal(pipe, 0);
amqp_connection_state_t conn = setup_amqp_connection();
int last_channel = rabbitmq_setup_queues(conn, (zlist_t*)args);
// connect to the receiver socket
zsock_t *receiver = zsock_new(ZMQ_PUSH);
zsock_set_sndhwm(receiver, 10000);
zsock_connect(receiver, "inproc://receiver");
// set up event loop
zloop_t *loop = zloop_new();
assert(loop);
zloop_set_verbose(loop, 0);
zloop_ignore_interrupts(loop);
// register actor command handler
int rc = zloop_reader(loop, pipe, pipe_command, NULL);
assert(rc==0);
// register rabbitmq socket for pollin events
zmq_pollitem_t rabbit_item = {
.fd = amqp_get_sockfd(conn),
.events = ZMQ_POLLIN
};
rabbit_listener_state_t listener_state = {
.conn = conn,
.receiver = zsock_resolve(receiver)
};
rc = zloop_poller(loop, &rabbit_item, rabbitmq_consume_message_and_forward, &listener_state);
assert(rc==0);
// start event loop
zloop_start(loop);
// shutdown
zloop_destroy(&loop);
zsock_destroy(&receiver);
shutdown_amqp_connection(conn, 0, last_channel);
}
/* ================ run_client() ================ */
int run_client(const char *endpoint, int op_code, int total_threads, uint32_t total_files, const char *key, const char *filename, int verbose)
{
info_log("run_client() with op_code:%d endpoint:%s threads:%d count:%d key:%s filename:%s", op_code, endpoint, total_threads, total_files, key, filename);
if ( prepare_file_data(filename) != 0 ){
return -1;
}
total_actors = total_threads;
client_t **clients = (client_t**)malloc(sizeof(client_t*) * total_actors);
for ( int i = 0 ; i < total_actors ; i++ ){
client_t *client = client_new(i, endpoint);
client->op_code = op_code;
client->total_threads = total_threads;
client->total_files = total_files;
client->key = key;
client->filename = filename;
client->file_data = file_data;
client->file_size = file_size;
client_create_actor(client);
clients[i] = client;
}
zloop_t *loop = zloop_new();
zloop_set_verbose(loop, verbose);
for ( int i = 0 ; i < total_actors ; i++ ){
zactor_t *actor = clients[i]->actor;
zloop_reader(loop, (zsock_t*)zactor_resolve(actor), handle_pullin_on_client_pipe, clients[i]);
}
zloop_start(loop);
zloop_destroy(&loop);
for ( int i = 0 ; i < total_actors ; i++ ){
client_free(clients[i]);
}
return 0;
}
static
void graylog_forwarder_subscriber(zsock_t *pipe, void *args)
{
set_thread_name("graylog-forwarder-subscriber");
int rc;
subscriber_state_t *state = subscriber_state_new(pipe, args);
// signal readyiness after sockets have been created
zsock_signal(pipe, 0);
// set up event loop
zloop_t *loop = zloop_new();
assert(loop);
zloop_set_verbose(loop, 0);
// we rely on the controller shutting us down
zloop_ignore_interrupts(loop);
// setup handler for actor messages
rc = zloop_reader(loop, state->pipe, actor_command, state);
assert(rc == 0);
// setup handler for the sub socket
rc = zloop_reader(loop, state->sub_socket, read_request_and_forward, state);
assert(rc == 0);
// run the loop
fprintf(stdout, "[I] subscriber: listening\n");
bool should_continue_to_run = getenv("CPUPROFILE") != NULL;
do {
rc = zloop_start(loop);
should_continue_to_run &= errno == EINTR;
if (!zsys_interrupted)
log_zmq_error(rc, __FILE__, __LINE__);
} while (should_continue_to_run);
fprintf(stdout, "[I] subscriber: shutting down\n");
// shutdown
subscriber_state_destroy(&state);
zloop_destroy(&loop);
assert(loop == NULL);
fprintf(stdout, "[I] subscriber: terminated\n");
}
static void
receiver_actor (zsock_t *pipe, void *args)
{
// initialization
ubx_block_t *b = (ubx_block_t *) args;
struct zmq_receiver_info *inf = (struct zmq_receiver_info*) b->private_data;
printf("zmq_receiver: actor started.\n");
// send signal on pipe socket to acknowledge initialisation
zsock_signal (pipe, 0);
zloop_t *loop = zloop_new ();
assert (loop);
int rc = zloop_reader (loop, inf->subscriber, handle_event, args);
assert (rc == 0);
zloop_start (loop);
zloop_destroy (&loop);
}
static void
driver_destroy (driver_t **self_p)
{
assert (self_p);
if (*self_p) {
driver_t *self = *self_p;
if (self->verbose)
zclock_log ("I: (tcp) shutting down driver");
while (zlist_size (self->vockets)) {
vocket_t *vocket = (vocket_t *) zlist_pop (self->vockets);
vocket_destroy (&vocket);
}
zlist_destroy (&self->vockets);
zloop_destroy (&self->loop);
free (self);
*self_p = NULL;
}
}
void watchdog(zsock_t *pipe, void *args)
{
set_thread_name("watchdog[0]");
int rc;
watchdog_state_t state = { .credit = CREDIT, .received_term_cmd = false };
// signal readyiness
zsock_signal(pipe, 0);
// set up event loop
zloop_t *loop = zloop_new();
assert(loop);
zloop_set_verbose(loop, 0);
// we rely on the controller shutting us down
zloop_ignore_interrupts(loop);
// decrease credit every second
rc = zloop_timer(loop, 1000, 0, timer_event, &state);
assert(rc != -1);
// setup handler for actor messages
rc = zloop_reader(loop, pipe, actor_command, &state);
assert(rc == 0);
// run the loop
bool should_continue_to_run = getenv("CPUPROFILE") != NULL;
do {
rc = zloop_start(loop);
should_continue_to_run &= errno == EINTR;
if (!state.received_term_cmd)
log_zmq_error(rc, __FILE__, __LINE__);
} while (should_continue_to_run);
if (!quiet)
printf("[I] watchdog[0]: shutting down\n");
// shutdown
zloop_destroy(&loop);
assert(loop == NULL);
if (!quiet)
printf("[I] watchdog[0]: terminated\n");
}
int main(void)
{
zctx_t *ctx = zctx_new();
lbbroker_t *self = (lbbroker_t *)zmalloc(sizeof(lbbroker_t));
self->frontend = zsocket_new(ctx, ZMQ_ROUTER);
self->backend = zsocket_new(ctx, ZMQ_ROUTER);
#if (defined (WIN32))
zsocket_bind(self->frontend, "tcp://*:5672"); // frontend
zsocket_bind(self->backend, "tcp://*:5673"); // backend
#else
zsocket_bind(self->frontend, "ipc://frontend.ipc");
zsocket_bind(self->backend, "ipc://backend.ipc");
#endif
int client_nbr;
for (client_nbr = 0; client_nbr < NBR_CLIENTS; client_nbr++)
zthread_new(client_task, NULL);
int worker_nbr;
for (worker_nbr = 0; worker_nbr < NBR_WORKERS; worker_nbr++)
zthread_new(worker_task, NULL);
// Queue of available workers
self->workers = zlist_new();
// Prepare reactor and fire it up
zloop_t *reactor = zloop_new();
zmq_pollitem_t poller = { self->backend, 0, ZMQ_POLLIN };
zloop_poller(reactor, &poller, s_handle_backend, self);
zloop_start(reactor);
zloop_destroy(&reactor);
// When we're done, clean up properly
while (zlist_size(self->workers)) {
zframe_t *frame = (zframe_t *)zlist_pop(self->workers);
zframe_destroy(&frame);
}
zlist_destroy(&self->workers);
zctx_destroy(&ctx);
free(self);
return 0;
}
int maltcp_ctx_destroy(void **self_p) {
clog_debug(maltcp_logger, "maltcp_ctx_destroy...\n");
if (self_p && *self_p) {
maltcp_ctx_t *self = (maltcp_ctx_t *) *self_p;
// TODO(AF): zmq_close versus zsocket_destroy
zsocket_set_linger(self->endpoints_socket, 0);
clog_debug(maltcp_logger, "maltcp_ctx_destroy: linger=%d\n", zsocket_linger(self->endpoints_socket));
zsocket_destroy(self->zmq_ctx, self->endpoints_socket);
// zmq_close(mal_ctx->endpoints_socket);
// Free all structures in hash-table, close socket and destroy mutex.
if (self->cnx_table) {
maltcp_ctx_connection_t *cnx_ptr = (maltcp_ctx_connection_t*) zhash_first(self->cnx_table);
while (cnx_ptr) {
// Close registered TCP connections
clog_debug(maltcp_logger, "maltcp_ctx_destroy: close socket %d.\n", cnx_ptr->socket);
maltcp_ctx_socket_destroy(cnx_ptr);
// destroy all registered sockets
cnx_ptr = (maltcp_ctx_connection_t*) zhash_next(self->cnx_table);
}
}
// TODO (AF): Close all pollers?
clog_debug(maltcp_logger, "maltcp_ctx_destroy: stopped.\n");
free(self->maltcp_header);
// Free all structures in hash-table, close socket and destroy mutex.
if (self->cnx_table)
zhash_destroy(&self->cnx_table);
zloop_destroy(&self->zloop);
// zsocket_destroy(self->zmq_ctx, self->endpoints_socket);
// zmq_close(self->endpoints_socket);
zctx_destroy(&self->zmq_ctx);
free(self);
*self_p = NULL;
}
clog_debug(maltcp_logger, "maltcp_ctx_destroy: destroyed.\n");
return 0;
}
static void s_destroy(ticket_printer_t **self_p) {
assert(self_p);
if (*self_p) {
ticket_printer_t *self = *self_p;
if (self->ticket_store_req != NULL)
zsock_destroy(&self->ticket_store_req);
if (self->printer_store_req != NULL)
zsock_destroy(&self->printer_store_req);
zloop_destroy(&self->loop);
if (self->hid_printer != NULL)
boca_hid_destroy(&self->hid_printer);
#ifdef __WIN32__
if (self->serial_printer != NULL)
boca_serial_destroy(&self->serial_printer);
#endif
free(self->last_token);
free(self);
*self_p = NULL;
}
}
void
zloop_test (bool verbose)
{
printf (" * zloop: ");
int rc = 0;
// @selftest
zctx_t *ctx = zctx_new ();
assert (ctx);
void *output = zsocket_new (ctx, ZMQ_PAIR);
assert (output);
zsocket_bind (output, "inproc://zloop.test");
void *input = zsocket_new (ctx, ZMQ_PAIR);
assert (input);
zsocket_connect (input, "inproc://zloop.test");
zloop_t *loop = zloop_new ();
assert (loop);
zloop_set_verbose (loop, verbose);
// Create a timer that will be canceled
int timer_id = zloop_timer (loop, 1000, 1, s_timer_event, NULL);
zloop_timer (loop, 5, 1, s_cancel_timer_event, &timer_id);
// After 20 msecs, send a ping message to output
zloop_timer (loop, 20, 1, s_timer_event, output);
// When we get the ping message, end the reactor
zmq_pollitem_t poll_input = { input, 0, ZMQ_POLLIN };
rc = zloop_poller (loop, &poll_input, s_socket_event, NULL);
assert (rc == 0);
zloop_set_tolerant (loop, &poll_input);
zloop_start (loop);
zloop_destroy (&loop);
assert (loop == NULL);
zctx_destroy (&ctx);
// @end
printf ("OK\n");
}
int main (int argc, char *argv [])
{
if (argc == 2) {
count = atoi(argv[1]);
}
zctx_t *ctx = zctx_new();
void *client = zsocket_new(ctx, ZMQ_ROUTER);
zloop_t *loop = zloop_new();
zsocket_bind(client, "ipc:///tmp/zmqtestbr");
zmq_pollitem_t items [] = { { client, 0, ZMQ_POLLIN, 0 } };
zloop_poller(loop, items, recvHandler, client);
zloop_start(loop);
zloop_destroy(&loop);
zctx_destroy(&ctx);
return 0;
}
static void
s_self_destroy(self_t** self_p)
{
assert(self_p);
if (*self_p) {
self_t* self = *self_p;
if (self->mrb) {
mrb_close(self->mrb);
self->mrb = NULL;
}
zloop_destroy(&self->reactor);
actor_message_destroy(&self->actor_msg);
zsock_destroy(&self->router);
zsock_destroy(&self->pull);
if (self->discovery) {
zyre_destroy(&self->discovery);
}
actor_discovery_destroy(&self->actor_discovery_msg);
free(self);
*self_p = NULL;
}
}
void PrimeWorker::Work(zctx_t *ctx, void *pipe) {
printf("PrimeWorker started.\n");
mBackend = zsocket_new(ctx, ZMQ_DEALER);
void* frontend = zsocket_new(ctx, ZMQ_DEALER);
void* input = zsocket_new(ctx, ZMQ_SUB);
mServer = zsocket_new(ctx, ZMQ_ROUTER);
mSignals = zsocket_new(ctx, ZMQ_PUB);
zsocket_set_sndhwm(mBackend, 1*1000*1000);
int err = 0;
err = zsocket_bind(mServer, "tcp://*:%d", mServerPort);
if(!err)
printf("zsocket_bind(mServer, tcp://*:*) failed.\n");
err = zsocket_bind(mSignals, "tcp://*:%d", mSignalPort);
if(!err)
printf("zsocket_bind(mSignals, tcp://*:*) failed.\n");
printf("PrimeWorker: mServerPort=%d mSignalPort=%d\n", mServerPort, mSignalPort);
err = zsocket_connect(mBackend, "tcp://localhost:8888");
assert(!err);
err = zsocket_connect(frontend, "tcp://localhost:7777");
assert(!err);
err = zsocket_connect(input, "inproc://bitcoin");
assert(!err);
const char one[2] = {1, 0};
zsocket_set_subscribe(input, one);
zloop_t* wloop = zloop_new();
zmq_pollitem_t item_input = {input, 0, ZMQ_POLLIN, 0};
err = zloop_poller(wloop, &item_input, &PrimeWorker::InvokeInput, this);
assert(!err);
zmq_pollitem_t item_server = {mServer, 0, ZMQ_POLLIN, 0};
err = zloop_poller(wloop, &item_server, &PrimeWorker::InvokeRequest, this);
assert(!err);
zmq_pollitem_t item_frontend = {frontend, 0, ZMQ_POLLIN, 0};
err = zloop_poller(wloop, &item_frontend, &PrimeWorker::InvokeRequest, this);
assert(!err);
err = zloop_timer(wloop, 60000, 0, &PrimeWorker::InvokeTimerFunc, this);
assert(err >= 0);
zsocket_signal(pipe);
zloop_start(wloop);
zloop_destroy(&wloop);
zsocket_destroy(ctx, mServer);
zsocket_destroy(ctx, mSignals);
zsocket_destroy(ctx, mBackend);
zsocket_destroy(ctx, frontend);
zsocket_destroy(ctx, input);
zsocket_signal(pipe);
printf("PrimeWorker exited.\n");
}
int main(int argc, char * const *argv)
{
int rc = 0;
process_arguments(argc, argv);
setvbuf(stdout, NULL, _IOLBF, 0);
setvbuf(stderr, NULL, _IOLBF, 0);
if (!quiet)
printf("[I] started %s\n"
"[I] sub-port: %d\n"
"[I] push-port: %d\n"
"[I] io-threads: %lu\n"
"[I] rcv-hwm: %d\n"
"[I] snd-hwm: %d\n"
, argv[0], pull_port, pub_port, io_threads, rcv_hwm, snd_hwm);
// load config
config_file_exists = zsys_file_exists(config_file_name);
if (config_file_exists) {
config_file_init();
config = zconfig_load((char*)config_file_name);
}
// set global config
zsys_init();
zsys_set_rcvhwm(10000);
zsys_set_sndhwm(10000);
zsys_set_pipehwm(1000);
zsys_set_linger(100);
zsys_set_io_threads(io_threads);
// create socket to receive messages on
zsock_t *receiver = zsock_new(ZMQ_SUB);
assert_x(receiver != NULL, "sub socket creation failed", __FILE__, __LINE__);
zsock_set_rcvhwm(receiver, rcv_hwm);
// bind externally
char* host = zlist_first(hosts);
while (host) {
if (!quiet)
printf("[I] connecting to: %s\n", host);
rc = zsock_connect(receiver, "%s", host);
assert_x(rc == 0, "sub socket connect failed", __FILE__, __LINE__);
host = zlist_next(hosts);
}
tracker = device_tracker_new(hosts, receiver);
// create socket for publishing
zsock_t *publisher = zsock_new(ZMQ_PUSH);
assert_x(publisher != NULL, "pub socket creation failed", __FILE__, __LINE__);
zsock_set_sndhwm(publisher, snd_hwm);
rc = zsock_bind(publisher, "tcp://%s:%d", "*", pub_port);
assert_x(rc == pub_port, "pub socket bind failed", __FILE__, __LINE__);
// create compressor sockets
zsock_t *compressor_input = zsock_new(ZMQ_PUSH);
assert_x(compressor_input != NULL, "compressor input socket creation failed", __FILE__, __LINE__);
rc = zsock_bind(compressor_input, "inproc://compressor-input");
assert_x(rc==0, "compressor input socket bind failed", __FILE__, __LINE__);
zsock_t *compressor_output = zsock_new(ZMQ_PULL);
assert_x(compressor_output != NULL, "compressor output socket creation failed", __FILE__, __LINE__);
rc = zsock_bind(compressor_output, "inproc://compressor-output");
assert_x(rc==0, "compressor output socket bind failed", __FILE__, __LINE__);
// create compressor agents
zactor_t *compressors[MAX_COMPRESSORS];
for (size_t i = 0; i < num_compressors; i++)
compressors[i] = message_decompressor_new(i);
// set up event loop
zloop_t *loop = zloop_new();
assert(loop);
zloop_set_verbose(loop, 0);
// calculate statistics every 1000 ms
int timer_id = zloop_timer(loop, 1000, 0, timer_event, NULL);
assert(timer_id != -1);
// setup handler for the receiver socket
publisher_state_t publisher_state = {
.receiver = zsock_resolve(receiver),
.publisher = zsock_resolve(publisher),
.compressor_input = zsock_resolve(compressor_input),
.compressor_output = zsock_resolve(compressor_output),
};
// setup handler for compression results
rc = zloop_reader(loop, compressor_output, read_zmq_message_and_forward, &publisher_state);
assert(rc == 0);
zloop_reader_set_tolerant(loop, compressor_output);
// setup handdler for messages incoming from the outside or rabbit_listener
rc = zloop_reader(loop, receiver, read_zmq_message_and_forward, &publisher_state);
assert(rc == 0);
zloop_reader_set_tolerant(loop, receiver);
// initialize clock
global_time = zclock_time();
// setup subscriptions
if (subscriptions == NULL || zlist_size(subscriptions) == 0) {
if (!quiet)
printf("[I] subscribing to all log messages\n");
zsock_set_subscribe(receiver, "");
} else {
char *subscription = zlist_first(subscriptions);
while (subscription) {
if (!quiet)
printf("[I] subscribing to %s\n", subscription);
zsock_set_subscribe(receiver, subscription);
subscription = zlist_next(subscriptions);
}
zsock_set_subscribe(receiver, "heartbeat");
}
// run the loop
if (!zsys_interrupted) {
if (verbose)
printf("[I] starting main event loop\n");
bool should_continue_to_run = getenv("CPUPROFILE") != NULL;
do {
rc = zloop_start(loop);
should_continue_to_run &= errno == EINTR && !zsys_interrupted;
log_zmq_error(rc, __FILE__, __LINE__);
} while (should_continue_to_run);
if (verbose)
printf("[I] main event zloop terminated with return code %d\n", rc);
}
zloop_destroy(&loop);
assert(loop == NULL);
if (!quiet) {
printf("[I] received %zu messages\n", received_messages_count);
printf("[I] shutting down\n");
}
zlist_destroy(&hosts);
zlist_destroy(&subscriptions);
zsock_destroy(&receiver);
zsock_destroy(&publisher);
zsock_destroy(&compressor_input);
zsock_destroy(&compressor_output);
device_tracker_destroy(&tracker);
for (size_t i = 0; i < num_compressors; i++)
zactor_destroy(&compressors[i]);
zsys_shutdown();
if (!quiet)
printf("[I] terminated\n");
return rc;
}
JNIEXPORT void JNICALL
Java_org_zeromq_czmq_Zloop__1_1destroy (JNIEnv *env, jclass c, jlong self)
{
zloop_destroy ((zloop_t **) &self);
}
void
zloop_test (bool verbose)
{
printf (" * zloop: ");
int rc = 0;
// @selftest
// Create two PAIR sockets and connect over inproc
zsock_t *output = zsock_new (ZMQ_PAIR);
assert (output);
zsock_bind (output, "inproc://zloop.test");
zsock_t *input = zsock_new (ZMQ_PAIR);
assert (input);
zsock_connect (input, "inproc://zloop.test");
zloop_t *loop = zloop_new ();
assert (loop);
zloop_set_verbose (loop, verbose);
// Create a timer that will be cancelled
int timer_id = zloop_timer (loop, 1000, 1, s_timer_event, NULL);
zloop_timer (loop, 5, 1, s_cancel_timer_event, &timer_id);
// After 20 msecs, send a ping message to output3
zloop_timer (loop, 20, 1, s_timer_event, output);
// Set up some tickets that will never expire
zloop_set_ticket_delay (loop, 10000);
void *ticket1 = zloop_ticket (loop, s_timer_event, NULL);
void *ticket2 = zloop_ticket (loop, s_timer_event, NULL);
void *ticket3 = zloop_ticket (loop, s_timer_event, NULL);
// When we get the ping message, end the reactor
rc = zloop_reader (loop, input, s_socket_event, NULL);
assert (rc == 0);
zloop_reader_set_tolerant (loop, input);
zloop_start (loop);
zloop_ticket_delete (loop, ticket1);
zloop_ticket_delete (loop, ticket2);
zloop_ticket_delete (loop, ticket3);
// Check whether loop properly ignores zsys_interrupted flag
// when asked to
zloop_destroy (&loop);
loop = zloop_new ();
bool timer_event_called = false;
zloop_timer (loop, 1, 1, s_timer_event3, &timer_event_called);
zsys_interrupted = 1;
zloop_start (loop);
// zloop returns immediately without giving any handler a chance to run
assert (!timer_event_called);
zloop_set_nonstop (loop, true);
zloop_start (loop);
// zloop runs the handler which will terminate the loop
assert (timer_event_called);
zsys_interrupted = 0;
// Check if reader removed in timer is not called
zloop_destroy (&loop);
loop = zloop_new ();
bool socket_event_called = false;
zloop_reader (loop, output, s_socket_event1, &socket_event_called);
zloop_timer (loop, 0, 1, s_timer_event5, output);
zstr_send (input, "PING");
zloop_start (loop);
assert (!socket_event_called);
// cleanup
zloop_destroy (&loop);
assert (loop == NULL);
zsock_destroy (&input);
zsock_destroy (&output);
#if defined (__WINDOWS__)
zsys_shutdown();
#endif
// @end
printf ("OK\n");
}
///
// Destroy a reactor
QZloop::~QZloop ()
{
zloop_destroy (&self);
}
///
// Destroy a reactor
void QmlZloopAttached::destruct (QmlZloop *qmlSelf) {
zloop_destroy (&qmlSelf->self);
};