/* logs service states */
int log_service_states(int type, time_t *timestamp){
char *temp_buffer=NULL;
char *processed_buffer=NULL;
service *temp_service=NULL;
host *temp_host=NULL;;
/* bail if we shouldn't be logging initial states */
if(type==INITIAL_STATES && log_initial_states==FALSE)
return OK;
for(temp_service=service_list;temp_service!=NULL;temp_service=temp_service->next){
/* find the associated host */
if((temp_host=temp_service->host_ptr)==NULL)
continue;
/* grab service macros */
clear_volatile_macros();
grab_host_macros(temp_host);
grab_service_macros(temp_service);
asprintf(&temp_buffer,"%s SERVICE STATE: %s;%s;$SERVICESTATE$;$SERVICESTATETYPE$;$SERVICEATTEMPT$;%s\n",(type==INITIAL_STATES)?"INITIAL":"CURRENT",temp_service->host_name,temp_service->description,temp_service->plugin_output);
process_macros(temp_buffer,&processed_buffer,0);
write_to_all_logs_with_timestamp(processed_buffer,NSLOG_INFO_MESSAGE,timestamp);
my_free(temp_buffer);
my_free(processed_buffer);
}
return OK;
}
/* write a host problem/recovery to the log file */
int log_host_event(host *hst){
char *temp_buffer=NULL;
char *processed_buffer=NULL;
unsigned long log_options=0L;
/* grab the host macros */
clear_volatile_macros();
grab_host_macros(hst);
/* get the log options */
if(hst->current_state==HOST_DOWN)
log_options=NSLOG_HOST_DOWN;
else if(hst->current_state==HOST_UNREACHABLE)
log_options=NSLOG_HOST_UNREACHABLE;
else
log_options=NSLOG_HOST_UP;
asprintf(&temp_buffer,"HOST ALERT: %s;$HOSTSTATE$;$HOSTSTATETYPE$;$HOSTATTEMPT$;%s\n",hst->name,(hst->plugin_output==NULL)?"":hst->plugin_output);
process_macros(temp_buffer,&processed_buffer,0);
write_to_all_logs(processed_buffer,log_options);
my_free(temp_buffer);
my_free(processed_buffer);
return OK;
}
/* logs host states */
int log_host_states(int type, time_t *timestamp){
char *temp_buffer=NULL;
char *processed_buffer=NULL;
host *temp_host=NULL;;
/* bail if we shouldn't be logging initial states */
if(type==INITIAL_STATES && log_initial_states==FALSE)
return OK;
for(temp_host=host_list;temp_host!=NULL;temp_host=temp_host->next){
/* grab the host macros */
clear_volatile_macros();
grab_host_macros(temp_host);
asprintf(&temp_buffer,"%s HOST STATE: %s;$HOSTSTATE$;$HOSTSTATETYPE$;$HOSTATTEMPT$;%s\n",(type==INITIAL_STATES)?"INITIAL":"CURRENT",temp_host->name,(temp_host->plugin_output==NULL)?"":temp_host->plugin_output);
process_macros(temp_buffer,&processed_buffer,0);
write_to_all_logs_with_timestamp(processed_buffer,NSLOG_INFO_MESSAGE,timestamp);
my_free(temp_buffer);
my_free(processed_buffer);
}
return OK;
}
/* updates host performance data */
int xpddefault_update_host_performance_data(host *hst)
{
nagios_macros mac;
/*
* bail early if we've got nothing to do so we don't spend a lot
* of time calculating macros that never get used
*/
if (!hst || !hst->perf_data || !*hst->perf_data) {
return OK;
}
if ((!xpddefault_host_perfdata_fp || !xpddefault_host_perfdata_file_template) && !xpddefault_host_perfdata_command)
{
return OK;
}
/* set up macros and get to work */
memset(&mac, 0, sizeof(mac));
grab_host_macros(&mac, hst);
/* run the performance data command */
xpddefault_run_host_performance_data_command(&mac, hst);
/* no more commands to run, so we won't need this any more */
clear_argv_macros(&mac);
/* update the performance data file */
xpddefault_update_host_performance_data_file(&mac, hst);
/* free() all */
clear_volatile_macros(&mac);
return OK;
}
/* updates service performance data */
int xpddefault_update_service_performance_data(service *svc)
{
nagios_macros mac;
host *hst;
/*
* bail early if we've got nothing to do so we don't spend a lot
* of time calculating macros that never get used
*/
if (!svc || !svc->perf_data || !*svc->perf_data) {
return OK;
}
if ((!xpddefault_service_perfdata_fp || !xpddefault_service_perfdata_file_template) && !xpddefault_service_perfdata_command)
{
return OK;
}
/*
* we know we've got some work to do, so grab the necessary
* macros and get busy
*/
memset(&mac, 0, sizeof(mac));
hst = find_host(svc->host_name);
grab_host_macros(&mac, hst);
grab_service_macros(&mac, svc);
/* run the performance data command */
xpddefault_run_service_performance_data_command(&mac, svc);
/* get rid of used memory we won't need anymore */
clear_argv_macros(&mac);
/* update the performance data file */
xpddefault_update_service_performance_data_file(&mac, svc);
/* now free() it all */
clear_volatile_macros(&mac);
return OK;
}
/* write a service problem/recovery to the nagios log file */
int log_service_event(service *svc){
char *temp_buffer=NULL;
char *processed_buffer=NULL;
unsigned long log_options=0L;
host *temp_host=NULL;
/* don't log soft errors if the user doesn't want to */
if(svc->state_type==SOFT_STATE && !log_service_retries)
return OK;
/* get the log options */
if(svc->current_state==STATE_UNKNOWN)
log_options=NSLOG_SERVICE_UNKNOWN;
else if(svc->current_state==STATE_WARNING)
log_options=NSLOG_SERVICE_WARNING;
else if(svc->current_state==STATE_CRITICAL)
log_options=NSLOG_SERVICE_CRITICAL;
else
log_options=NSLOG_SERVICE_OK;
/* find the associated host */
if((temp_host=svc->host_ptr)==NULL)
return ERROR;
/* grab service macros */
clear_volatile_macros();
grab_host_macros(temp_host);
grab_service_macros(svc);
asprintf(&temp_buffer,"SERVICE ALERT: %s;%s;$SERVICESTATE$;$SERVICESTATETYPE$;$SERVICEATTEMPT$;%s\n",svc->host_name,svc->description,(svc->plugin_output==NULL)?"":svc->plugin_output);
process_macros(temp_buffer,&processed_buffer,0);
write_to_all_logs(processed_buffer,log_options);
my_free(temp_buffer);
my_free(processed_buffer);
return OK;
}
/* handle service check events */
static int handle_svc_check( int event_type, void *data ) {
host * hst = NULL;
service * svc = NULL;
char *raw_command=NULL;
char *processed_command=NULL;
nebstruct_service_check_data * svcdata;
int prio = GM_JOB_PRIO_LOW;
check_result * chk_result;
struct timeval core_time;
struct tm next_check;
char buffer1[GM_BUFFERSIZE];
gettimeofday(&core_time,NULL);
gm_log( GM_LOG_TRACE, "handle_svc_check(%i, data)\n", event_type );
svcdata = ( nebstruct_service_check_data * )data;
if ( event_type != NEBCALLBACK_SERVICE_CHECK_DATA )
return NEB_OK;
/* ignore non-initiate service checks */
if ( svcdata->type != NEBTYPE_SERVICECHECK_ASYNC_PRECHECK )
return NEB_OK;
/* get objects and set target function */
if((svc=svcdata->object_ptr)==NULL) {
gm_log( GM_LOG_ERROR, "Service handler received NULL service object pointer.\n" );
return NEBERROR_CALLBACKCANCEL;
}
/* find the host associated with this service */
if((hst=svc->host_ptr)==NULL) {
gm_log( GM_LOG_ERROR, "Service handler received NULL host object pointer.\n" );
return NEBERROR_CALLBACKCANCEL;
}
set_target_queue( hst, svc );
/* local check? */
if(!strcmp( target_queue, "" )) {
gm_log( GM_LOG_DEBUG, "passing by local servicecheck: %s - %s\n", svcdata->host_name, svcdata->service_description);
return NEB_OK;
}
gm_log( GM_LOG_DEBUG, "received job for queue %s: %s - %s\n", target_queue, svcdata->host_name, svcdata->service_description );
temp_buffer[0]='\x0';
/* as we have to intercept service checks so early
* (we cannot cancel checks otherwise)
* we have to do some service check logic here
* taken from checks.c:
*/
/* clear check options - we don't want old check options retained */
svc->check_options=CHECK_OPTION_NONE;
/* unset the freshening flag, otherwise only the first freshness check would be run */
svc->is_being_freshened=FALSE;
/* grab the host and service macro variables */
clear_volatile_macros();
grab_host_macros(hst);
grab_service_macros(svc);
/* get the raw command line */
get_raw_command_line(svc->check_command_ptr,svc->check_command,&raw_command,0);
if(raw_command==NULL){
gm_log( GM_LOG_ERROR, "Raw check command for service '%s' on host '%s' was NULL - aborting.\n", svc->description, svc->host_name );
return NEBERROR_CALLBACKCANCEL;
}
/* process any macros contained in the argument */
process_macros(raw_command, &processed_command, 0);
if(processed_command==NULL) {
gm_log( GM_LOG_ERROR, "Processed check command for service '%s' on host '%s' was NULL - aborting.\n", svc->description, svc->host_name);
my_free(raw_command);
return NEBERROR_CALLBACKCANCEL;
}
/* log latency */
if(mod_gm_opt->debug_level >= GM_LOG_DEBUG) {
localtime_r(&svc->next_check, &next_check);
strftime(buffer1, sizeof(buffer1), "%Y-%m-%d %H:%M:%S", &next_check );
gm_log( GM_LOG_DEBUG, "service: '%s' - '%s', next_check is at %s, latency so far: %i\n", svcdata->host_name, svcdata->service_description, buffer1, ((int)core_time.tv_sec - (int)svc->next_check));
}
/* increment number of service checks that are currently running... */
currently_running_service_checks++;
/* set the execution flag */
svc->is_executing=TRUE;
gm_log( GM_LOG_TRACE, "cmd_line: %s\n", processed_command );
snprintf( temp_buffer,GM_BUFFERSIZE-1,"type=service\nresult_queue=%s\nhost_name=%s\nservice_description=%s\nstart_time=%i.0\nnext_check=%i.0\ncore_time=%i.%i\ntimeout=%d\ncommand_line=%s\n\n\n",
mod_gm_opt->result_queue,
svcdata->host_name,
svcdata->service_description,
(int)svc->next_check,
(int)svc->next_check,
(int)core_time.tv_sec,
(int)core_time.tv_usec,
service_check_timeout,
processed_command
);
uniq[0]='\x0';
snprintf( uniq,GM_BUFFERSIZE-1,"%s-%s", svcdata->host_name, svcdata->service_description);
/* execute forced checks with high prio as they are propably user requested */
//if(check_result_info.check_options & CHECK_OPTION_FORCE_EXECUTION)
// prio = GM_JOB_PRIO_HIGH;
if(add_job_to_queue( &client,
mod_gm_opt->server_list,
target_queue,
(mod_gm_opt->use_uniq_jobs == GM_ENABLED ? uniq : NULL),
temp_buffer,
prio,
GM_DEFAULT_JOB_RETRIES,
mod_gm_opt->transportmode,
TRUE
) == GM_OK) {
gm_log( GM_LOG_TRACE, "handle_svc_check() finished successfully\n" );
}
else {
my_free(raw_command);
my_free(processed_command);
/* unset the execution flag */
svc->is_executing=FALSE;
/* decrement number of host checks that are currently running */
currently_running_service_checks--;
gm_log( GM_LOG_TRACE, "handle_svc_check() finished unsuccessfully\n" );
return NEBERROR_CALLBACKCANCEL;
}
/* clean up */
my_free(raw_command);
my_free(processed_command);
/* orphaned check - submit fake result to mark service as orphaned */
if(mod_gm_opt->orphan_service_checks == GM_ENABLED && svc->check_options & CHECK_OPTION_ORPHAN_CHECK) {
gm_log( GM_LOG_DEBUG, "service check for %s - %s orphaned\n", svc->host_name, svc->description );
if ( ( chk_result = ( check_result * )malloc( sizeof *chk_result ) ) == 0 )
return NEBERROR_CALLBACKCANCEL;
snprintf( temp_buffer,GM_BUFFERSIZE-1,"(service check orphaned, is the mod-gearman worker on queue '%s' running?)\n", target_queue);
init_check_result(chk_result);
chk_result->host_name = strdup( svc->host_name );
chk_result->service_description = strdup( svc->description );
chk_result->scheduled_check = TRUE;
chk_result->reschedule_check = TRUE;
chk_result->output_file = 0;
chk_result->output_file_fp = NULL;
chk_result->output = strdup(temp_buffer);
chk_result->return_code = mod_gm_opt->orphan_return;
chk_result->check_options = CHECK_OPTION_NONE;
chk_result->object_check_type = SERVICE_CHECK;
chk_result->check_type = SERVICE_CHECK_ACTIVE;
chk_result->start_time.tv_sec = (unsigned long)time(NULL);
chk_result->finish_time.tv_sec = (unsigned long)time(NULL);
chk_result->latency = 0;
mod_gm_add_result_to_list( chk_result );
chk_result = NULL;
}
/* tell naemon to not execute */
gm_log( GM_LOG_TRACE, "handle_svc_check() finished successfully -> %d\n", NEBERROR_CALLBACKOVERRIDE );
return NEBERROR_CALLBACKOVERRIDE;
}
/* handle host check events */
static int handle_host_check( int event_type, void *data ) {
nebstruct_host_check_data * hostdata;
char *raw_command=NULL;
char *processed_command=NULL;
host * hst;
check_result * chk_result;
int check_options;
struct timeval core_time;
struct tm next_check;
char buffer1[GM_BUFFERSIZE];
gettimeofday(&core_time,NULL);
gm_log( GM_LOG_TRACE, "handle_host_check(%i)\n", event_type );
if ( mod_gm_opt->do_hostchecks != GM_ENABLED )
return NEB_OK;
hostdata = ( nebstruct_host_check_data * )data;
gm_log( GM_LOG_TRACE, "---------------\nhost Job -> %i, %i\n", event_type, hostdata->type );
if ( event_type != NEBCALLBACK_HOST_CHECK_DATA )
return NEB_OK;
/* ignore non-initiate host checks */
if ( hostdata->type != NEBTYPE_HOSTCHECK_ASYNC_PRECHECK
&& hostdata->type != NEBTYPE_HOSTCHECK_SYNC_PRECHECK)
return NEB_OK;
/* get objects and set target function */
if((hst=hostdata->object_ptr)==NULL) {
gm_log( GM_LOG_ERROR, "Host handler received NULL host object pointer.\n" );
return NEBERROR_CALLBACKCANCEL;
}
set_target_queue( hst, NULL );
/* local check? */
if(!strcmp( target_queue, "" )) {
gm_log( GM_LOG_DEBUG, "passing by local hostcheck: %s\n", hostdata->host_name );
return NEB_OK;
}
gm_log( GM_LOG_DEBUG, "received job for queue %s: %s\n", target_queue, hostdata->host_name );
/* as we have to intercept host checks so early
* (we cannot cancel checks otherwise)
* we have to do some host check logic here
* taken from checks.c:
*/
/* clear check options - we don't want old check options retained */
check_options = hst->check_options;
hst->check_options = CHECK_OPTION_NONE;
/* unset the freshening flag, otherwise only the first freshness check would be run */
hst->is_being_freshened=FALSE;
/* adjust host check attempt */
adjust_host_check_attempt(hst,TRUE);
temp_buffer[0]='\x0';
/* grab the host macro variables */
clear_volatile_macros();
grab_host_macros(hst);
/* get the raw command line */
get_raw_command_line(hst->check_command_ptr,hst->check_command,&raw_command,0);
if(raw_command==NULL){
gm_log( GM_LOG_ERROR, "Raw check command for host '%s' was NULL - aborting.\n",hst->name );
return NEBERROR_CALLBACKCANCEL;
}
/* process any macros contained in the argument */
process_macros(raw_command,&processed_command,0);
if(processed_command==NULL){
gm_log( GM_LOG_ERROR, "Processed check command for host '%s' was NULL - aborting.\n",hst->name);
return NEBERROR_CALLBACKCANCEL;
}
/* log latency */
if(mod_gm_opt->debug_level >= GM_LOG_DEBUG) {
localtime_r(&hst->next_check, &next_check);
strftime(buffer1, sizeof(buffer1), "%Y-%m-%d %H:%M:%S", &next_check );
gm_log( GM_LOG_DEBUG, "host: '%s', next_check is at %s, latency so far: %i\n", hst->name, buffer1, ((int)core_time.tv_sec - (int)hst->next_check));
}
/* increment number of host checks that are currently running */
currently_running_host_checks++;
/* set the execution flag */
hst->is_executing=TRUE;
gm_log( GM_LOG_TRACE, "cmd_line: %s\n", processed_command );
snprintf( temp_buffer,GM_BUFFERSIZE-1,"type=host\nresult_queue=%s\nhost_name=%s\nstart_time=%i.0\nnext_check=%i.0\ntimeout=%d\ncore_time=%i.%i\ncommand_line=%s\n\n\n",
mod_gm_opt->result_queue,
hst->name,
(int)hst->next_check,
(int)hst->next_check,
host_check_timeout,
(int)core_time.tv_sec,
(int)core_time.tv_usec,
processed_command
);
if(add_job_to_queue( &client,
mod_gm_opt->server_list,
target_queue,
(mod_gm_opt->use_uniq_jobs == GM_ENABLED ? hst->name : NULL),
temp_buffer,
GM_JOB_PRIO_NORMAL,
GM_DEFAULT_JOB_RETRIES,
mod_gm_opt->transportmode,
TRUE
) == GM_OK) {
}
else {
my_free(raw_command);
my_free(processed_command);
/* unset the execution flag */
hst->is_executing=FALSE;
/* decrement number of host checks that are currently running */
currently_running_host_checks--;
gm_log( GM_LOG_TRACE, "handle_host_check() finished unsuccessfully -> %d\n", NEBERROR_CALLBACKCANCEL );
return NEBERROR_CALLBACKCANCEL;
}
/* clean up */
my_free(raw_command);
my_free(processed_command);
/* orphaned check - submit fake result to mark host as orphaned */
if(mod_gm_opt->orphan_host_checks == GM_ENABLED && check_options & CHECK_OPTION_ORPHAN_CHECK) {
gm_log( GM_LOG_DEBUG, "host check for %s orphaned\n", hst->name );
if ( ( chk_result = ( check_result * )malloc( sizeof *chk_result ) ) == 0 )
return NEBERROR_CALLBACKCANCEL;
snprintf( temp_buffer,GM_BUFFERSIZE-1,"(host check orphaned, is the mod-gearman worker on queue '%s' running?)\n", target_queue);
init_check_result(chk_result);
chk_result->host_name = strdup( hst->name );
chk_result->scheduled_check = TRUE;
chk_result->reschedule_check = TRUE;
chk_result->output_file = 0;
chk_result->output_file_fp = NULL;
chk_result->output = strdup(temp_buffer);
chk_result->return_code = mod_gm_opt->orphan_return;
chk_result->check_options = CHECK_OPTION_NONE;
chk_result->object_check_type = HOST_CHECK;
chk_result->check_type = HOST_CHECK_ACTIVE;
chk_result->start_time.tv_sec = (unsigned long)time(NULL);
chk_result->finish_time.tv_sec = (unsigned long)time(NULL);
chk_result->latency = 0;
mod_gm_add_result_to_list( chk_result );
chk_result = NULL;
}
/* tell naemon to not execute */
gm_log( GM_LOG_TRACE, "handle_host_check() finished successfully -> %d\n", NEBERROR_CALLBACKOVERRIDE );
return NEBERROR_CALLBACKOVERRIDE;
}