src/utils_rrdcreate.c

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