int nh_init_cluster(void)
{
if (load_clusterer_api(&c_api)!=0) {
LM_ERR("failed to find clusterer API - is clusterer "
"module loaded?\n");
return -1;
}
/* "register" the sharing tag */
if (nh_cluster_shtag.s) {
nh_cluster_shtag.len = strlen(nh_cluster_shtag.s);
if (c_api.shtag_get( &nh_cluster_shtag, nh_cluster_id)<0) {
LM_ERR("failed to initialized the sharing tag <%.*s>\n",
nh_cluster_shtag.len, nh_cluster_shtag.s);
return -1;
}
} else {
nh_cluster_shtag.len = 0;
}
return 0;
}
static int mod_init(void)
{
LM_INFO("Load-Balancer module - initializing\n");
init_db_url( db_url , 0 /*cannot be null*/);
/* Load dialog API */
if (load_dlg_api(&lb_dlg_binds) != 0) {
LM_ERR("Can't load dialog hooks\n");
return -1;
}
if (fetch_freeswitch_stats) {
if (load_fs_api(&fs_api) == -1) {
LM_ERR("failed to load the FS API!\n");
return -1;
}
}
/* data pointer in shm */
curr_data = (struct lb_data**)shm_malloc( sizeof(struct lb_data*) );
if (curr_data==0) {
LM_CRIT("failed to get shm mem for data ptr\n");
return -1;
}
*curr_data = 0;
/* create & init lock */
if ((ref_lock = lock_init_rw()) == NULL) {
LM_CRIT("failed to init lock\n");
return -1;
}
if (init_lb_bls()) {
LM_ERR("BL INIT failed\n");
return -1;
}
/* init and open DB connection */
if (init_lb_db(&db_url, table_name)!=0) {
LM_ERR("failed to initialize the DB support\n");
return -1;
}
/* load data */
if ( lb_reload_data()!=0 ) {
LM_CRIT("failed to load load-balancing data\n");
return -1;
}
/* close DB connection */
lb_close_db();
/* arm a function for probing */
if (lb_prob_interval) {
/* load TM API */
if (load_tm_api(&lb_tmb)!=0) {
LM_ERR("can't load TM API\n");
return -1;
}
/* probing method */
lb_probe_method.len = strlen(lb_probe_method.s);
lb_probe_from.len = strlen(lb_probe_from.s);
if (lb_probe_replies.s)
lb_probe_replies.len = strlen(lb_probe_replies.s);
/* register pinger function */
if (register_timer( "lb-pinger", lb_prob_handler , NULL,
lb_prob_interval, TIMER_FLAG_DELAY_ON_DELAY)<0) {
LM_ERR("failed to register probing handler\n");
return -1;
}
/* Register the max load recalculation timer */
if (fetch_freeswitch_stats &&
register_timer("lb-update-max-load", lb_update_max_loads, NULL,
fs_api.stats_update_interval, TIMER_FLAG_SKIP_ON_DELAY)<0) {
LM_ERR("failed to register timer for max load recalc!\n");
return -1;
}
if (lb_probe_replies.s) {
lb_probe_replies.len = strlen(lb_probe_replies.s);
if(parse_reply_codes( &lb_probe_replies, &probing_reply_codes,
&probing_codes_no )< 0) {
LM_ERR("Bad format for options_reply_code parameter"
" - Need a code list separated by commas\n");
return -1;
}
}
}
/* parse avps */
if (parse_avp_spec(&group_avp_name_s, &group_avp_name)) {
LM_ERR("cannot parse group avp\n");
return -1;
}
if (parse_avp_spec(&flags_avp_name_s, &flags_avp_name)) {
LM_ERR("cannot parse flags avp\n");
return -1;
}
if (parse_avp_spec(&mask_avp_name_s, &mask_avp_name)) {
LM_ERR("cannot parse mask avp\n");
return -1;
}
if (parse_avp_spec(&id_avp_name_s, &id_avp_name)) {
LM_ERR("cannot parse id avp\n");
return -1;
}
if (parse_avp_spec(&res_avp_name_s, &res_avp_name)) {
LM_ERR("cannot parse resources avp\n");
return -1;
}
if (lb_init_event() < 0) {
LM_ERR("cannot init event\n");
return -1;
}
if (lb_repl_cluster < 0) {
LM_ERR("Invalid replication_cluster, must be 0 or "
"a positive cluster id\n");
return -1;
}
if (lb_repl_cluster && load_clusterer_api(&clusterer_api)!=0) {
LM_DBG("failed to find clusterer API - is clusterer module loaded?\n");
return -1;
}
/* register handler for processing load_balancer replication packets to the clusterer module */
if (lb_repl_cluster > 0 &&
clusterer_api.register_capability(&status_repl_cap,
receive_lb_binary_packet, NULL, lb_repl_cluster, 0, NODE_CMP_ANY) < 0) {
LM_ERR("cannot register binary packet callback to clusterer module!\n");
return -1;
}
return 0;
}
/*! \brief
* Module initialization function
*/
static int mod_init(void)
{
LM_DBG("initializing\n");
/* Compute the lengths of string parameters */
init_db_url( db_url , 1 /*can be null*/);
user_col.len = strlen(user_col.s);
domain_col.len = strlen(domain_col.s);
contact_col.len = strlen(contact_col.s);
expires_col.len = strlen(expires_col.s);
q_col.len = strlen(q_col.s);
callid_col.len = strlen(callid_col.s);
cseq_col.len = strlen(cseq_col.s);
flags_col.len = strlen(flags_col.s);
cflags_col.len = strlen(cflags_col.s);
user_agent_col.len = strlen(user_agent_col.s);
received_col.len = strlen(received_col.s);
path_col.len = strlen(path_col.s);
sock_col.len = strlen(sock_col.s);
methods_col.len = strlen(methods_col.s);
sip_instance_col.len = strlen(sip_instance_col.s);
attr_col.len = strlen(attr_col.s);
last_mod_col.len = strlen(last_mod_col.s);
if(ul_hash_size<=1)
ul_hash_size = 512;
else
ul_hash_size = 1<<ul_hash_size;
ul_locks_no = ul_hash_size;
/* check matching mode */
switch (matching_mode) {
case CONTACT_ONLY:
case CONTACT_CALLID:
break;
default:
LM_ERR("invalid matching mode %d\n", matching_mode);
}
if(ul_init_locks()!=0)
{
LM_ERR("locks array initialization failed\n");
return -1;
}
/* Register cache timer */
register_timer( "ul-timer", timer, 0, timer_interval,
TIMER_FLAG_DELAY_ON_DELAY);
/* init the callbacks list */
if ( init_ulcb_list() < 0) {
LM_ERR("usrloc/callbacks initialization failed\n");
return -1;
}
/* Shall we use database ? */
if (db_mode != NO_DB) { /* Yes */
if (db_url.s==NULL || db_url.len==0) {
LM_ERR("selected db_mode requires a db connection -> db_url \n");
return -1;
}
if (db_bind_mod(&db_url, &ul_dbf) < 0) { /* Find database module */
LM_ERR("failed to bind database module\n");
return -1;
}
if (!DB_CAPABILITY(ul_dbf, DB_CAP_ALL)) {
LM_ERR("database module does not implement all functions"
" needed by the module\n");
return -1;
}
if (db_mode != DB_ONLY && (sync_lock = lock_init_rw()) == NULL) {
LM_ERR("cannot init rw lock\n");
return -1;
}
}
fix_flag_name(nat_bflag_str, nat_bflag);
nat_bflag = get_flag_id_by_name(FLAG_TYPE_BRANCH, nat_bflag_str);
if (nat_bflag==(unsigned int)-1) {
nat_bflag = 0;
} else if ( nat_bflag>=8*sizeof(nat_bflag) ) {
LM_ERR("bflag index (%d) too big!\n", nat_bflag);
return -1;
} else {
nat_bflag = 1<<nat_bflag;
}
if (ul_event_init() < 0) {
LM_ERR("cannot initialize USRLOC events\n");
return -1;
}
/* register handler for processing usrloc packets from the bin interface */
if (accept_replicated_udata &&
bin_register_cb(repl_module_name.s, receive_binary_packet) < 0) {
LM_ERR("cannot register binary packet callback!\n");
return -1;
}
if(ul_replicate_cluster > 0 && load_clusterer_api(&clusterer_api)!=0){
LM_DBG("failed to find clusterer API - is clusterer module loaded?\n");
return -1;
}
if(ul_replicate_cluster < 0){
ul_replicate_cluster = 0;
}
init_flag = 1;
return 0;
}
/* initialize ratelimit module */
static int mod_init(void)
{
unsigned int n;
LM_INFO("Ratelimit module - initializing ...\n");
if (rl_timer_interval < 0) {
LM_ERR("invalid timer interval\n");
return -1;
}
if (rl_expire_time < 0) {
LM_ERR("invalid expire time\n");
return -1;
}
if (rl_repl_timer_interval < 0) {
LM_ERR("invalid replication time\n");
return -1;
}
if( rl_repl_cluster < 0 )
rl_repl_cluster = 0;
if( accept_repl_pipes < 0 )
accept_repl_pipes = 0;
if ( (rl_repl_cluster || accept_repl_pipes) && load_clusterer_api(&clusterer_api) != 0 ){
LM_DBG("failed to find clusterer API - is clusterer module loaded?\n");
return -1;
}
if (db_url.s) {
db_url.len = strlen(db_url.s);
db_prefix.len = strlen(db_prefix.s);
LM_DBG("using CacheDB url: %s\n", db_url.s);
}
RL_SHM_MALLOC(rl_network_count, sizeof(int));
RL_SHM_MALLOC(rl_network_load, sizeof(int));
RL_SHM_MALLOC(rl_load_value, sizeof(double));
RL_SHM_MALLOC(pid_kp, sizeof(double));
RL_SHM_MALLOC(pid_ki, sizeof(double));
RL_SHM_MALLOC(pid_kd, sizeof(double));
RL_SHM_MALLOC(pid_setpoint, sizeof(double));
RL_SHM_MALLOC(drop_rate, sizeof(int));
RL_SHM_MALLOC(rl_feedback_limit, sizeof(int));
/* init ki value for feedback algo */
*pid_ki = -25.0;
rl_lock = lock_alloc();
if (!rl_lock) {
LM_ERR("cannot alloc lock\n");
return -1;
}
if (!lock_init(rl_lock)) {
LM_ERR("failed to init lock\n");
return -1;
}
/* register timer to reset counters */
if (register_timer("rl-timer", rl_timer, NULL,
rl_timer_interval, TIMER_FLAG_DELAY_ON_DELAY) < 0 ) {
LM_ERR("could not register timer function\n");
return -1;
}
if(rl_repl_cluster)
if (register_utimer("rl-utimer", rl_timer_repl, NULL,
rl_repl_timer_interval * 1000, TIMER_FLAG_DELAY_ON_DELAY) < 0) {
LM_ERR("failed to register utimer\n");
return -1;
}
/* if db_url is not used */
for( n=0 ; n < 8 * sizeof(unsigned int) ; n++) {
if (rl_hash_size==(1<<n))
break;
if (rl_hash_size<(1<<n)) {
LM_WARN("hash_size is not a power "
"of 2 as it should be -> rounding from %d to %d\n",
rl_hash_size, 1<<(n-1));
rl_hash_size = 1<<(n-1);
}
}
if (init_rl_table(rl_hash_size) < 0) {
LM_ERR("cannot allocate the table\n");
return -1;
}
if (rl_repl_init() < 0) {
LM_ERR("cannot init bin replication\n");
return -1;
}
return 0;
}
