src/utils_rrdcreate.c

   1 /**
   2  * collectd - src/utils_rrdcreate.c
   3  * Copyright (C) 2006-2008  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  * Authors:
  19  *   Florian octo Forster <octo at verplant.org>
  20  **/
  21
  22 #include "collectd.h"
  23 #include "common.h"
  24 #include "utils_rrdcreate.h"
  25
  26 #include <pthread.h>
  27 #include <rrd.h>
  28
  29 /*
  30  * Private variables
  31  */
  32 static int rra_timespans[] =
  33 {
  34   3600,
  35   86400,
  36   604800,
  37   2678400,
  38   31622400
  39 };
  40 static int rra_timespans_num = STATIC_ARRAY_SIZE (rra_timespans);
  41
  42 static char *rra_types[] =
  43 {
  44   "AVERAGE",
  45   "MIN",
  46   "MAX"
  47 };
  48 static int rra_types_num = STATIC_ARRAY_SIZE (rra_types);
  49
  50 #if !defined(HAVE_THREADSAFE_LIBRRD) || !HAVE_THREADSAFE_LIBRRD
  51 static pthread_mutex_t librrd_lock = PTHREAD_MUTEX_INITIALIZER;
  52 #endif
  53
  54 /*
  55  * Private functions
  56  */
  57 static void rra_free (int rra_num, char **rra_def) /* {{{ */
  58 {
  59   int i;
  60
  61   for (i = 0; i < rra_num; i++)
  62   {
  63     sfree (rra_def[i]);
  64   }
  65   sfree (rra_def);
  66 } /* }}} void rra_free */
  67
  68 /* * * * * * * * * *
  69  * WARNING:  Magic *
  70  * * * * * * * * * */
  71 static int rra_get (char ***ret, const value_list_t *vl, /* {{{ */
  72     const rrdcreate_config_t *cfg)
  73 {
  74   char **rra_def;
  75   int rra_num;
  76
  77   int *rts;
  78   int  rts_num;
  79
  80   int rra_max;
  81
  82   int span;
  83
  84   int cdp_num;
  85   int cdp_len;
  86   int i, j;
  87
  88   char buffer[128];
  89
  90   /* The stepsize we use here: If it is user-set, use it. If not, use the
  91    * interval of the value-list. */
  92   int ss;
  93
  94   if (cfg->rrarows <= 0)
  95   {
  96     *ret = NULL;
  97     return (-1);
  98   }
  99
 100   if ((cfg->xff < 0) || (cfg->xff >= 1.0))
 101   {
 102     *ret = NULL;
 103     return (-1);
 104   }
 105
 106   ss = (cfg->stepsize > 0) ? cfg->stepsize : vl->interval;
 107   if (ss <= 0)
 108   {
 109     *ret = NULL;
 110     return (-1);
 111   }
 112
 113   /* Use the configured timespans or fall back to the built-in defaults */
 114   if (cfg->timespans_num != 0)
 115   {
 116     rts = cfg->timespans;
 117     rts_num = cfg->timespans_num;
 118   }
 119   else
 120   {
 121     rts = rra_timespans;
 122     rts_num = rra_timespans_num;
 123   }
 124
 125   rra_max = rts_num * rra_types_num;
 126
 127   if ((rra_def = (char **) malloc ((rra_max + 1) * sizeof (char *))) == NULL)
 128     return (-1);
 129   memset (rra_def, '\0', (rra_max + 1) * sizeof (char *));
 130   rra_num = 0;
 131
 132   cdp_len = 0;
 133   for (i = 0; i < rts_num; i++)
 134   {
 135     span = rts[i];
 136
 137     if ((span / ss) < cfg->rrarows)
 138       span = ss * cfg->rrarows;
 139
 140     if (cdp_len == 0)
 141       cdp_len = 1;
 142     else
 143       cdp_len = (int) floor (((double) span)
 144           / ((double) (cfg->rrarows * ss)));
 145
 146     cdp_num = (int) ceil (((double) span)
 147         / ((double) (cdp_len * ss)));
 148
 149     for (j = 0; j < rra_types_num; j++)
 150     {
 151       int status;
 152
 153       if (rra_num >= rra_max)
 154         break;
 155
 156       status = ssnprintf (buffer, sizeof (buffer), "RRA:%s:%3.1f:%u:%u",
 157           rra_types[j], cfg->xff, cdp_len, cdp_num);
 158
 159       if ((status < 0) || ((size_t) status >= sizeof (buffer)))
 160       {
 161         ERROR ("rra_get: Buffer would have been truncated.");
 162         continue;
 163       }
 164
 165       rra_def[rra_num++] = sstrdup (buffer);
 166     }
 167   }
 168
 169   *ret = rra_def;
 170   return (rra_num);
 171 } /* }}} int rra_get */
 172
 173 static void ds_free (int ds_num, char **ds_def) /* {{{ */
 174 {
 175   int i;
 176
 177   for (i = 0; i < ds_num; i++)
 178     if (ds_def[i] != NULL)
 179       free (ds_def[i]);
 180   free (ds_def);
 181 } /* }}} void ds_free */
 182
 183 static int ds_get (char ***ret, /* {{{ */
 184     const data_set_t *ds, const value_list_t *vl,
 185     const rrdcreate_config_t *cfg)
 186 {
 187   char **ds_def;
 188   int ds_num;
 189
 190   char min[32];
 191   char max[32];
 192   char buffer[128];
 193
 194   ds_def = (char **) malloc (ds->ds_num * sizeof (char *));
 195   if (ds_def == NULL)
 196   {
 197     char errbuf[1024];
 198     ERROR ("rrdtool plugin: malloc failed: %s",
 199         sstrerror (errno, errbuf, sizeof (errbuf)));
 200     return (-1);
 201   }
 202   memset (ds_def, '\0', ds->ds_num * sizeof (char *));
 203
 204   for (ds_num = 0; ds_num < ds->ds_num; ds_num++)
 205   {
 206     data_source_t *d = ds->ds + ds_num;
 207     char *type;
 208     int status;
 209
 210     ds_def[ds_num] = NULL;
 211
 212     if (d->type == DS_TYPE_COUNTER)
 213       type = "COUNTER";
 214     else if (d->type == DS_TYPE_GAUGE)
 215       type = "GAUGE";
 216     else
 217     {
 218       ERROR ("rrdtool plugin: Unknown DS type: %i",
 219           d->type);
 220       break;
 221     }
 222
 223     if (isnan (d->min))
 224     {
 225       sstrncpy (min, "U", sizeof (min));
 226     }
 227     else
 228       ssnprintf (min, sizeof (min), "%lf", d->min);
 229
 230     if (isnan (d->max))
 231     {
 232       sstrncpy (max, "U", sizeof (max));
 233     }
 234     else
 235       ssnprintf (max, sizeof (max), "%lf", d->max);
 236
 237     status = ssnprintf (buffer, sizeof (buffer),
 238         "DS:%s:%s:%i:%s:%s",
 239         d->name, type,
 240         (cfg->heartbeat > 0) ? cfg->heartbeat : (2 * vl->interval),
 241         min, max);
 242     if ((status < 1) || ((size_t) status >= sizeof (buffer)))
 243       break;
 244
 245     ds_def[ds_num] = sstrdup (buffer);
 246   } /* for ds_num = 0 .. ds->ds_num */
 247
 248   if (ds_num != ds->ds_num)
 249   {
 250     ds_free (ds_num, ds_def);
 251     return (-1);
 252   }
 253
 254   *ret = ds_def;
 255   return (ds_num);
 256 } /* }}} int ds_get */
 257
 258 #if HAVE_THREADSAFE_LIBRRD
 259 static int srrd_create (const char *filename, /* {{{ */
 260     unsigned long pdp_step, time_t last_up,
 261     int argc, const char **argv)
 262 {
 263   int status;
 264   char *filename_copy;
 265
 266   if ((filename == NULL) || (argv == NULL))
 267     return (-EINVAL);
 268
 269   /* Some versions of librrd don't have the `const' qualifier for the first
 270    * argument, so we have to copy the pointer here to avoid warnings. It sucks,
 271    * but what else can we do? :(  -octo */
 272   filename_copy = strdup (filename);
 273   if (filename_copy == NULL)
 274   {
 275     ERROR ("srrd_create: strdup failed.");
 276     return (-ENOMEM);
 277   }
 278
 279   optind = 0; /* bug in librrd? */
 280   rrd_clear_error ();
 281
 282   status = rrd_create_r (filename_copy, pdp_step, last_up,
 283       argc, (void *) argv);
 284
 285   if (status != 0)
 286   {
 287     WARNING ("rrdtool plugin: rrd_create_r (%s) failed: %s",
 288         filename, rrd_get_error ());
 289   }
 290
 291   sfree (filename_copy);
 292
 293   return (status);
 294 } /* }}} int srrd_create */
 295 /* #endif HAVE_THREADSAFE_LIBRRD */
 296
 297 #else /* !HAVE_THREADSAFE_LIBRRD */
 298 static int srrd_create (const char *filename, /* {{{ */
 299     unsigned long pdp_step, time_t last_up,
 300     int argc, const char **argv)
 301 {
 302   int status;
 303
 304   int new_argc;
 305   char **new_argv;
 306
 307   char pdp_step_str[16];
 308   char last_up_str[16];
 309
 310   new_argc = 6 + argc;
 311   new_argv = (char **) malloc ((new_argc + 1) * sizeof (char *));
 312   if (new_argv == NULL)
 313   {
 314     ERROR ("rrdtool plugin: malloc failed.");
 315     return (-1);
 316   }
 317
 318   if (last_up == 0)
 319     last_up = time (NULL) - 10;
 320
 321   ssnprintf (pdp_step_str, sizeof (pdp_step_str), "%lu", pdp_step);
 322   ssnprintf (last_up_str, sizeof (last_up_str), "%u", (unsigned int) last_up);
 323
 324   new_argv[0] = "create";
 325   new_argv[1] = (void *) filename;
 326   new_argv[2] = "-s";
 327   new_argv[3] = pdp_step_str;
 328   new_argv[4] = "-b";
 329   new_argv[5] = last_up_str;
 330
 331   memcpy (new_argv + 6, argv, argc * sizeof (char *));
 332   new_argv[new_argc] = NULL;
 333
 334   pthread_mutex_lock (&librrd_lock);
 335   optind = 0; /* bug in librrd? */
 336   rrd_clear_error ();
 337
 338   status = rrd_create (new_argc, new_argv);
 339   pthread_mutex_unlock (&librrd_lock);
 340
 341   if (status != 0)
 342   {
 343     WARNING ("rrdtool plugin: rrd_create (%s) failed: %s",
 344         filename, rrd_get_error ());
 345   }
 346
 347   sfree (new_argv);
 348
 349   return (status);
 350 } /* }}} int srrd_create */
 351 #endif /* !HAVE_THREADSAFE_LIBRRD */
 352
 353 /*
 354  * Public functions
 355  */
 356 int cu_rrd_create_file (const char *filename, /* {{{ */
 357     const data_set_t *ds, const value_list_t *vl,
 358     const rrdcreate_config_t *cfg)
 359 {
 360   char **argv;
 361   int argc;
 362   char **rra_def;
 363   int rra_num;
 364   char **ds_def;
 365   int ds_num;
 366   int status = 0;
 367
 368   if (check_create_dir (filename))
 369     return (-1);
 370
 371   if ((rra_num = rra_get (&rra_def, vl, cfg)) < 1)
 372   {
 373     ERROR ("cu_rrd_create_file failed: Could not calculate RRAs");
 374     return (-1);
 375   }
 376
 377   if ((ds_num = ds_get (&ds_def, ds, vl, cfg)) < 1)
 378   {
 379     ERROR ("cu_rrd_create_file failed: Could not calculate DSes");
 380     return (-1);
 381   }
 382
 383   argc = ds_num + rra_num;
 384
 385   if ((argv = (char **) malloc (sizeof (char *) * (argc + 1))) == NULL)
 386   {
 387     char errbuf[1024];
 388     ERROR ("cu_rrd_create_file failed: %s",
 389         sstrerror (errno, errbuf, sizeof (errbuf)));
 390     return (-1);
 391   }
 392
 393   memcpy (argv, ds_def, ds_num * sizeof (char *));
 394   memcpy (argv + ds_num, rra_def, rra_num * sizeof (char *));
 395   argv[ds_num + rra_num] = NULL;
 396
 397   assert (vl->time > 10);
 398   status = srrd_create (filename,
 399       (cfg->stepsize > 0) ? cfg->stepsize : vl->interval,
 400       vl->time - 10,
 401       argc, (const char **) argv);
 402
 403   free (argv);
 404   ds_free (ds_num, ds_def);
 405   rra_free (rra_num, rra_def);
 406
 407   if (status != 0)
 408   {
 409     WARNING ("cu_rrd_create_file: srrd_create (%s) returned status %i.",
 410         filename, status);
 411   }
 412   else
 413   {
 414     DEBUG ("cu_rrd_create_file: Successfully created RRD file \"%s\".",
 415         filename);
 416   }
 417
 418   return (status);
 419 } /* }}} int cu_rrd_create_file */
 420
 421 /* vim: set sw=2 sts=2 et fdm=marker : */