static struct mi_root* clusterer_reload(struct mi_root* root, void *param)
{
cluster_info_t *new_info;
cluster_info_t *old_info;
if (!db_mode) {
LM_ERR("Running in non-DB mode\n");
return init_mi_tree(400, "Non-DB mode", 11);
}
if (load_db_info(&dr_dbf, db_hdl, &db_table, &new_info) != 0) {
LM_ERR("Failed to load info from DB\n");
return init_mi_tree(500, "Failed to reload", 16);
}
lock_start_write(cl_list_lock);
old_info = *cluster_list;
*cluster_list = new_info;
lock_stop_write(cl_list_lock);
if (old_info)
free_info(old_info);
LM_INFO("Reloaded DB info\n");
/* check if the cluster IDs in the the sharing tag list are valid */
shtag_validate_list();
return init_mi_tree(200, MI_SSTR(MI_OK));
}
mi_response_t *clusterer_reload(const mi_params_t *params,
struct mi_handler *async_hdl)
{
cluster_info_t *new_info;
cluster_info_t *old_info;
if (!db_mode) {
LM_ERR("Running in non-DB mode\n");
return init_mi_error(400, MI_SSTR("Non-DB mode"));
}
if (load_db_info(&dr_dbf, db_hdl, &db_table, &new_info) != 0) {
LM_ERR("Failed to load info from DB\n");
return init_mi_error(500, MI_SSTR("Failed to reload"));
}
lock_start_write(cl_list_lock);
if (preserve_reg_caps(new_info) < 0) {
lock_stop_write(cl_list_lock);
LM_ERR("Failed to preserve registered capabilities\n");
if (new_info)
free_info(new_info);
return init_mi_error(500, "Failed to reload", 16);
}
old_info = *cluster_list;
*cluster_list = new_info;
lock_stop_write(cl_list_lock);
if (old_info)
free_info(old_info);
LM_INFO("Reloaded DB info\n");
/* check if the cluster IDs in the the sharing tag list are valid */
shtag_validate_list();
return init_mi_result_ok();
}
static int mod_init(void)
{
int heartbeats_timer_interval;
cluster_info_t *cl;
LM_INFO("Clusterer module - initializing\n");
db_table.len = strlen(db_table.s);
id_col.len = strlen(id_col.s);
cluster_id_col.len = strlen(cluster_id_col.s);
node_id_col.len = strlen(node_id_col.s);
url_col.len = strlen(url_col.s);
state_col.len = strlen(state_col.s);
no_ping_retries_col.len = strlen(no_ping_retries_col.s);
priority_col.len = strlen(priority_col.s);
sip_addr_col.len = strlen(sip_addr_col.s);
flags_col.len = strlen(flags_col.s);
description_col.len = strlen(description_col.s);
/* only allow the DB URL to be skipped in "P2P discovery" mode */
init_db_url(clusterer_db_url, db_mode == 0);
if (current_id < 1) {
LM_CRIT("Invalid 'my_node_id' parameter\n");
return -1;
}
if (ping_interval <= 0) {
LM_WARN("Invalid ping_interval parameter, using default value\n");
ping_interval = DEFAULT_PING_INTERVAL;
}
if (node_timeout < 0) {
LM_WARN("Invalid node_timeout parameter, using default value\n");
node_timeout = DEFAULT_NODE_TIMEOUT;
}
if (ping_timeout <= 0) {
LM_WARN("Invalid ping_timeout parameter, using default value\n");
ping_timeout = DEFAULT_PING_TIMEOUT;
}
/* create & init lock */
if ((cl_list_lock = lock_init_rw()) == NULL) {
LM_CRIT("Failed to init lock\n");
return -1;
}
/* data pointer in shm */
if (cluster_list == NULL) {
cluster_list = shm_malloc(sizeof *cluster_list);
if (!cluster_list) {
LM_CRIT("No more shm memory\n");
goto error;
}
*cluster_list = NULL;
} else {
/* sanity check of my_node_id if node_id also set in a my_node_info param */
for (cl = *cluster_list; cl; cl = cl->next)
if (cl->current_node->node_id != current_id) {
LM_ERR("Bad 'my_node_id' parameter, value: %d different than"
" the node_id property in the 'my_node_info' parameter\n", current_id);
goto error;
}
}
if (db_mode) {
/* bind to the mysql module */
if (db_bind_mod(&clusterer_db_url, &dr_dbf)) {
LM_CRIT("Cannot bind to database module! "
"Did you forget to load a database module ?\n");
goto error;
}
if (!DB_CAPABILITY(dr_dbf, DB_CAP_QUERY)) {
LM_CRIT("Given SQL DB does not provide query types needed by this module!\n");
goto error;
}
/* init DB connection */
if ((db_hdl = dr_dbf.init(&clusterer_db_url)) == 0) {
LM_ERR("cannot initialize database connection\n");
goto error;
}
if (load_db_info(&dr_dbf, db_hdl, &db_table, cluster_list) < 0) {
LM_ERR("Failed to load info from DB\n");
goto error;
}
}
/* register timer */
heartbeats_timer_interval = gcd(ping_interval*1000, ping_timeout);
heartbeats_timer_interval = gcd(heartbeats_timer_interval, node_timeout*1000);
if (heartbeats_timer_interval % 1000 == 0) {
if (register_timer("clstr-heartbeats-timer", heartbeats_timer_handler,
NULL, heartbeats_timer_interval/1000, TIMER_FLAG_DELAY_ON_DELAY) < 0) {
LM_CRIT("Unable to register clusterer heartbeats timer\n");
goto error;
}
} else {
if (register_utimer("clstr-heartbeats-utimer", heartbeats_utimer_handler,
NULL, heartbeats_timer_interval*1000, TIMER_FLAG_DELAY_ON_DELAY) < 0) {
LM_CRIT("Unable to register clusterer heartbeats timer\n");
goto error;
}
}
if (bin_register_cb(&cl_internal_cap, bin_rcv_cl_packets, NULL) < 0) {
LM_CRIT("Cannot register clusterer binary packet callback!\n");
goto error;
}
if (bin_register_cb(&cl_extra_cap, bin_rcv_cl_extra_packets, NULL) < 0) {
LM_CRIT("Cannot register extra clusterer binary packet callback!\n");
goto error;
}
/* create generic message receiving events */
if (gen_rcv_evs_init() < 0) {
LM_ERR("cannot create cluster message received event\n");
return -1;
}
/* create node state event */
if (node_state_ev_init() < 0) {
LM_ERR("cannot create node state change event\n");
return -1;
}
/* check if the cluster IDs in the the sharing tag list are valid */
shtag_init_list();
shtag_validate_list();
return 0;
error:
lock_destroy_rw(cl_list_lock);
cl_list_lock = NULL;
if (cluster_list) {
shm_free(cluster_list);
cluster_list = 0;
}
return -1;
}
