/**
* collectd - src/rrdtool.c
- * Copyright (C) 2006 Florian octo Forster
+ * Copyright (C) 2006,2007 Florian octo Forster
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
#include "common.h"
#include "utils_avltree.h"
+#if HAVE_PTHREAD_H
+# include <pthread.h>
+#endif
+
/*
* Private types
*/
int values_num;
char **values;
time_t first_value;
+ time_t last_value;
};
typedef struct rrd_cache_s rrd_cache_t;
};
static int rra_timespans_num = STATIC_ARRAY_SIZE (rra_timespans);
+static int *rra_timespans_custom = NULL;
+static int rra_timespans_custom_num = 0;
+
static char *rra_types[] =
{
"AVERAGE",
"StepSize",
"HeartBeat",
"RRARows",
+ "RRATimespan",
"XFF"
};
static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
static int cache_flush_timeout = 0;
static time_t cache_flush_last;
static avl_tree_t *cache = NULL;
+static pthread_mutex_t cache_lock = PTHREAD_MUTEX_INITIALIZER;
/* * * * * * * * * *
* WARNING: Magic *
static char **rra_def = NULL;
static int rra_num = 0;
- int rra_max = rra_timespans_num * rra_types_num;
+ int *rts;
+ int rts_num;
+
+ int rra_max;
int span;
return (rra_num);
}
+ /* Use the configured timespans or fall back to the built-in defaults */
+ if (rra_timespans_custom_num != 0)
+ {
+ rts = rra_timespans_custom;
+ rts_num = rra_timespans_custom_num;
+ }
+ else
+ {
+ rts = rra_timespans;
+ rts_num = rra_timespans_num;
+ }
+
+ rra_max = rts_num * rra_types_num;
+
if ((rra_def = (char **) malloc ((rra_max + 1) * sizeof (char *))) == NULL)
return (-1);
memset (rra_def, '\0', (rra_max + 1) * sizeof (char *));
}
cdp_len = 0;
- for (i = 0; i < rra_timespans_num; i++)
+ for (i = 0; i < rts_num; i++)
{
- span = rra_timespans[i];
+ span = rts[i];
if ((span / stepsize) < rrarows)
continue;
ds_def = (char **) malloc (ds->ds_num * sizeof (char *));
if (ds_def == NULL)
{
+ char errbuf[1024];
ERROR ("rrdtool plugin: malloc failed: %s",
- strerror (errno));
+ sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
memset (ds_def, '\0', ds->ds_num * sizeof (char *));
if ((argv = (char **) malloc (sizeof (char *) * (argc + 1))) == NULL)
{
- ERROR ("rrd_create failed: %s", strerror (errno));
+ char errbuf[1024];
+ ERROR ("rrd_create failed: %s",
+ sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
int status;
int i;
- memset (buffer, '\0', sizeof (buffer_len));
+ memset (buffer, '\0', buffer_len);
status = snprintf (buffer, buffer_len, "%u", (unsigned int) vl->time);
if ((status < 1) || (status >= buffer_len))
} /* int value_list_to_filename */
static rrd_cache_t *rrd_cache_insert (const char *filename,
- const char *value)
+ const char *value, time_t value_time)
{
rrd_cache_t *rc = NULL;
int new_rc = 0;
rc->values_num = 0;
rc->values = NULL;
rc->first_value = 0;
+ rc->last_value = 0;
new_rc = 1;
}
+ if (rc->last_value >= value_time)
+ {
+ WARNING ("rrdtool plugin: (rc->last_value = %u) >= (value_time = %u)",
+ (unsigned int) rc->last_value,
+ (unsigned int) value_time);
+ return (NULL);
+ }
+
rc->values = (char **) realloc ((void *) rc->values,
(rc->values_num + 1) * sizeof (char *));
if (rc->values == NULL)
{
+ char errbuf[1024];
ERROR ("rrdtool plugin: realloc failed: %s",
- strerror (errno));
+ sstrerror (errno, errbuf, sizeof (errbuf)));
if (cache != NULL)
{
void *cache_key = NULL;
rc->values_num++;
if (rc->values_num == 1)
- rc->first_value = time (NULL);
+ rc->first_value = value_time;
+ rc->last_value = value_time;
/* Insert if this is the first value */
if ((cache != NULL) && (new_rc == 1))
if (cache_key == NULL)
{
+ char errbuf[1024];
ERROR ("rrdtool plugin: strdup failed: %s",
- strerror (errno));
+ sstrerror (errno, errbuf, sizeof (errbuf)));
sfree (rc->values[0]);
sfree (rc->values);
sfree (rc);
avl_insert (cache, cache_key, rc);
}
- DEBUG ("rrd_cache_insert (%s, %s) = %p", filename, value, (void *) rc);
+ DEBUG ("rrd_cache_insert (%s, %s, %u) = %p", filename, value,
+ (unsigned int) value_time, (void *) rc);
return (rc);
} /* rrd_cache_t *rrd_cache_insert */
int i;
+ if (rc->values_num < 1)
+ return (0);
+
argc = rc->values_num + 2;
argv = (char **) malloc ((argc + 1) * sizeof (char *));
if (argv == NULL)
optind = 0; /* bug in librrd? */
rrd_clear_error ();
status = rrd_update (argc, argv);
+ if (status != 0)
+ {
+ WARNING ("rrd_update failed: %s: %s",
+ filename, rrd_get_error ());
+ status = -1;
+ }
free (argv);
free (fn);
-
/* Free the value list of `rc' */
for (i = 0; i < rc->values_num; i++)
free (rc->values[i]);
rc->values = NULL;
rc->values_num = 0;
- if (status != 0)
- {
- WARNING ("rrd_update failed: %s: %s",
- filename, rrd_get_error ());
- return (-1);
- }
-
- return (0);
+ return (status);
} /* int rrd_write_cache_entry */
static void rrd_cache_flush (int timeout)
(keys_num + 1) * sizeof (char *));
if (keys == NULL)
{
- DEBUG ("realloc failed: %s", strerror (errno));
+ char errbuf[1024];
ERROR ("rrdtool plugin: "
"realloc failed: %s",
- strerror (errno));
+ sstrerror (errno, errbuf,
+ sizeof (errbuf)));
avl_iterator_destroy (iter);
return;
}
}
else
{
- ERROR ("stat(%s) failed: %s",
- filename, strerror (errno));
+ char errbuf[1024];
+ ERROR ("stat(%s) failed: %s", filename,
+ sstrerror (errno, errbuf,
+ sizeof (errbuf)));
return (-1);
}
}
return (-1);
}
- rc = rrd_cache_insert (filename, values);
+ pthread_mutex_lock (&cache_lock);
+ rc = rrd_cache_insert (filename, values, vl->time);
if (rc == NULL)
+ {
+ pthread_mutex_unlock (&cache_lock);
return (-1);
+ }
if (cache == NULL)
{
rrd_write_cache_entry (filename, rc);
/* rc's value-list is free's by `rrd_write_cache_entry' */
sfree (rc);
+ pthread_mutex_unlock (&cache_lock);
return (0);
}
if ((now - cache_flush_last) >= cache_flush_timeout)
rrd_cache_flush (cache_flush_timeout);
+ pthread_mutex_unlock (&cache_lock);
return (0);
} /* int rrd_write */
}
rrarows = tmp;
}
+ else if (strcasecmp ("RRATimespan", key) == 0)
+ {
+ char *saveptr = NULL;
+ char *dummy;
+ char *ptr;
+ char *value_copy;
+ int *tmp_alloc;
+
+ value_copy = strdup (value);
+ if (value_copy == NULL)
+ return (1);
+
+ dummy = value_copy;
+ while ((ptr = strtok_r (dummy, ", \t", &saveptr)) != NULL)
+ {
+ dummy = NULL;
+
+ tmp_alloc = realloc (rra_timespans_custom,
+ sizeof (int) * (rra_timespans_custom_num + 1));
+ if (tmp_alloc == NULL)
+ {
+ fprintf (stderr, "rrdtool: realloc failed.\n");
+ free (value_copy);
+ return (1);
+ }
+ rra_timespans_custom = tmp_alloc;
+ rra_timespans_custom[rra_timespans_custom_num] = atoi (ptr);
+ if (rra_timespans_custom[rra_timespans_custom_num] != 0)
+ rra_timespans_custom_num++;
+ } /* while (strtok_r) */
+ free (value_copy);
+ }
else if (strcasecmp ("XFF", key) == 0)
{
double tmp = atof (value);
static int rrd_shutdown (void)
{
+ pthread_mutex_lock (&cache_lock);
rrd_cache_flush (-1);
if (cache != NULL)
avl_destroy (cache);
cache = NULL;
+ pthread_mutex_unlock (&cache_lock);
return (0);
} /* int rrd_shutdown */
"smaller than your `interval'. This will "
"create needlessly big RRD-files.");
+ pthread_mutex_lock (&cache_lock);
if (cache_timeout < 2)
{
cache_timeout = 0;
cache_flush_last = time (NULL);
plugin_register_shutdown ("rrdtool", rrd_shutdown);
}
+ pthread_mutex_unlock (&cache_lock);
- DEBUG ("datadir = %s; stepsize = %i; heartbeat = %i; rrarows = %i; xff = %lf;",
+ DEBUG ("rrdtool plugin: rrd_init: datadir = %s; stepsize = %i;"
+ " heartbeat = %i; rrarows = %i; xff = %lf;",
(datadir == NULL) ? "(null)" : datadir,
stepsize, heartbeat, rrarows, xff);
projects / collectd.git / blobdiff