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