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 /*
40 * Private variables
41 */
42 static int rra_timespans[] =
43 {
44 3600,
45 86400,
46 604800,
47 2678400,
48 31622400
49 };
50 static int rra_timespans_num = STATIC_ARRAY_SIZE (rra_timespans);
52 static char *rra_types[] =
53 {
54 "AVERAGE",
55 "MIN",
56 "MAX"
57 };
58 static int rra_types_num = STATIC_ARRAY_SIZE (rra_types);
60 #if !defined(HAVE_THREADSAFE_LIBRRD) || !HAVE_THREADSAFE_LIBRRD
61 static pthread_mutex_t librrd_lock = PTHREAD_MUTEX_INITIALIZER;
62 #endif
64 /*
65 * Private functions
66 */
67 static void rra_free (int rra_num, char **rra_def) /* {{{ */
68 {
69 int i;
71 for (i = 0; i < rra_num; i++)
72 {
73 sfree (rra_def[i]);
74 }
75 sfree (rra_def);
76 } /* }}} void rra_free */
78 static void srrd_create_args_destroy (srrd_create_args_t *args)
79 {
80 if (args == NULL)
81 return;
83 sfree (args->filename);
84 if (args->argv != NULL)
85 {
86 int i;
87 for (i = 0; i < args->argc; i++)
88 sfree (args->argv[i]);
89 sfree (args->argv);
90 }
91 } /* void srrd_create_args_destroy */
93 static srrd_create_args_t *srrd_create_args_create (const char *filename,
94 unsigned long pdp_step, time_t last_up,
95 int argc, const char **argv)
96 {
97 srrd_create_args_t *args;
99 args = malloc (sizeof (*args));
100 if (args == NULL)
101 {
102 ERROR ("srrd_create_args_create: malloc failed.");
103 return (NULL);
104 }
105 memset (args, 0, sizeof (*args));
106 args->filename = NULL;
107 args->pdp_step = pdp_step;
108 args->last_up = last_up;
109 args->argv = NULL;
111 args->filename = strdup (filename);
112 if (args->filename == NULL)
113 {
114 ERROR ("srrd_create_args_create: strdup failed.");
115 srrd_create_args_destroy (args);
116 return (NULL);
117 }
119 args->argv = calloc ((size_t) (argc + 1), sizeof (*args->argv));
120 if (args->argv == NULL)
121 {
122 ERROR ("srrd_create_args_create: calloc failed.");
123 srrd_create_args_destroy (args);
124 return (NULL);
125 }
127 for (args->argc = 0; args->argc < argc; args->argc++)
128 {
129 args->argv[args->argc] = strdup (argv[args->argc]);
130 if (args->argv[args->argc] == NULL)
131 {
132 ERROR ("srrd_create_args_create: strdup failed.");
133 srrd_create_args_destroy (args);
134 return (NULL);
135 }
136 }
137 assert (args->argc == argc);
138 args->argv[args->argc] = NULL;
140 return (args);
141 } /* srrd_create_args_t *srrd_create_args_create */
143 /* * * * * * * * * *
144 * WARNING: Magic *
145 * * * * * * * * * */
146 static int rra_get (char ***ret, const value_list_t *vl, /* {{{ */
147 const rrdcreate_config_t *cfg)
148 {
149 char **rra_def;
150 int rra_num;
152 int *rts;
153 int rts_num;
155 int rra_max;
157 int span;
159 int cdp_num;
160 int cdp_len;
161 int i, j;
163 char buffer[128];
165 /* The stepsize we use here: If it is user-set, use it. If not, use the
166 * interval of the value-list. */
167 int ss;
169 if (cfg->rrarows <= 0)
170 {
171 *ret = NULL;
172 return (-1);
173 }
175 if ((cfg->xff < 0) || (cfg->xff >= 1.0))
176 {
177 *ret = NULL;
178 return (-1);
179 }
181 if (cfg->stepsize > 0)
182 ss = cfg->stepsize;
183 else
184 ss = (int) CDTIME_T_TO_TIME_T (vl->interval);
185 if (ss <= 0)
186 {
187 *ret = NULL;
188 return (-1);
189 }
191 /* Use the configured timespans or fall back to the built-in defaults */
192 if (cfg->timespans_num != 0)
193 {
194 rts = cfg->timespans;
195 rts_num = cfg->timespans_num;
196 }
197 else
198 {
199 rts = rra_timespans;
200 rts_num = rra_timespans_num;
201 }
203 rra_max = rts_num * rra_types_num;
205 if ((rra_def = (char **) malloc ((rra_max + 1) * sizeof (char *))) == NULL)
206 return (-1);
207 memset (rra_def, '\0', (rra_max + 1) * sizeof (char *));
208 rra_num = 0;
210 cdp_len = 0;
211 for (i = 0; i < rts_num; i++)
212 {
213 span = rts[i];
215 if ((span / ss) < cfg->rrarows)
216 span = ss * cfg->rrarows;
218 if (cdp_len == 0)
219 cdp_len = 1;
220 else
221 cdp_len = (int) floor (((double) span)
222 / ((double) (cfg->rrarows * ss)));
224 cdp_num = (int) ceil (((double) span)
225 / ((double) (cdp_len * ss)));
227 for (j = 0; j < rra_types_num; j++)
228 {
229 int status;
231 if (rra_num >= rra_max)
232 break;
234 status = ssnprintf (buffer, sizeof (buffer), "RRA:%s:%.10f:%u:%u",
235 rra_types[j], cfg->xff, cdp_len, cdp_num);
237 if ((status < 0) || ((size_t) status >= sizeof (buffer)))
238 {
239 ERROR ("rra_get: Buffer would have been truncated.");
240 continue;
241 }
243 rra_def[rra_num++] = sstrdup (buffer);
244 }
245 }
247 *ret = rra_def;
248 return (rra_num);
249 } /* }}} int rra_get */
251 static void ds_free (int ds_num, char **ds_def) /* {{{ */
252 {
253 int i;
255 for (i = 0; i < ds_num; i++)
256 if (ds_def[i] != NULL)
257 free (ds_def[i]);
258 free (ds_def);
259 } /* }}} void ds_free */
261 static int ds_get (char ***ret, /* {{{ */
262 const data_set_t *ds, const value_list_t *vl,
263 const rrdcreate_config_t *cfg)
264 {
265 char **ds_def;
266 int ds_num;
268 char min[32];
269 char max[32];
270 char buffer[128];
272 ds_def = (char **) malloc (ds->ds_num * sizeof (char *));
273 if (ds_def == NULL)
274 {
275 char errbuf[1024];
276 ERROR ("rrdtool plugin: malloc failed: %s",
277 sstrerror (errno, errbuf, sizeof (errbuf)));
278 return (-1);
279 }
280 memset (ds_def, '\0', ds->ds_num * sizeof (char *));
282 for (ds_num = 0; ds_num < ds->ds_num; ds_num++)
283 {
284 data_source_t *d = ds->ds + ds_num;
285 char *type;
286 int status;
288 ds_def[ds_num] = NULL;
290 if (d->type == DS_TYPE_COUNTER)
291 type = "COUNTER";
292 else if (d->type == DS_TYPE_GAUGE)
293 type = "GAUGE";
294 else if (d->type == DS_TYPE_DERIVE)
295 type = "DERIVE";
296 else if (d->type == DS_TYPE_ABSOLUTE)
297 type = "ABSOLUTE";
298 else
299 {
300 ERROR ("rrdtool plugin: Unknown DS type: %i",
301 d->type);
302 break;
303 }
305 if (isnan (d->min))
306 {
307 sstrncpy (min, "U", sizeof (min));
308 }
309 else
310 ssnprintf (min, sizeof (min), "%f", d->min);
312 if (isnan (d->max))
313 {
314 sstrncpy (max, "U", sizeof (max));
315 }
316 else
317 ssnprintf (max, sizeof (max), "%f", d->max);
319 status = ssnprintf (buffer, sizeof (buffer),
320 "DS:%s:%s:%i:%s:%s",
321 d->name, type,
322 (cfg->heartbeat > 0)
323 ? cfg->heartbeat
324 : (int) CDTIME_T_TO_TIME_T (2 * vl->interval),
325 min, max);
326 if ((status < 1) || ((size_t) status >= sizeof (buffer)))
327 break;
329 ds_def[ds_num] = sstrdup (buffer);
330 } /* for ds_num = 0 .. ds->ds_num */
332 if (ds_num != ds->ds_num)
333 {
334 ds_free (ds_num, ds_def);
335 return (-1);
336 }
338 *ret = ds_def;
339 return (ds_num);
340 } /* }}} int ds_get */
342 #if HAVE_THREADSAFE_LIBRRD
343 static int srrd_create (const char *filename, /* {{{ */
344 unsigned long pdp_step, time_t last_up,
345 int argc, const char **argv)
346 {
347 int status;
348 char *filename_copy;
350 if ((filename == NULL) || (argv == NULL))
351 return (-EINVAL);
353 /* Some versions of librrd don't have the `const' qualifier for the first
354 * argument, so we have to copy the pointer here to avoid warnings. It sucks,
355 * but what else can we do? :( -octo */
356 filename_copy = strdup (filename);
357 if (filename_copy == NULL)
358 {
359 ERROR ("srrd_create: strdup failed.");
360 return (-ENOMEM);
361 }
363 optind = 0; /* bug in librrd? */
364 rrd_clear_error ();
366 status = rrd_create_r (filename_copy, pdp_step, last_up,
367 argc, (void *) argv);
369 if (status != 0)
370 {
371 WARNING ("rrdtool plugin: rrd_create_r (%s) failed: %s",
372 filename, rrd_get_error ());
373 }
375 sfree (filename_copy);
377 return (status);
378 } /* }}} int srrd_create */
379 /* #endif HAVE_THREADSAFE_LIBRRD */
381 #else /* !HAVE_THREADSAFE_LIBRRD */
382 static int srrd_create (const char *filename, /* {{{ */
383 unsigned long pdp_step, time_t last_up,
384 int argc, const char **argv)
385 {
386 int status;
388 int new_argc;
389 char **new_argv;
391 char pdp_step_str[16];
392 char last_up_str[16];
394 new_argc = 6 + argc;
395 new_argv = (char **) malloc ((new_argc + 1) * sizeof (char *));
396 if (new_argv == NULL)
397 {
398 ERROR ("rrdtool plugin: malloc failed.");
399 return (-1);
400 }
402 if (last_up == 0)
403 last_up = time (NULL) - 10;
405 ssnprintf (pdp_step_str, sizeof (pdp_step_str), "%lu", pdp_step);
406 ssnprintf (last_up_str, sizeof (last_up_str), "%lu", (unsigned long) last_up);
408 new_argv[0] = "create";
409 new_argv[1] = (void *) filename;
410 new_argv[2] = "-s";
411 new_argv[3] = pdp_step_str;
412 new_argv[4] = "-b";
413 new_argv[5] = last_up_str;
415 memcpy (new_argv + 6, argv, argc * sizeof (char *));
416 new_argv[new_argc] = NULL;
418 pthread_mutex_lock (&librrd_lock);
419 optind = 0; /* bug in librrd? */
420 rrd_clear_error ();
422 status = rrd_create (new_argc, new_argv);
423 pthread_mutex_unlock (&librrd_lock);
425 if (status != 0)
426 {
427 WARNING ("rrdtool plugin: rrd_create (%s) failed: %s",
428 filename, rrd_get_error ());
429 }
431 sfree (new_argv);
433 return (status);
434 } /* }}} int srrd_create */
435 #endif /* !HAVE_THREADSAFE_LIBRRD */
437 static void *srrd_create_thread (void *targs)
438 {
439 srrd_create_args_t *args = targs;
440 int status;
442 status = srrd_create (args->filename, args->pdp_step, args->last_up,
443 args->argc, (void *) args->argv);
444 if (status != 0)
445 {
446 WARNING ("srrd_create_thread: srrd_create (%s) returned status %i.",
447 args->filename, status);
448 }
449 else
450 {
451 DEBUG ("srrd_create_thread: Successfully created RRD file \"%s\".",
452 args->filename);
453 }
455 srrd_create_args_destroy (args);
457 return (0);
458 } /* void *srrd_create_thread */
460 static int srrd_create_async (const char *filename,
461 unsigned long pdp_step, time_t last_up,
462 int argc, const char **argv)
463 {
464 srrd_create_args_t *args;
465 pthread_t thread;
466 pthread_attr_t attr;
467 int status;
469 args = srrd_create_args_create (filename, pdp_step, last_up, argc, argv);
470 if (args == NULL)
471 return (-1);
473 status = pthread_attr_init (&attr);
474 if (status != 0)
475 return (-1);
477 status = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
478 if (status != 0)
479 return (-1);
481 status = pthread_create (&thread, &attr, srrd_create_thread, args);
482 if (status != 0)
483 {
484 char errbuf[1024];
485 ERROR ("srrd_create_async: pthread_create failed: %s",
486 sstrerror (status, errbuf, sizeof (errbuf)));
487 pthread_attr_destroy (&attr);
488 srrd_create_args_destroy (args);
489 return (status);
490 }
492 pthread_attr_destroy (&attr);
493 return (0);
494 }
496 /*
497 * Public functions
498 */
499 int cu_rrd_create_file (const char *filename, /* {{{ */
500 const data_set_t *ds, const value_list_t *vl,
501 const rrdcreate_config_t *cfg)
502 {
503 char **argv;
504 int argc;
505 char **rra_def;
506 int rra_num;
507 char **ds_def;
508 int ds_num;
509 int status = 0;
510 time_t last_up;
511 unsigned long stepsize;
513 if (check_create_dir (filename))
514 return (-1);
516 if ((rra_num = rra_get (&rra_def, vl, cfg)) < 1)
517 {
518 ERROR ("cu_rrd_create_file failed: Could not calculate RRAs");
519 return (-1);
520 }
522 if ((ds_num = ds_get (&ds_def, ds, vl, cfg)) < 1)
523 {
524 ERROR ("cu_rrd_create_file failed: Could not calculate DSes");
525 return (-1);
526 }
528 argc = ds_num + rra_num;
530 if ((argv = (char **) malloc (sizeof (char *) * (argc + 1))) == NULL)
531 {
532 char errbuf[1024];
533 ERROR ("cu_rrd_create_file failed: %s",
534 sstrerror (errno, errbuf, sizeof (errbuf)));
535 return (-1);
536 }
538 memcpy (argv, ds_def, ds_num * sizeof (char *));
539 memcpy (argv + ds_num, rra_def, rra_num * sizeof (char *));
540 argv[ds_num + rra_num] = NULL;
542 last_up = CDTIME_T_TO_TIME_T (vl->time);
543 if (last_up <= 0)
544 last_up = time (NULL);
545 last_up -= 1;
547 if (cfg->stepsize > 0)
548 stepsize = cfg->stepsize;
549 else
550 stepsize = (unsigned long) CDTIME_T_TO_TIME_T (vl->interval);
552 if (cfg->async)
553 {
554 status = srrd_create_async (filename, stepsize, last_up,
555 argc, (const char **) argv);
556 if (status != 0)
557 WARNING ("cu_rrd_create_file: srrd_create_async (%s) "
558 "returned status %i.",
559 filename, status);
560 }
561 else /* synchronous */
562 {
563 status = srrd_create (filename, stepsize, last_up,
564 argc, (const char **) argv);
566 if (status != 0)
567 {
568 WARNING ("cu_rrd_create_file: srrd_create (%s) returned status %i.",
569 filename, status);
570 }
571 else
572 {
573 DEBUG ("cu_rrd_create_file: Successfully created RRD file \"%s\".",
574 filename);
575 }
576 }
578 free (argv);
579 ds_free (ds_num, ds_def);
580 rra_free (rra_num, rra_def);
582 return (status);
583 } /* }}} int cu_rrd_create_file */
585 /* vim: set sw=2 sts=2 et fdm=marker : */