static
subscriber_state_t* subscriber_state_new(zsock_t *pipe, zconfig_t* config, zlist_t *devices)
{
// figure out devices specs
if (devices == NULL)
devices = zlist_new();
if (zlist_size(devices) == 0) {
zlist_destroy(&devices);
devices = extract_devices_from_config(config);
}
if (zlist_size(devices) == 0)
zlist_append(devices, augment_zmq_connection_spec("localhost", sub_port));
//create the state
subscriber_state_t *state = zmalloc(sizeof(*state));
state->pipe = pipe;
state->devices = devices;
state->sub_socket = subscriber_sub_socket_new(config, state->devices);
state->tracker = device_tracker_new(devices, state->sub_socket);
state->pull_socket = subscriber_pull_socket_new(config);
state->router_socket = subscriber_router_socket_new(config);
state->push_socket = subscriber_push_socket_new(config);
if (PUBLISH_DUPLICATES)
state->pub_socket = subscriber_pub_socket_new(config);
return state;
}
static
subscriber_state_t* subscriber_state_new(zsock_t* pipe, subscriber_args_t* args)
{
subscriber_state_t *state = zmalloc(sizeof(*state));
state->pipe = pipe;
state->config = args->config;
state->devices = args->devices;
state->subscriptions = args->subscriptions;
state->rcv_hwm = args->rcv_hwm;
state->snd_hwm = args->snd_hwm;
state->sub_socket = subscriber_sub_socket_new(state);
state->push_socket = subscriber_push_socket_new();
state->tracker = device_tracker_new(state->devices, state->sub_socket);
free(args);
return state;
}
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;
}
