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 **/
27 #include "collectd.h"
28 #include "common.h"
29 #include "utils_rrdcreate.h"
31 #include <pthread.h>
32 #include <rrd.h>
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;
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 };
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);
65 static char *rra_types[] =
66 {
67 "AVERAGE",
68 "MIN",
69 "MAX"
70 };
71 static int rra_types_num = STATIC_ARRAY_SIZE (rra_types);
73 #if !defined(HAVE_THREADSAFE_LIBRRD) || !HAVE_THREADSAFE_LIBRRD
74 static pthread_mutex_t librrd_lock = PTHREAD_MUTEX_INITIALIZER;
75 #endif
77 static async_create_file_t *async_creation_list = NULL;
78 static pthread_mutex_t async_creation_lock = PTHREAD_MUTEX_INITIALIZER;
80 /*
81 * Private functions
82 */
83 static void rra_free (int rra_num, char **rra_def) /* {{{ */
84 {
85 int i;
87 for (i = 0; i < rra_num; i++)
88 {
89 sfree (rra_def[i]);
90 }
91 sfree (rra_def);
92 } /* }}} void rra_free */
94 static void srrd_create_args_destroy (srrd_create_args_t *args)
95 {
96 if (args == NULL)
97 return;
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 */
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;
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;
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 }
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 }
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;
157 return (args);
158 } /* srrd_create_args_t *srrd_create_args_create */
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;
169 int *rts;
170 int rts_num;
172 int rra_max;
174 int span;
176 int cdp_num;
177 int cdp_len;
178 int i, j;
180 char buffer[128];
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;
186 if (cfg->rrarows <= 0)
187 {
188 *ret = NULL;
189 return (-1);
190 }
192 if ((cfg->xff < 0) || (cfg->xff >= 1.0))
193 {
194 *ret = NULL;
195 return (-1);
196 }
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 }
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 }
220 rra_max = rts_num * rra_types_num;
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;
227 cdp_len = 0;
228 for (i = 0; i < rts_num; i++)
229 {
230 span = rts[i];
232 if ((span / ss) < cfg->rrarows)
233 span = ss * cfg->rrarows;
235 if (cdp_len == 0)
236 cdp_len = 1;
237 else
238 cdp_len = (int) floor (((double) span)
239 / ((double) (cfg->rrarows * ss)));
241 cdp_num = (int) ceil (((double) span)
242 / ((double) (cdp_len * ss)));
244 for (j = 0; j < rra_types_num; j++)
245 {
246 int status;
248 if (rra_num >= rra_max)
249 break;
251 status = ssnprintf (buffer, sizeof (buffer), "RRA:%s:%.10f:%u:%u",
252 rra_types[j], cfg->xff, cdp_len, cdp_num);
254 if ((status < 0) || ((size_t) status >= sizeof (buffer)))
255 {
256 ERROR ("rra_get: Buffer would have been truncated.");
257 continue;
258 }
260 rra_def[rra_num++] = sstrdup (buffer);
261 }
262 }
264 *ret = rra_def;
265 return (rra_num);
266 } /* }}} int rra_get */
268 static void ds_free (int ds_num, char **ds_def) /* {{{ */
269 {
270 int i;
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 */
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;
285 char min[32];
286 char max[32];
287 char buffer[128];
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 *));
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;
305 ds_def[ds_num] = NULL;
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 }
322 if (isnan (d->min))
323 {
324 sstrncpy (min, "U", sizeof (min));
325 }
326 else
327 ssnprintf (min, sizeof (min), "%f", d->min);
329 if (isnan (d->max))
330 {
331 sstrncpy (max, "U", sizeof (max));
332 }
333 else
334 ssnprintf (max, sizeof (max), "%f", d->max);
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;
346 ds_def[ds_num] = sstrdup (buffer);
347 } /* for ds_num = 0 .. ds->ds_num */
349 if (ds_num != ds->ds_num)
350 {
351 ds_free (ds_num, ds_def);
352 return (-1);
353 }
355 *ret = ds_def;
356 return (ds_num);
357 } /* }}} int ds_get */
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;
367 if ((filename == NULL) || (argv == NULL))
368 return (-EINVAL);
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 }
380 optind = 0; /* bug in librrd? */
381 rrd_clear_error ();
383 status = rrd_create_r (filename_copy, pdp_step, last_up,
384 argc, (void *) argv);
386 if (status != 0)
387 {
388 WARNING ("rrdtool plugin: rrd_create_r (%s) failed: %s",
389 filename, rrd_get_error ());
390 }
392 sfree (filename_copy);
394 return (status);
395 } /* }}} int srrd_create */
396 /* #endif HAVE_THREADSAFE_LIBRRD */
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;
405 int new_argc;
406 char **new_argv;
408 char pdp_step_str[16];
409 char last_up_str[16];
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 }
419 if (last_up == 0)
420 last_up = time (NULL) - 10;
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);
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;
432 memcpy (new_argv + 6, argv, argc * sizeof (char *));
433 new_argv[new_argc] = NULL;
435 pthread_mutex_lock (&librrd_lock);
436 optind = 0; /* bug in librrd? */
437 rrd_clear_error ();
439 status = rrd_create (new_argc, new_argv);
440 pthread_mutex_unlock (&librrd_lock);
442 if (status != 0)
443 {
444 WARNING ("rrdtool plugin: rrd_create (%s) failed: %s",
445 filename, rrd_get_error ());
446 }
448 sfree (new_argv);
450 return (status);
451 } /* }}} int srrd_create */
452 #endif /* !HAVE_THREADSAFE_LIBRRD */
454 static int lock_file (char const *filename) /* {{{ */
455 {
456 async_create_file_t *ptr;
457 struct stat sb;
458 int status;
460 pthread_mutex_lock (&async_creation_lock);
462 for (ptr = async_creation_list; ptr != NULL; ptr = ptr->next)
463 if (strcmp (filename, ptr->filename) == 0)
464 break;
466 if (ptr != NULL)
467 {
468 pthread_mutex_unlock (&async_creation_lock);
469 return (EEXIST);
470 }
472 status = stat (filename, &sb);
473 if ((status == 0) || (errno != ENOENT))
474 {
475 pthread_mutex_unlock (&async_creation_lock);
476 return (EEXIST);
477 }
479 ptr = malloc (sizeof (*ptr));
480 if (ptr == NULL)
481 {
482 pthread_mutex_unlock (&async_creation_lock);
483 return (ENOMEM);
484 }
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 }
494 ptr->next = async_creation_list;
495 async_creation_list = ptr;
497 pthread_mutex_unlock (&async_creation_lock);
499 return (0);
500 } /* }}} int lock_file */
502 static int unlock_file (char const *filename) /* {{{ */
503 {
504 async_create_file_t *this;
505 async_create_file_t *prev;
508 pthread_mutex_lock (&async_creation_lock);
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 }
518 if (this == NULL)
519 {
520 pthread_mutex_unlock (&async_creation_lock);
521 return (ENOENT);
522 }
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;
536 pthread_mutex_unlock (&async_creation_lock);
538 sfree (this->filename);
539 sfree (this);
541 return (0);
542 } /* }}} int unlock_file */
544 static void *srrd_create_thread (void *targs) /* {{{ */
545 {
546 srrd_create_args_t *args = targs;
547 char tmpfile[PATH_MAX];
548 int status;
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 }
563 ssnprintf (tmpfile, sizeof (tmpfile), "%s.async", args->filename);
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 }
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 }
590 DEBUG ("srrd_create_thread: Successfully created RRD file \"%s\".",
591 args->filename);
593 unlock_file (args->filename);
594 srrd_create_args_destroy (args);
596 return (0);
597 } /* }}} void *srrd_create_thread */
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;
608 DEBUG ("srrd_create_async: Creating \"%s\" in the background.", filename);
610 args = srrd_create_args_create (filename, pdp_step, last_up, argc, argv);
611 if (args == NULL)
612 return (-1);
614 status = pthread_attr_init (&attr);
615 if (status != 0)
616 {
617 srrd_create_args_destroy (args);
618 return (-1);
619 }
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 }
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 }
640 pthread_attr_destroy (&attr);
641 /* args is freed in srrd_create_thread(). */
642 return (0);
643 } /* }}} int srrd_create_async */
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;
662 if (check_create_dir (filename))
663 return (-1);
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 }
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 }
677 argc = ds_num + rra_num;
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 }
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;
691 last_up = CDTIME_T_TO_TIME_T (vl->time);
692 if (last_up <= 0)
693 last_up = time (NULL);
694 last_up -= 1;
696 if (cfg->stepsize > 0)
697 stepsize = cfg->stepsize;
698 else
699 stepsize = (unsigned long) CDTIME_T_TO_TIME_T (vl->interval);
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 = srrd_create (filename, stepsize, last_up,
713 argc, (const char **) argv);
715 if (status != 0)
716 {
717 WARNING ("cu_rrd_create_file: srrd_create (%s) returned status %i.",
718 filename, status);
719 }
720 else
721 {
722 DEBUG ("cu_rrd_create_file: Successfully created RRD file \"%s\".",
723 filename);
724 }
725 }
727 free (argv);
728 ds_free (ds_num, ds_def);
729 rra_free (rra_num, rra_def);
731 return (status);
732 } /* }}} int cu_rrd_create_file */
734 /* vim: set sw=2 sts=2 et fdm=marker : */