X-Git-Url: https://git.tokkee.org/?p=sysdb.git;a=blobdiff_plain;f=src%2Fcore%2Fstore.c;h=c6e22df69f55591e433c2d52fee5341dea6c2d90;hp=1b8243b091d4149a98dabea39927b5eb661b122c;hb=b75718ea9fe4d6c90f1794e517a0712729553c0c;hpb=98211ed75b3ce19225cb6d6628b0abfa669823ac diff --git a/src/core/store.c b/src/core/store.c index 1b8243b..c6e22df 100644 --- a/src/core/store.c +++ b/src/core/store.c @@ -32,8 +32,8 @@ #include "sysdb.h" #include "core/store-private.h" #include "core/plugin.h" +#include "utils/avltree.h" #include "utils/error.h" -#include "utils/llist.h" #include @@ -43,22 +43,68 @@ #include #include +#include #include /* - * private variables + * private types */ -static sdb_llist_t *host_list = NULL; -static pthread_rwlock_t host_lock = PTHREAD_RWLOCK_INITIALIZER; +struct sdb_store { + sdb_object_t super; -/* - * private types - */ + /* hosts are the top-level entries and + * reference everything else */ + sdb_avltree_t *hosts; + pthread_rwlock_t host_lock; +}; + +/* internal representation of a to-be-stored object */ +typedef struct { + sdb_store_obj_t *parent; + sdb_avltree_t *parent_tree; + int type; + const char *name; + sdb_time_t last_update; + const char **backends; + size_t backends_num; +} store_obj_t; +#define STORE_OBJ_INIT { NULL, NULL, 0, NULL, 0, NULL, 0 } + +static sdb_type_t host_type; +static sdb_type_t service_type; +static sdb_type_t metric_type; +static sdb_type_t attribute_type; + +static int +store_init(sdb_object_t *obj, va_list __attribute__((unused)) ap) +{ + int err; + if (! (SDB_STORE(obj)->hosts = sdb_avltree_create())) + return -1; + if ((err = pthread_rwlock_init(&SDB_STORE(obj)->host_lock, + /* attr = */ NULL))) { + char errbuf[128]; + sdb_log(SDB_LOG_ERR, "store: Failed to initialize lock: %s", + sdb_strerror(err, errbuf, sizeof(errbuf))); + return -1; + } + return 0; +} /* store_init */ -static sdb_type_t sdb_host_type; -static sdb_type_t sdb_service_type; -static sdb_type_t sdb_attribute_type; +static void +store_destroy(sdb_object_t *obj) +{ + int err; + if ((err = pthread_rwlock_destroy(&SDB_STORE(obj)->host_lock))) { + char errbuf[128]; + sdb_log(SDB_LOG_ERR, "store: Failed to destroy lock: %s", + sdb_strerror(err, errbuf, sizeof(errbuf))); + return; + } + sdb_avltree_destroy(SDB_STORE(obj)->hosts); + SDB_STORE(obj)->hosts = NULL; +} /* store_destroy */ static int store_obj_init(sdb_object_t *obj, va_list ap) @@ -69,6 +115,8 @@ store_obj_init(sdb_object_t *obj, va_list ap) sobj->last_update = va_arg(ap, sdb_time_t); sobj->interval = 0; + sobj->backends = NULL; + sobj->backends_num = 0; sobj->parent = NULL; return 0; } /* store_obj_init */ @@ -76,16 +124,25 @@ store_obj_init(sdb_object_t *obj, va_list ap) static void store_obj_destroy(sdb_object_t *obj) { - const sdb_store_obj_t *sobj = STORE_CONST_OBJ(obj); - - if (sobj->parent) - sdb_object_deref(SDB_OBJ(sobj->parent)); + sdb_store_obj_t *sobj = STORE_OBJ(obj); + size_t i; + + for (i = 0; i < sobj->backends_num; ++i) + free(sobj->backends[i]); + free(sobj->backends); + sobj->backends = NULL; + sobj->backends_num = 0; + + // We don't currently keep an extra reference for parent objects to + // avoid circular self-references which are not handled correctly by + // the ref-count base management layer. + //sdb_object_deref(SDB_OBJ(sobj->parent)); } /* store_obj_destroy */ static int -sdb_host_init(sdb_object_t *obj, va_list ap) +host_init(sdb_object_t *obj, va_list ap) { - sdb_host_t *sobj = HOST(obj); + host_t *sobj = HOST(obj); int ret; /* this will consume the first argument (type) of ap */ @@ -93,33 +150,67 @@ sdb_host_init(sdb_object_t *obj, va_list ap) if (ret) return ret; - sobj->services = sdb_llist_create(); + sobj->services = sdb_avltree_create(); if (! sobj->services) return -1; - sobj->attributes = sdb_llist_create(); + sobj->metrics = sdb_avltree_create(); + if (! sobj->metrics) + return -1; + sobj->attributes = sdb_avltree_create(); if (! sobj->attributes) return -1; return 0; -} /* sdb_host_init */ +} /* host_init */ static void -sdb_host_destroy(sdb_object_t *obj) +host_destroy(sdb_object_t *obj) { - sdb_host_t *sobj = HOST(obj); + host_t *sobj = HOST(obj); assert(obj); store_obj_destroy(obj); if (sobj->services) - sdb_llist_destroy(sobj->services); + sdb_avltree_destroy(sobj->services); + if (sobj->metrics) + sdb_avltree_destroy(sobj->metrics); + if (sobj->attributes) + sdb_avltree_destroy(sobj->attributes); +} /* host_destroy */ + +static int +service_init(sdb_object_t *obj, va_list ap) +{ + service_t *sobj = SVC(obj); + int ret; + + /* this will consume the first argument (type) of ap */ + ret = store_obj_init(obj, ap); + if (ret) + return ret; + + sobj->attributes = sdb_avltree_create(); + if (! sobj->attributes) + return -1; + return 0; +} /* service_init */ + +static void +service_destroy(sdb_object_t *obj) +{ + service_t *sobj = SVC(obj); + assert(obj); + + store_obj_destroy(obj); + if (sobj->attributes) - sdb_llist_destroy(sobj->attributes); -} /* sdb_host_destroy */ + sdb_avltree_destroy(sobj->attributes); +} /* service_destroy */ static int -sdb_service_init(sdb_object_t *obj, va_list ap) +metric_init(sdb_object_t *obj, va_list ap) { - sdb_service_t *sobj = SVC(obj); + sdb_metric_t *sobj = METRIC(obj); int ret; /* this will consume the first argument (type) of ap */ @@ -127,26 +218,33 @@ sdb_service_init(sdb_object_t *obj, va_list ap) if (ret) return ret; - sobj->attributes = sdb_llist_create(); + sobj->attributes = sdb_avltree_create(); if (! sobj->attributes) return -1; + + sobj->store.type = sobj->store.id = NULL; return 0; -} /* sdb_service_init */ +} /* metric_init */ static void -sdb_service_destroy(sdb_object_t *obj) +metric_destroy(sdb_object_t *obj) { - sdb_service_t *sobj = SVC(obj); + sdb_metric_t *sobj = METRIC(obj); assert(obj); store_obj_destroy(obj); if (sobj->attributes) - sdb_llist_destroy(sobj->attributes); -} /* sdb_service_destroy */ + sdb_avltree_destroy(sobj->attributes); + + if (sobj->store.type) + free(sobj->store.type); + if (sobj->store.id) + free(sobj->store.id); +} /* metric_destroy */ static int -sdb_attr_init(sdb_object_t *obj, va_list ap) +attr_init(sdb_object_t *obj, va_list ap) { const sdb_data_t *value; int ret; @@ -162,128 +260,116 @@ sdb_attr_init(sdb_object_t *obj, va_list ap) if (sdb_data_copy(&ATTR(obj)->value, value)) return -1; return 0; -} /* sdb_attr_init */ +} /* attr_init */ static void -sdb_attr_destroy(sdb_object_t *obj) +attr_destroy(sdb_object_t *obj) { assert(obj); store_obj_destroy(obj); sdb_data_free_datum(&ATTR(obj)->value); -} /* sdb_attr_destroy */ +} /* attr_destroy */ + +static sdb_type_t store_type = { + /* size = */ sizeof(sdb_store_t), + /* init = */ store_init, + /* destroy = */ store_destroy, +}; -static sdb_type_t sdb_host_type = { - sizeof(sdb_host_t), - sdb_host_init, - sdb_host_destroy +static sdb_type_t host_type = { + /* size = */ sizeof(host_t), + /* init = */ host_init, + /* destroy = */ host_destroy }; -static sdb_type_t sdb_service_type = { - sizeof(sdb_service_t), - sdb_service_init, - sdb_service_destroy +static sdb_type_t service_type = { + /* size = */ sizeof(service_t), + /* init = */ service_init, + /* destroy = */ service_destroy }; -static sdb_type_t sdb_attribute_type = { - sizeof(sdb_attribute_t), - sdb_attr_init, - sdb_attr_destroy +static sdb_type_t metric_type = { + /* size = */ sizeof(sdb_metric_t), + /* init = */ metric_init, + /* destroy = */ metric_destroy +}; + +static sdb_type_t attribute_type = { + /* size = */ sizeof(attr_t), + /* init = */ attr_init, + /* destroy = */ attr_destroy }; /* * private helper functions */ -static sdb_host_t * -lookup_host(const char *name) -{ - return HOST(sdb_llist_search_by_name(host_list, name)); -} /* lookup_host */ - -/* The host_lock has to be acquired before calling this function. */ static int -store_obj(const char *hostname, int type, const char *name, - sdb_time_t last_update, sdb_store_obj_t **updated_obj) +record_backends(sdb_store_obj_t *obj, + const char **backends, size_t backends_num) { - char *host_cname = NULL, *cname = NULL; + char **tmp; + size_t i; - sdb_llist_t *parent_list; - sdb_store_obj_t *old; - int status = 0; - - if (last_update <= 0) - last_update = sdb_gettime(); + for (i = 0; i < backends_num; i++) { + bool found = 0; + size_t j; - assert((type == 0) - || (type == SDB_HOST) - || (type == SDB_SERVICE) - || (type == SDB_ATTRIBUTE)); - - assert(hostname || (type == SDB_HOST)); - assert((! hostname) - || (type == SDB_SERVICE) - || (type == SDB_ATTRIBUTE)); + for (j = 0; j < obj->backends_num; ++j) { + if (!strcasecmp(obj->backends[j], backends[i])) { + found = 1; + break; + } + } + if (found) + continue; - if (! host_list) - if (! (host_list = sdb_llist_create())) + tmp = realloc(obj->backends, + (obj->backends_num + 1) * sizeof(*obj->backends)); + if (! tmp) return -1; - parent_list = host_list; - if (type == SDB_HOST) { - cname = sdb_plugin_cname(strdup(name)); - if (! cname) { - sdb_log(SDB_LOG_ERR, "store: strdup failed"); + obj->backends = tmp; + obj->backends[obj->backends_num] = strdup(backends[i]); + if (! obj->backends[obj->backends_num]) return -1; - } - name = cname; + + ++obj->backends_num; } + return 0; +} /* record_backends */ - if (hostname) { - sdb_host_t *host; +static int +store_obj(store_obj_t *obj, sdb_store_obj_t **updated_obj) +{ + sdb_store_obj_t *old, *new; + int status = 0; - host_cname = sdb_plugin_cname(strdup(hostname)); - if (! host_cname) { - sdb_log(SDB_LOG_ERR, "store: strdup failed"); - free(cname); - return -1; - } - hostname = host_cname; - - host = lookup_host(hostname); - if (! host) { - sdb_log(SDB_LOG_ERR, "store: Failed to store %s '%s' - " - "host '%s' not found", SDB_STORE_TYPE_TO_NAME(type), - name, hostname); - free(host_cname); - free(cname); - return -1; - } + assert(obj->parent_tree); - if (type == SDB_ATTRIBUTE) - parent_list = host->attributes; - else - parent_list = host->services; - } - - if (type == SDB_HOST) - old = STORE_OBJ(sdb_llist_search_by_name(host_list, name)); - else - old = STORE_OBJ(sdb_llist_search_by_name(parent_list, name)); + if (obj->last_update <= 0) + obj->last_update = sdb_gettime(); + old = STORE_OBJ(sdb_avltree_lookup(obj->parent_tree, obj->name)); if (old) { - if (old->last_update > last_update) { + if (old->last_update > obj->last_update) { sdb_log(SDB_LOG_DEBUG, "store: Cannot update %s '%s' - " - "value too old (%"PRIscTIME" < %"PRIscTIME")", - SDB_STORE_TYPE_TO_NAME(type), name, - last_update, old->last_update); + "value too old (%"PRIsdbTIME" < %"PRIsdbTIME")", + SDB_STORE_TYPE_TO_NAME(obj->type), obj->name, + obj->last_update, old->last_update); /* don't report an error; the object may be updated by multiple * backends */ status = 1; } + else if (old->last_update == obj->last_update) { + /* don't report an error and also don't even log this to avoid + * excessive noise on high sampling frequencies */ + status = 1; + } else { - sdb_time_t interval = last_update - old->last_update; - old->last_update = last_update; + sdb_time_t interval = obj->last_update - old->last_update; + old->last_update = obj->last_update; if (interval) { if (old->interval) old->interval = (sdb_time_t)((0.9 * (double)old->interval) @@ -293,317 +379,726 @@ store_obj(const char *hostname, int type, const char *name, } } - if (updated_obj) - *updated_obj = old; + new = old; + sdb_object_deref(SDB_OBJ(old)); } else { - sdb_store_obj_t *new; - - if (type == SDB_ATTRIBUTE) { + if (obj->type == SDB_ATTRIBUTE) { /* the value will be updated by the caller */ - new = STORE_OBJ(sdb_object_create(name, sdb_attribute_type, - type, last_update, NULL)); + new = STORE_OBJ(sdb_object_create(obj->name, attribute_type, + obj->type, obj->last_update, NULL)); } else { sdb_type_t t; - t = type == SDB_HOST ? sdb_host_type : sdb_service_type; - new = STORE_OBJ(sdb_object_create(name, t, type, last_update)); + t = obj->type == SDB_HOST + ? host_type + : obj->type == SDB_SERVICE + ? service_type + : metric_type; + new = STORE_OBJ(sdb_object_create(obj->name, t, + obj->type, obj->last_update)); } - if (! new) { + if (new) { + status = sdb_avltree_insert(obj->parent_tree, SDB_OBJ(new)); + + /* pass control to the tree or destroy in case of an error */ + sdb_object_deref(SDB_OBJ(new)); + } + else { char errbuf[1024]; sdb_log(SDB_LOG_ERR, "store: Failed to create %s '%s': %s", - SDB_STORE_TYPE_TO_NAME(type), name, + SDB_STORE_TYPE_TO_NAME(obj->type), obj->name, sdb_strerror(errno, errbuf, sizeof(errbuf))); - free(host_cname); - free(cname); - return -1; + status = -1; } + } - status = sdb_llist_insert_sorted(parent_list, SDB_OBJ(new), - sdb_object_cmp_by_name); - - /* pass control to the list or destroy in case of an error */ - sdb_object_deref(SDB_OBJ(new)); + if (status < 0) + return status; + assert(new); - if (updated_obj) - *updated_obj = new; + if (new->parent != obj->parent) { + // Avoid circular self-references which are not handled + // correctly by the ref-count based management layer. + //sdb_object_deref(SDB_OBJ(new->parent)); + //sdb_object_ref(SDB_OBJ(obj->parent)); + new->parent = obj->parent; } - free(host_cname); - free(cname); + + if (updated_obj) + *updated_obj = new; + + if (record_backends(new, obj->backends, obj->backends_num)) + return -1; return status; } /* store_obj */ +static int +store_metric_store(sdb_metric_t *metric, sdb_store_metric_t *m) +{ + char *type = metric->store.type; + char *id = metric->store.id; + + if ((! metric->store.type) || strcasecmp(metric->store.type, m->store.type)) { + if (! (type = strdup(m->store.type))) + return -1; + } + if ((! metric->store.id) || strcasecmp(metric->store.id, m->store.id)) { + if (! (id = strdup(m->store.id))) { + if (type != metric->store.type) + free(type); + return -1; + } + } + + if (type != metric->store.type) { + if (metric->store.type) + free(metric->store.type); + metric->store.type = type; + } + if (id != metric->store.id) { + if (metric->store.id) + free(metric->store.id); + metric->store.id = id; + } + return 0; +} /* store_metric_store */ + +/* The store's host_lock has to be acquired before calling this function. */ +static sdb_avltree_t * +get_host_children(host_t *host, int type) +{ + if ((type != SDB_SERVICE) && (type != SDB_METRIC) + && (type != SDB_ATTRIBUTE)) + return NULL; + + if (! host) + return NULL; + + if (type == SDB_ATTRIBUTE) + return host->attributes; + else if (type == SDB_METRIC) + return host->metrics; + else + return host->services; +} /* get_host_children */ + /* - * store_obj_tojson serializes attribute / service objects to JSON. + * ts_tojson serializes a time-series to JSON. * * The function never returns an error. Rather, an error message will be part * of the serialized data. */ static void -store_obj_tojson(sdb_llist_t *list, int type, sdb_strbuf_t *buf) +ts_tojson(sdb_timeseries_t *ts, sdb_strbuf_t *buf) { - sdb_llist_iter_t *iter; - char time_str[64]; - char interval_str[64]; + char start_str[64]; + char end_str[64]; + + size_t i; + + /* TODO: make time format configurable */ + if (! sdb_strftime(start_str, sizeof(start_str), ts->start)) + snprintf(start_str, sizeof(start_str), ""); + start_str[sizeof(start_str) - 1] = '\0'; + if (! sdb_strftime(end_str, sizeof(end_str), ts->end)) + snprintf(end_str, sizeof(end_str), ""); + end_str[sizeof(end_str) - 1] = '\0'; + + sdb_strbuf_append(buf, "{\"start\": \"%s\", \"end\": \"%s\", \"data\": {", + start_str, end_str); + + for (i = 0; i < ts->data_names_len; ++i) { + size_t j; + sdb_strbuf_append(buf, "\"%s\": [", ts->data_names[i]); + + for (j = 0; j < ts->data_len; ++j) { + char time_str[64]; + + if (! sdb_strftime(time_str, sizeof(time_str), ts->data[i][j].timestamp)) + snprintf(time_str, sizeof(time_str), ""); + time_str[sizeof(time_str) - 1] = '\0'; + + /* Some GNU libc versions may print '-nan' which we dont' want */ + if (isnan(ts->data[i][j].value)) + sdb_strbuf_append(buf, "{\"timestamp\": \"%s\", " + "\"value\": \"nan\"}", time_str); + else + sdb_strbuf_append(buf, "{\"timestamp\": \"%s\", " + "\"value\": \"%f\"}", time_str, ts->data[i][j].value); + + if (j < ts->data_len - 1) + sdb_strbuf_append(buf, ","); + } + + if (i < ts->data_names_len - 1) + sdb_strbuf_append(buf, "],"); + else + sdb_strbuf_append(buf, "]"); + } + sdb_strbuf_append(buf, "}}"); +} /* ts_tojson */ + +/* + * store writer API + */ - assert((type == SDB_ATTRIBUTE) || (type == SDB_SERVICE)); +static int +store_attribute(sdb_store_attribute_t *attr, sdb_object_t *user_data) +{ + sdb_store_t *st = SDB_STORE(user_data); + store_obj_t obj = STORE_OBJ_INIT; + sdb_store_obj_t *new = NULL; + const char *hostname; + host_t *host; - sdb_strbuf_append(buf, "["); + sdb_avltree_t *children = NULL; + int status = 0; - iter = sdb_llist_get_iter(list); - if (! iter) { - char errbuf[1024]; - sdb_log(SDB_LOG_ERR, "store: Failed to retrieve %ss: %s\n", - SDB_STORE_TYPE_TO_NAME(type), - sdb_strerror(errno, errbuf, sizeof(errbuf))); - sdb_strbuf_append(buf, "{\"error\": \"failed to retrieve %ss: %s\"}", - SDB_STORE_TYPE_TO_NAME(type), errbuf); + if ((! attr) || (! attr->parent) || (! attr->key)) + return -1; + + hostname = attr->hostname; + if (attr->parent_type == SDB_HOST) + hostname = attr->parent; + if (! hostname) + return -1; + + pthread_rwlock_wrlock(&st->host_lock); + host = HOST(sdb_avltree_lookup(st->hosts, hostname)); + if (! host) { + sdb_log(SDB_LOG_ERR, "store: Failed to store attribute '%s' - " + "host '%s' not found", attr->key, hostname); + status = -1; } - /* has_next returns false if the iterator is NULL */ - while (sdb_llist_iter_has_next(iter)) { - sdb_store_obj_t *sobj = STORE_OBJ(sdb_llist_iter_get_next(iter)); - assert(sobj); - assert(sobj->type == type); - - if (! sdb_strftime(time_str, sizeof(time_str), - "%F %T %z", sobj->last_update)) - snprintf(time_str, sizeof(time_str), ""); - time_str[sizeof(time_str) - 1] = '\0'; - - if (! sdb_strfinterval(interval_str, sizeof(interval_str), - sobj->interval)) - snprintf(interval_str, sizeof(interval_str), ""); - interval_str[sizeof(interval_str) - 1] = '\0'; - - sdb_strbuf_append(buf, "{\"name\": \"%s\", ", SDB_OBJ(sobj)->name); - if (sobj->type == SDB_ATTRIBUTE) { - char tmp[sdb_data_strlen(&ATTR(sobj)->value) + 1]; - sdb_data_format(&ATTR(sobj)->value, tmp, sizeof(tmp), - SDB_DOUBLE_QUOTED); - sdb_strbuf_append(buf, "\"value\": %s, \"last_update\": \"%s\", " - "\"update_interval\": \"%s\"}", tmp, time_str, - interval_str); + switch (attr->parent_type) { + case SDB_HOST: + obj.parent = STORE_OBJ(host); + obj.parent_tree = get_host_children(host, SDB_ATTRIBUTE); + break; + case SDB_SERVICE: + children = get_host_children(host, SDB_SERVICE); + break; + case SDB_METRIC: + children = get_host_children(host, SDB_METRIC); + break; + default: + status = -1; + break; + } + + if (children) { + obj.parent = STORE_OBJ(sdb_avltree_lookup(children, attr->parent)); + if (! obj.parent) { + sdb_log(SDB_LOG_ERR, "store: Failed to store attribute '%s' - " + "%s '%s/%s' not found", attr->key, + SDB_STORE_TYPE_TO_NAME(attr->parent_type), + attr->hostname, attr->parent); + status = -1; } else - sdb_strbuf_append(buf, "\"last_update\": \"%s\", " - "\"update_interval\": \"%s\"}", time_str, interval_str); + obj.parent_tree = attr->parent_type == SDB_SERVICE + ? SVC(obj.parent)->attributes + : METRIC(obj.parent)->attributes; + } + + obj.type = SDB_ATTRIBUTE; + obj.name = attr->key; + obj.last_update = attr->last_update; + obj.backends = attr->backends; + obj.backends_num = attr->backends_num; + if (! status) + status = store_obj(&obj, &new); + + if (! status) { + assert(new); + /* update the value if it changed */ + if (sdb_data_cmp(&ATTR(new)->value, &attr->value)) + if (sdb_data_copy(&ATTR(new)->value, &attr->value)) + status = -1; + } + + if (obj.parent != STORE_OBJ(host)) + sdb_object_deref(SDB_OBJ(obj.parent)); + sdb_object_deref(SDB_OBJ(host)); + pthread_rwlock_unlock(&st->host_lock); + + return status; +} /* store_attribute */ - if (sdb_llist_iter_has_next(iter)) - sdb_strbuf_append(buf, ","); +static int +store_host(sdb_store_host_t *host, sdb_object_t *user_data) +{ + sdb_store_t *st = SDB_STORE(user_data); + store_obj_t obj = { NULL, st->hosts, SDB_HOST, NULL, 0, NULL, 0 }; + int status = 0; + + if ((! host) || (! host->name)) + return -1; + + obj.name = host->name; + obj.last_update = host->last_update; + obj.backends = host->backends; + obj.backends_num = host->backends_num; + pthread_rwlock_wrlock(&st->host_lock); + status = store_obj(&obj, NULL); + pthread_rwlock_unlock(&st->host_lock); + + return status; +} /* store_host */ + +static int +store_service(sdb_store_service_t *service, sdb_object_t *user_data) +{ + sdb_store_t *st = SDB_STORE(user_data); + store_obj_t obj = STORE_OBJ_INIT; + host_t *host; + + int status = 0; + + if ((! service) || (! service->hostname) || (! service->name)) + return -1; + + pthread_rwlock_wrlock(&st->host_lock); + host = HOST(sdb_avltree_lookup(st->hosts, service->hostname)); + obj.parent = STORE_OBJ(host); + obj.parent_tree = get_host_children(host, SDB_SERVICE); + obj.type = SDB_SERVICE; + if (! obj.parent_tree) { + sdb_log(SDB_LOG_ERR, "store: Failed to store service '%s' - " + "host '%s' not found", service->name, service->hostname); + status = -1; + } + + obj.name = service->name; + obj.last_update = service->last_update; + obj.backends = service->backends; + obj.backends_num = service->backends_num; + if (! status) + status = store_obj(&obj, NULL); + + sdb_object_deref(SDB_OBJ(host)); + pthread_rwlock_unlock(&st->host_lock); + return status; +} /* store_service */ + +static int +store_metric(sdb_store_metric_t *metric, sdb_object_t *user_data) +{ + sdb_store_t *st = SDB_STORE(user_data); + store_obj_t obj = STORE_OBJ_INIT; + sdb_store_obj_t *new = NULL; + host_t *host; + + int status = 0; + + if ((! metric) || (! metric->hostname) || (! metric->name)) + return -1; + + if ((metric->store.type != NULL) != (metric->store.id != NULL)) + return -1; + + pthread_rwlock_wrlock(&st->host_lock); + host = HOST(sdb_avltree_lookup(st->hosts, metric->hostname)); + obj.parent = STORE_OBJ(host); + obj.parent_tree = get_host_children(host, SDB_METRIC); + obj.type = SDB_METRIC; + if (! obj.parent_tree) { + sdb_log(SDB_LOG_ERR, "store: Failed to store metric '%s' - " + "host '%s' not found", metric->name, metric->hostname); + status = -1; } - sdb_llist_iter_destroy(iter); - sdb_strbuf_append(buf, "]"); -} /* store_obj_tojson */ + obj.name = metric->name; + obj.last_update = metric->last_update; + obj.backends = metric->backends; + obj.backends_num = metric->backends_num; + if (! status) + status = store_obj(&obj, &new); + sdb_object_deref(SDB_OBJ(host)); + + if (status) { + pthread_rwlock_unlock(&st->host_lock); + return status; + } + + assert(new); + if (metric->store.type && metric->store.id) + if (store_metric_store(METRIC(new), metric)) + status = -1; + pthread_rwlock_unlock(&st->host_lock); + return status; +} /* store_metric */ + +sdb_store_writer_t sdb_store_writer = { + store_host, store_service, store_metric, store_attribute, +}; + +static sdb_object_t * +prepare_query(sdb_ast_node_t *ast, + sdb_strbuf_t __attribute__((unused)) *errbuf, + sdb_object_t __attribute__((unused)) *user_data) +{ + return SDB_OBJ(sdb_store_query_prepare(ast)); +} /* prepare_query */ + +static int +execute_query(sdb_object_t *q, + sdb_strbuf_t *buf, sdb_strbuf_t *errbuf, + sdb_object_t *user_data) +{ + return sdb_store_query_execute(SDB_STORE(user_data), + QUERY(q), buf, errbuf); +} /* execute_query */ + +sdb_store_reader_t sdb_store_reader = { + prepare_query, execute_query, +}; /* * public API */ -void -sdb_store_clear(void) +sdb_store_t * +sdb_store_create(void) { - sdb_llist_destroy(host_list); - host_list = NULL; -} /* sdb_store_clear */ + return SDB_STORE(sdb_object_create("store", store_type)); +} /* sdb_store_create */ int -sdb_store_host(const char *name, sdb_time_t last_update) +sdb_store_host(sdb_store_t *store, const char *name, sdb_time_t last_update) { - int status; + sdb_store_host_t host = { + name, last_update, 0, NULL, 0, + }; + return store_host(&host, SDB_OBJ(store)); +} /* sdb_store_host */ - if (! name) - return -1; +int +sdb_store_service(sdb_store_t *store, const char *hostname, const char *name, + sdb_time_t last_update) +{ + sdb_store_service_t service = { + hostname, name, last_update, 0, NULL, 0, + }; + return store_service(&service, SDB_OBJ(store)); +} /* sdb_store_service */ - pthread_rwlock_wrlock(&host_lock); - status = store_obj(/* hostname = */ NULL, - /* stored object = */ SDB_HOST, name, last_update, - /* updated_obj = */ NULL); - pthread_rwlock_unlock(&host_lock); - return status; -} /* sdb_store_host */ +int +sdb_store_metric(sdb_store_t *store, const char *hostname, const char *name, + sdb_metric_store_t *metric_store, sdb_time_t last_update) +{ + sdb_store_metric_t metric = { + hostname, name, { NULL, NULL }, last_update, 0, NULL, 0, + }; + if (metric_store) { + metric.store.type = metric_store->type; + metric.store.id = metric_store->id; + } + return store_metric(&metric, SDB_OBJ(store)); +} /* sdb_store_metric */ -_Bool -sdb_store_has_host(const char *name) +int +sdb_store_attribute(sdb_store_t *store, const char *hostname, + const char *key, const sdb_data_t *value, sdb_time_t last_update) { - sdb_host_t *host; + sdb_store_attribute_t attr = { + NULL, SDB_HOST, hostname, key, SDB_DATA_INIT, last_update, 0, NULL, 0, + }; + if (value) { + attr.value = *value; + } + return store_attribute(&attr, SDB_OBJ(store)); +} /* sdb_store_attribute */ - if (! name) - return NULL; +int +sdb_store_service_attr(sdb_store_t *store, const char *hostname, + const char *service, const char *key, const sdb_data_t *value, + sdb_time_t last_update) +{ + sdb_store_attribute_t attr = { + hostname, SDB_SERVICE, service, key, SDB_DATA_INIT, last_update, 0, NULL, 0, + }; + if (value) { + attr.value = *value; + } + return store_attribute(&attr, SDB_OBJ(store)); +} /* sdb_store_service_attr */ - host = lookup_host(name); - return host != NULL; -} /* sdb_store_has_host */ +int +sdb_store_metric_attr(sdb_store_t *store, const char *hostname, + const char *metric, const char *key, const sdb_data_t *value, + sdb_time_t last_update) +{ + sdb_store_attribute_t attr = { + hostname, SDB_METRIC, metric, key, SDB_DATA_INIT, last_update, 0, NULL, 0, + }; + if (value) { + attr.value = *value; + } + return store_attribute(&attr, SDB_OBJ(store)); +} /* sdb_store_metric_attr */ sdb_store_obj_t * -sdb_store_get_host(const char *name) +sdb_store_get_host(sdb_store_t *store, const char *name) { - sdb_host_t *host; + host_t *host; - if (! name) + if ((! store) || (! name)) return NULL; - host = lookup_host(name); + host = HOST(sdb_avltree_lookup(store->hosts, name)); if (! host) return NULL; - sdb_object_ref(SDB_OBJ(host)); return STORE_OBJ(host); } /* sdb_store_get_host */ -int -sdb_store_attribute(const char *hostname, - const char *key, const sdb_data_t *value, - sdb_time_t last_update) +sdb_store_obj_t * +sdb_store_get_child(sdb_store_obj_t *host, int type, const char *name) { - int status; - - sdb_store_obj_t *updated_attr = NULL; + sdb_avltree_t *children; - if ((! hostname) || (! key)) - return -1; - - pthread_rwlock_wrlock(&host_lock); - status = store_obj(hostname, - /* stored object = */ SDB_ATTRIBUTE, key, last_update, - &updated_attr); - - if (status >= 0) { - assert(updated_attr); - sdb_data_free_datum(&ATTR(updated_attr)->value); - if (sdb_data_copy(&ATTR(updated_attr)->value, value)) { - sdb_object_deref(SDB_OBJ(updated_attr)); - status = -1; - } - } + if ((! host) || (host->type != SDB_HOST) || (! name)) + return NULL; - pthread_rwlock_unlock(&host_lock); - return status; -} /* sdb_store_attribute */ + children = get_host_children(HOST(host), type); + if (! children) + return NULL; + return STORE_OBJ(sdb_avltree_lookup(children, name)); +} /* sdb_store_get_child */ int -sdb_store_service(const char *hostname, const char *name, - sdb_time_t last_update) +sdb_store_get_field(sdb_store_obj_t *obj, int field, sdb_data_t *res) { - int status; + sdb_data_t tmp; - if ((! hostname) || (! name)) + if (! obj) return -1; - pthread_rwlock_wrlock(&host_lock); - status = store_obj(hostname, - /* stored object = */ SDB_SERVICE, name, last_update, - /* updated obj = */ NULL); - pthread_rwlock_unlock(&host_lock); - return status; -} /* sdb_store_service */ + switch (field) { + case SDB_FIELD_NAME: + tmp.type = SDB_TYPE_STRING; + tmp.data.string = strdup(SDB_OBJ(obj)->name); + if (! tmp.data.string) + return -1; + break; + case SDB_FIELD_LAST_UPDATE: + tmp.type = SDB_TYPE_DATETIME; + tmp.data.datetime = obj->last_update; + break; + case SDB_FIELD_AGE: + tmp.type = SDB_TYPE_DATETIME; + tmp.data.datetime = sdb_gettime() - obj->last_update; + break; + case SDB_FIELD_INTERVAL: + tmp.type = SDB_TYPE_DATETIME; + tmp.data.datetime = obj->interval; + break; + case SDB_FIELD_BACKEND: + if (! res) + return 0; + tmp.type = SDB_TYPE_ARRAY | SDB_TYPE_STRING; + tmp.data.array.length = obj->backends_num; + tmp.data.array.values = obj->backends; + return sdb_data_copy(res, &tmp); + case SDB_FIELD_VALUE: + if (obj->type != SDB_ATTRIBUTE) + return -1; + if (! res) + return 0; + return sdb_data_copy(res, &ATTR(obj)->value); + case SDB_FIELD_TIMESERIES: + if (obj->type != SDB_METRIC) + return -1; + tmp.type = SDB_TYPE_BOOLEAN; + tmp.data.boolean = METRIC(obj)->store.type != NULL; + default: + return -1; + } + if (res) + *res = tmp; + else + sdb_data_free_datum(&tmp); + return 0; +} /* sdb_store_get_field */ int -sdb_store_host_tojson(sdb_store_obj_t *h, sdb_strbuf_t *buf, int flags) +sdb_store_get_attr(sdb_store_obj_t *obj, const char *name, sdb_data_t *res, + sdb_store_matcher_t *filter) { - sdb_host_t *host; - char time_str[64]; - char interval_str[64]; + sdb_avltree_t *tree = NULL; + sdb_store_obj_t *attr; - if ((! h) || (h->type != SDB_HOST) || (! buf)) + if ((! obj) || (! name)) return -1; - host = HOST(h); - - if (! sdb_strftime(time_str, sizeof(time_str), - "%F %T %z", host->_last_update)) - snprintf(time_str, sizeof(time_str), ""); - time_str[sizeof(time_str) - 1] = '\0'; - - if (! sdb_strfinterval(interval_str, sizeof(interval_str), - host->_interval)) - snprintf(interval_str, sizeof(interval_str), ""); - interval_str[sizeof(interval_str) - 1] = '\0'; - - sdb_strbuf_append(buf, "{\"name\": \"%s\", " - "\"last_update\": \"%s\", \"update_interval\": \"%s\"", - SDB_OBJ(host)->name, time_str, interval_str); + if (obj->type == SDB_HOST) + tree = HOST(obj)->attributes; + else if (obj->type == SDB_SERVICE) + tree = SVC(obj)->attributes; + else if (obj->type == SDB_METRIC) + tree = METRIC(obj)->attributes; - if (! (flags & SDB_SKIP_ATTRIBUTES)) { - sdb_strbuf_append(buf, ", \"attributes\": "); - store_obj_tojson(host->attributes, SDB_ATTRIBUTE, buf); - } + if (! tree) + return -1; - if (! (flags & SDB_SKIP_SERVICES)) { - sdb_strbuf_append(buf, ", \"services\": "); - store_obj_tojson(host->services, SDB_SERVICE, buf); + attr = STORE_OBJ(sdb_avltree_lookup(tree, name)); + if (! attr) + return -1; + if (filter && (! sdb_store_matcher_matches(filter, attr, NULL))) { + sdb_object_deref(SDB_OBJ(attr)); + return -1; } - sdb_strbuf_append(buf, "}"); + assert(STORE_OBJ(attr)->type == SDB_ATTRIBUTE); + if (res) + sdb_data_copy(res, &ATTR(attr)->value); + sdb_object_deref(SDB_OBJ(attr)); return 0; -} /* sdb_store_host_tojson */ +} /* sdb_store_get_attr */ + +/* TODO: sdb_store_fetch_timeseries should move into the plugin module */ int -sdb_store_tojson(sdb_strbuf_t *buf, int flags) +sdb_store_fetch_timeseries(sdb_store_t *store, + const char *hostname, const char *metric, + sdb_timeseries_opts_t *opts, sdb_strbuf_t *buf) { - sdb_llist_iter_t *host_iter; + sdb_avltree_t *metrics; + host_t *host; + sdb_metric_t *m; + + sdb_timeseries_t *ts; + + int status = 0; - if (! buf) + if ((! store) || (! hostname) || (! metric) || (! opts) || (! buf)) return -1; - pthread_rwlock_rdlock(&host_lock); + pthread_rwlock_rdlock(&store->host_lock); + host = HOST(sdb_avltree_lookup(store->hosts, hostname)); + metrics = get_host_children(host, SDB_METRIC); + sdb_object_deref(SDB_OBJ(host)); + if (! metrics) { + sdb_log(SDB_LOG_ERR, "store: Failed to fetch time-series '%s/%s' " + "- host '%s' not found", hostname, metric, hostname); + pthread_rwlock_unlock(&store->host_lock); + return -1; + } - host_iter = sdb_llist_get_iter(host_list); - if (! host_iter) { - pthread_rwlock_unlock(&host_lock); + m = METRIC(sdb_avltree_lookup(metrics, metric)); + if (! m) { + sdb_log(SDB_LOG_ERR, "store: Failed to fetch time-series '%s/%s' " + "- metric '%s' not found", hostname, metric, metric); + pthread_rwlock_unlock(&store->host_lock); return -1; } - sdb_strbuf_append(buf, "{\"hosts\":["); + if ((! m->store.type) || (! m->store.id)) { + sdb_log(SDB_LOG_ERR, "store: Failed to fetch time-series '%s/%s' " + "- no data-store configured for the stored metric", + hostname, metric); + sdb_object_deref(SDB_OBJ(m)); + pthread_rwlock_unlock(&store->host_lock); + return -1; + } - while (sdb_llist_iter_has_next(host_iter)) { - sdb_store_obj_t *host = STORE_OBJ(sdb_llist_iter_get_next(host_iter)); - assert(host); + { + char type[strlen(m->store.type) + 1]; + char id[strlen(m->store.id) + 1]; - if (sdb_store_host_tojson(host, buf, flags)) - return -1; + strncpy(type, m->store.type, sizeof(type)); + strncpy(id, m->store.id, sizeof(id)); + pthread_rwlock_unlock(&store->host_lock); - if (sdb_llist_iter_has_next(host_iter)) - sdb_strbuf_append(buf, ","); + ts = sdb_plugin_fetch_timeseries(type, id, opts); + if (! ts) { + sdb_log(SDB_LOG_ERR, "store: Failed to fetch time-series '%s/%s' " + "- %s fetcher callback returned no data for '%s'", + hostname, metric, type, id); + status = -1; + } } - sdb_strbuf_append(buf, "]}"); - - sdb_llist_iter_destroy(host_iter); - pthread_rwlock_unlock(&host_lock); - return 0; -} /* sdb_store_tojson */ + ts_tojson(ts, buf); + sdb_object_deref(SDB_OBJ(m)); + sdb_timeseries_destroy(ts); + return status; +} /* sdb_store_fetch_timeseries */ -/* TODO: actually support hierarchical data */ int -sdb_store_iterate(sdb_store_iter_cb cb, void *user_data) +sdb_store_scan(sdb_store_t *store, int type, + sdb_store_matcher_t *m, sdb_store_matcher_t *filter, + sdb_store_lookup_cb cb, void *user_data) { - sdb_llist_iter_t *host_iter; + sdb_avltree_iter_t *host_iter = NULL; int status = 0; - pthread_rwlock_rdlock(&host_lock); + if ((! store) || (! cb)) + return -1; + + if ((type != SDB_HOST) && (type != SDB_SERVICE) && (type != SDB_METRIC)) { + sdb_log(SDB_LOG_ERR, "store: Cannot scan objects of type %d", type); + return -1; + } - host_iter = sdb_llist_get_iter(host_list); + pthread_rwlock_rdlock(&store->host_lock); + host_iter = sdb_avltree_get_iter(store->hosts); if (! host_iter) status = -1; /* has_next returns false if the iterator is NULL */ - while (sdb_llist_iter_has_next(host_iter)) { - sdb_store_obj_t *host = STORE_OBJ(sdb_llist_iter_get_next(host_iter)); + while (sdb_avltree_iter_has_next(host_iter)) { + sdb_store_obj_t *host; + sdb_avltree_iter_t *iter = NULL; + + host = STORE_OBJ(sdb_avltree_iter_get_next(host_iter)); assert(host); - if (cb(host, user_data)) { - status = -1; - break; + if (! sdb_store_matcher_matches(filter, host, NULL)) + continue; + + if (type == SDB_SERVICE) + iter = sdb_avltree_get_iter(HOST(host)->services); + else if (type == SDB_METRIC) + iter = sdb_avltree_get_iter(HOST(host)->metrics); + + if (iter) { + while (sdb_avltree_iter_has_next(iter)) { + sdb_store_obj_t *obj; + obj = STORE_OBJ(sdb_avltree_iter_get_next(iter)); + assert(obj); + + if (sdb_store_matcher_matches(m, obj, filter)) { + if (cb(obj, filter, user_data)) { + sdb_log(SDB_LOG_ERR, "store: Callback returned " + "an error while scanning"); + status = -1; + break; + } + } + } } + else if (sdb_store_matcher_matches(m, host, filter)) { + if (cb(host, filter, user_data)) { + sdb_log(SDB_LOG_ERR, "store: Callback returned " + "an error while scanning"); + status = -1; + } + } + + sdb_avltree_iter_destroy(iter); + if (status) + break; } - sdb_llist_iter_destroy(host_iter); - pthread_rwlock_unlock(&host_lock); + sdb_avltree_iter_destroy(host_iter); + pthread_rwlock_unlock(&store->host_lock); return status; -} /* sdb_store_iterate */ +} /* sdb_store_scan */ /* vim: set tw=78 sw=4 ts=4 noexpandtab : */