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       if (rra_num >= rra_max)
 152         break;
 153
 154       if (ssnprintf (buffer, sizeof (buffer), "RRA:%s:%3.1f:%u:%u",
 155             rra_types[j], cfg->xff,
 156             cdp_len, cdp_num) >= sizeof (buffer))
 157       {
 158         ERROR ("rra_get: Buffer would have been truncated.");
 159         continue;
 160       }
 161
 162       rra_def[rra_num++] = sstrdup (buffer);
 163     }
 164   }
 165
 166   *ret = rra_def;
 167   return (rra_num);
 168 } /* }}} int rra_get */
 169
 170 static void ds_free (int ds_num, char **ds_def) /* {{{ */
 171 {
 172   int i;
 173
 174   for (i = 0; i < ds_num; i++)
 175     if (ds_def[i] != NULL)
 176       free (ds_def[i]);
 177   free (ds_def);
 178 } /* }}} void ds_free */
 179
 180 static int ds_get (char ***ret, /* {{{ */
 181     const data_set_t *ds, const value_list_t *vl,
 182     const rrdcreate_config_t *cfg)
 183 {
 184   char **ds_def;
 185   int ds_num;
 186
 187   char min[32];
 188   char max[32];
 189   char buffer[128];
 190
 191   ds_def = (char **) malloc (ds->ds_num * sizeof (char *));
 192   if (ds_def == NULL)
 193   {
 194     char errbuf[1024];
 195     ERROR ("rrdtool plugin: malloc failed: %s",
 196         sstrerror (errno, errbuf, sizeof (errbuf)));
 197     return (-1);
 198   }
 199   memset (ds_def, '\0', ds->ds_num * sizeof (char *));
 200
 201   for (ds_num = 0; ds_num < ds->ds_num; ds_num++)
 202   {
 203     data_source_t *d = ds->ds + ds_num;
 204     char *type;
 205     int status;
 206
 207     ds_def[ds_num] = NULL;
 208
 209     if (d->type == DS_TYPE_COUNTER)
 210       type = "COUNTER";
 211     else if (d->type == DS_TYPE_GAUGE)
 212       type = "GAUGE";
 213     else
 214     {
 215       ERROR ("rrdtool plugin: Unknown DS type: %i",
 216           d->type);
 217       break;
 218     }
 219
 220     if (isnan (d->min))
 221     {
 222       sstrncpy (min, "U", sizeof (min));
 223     }
 224     else
 225       ssnprintf (min, sizeof (min), "%lf", d->min);
 226
 227     if (isnan (d->max))
 228     {
 229       sstrncpy (max, "U", sizeof (max));
 230     }
 231     else
 232       ssnprintf (max, sizeof (max), "%lf", d->max);
 233
 234     status = ssnprintf (buffer, sizeof (buffer),
 235         "DS:%s:%s:%i:%s:%s",
 236         d->name, type,
 237         (cfg->heartbeat > 0) ? cfg->heartbeat : (2 * vl->interval),
 238         min, max);
 239     if ((status < 1) || (status >= sizeof (buffer)))
 240       break;
 241
 242     ds_def[ds_num] = sstrdup (buffer);
 243   } /* for ds_num = 0 .. ds->ds_num */
 244
 245   if (ds_num != ds->ds_num)
 246   {
 247     ds_free (ds_num, ds_def);
 248     return (-1);
 249   }
 250
 251   *ret = ds_def;
 252   return (ds_num);
 253 } /* }}} int ds_get */
 254
 255 #if HAVE_THREADSAFE_LIBRRD
 256 static int srrd_create (const char *filename, /* {{{ */
 257     unsigned long pdp_step, time_t last_up,
 258     int argc, const char **argv)
 259 {
 260   int status;
 261   char *filename_copy;
 262
 263   if ((filename == NULL) || (argv == NULL))
 264     return (-EINVAL);
 265
 266   /* Some versions of librrd don't have the `const' qualifier for the first
 267    * argument, so we have to copy the pointer here to avoid warnings. It sucks,
 268    * but what else can we do? :(  -octo */
 269   filename_copy = strdup (filename);
 270   if (filename_copy == NULL)
 271   {
 272     ERROR ("srrd_create: strdup failed.");
 273     return (-ENOMEM);
 274   }
 275
 276   optind = 0; /* bug in librrd? */
 277   rrd_clear_error ();
 278
 279   status = rrd_create_r (filename_copy, pdp_step, last_up,
 280       argc, (void *) argv);
 281
 282   if (status != 0)
 283   {
 284     WARNING ("rrdtool plugin: rrd_create_r (%s) failed: %s",
 285         filename, rrd_get_error ());
 286   }
 287
 288   sfree (filename_copy);
 289
 290   return (status);
 291 } /* }}} int srrd_create */
 292 /* #endif HAVE_THREADSAFE_LIBRRD */
 293
 294 #else /* !HAVE_THREADSAFE_LIBRRD */
 295 static int srrd_create (const char *filename, /* {{{ */
 296     unsigned long pdp_step, time_t last_up,
 297     int argc, const char **argv)
 298 {
 299   int status;
 300
 301   int new_argc;
 302   char **new_argv;
 303
 304   char pdp_step_str[16];
 305   char last_up_str[16];
 306
 307   new_argc = 6 + argc;
 308   new_argv = (char **) malloc ((new_argc + 1) * sizeof (char *));
 309   if (new_argv == NULL)
 310   {
 311     ERROR ("rrdtool plugin: malloc failed.");
 312     return (-1);
 313   }
 314
 315   if (last_up == 0)
 316     last_up = time (NULL) - 10;
 317
 318   ssnprintf (pdp_step_str, sizeof (pdp_step_str), "%lu", pdp_step);
 319   ssnprintf (last_up_str, sizeof (last_up_str), "%u", (unsigned int) last_up);
 320
 321   new_argv[0] = "create";
 322   new_argv[1] = (void *) filename;
 323   new_argv[2] = "-s";
 324   new_argv[3] = pdp_step_str;
 325   new_argv[4] = "-b";
 326   new_argv[5] = last_up_str;
 327
 328   memcpy (new_argv + 6, argv, argc * sizeof (char *));
 329   new_argv[new_argc] = NULL;
 330
 331   pthread_mutex_lock (&librrd_lock);
 332   optind = 0; /* bug in librrd? */
 333   rrd_clear_error ();
 334
 335   status = rrd_create (new_argc, new_argv);
 336   pthread_mutex_unlock (&librrd_lock);
 337
 338   if (status != 0)
 339   {
 340     WARNING ("rrdtool plugin: rrd_create (%s) failed: %s",
 341         filename, rrd_get_error ());
 342   }
 343
 344   sfree (new_argv);
 345
 346   return (status);
 347 } /* }}} int srrd_create */
 348 #endif /* !HAVE_THREADSAFE_LIBRRD */
 349
 350 /*
 351  * Public functions
 352  */
 353 int cu_rrd_create_file (const char *filename, /* {{{ */
 354     const data_set_t *ds, const value_list_t *vl,
 355     const rrdcreate_config_t *cfg)
 356 {
 357   char **argv;
 358   int argc;
 359   char **rra_def;
 360   int rra_num;
 361   char **ds_def;
 362   int ds_num;
 363   int status = 0;
 364
 365   if (check_create_dir (filename))
 366     return (-1);
 367
 368   if ((rra_num = rra_get (&rra_def, vl, cfg)) < 1)
 369   {
 370     ERROR ("cu_rrd_create_file failed: Could not calculate RRAs");
 371     return (-1);
 372   }
 373
 374   if ((ds_num = ds_get (&ds_def, ds, vl, cfg)) < 1)
 375   {
 376     ERROR ("cu_rrd_create_file failed: Could not calculate DSes");
 377     return (-1);
 378   }
 379
 380   argc = ds_num + rra_num;
 381
 382   if ((argv = (char **) malloc (sizeof (char *) * (argc + 1))) == NULL)
 383   {
 384     char errbuf[1024];
 385     ERROR ("cu_rrd_create_file failed: %s",
 386         sstrerror (errno, errbuf, sizeof (errbuf)));
 387     return (-1);
 388   }
 389
 390   memcpy (argv, ds_def, ds_num * sizeof (char *));
 391   memcpy (argv + ds_num, rra_def, rra_num * sizeof (char *));
 392   argv[ds_num + rra_num] = NULL;
 393
 394   assert (vl->time > 10);
 395   status = srrd_create (filename,
 396       (cfg->stepsize > 0) ? cfg->stepsize : vl->interval,
 397       vl->time - 10,
 398       argc, (const char **) argv);
 399
 400   free (argv);
 401   ds_free (ds_num, ds_def);
 402   rra_free (rra_num, rra_def);
 403
 404   if (status != 0)
 405   {
 406     WARNING ("cu_rrd_create_file: srrd_create (%s) returned status %i.",
 407         filename, status);
 408   }
 409   else
 410   {
 411     DEBUG ("cu_rrd_create_file: Successfully created RRD file \"%s\".",
 412         filename);
 413   }
 414
 415   return (status);
 416 } /* }}} int cu_rrd_create_file */
 417
 418 /* vim: set sw=2 sts=2 et fdm=marker : */