int bartlby_extension_startup(void * shm_addr, void * dataLoaderHandle, char * configfile) {
_log(LH_MOD, B_LOG_INFO, "extlogger: %s", configfile);
/*
extlogger_type=
extlogger_host=
extlogger_user=
extlogger_password=
extlogger_db=
*/
cType = getConfigValue("extlogger_type", configfile);
cHost = getConfigValue("extlogger_host", configfile);
cUser = getConfigValue("extlogger_user", configfile);
cPassword = getConfigValue("extlogger_password", configfile);
cDB = getConfigValue("extlogger_db", configfile);
if(cType == NULL || cHost == NULL || cUser == NULL || cPassword == NULL || cDB == NULL) {
_log(LH_MOD, B_LOG_CRIT, "extlogger: configuration failed 'extlogger_type', 'extlogger_host', 'extlogger_user', 'extlogger_password', 'extlogger_db'");
}
gHdr=bartlby_SHM_GetHDR(shm_addr);
gDataLoaderHandle=dataLoaderHandle;
gCFG=configfile;
_log(LH_MOD, B_LOG_INFO, "Extlogger initiated");
return EXTENSION_OK;
}
void sched_write_back_all(char * cfgfile, void * shm_addr, void * SOHandle) {
int x;
struct service * services;
int (*doUpdate)(struct service *,char *);
//int (*doUpdateTrap)(struct trap *, char *);
char * dlmsg;
gshm_hdr=bartlby_SHM_GetHDR(shm_addr); //just to be sure ;)
services=bartlby_SHM_ServiceMap(shm_addr);
LOAD_SYMBOL(doUpdate,SOHandle, "doUpdate");
for(x=0; x<gshm_hdr->svccount; x++) {
//Do not writeback services that came in via an orch-node
if(bartlby_orchestra_belongs_to_orch(&services[x], cfgfile) < 0) {
continue;
}
if(doUpdate(&services[x], cfgfile) != 1) {
_log(LH_SCHED, B_LOG_CRIT, "doUpdate() failed in sched_writeback_all() '%s` for service id: %d", strerror(errno), services[x].service_id);
}
}
_log(LH_SCHED, B_LOG_DEBUG,"wrote back %d services!", x);
/*
for(x=0; x<gshm_hdr->trapcount; x++) {
//Do not writeback services that came in via an orch-node
if(bartlby_orchestra_trap_belongs_to_orch(&traps[x], cfgfile) < 0) {
continue;
}
if(doUpdateTrap(&traps[x], cfgfile) != 1) {
_log(LH_SCHED, B_LOG_CRIT, "doUpdateTrap() failed in sched_writeback_all() '%s` for trap id: %d", strerror(errno), traps[x].trap_id);
}
}
_log(LH_SCHED, B_LOG_DEBUG,"wrote back %d traps!", x);
*/
/*
for(x=0; x<gshm_hdr->srvcount; x++) {
doUpdateServer(&servers[x], cfgfile);
}
_log("wrote back %d servers!", x);
*/
}
int bartlby_extension_startup(void * shm_addr, void * dataLoaderHandle, char * configfile) {
_log(LH_MOD, B_LOG_INFO, "distributive: %s", configfile);
distr_command = getConfigValue("distributive_command", configfile);
if(distr_command == NULL) {
_log(LH_MOD, B_LOG_CRIT, "distributive: configuration failed 'distributive_command'");
}
gHdr=bartlby_SHM_GetHDR(shm_addr);
gDataLoaderHandle=dataLoaderHandle;
gCFG=configfile;
_log(LH_MOD, B_LOG_INFO, "distributive initiated");
return EXTENSION_OK;
}
int bartlby_extension_startup(void * shm_addr, void * dataLoaderHandle, char * configfile) {
int x;
struct service * svcmap;
unsigned char new_hash_bin[SHA_DIGEST_LENGTH];
char new_hash_str[40];
_log("statehistory: %s", configfile);
cfg_statehistory_dir = getConfigValue("statehistory_logdir", configfile);
gHdr=bartlby_SHM_GetHDR(shm_addr);
gDataLoaderHandle=dataLoaderHandle;
gCFG=configfile;
svcmap=bartlby_SHM_ServiceMap(shm_addr);
if(cfg_statehistory_dir == NULL) {
_log("statehistory you have to set 'statehistory_logdir'");
}
_log("statehistory: servicescount->%ld", gHdr->svccount);
state_hash_map = malloc(sizeof(struct service_hash_map)*(gHdr->svccount+1));
//initial hashing
for(x=0; x<gHdr->svccount; x++) {
state_hash_map[x].service_id=svcmap[x].service_id;
SHA1(svcmap[x].new_server_text, strlen(svcmap[x].new_server_text), new_hash_bin);
convertSHA1BinaryToCharStr(new_hash_bin, new_hash_str);
sprintf(state_hash_map[x].sha1_hash, "%s", new_hash_str);
state_hash_map[x].last_write = time(NULL);
}
return EXTENSION_OK;
}
/// TEST FUNCTIONS
void test_trap_lib(void *data) {
(void)data;
void * SOHandle;
void * bartlby_address;
struct trap modified_object;
struct trap returned_object;
struct trap * srvmap;
srvmap=NULL;
long (*AddTrap)(struct trap *, char *);
int (*UpdateTrap)(struct trap *, char *);
int (*DeleteTrap)(long trap_id, char *);
int (*GetTrapById)(long, struct trap *, char * );
long (*TrapChangeId)(long, long, char*);
int (*GetTrapMap)(struct trap*, char*, int);
int rtc=-1;
long object_id=-1;
long lrtc=-1;
long NN=-1;
int x;
struct shm_header * shm_hdr;
bartlby_address=NULL;
SOHandle=NULL;
SKIP_IF_NOT_RUNNING(CONFIG);
SOHandle = bartlby_get_sohandle(CONFIG);
bartlby_address=bartlby_get_shm(CONFIG);
tt_ptr_op(bartlby_address, !=, NULL);
tt_ptr_op(SOHandle, !=, NULL);
shm_hdr = bartlby_SHM_GetHDR(bartlby_address);
LOAD_SYMBOL_TEST(AddTrap,SOHandle, "AddTrap");
LOAD_SYMBOL_TEST(DeleteTrap,SOHandle, "DeleteTrap");
LOAD_SYMBOL_TEST(UpdateTrap,SOHandle, "UpdateTrap");
LOAD_SYMBOL_TEST(GetTrapById,SOHandle, "GetTrapById");
LOAD_SYMBOL_TEST(TrapChangeId,SOHandle, "TrapChangeId");
LOAD_SYMBOL_TEST(GetTrapMap,SOHandle, "GetTrapMap");
/******* ADD TRAP ****/
lrtc=AddTrap(&dummy_trap, CONFIG);
object_id=lrtc;
tt_int_op(lrtc, >, 0);
TT_DECLARE("INFO",("... Added Trap id: %ld", object_id));
/******* ADD TRAP ****/
/******* MODIFY TRAP ****/
dummy_trap.trap_id=object_id;
memcpy(&modified_object,&dummy_trap, sizeof(struct trap));
memcpy(&returned_object,&dummy_trap, sizeof(struct trap));
snprintf(modified_object.trap_catcher,2048, "modified-unit-test");
rtc=UpdateTrap(&modified_object, CONFIG);
tt_int_op(rtc, ==, 1);
TT_DECLARE("INFO",("... Modified Trap, changed name"));
/******* MODIFY TRAP ****/
/******* GETTRAPBYID ****/
rtc=GetTrapById(object_id, &returned_object, CONFIG);
tt_int_op(rtc, ==, 0);
tt_str_op(returned_object.trap_catcher, ==, modified_object.trap_catcher);
TT_DECLARE("INFO",("... get trap by id %ld", object_id));
/******* GETTRAPBYID ****/
/******* TRAPCHANGEID ****/
NN=lrtc+999;
object_id=TrapChangeId(lrtc, NN, CONFIG);
tt_int_op(object_id, ==, NN);
TT_DECLARE("INFO",("... Changed trap id from %ld to %ld ",lrtc, object_id));
/******* TRAPCHANGEID ****/
/*** TRAPMAP **/
srvmap = malloc(sizeof(struct trap)*(shm_hdr->trapcount+2));
rtc=GetTrapMap(srvmap, CONFIG, TEST_ORCH_ID);
tt_int_op(rtc, >, 0);
lrtc=-1;
for(x=0; x<rtc; x++) {
if(srvmap[x].trap_id==object_id) {
lrtc = 1;
}
}
tt_int_op(lrtc, ==, 1);
TT_DECLARE("INFO",("... Created TrapMap and found %ld ", object_id));
/*** TRAPMAP **/
/*** DELETETRAP **/
rtc=DeleteTrap(object_id, CONFIG);
tt_int_op(rtc, ==, 1);
TT_DECLARE("INFO",("... Delete Trap %ld ", object_id));
/*** DELETETRAP **/
end:
if(srvmap != NULL) free(srvmap);
if(SOHandle != NULL) dlclose(SOHandle);
if(bartlby_address != NULL) shmdt(bartlby_address);
;
}
void test_trap_running(void *data) {
(void)data;
void * SOHandle;
void * bartlby_address;
struct shm_header * shm_hdr;
struct trap * map;
int x;
int res;
int (*AddTrap)(struct trap *, char *);
int (*DeleteTrap)(long trap_id, char *);
int rtc=-1;
long lrtc=-1;
long object_id=-1;
bartlby_address=NULL;
SOHandle=NULL;
SKIP_IF_NOT_RUNNING(CONFIG);
SOHandle = bartlby_get_sohandle(CONFIG);
bartlby_address=bartlby_get_shm(CONFIG);
tt_ptr_op(bartlby_address, !=, NULL);
tt_ptr_op(SOHandle, !=, NULL);
/// ADD trap
LOAD_SYMBOL_TEST(AddTrap,SOHandle, "AddTrap");
LOAD_SYMBOL_TEST(DeleteTrap,SOHandle, "DeleteTrap");
lrtc=AddTrap(&dummy_trap, CONFIG);
object_id=lrtc;
tt_int_op(lrtc, >, 0);
TT_DECLARE("INFO",("... Added Trap id: %ld", object_id));
dummy_trap.trap_id=object_id;
//Reload - and detach/reattach to shm
shm_hdr=bartlby_SHM_GetHDR(bartlby_address);
shm_hdr->do_reload=1;
shmdt(bartlby_address);
sleep(2);
bartlby_address=bartlby_get_shm(CONFIG);
shm_hdr=bartlby_SHM_GetHDR(bartlby_address);
TT_DECLARE("INFO", ("Reloaded SHM"));
tt_int_op(shm_hdr->do_reload, ==, 0);
map = bartlby_SHM_TrapMap(bartlby_address);
res = -1;
for(x=0; x<shm_hdr->trapcount; x++) {
if(map[x].trap_id == object_id) {
res = 1;
break;
}
}
rtc=DeleteTrap(object_id, CONFIG);
tt_int_op(rtc, ==, 1);
TT_DECLARE("INFO",("... Delete Trap ", object_id));
tt_int_op(res, ==, 1);
TT_DECLARE("INFO",("... SHM Trap found ", object_id));
end:
if(SOHandle != NULL) dlclose(SOHandle);
if(bartlby_address != NULL) shmdt(bartlby_address);
;
}
int schedule_loop(char * cfgfile, void * shm_addr, void * SOHandle) {
int x;
int cfg_max_parallel=0;
int round_start, round_visitors;
char * cfg_sched_pause;
char * cfg_g_micros_before_after_check;
char * cfg_sched_mode;
char * cfg_sched_worker_count;
int sched_pause;
struct timeval stat_round_start, stat_round_end, run_c_start, run_c_end;
char * cfg_mps;
struct service * services;
struct service_sort * ssort;
int cfg_max_load;
double current_load[3];
char * cfg_load_max;
char * cfg_notification_aggregation;
int notification_aggregate_interval;
int ct, expt;
int worker_slot=0;
sched_pid=getpid();
gshm_addr=shm_addr;
gSOHandle=SOHandle;
gConfig=cfgfile;
gshm_hdr=bartlby_SHM_GetHDR(shm_addr);
ssort = malloc(sizeof(struct service_sort)*gshm_hdr->svccount);
_log(LH_SCHED, B_LOG_INFO,"Scheduler working on %ld Services", gshm_hdr->svccount);
cfg_notification_aggregation=getConfigValue("notification_aggregation_interval", cfgfile);
if(cfg_notification_aggregation == NULL) {
notification_aggregate_interval=0;
} else {
notification_aggregate_interval=atoi(cfg_notification_aggregation);
free(cfg_notification_aggregation);
}
cfg_mps=getConfigValue("max_concurent_checks", cfgfile);
if(cfg_mps == NULL) {
_log(LH_SCHED, B_LOG_WARN,"<Warn>Defaulting max_concurent_checks to '20'");
cfg_max_parallel=20;
} else {
cfg_max_parallel=atoi(cfg_mps);
free(cfg_mps);
}
cfg_load_max=getConfigValue("max_load", cfgfile);
if(cfg_load_max == NULL) {
cfg_max_load=0;
} else {
cfg_max_load=atoi(cfg_load_max);
free(cfg_load_max);
}
signal(SIGINT, catch_signal);
signal(SIGUSR1, catch_signal);
signal(SIGUSR2, catch_signal);
signal(SIGTERM, catch_signal);
signal(SIGKILL, catch_signal);
services=bartlby_SHM_ServiceMap(shm_addr);
gservices=services;
gshm_hdr->do_reload=0;
cfg_sched_pause = getConfigValue("sched_round_pause", cfgfile);
if(cfg_sched_pause == NULL) {
sched_pause=100;
_log(LH_SCHED, B_LOG_INFO,"info: sched_pause defaulted to: %d milli-seconds (set sched_round_pause to modify)", sched_pause);
} else {
sched_pause=atoi(cfg_sched_pause);
free(cfg_sched_pause);
if(sched_pause <= 0) {
sched_pause=1;
_log(LH_SCHED, B_LOG_WARN,"info: sched_pause really low should'nt be less than 1 milliseconds defaulting to it: %d", sched_pause);
}
}
cfg_g_micros_before_after_check = getConfigValue("sched_micros_before_after_check", cfgfile);
if(cfg_g_micros_before_after_check == NULL) {
_log(LH_SCHED, B_LOG_INFO,"HINT: to tune performance see 'sched_micros_before_after_check' defaults to 700");
} else {
g_micros_before_after_check=atoi(cfg_g_micros_before_after_check);
_log(LH_SCHED, B_LOG_DEBUG,"micros_before_after=%d", g_micros_before_after_check);
free(cfg_g_micros_before_after_check);
}
long local_svc_count=0;
long local_idx=0;
//Make a second sortable array
for(x=0; x<gshm_hdr->svccount; x++) {
if(bartlby_orchestra_belongs_to_orch(&services[x], cfgfile) < 0) {
continue; //Kick from sched circle if service never would be checked
}
ssort[local_idx].svc=&services[x];
local_idx++;
local_svc_count++;
}
_log(LH_SCHED, B_LOG_DEBUG,"Scheduler working on %ld Services after kick: %ld", gshm_hdr->svccount, local_idx);
cfg_sched_mode = getConfigValue("sched_mode", cfgfile);
if(cfg_sched_mode == NULL) {
sched_mode=SCHED_MODE_FORK;
_log(LH_SCHED, B_LOG_DEBUG,"Defaulting sched mode to SCHED_MODE_FORK");
} else {
sched_mode=atoi(cfg_sched_mode);
_log(LH_SCHED, B_LOG_DEBUG,"Set sched_mode to:%d", sched_mode);
free(cfg_sched_mode);
sched_worker_count=0;
if(sched_mode == SCHED_MODE_WORKER) {
cfg_sched_worker_count = getConfigValue("sched_worker_count", cfgfile);
if(cfg_sched_worker_count == NULL) {
sched_worker_count=5;
_log(LH_SCHED, B_LOG_INFO,"Defaulting sched_worker_count to 5");
} else {
sched_worker_count=atoi(cfg_sched_worker_count);
_log(LH_SCHED, B_LOG_INFO,"Using %d workers", sched_worker_count);
free(cfg_sched_worker_count);
}
_log(LH_SCHED, B_LOG_DEBUG,"USING WORKER MODE");
}
if(sched_mode == SCHED_MODE_FORK) {
_log(LH_SCHED, B_LOG_DEBUG,"using FORK MODE");
}
if(sched_mode == SCHED_MODE_PROFILE) {
_log(LH_SCHED, B_LOG_DEBUG, "using profile mode");
}
}
// Check if we should use worker or per check-fork
sched_init_workers();
while(1) {
if(gshm_hdr->do_reload == 1 || gshm_hdr->do_reload == 2) {
_log(LH_SCHED, B_LOG_INFO,"queuing Reload");
sched_wait_open(1, 0);
signal(SIGCHLD, SIG_IGN);
free(ssort);
return -2;
}
if(do_shutdown == 1) {
_log(LH_SCHED, B_LOG_INFO,"Exit recieved");
sched_wait_open(1,0);
signal(SIGCHLD, SIG_IGN);
free(ssort);
break;
}
if(gshm_hdr->sirene_mode == 1) {
//We are in Sirene Mode dont check anything just notifie workers that something b ad is going on
bartlby_check_sirene(cfgfile,shm_addr);
continue;
}
round_start=time(NULL);
gettimeofday(&stat_round_start,NULL);
round_visitors=0;
//Sort ascending on delay time so most delayed service will be checked rapidly ;)
if(local_svc_count>0) {
qsort(ssort, local_svc_count-1, sizeof(struct service_sort), cmpservice);
}
shortest_intervall=10;
getloadavg(current_load, 3);
sched_definitiv_running();
for(x=0; x<local_svc_count; x++) {
if(do_shutdown == 1 || gshm_hdr->do_reload == 1 || gshm_hdr->do_reload == 2) {
break;
}
if(gshm_hdr->current_running < cfg_max_parallel || (int)current_load[0] < cfg_max_load) {
if(sched_check_waiting(shm_addr, ssort[x].svc, cfgfile, SOHandle, sched_pause) == 1) {
if(sched_mode == SCHED_MODE_WORKER) {
worker_slot=sched_find_open_worker();
if(worker_slot < 0) {
sched_check_for_dead_workers();
continue;
}
}
gettimeofday(&run_c_start,NULL);
round_visitors++;
ct = time(NULL);
expt = (ssort[x].svc->last_check+ssort[x].svc->check_interval);
if(ct > expt && ssort[x].svc->service_type != SVC_TYPE_PASSIVE) {
// service check has delayed
ssort[x].svc->delay_time.sum += ct - expt;
}
ssort[x].svc->delay_time.counter++;
//WTF?
if(ssort[x].svc->service_type != SVC_TYPE_PASSIVE) {
ssort[x].svc->last_check=time(NULL);
}
bartlby_callback(EXTENSION_CALLBACK_CHECK_WILL_RUN, ssort[x].svc);
sched_reschedule(ssort[x].svc);
sched_run_check(ssort[x].svc, cfgfile, shm_addr, SOHandle, worker_slot);
usleep(g_micros_before_after_check);
gettimeofday(&run_c_end,NULL);
}
} else {
sched_wait_for_childs();
sched_wait_open(60,cfg_max_parallel-1);
}
}
if(time(NULL)-round_start > sched_pause*3 && sched_pause > 0) {
_log(LH_SCHED, B_LOG_INFO,"Done %d Services in %ld Seconds", round_visitors, time(NULL)-round_start);
}
//Log Round End
gettimeofday(&stat_round_end,NULL);
bartlby_core_perf_track(gshm_hdr, &services[x], PERF_TYPE_ROUND_TIME, bartlby_milli_timediff(stat_round_end,stat_round_start));
sched_wait_for_childs();
usleep(sched_pause);
if(shortest_intervall > 1) {
usleep((shortest_intervall-1)*1000);
}
if(notification_aggregate_interval > 0 && time(NULL)-gshm_hdr->notification_log_aggregate_last_run >= notification_aggregate_interval) {
_log(LH_SCHED, B_LOG_DEBUG,"AGGREGATION RUN");
bartlby_notification_log_aggregate(gshm_hdr, cfgfile);
}
bartlby_orchestra_check_timeouts(services, gshm_hdr, cfgfile, shm_addr, SOHandle);
}
return 1;
}
