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"); }
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); }
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"); }
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_ignore_interrupts (loop); zloop_start (loop); // zloop runs the handler which will terminate the loop assert (timer_event_called); zsys_interrupted = 0; // cleanup zloop_destroy (&loop); assert (loop == NULL); zsock_destroy (&input); zsock_destroy (&output); // @end printf ("OK\n"); }
/// // Ignore zsys_interrupted flag in this loop. By default, a zloop_start will // exit as soon as it detects zsys_interrupted is set to something other than // zero. Calling zloop_ignore_interrupts will supress this behavior. void QZloop::ignoreInterrupts () { zloop_ignore_interrupts (self); }