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