void _rrwrk_config_ppp(rrwrk_t *self, inip_file_t *keyfile)
{
assert(keyfile);
self->sinker = inip_get_string(keyfile, "pppwrk", "sinker", NULL);
assert(self->sinker);
self->broker = inip_get_string(keyfile, "pppwrk", "broker", NULL);
assert(self->broker);
self->liveness = inip_get_integer(keyfile, "pppwrk", "liveness", HEARTBEAT_LIVENESS);
self->heartbeat = inip_get_integer(keyfile, "pppwrk", "heartbeat", HEARTBEAT_DFT);
self->reconnect = inip_get_integer(keyfile, "pppwrk", "reconnect", RECONNECT_DFT);
rrwrk_connect_to_broker(self);
rrwrk_connect_to_sinker(self);
}
void mlog_load(char *fname)
{
char *group_index, *group_level;
char *name, *value, *logname;
int n, default_level;
inip_file_t *fd;
inip_group_t *g;
inip_element_t *ele;
if (_log_lock == NULL) _log_init();
group_index = "log_index";
group_level = "log_level";
//** Open the file
fd = inip_read(fname);
if (fd == NULL) {
log_printf(0, "Error loading module definitions! fname=%s\n", fname);
return;
}
default_level = inip_get_integer(fd, group_level, "default", 0);
//printf("mlog_load: inital ll=%d\n", _log_level);
_log_level = inip_get_integer(fd, group_level, "start_level", _log_level);
//printf("mlog_load: new ll=%d\n", _log_level);
for (n=0; n<_mlog_size; n++) _mlog_table[n] = default_level;
logname = inip_get_string(fd, group_level, "output", "stdout");
open_log(logname);
_log_maxsize = inip_get_integer(fd, group_level, "size", 100*1024*1024);
//** Load the mappings
g = inip_find_group(fd, group_index);
if (g == NULL) {
log_printf(1, "Missing %s group!\n", group_index);
inip_destroy(fd);
return;
}
ele = inip_first_element(g);
while (ele != NULL) {
name = inip_get_element_key(ele);
value = inip_get_element_value(ele);
n = (value != NULL) ? atoi(value) : -1;
if ((n>=0) && (n<_mlog_size)) {
_mlog_file_table[n] = strdup(name);
_mlog_table[n] = inip_get_integer(fd, group_level, name, _mlog_table[n]);
//printf("mlog_load: mi=%d key=%s val=%d\n", n, name, _mlog_table[n]);
} else {
log_printf(0, "Invalid index: %s=%d should be between 0..%d! Skipping option\n", name, n, _mlog_size);
}
//** Move to the next segmnet to load
ele = inip_next_element(ele);
}
inip_destroy(fd);
}
segment_t *load_segment(service_manager_t *ess, ex_id_t id, exnode_exchange_t *ex)
{
char *type = NULL;
char name[1024];
segment_load_t *sload;
if (ex->type == EX_TEXT) {
snprintf(name, sizeof(name), "segment-" XIDT, id);
inip_file_t *fd = ex->text.fd;
type = inip_get_string(fd, name, "type", "");
} else if (ex->type == EX_PROTOCOL_BUFFERS) {
log_printf(0, "load_segment: segment exnode parsing goes here\n");
} else {
log_printf(0, "load_segment: Invalid exnode type type=%d for id=" XIDT "\n", ex->type, id);
return(NULL);
}
sload = lookup_service(ess, SEG_SM_LOAD, type);
if (sload == NULL) {
log_printf(0, "load_segment: No matching driver for type=%s id=" XIDT "\n", type, id);
return(NULL);
}
free(type);
return((*sload)(ess, id, ex));
}
void _rrsvr_config_lpp(rrsvr_t *self, inip_file_t *keyfile)
{
assert(keyfile);
rr_set_mode_tm(keyfile, "lppsvr", &self->mode, &self->timeout);
self->endpoint = inip_get_string(keyfile, "lppsvr", "endpoint", NULL);
assert(self->endpoint);
_rrsvr_bind_lpp(self);
}
void zsock_cc_load(inip_file_t *kf, zsock_context_t *cfg)
{
int i;
for (i = 0; i < ZSOCK_MAX_NUM_CMDS; i++) {
cfg->cc[i].conn_type = NS_TYPE_ZSOCK;
char *type = inip_get_string(kf, "zsock_connect", "sock_type", NULL);
cfg->cc[i].sock_type = zsock_get_type(type);
assert(cfg->cc[i].sock_type != -1);
free(type);
cfg->cc[i].prtcl = inip_get_string(kf, "zsock_connect", "protocol", NULL);
//** Handle socket options
zsocket_opt_t *option = zsock_option_create();
zsock_option_load(kf, "zsock_connect", option);
cfg->cc[i].arg = (void *)option;
}
}
void phoebus_load_config(inip_file_t *kf)
{
if (global_phoebus == NULL) phoebus_init();
char *gateway = inip_get_string(kf, "phoebus", "gateway", NULL);
if (gateway != NULL) {
phoebus_path_set(global_phoebus, gateway);
log_printf(10, "phoebus_init: Using the gateway specified in local config: %s\n", gateway);
free(gateway);
} else if (!global_phoebus->path) {
log_printf(10, "phoebus_init: Error, no valid Phoebus Gateway specified!\n");
abort();
}
}
void rrsvr_load_config(rrsvr_t *self, char *fname)
{
assert(fname);
inip_file_t *keyfile = inip_read(fname);
self->pattern = inip_get_string(keyfile, "zsock", "pattern", NULL);
assert(self->pattern);
if (strcmp(self->pattern, "lpp") == 0) {
_rrsvr_config_lpp(self, keyfile);
} else {
log_printf(0, "Unknown ZMQ Pattern: %s.\n", self->pattern);
exit(0);
}
inip_destroy(keyfile);
}
void rrwrk_load_config(rrwrk_t *self, char *fname)
{
assert(fname);
inip_file_t *keyfile = inip_read(fname);
self->pattern = inip_get_string(keyfile, "zsock", "pattern", NULL);
assert(self->pattern); //** Need a more decent way to handle misconfiguration
if (strcmp(self->pattern, "ppp") == 0) {
_rrwrk_config_ppp(self, keyfile);
} else {
log_printf(0, "W: Unknown ZMQ Pattern: %s.\n", self->pattern);
exit(EXIT_FAILURE);
}
inip_destroy(keyfile);
}
int main(int argc, char **argv)
{
if (argc < 2) {
printf("\n");
printf("rs_test LIO_COMMON_OPTIONS\n");
lio_print_options(stdout);
return(1);
}
int thread_nbr;
lio_init(&argc, &argv);
thread_nbr = lio_parallel_task_count;
//*** Parses the args
char *svr_proto, *svr_addr, *svr_port, *zmq_svr;
//** Retrieves remote zmq server name, transport protocol, and lisenting port
svr_proto = inip_get_string(lio_gc->ifd, "zmq_server", "protocol", RS_ZMQ_DFT_PROTO);
svr_addr = inip_get_string(lio_gc->ifd, "zmq_server", "server", NULL);
svr_port = inip_get_string(lio_gc->ifd, "zmq_server", "port", RS_ZMQ_DFT_PORT);
asprintf(&zmq_svr, "%s://%s:%s", string_trim(svr_proto), string_trim(svr_addr), string_trim(svr_port));
//** Creates zmq context
void *context = zmq_ctx_new();
assert(context != NULL);
//** Creates zmq router and binds it to tcp://*:5555
//** It talks to rs client
void *router = zmq_socket(context, ZMQ_ROUTER);
assert(router != NULL);
int rc = zmq_bind(router, zmq_svr);
assert(rc != -1);
printf("ZMQ router socket created.\n");
// Creates and binds DEALER socket to inproc://worker
// It talks to workers
void *dealer = zmq_socket(context, ZMQ_DEALER);
assert(dealer != NULL);
rc = zmq_bind(dealer, "inproc://worker");
assert(rc != -1);
printf("ZMQ dealer socket created.\n");
//** Blocks the SIGINT, SIGTERM signals
sigemptyset(&signal_mask);
sigaddset(&signal_mask, SIGINT);
sigaddset(&signal_mask, SIGTERM);
rc = pthread_sigmask(SIG_BLOCK, &signal_mask, NULL);
assert(rc == 0);
//** Launches thread pool
printf("Launching threads...\n");
int thread_count;
rs_zmq_thread_arg_t **arg;
type_malloc_clear(arg, rs_zmq_thread_arg_t *, thread_nbr);
pthread_t *workers;
type_malloc_clear(workers, pthread_t, thread_nbr);
for (thread_count = 0; thread_count < thread_nbr; thread_count++) {
type_malloc_clear(arg[thread_count], rs_zmq_thread_arg_t, 1);
arg[thread_count]->zmq_context = context;
arg[thread_count]->rs = lio_gc->rs;
arg[thread_count]->da = ds_attr_create(lio_gc->ds);
arg[thread_count]->ds = lio_gc->ds;
arg[thread_count]->timeout = lio_gc->timeout;
pthread_create(&workers[thread_count], NULL, rs_zmq_worker_routine, (void *)arg[thread_count]);
}
printf("Launched all %d threads.\n", thread_nbr);
//** Unblocks the SIGINT, SIGTERM signals
rc = pthread_sigmask(SIG_UNBLOCK, &signal_mask, NULL);
assert(rc == 0);
//** Catches the SIGNIT, SIGTERM signals
catch_signals();
//** Uses a QUEUE device to connect router and dealer
zmq_device(ZMQ_QUEUE, router, dealer);
if (s_interrupted == 1)
printf("Interrupt received, killing server...\n");
//** Shutdown zmq should go before cleaning thread resources
zmq_close(router);
zmq_close(dealer);
printf("Destroied ZMQ router and dealer\n");
zmq_ctx_destroy(context); //** This "trigers" the exit of all threads, because it makes all blocking operations on sockets return
printf("Destroied ZMQ context\n");
fflush(stdout);
//** Waits for all threads to exit
for (thread_count = 0; thread_count < thread_nbr; thread_count++) {
pthread_join(workers[thread_count], NULL);
}
//** Destroys allocations for threads
for (thread_count = 0; thread_count < thread_nbr; thread_count++) {
ds_attr_destroy(lio_gc->ds, arg[thread_count]->da);
free(arg[thread_count]);
}
free(arg);
free(workers);
free(svr_proto);
free(svr_addr);
free(svr_port);
free(zmq_svr);
lio_shutdown();
return(0);
}
void zsock_option_load(inip_file_t *kf, const char *group, zsocket_opt_t *option)
{
if (_find_group_key(kf, group, "rate")) {
set_flag(option->flag, RATE);
option->rate = inip_get_integer(kf, group, "rate", 100);
}
if (_find_group_key(kf, group, "multicast_hops")) {
set_flag(option->flag, MULTICAST_HOPS);
option->rate = inip_get_integer(kf, group, "multicast_hops", 1);
}
if (_find_group_key(kf, group, "router_behavior")) {
set_flag(option->flag, ROUTER_BEHAVIOR);
option->router_behavior = inip_get_integer(kf, group, "router_behavior", 0);
}
if (_find_group_key(kf, group, "sndhwm")) {
set_flag(option->flag, SNDHWM);
option->sndhwm = inip_get_integer(kf, group, "sndhwm", 1000);
}
if (_find_group_key(kf, group, "rcvhwm")) {
set_flag(option->flag, RCVHWM);
option->rcvhwm = inip_get_integer(kf, group, "rcvhwm", 1000);
}
if (_find_group_key(kf, group, "affinity")) {
set_flag(option->flag, AFFINITY);
option->affinity = inip_get_integer(kf, group, "affinity", 0);
}
if (_find_group_key(kf, group, "recovery_ivl")) {
set_flag(option->flag, RECOVERY_IVL);
option->recovery_ivl = inip_get_integer(kf, group, "recovery_ivl", 1);
}
if (_find_group_key(kf, group, "sndbuf")) {
set_flag(option->flag, SNDBUF);
option->sndbuf = inip_get_integer(kf, group, "sndbuf", 0);
}
if (_find_group_key(kf, group, "rcvbuf")) {
set_flag(option->flag, RCVBUF);
option->rcvbuf = inip_get_integer(kf, group, "rcvbuf", 0);
}
if (_find_group_key(kf, group, "reconnect_ivl")) {
set_flag(option->flag, RECONNECT_IVL);
option->reconnect_ivl = inip_get_integer(kf, group, "reconnect_ivl", 100);
}
if (_find_group_key(kf, group, "reconnect_ivl_max")) {
set_flag(option->flag, RECONNECT_IVL_MAX);
option->reconnect_ivl = inip_get_integer(kf, group, "reconnect_ivl_max", 0);
}
if (_find_group_key(kf, group, "backlog")) {
set_flag(option->flag, BACKLOG);
option->backlog = inip_get_integer(kf, group, "backlog", 100);
}
if (_find_group_key(kf, group, "maxmsgsize")) {
set_flag(option->flag, MAXMSGSIZE);
option->maxmsgsize = inip_get_integer(kf, group, "maxmsgsize", -1);
}
if (_find_group_key(kf, group, "rcvtimeo")) {
set_flag(option->flag, RCVTIMEO);
option->rcvtimeo = inip_get_integer(kf, group, "rcvtimeo", -1);
}
if (_find_group_key(kf, group, "sndtimeo")) {
set_flag(option->flag, SNDTIMEO);
option->sndtimeo = inip_get_integer(kf, group, "sndtimeo", -1);
}
if (_find_group_key(kf, group, "ipv4only")) {
set_flag(option->flag, IPV4ONLY);
option->ipv4only = inip_get_integer(kf, group, "ipv4only", 1);
}
if (_find_group_key(kf, group, "hwm")) {
set_flag(option->flag, HWM);
option->hwm = inip_get_integer(kf, group, "hwm", 1);
}
if (_find_group_key(kf, group, "sub_num")) {
set_flag(option->flag, SUBSCRIBE);
option->sub_num = inip_get_integer(kf, group, "sub_num", 0);
char *sub_list = inip_get_string(kf, group, "subscribe", NULL);
option->subscribe = (char**) malloc(option->sub_num * sizeof(char *));
option->subscribe[0] = strdup(strtok(sub_list, "|"));
int i;
for (i = 1; i < option->sub_num; i++) {
option->subscribe[i] = strdup(strtok(NULL, "|"));
}
free(sub_list);
}
if (_find_group_key(kf, group, "unsub_num")) {
set_flag(option->flag, UNSUBSCRIBE);
option->unsub_num = inip_get_integer(kf, group, "unsub_num", 0);
char *unsub_list = inip_get_string(kf, group, "unsubscribe", NULL);
option->unsubscribe = (char**) malloc(option->unsub_num * sizeof(char *));
option->unsubscribe[0] = strdup(strtok(unsub_list, "|"));
int i;
for (i = 1; i < option->unsub_num; i++) {
option->unsubscribe[i] = strdup(strtok(NULL, "|"));
}
free(unsub_list);
}
if (_find_group_key(kf, group, "identity")) {
set_flag(option->flag, IDENTITY);
option->identity = inip_get_string(kf, group, "identity", NULL);
}
}
