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 **/
22 #include "collectd.h"
23 #include "common.h"
24 #include "utils_rrdcreate.h"
26 #include <pthread.h>
27 #include <rrd.h>
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;
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 };
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);
60 static char *rra_types[] =
61 {
62 "AVERAGE",
63 "MIN",
64 "MAX"
65 };
66 static int rra_types_num = STATIC_ARRAY_SIZE (rra_types);
68 #if !defined(HAVE_THREADSAFE_LIBRRD) || !HAVE_THREADSAFE_LIBRRD
69 static pthread_mutex_t librrd_lock = PTHREAD_MUTEX_INITIALIZER;
70 #endif
72 static async_create_file_t *async_creation_list = NULL;
73 static pthread_mutex_t async_creation_lock = PTHREAD_MUTEX_INITIALIZER;
75 /*
76 * Private functions
77 */
78 static void rra_free (int rra_num, char **rra_def) /* {{{ */
79 {
80 int i;
82 for (i = 0; i < rra_num; i++)
83 {
84 sfree (rra_def[i]);
85 }
86 sfree (rra_def);
87 } /* }}} void rra_free */
89 static void srrd_create_args_destroy (srrd_create_args_t *args)
90 {
91 if (args == NULL)
92 return;
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 */
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;
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;
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 }
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 }
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;
152 return (args);
153 } /* srrd_create_args_t *srrd_create_args_create */
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;
164 int *rts;
165 int rts_num;
167 int rra_max;
169 int cdp_num;
170 int cdp_len;
171 int i, j;
173 /* The stepsize we use here: If it is user-set, use it. If not, use the
174 * interval of the value-list. */
175 int ss;
177 if (cfg->rrarows <= 0)
178 {
179 *ret = NULL;
180 return (-1);
181 }
183 if ((cfg->xff < 0) || (cfg->xff >= 1.0))
184 {
185 *ret = NULL;
186 return (-1);
187 }
189 if (cfg->stepsize > 0)
190 ss = cfg->stepsize;
191 else
192 ss = (int) CDTIME_T_TO_TIME_T (vl->interval);
193 if (ss <= 0)
194 {
195 *ret = NULL;
196 return (-1);
197 }
199 /* Use the configured timespans or fall back to the built-in defaults */
200 if (cfg->timespans_num != 0)
201 {
202 rts = cfg->timespans;
203 rts_num = cfg->timespans_num;
204 }
205 else
206 {
207 rts = rra_timespans;
208 rts_num = rra_timespans_num;
209 }
211 rra_max = rts_num * rra_types_num;
212 assert (rra_max > 0);
214 if ((rra_def = malloc ((rra_max + 1) * sizeof (*rra_def))) == NULL)
215 return (-1);
216 memset (rra_def, 0, (rra_max + 1) * sizeof (*rra_def));
217 rra_num = 0;
219 cdp_len = 0;
220 for (i = 0; i < rts_num; i++)
221 {
222 int span = rts[i];
224 if ((span / ss) < cfg->rrarows)
225 span = ss * cfg->rrarows;
227 if (cdp_len == 0)
228 cdp_len = 1;
229 else
230 cdp_len = (int) floor (((double) span)
231 / ((double) (cfg->rrarows * ss)));
233 cdp_num = (int) ceil (((double) span)
234 / ((double) (cdp_len * ss)));
236 for (j = 0; j < rra_types_num; j++)
237 {
238 char buffer[128];
239 int status;
241 if (rra_num >= rra_max)
242 break;
244 status = ssnprintf (buffer, sizeof (buffer), "RRA:%s:%.10f:%u:%u",
245 rra_types[j], cfg->xff, cdp_len, cdp_num);
247 if ((status < 0) || ((size_t) status >= sizeof (buffer)))
248 {
249 ERROR ("rra_get: Buffer would have been truncated.");
250 continue;
251 }
253 rra_def[rra_num++] = sstrdup (buffer);
254 }
255 }
257 if (rra_num <= 0)
258 {
259 sfree (rra_def);
260 return (0);
261 }
263 *ret = rra_def;
264 return (rra_num);
265 } /* }}} int rra_get */
267 static void ds_free (int ds_num, char **ds_def) /* {{{ */
268 {
269 int i;
271 for (i = 0; i < ds_num; i++)
272 if (ds_def[i] != NULL)
273 free (ds_def[i]);
274 free (ds_def);
275 } /* }}} void ds_free */
277 static int ds_get (char ***ret, /* {{{ */
278 const data_set_t *ds, const value_list_t *vl,
279 const rrdcreate_config_t *cfg)
280 {
281 char **ds_def;
282 int ds_num;
284 char min[32];
285 char max[32];
286 char buffer[128];
288 assert (ds->ds_num > 0);
290 ds_def = malloc (ds->ds_num * sizeof (*ds_def));
291 if (ds_def == NULL)
292 {
293 char errbuf[1024];
294 ERROR ("rrdtool plugin: malloc failed: %s",
295 sstrerror (errno, errbuf, sizeof (errbuf)));
296 return (-1);
297 }
298 memset (ds_def, 0, ds->ds_num * sizeof (*ds_def));
300 for (ds_num = 0; ds_num < ds->ds_num; ds_num++)
301 {
302 data_source_t *d = ds->ds + ds_num;
303 char *type;
304 int status;
306 ds_def[ds_num] = NULL;
308 if (d->type == DS_TYPE_COUNTER)
309 type = "COUNTER";
310 else if (d->type == DS_TYPE_GAUGE)
311 type = "GAUGE";
312 else if (d->type == DS_TYPE_DERIVE)
313 type = "DERIVE";
314 else if (d->type == DS_TYPE_ABSOLUTE)
315 type = "ABSOLUTE";
316 else
317 {
318 ERROR ("rrdtool plugin: Unknown DS type: %i",
319 d->type);
320 break;
321 }
323 if (isnan (d->min))
324 {
325 sstrncpy (min, "U", sizeof (min));
326 }
327 else
328 ssnprintf (min, sizeof (min), "%f", d->min);
330 if (isnan (d->max))
331 {
332 sstrncpy (max, "U", sizeof (max));
333 }
334 else
335 ssnprintf (max, sizeof (max), "%f", d->max);
337 status = ssnprintf (buffer, sizeof (buffer),
338 "DS:%s:%s:%i:%s:%s",
339 d->name, type,
340 (cfg->heartbeat > 0)
341 ? cfg->heartbeat
342 : (int) CDTIME_T_TO_TIME_T (2 * vl->interval),
343 min, max);
344 if ((status < 1) || ((size_t) status >= sizeof (buffer)))
345 break;
347 ds_def[ds_num] = sstrdup (buffer);
348 } /* for ds_num = 0 .. ds->ds_num */
350 if (ds_num != ds->ds_num)
351 {
352 ds_free (ds_num, ds_def);
353 return (-1);
354 }
356 if (ds_num <= 0)
357 {
358 sfree (ds_def);
359 return (0);
360 }
362 *ret = ds_def;
363 return (ds_num);
364 } /* }}} int ds_get */
366 #if HAVE_THREADSAFE_LIBRRD
367 static int srrd_create (const char *filename, /* {{{ */
368 unsigned long pdp_step, time_t last_up,
369 int argc, const char **argv)
370 {
371 int status;
372 char *filename_copy;
374 if ((filename == NULL) || (argv == NULL))
375 return (-EINVAL);
377 /* Some versions of librrd don't have the `const' qualifier for the first
378 * argument, so we have to copy the pointer here to avoid warnings. It sucks,
379 * but what else can we do? :( -octo */
380 filename_copy = strdup (filename);
381 if (filename_copy == NULL)
382 {
383 ERROR ("srrd_create: strdup failed.");
384 return (-ENOMEM);
385 }
387 optind = 0; /* bug in librrd? */
388 rrd_clear_error ();
390 status = rrd_create_r (filename_copy, pdp_step, last_up,
391 argc, (void *) argv);
393 if (status != 0)
394 {
395 WARNING ("rrdtool plugin: rrd_create_r (%s) failed: %s",
396 filename, rrd_get_error ());
397 }
399 sfree (filename_copy);
401 return (status);
402 } /* }}} int srrd_create */
403 /* #endif HAVE_THREADSAFE_LIBRRD */
405 #else /* !HAVE_THREADSAFE_LIBRRD */
406 static int srrd_create (const char *filename, /* {{{ */
407 unsigned long pdp_step, time_t last_up,
408 int argc, const char **argv)
409 {
410 int status;
412 int new_argc;
413 char **new_argv;
415 char pdp_step_str[16];
416 char last_up_str[16];
418 new_argc = 6 + argc;
419 new_argv = (char **) malloc ((new_argc + 1) * sizeof (char *));
420 if (new_argv == NULL)
421 {
422 ERROR ("rrdtool plugin: malloc failed.");
423 return (-1);
424 }
426 if (last_up == 0)
427 last_up = time (NULL) - 10;
429 ssnprintf (pdp_step_str, sizeof (pdp_step_str), "%lu", pdp_step);
430 ssnprintf (last_up_str, sizeof (last_up_str), "%lu", (unsigned long) last_up);
432 new_argv[0] = "create";
433 new_argv[1] = (void *) filename;
434 new_argv[2] = "-s";
435 new_argv[3] = pdp_step_str;
436 new_argv[4] = "-b";
437 new_argv[5] = last_up_str;
439 memcpy (new_argv + 6, argv, argc * sizeof (char *));
440 new_argv[new_argc] = NULL;
442 pthread_mutex_lock (&librrd_lock);
443 optind = 0; /* bug in librrd? */
444 rrd_clear_error ();
446 status = rrd_create (new_argc, new_argv);
447 pthread_mutex_unlock (&librrd_lock);
449 if (status != 0)
450 {
451 WARNING ("rrdtool plugin: rrd_create (%s) failed: %s",
452 filename, rrd_get_error ());
453 }
455 sfree (new_argv);
457 return (status);
458 } /* }}} int srrd_create */
459 #endif /* !HAVE_THREADSAFE_LIBRRD */
461 static int lock_file (char const *filename) /* {{{ */
462 {
463 async_create_file_t *ptr;
464 struct stat sb;
465 int status;
467 pthread_mutex_lock (&async_creation_lock);
469 for (ptr = async_creation_list; ptr != NULL; ptr = ptr->next)
470 if (strcmp (filename, ptr->filename) == 0)
471 break;
473 if (ptr != NULL)
474 {
475 pthread_mutex_unlock (&async_creation_lock);
476 return (EEXIST);
477 }
479 status = stat (filename, &sb);
480 if ((status == 0) || (errno != ENOENT))
481 {
482 pthread_mutex_unlock (&async_creation_lock);
483 return (EEXIST);
484 }
486 ptr = malloc (sizeof (*ptr));
487 if (ptr == NULL)
488 {
489 pthread_mutex_unlock (&async_creation_lock);
490 return (ENOMEM);
491 }
493 ptr->filename = strdup (filename);
494 if (ptr->filename == NULL)
495 {
496 pthread_mutex_unlock (&async_creation_lock);
497 sfree (ptr);
498 return (ENOMEM);
499 }
501 ptr->next = async_creation_list;
502 async_creation_list = ptr;
504 pthread_mutex_unlock (&async_creation_lock);
506 return (0);
507 } /* }}} int lock_file */
509 static int unlock_file (char const *filename) /* {{{ */
510 {
511 async_create_file_t *this;
512 async_create_file_t *prev;
515 pthread_mutex_lock (&async_creation_lock);
517 prev = NULL;
518 for (this = async_creation_list; this != NULL; this = this->next)
519 {
520 if (strcmp (filename, this->filename) == 0)
521 break;
522 prev = this;
523 }
525 if (this == NULL)
526 {
527 pthread_mutex_unlock (&async_creation_lock);
528 return (ENOENT);
529 }
531 if (prev == NULL)
532 {
533 assert (this == async_creation_list);
534 async_creation_list = this->next;
535 }
536 else
537 {
538 assert (this == prev->next);
539 prev->next = this->next;
540 }
541 this->next = NULL;
543 pthread_mutex_unlock (&async_creation_lock);
545 sfree (this->filename);
546 sfree (this);
548 return (0);
549 } /* }}} int unlock_file */
551 static void *srrd_create_thread (void *targs) /* {{{ */
552 {
553 srrd_create_args_t *args = targs;
554 char tmpfile[PATH_MAX];
555 int status;
557 status = lock_file (args->filename);
558 if (status != 0)
559 {
560 if (status == EEXIST)
561 NOTICE ("srrd_create_thread: File \"%s\" is already being created.",
562 args->filename);
563 else
564 ERROR ("srrd_create_thread: Unable to lock file \"%s\".",
565 args->filename);
566 srrd_create_args_destroy (args);
567 return (0);
568 }
570 ssnprintf (tmpfile, sizeof (tmpfile), "%s.async", args->filename);
572 status = srrd_create (tmpfile, args->pdp_step, args->last_up,
573 args->argc, (void *) args->argv);
574 if (status != 0)
575 {
576 WARNING ("srrd_create_thread: srrd_create (%s) returned status %i.",
577 args->filename, status);
578 unlink (tmpfile);
579 unlock_file (args->filename);
580 srrd_create_args_destroy (args);
581 return (0);
582 }
584 status = rename (tmpfile, args->filename);
585 if (status != 0)
586 {
587 char errbuf[1024];
588 ERROR ("srrd_create_thread: rename (\"%s\", \"%s\") failed: %s",
589 tmpfile, args->filename,
590 sstrerror (errno, errbuf, sizeof (errbuf)));
591 unlink (tmpfile);
592 unlock_file (args->filename);
593 srrd_create_args_destroy (args);
594 return (0);
595 }
597 DEBUG ("srrd_create_thread: Successfully created RRD file \"%s\".",
598 args->filename);
600 unlock_file (args->filename);
601 srrd_create_args_destroy (args);
603 return (0);
604 } /* }}} void *srrd_create_thread */
606 static int srrd_create_async (const char *filename, /* {{{ */
607 unsigned long pdp_step, time_t last_up,
608 int argc, const char **argv)
609 {
610 srrd_create_args_t *args;
611 pthread_t thread;
612 pthread_attr_t attr;
613 int status;
615 DEBUG ("srrd_create_async: Creating \"%s\" in the background.", filename);
617 args = srrd_create_args_create (filename, pdp_step, last_up, argc, argv);
618 if (args == NULL)
619 return (-1);
621 status = pthread_attr_init (&attr);
622 if (status != 0)
623 {
624 srrd_create_args_destroy (args);
625 return (-1);
626 }
628 status = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
629 if (status != 0)
630 {
631 pthread_attr_destroy (&attr);
632 srrd_create_args_destroy (args);
633 return (-1);
634 }
636 status = pthread_create (&thread, &attr, srrd_create_thread, args);
637 if (status != 0)
638 {
639 char errbuf[1024];
640 ERROR ("srrd_create_async: pthread_create failed: %s",
641 sstrerror (status, errbuf, sizeof (errbuf)));
642 pthread_attr_destroy (&attr);
643 srrd_create_args_destroy (args);
644 return (status);
645 }
647 pthread_attr_destroy (&attr);
648 /* args is freed in srrd_create_thread(). */
649 return (0);
650 } /* }}} int srrd_create_async */
652 /*
653 * Public functions
654 */
655 int cu_rrd_create_file (const char *filename, /* {{{ */
656 const data_set_t *ds, const value_list_t *vl,
657 const rrdcreate_config_t *cfg)
658 {
659 char **argv;
660 int argc;
661 char **rra_def = NULL;
662 int rra_num;
663 char **ds_def = NULL;
664 int ds_num;
665 int status = 0;
666 time_t last_up;
667 unsigned long stepsize;
669 if (check_create_dir (filename))
670 return (-1);
672 if ((rra_num = rra_get (&rra_def, vl, cfg)) < 1)
673 {
674 ERROR ("cu_rrd_create_file failed: Could not calculate RRAs");
675 return (-1);
676 }
678 if ((ds_num = ds_get (&ds_def, ds, vl, cfg)) < 1)
679 {
680 ERROR ("cu_rrd_create_file failed: Could not calculate DSes");
681 rra_free (rra_num, rra_def);
682 return (-1);
683 }
685 argc = ds_num + rra_num;
687 if ((argv = (char **) malloc (sizeof (char *) * (argc + 1))) == NULL)
688 {
689 char errbuf[1024];
690 ERROR ("cu_rrd_create_file failed: %s",
691 sstrerror (errno, errbuf, sizeof (errbuf)));
692 rra_free (rra_num, rra_def);
693 ds_free (ds_num, ds_def);
694 return (-1);
695 }
697 memcpy (argv, ds_def, ds_num * sizeof (char *));
698 memcpy (argv + ds_num, rra_def, rra_num * sizeof (char *));
699 argv[ds_num + rra_num] = NULL;
701 last_up = CDTIME_T_TO_TIME_T (vl->time);
702 if (last_up <= 0)
703 last_up = time (NULL);
704 last_up -= 1;
706 if (cfg->stepsize > 0)
707 stepsize = cfg->stepsize;
708 else
709 stepsize = (unsigned long) CDTIME_T_TO_TIME_T (vl->interval);
711 if (cfg->async)
712 {
713 status = srrd_create_async (filename, stepsize, last_up,
714 argc, (const char **) argv);
715 if (status != 0)
716 WARNING ("cu_rrd_create_file: srrd_create_async (%s) "
717 "returned status %i.",
718 filename, status);
719 }
720 else /* synchronous */
721 {
722 status = lock_file (filename);
723 if (status != 0)
724 {
725 if (status == EEXIST)
726 NOTICE ("cu_rrd_create_file: File \"%s\" is already being created.",
727 filename);
728 else
729 ERROR ("cu_rrd_create_file: Unable to lock file \"%s\".",
730 filename);
731 }
732 else
733 {
734 status = srrd_create (filename, stepsize, last_up,
735 argc, (const char **) argv);
737 if (status != 0)
738 {
739 WARNING ("cu_rrd_create_file: srrd_create (%s) returned status %i.",
740 filename, status);
741 }
742 else
743 {
744 DEBUG ("cu_rrd_create_file: Successfully created RRD file \"%s\".",
745 filename);
746 }
747 unlock_file (filename);
748 }
749 }
751 free (argv);
752 ds_free (ds_num, ds_def);
753 rra_free (rra_num, rra_def);
755 return (status);
756 } /* }}} int cu_rrd_create_file */
758 /* vim: set sw=2 sts=2 et fdm=marker : */