src/utils_rrdcreate.c

   1 /**
   2  * collectd - src/utils_rrdcreate.c
   3  * Copyright (C) 2006-2013  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 collectd.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 struct srrd_create_args_s
  30 {
  31   char *filename;
  32   unsigned long pdp_step;
  33   time_t last_up;
  34   int argc;
  35   char **argv;
  36 };
  37 typedef struct srrd_create_args_s srrd_create_args_t;
  38
  39 struct async_create_file_s;
  40 typedef struct async_create_file_s async_create_file_t;
  41 struct async_create_file_s
  42 {
  43   char *filename;
  44   async_create_file_t *next;
  45 };
  46
  47 /*
  48  * Private variables
  49  */
  50 static int rra_timespans[] =
  51 {
  52   3600,
  53   86400,
  54   604800,
  55   2678400,
  56   31622400
  57 };
  58 static int rra_timespans_num = STATIC_ARRAY_SIZE (rra_timespans);
  59
  60 static char *rra_types[] =
  61 {
  62   "AVERAGE",
  63   "MIN",
  64   "MAX"
  65 };
  66 static int rra_types_num = STATIC_ARRAY_SIZE (rra_types);
  67
  68 #if !defined(HAVE_THREADSAFE_LIBRRD) || !HAVE_THREADSAFE_LIBRRD
  69 static pthread_mutex_t librrd_lock = PTHREAD_MUTEX_INITIALIZER;
  70 #endif
  71
  72 static async_create_file_t *async_creation_list = NULL;
  73 static pthread_mutex_t async_creation_lock = PTHREAD_MUTEX_INITIALIZER;
  74
  75 /*
  76  * Private functions
  77  */
  78 static void rra_free (int rra_num, char **rra_def) /* {{{ */
  79 {
  80   int i;
  81
  82   for (i = 0; i < rra_num; i++)
  83   {
  84     sfree (rra_def[i]);
  85   }
  86   sfree (rra_def);
  87 } /* }}} void rra_free */
  88
  89 static void srrd_create_args_destroy (srrd_create_args_t *args)
  90 {
  91   if (args == NULL)
  92     return;
  93
  94   sfree (args->filename);
  95   if (args->argv != NULL)
  96   {
  97     int i;
  98     for (i = 0; i < args->argc; i++)
  99       sfree (args->argv[i]);
 100     sfree (args->argv);
 101   }
 102   sfree (args);
 103 } /* void srrd_create_args_destroy */
 104
 105 static srrd_create_args_t *srrd_create_args_create (const char *filename,
 106     unsigned long pdp_step, time_t last_up,
 107     int argc, const char **argv)
 108 {
 109   srrd_create_args_t *args;
 110
 111   args = malloc (sizeof (*args));
 112   if (args == NULL)
 113   {
 114     ERROR ("srrd_create_args_create: malloc failed.");
 115     return (NULL);
 116   }
 117   memset (args, 0, sizeof (*args));
 118   args->filename = NULL;
 119   args->pdp_step = pdp_step;
 120   args->last_up = last_up;
 121   args->argv = NULL;
 122
 123   args->filename = strdup (filename);
 124   if (args->filename == NULL)
 125   {
 126     ERROR ("srrd_create_args_create: strdup failed.");
 127     srrd_create_args_destroy (args);
 128     return (NULL);
 129   }
 130
 131   args->argv = calloc ((size_t) (argc + 1), sizeof (*args->argv));
 132   if (args->argv == NULL)
 133   {
 134     ERROR ("srrd_create_args_create: calloc failed.");
 135     srrd_create_args_destroy (args);
 136     return (NULL);
 137   }
 138
 139   for (args->argc = 0; args->argc < argc; args->argc++)
 140   {
 141     args->argv[args->argc] = strdup (argv[args->argc]);
 142     if (args->argv[args->argc] == NULL)
 143     {
 144       ERROR ("srrd_create_args_create: strdup failed.");
 145       srrd_create_args_destroy (args);
 146       return (NULL);
 147     }
 148   }
 149   assert (args->argc == argc);
 150   args->argv[args->argc] = NULL;
 151
 152   return (args);
 153 } /* srrd_create_args_t *srrd_create_args_create */
 154
 155 /* * * * * * * * * *
 156  * WARNING:  Magic *
 157  * * * * * * * * * */
 158 static int rra_get (char ***ret, const value_list_t *vl, /* {{{ */
 159     const rrdcreate_config_t *cfg)
 160 {
 161   char **rra_def;
 162   int rra_num;
 163
 164   int *rts;
 165   int  rts_num;
 166
 167   int rra_max;
 168
 169   int span;
 170
 171   int cdp_num;
 172   int cdp_len;
 173   int i, j;
 174
 175   char buffer[128];
 176
 177   /* The stepsize we use here: If it is user-set, use it. If not, use the
 178    * interval of the value-list. */
 179   int ss;
 180
 181   if (cfg->rrarows <= 0)
 182   {
 183     *ret = NULL;
 184     return (-1);
 185   }
 186
 187   if ((cfg->xff < 0) || (cfg->xff >= 1.0))
 188   {
 189     *ret = NULL;
 190     return (-1);
 191   }
 192
 193   if (cfg->stepsize > 0)
 194     ss = cfg->stepsize;
 195   else
 196     ss = (int) CDTIME_T_TO_TIME_T (vl->interval);
 197   if (ss <= 0)
 198   {
 199     *ret = NULL;
 200     return (-1);
 201   }
 202
 203   /* Use the configured timespans or fall back to the built-in defaults */
 204   if (cfg->timespans_num != 0)
 205   {
 206     rts = cfg->timespans;
 207     rts_num = cfg->timespans_num;
 208   }
 209   else
 210   {
 211     rts = rra_timespans;
 212     rts_num = rra_timespans_num;
 213   }
 214
 215   rra_max = rts_num * rra_types_num;
 216
 217   if ((rra_def = (char **) malloc ((rra_max + 1) * sizeof (char *))) == NULL)
 218     return (-1);
 219   memset (rra_def, '\0', (rra_max + 1) * sizeof (char *));
 220   rra_num = 0;
 221
 222   cdp_len = 0;
 223   for (i = 0; i < rts_num; i++)
 224   {
 225     span = rts[i];
 226
 227     if ((span / ss) < cfg->rrarows)
 228       span = ss * cfg->rrarows;
 229
 230     if (cdp_len == 0)
 231       cdp_len = 1;
 232     else
 233       cdp_len = (int) floor (((double) span)
 234           / ((double) (cfg->rrarows * ss)));
 235
 236     cdp_num = (int) ceil (((double) span)
 237         / ((double) (cdp_len * ss)));
 238
 239     for (j = 0; j < rra_types_num; j++)
 240     {
 241       int status;
 242
 243       if (rra_num >= rra_max)
 244         break;
 245
 246       status = ssnprintf (buffer, sizeof (buffer), "RRA:%s:%.10f:%u:%u",
 247           rra_types[j], cfg->xff, cdp_len, cdp_num);
 248
 249       if ((status < 0) || ((size_t) status >= sizeof (buffer)))
 250       {
 251         ERROR ("rra_get: Buffer would have been truncated.");
 252         continue;
 253       }
 254
 255       rra_def[rra_num++] = sstrdup (buffer);
 256     }
 257   }
 258
 259   *ret = rra_def;
 260   return (rra_num);
 261 } /* }}} int rra_get */
 262
 263 static void ds_free (int ds_num, char **ds_def) /* {{{ */
 264 {
 265   int i;
 266
 267   for (i = 0; i < ds_num; i++)
 268     if (ds_def[i] != NULL)
 269       free (ds_def[i]);
 270   free (ds_def);
 271 } /* }}} void ds_free */
 272
 273 static int ds_get (char ***ret, /* {{{ */
 274     const data_set_t *ds, const value_list_t *vl,
 275     const rrdcreate_config_t *cfg)
 276 {
 277   char **ds_def;
 278   int ds_num;
 279
 280   char min[32];
 281   char max[32];
 282   char buffer[128];
 283
 284   ds_def = (char **) malloc (ds->ds_num * sizeof (char *));
 285   if (ds_def == NULL)
 286   {
 287     char errbuf[1024];
 288     ERROR ("rrdtool plugin: malloc failed: %s",
 289         sstrerror (errno, errbuf, sizeof (errbuf)));
 290     return (-1);
 291   }
 292   memset (ds_def, '\0', ds->ds_num * sizeof (char *));
 293
 294   for (ds_num = 0; ds_num < ds->ds_num; ds_num++)
 295   {
 296     data_source_t *d = ds->ds + ds_num;
 297     char *type;
 298     int status;
 299
 300     ds_def[ds_num] = NULL;
 301
 302     if (d->type == DS_TYPE_COUNTER)
 303       type = "COUNTER";
 304     else if (d->type == DS_TYPE_GAUGE)
 305       type = "GAUGE";
 306     else if (d->type == DS_TYPE_DERIVE)
 307       type = "DERIVE";
 308     else if (d->type == DS_TYPE_ABSOLUTE)
 309       type = "ABSOLUTE";
 310     else
 311     {
 312       ERROR ("rrdtool plugin: Unknown DS type: %i",
 313           d->type);
 314       break;
 315     }
 316
 317     if (isnan (d->min))
 318     {
 319       sstrncpy (min, "U", sizeof (min));
 320     }
 321     else
 322       ssnprintf (min, sizeof (min), "%f", d->min);
 323
 324     if (isnan (d->max))
 325     {
 326       sstrncpy (max, "U", sizeof (max));
 327     }
 328     else
 329       ssnprintf (max, sizeof (max), "%f", d->max);
 330
 331     status = ssnprintf (buffer, sizeof (buffer),
 332         "DS:%s:%s:%i:%s:%s",
 333         d->name, type,
 334         (cfg->heartbeat > 0)
 335         ? cfg->heartbeat
 336         : (int) CDTIME_T_TO_TIME_T (2 * vl->interval),
 337         min, max);
 338     if ((status < 1) || ((size_t) status >= sizeof (buffer)))
 339       break;
 340
 341     ds_def[ds_num] = sstrdup (buffer);
 342   } /* for ds_num = 0 .. ds->ds_num */
 343
 344   if (ds_num != ds->ds_num)
 345   {
 346     ds_free (ds_num, ds_def);
 347     return (-1);
 348   }
 349
 350   *ret = ds_def;
 351   return (ds_num);
 352 } /* }}} int ds_get */
 353
 354 #if HAVE_THREADSAFE_LIBRRD
 355 static int srrd_create (const char *filename, /* {{{ */
 356     unsigned long pdp_step, time_t last_up,
 357     int argc, const char **argv)
 358 {
 359   int status;
 360   char *filename_copy;
 361
 362   if ((filename == NULL) || (argv == NULL))
 363     return (-EINVAL);
 364
 365   /* Some versions of librrd don't have the `const' qualifier for the first
 366    * argument, so we have to copy the pointer here to avoid warnings. It sucks,
 367    * but what else can we do? :(  -octo */
 368   filename_copy = strdup (filename);
 369   if (filename_copy == NULL)
 370   {
 371     ERROR ("srrd_create: strdup failed.");
 372     return (-ENOMEM);
 373   }
 374
 375   optind = 0; /* bug in librrd? */
 376   rrd_clear_error ();
 377
 378   status = rrd_create_r (filename_copy, pdp_step, last_up,
 379       argc, (void *) argv);
 380
 381   if (status != 0)
 382   {
 383     WARNING ("rrdtool plugin: rrd_create_r (%s) failed: %s",
 384         filename, rrd_get_error ());
 385   }
 386
 387   sfree (filename_copy);
 388
 389   return (status);
 390 } /* }}} int srrd_create */
 391 /* #endif HAVE_THREADSAFE_LIBRRD */
 392
 393 #else /* !HAVE_THREADSAFE_LIBRRD */
 394 static int srrd_create (const char *filename, /* {{{ */
 395     unsigned long pdp_step, time_t last_up,
 396     int argc, const char **argv)
 397 {
 398   int status;
 399
 400   int new_argc;
 401   char **new_argv;
 402
 403   char pdp_step_str[16];
 404   char last_up_str[16];
 405
 406   new_argc = 6 + argc;
 407   new_argv = (char **) malloc ((new_argc + 1) * sizeof (char *));
 408   if (new_argv == NULL)
 409   {
 410     ERROR ("rrdtool plugin: malloc failed.");
 411     return (-1);
 412   }
 413
 414   if (last_up == 0)
 415     last_up = time (NULL) - 10;
 416
 417   ssnprintf (pdp_step_str, sizeof (pdp_step_str), "%lu", pdp_step);
 418   ssnprintf (last_up_str, sizeof (last_up_str), "%lu", (unsigned long) last_up);
 419
 420   new_argv[0] = "create";
 421   new_argv[1] = (void *) filename;
 422   new_argv[2] = "-s";
 423   new_argv[3] = pdp_step_str;
 424   new_argv[4] = "-b";
 425   new_argv[5] = last_up_str;
 426
 427   memcpy (new_argv + 6, argv, argc * sizeof (char *));
 428   new_argv[new_argc] = NULL;
 429
 430   pthread_mutex_lock (&librrd_lock);
 431   optind = 0; /* bug in librrd? */
 432   rrd_clear_error ();
 433
 434   status = rrd_create (new_argc, new_argv);
 435   pthread_mutex_unlock (&librrd_lock);
 436
 437   if (status != 0)
 438   {
 439     WARNING ("rrdtool plugin: rrd_create (%s) failed: %s",
 440         filename, rrd_get_error ());
 441   }
 442
 443   sfree (new_argv);
 444
 445   return (status);
 446 } /* }}} int srrd_create */
 447 #endif /* !HAVE_THREADSAFE_LIBRRD */
 448
 449 static int lock_file (char const *filename) /* {{{ */
 450 {
 451   async_create_file_t *ptr;
 452   struct stat sb;
 453   int status;
 454
 455   pthread_mutex_lock (&async_creation_lock);
 456
 457   for (ptr = async_creation_list; ptr != NULL; ptr = ptr->next)
 458     if (strcmp (filename, ptr->filename) == 0)
 459       break;
 460
 461   if (ptr != NULL)
 462   {
 463     pthread_mutex_unlock (&async_creation_lock);
 464     return (EEXIST);
 465   }
 466
 467   status = stat (filename, &sb);
 468   if ((status == 0) || (errno != ENOENT))
 469   {
 470     pthread_mutex_unlock (&async_creation_lock);
 471     return (EEXIST);
 472   }
 473
 474   ptr = malloc (sizeof (*ptr));
 475   if (ptr == NULL)
 476   {
 477     pthread_mutex_unlock (&async_creation_lock);
 478     return (ENOMEM);
 479   }
 480
 481   ptr->filename = strdup (filename);
 482   if (ptr->filename == NULL)
 483   {
 484     pthread_mutex_unlock (&async_creation_lock);
 485     sfree (ptr);
 486     return (ENOMEM);
 487   }
 488
 489   ptr->next = async_creation_list;
 490   async_creation_list = ptr;
 491
 492   pthread_mutex_unlock (&async_creation_lock);
 493
 494   return (0);
 495 } /* }}} int lock_file */
 496
 497 static int unlock_file (char const *filename) /* {{{ */
 498 {
 499   async_create_file_t *this;
 500   async_create_file_t *prev;
 501
 502
 503   pthread_mutex_lock (&async_creation_lock);
 504
 505   prev = NULL;
 506   for (this = async_creation_list; this != NULL; this = this->next)
 507   {
 508     if (strcmp (filename, this->filename) == 0)
 509       break;
 510     prev = this;
 511   }
 512
 513   if (this == NULL)
 514   {
 515     pthread_mutex_unlock (&async_creation_lock);
 516     return (ENOENT);
 517   }
 518
 519   if (prev == NULL)
 520   {
 521     assert (this == async_creation_list);
 522     async_creation_list = this->next;
 523   }
 524   else
 525   {
 526     assert (this == prev->next);
 527     prev->next = this->next;
 528   }
 529   this->next = NULL;
 530
 531   pthread_mutex_unlock (&async_creation_lock);
 532
 533   sfree (this->filename);
 534   sfree (this);
 535
 536   return (0);
 537 } /* }}} int unlock_file */
 538
 539 static void *srrd_create_thread (void *targs) /* {{{ */
 540 {
 541   srrd_create_args_t *args = targs;
 542   char tmpfile[PATH_MAX];
 543   int status;
 544
 545   status = lock_file (args->filename);
 546   if (status != 0)
 547   {
 548     if (status == EEXIST)
 549       NOTICE ("srrd_create_thread: File \"%s\" is already being created.",
 550           args->filename);
 551     else
 552       ERROR ("srrd_create_thread: Unable to lock file \"%s\".",
 553           args->filename);
 554     srrd_create_args_destroy (args);
 555     return (0);
 556   }
 557
 558   ssnprintf (tmpfile, sizeof (tmpfile), "%s.async", args->filename);
 559
 560   status = srrd_create (tmpfile, args->pdp_step, args->last_up,
 561       args->argc, (void *) args->argv);
 562   if (status != 0)
 563   {
 564     WARNING ("srrd_create_thread: srrd_create (%s) returned status %i.",
 565         args->filename, status);
 566     unlink (tmpfile);
 567     unlock_file (args->filename);
 568     srrd_create_args_destroy (args);
 569     return (0);
 570   }
 571
 572   status = rename (tmpfile, args->filename);
 573   if (status != 0)
 574   {
 575     char errbuf[1024];
 576     ERROR ("srrd_create_thread: rename (\"%s\", \"%s\") failed: %s",
 577         tmpfile, args->filename,
 578         sstrerror (errno, errbuf, sizeof (errbuf)));
 579     unlink (tmpfile);
 580     unlock_file (args->filename);
 581     srrd_create_args_destroy (args);
 582     return (0);
 583   }
 584
 585   DEBUG ("srrd_create_thread: Successfully created RRD file \"%s\".",
 586       args->filename);
 587
 588   unlock_file (args->filename);
 589   srrd_create_args_destroy (args);
 590
 591   return (0);
 592 } /* }}} void *srrd_create_thread */
 593
 594 static int srrd_create_async (const char *filename, /* {{{ */
 595     unsigned long pdp_step, time_t last_up,
 596     int argc, const char **argv)
 597 {
 598   srrd_create_args_t *args;
 599   pthread_t thread;
 600   pthread_attr_t attr;
 601   int status;
 602
 603   DEBUG ("srrd_create_async: Creating \"%s\" in the background.", filename);
 604
 605   args = srrd_create_args_create (filename, pdp_step, last_up, argc, argv);
 606   if (args == NULL)
 607     return (-1);
 608
 609   status = pthread_attr_init (&attr);
 610   if (status != 0)
 611   {
 612     srrd_create_args_destroy (args);
 613     return (-1);
 614   }
 615
 616   status = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 617   if (status != 0)
 618   {
 619     pthread_attr_destroy (&attr);
 620     srrd_create_args_destroy (args);
 621     return (-1);
 622   }
 623
 624   status = pthread_create (&thread, &attr, srrd_create_thread, args);
 625   if (status != 0)
 626   {
 627     char errbuf[1024];
 628     ERROR ("srrd_create_async: pthread_create failed: %s",
 629         sstrerror (status, errbuf, sizeof (errbuf)));
 630     pthread_attr_destroy (&attr);
 631     srrd_create_args_destroy (args);
 632     return (status);
 633   }
 634
 635   pthread_attr_destroy (&attr);
 636   /* args is freed in srrd_create_thread(). */
 637   return (0);
 638 } /* }}} int srrd_create_async */
 639
 640 /*
 641  * Public functions
 642  */
 643 int cu_rrd_create_file (const char *filename, /* {{{ */
 644     const data_set_t *ds, const value_list_t *vl,
 645     const rrdcreate_config_t *cfg)
 646 {
 647   char **argv;
 648   int argc;
 649   char **rra_def;
 650   int rra_num;
 651   char **ds_def;
 652   int ds_num;
 653   int status = 0;
 654   time_t last_up;
 655   unsigned long stepsize;
 656
 657   if (check_create_dir (filename))
 658     return (-1);
 659
 660   if ((rra_num = rra_get (&rra_def, vl, cfg)) < 1)
 661   {
 662     ERROR ("cu_rrd_create_file failed: Could not calculate RRAs");
 663     return (-1);
 664   }
 665
 666   if ((ds_num = ds_get (&ds_def, ds, vl, cfg)) < 1)
 667   {
 668     ERROR ("cu_rrd_create_file failed: Could not calculate DSes");
 669     return (-1);
 670   }
 671
 672   argc = ds_num + rra_num;
 673
 674   if ((argv = (char **) malloc (sizeof (char *) * (argc + 1))) == NULL)
 675   {
 676     char errbuf[1024];
 677     ERROR ("cu_rrd_create_file failed: %s",
 678         sstrerror (errno, errbuf, sizeof (errbuf)));
 679     return (-1);
 680   }
 681
 682   memcpy (argv, ds_def, ds_num * sizeof (char *));
 683   memcpy (argv + ds_num, rra_def, rra_num * sizeof (char *));
 684   argv[ds_num + rra_num] = NULL;
 685
 686   last_up = CDTIME_T_TO_TIME_T (vl->time);
 687   if (last_up <= 0)
 688     last_up = time (NULL);
 689   last_up -= 1;
 690
 691   if (cfg->stepsize > 0)
 692     stepsize = cfg->stepsize;
 693   else
 694     stepsize = (unsigned long) CDTIME_T_TO_TIME_T (vl->interval);
 695
 696   if (cfg->async)
 697   {
 698     status = srrd_create_async (filename, stepsize, last_up,
 699         argc, (const char **) argv);
 700     if (status != 0)
 701       WARNING ("cu_rrd_create_file: srrd_create_async (%s) "
 702           "returned status %i.",
 703           filename, status);
 704   }
 705   else /* synchronous */
 706   {
 707     status = lock_file (filename);
 708     if (status != 0)
 709     {
 710       if (status == EEXIST)
 711         NOTICE ("cu_rrd_create_file: File \"%s\" is already being created.",
 712             filename);
 713       else
 714         ERROR ("cu_rrd_create_file: Unable to lock file \"%s\".",
 715             filename);
 716     }
 717     else
 718     {
 719       status = srrd_create (filename, stepsize, last_up,
 720           argc, (const char **) argv);
 721
 722       if (status != 0)
 723       {
 724         WARNING ("cu_rrd_create_file: srrd_create (%s) returned status %i.",
 725             filename, status);
 726       }
 727       else
 728       {
 729         DEBUG ("cu_rrd_create_file: Successfully created RRD file \"%s\".",
 730             filename);
 731       }
 732       unlock_file (filename);
 733     }
 734   }
 735
 736   free (argv);
 737   ds_free (ds_num, ds_def);
 738   rra_free (rra_num, rra_def);
 739
 740   return (status);
 741 } /* }}} int cu_rrd_create_file */
 742
 743 /* vim: set sw=2 sts=2 et fdm=marker : */