src/utils_cache.c

   1 /**
   2  * collectd - src/utils_cache.c
   3  * Copyright (C) 2007  Florian octo Forster
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; only version 2 of the License is applicable.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  17  *
  18  * Author:
  19  *   Florian octo Forster <octo at verplant.org>
  20  **/
  21
  22 #include "collectd.h"
  23 #include "common.h"
  24 #include "plugin.h"
  25 #include "utils_avltree.h"
  26 #include "utils_cache.h"
  27 #include "utils_threshold.h"
  28
  29 #include <assert.h>
  30 #include <pthread.h>
  31
  32 typedef struct cache_entry_s
  33 {
  34         char name[6 * DATA_MAX_NAME_LEN];
  35         int        values_num;
  36         gauge_t   *values_gauge;
  37         counter_t *values_counter;
  38         /* Time contained in the package
  39          * (for calculating rates) */
  40         time_t last_time;
  41         /* Time according to the local clock
  42          * (for purging old entries) */
  43         time_t last_update;
  44         /* Interval in which the data is collected
  45          * (for purding old entries) */
  46         int interval;
  47         int state;
  48 } cache_entry_t;
  49
  50 static c_avl_tree_t   *cache_tree = NULL;
  51 static pthread_mutex_t cache_lock = PTHREAD_MUTEX_INITIALIZER;
  52
  53 static int cache_compare (const cache_entry_t *a, const cache_entry_t *b)
  54 {
  55   assert ((a != NULL) && (b != NULL));
  56   return (strcmp (a->name, b->name));
  57 } /* int cache_compare */
  58
  59 static cache_entry_t *cache_alloc (int values_num)
  60 {
  61   cache_entry_t *ce;
  62
  63   ce = (cache_entry_t *) malloc (sizeof (cache_entry_t));
  64   if (ce == NULL)
  65   {
  66     ERROR ("utils_cache: cache_alloc: malloc failed.");
  67     return (NULL);
  68   }
  69   memset (ce, '\0', sizeof (cache_entry_t));
  70   ce->values_num = values_num;
  71
  72   ce->values_gauge = (gauge_t *) calloc (values_num, sizeof (gauge_t));
  73   ce->values_counter = (counter_t *) calloc (values_num, sizeof (counter_t));
  74   if ((ce->values_gauge == NULL) || (ce->values_counter == NULL))
  75   {
  76     sfree (ce->values_gauge);
  77     sfree (ce->values_counter);
  78     sfree (ce);
  79     ERROR ("utils_cache: cache_alloc: calloc failed.");
  80     return (NULL);
  81   }
  82
  83   return (ce);
  84 } /* cache_entry_t *cache_alloc */
  85
  86 static void cache_free (cache_entry_t *ce)
  87 {
  88   if (ce == NULL)
  89     return;
  90
  91   sfree (ce->values_gauge);
  92   sfree (ce->values_counter);
  93   sfree (ce);
  94 } /* void cache_free */
  95
  96 static int uc_send_notification (const char *name)
  97 {
  98   cache_entry_t *ce = NULL;
  99   int status;
 100
 101   char *name_copy;
 102   char *host;
 103   char *plugin;
 104   char *plugin_instance;
 105   char *type;
 106   char *type_instance;
 107
 108   notification_t n;
 109
 110   name_copy = strdup (name);
 111   if (name_copy == NULL)
 112   {
 113     ERROR ("uc_send_notification: strdup failed.");
 114     return (-1);
 115   }
 116
 117   status = parse_identifier (name_copy, &host,
 118       &plugin, &plugin_instance,
 119       &type, &type_instance);
 120   if (status != 0)
 121   {
 122     ERROR ("uc_send_notification: Cannot parse name `%s'", name);
 123     return (-1);
 124   }
 125
 126   /* Copy the associative members */
 127   notification_init (&n, NOTIF_FAILURE, /* host = */ NULL,
 128       host, plugin, plugin_instance, type, type_instance);
 129
 130   sfree (name_copy);
 131   name_copy = host = plugin = plugin_instance = type = type_instance = NULL;
 132
 133   pthread_mutex_lock (&cache_lock);
 134
 135   /*
 136    * Set the time _after_ getting the lock because we don't know how long
 137    * acquiring the lock takes and we will use this time later to decide
 138    * whether or not the state is OKAY.
 139    */
 140   n.time = time (NULL);
 141
 142   status = c_avl_get (cache_tree, name, (void *) &ce);
 143   if (status != 0)
 144   {
 145     pthread_mutex_unlock (&cache_lock);
 146     sfree (name_copy);
 147     return (-1);
 148   }
 149
 150   /* Check if the entry has been updated in the meantime */
 151   if ((n.time - ce->last_update) < (2 * ce->interval))
 152   {
 153     ce->state = STATE_OKAY;
 154     pthread_mutex_unlock (&cache_lock);
 155     sfree (name_copy);
 156     return (-1);
 157   }
 158
 159   snprintf (n.message, sizeof (n.message),
 160       "%s has not been updated for %i seconds.", name,
 161       (int) (n.time - ce->last_update));
 162
 163   pthread_mutex_unlock (&cache_lock);
 164
 165   n.message[sizeof (n.message) - 1] = '\0';
 166   plugin_dispatch_notification (&n);
 167
 168   return (0);
 169 } /* int uc_send_notification */
 170
 171 static int uc_insert (const data_set_t *ds, const value_list_t *vl,
 172     const char *key)
 173 {
 174   int i;
 175   char *key_copy;
 176   cache_entry_t *ce;
 177
 178   /* `cache_lock' has been locked by `uc_update' */
 179
 180   key_copy = strdup (key);
 181   if (key_copy == NULL)
 182   {
 183     ERROR ("uc_insert: strdup failed.");
 184     return (-1);
 185   }
 186
 187   ce = cache_alloc (ds->ds_num);
 188   if (ce == NULL)
 189   {
 190     ERROR ("uc_insert: cache_alloc (%i) failed.", ds->ds_num);
 191     return (-1);
 192   }
 193
 194   sstrncpy (ce->name, key, sizeof (ce->name));
 195
 196   for (i = 0; i < ds->ds_num; i++)
 197   {
 198     if (ds->ds[i].type == DS_TYPE_COUNTER)
 199     {
 200       ce->values_gauge[i] = NAN;
 201       ce->values_counter[i] = vl->values[i].counter;
 202     }
 203     else /* if (ds->ds[i].type == DS_TYPE_GAUGE) */
 204     {
 205       ce->values_gauge[i] = vl->values[i].gauge;
 206     }
 207   } /* for (i) */
 208
 209   ce->last_time = vl->time;
 210   ce->last_update = time (NULL);
 211   ce->interval = vl->interval;
 212   ce->state = STATE_OKAY;
 213
 214   if (c_avl_insert (cache_tree, key_copy, ce) != 0)
 215   {
 216     sfree (key_copy);
 217     ERROR ("uc_insert: c_avl_insert failed.");
 218     return (-1);
 219   }
 220
 221   DEBUG ("uc_insert: Added %s to the cache.", key);
 222   return (0);
 223 } /* int uc_insert */
 224
 225 int uc_init (void)
 226 {
 227   if (cache_tree == NULL)
 228     cache_tree = c_avl_create ((int (*) (const void *, const void *))
 229         cache_compare);
 230
 231   return (0);
 232 } /* int uc_init */
 233
 234 int uc_check_timeout (void)
 235 {
 236   time_t now;
 237   cache_entry_t *ce;
 238
 239   char **keys = NULL;
 240   int keys_len = 0;
 241
 242   char *key;
 243   c_avl_iterator_t *iter;
 244   int i;
 245
 246   pthread_mutex_lock (&cache_lock);
 247
 248   now = time (NULL);
 249
 250   /* Build a list of entries to be flushed */
 251   iter = c_avl_get_iterator (cache_tree);
 252   while (c_avl_iterator_next (iter, (void *) &key, (void *) &ce) == 0)
 253   {
 254     /* If entry has not been updated, add to `keys' array */
 255     if ((now - ce->last_update) >= (2 * ce->interval))
 256     {
 257       char **tmp;
 258
 259       tmp = (char **) realloc ((void *) keys,
 260           (keys_len + 1) * sizeof (char *));
 261       if (tmp == NULL)
 262       {
 263         ERROR ("uc_purge: realloc failed.");
 264         c_avl_iterator_destroy (iter);
 265         return (-1);
 266       }
 267
 268       keys = tmp;
 269       keys[keys_len] = strdup (key);
 270       if (keys[keys_len] == NULL)
 271       {
 272         ERROR ("uc_check_timeout: strdup failed.");
 273         continue;
 274       }
 275       keys_len++;
 276     }
 277   } /* while (c_avl_iterator_next) */
 278
 279   for (i = 0; i < keys_len; i++)
 280   {
 281     int status;
 282
 283     status = ut_check_interesting (keys[i]);
 284
 285     if (status < 0)
 286     {
 287       ERROR ("uc_check_timeout: ut_check_interesting failed.");
 288       sfree (keys[i]);
 289     }
 290     else if (status == 0) /* ``service'' is uninteresting */
 291     {
 292       ce = NULL;
 293       DEBUG ("uc_check_timeout: %s is missing but ``uninteresting''",
 294           keys[i]);
 295       status = c_avl_remove (cache_tree, keys[i],
 296           (void *) &key, (void *) &ce);
 297       if (status != 0)
 298       {
 299         ERROR ("uc_check_timeout: c_avl_remove (%s) failed.", keys[i]);
 300       }
 301       sfree (keys[i]);
 302       cache_free (ce);
 303     }
 304     else if (status == 1) /* persist */
 305     {
 306       DEBUG ("uc_check_timeout: %s is missing, sending notification.",
 307           keys[i]);
 308       ce->state = STATE_ERROR;
 309     }
 310     else if (status == 2) /* do not persist */
 311     {
 312       if (ce->state == STATE_ERROR)
 313       {
 314         DEBUG ("uc_check_timeout: %s is missing but "
 315             "notification has already been sent.",
 316             keys[i]);
 317         sfree (keys[i]);
 318       }
 319       else /* (ce->state != STATE_ERROR) */
 320       {
 321         DEBUG ("uc_check_timeout: %s is missing, sending one notification.",
 322             keys[i]);
 323         ce->state = STATE_ERROR;
 324       }
 325     }
 326     else
 327     {
 328       WARNING ("uc_check_timeout: ut_check_interesting (%s) returned ",
 329           "invalid status %i.",
 330           keys[i], status);
 331     }
 332   } /* for (keys[i]) */
 333
 334   c_avl_iterator_destroy (iter);
 335
 336   pthread_mutex_unlock (&cache_lock);
 337
 338   for (i = 0; i < keys_len; i++)
 339   {
 340     if (keys[i] == NULL)
 341       continue;
 342
 343     uc_send_notification (keys[i]);
 344     sfree (keys[i]);
 345   }
 346
 347   sfree (keys);
 348
 349   return (0);
 350 } /* int uc_check_timeout */
 351
 352 int uc_update (const data_set_t *ds, const value_list_t *vl)
 353 {
 354   char name[6 * DATA_MAX_NAME_LEN];
 355   cache_entry_t *ce = NULL;
 356   int send_okay_notification = 0;
 357   time_t update_delay = 0;
 358   notification_t n;
 359   int status;
 360   int i;
 361
 362   if (FORMAT_VL (name, sizeof (name), vl, ds) != 0)
 363   {
 364     ERROR ("uc_update: FORMAT_VL failed.");
 365     return (-1);
 366   }
 367
 368   pthread_mutex_lock (&cache_lock);
 369
 370   status = c_avl_get (cache_tree, name, (void *) &ce);
 371   if (status != 0) /* entry does not yet exist */
 372   {
 373     status = uc_insert (ds, vl, name);
 374     pthread_mutex_unlock (&cache_lock);
 375     return (status);
 376   }
 377
 378   assert (ce != NULL);
 379   assert (ce->values_num == ds->ds_num);
 380
 381   if (ce->last_time >= vl->time)
 382   {
 383     pthread_mutex_unlock (&cache_lock);
 384     NOTICE ("uc_update: Value too old: name = %s; value time = %u; "
 385         "last cache update = %u;",
 386         name, (unsigned int) vl->time, (unsigned int) ce->last_time);
 387     return (-1);
 388   }
 389
 390   /* Send a notification (after the lock has been released) if we switch the
 391    * state from something else to `okay'. */
 392   if (ce->state != STATE_OKAY)
 393   {
 394     send_okay_notification = 1;
 395     ce->state = STATE_OKAY;
 396     update_delay = time (NULL) - ce->last_update;
 397   }
 398
 399   for (i = 0; i < ds->ds_num; i++)
 400   {
 401     if (ds->ds[i].type == DS_TYPE_COUNTER)
 402     {
 403       counter_t diff;
 404
 405       /* check if the counter has wrapped around */
 406       if (vl->values[i].counter < ce->values_counter[i])
 407       {
 408         if (ce->values_counter[i] <= 4294967295U)
 409           diff = (4294967295U - ce->values_counter[i])
 410             + vl->values[i].counter;
 411         else
 412           diff = (18446744073709551615ULL - ce->values_counter[i])
 413             + vl->values[i].counter;
 414       }
 415       else /* counter has NOT wrapped around */
 416       {
 417         diff = vl->values[i].counter - ce->values_counter[i];
 418       }
 419
 420       ce->values_gauge[i] = ((double) diff)
 421         / ((double) (vl->time - ce->last_time));
 422       ce->values_counter[i] = vl->values[i].counter;
 423     }
 424     else /* if (ds->ds[i].type == DS_TYPE_GAUGE) */
 425     {
 426       ce->values_gauge[i] = vl->values[i].gauge;
 427     }
 428     DEBUG ("uc_update: %s: ds[%i] = %lf", name, i, ce->values_gauge[i]);
 429   } /* for (i) */
 430
 431   ce->last_time = vl->time;
 432   ce->last_update = time (NULL);
 433   ce->interval = vl->interval;
 434
 435   pthread_mutex_unlock (&cache_lock);
 436
 437   if (send_okay_notification == 0)
 438     return (0);
 439
 440   /* Do not send okay notifications for uninteresting values, i. e. values for
 441    * which no threshold is configured. */
 442   status = ut_check_interesting (name);
 443   if (status <= 0)
 444     return (0);
 445
 446   /* Initialize the notification */
 447   memset (&n, '\0', sizeof (n));
 448   NOTIFICATION_INIT_VL (&n, vl, ds);
 449
 450   n.severity = NOTIF_OKAY;
 451   n.time = vl->time;
 452
 453   snprintf (n.message, sizeof (n.message),
 454       "Received a value for %s. It was missing for %u seconds.",
 455       name, (unsigned int) update_delay);
 456   n.message[sizeof (n.message) - 1] = '\0';
 457
 458   plugin_dispatch_notification (&n);
 459
 460   return (0);
 461 } /* int uc_update */
 462
 463 gauge_t *uc_get_rate (const data_set_t *ds, const value_list_t *vl)
 464 {
 465   char name[6 * DATA_MAX_NAME_LEN];
 466   gauge_t *ret = NULL;
 467   cache_entry_t *ce = NULL;
 468
 469   if (FORMAT_VL (name, sizeof (name), vl, ds) != 0)
 470   {
 471     ERROR ("uc_get_rate: FORMAT_VL failed.");
 472     return (NULL);
 473   }
 474
 475   pthread_mutex_lock (&cache_lock);
 476
 477   if (c_avl_get (cache_tree, name, (void *) &ce) == 0)
 478   {
 479     assert (ce != NULL);
 480     assert (ce->values_num == ds->ds_num);
 481
 482     ret = (gauge_t *) malloc (ce->values_num * sizeof (gauge_t));
 483     if (ret == NULL)
 484     {
 485       ERROR ("uc_get_rate: malloc failed.");
 486     }
 487     else
 488     {
 489       memcpy (ret, ce->values_gauge, ce->values_num * sizeof (gauge_t));
 490     }
 491   }
 492
 493   pthread_mutex_unlock (&cache_lock);
 494
 495   return (ret);
 496 } /* gauge_t *uc_get_rate */
 497
 498 int uc_get_state (const data_set_t *ds, const value_list_t *vl)
 499 {
 500   char name[6 * DATA_MAX_NAME_LEN];
 501   cache_entry_t *ce = NULL;
 502   int ret = STATE_ERROR;
 503
 504   if (FORMAT_VL (name, sizeof (name), vl, ds) != 0)
 505   {
 506     ERROR ("uc_get_state: FORMAT_VL failed.");
 507     return (STATE_ERROR);
 508   }
 509
 510   pthread_mutex_lock (&cache_lock);
 511
 512   if (c_avl_get (cache_tree, name, (void *) &ce) == 0)
 513   {
 514     assert (ce != NULL);
 515     ret = ce->state;
 516   }
 517
 518   pthread_mutex_unlock (&cache_lock);
 519
 520   return (ret);
 521 } /* int uc_get_state */
 522
 523 int uc_set_state (const data_set_t *ds, const value_list_t *vl, int state)
 524 {
 525   char name[6 * DATA_MAX_NAME_LEN];
 526   cache_entry_t *ce = NULL;
 527   int ret = -1;
 528
 529   if (state < STATE_OKAY)
 530     state = STATE_OKAY;
 531   if (state > STATE_ERROR)
 532     state = STATE_ERROR;
 533
 534   if (FORMAT_VL (name, sizeof (name), vl, ds) != 0)
 535   {
 536     ERROR ("uc_get_state: FORMAT_VL failed.");
 537     return (STATE_ERROR);
 538   }
 539
 540   pthread_mutex_lock (&cache_lock);
 541
 542   if (c_avl_get (cache_tree, name, (void *) &ce) == 0)
 543   {
 544     assert (ce != NULL);
 545     ret = ce->state;
 546     ce->state = state;
 547   }
 548
 549   pthread_mutex_unlock (&cache_lock);
 550
 551   return (ret);
 552 } /* int uc_set_state */
 553 /* vim: set sw=2 ts=8 sts=2 tw=78 : */