void n2a_free_fifo (fifo * pFifo)
{
n2a_csync (pFifo);
n2a_logger (LG_DEBUG, "FIFO: Freeing fifo");
if (pFifo->first)
{
event *pEvent = pFifo->first;
event *pNext = NULL;
do
{
pNext = pEvent->pNext;
n2a_free_event (pEvent);
pEvent = pNext;
}
while (pNext != NULL);
}
if (pFifo->pFile)
{
n2a_logger (LG_DEBUG, "FIFO: Close file");
fclose (pFifo->pFile);
pFifo->pFile = NULL;
}
free (pFifo->file_path);
free (pFifo);
}
int n2a_fifo_open_file (fifo *pFifo)
{
if (!pFifo->pFile)
{
n2a_logger (LG_DEBUG, "FIFO: Open fifo file '%s'", pFifo->file_path);
pFifo->pFile = fopen (pFifo->file_path, "r+");
if (!pFifo->pFile)
{
pFifo->pFile = fopen (pFifo->file_path, "w+");
}
if (!pFifo->pFile)
{
n2a_logger (LG_ERR, "FIFO: Impossible to open '%s'", pFifo->file_path);
}
else
{
n2a_logger (LG_DEBUG, "FIFO: File successfully opened");
}
}
else
{
n2a_logger (LG_DEBUG, "FIFO: '%s' already open", pFifo->file_path);
}
return (!pFifo->pFile ? 0 : 1);
}
fifo *n2a_fifo_init (int max_size, char *file_path)
{
fifo *pFifo = NULL;
int loaded = 0;
n2a_logger (LG_DEBUG, "Initialize FIFO: %s (maximum size: %d", file_path, max_size);
pFifo = malloc (sizeof (fifo));
pFifo->first = NULL;
pFifo->last = NULL;
pFifo->pFile = NULL;
pFifo->size = 0;
pFifo->file_lock = false;
pFifo->dirty = false;
pFifo->full = false;
pFifo->file_path = strdup (file_path);
pFifo->max_size = max_size;
loaded = n2a_load (pFifo);
n2a_logger (LG_INFO, "FIFO: %d events loaded", loaded);
return pFifo;
}
int n2a_csync (fifo *pFifo)
{
int i = 0;
if (!pFifo)
{
n2a_logger (LG_ERR, "FIFO: Invalid fifo");
return 0;
}
if (!pFifo->dirty)
{
n2a_logger (LG_DEBUG, "FIFO: Up to date");
return 0;
}
n2a_logger (LG_DEBUG, "FIFO: Sync %d events to file", pFifo->size);
/* TODO:
* - Use pthread locks
* - Or better, but more complicated : use lock-free algorithm based on
* compare-and-swap atomic instruction.
*/
if (pFifo->file_lock)
{
n2a_logger (LG_WARN, "FIFO: Fifo file is locked");
return 0;
}
pFifo->file_lock = true;
n2a_clear (pFifo);
if (!n2a_fifo_open_file (pFifo))
{
pFifo->file_lock = false;
return 0;
}
if (pFifo->first)
{
event *pEvent = NULL;
for (pEvent = pFifo->first; pEvent != NULL; pEvent = pEvent->pNext, ++i)
{
fprintf (pFifo->pFile, "%s\n%s\n", pEvent->rk, pEvent->msg);
}
}
fflush (pFifo->pFile);
n2a_logger (LG_INFO, "FIFO: %d events written to file", i);
pFifo->file_lock = false;
pFifo->dirty = false;
return i;
}
int n2a_load (fifo *pFifo)
{
int i = 0;
n2a_logger (LG_DEBUG, "FIFO: Load events from file");
if (pFifo->file_lock)
{
n2a_logger (LG_WARN, "FIFO: Fifo is locked");
return 0;
}
if (!n2a_fifo_open_file (pFifo))
{
return 0;
}
pFifo->file_lock = true;
rewind (pFifo->pFile);
while(!feof (pFifo->pFile))
{
char rk[EVENT_MSG_MAX_SIZE];
char msg[EVENT_MSG_MAX_SIZE];
/* Read RK */
fgets (rk, EVENT_MSG_MAX_SIZE, pFifo->pFile);
/* Read event */
fgets (msg, EVENT_MSG_MAX_SIZE, pFifo->pFile);
/* Remove trailing \n */
rk[strlen (rk) - 1] = 0;
msg[strlen (msg) - 1] = 0;
n2a_push (pFifo, n2a_event_init (rk, msg));
i += 1;
}
if (pFifo->pFile)
{
n2a_logger (LG_DEBUG, "FIFO: Close file");
fclose (pFifo->pFile);
pFifo->pFile = NULL;
}
pFifo->file_lock = false;
return i;
}
int n2a_prepend (fifo *pFifo, event *pEvent)
{
n2a_logger (LG_DEBUG, "FIFO: Prepand (%d)", pFifo->size);
n2a_check_size (pFifo);
if (pFifo->full)
{
n2a_free_event (n2a_pop (pFifo));
}
if (pFifo->first == NULL)
{
pFifo->first = pEvent;
pFifo->last = pEvent;
}
else
{
pEvent->pPrev = NULL;
pEvent->pNext = pFifo->first;
pFifo->first->pPrev = pEvent;
pFifo->first = pEvent;
}
pFifo->size += 1;
pFifo->dirty = true;
return pFifo->size;
}
void n2a_check_size (fifo *pFifo)
{
if (pFifo->size >= pFifo->max_size && !pFifo->full)
{
pFifo->full = true;
n2a_logger (LG_WARN, "FIFO: Queue is full, drop events ...");
}
if (pFifo->size < pFifo->max_size)
{
pFifo->full = false;
}
}
int n2a_clear (fifo *pFifo)
{
n2a_logger (LG_DEBUG, "FIFO: Remove fifo file");
if (pFifo->pFile)
{
fclose (pFifo->pFile);
}
pFifo->pFile = NULL;
return unlink (pFifo->file_path);
}
int
verify_event_broker_options ()
{
int errors = 0;
/*if (!(event_broker_options & BROKER_PROGRAM_STATE))
{
n2a_logger (LG_CRIT,
"need BROKER_PROGRAM_STATE (%i) event_broker_option enabled to work.",
BROKER_PROGRAM_STATE);
errors++;
}*/
/*if (!(event_broker_options & BROKER_TIMED_EVENTS))
{
n2a_logger (LG_CRIT,
"need BROKER_TIMED_EVENTS (%i) event_broker_option enabled to work.",
BROKER_TIMED_EVENTS);
errors++;
}*/
if (!(event_broker_options & BROKER_SERVICE_CHECKS))
{
n2a_logger (LG_CRIT,
"need BROKER_SERVICE_CHECKS (%i) event_broker_option enabled to work.",
BROKER_SERVICE_CHECKS);
errors++;
}
if (!(event_broker_options & BROKER_HOST_CHECKS))
{
n2a_logger (LG_CRIT,
"need BROKER_HOST_CHECKS (%i) event_broker_option enabled to work.",
BROKER_HOST_CHECKS);
errors++;
}
/*if (!(event_broker_options & BROKER_LOGGED_DATA))
{
n2a_logger (LG_CRIT,
"need BROKER_LOGGED_DATA (%i) event_broker_option enabled to work.",
BROKER_LOGGED_DATA);
errors++;
}*/
/*if (!(event_broker_options & BROKER_COMMENT_DATA))
{
n2a_logger (LG_CRIT,
"need BROKER_COMMENT_DATA (%i) event_broker_option enabled to work.",
BROKER_COMMENT_DATA);
errors++;
}
if (!(event_broker_options & BROKER_DOWNTIME_DATA))
{
n2a_logger (LG_CRIT,
"need BROKER_DOWNTIME_DATA (%i) event_broker_option enabled to work.",
BROKER_DOWNTIME_DATA);
errors++;
}
if (!(event_broker_options & BROKER_STATUS_DATA))
{
n2a_logger (LG_CRIT,
"need BROKER_STATUS_DATA (%i) event_broker_option enabled to work.",
BROKER_STATUS_DATA);
errors++;
}
if (!(event_broker_options & BROKER_ADAPTIVE_DATA))
{
n2a_logger (LG_CRIT,
"need BROKER_ADAPTIVE_DATA (%i) event_broker_option enabled to work.",
BROKER_ADAPTIVE_DATA);
errors++;
}
if (!(event_broker_options & BROKER_EXTERNALCOMMAND_DATA))
{
n2a_logger (LG_CRIT,
"need BROKER_EXTERNALCOMMAND_DATA (%i) event_broker_option enabled to work.",
BROKER_EXTERNALCOMMAND_DATA);
errors++;
}
if (!(event_broker_options & BROKER_STATECHANGE_DATA))
{
n2a_logger (LG_CRIT,
"need BROKER_STATECHANGE_DATA (%i) event_broker_option enabled to work.",
BROKER_STATECHANGE_DATA);
errors++;
}*/
return errors == 0;
}
int
n2a_event_service_check (int event_type __attribute__ ((__unused__)), void *data)
{
//logger(LG_DEBUG, "Event: event_host_check");
nebstruct_service_check_data *c = (nebstruct_service_check_data *) data;
if (c->type == NEBTYPE_SERVICECHECK_PROCESSED)
{
//logger(LG_DEBUG, "SERVICECHECK_PROCESSED: %s->%s", c->host_name, c->service_description);
char *buffer = NULL, *key = NULL;
size_t l = xstrlen(g_options.connector) +
xstrlen(g_options.eventsource_name) + xstrlen(c->host_name) + xstrlen(c->service_description) + 20;
// "..check.ressource.." + \0 = 20 chars
json_t *jdata = NULL;
size_t message_size = 0;
int nbmsg = nebstruct_service_check_data_to_json(c, &jdata, &message_size);
// DO NOT FREE !!!
xalloca(key, xmin(g_options.max_size, (int)l) * sizeof(char));
snprintf(key, xmin(g_options.max_size, (int)l),
"%s.%s.check.resource.%s.%s", g_options.connector,
g_options.eventsource_name, c->host_name,
c->service_description);
if (nbmsg == 1) {
char *json = json_dumps(jdata, 0);
buffer = xmalloc (message_size + 1);
snprintf (buffer, message_size + 1, "%s", json);
if (c_size == -10000 || c_size / 2 == 0)
amqp_publish(key, buffer);
else
n2a_record_cache (key, buffer);
xfree(buffer);
xfree (json);
} else {
int left = g_options.max_size - (int)message_size;
size_t l_out = xstrlen(c->long_output);
size_t out = xstrlen(c->output);
size_t perf = xstrlen(c->perf_data);
int msgs = ((int)l_out/left + 1) + ((int)out/left + 1) + ((int)perf/left + 1);
n2a_logger(LG_INFO, "Data too long... sending %d messages for host: %s, service: %s", msgs, c->host_name, c->service_description);
int i, temp;
split_message(c->long_output, "long_output");
split_message(c->output, "output");
split_message(c->perf_data, "perf_data");
}
if (jdata != NULL)
json_decref (jdata);
}
return 0;
}
