/* * bronx_processors.c -- Manages different kinds of nagios data. * * Copyright (C) 2008 Groundwork Open Source * Written by Daniel Emmanuel Feinsmith * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor * Boston, MA 02110-1301, USA. * * Change Log: * DEF Created on September 17, 2007, 1:00 PM */ #include "bronx.h" #include "bronx_neb.h" #include "bronx_log.h" #include "bronx_route.h" #include "bronx_config.h" /* * Globals */ apr_pool_t *_processors_pool; apr_hash_t *_processors_host_last_state_table; apr_hash_t *_processors_hostservice_last_state_table; /* * Nagios Globals */ extern time_t program_start; extern host *host_list; extern hostgroup *hostgroup_list; extern service *service_list; extern servicegroup *servicegroup_list; /* * Functionality. */ apr_status_t processors_init() { apr_status_t rv; if ((rv = apr_pool_create(&_processors_pool, NULL)) == APR_SUCCESS) { _processors_host_last_state_table = apr_hash_make(_processors_pool); _processors_hostservice_last_state_table = apr_hash_make(_processors_pool); } else bronx_log("{processors_init} Failed to create memory pool for processors.", BRONX_LOGGING_NORMAL); return(rv); } void processors_uninit() { apr_pool_destroy(_processors_pool); } /* * NEB Processors. */ int processAcknowledgement(int cmd, void *data) { apr_hash_t *properties; apr_pool_t *pool; nebstruct_acknowledgement_data *ackData = data; int isHostAck; if (!threads_running() || !routes_initialized()) return(0); bronx_log("{processAcknowledgement}", BRONX_LOGGING_DEBUG); // // Make sure we can support the type // if(ackData->type != NEBTYPE_ACKNOWLEDGEMENT_ADD && ackData->type != NEBTYPE_ACKNOWLEDGEMENT_REMOVE) return(0); // // Is this a host or service ack? // isHostAck = (ackData->service_description == NULL); // // First, create and send the acknowledgement. // apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); apr_hash_set(properties, apr_pstrdup(pool, "ApplicationType"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "NAGIOS")); apr_hash_set(properties, apr_pstrdup(pool, "Host"), APR_HASH_KEY_STRING, apr_pstrdup(pool, ackData->host_name)); apr_hash_set(properties, apr_pstrdup(pool, "MonitorServerName"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "localhost")); if(ackData->service_description != NULL) apr_hash_set(properties, apr_pstrdup(pool, "ServiceDescription"), APR_HASH_KEY_STRING, apr_pstrdup(pool, ackData->service_description)); apr_hash_set(properties, apr_pstrdup(pool, "AcknowledgedBy"), APR_HASH_KEY_STRING, apr_pstrdup(pool, ackData->author_name)); // Substitute quotes and <'> with XML chars. apr_hash_set(properties, apr_pstrdup(pool, "AcknowledgeComment"), APR_HASH_KEY_STRING, apr_pstrdup(pool, strcleanup(pool, ackData->comment_data))); if(ackData->type == NEBTYPE_ACKNOWLEDGEMENT_ADD) apr_hash_set(properties, apr_pstrdup(pool, "TypeRule"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "ACKNOWLEDGE")); else if(ackData->type == NEBTYPE_ACKNOWLEDGEMENT_REMOVE) apr_hash_set(properties, apr_pstrdup(pool, "TypeRule"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "UNACKNOWLEDGE")); queue_push_message(MSG_TYPE_ACKNOWLEDGEMENT, pool, properties, "processAcknowledgement"); // // Next, send a status update after sending the Acknowledgement // message. // if (isHostAck) { host *hst; hst = find_host(ackData->host_name); if (hst != NULL) { apr_pool_t *pool; apr_hash_t *properties; /* * First, generate a Host Status * Message. */ apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); generate_host_properties(hst, pool, properties, -1); queue_push_message(MSG_TYPE_HOST_STATUS, pool, properties, "processAcknowledgement"); } } else { service *svc; svc = find_service(ackData->host_name, ackData->service_description); if (svc != NULL) { apr_pool_t *pool; apr_hash_t *properties; /* * First, generate a Service Status * Message. */ apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); generate_service_properties(svc, pool, properties); queue_push_message(MSG_TYPE_SERVICE_STATUS, pool, properties, "processAcknowledgement"); } } return(0); } int processContactNotification(int cmd, void *data) { apr_hash_t *properties; apr_pool_t *pool; nebstruct_contact_notification_data *notificationData = data; int isHostNotification; if (!threads_running() || !routes_initialized()) return(0); // // Make sure we can support the type // if(notificationData->type != NEBTYPE_CONTACTNOTIFICATION_END) return(0); bronx_logprintf(BRONX_LOGGING_DEBUG, "{processContactNotification} contact_name=%s, host_name=%s, output=%s", notificationData->contact_name, notificationData->host_name, notificationData->output); isHostNotification = (notificationData->service_description == NULL); // // Create our memory pool to hold the properties for our message // apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); apr_hash_set(properties, apr_pstrdup(pool, "Host"), APR_HASH_KEY_STRING, apr_pstrdup(pool, notificationData->host_name)); apr_hash_set(properties, apr_pstrdup(pool, "Device"), APR_HASH_KEY_STRING, apr_pstrdup(pool, notificationData->host_name)); apr_hash_set(properties, apr_pstrdup(pool, "LoggerName"), APR_HASH_KEY_STRING, apr_pstrdup(pool, notificationData->contact_name)); if(isHostNotification) switch(notificationData->state) { case HOST_UP: apr_hash_set(properties, apr_pstrdup(pool, "Severity"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "OK")); apr_hash_set(properties, apr_pstrdup(pool, "MonitorStatus"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "UP")); break; case HOST_DOWN: apr_hash_set(properties, apr_pstrdup(pool, "Severity"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "CRITICAL")); apr_hash_set(properties, apr_pstrdup(pool, "MonitorStatus"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "DOWN")); break; case HOST_UNREACHABLE: apr_hash_set(properties, apr_pstrdup(pool, "Severity"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "UNREACHABLE")); apr_hash_set(properties, apr_pstrdup(pool, "MonitorStatus"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "UNREACHABLE")); break; default: apr_hash_set(properties, apr_pstrdup(pool, "Severity"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "UNKNOWN")); apr_hash_set(properties, apr_pstrdup(pool, "MonitorStatus"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "UNKNOWN")); break; } else switch(notificationData->state) { case STATE_OK: apr_hash_set(properties, apr_pstrdup(pool, "Severity"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "OK")); apr_hash_set(properties, apr_pstrdup(pool, "MonitorStatus"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "OK")); break; case STATE_WARNING: apr_hash_set(properties, apr_pstrdup(pool, "Severity"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "WARNING")); apr_hash_set(properties, apr_pstrdup(pool, "MonitorStatus"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "WARNING")); break; case STATE_CRITICAL: apr_hash_set(properties, apr_pstrdup(pool, "Severity"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "CRITICAL")); apr_hash_set(properties, apr_pstrdup(pool, "MonitorStatus"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "CRITICAL")); break; default: apr_hash_set(properties, apr_pstrdup(pool, "Severity"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "UNKNOWN")); apr_hash_set(properties, apr_pstrdup(pool, "MonitorStatus"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "UNKNOWN")); break; } apr_hash_set(properties, apr_pstrdup(pool, "TextMessage"), APR_HASH_KEY_STRING, strcleanup(pool,notificationData->output)); apr_hash_set(properties, apr_pstrdup(pool, "ReportDate"), APR_HASH_KEY_STRING, datetostring(pool, time(NULL))); apr_hash_set(properties, apr_pstrdup(pool, "LastInsertDate"), APR_HASH_KEY_STRING, datetostring(pool, time(NULL))); apr_hash_set(properties, apr_pstrdup(pool, "SubComponent"), APR_HASH_KEY_STRING, apr_pstrdup(pool, notificationData->host_name)); apr_hash_set(properties, apr_pstrdup(pool, "MonitorServerName"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "localhost")); if(isHostNotification) apr_hash_set(properties, apr_pstrdup(pool, "ErrorType"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "HOST NOTIFICATION")); else apr_hash_set(properties, apr_pstrdup(pool, "ErrorType"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "SERVICE NOTIFICATION")); apr_hash_set(properties, apr_pstrdup(pool, "consolidation"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "NAGIOSEVENT")); queue_push_message(MSG_TYPE_NOTIFICATION, pool, properties, "processNotification"); return(0); } int processHostCheck(int cmd, void *data) { apr_hash_t *properties; apr_pool_t *pool; nebstruct_host_check_data *host_check_data = (nebstruct_host_check_data *) data; last_object_state *los; if (!threads_running() || !routes_initialized()) return(0); if(host_check_data->type != NEBTYPE_HOSTCHECK_PROCESSED) return(0); if (host_check_data->output == NULL || !strcmp(host_check_data->output, "")) return(0); bronx_logprintf(BRONX_LOGGING_DEBUG, "{processHostCheck} (Host: %s)", host_check_data->host_name); /* * Now send the HOST ALERT, * but only on HARD state. */ if(host_check_data->state_type == HARD_STATE || _configuration->soft_state_changes == 1) { int forward=0; /* * Now, check to see if there has been a state change. */ los = apr_hash_get(_processors_host_last_state_table, (void*)host_check_data->host_name, APR_HASH_KEY_STRING); if (los == NULL) { if ((los = (last_object_state *)apr_palloc(_processors_pool, sizeof(last_object_state)))) { los->last_state = host_check_data->state; los->last_state_type = host_check_data->state_type; apr_hash_set(_processors_host_last_state_table, apr_pstrdup(_processors_pool, host_check_data->host_name), APR_HASH_KEY_STRING, (void *)los); forward = 1; } } else { if (los->last_state != host_check_data->state) { los->last_state = host_check_data->state; los->last_state_type = host_check_data->state_type; forward = 1; } } if (!forward) return(0); apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); if (_configuration->consolidation) apr_hash_set(properties, apr_pstrdup(pool, "consolidation"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "NAGIOSEVENT")); apr_hash_set(properties, apr_pstrdup(pool, "MonitorServerName"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "localhost")); apr_hash_set(properties, apr_pstrdup(pool, "Host"), APR_HASH_KEY_STRING, apr_pstrdup(pool, host_check_data->host_name)); apr_hash_set(properties, apr_pstrdup(pool, "Device"), APR_HASH_KEY_STRING, apr_pstrdup(pool, host_check_data->host_name)); switch(host_check_data->state) { case HOST_UP: { apr_hash_set(properties, apr_pstrdup(pool, "Severity"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "OK")); apr_hash_set(properties, apr_pstrdup(pool, "MonitorStatus"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "UP")); break; } case HOST_DOWN: { apr_hash_set(properties, apr_pstrdup(pool, "Severity"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "CRITICAL")); apr_hash_set(properties, apr_pstrdup(pool, "MonitorStatus"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "DOWN")); break; } case HOST_UNREACHABLE: { apr_hash_set(properties, apr_pstrdup(pool, "Severity"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "UNREACHABLE")); apr_hash_set(properties, apr_pstrdup(pool, "MonitorStatus"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "UNREACHABLE")); break; } default: { apr_hash_set(properties, apr_pstrdup(pool, "Severity"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "UNKNOWN")); apr_hash_set(properties, apr_pstrdup(pool, "MonitorStatus"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "UNKNOWN")); break; } } apr_hash_set(properties, apr_pstrdup(pool, "TextMessage"), APR_HASH_KEY_STRING, strcleanup(pool, host_check_data->output)); apr_hash_set(properties, apr_pstrdup(pool, "ReportDate"), APR_HASH_KEY_STRING, datetostring(pool, time(NULL))); apr_hash_set(properties, apr_pstrdup(pool, "LastInsertDate"), APR_HASH_KEY_STRING, datetostring(pool, time(NULL))); apr_hash_set(properties, apr_pstrdup(pool, "SubComponent"), APR_HASH_KEY_STRING, apr_pstrdup(pool, host_check_data->host_name)); apr_hash_set(properties, apr_pstrdup(pool, "ErrorType"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "HOST ALERT")); bronx_logprintf(BRONX_LOGGING_DEBUG, "{processServiceCheck} Posting LogMessage for Host to queue, (host='%s') Adding message to queue.", host_check_data->host_name); queue_push_message(MSG_TYPE_NAGIOS_LOG, pool, properties, "processHostCheck"); } return(0); } int processServiceCheck(int cmd, void *data) { apr_hash_t *properties; apr_pool_t *pool; nebstruct_service_check_data *service_check_data; if (!threads_running() || !routes_initialized()) return(0); service_check_data = (nebstruct_service_check_data *) data; if(service_check_data->type != NEBTYPE_SERVICECHECK_PROCESSED) return(0); /* * Now send the SERVICE ALERT * But: only on HARD state */ bronx_logprintf(BRONX_LOGGING_DEBUG, "{processServiceCheck} (Host: %s, Service: %s)", service_check_data->host_name, service_check_data->service_description); if(service_check_data->state_type == HARD_STATE || _configuration->soft_state_changes == 1) { int forward=0; char key[MAX_HOSTNAME_LENGTH + MAX_SERVICEDESC_LENGTH]; last_object_state *los; /* * Now, check to see if there has been a state change. */ sprintf(key, "%s%s",service_check_data->host_name, service_check_data->service_description); los = apr_hash_get(_processors_hostservice_last_state_table, (void*)key, APR_HASH_KEY_STRING); if (los == NULL) { if ((los = (last_object_state *)apr_palloc(_processors_pool, sizeof(last_object_state)))) { los->last_state = service_check_data->state; los->last_state_type = service_check_data->state_type; apr_hash_set(_processors_hostservice_last_state_table, (void*)key, APR_HASH_KEY_STRING, (void *)los); forward = 1; } } else if (los->last_state != service_check_data->state) { los->last_state = service_check_data->state; los->last_state_type = service_check_data->state_type; forward = 1; } if (!forward) return(0); /* * Make pool for this property set. */ bronx_logprintf(BRONX_LOGGING_DEBUG, "{processServiceCheck} (host: %s) (service: %s)", service_check_data->host_name, service_check_data->service_description); apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); if (_configuration->consolidation) apr_hash_set(properties, apr_pstrdup(pool, "consolidation"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "NAGIOSEVENT")); apr_hash_set(properties, apr_pstrdup(pool, "MonitorServerName"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "localhost")); apr_hash_set(properties, apr_pstrdup(pool, "Host"), APR_HASH_KEY_STRING, apr_pstrdup(pool, service_check_data->host_name)); apr_hash_set(properties, apr_pstrdup(pool, "ServiceDescription"), APR_HASH_KEY_STRING, apr_pstrdup(pool, service_check_data->service_description)); apr_hash_set(properties, apr_pstrdup(pool, "Device"), APR_HASH_KEY_STRING, apr_pstrdup(pool, service_check_data->host_name)); switch(service_check_data->state) { case STATE_OK: { apr_hash_set(properties, apr_pstrdup(pool, "Severity"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "OK")); apr_hash_set(properties, apr_pstrdup(pool, "MonitorStatus"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "OK")); break; } case STATE_WARNING: { apr_hash_set(properties, apr_pstrdup(pool, "Severity"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "WARNING")); apr_hash_set(properties, apr_pstrdup(pool, "MonitorStatus"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "WARNING")); break; } case STATE_CRITICAL: { apr_hash_set(properties, apr_pstrdup(pool, "Severity"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "CRITICAL")); apr_hash_set(properties, apr_pstrdup(pool, "MonitorStatus"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "CRITICAL")); break; } default: { apr_hash_set(properties, apr_pstrdup(pool, "Severity"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "UNKNOWN")); apr_hash_set(properties, apr_pstrdup(pool, "MonitorStatus"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "UNKNOWN")); break; } } apr_hash_set(properties, apr_pstrdup(pool, "TextMessage"), APR_HASH_KEY_STRING, strcleanup(pool, service_check_data->output)); apr_hash_set(properties, apr_pstrdup(pool, "ReportDate"), APR_HASH_KEY_STRING, datetostring(pool, time(NULL))); apr_hash_set(properties, apr_pstrdup(pool, "LastInsertDate"), APR_HASH_KEY_STRING, datetostring(pool, time(NULL))); apr_hash_set(properties, apr_pstrdup(pool, "SubComponent"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%s:%s", service_check_data->host_name, service_check_data->service_description)); apr_hash_set(properties, apr_pstrdup(pool, "ErrorType"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "SERVICE ALERT")); bronx_logprintf(BRONX_LOGGING_DEBUG, "{processServiceCheck} Posting LogMessage for Service to queue, (host='%s', service='%s') Adding message to queue.", service_check_data->host_name, service_check_data->service_description); queue_push_message(MSG_TYPE_NAGIOS_LOG, pool, properties, "processServiceCheck"); } return(0); } int processStatusHost(int cmd, void *data) { host *hst; apr_pool_t *pool; apr_hash_t *properties; nebstruct_host_status_data *host_status_data; time_t time_now; if (!threads_running() || !routes_initialized()) return(0); host_status_data = (nebstruct_host_status_data *) data; hst = (host *) host_status_data->object_ptr; time_now = time(&time_now); /* * If Data is stale, ignore it. */ if (hst->last_check < (time_now - BRONX_STALE_TIMEOUT)) return(0); /* * We've got Fresh Data here, process it and add to the queue. */ bronx_logprintf(BRONX_LOGGING_DEBUG, "{processStatusHost} Received from NAGIOS: HOST STATUS (host='%s')", hst->name); normalize_plugin_output(hst->plugin_output, "B3"); apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); generate_host_properties(hst, pool, properties,hst->scheduled_downtime_depth); queue_push_message(MSG_TYPE_HOST_STATUS, pool, properties, "processStatus/Host Status"); return(0); } void generate_host_properties(host *hst, apr_pool_t *pool, apr_hash_t *properties, int downtime_depth) { char monitorStatus[MAX_STATE_LENGTH], checkType[MAX_CHECKTYPE_LENGTH]; time_t last_state_change; switch(hst->check_type) { case HOST_CHECK_ACTIVE: strcpy(checkType, "ACTIVE"); break; case HOST_CHECK_PASSIVE: strcpy(checkType, "PASSIVE"); break; default: strcpy(checkType, "UNKNOWN"); break; } switch(hst->current_state) { case HOST_UP: strcpy(monitorStatus, "UP"); break; case HOST_DOWN: strcpy(monitorStatus, "DOWN"); break; case HOST_UNREACHABLE: strcpy(monitorStatus, "UNREACHABLE"); break; default: strcpy(monitorStatus, "UNKNOWN"); break; } if (hst->last_state_change == (time_t)0) last_state_change = /*time(NULL) - */program_start; else last_state_change = hst->last_state_change; apr_hash_set(properties, apr_pstrdup(pool, "Host"), APR_HASH_KEY_STRING, apr_pstrdup(pool, hst->name)); apr_hash_set(properties, apr_pstrdup(pool, "MonitorServerName"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "localhost")); apr_hash_set(properties, apr_pstrdup(pool, "Device"), APR_HASH_KEY_STRING, apr_pstrdup(pool, hst->name)); apr_hash_set(properties, apr_pstrdup(pool, "CheckType"), APR_HASH_KEY_STRING, apr_pstrdup(pool, checkType)); apr_hash_set(properties, apr_pstrdup(pool, "CurrentNotificationNumber"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", hst->current_notification_number)); apr_hash_set(properties, apr_pstrdup(pool, "LastCheckTime"), APR_HASH_KEY_STRING, datetostring(pool, hst->last_check)); apr_hash_set(properties, apr_pstrdup(pool, "LastNotificationTime"), APR_HASH_KEY_STRING, datetostring(pool, hst->last_host_notification)); apr_hash_set(properties, apr_pstrdup(pool, "LastStateChange"), APR_HASH_KEY_STRING, datetostring(pool, last_state_change)); apr_hash_set(properties, apr_pstrdup(pool, "Latency"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%f", hst->latency)); apr_hash_set(properties, apr_pstrdup(pool, "ExecutionTime"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%f", hst->execution_time)); apr_hash_set(properties, apr_pstrdup(pool, "MonitorStatus"), APR_HASH_KEY_STRING, apr_pstrdup(pool, monitorStatus)); if (downtime_depth == -1) apr_hash_set(properties, apr_pstrdup(pool, "ScheduledDowntimeDepth"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", hst->scheduled_downtime_depth)); else apr_hash_set(properties, apr_pstrdup(pool, "ScheduledDowntimeDepth"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", downtime_depth)); apr_hash_set(properties, apr_pstrdup(pool, "PercentStateChange"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%f", hst->percent_state_change)); apr_hash_set(properties, apr_pstrdup(pool, "TimeDown"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%lu", hst->last_time_down)); // Convert to string? apr_hash_set(properties, apr_pstrdup(pool, "TimeUnreachable"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%lu", hst->last_time_unreachable)); // Convert to string? apr_hash_set(properties, apr_pstrdup(pool, "TimeUp"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%lu", hst->last_time_up)); // Convert to string? apr_hash_set(properties, apr_pstrdup(pool, "isAcknowledged"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", hst->problem_has_been_acknowledged)); apr_hash_set(properties, apr_pstrdup(pool, "isChecksEnabled"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", hst->checks_enabled)); apr_hash_set(properties, apr_pstrdup(pool, "isPassiveChecksEnabled"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", hst->accept_passive_host_checks)); apr_hash_set(properties, apr_pstrdup(pool, "isEventHandlersEnabled"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", hst->event_handler_enabled)); apr_hash_set(properties, apr_pstrdup(pool, "isFailurePredictionEnabled"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", hst->failure_prediction_enabled)); apr_hash_set(properties, apr_pstrdup(pool, "isFlapDetectionEnabled"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", hst->flap_detection_enabled)); apr_hash_set(properties, apr_pstrdup(pool, "isHostFlapping"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", hst->is_flapping)); apr_hash_set(properties, apr_pstrdup(pool, "isNotificationsEnabled"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", hst->notifications_enabled)); apr_hash_set(properties, apr_pstrdup(pool, "isProcessPerformanceData"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", hst->process_performance_data)); apr_hash_set(properties, apr_pstrdup(pool, "LastPluginOutput"), APR_HASH_KEY_STRING, strcleanup(pool, hst->plugin_output)); } int processProgramStatus(int cmd, void *data) { return(0); } int processStatusService(int cmd, void *data) { service *svc; apr_pool_t *pool; apr_hash_t *properties; if (!threads_running() || !routes_initialized()) return(0); nebstruct_service_status_data *service_status_data; time_t time_now; service_status_data = (nebstruct_service_status_data *) data; svc = (service *) service_status_data->object_ptr; time_now = time(&time_now); /* * If Data is stale, ignore it. */ if (svc->last_check < (time_now - BRONX_STALE_TIMEOUT)) return(0); /* * Data is fresh, process it. */ bronx_logprintf(BRONX_LOGGING_DEBUG, "{processStatusService} Received from NAGIOS: SERVICE (service = '%s')", svc->description); normalize_plugin_output(svc->plugin_output, "B3"); apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); generate_service_properties(svc, pool, properties); queue_push_message(MSG_TYPE_SERVICE_STATUS, pool, properties, "processStatus/Service Status"); return(0); } void generate_service_properties(service *svc, apr_pool_t *pool, apr_hash_t *properties) { char monitorStatus[MAX_STATE_LENGTH], checkType[MAX_CHECKTYPE_LENGTH], lastHardState[MAX_STATE_LENGTH], stateType[MAX_STATETYPE_LENGTH]; time_t last_state_change; bronx_logprintf(BRONX_LOGGING_DEBUG, "{generate_service_properties} (service: %s) ", svc->description); switch(svc->check_type) { case SERVICE_CHECK_ACTIVE: strcpy(checkType, "ACTIVE"); break; case SERVICE_CHECK_PASSIVE: strcpy(checkType, "PASSIVE"); break; default: strcpy(checkType, "UNKNOWN"); break; } switch(svc->last_hard_state) { case STATE_OK: strcpy(lastHardState, "OK"); break; case STATE_WARNING: strcpy(lastHardState, "WARNING"); break; case STATE_CRITICAL: strcpy(lastHardState, "CRITICAL"); break; case STATE_UNKNOWN: strcpy(lastHardState, "UNKNOWN"); break; default: strcpy(lastHardState, "UNKNOWN"); break; } switch(svc->current_state) { case STATE_OK: strcpy(monitorStatus, "OK"); break; case STATE_WARNING: strcpy(monitorStatus, "WARNING"); break; case STATE_CRITICAL: strcpy(monitorStatus, "CRITICAL"); break; case STATE_UNKNOWN: strcpy(monitorStatus, "UNKNOWN"); break; default: strcpy(monitorStatus, "UNKNOWN"); break; } switch(svc->state_type) { case HARD_STATE: strcpy(stateType, "HARD"); break; case SOFT_STATE: strcpy(stateType, "SOFT"); break; default: bronx_logprintf(BRONX_LOGGING_DEBUG, "{processStatusService} UNKNOWN STATE TYPE: %d", svc->state_type); strcpy(stateType, "UNKNOWN"); break; } if (svc->last_state_change == (time_t)0) last_state_change = /*time(NULL) - */program_start; else last_state_change = svc->last_state_change; apr_hash_set(properties, apr_pstrdup(pool, "MonitorServerName"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "localhost")); apr_hash_set(properties, apr_pstrdup(pool, "Host"), APR_HASH_KEY_STRING, apr_pstrdup(pool, svc->host_name)); apr_hash_set(properties, apr_pstrdup(pool, "Device"), APR_HASH_KEY_STRING, apr_pstrdup(pool, svc->host_name)); apr_hash_set(properties, apr_pstrdup(pool, "ServiceDescription"), APR_HASH_KEY_STRING, apr_pstrdup(pool, svc->description)); apr_hash_set(properties, apr_pstrdup(pool, "CheckType"), APR_HASH_KEY_STRING, apr_pstrdup(pool, checkType)); apr_hash_set(properties, apr_pstrdup(pool, "CurrentNotificationNumber"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", svc->current_notification_number)); apr_hash_set(properties, apr_pstrdup(pool, "ExecutionTime"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%f", svc->execution_time)); apr_hash_set(properties, apr_pstrdup(pool, "LastCheckTime"), APR_HASH_KEY_STRING, datetostring(pool, /* DDF: was svc->last_state_change*/ svc->last_check)); apr_hash_set(properties, apr_pstrdup(pool, "LastHardState"), APR_HASH_KEY_STRING, apr_pstrdup(pool, lastHardState)); apr_hash_set(properties, apr_pstrdup(pool, "LastNotificationTime"), APR_HASH_KEY_STRING, datetostring(pool, svc->last_notification)); apr_hash_set(properties, apr_pstrdup(pool, "LastStateChange"), APR_HASH_KEY_STRING, datetostring(pool, last_state_change)); apr_hash_set(properties, apr_pstrdup(pool, "Latency"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%f", svc->latency)); apr_hash_set(properties, apr_pstrdup(pool, "MonitorStatus"), APR_HASH_KEY_STRING, apr_pstrdup(pool, monitorStatus)); apr_hash_set(properties, apr_pstrdup(pool, "NextCheckTime"), APR_HASH_KEY_STRING, datetostring(pool, svc->next_check)); apr_hash_set(properties, apr_pstrdup(pool, "PercentStateChange"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%f", svc->percent_state_change)); apr_hash_set(properties, apr_pstrdup(pool, "RetryNumber"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", svc->retry_interval)); apr_hash_set(properties, apr_pstrdup(pool, "ScheduledDowntimeDepth"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", svc->scheduled_downtime_depth)); apr_hash_set(properties, apr_pstrdup(pool, "StateType"), APR_HASH_KEY_STRING, apr_pstrdup(pool, stateType)); apr_hash_set(properties, apr_pstrdup(pool, "TimeCritical"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%lu", svc->last_time_critical)); // Convert to string? apr_hash_set(properties, apr_pstrdup(pool, "TimeOK"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%lu", svc->last_time_ok)); // Convert to string? apr_hash_set(properties, apr_pstrdup(pool, "TimeUnknown"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%lu", svc->last_time_unknown)); // Convert to string? apr_hash_set(properties, apr_pstrdup(pool, "TimeWarning"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%lu", svc->last_time_warning)); // Convert to string? apr_hash_set(properties, apr_pstrdup(pool, "isAcceptPassiveChecks"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", svc->accept_passive_service_checks)); apr_hash_set(properties, apr_pstrdup(pool, "isChecksEnabled"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", svc->checks_enabled)); apr_hash_set(properties, apr_pstrdup(pool, "isEventHandlersEnabled"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", svc->event_handler_enabled)); apr_hash_set(properties, apr_pstrdup(pool, "isFailurePredictionEnabled"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", svc->failure_prediction_enabled)); apr_hash_set(properties, apr_pstrdup(pool, "isFlapDetectionEnabled"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", svc->flap_detection_enabled)); apr_hash_set(properties, apr_pstrdup(pool, "isNotificationsEnabled"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", svc->notifications_enabled)); apr_hash_set(properties, apr_pstrdup(pool, "isObsessOverService"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", svc->obsess_over_service)); apr_hash_set(properties, apr_pstrdup(pool, "isProblemAcknowledged"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", svc->problem_has_been_acknowledged)); apr_hash_set(properties, apr_pstrdup(pool, "isProcessPerformanceData"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", svc->process_performance_data)); apr_hash_set(properties, apr_pstrdup(pool, "isServiceFlapping"), APR_HASH_KEY_STRING, apr_psprintf(pool, "%d", svc->is_flapping)); bronx_logprintf(BRONX_LOGGING_DEBUG, "{processStatusService} Received from NAGIOS: SERVICE STATUS (host='%s', service='%s', type=%s, state=%s), adding to queue.", svc->host_name, svc->description, checkType, monitorStatus); normalize_plugin_output(svc->plugin_output, "B3"); apr_hash_set(properties, apr_pstrdup(pool, "LastPluginOutput"), APR_HASH_KEY_STRING, strcleanup(pool, svc->plugin_output)); } int processStatus(int cmd, void *data) { int rv; if (!threads_running() || !routes_initialized()) return(0); switch(cmd) { case NEBCALLBACK_HOST_STATUS_DATA: rv = processStatusHost(cmd, data); break; case NEBCALLBACK_SERVICE_STATUS_DATA: rv = processStatusService(cmd, data); break; default: bronx_log("{processStatus} ERROR, UNKNOWN TYPE", BRONX_LOGGING_DEBUG); rv = ERROR; break; } return(rv); } int processCommand(int cmd, void *data) { nebstruct_system_command_data *cmd_data; cmd_data = (nebstruct_system_command_data *)data; if (cmd_data->type != NEBTYPE_SYSTEM_COMMAND_END) return(0); bronx_logprintf(BRONX_LOGGING_DEBUG, "{processCommand} (execution time: %lf) command: '%s'", cmd_data->execution_time, cmd_data->command_line); return(0); } int processExternalCommand(int cmd, void *data) { nebstruct_external_command_data *cmd_data; if (!threads_running() || !routes_initialized()) return(0); cmd_data = (nebstruct_external_command_data *)data; if (cmd_data->type == NEBTYPE_EXTERNALCOMMAND_END) { apr_pool_t *pool; apr_hash_t *properties; hostgroupmember *hgmember; hostgroup *hg; host *hst; service *svc; bronx_logprintf(BRONX_LOGGING_DEBUG, "{processExternalCommand} command: '%s', args: '%s'", cmd_data->command_string, cmd_data->command_args); switch(cmd_data->command_type) { case CMD_ENABLE_PASSIVE_HOST_CHECKS: hst = find_host(cmd_data->command_args); if (hst) { apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); hst->accept_passive_host_checks = 1; generate_host_properties(hst, pool, properties, -1); queue_push_message(MSG_TYPE_HOST_STATUS, pool, properties, "CMD_ENABLE_PASSIVE_HOST_CHECKS"); } break; case CMD_DISABLE_PASSIVE_HOST_CHECKS: hst = find_host(cmd_data->command_args); if (hst) { apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); hst->accept_passive_host_checks = 0; generate_host_properties(hst, pool, properties, -1); queue_push_message(MSG_TYPE_HOST_STATUS, pool, properties, "CMD_DISABLE_PASSIVE_HOST_CHECKS"); } break; case CMD_ENABLE_HOST_CHECK: hst = find_host(cmd_data->command_args); if (hst) { apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); hst->checks_enabled = 1; generate_host_properties(hst, pool, properties, -1); queue_push_message(MSG_TYPE_HOST_STATUS, pool, properties, "CMD_ENABLE_HOST_CHECK"); } break; case CMD_DISABLE_HOST_CHECK: hst = find_host(cmd_data->command_args); if (hst) { apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); hst->checks_enabled = 0; generate_host_properties(hst, pool, properties, -1); queue_push_message(MSG_TYPE_HOST_STATUS, pool, properties, "CMD_DISABLE_HOST_CHECK"); } break; case CMD_ENABLE_HOST_FLAP_DETECTION: hst = find_host(cmd_data->command_args); if (hst) { apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); hst->flap_detection_enabled = 1; generate_host_properties(hst, pool, properties, -1); queue_push_message(MSG_TYPE_HOST_STATUS, pool, properties, "CMD_ENABLE_HOST_FLAP_DETECTION"); } break; case CMD_DISABLE_HOST_FLAP_DETECTION: hst = find_host(cmd_data->command_args); if (hst) { apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); hst->flap_detection_enabled = 0; generate_host_properties(hst, pool, properties, -1); queue_push_message(MSG_TYPE_HOST_STATUS, pool, properties, "CMD_DISABLE_HOST_FLAP_DETECTION"); } break; case CMD_ENABLE_HOST_SVC_CHECKS: for(svc=service_list;svc!=NULL;svc=svc->next) { if (!strcmp(svc->host_name, cmd_data->command_args)) { apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); svc->checks_enabled = 1; generate_service_properties(svc, pool, properties); queue_push_message(MSG_TYPE_SERVICE_STATUS, pool, properties, "CMD_DISABLE_HOST_SVC_CHECKS"); } } break; case CMD_DISABLE_HOST_SVC_CHECKS: for(svc=service_list;svc!=NULL;svc=svc->next) { if (!strcmp(svc->host_name, cmd_data->command_args)) { apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); svc->checks_enabled = 0; generate_service_properties(svc, pool, properties); queue_push_message(MSG_TYPE_SERVICE_STATUS, pool, properties, "CMD_DISABLE_HOST_SVC_CHECKS"); } } break; case CMD_ENABLE_HOST_EVENT_HANDLER: hst = find_host(cmd_data->command_args); if (hst) { apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); hst->event_handler_enabled = 1; generate_host_properties(hst, pool, properties, -1); queue_push_message(MSG_TYPE_HOST_STATUS, pool, properties, "CMD_ENABLE_HOST_EVENT_HANDLER"); } break; case CMD_DISABLE_HOST_EVENT_HANDLER: hst = find_host(cmd_data->command_args); if (hst) { apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); hst->event_handler_enabled = 0; generate_host_properties(hst, pool, properties, -1); queue_push_message(MSG_TYPE_HOST_STATUS, pool, properties, "CMD_DISABLE_HOST_EVENT_HANDLER"); } break; case CMD_ENABLE_HOST_NOTIFICATIONS: hst = find_host(cmd_data->command_args); if (hst) { apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); hst->notifications_enabled = 1; generate_host_properties(hst, pool, properties, -1); queue_push_message(MSG_TYPE_HOST_STATUS, pool, properties, "CMD_ENABLE_HOST_NOTIFICATIONS"); } break; case CMD_DISABLE_HOST_NOTIFICATIONS: hst = find_host(cmd_data->command_args); if (hst) { apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); hst->notifications_enabled = 0; generate_host_properties(hst, pool, properties, -1); queue_push_message(MSG_TYPE_HOST_STATUS, pool, properties, "CMD_DISABLE_HOST_NOTIFICATIONS"); } break; case CMD_ENABLE_HOST_SVC_NOTIFICATIONS: for(svc=service_list;svc!=NULL;svc=svc->next) { if (!strcmp(svc->host_name, cmd_data->command_args)) { apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); svc->notifications_enabled = 1; generate_service_properties(svc, pool, properties); queue_push_message(MSG_TYPE_SERVICE_STATUS, pool, properties, "CMD_ENABLE_HOST_SVC_NOTIFICATIONS"); } } break; case CMD_DISABLE_HOST_SVC_NOTIFICATIONS: for(svc=service_list;svc!=NULL;svc=svc->next) { if (!strcmp(svc->host_name, cmd_data->command_args)) { apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); svc->notifications_enabled = 0; generate_service_properties(svc, pool, properties); queue_push_message(MSG_TYPE_SERVICE_STATUS, pool, properties, "CMD_DISABLE_HOST_SVC_NOTIFICATIONS"); } } break; case CMD_ENABLE_HOSTGROUP_HOST_NOTIFICATIONS: for (hg=hostgroup_list; hg!=NULL;hg=hg->next) { if (!strcmp(hg->group_name, cmd_data->command_args)) { for(hgmember=hg->members;hgmember!=NULL;hgmember=hgmember->next) { hst = find_host(hgmember->host_name); if (hst) { apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); hst->notifications_enabled = 1; generate_host_properties(hst, pool, properties, -1); queue_push_message(MSG_TYPE_HOST_STATUS, pool, properties, "CMD_ENABLE_HOSTGROUP_HOST_NOTIFICATIONS"); } } } } break; case CMD_DISABLE_HOSTGROUP_HOST_NOTIFICATIONS: for (hg=hostgroup_list; hg!=NULL;hg=hg->next) { if (!strcmp(hg->group_name, cmd_data->command_args)) { for(hgmember=hg->members;hgmember!=NULL;hgmember=hgmember->next) { hst = find_host(hgmember->host_name); if (hst) { apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); hst->notifications_enabled = 0; generate_host_properties(hst, pool, properties, -1); queue_push_message(MSG_TYPE_HOST_STATUS, pool, properties, "CMD_DISABLE_HOSTGROUP_HOST_NOTIFICATIONS"); } } } } break; case CMD_ENABLE_HOSTGROUP_SVC_NOTIFICATIONS: for (hg=hostgroup_list; hg!=NULL;hg=hg->next) { if (!strcmp(hg->group_name, cmd_data->command_args)) { for(hgmember=hg->members;hgmember!=NULL;hgmember=hgmember->next) { for (svc=service_list;svc!=NULL;svc=svc->next) { if (!strcmp(svc->host_name, hgmember->host_name)) { apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); svc->notifications_enabled = 1; generate_service_properties(svc, pool, properties); queue_push_message(MSG_TYPE_SERVICE_STATUS, pool, properties, "CMD_ENABLE_HOSTGROUP_SVC_NOTIFICATIONS"); } } } } } break; case CMD_DISABLE_HOSTGROUP_SVC_NOTIFICATIONS: for (hg=hostgroup_list; hg!=NULL;hg=hg->next) { if (!strcmp(hg->group_name, cmd_data->command_args)) { for(hgmember=hg->members;hgmember!=NULL;hgmember=hgmember->next) { for (svc=service_list;svc!=NULL;svc=svc->next) { if (!strcmp(svc->host_name, hgmember->host_name)) { apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); svc->notifications_enabled = 0; generate_service_properties(svc, pool, properties); queue_push_message(MSG_TYPE_SERVICE_STATUS, pool, properties, "CMD_DISABLE_HOSTGROUP_SVC_NOTIFICATIONS"); } } } } } break; case CMD_ENABLE_HOSTGROUP_HOST_CHECKS: for (hg=hostgroup_list; hg!=NULL;hg=hg->next) { if (!strcmp(hg->group_name, cmd_data->command_args)) { for(hgmember=hg->members;hgmember!=NULL;hgmember=hgmember->next) { hst = find_host(hgmember->host_name); if (hst) { apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); hst->checks_enabled = 1; generate_host_properties(hst, pool, properties, -1); queue_push_message(MSG_TYPE_HOST_STATUS, pool, properties, "CMD_ENABLE_HOSTGROUP_HOST_CHECKS"); } } } } break; case CMD_DISABLE_HOSTGROUP_HOST_CHECKS: for (hg=hostgroup_list; hg!=NULL;hg=hg->next) { if (!strcmp(hg->group_name, cmd_data->command_args)) { for(hgmember=hg->members;hgmember!=NULL;hgmember=hgmember->next) { hst = find_host(hgmember->host_name); if (hst) { apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); hst->checks_enabled = 0; generate_host_properties(hst, pool, properties, -1); queue_push_message(MSG_TYPE_HOST_STATUS, pool, properties, "CMD_DISABLE_HOSTGROUP_HOST_CHECKS"); } } } } break; case CMD_ENABLE_HOSTGROUP_SVC_CHECKS: for (hg=hostgroup_list; hg!=NULL;hg=hg->next) { if (!strcmp(hg->group_name, cmd_data->command_args)) { for(hgmember=hg->members;hgmember!=NULL;hgmember=hgmember->next) { for (svc=service_list;svc!=NULL;svc=svc->next) { if (!strcmp(svc->host_name, hgmember->host_name)) { apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); svc->checks_enabled = 1; generate_service_properties(svc, pool, properties); queue_push_message(MSG_TYPE_SERVICE_STATUS, pool, properties, "CMD_ENABLE_HOSTGROUP_SVC_CHECKS"); } } } } } break; case CMD_DISABLE_HOSTGROUP_SVC_CHECKS: for (hg=hostgroup_list; hg!=NULL;hg=hg->next) { if (!strcmp(hg->group_name, cmd_data->command_args)) { for(hgmember=hg->members;hgmember!=NULL;hgmember=hgmember->next) { for (svc=service_list;svc!=NULL;svc=svc->next) { if (!strcmp(svc->host_name, hgmember->host_name)) { apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); svc->checks_enabled = 0; generate_service_properties(svc, pool, properties); queue_push_message(MSG_TYPE_SERVICE_STATUS, pool, properties, "CMD_DISABLE_HOSTGROUP_SVC_CHECKS"); } } } } } break; } } return(0); } int processProcessData(int cmd, void *data) { nebstruct_process_data *process_data; process_data = (nebstruct_process_data *)data; if (process_data->type == NEBTYPE_PROCESS_EVENTLOOPSTART) { bronx_logprintf(BRONX_LOGGING_NORMAL, "{processProcessData} Received Event Loop Start Indicator, Initializing Threads and Routes"); assert_threads_running(_configuration); assert_routes_initialized(_configuration); } return(0); } int processDowntime(int cmd, void *data) { nebstruct_downtime_data *downtime_data; if (!threads_running() || !routes_initialized()) return(0); downtime_data = (nebstruct_downtime_data *)data; /* * We only are handling Host Downtime Data * In this callback. */ if (downtime_data->downtime_type == HOST_DOWNTIME && (downtime_data->type == NEBTYPE_DOWNTIME_START || downtime_data->type == NEBTYPE_DOWNTIME_STOP)) { host *hst; bronx_logprintf(BRONX_LOGGING_DEBUG, "{processDowntime} Received NAGIOS Downtime Data, type=%d", downtime_data->downtime_type); hst = find_host(downtime_data->host_name); if (hst != NULL) { apr_pool_t *pool; apr_hash_t *properties; char text_message[MAX_PLUGINOUTPUT_LENGTH]; int downtime_depth; /* * First, generate a Host Status * Message. */ apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); switch(downtime_data->type) { case NEBTYPE_DOWNTIME_START: downtime_depth = hst->scheduled_downtime_depth + 1; break; case NEBTYPE_DOWNTIME_STOP: downtime_depth = hst->scheduled_downtime_depth - 1; break; default: downtime_depth = hst->scheduled_downtime_depth; break; } generate_host_properties(hst, pool, properties, downtime_depth); queue_push_message(MSG_TYPE_HOST_STATUS, pool, properties, "processDowntime"); /* * Next, generate a log message. */ apr_pool_create(&pool, queue_pool()); properties = apr_hash_make(pool); generate_log_message_properties(hst, pool, properties); switch(downtime_data->type) { case NEBTYPE_DOWNTIME_START: sprintf(text_message, "Host Downtime Start: (id=%ld, scheduled restart: %s) %s", downtime_data->downtime_id, asctime(localtime(&downtime_data->end_time)), downtime_data->comment_data); break; case NEBTYPE_DOWNTIME_STOP: sprintf(text_message, "Host Downtime Stop: (id=%ld) %s", downtime_data->downtime_id, downtime_data->comment_data); break; } apr_hash_set(properties, apr_pstrdup(pool, "TextMessage"), APR_HASH_KEY_STRING, strcleanup(pool, text_message)); queue_push_message(MSG_TYPE_NAGIOS_LOG, pool, properties, "processDowntime"); } else bronx_logprintf(BRONX_LOGGING_DEBUG, "{processDowntime} Unknown Host '%s' Supplied", downtime_data->host_name); } return(0); } void generate_log_message_properties(host *hst, apr_pool_t *pool, apr_hash_t *properties) { apr_hash_set(properties, apr_pstrdup(pool, "MonitorServerName"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "localhost")); apr_hash_set(properties, apr_pstrdup(pool, "Host"), APR_HASH_KEY_STRING, apr_pstrdup(pool, hst->name)); apr_hash_set(properties, apr_pstrdup(pool, "Device"), APR_HASH_KEY_STRING, apr_pstrdup(pool, hst->name)); apr_hash_set(properties, apr_pstrdup(pool, "MonitorStatus"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "MAINTENANCE")); apr_hash_set(properties, apr_pstrdup(pool, "Severity"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "INFORMATIONAL")); apr_hash_set(properties, apr_pstrdup(pool, "ReportDate"), APR_HASH_KEY_STRING, datetostring(pool, time(NULL))); apr_hash_set(properties, apr_pstrdup(pool, "LastInsertDate"), APR_HASH_KEY_STRING, datetostring(pool, time(NULL))); apr_hash_set(properties, apr_pstrdup(pool, "SubComponent"), APR_HASH_KEY_STRING, apr_pstrdup(pool, hst->name)); apr_hash_set(properties, apr_pstrdup(pool, "ErrorType"), APR_HASH_KEY_STRING, apr_pstrdup(pool, "HOST ALERT")); }