/* checks for flexible (non-fixed) service downtime that should start now */ int check_pending_flex_service_downtime(service *svc) { scheduled_downtime *temp_downtime = NULL; time_t current_time = 0L; log_debug_info(DEBUGL_FUNCTIONS, 0, "check_pending_flex_service_downtime()\n"); if(svc == NULL) return ERROR; time(¤t_time); /* if service is currently ok, nothing to do */ if(svc->current_state == STATE_OK) return OK; /* check all downtime entries */ for(temp_downtime = scheduled_downtime_list; temp_downtime != NULL; temp_downtime = temp_downtime->next) { if(temp_downtime->type != SERVICE_DOWNTIME) continue; if(temp_downtime->fixed == TRUE) continue; if(temp_downtime->is_in_effect == TRUE) continue; /* triggered downtime entries should be ignored here */ if(temp_downtime->triggered_by != 0) continue; /* this entry matches our service! */ if(find_service(temp_downtime->host_name, temp_downtime->service_description) == svc) { /* if the time boundaries are okay, start this scheduled downtime */ if(temp_downtime->start_time <= current_time && current_time <= temp_downtime->end_time) { log_debug_info(DEBUGL_DOWNTIME, 0, "Flexible downtime (id=%lu) for service '%s' on host '%s' starting now...\n", temp_downtime->downtime_id, svc->description, svc->host_name); temp_downtime->flex_downtime_start = current_time; handle_scheduled_downtime_by_id(temp_downtime->downtime_id); } } } return OK; }
/* handles a timed event */ int handle_timed_event(timed_event *event) { host *temp_host = NULL; service *temp_service = NULL; void (*userfunc)(void *); struct timeval tv; const struct timeval *event_runtime; double latency; log_debug_info(DEBUGL_FUNCTIONS, 0, "handle_timed_event() start\n"); #ifdef USE_EVENT_BROKER /* send event data to broker */ broker_timed_event(NEBTYPE_TIMEDEVENT_EXECUTE, NEBFLAG_NONE, NEBATTR_NONE, event, NULL); #endif log_debug_info(DEBUGL_EVENTS, 0, "** Timed Event ** Type: EVENT_%s, Run Time: %s", EVENT_TYPE_STR(event->event_type), ctime(&event->run_time)); /* get event latency */ gettimeofday(&tv, NULL); event_runtime = squeue_event_runtime(event->sq_event); latency = (double)(tv_delta_f(event_runtime, &tv)); if (latency < 0.0) /* events may run up to 0.1 seconds early */ latency = 0.0; /* how should we handle the event? */ switch (event->event_type) { case EVENT_SERVICE_CHECK: temp_service = (service *)event->event_data; log_debug_info(DEBUGL_EVENTS, 0, "** Service Check Event ==> Host: '%s', Service: '%s', Options: %d, Latency: %f sec\n", temp_service->host_name, temp_service->description, event->event_options, latency); /* run the service check */ run_scheduled_service_check(temp_service, event->event_options, latency); break; case EVENT_HOST_CHECK: temp_host = (host *)event->event_data; log_debug_info(DEBUGL_EVENTS, 0, "** Host Check Event ==> Host: '%s', Options: %d, Latency: %f sec\n", temp_host->name, event->event_options, latency); /* run the host check */ run_scheduled_host_check(temp_host, event->event_options, latency); break; case EVENT_PROGRAM_SHUTDOWN: log_debug_info(DEBUGL_EVENTS, 0, "** Program Shutdown Event. Latency: %.3fs\n", latency); /* set the shutdown flag */ sigshutdown = TRUE; /* log the shutdown */ logit(NSLOG_PROCESS_INFO, TRUE, "PROGRAM_SHUTDOWN event encountered, shutting down...\n"); break; case EVENT_PROGRAM_RESTART: log_debug_info(DEBUGL_EVENTS, 0, "** Program Restart Event. Latency: %.3fs\n", latency); /* set the restart flag */ sigrestart = TRUE; /* log the restart */ logit(NSLOG_PROCESS_INFO, TRUE, "PROGRAM_RESTART event encountered, restarting...\n"); break; case EVENT_CHECK_REAPER: log_debug_info(DEBUGL_EVENTS, 0, "** Check Result Reaper. Latency: %.3fs\n", latency); /* reap host and service check results */ reap_check_results(); break; case EVENT_ORPHAN_CHECK: log_debug_info(DEBUGL_EVENTS, 0, "** Orphaned Host and Service Check Event. Latency: %.3fs\n", latency); /* check for orphaned hosts and services */ if (check_orphaned_hosts == TRUE) check_for_orphaned_hosts(); if (check_orphaned_services == TRUE) check_for_orphaned_services(); break; case EVENT_RETENTION_SAVE: log_debug_info(DEBUGL_EVENTS, 0, "** Retention Data Save Event. Latency: %.3fs\n", latency); /* save state retention data */ save_state_information(TRUE); break; case EVENT_STATUS_SAVE: log_debug_info(DEBUGL_EVENTS, 0, "** Status Data Save Event. Latency: %.3fs\n", latency); /* save all status data (program, host, and service) */ update_all_status_data(); break; case EVENT_SCHEDULED_DOWNTIME: log_debug_info(DEBUGL_EVENTS, 0, "** Scheduled Downtime Event. Latency: %.3fs\n", latency); /* process scheduled downtime info */ if (event->event_data) { handle_scheduled_downtime_by_id(*(unsigned long *)event->event_data); free(event->event_data); event->event_data = NULL; } break; case EVENT_SFRESHNESS_CHECK: log_debug_info(DEBUGL_EVENTS, 0, "** Service Result Freshness Check Event. Latency: %.3fs\n", latency); /* check service result freshness */ check_service_result_freshness(); break; case EVENT_HFRESHNESS_CHECK: log_debug_info(DEBUGL_EVENTS, 0, "** Host Result Freshness Check Event. Latency: %.3fs\n", latency); /* check host result freshness */ check_host_result_freshness(); break; case EVENT_EXPIRE_DOWNTIME: log_debug_info(DEBUGL_EVENTS, 0, "** Expire Downtime Event. Latency: %.3fs\n", latency); /* check for expired scheduled downtime entries */ check_for_expired_downtime(); break; case EVENT_EXPIRE_COMMENT: log_debug_info(DEBUGL_EVENTS, 0, "** Expire Comment Event. Latency: %.3fs\n", latency); /* check for expired comment */ check_for_expired_comment((unsigned long)event->event_data); break; case EVENT_CHECK_PROGRAM_UPDATE: /* this doesn't do anything anymore */ break; case EVENT_USER_FUNCTION: log_debug_info(DEBUGL_EVENTS, 0, "** User Function Event. Latency: %.3fs\n", latency); /* run a user-defined function */ if (event->event_data != NULL) { userfunc = event->event_data; (*userfunc)(event->event_args); } break; default: break; } log_debug_info(DEBUGL_FUNCTIONS, 0, "handle_timed_event() end\n"); return OK; }