src/utils_cache.c: Added the creation of an `OKAY' notification.

[collectd.git] / src / utils_cache.c

diff --git a/src/utils_cache.c b/src/utils_cache.c
index 20d4deb..77b38eb 100644 (file)
--- a/src/utils_cache.c
+++ b/src/utils_cache.c
@@ -23,6 +23,8 @@
 #include "common.h"
 #include "plugin.h"
 #include "utils_avltree.h"
+#include "utils_cache.h"
+#include "utils_threshold.h"
 
 #include <assert.h>
 #include <pthread.h>
@@ -42,6 +44,7 @@ typedef struct cache_entry_s
        /* Interval in which the data is collected
         * (for purding old entries) */
        int interval;
+       int state;
 } cache_entry_t;
 
 static avl_tree_t     *cache_tree = NULL;
@@ -105,8 +108,9 @@ static int uc_send_notification (const char *name)
   }
     
   /* Check if the entry has been updated in the meantime */
-  if ((n.time - ce->last_update) <= (2 * ce->interval))
+  if ((n.time - ce->last_update) < (2 * ce->interval))
   {
+    ce->state = STATE_OKAY;
     pthread_mutex_unlock (&cache_lock);
     sfree (name_copy);
     return (-1);
@@ -114,7 +118,7 @@ static int uc_send_notification (const char *name)
 
   snprintf (n.message, sizeof (n.message),
       "%s has not been updated for %i seconds.", name,
-      (int) (ce->last_update - n.time));
+      (int) (n.time - ce->last_update));
 
   pthread_mutex_unlock (&cache_lock);
 
@@ -154,7 +158,7 @@ int uc_check_timeout (void)
   while (avl_iterator_next (iter, (void *) &key, (void *) &ce) == 0)
   {
     /* If entry has not been updated, add to `keys' array */
-    if ((now - ce->last_update) > (2 * ce->interval))
+    if ((now - ce->last_update) >= (2 * ce->interval))
     {
       char **tmp;
 
@@ -182,21 +186,35 @@ int uc_check_timeout (void)
   {
     int status;
 
-    /* TODO: Check if value interesting:
-     * - Not interesting: Remove value from cache and shut up
-     * - Interesting:     Don't remove value from cache but send a
-     *                    notification.
-     */
-    status = avl_remove (cache_tree, keys[i], (void *) &key, (void *) &ce);
-    if (status != 0)
+    status = ut_check_interesting (keys[i]);
+
+    if (status < 0)
     {
-      ERROR ("uc_check_timeout: avl_remove (%s) failed.", keys[i]);
-      continue;
+      ERROR ("uc_check_timeout: ut_check_interesting failed.");
+      sfree (keys[i]);
     }
-
-    sfree (key);
-    sfree (ce);
-  }
+    else if (status == 0) /* ``service'' is uninteresting */
+    {
+      ce = NULL;
+      DEBUG ("uc_check_timeout: %s is missing but ``uninteresting''", keys[i]);
+      status = avl_remove (cache_tree, keys[i], (void *) &key, (void *) &ce);
+      if (status != 0)
+      {
+       ERROR ("uc_check_timeout: avl_remove (%s) failed.", keys[i]);
+      }
+      sfree (keys[i]);
+      sfree (ce);
+    }
+    else /* (status > 0); ``service'' is interesting */
+    {
+      /*
+       * `keys[i]' is not freed and set to NULL, so that the for-loop below
+       * will send out notifications. There's nothing else to do here.
+       */
+      DEBUG ("uc_check_timeout: %s is missing and ``interesting''", keys[i]);
+      ce->state = STATE_ERROR;
+    }
+  } /* for (keys[i]) */
 
   avl_iterator_destroy (iter);
 
@@ -204,6 +222,9 @@ int uc_check_timeout (void)
 
   for (i = 0; i < keys_len; i++)
   {
+    if (keys[i] == NULL)
+      continue;
+
     uc_send_notification (keys[i]);
     sfree (keys[i]);
   }
@@ -217,6 +238,7 @@ int uc_update (const data_set_t *ds, const value_list_t *vl)
 {
   char name[6 * DATA_MAX_NAME_LEN];
   cache_entry_t *ce = NULL;
+  int send_okay_notification = 0;
 
   if (FORMAT_VL (name, sizeof (name), vl, ds) != 0)
   {
@@ -244,9 +266,8 @@ int uc_update (const data_set_t *ds, const value_list_t *vl)
 
     if ((ce->last_time + ce->interval) < vl->time)
     {
-      /* TODO: Implement a `real' okay notification. Watch out for locking
-       * issues, though! */
-      NOTICE ("uc_insert: Okay notification for %s", name);
+      send_okay_notification = vl->time - ce->last_time;
+      ce->state = STATE_OKAY;
     }
 
     for (i = 0; i < ds->ds_num; i++)
@@ -331,6 +352,9 @@ int uc_update (const data_set_t *ds, const value_list_t *vl)
     } /* for (i) */
 
     ce->last_time = vl->time;
+    ce->last_update = time (NULL);
+    ce->interval = vl->interval;
+    ce->state = STATE_OKAY;
 
     if (avl_insert (cache_tree, key, ce) != 0)
     {
@@ -344,6 +368,24 @@ int uc_update (const data_set_t *ds, const value_list_t *vl)
 
   pthread_mutex_unlock (&cache_lock);
 
+  if (send_okay_notification > 0)
+  {
+    notification_t n;
+    memset (&n, '\0', sizeof (n));
+
+    n.severity = NOTIF_OKAY;
+    strncpy (n.host, vl->host, sizeof (n.host));
+    n.host[sizeof (n.host) - 1] = '\0';
+    n.time = vl->time;
+
+    snprintf (n.message, sizeof (n.message),
+       "Received a value for %s. It was missing for %i seconds.",
+       name, send_okay_notification);
+    n.message[sizeof (n.message) - 1] = '\0';
+
+    plugin_dispatch_notification (&n);
+  }
+
   return (0);
 } /* int uc_insert */
 
@@ -382,4 +424,59 @@ gauge_t *uc_get_rate (const data_set_t *ds, const value_list_t *vl)
   return (ret);
 } /* gauge_t *uc_get_rate */
 
+int uc_get_state (const data_set_t *ds, const value_list_t *vl)
+{
+  char name[6 * DATA_MAX_NAME_LEN];
+  cache_entry_t *ce = NULL;
+  int ret = STATE_ERROR;
+
+  if (FORMAT_VL (name, sizeof (name), vl, ds) != 0)
+  {
+    ERROR ("uc_get_state: FORMAT_VL failed.");
+    return (STATE_ERROR);
+  }
+
+  pthread_mutex_lock (&cache_lock);
+
+  if (avl_get (cache_tree, name, (void *) &ce) == 0)
+  {
+    assert (ce != NULL);
+    ret = ce->state;
+  }
+
+  pthread_mutex_unlock (&cache_lock);
+
+  return (ret);
+} /* int uc_get_state */
+
+int uc_set_state (const data_set_t *ds, const value_list_t *vl, int state)
+{
+  char name[6 * DATA_MAX_NAME_LEN];
+  cache_entry_t *ce = NULL;
+  int ret = -1;
+
+  if (state < STATE_OKAY)
+    state = STATE_OKAY;
+  if (state > STATE_ERROR)
+    state = STATE_ERROR;
+
+  if (FORMAT_VL (name, sizeof (name), vl, ds) != 0)
+  {
+    ERROR ("uc_get_state: FORMAT_VL failed.");
+    return (STATE_ERROR);
+  }
+
+  pthread_mutex_lock (&cache_lock);
+
+  if (avl_get (cache_tree, name, (void *) &ce) == 0)
+  {
+    assert (ce != NULL);
+    ret = ce->state;
+    ce->state = state;
+  }
+
+  pthread_mutex_unlock (&cache_lock);
+
+  return (ret);
+} /* int uc_set_state */
 /* vim: set sw=2 ts=8 sts=2 tw=78 : */