X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;ds=sidebyside;f=src%2Fcore%2Fstore_json.c;h=256fdeac0496f9a55f97fa53bf3ee10f7c375ada;hb=1f99d1a0d8a7e923dede7c938340c26061b8398b;hp=493ac9f377c9072d54fdf76488ab242e76cc6ec6;hpb=914549be3bfffdd3ad4b2599ed1e771d857512da;p=sysdb.git diff --git a/src/core/store_json.c b/src/core/store_json.c index 493ac9f..256fdea 100644 --- a/src/core/store_json.c +++ b/src/core/store_json.c @@ -1,6 +1,6 @@ /* * SysDB - src/core/store_json.c - * Copyright (C) 2013-2014 Sebastian 'tokkee' Harl + * Copyright (C) 2013-2015 Sebastian 'tokkee' Harl * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -34,18 +34,24 @@ #endif /* HAVE_CONFIG_H */ #include "sysdb.h" -#include "core/store-private.h" +#include "core/store.h" #include "utils/error.h" +#include "utils/strings.h" #include +#include #include +#include /* * private data types */ struct sdb_store_json_formatter { + sdb_object_t super; + + /* The string buffer to write to */ sdb_strbuf_t *buf; /* The context describes the state of the formatter through @@ -53,216 +59,363 @@ struct sdb_store_json_formatter { int context[8]; size_t current; - /* The current host context when processing non-host objects */ - sdb_store_obj_t *current_host; - int type; int flags; }; - -/* - * private helper functions - */ +#define F(obj) ((sdb_store_json_formatter_t *)(obj)) static int -json_emit(sdb_store_json_formatter_t *f, sdb_store_obj_t *obj) +formatter_init(sdb_object_t *obj, va_list ap) { - char time_str[64]; - char interval_str[64]; - size_t i; + sdb_store_json_formatter_t *f = F(obj); - assert(f && obj); - - if ((f->type != SDB_HOST) && (f->type == obj->type)) { - /* create the host for the current entry first */ - assert(obj->parent && (obj->parent->type == SDB_HOST)); - if (f->current_host != obj->parent) { - json_emit(f, obj->parent); - sdb_strbuf_append(f->buf, ", \"%ss\": [", - SDB_STORE_TYPE_TO_NAME(obj->type)); - f->current_host = obj->parent; - } - } + f->buf = va_arg(ap, sdb_strbuf_t *); + if (! f->buf) + return -1; - sdb_strbuf_append(f->buf, "{\"name\": \"%s\", ", SDB_OBJ(obj)->name); - if (obj->type == SDB_ATTRIBUTE) { - char tmp[sdb_data_strlen(&ATTR(obj)->value) + 1]; - if (sdb_data_format(&ATTR(obj)->value, tmp, sizeof(tmp), - SDB_DOUBLE_QUOTED) < 0) - snprintf(tmp, sizeof(tmp), ""); - sdb_strbuf_append(f->buf, "\"value\": %s, ", tmp); - } + f->type = va_arg(ap, int); + if ((f->type != SDB_HOST) && (f->type != SDB_SERVICE) && (f->type != SDB_METRIC)) + return -1; - /* TODO: make time and interval formats configurable */ - if (! sdb_strftime(time_str, sizeof(time_str), - "%F %T %z", obj->last_update)) - snprintf(time_str, sizeof(time_str), ""); - time_str[sizeof(time_str) - 1] = '\0'; + f->flags = va_arg(ap, int); - if (! sdb_strfinterval(interval_str, sizeof(interval_str), - obj->interval)) - snprintf(interval_str, sizeof(interval_str), ""); - interval_str[sizeof(interval_str) - 1] = '\0'; + f->context[0] = 0; + f->current = 0; + return 0; +} /* formatter_init */ - sdb_strbuf_append(f->buf, "\"last_update\": \"%s\", " - "\"update_interval\": \"%s\", \"backends\": [", - time_str, interval_str); +static sdb_type_t formatter_type = { + /* size = */ sizeof(sdb_store_json_formatter_t), + /* init = */ formatter_init, + /* destroy = */ NULL, +}; - for (i = 0; i < obj->backends_num; ++i) { - sdb_strbuf_append(f->buf, "\"%s\"", obj->backends[i]); - if (i < obj->backends_num - 1) - sdb_strbuf_append(f->buf, ","); - } - sdb_strbuf_append(f->buf, "]"); - return 0; -} /* json_emit */ +/* A generic representation of a stored object. */ +typedef struct { + /* identifier */ + int type; + const char *name; + + /* attribute value (optional) */ + sdb_data_t *value; + + /* metric's timeseries (optional) + * -1: unset + * 0: false + * 1: true */ + int timeseries; + char **data_names; + size_t data_names_len; + + /* generic meta-data */ + sdb_time_t last_update; + sdb_time_t interval; + size_t backends_num; + const char * const *backends; +} obj_t; /* - * public API + * private helper functions */ -sdb_store_json_formatter_t * -sdb_store_json_formatter(sdb_strbuf_t *buf, int type, int flags) -{ - sdb_store_json_formatter_t *f; - - if (! buf) - return NULL; - - if ((type != SDB_HOST) && (type != SDB_SERVICE) && (type != SDB_METRIC)) - return NULL; - - f = calloc(1, sizeof(*f)); - if (! f) - return NULL; - - f->buf = buf; - f->context[0] = 0; - f->current = 0; - - f->current_host = NULL; - - f->type = type; - f->flags = flags; - return f; -} /* sdb_store_json_formatter */ - -int -sdb_store_json_emit(sdb_store_json_formatter_t *f, sdb_store_obj_t *obj) +static void +escape_string(const char *src, char *dest) { - if ((! f) || (! obj)) - return -1; - - if ((f->type != SDB_HOST) && (obj->type == SDB_HOST)) { - sdb_log(SDB_LOG_ERR, "store: Unexpected object of type host " - "during %s JSON serialization", - SDB_STORE_TYPE_TO_NAME(f->type)); - return -1; + size_t i = 1; + dest[0] = '"'; + for ( ; *src; ++src) { + char c = *src; + if ((c == '"') || (c == '\\') || iscntrl((int)c)) { + dest[i] = '\\'; + ++i; + } + switch (c) { + case '\a': dest[i] = 'a'; break; + case '\b': dest[i] = 'b'; break; + case '\t': dest[i] = 't'; break; + case '\n': dest[i] = 'n'; break; + case '\v': dest[i] = 'v'; break; + case '\f': dest[i] = 'f'; break; + case '\r': dest[i] = 'r'; break; + default: dest[i] = c; break; + } + ++i; } + dest[i] = '"'; + dest[i + 1] = '\0'; +} /* escape_string */ +/* handle_new_object takes care of all maintenance logic related to adding a + * new object. That is, it manages context information and emit the prefix and + * suffix of an object. */ +static int +handle_new_object(sdb_store_json_formatter_t *f, int type) +{ /* first top-level object */ if (! f->context[0]) { - if (obj->type != f->type) { + if ((type != f->type) && (type != SDB_HOST)) { sdb_log(SDB_LOG_ERR, "store: Unexpected object of type %s " "as the first element during %s JSON serialization", - SDB_STORE_TYPE_TO_NAME(obj->type), + SDB_STORE_TYPE_TO_NAME(type), SDB_STORE_TYPE_TO_NAME(f->type)); return -1; } if (f->flags & SDB_WANT_ARRAY) sdb_strbuf_append(f->buf, "["); assert(f->current == 0); - f->context[0] = obj->type; - return json_emit(f, obj); + f->context[f->current] = type; + return 0; } - if ((f->current >= 1) && (obj->type != SDB_ATTRIBUTE)) { - /* new entry of a previous type or a new type on the same level; + if ((f->context[f->current] != SDB_HOST) + && (type != SDB_ATTRIBUTE)) { + /* new entry of the same type or a parent object; * rewind to the right state */ - while (f->current > 0) { - if (f->context[f->current] == obj->type) - break; + while ((f->current > 0) + && (f->context[f->current] != type)) { sdb_strbuf_append(f->buf, "}]"); --f->current; } } - if ((obj->type == f->type) && (f->type != SDB_HOST)) - if (obj->parent != f->current_host) - sdb_strbuf_append(f->buf, "}]"); - if (obj->type == f->context[f->current]) { + if (type == f->context[f->current]) { /* new entry of the same type */ sdb_strbuf_append(f->buf, "},"); } else if ((f->context[f->current] == SDB_HOST) - || (obj->type == SDB_ATTRIBUTE)) { - assert(obj->type != SDB_HOST); + || (type == SDB_ATTRIBUTE)) { + assert(type != SDB_HOST); /* all object types may be children of a host; * attributes may be children of any type */ sdb_strbuf_append(f->buf, ", \"%ss\": [", - SDB_STORE_TYPE_TO_NAME(obj->type)); + SDB_STORE_TYPE_TO_NAME(type)); ++f->current; } else { sdb_log(SDB_LOG_ERR, "store: Unexpected object of type %s " "on level %zu during JSON serialization", - SDB_STORE_TYPE_TO_NAME(obj->type), f->current); + SDB_STORE_TYPE_TO_NAME(type), f->current); return -1; } - json_emit(f, obj); assert(f->current < SDB_STATIC_ARRAY_LEN(f->context)); - f->context[f->current] = obj->type; + f->context[f->current] = type; return 0; -} /* sdb_store_json_emit */ +} /* handle_new_object */ -int -sdb_store_json_emit_full(sdb_store_json_formatter_t *f, sdb_store_obj_t *obj, - sdb_store_matcher_t *filter) +static int +json_emit(sdb_store_json_formatter_t *f, obj_t *obj) { - sdb_avltree_t *trees[] = { NULL, NULL, NULL }; + char time_str[64]; + char interval_str[64]; + char name[2 * strlen(obj->name) + 3]; size_t i; - if (sdb_store_json_emit(f, obj)) + assert(f && obj); + + handle_new_object(f, obj->type); + + escape_string(obj->name, name); + sdb_strbuf_append(f->buf, "{\"name\": %s, ", name); + if ((obj->type == SDB_ATTRIBUTE) && (obj->value)) { + char tmp[sdb_data_strlen(obj->value) + 1]; + char val[2 * sizeof(tmp) + 3]; + if (! sdb_data_format(obj->value, tmp, sizeof(tmp), + SDB_DOUBLE_QUOTED)) + snprintf(tmp, sizeof(tmp), ""); + + if (tmp[0] == '"') { + /* a string; escape_string handles quoting */ + tmp[strlen(tmp) - 1] = '\0'; + escape_string(tmp + 1, val); + sdb_strbuf_append(f->buf, "\"value\": %s, ", val); + } + else + sdb_strbuf_append(f->buf, "\"value\": %s, ", tmp); + } + else if ((obj->type == SDB_METRIC) && (obj->timeseries >= 0)) { + if (obj->timeseries) + sdb_strbuf_append(f->buf, "\"timeseries\": true, "); + else + sdb_strbuf_append(f->buf, "\"timeseries\": false, "); + + if (obj->data_names_len > 0) { + sdb_strbuf_append(f->buf, "\"data_names\": ["); + for (i = 0; i < obj->data_names_len; i++) { + char dn[2 * strlen(obj->data_names[i]) + 3]; + escape_string(obj->data_names[i], dn); + sdb_strbuf_append(f->buf, "%s", dn); + if (i < obj->data_names_len - 1) + sdb_strbuf_append(f->buf, ", "); + } + sdb_strbuf_append(f->buf, "], "); + } + } + + /* TODO: make time and interval formats configurable */ + if (! sdb_strftime(time_str, sizeof(time_str), obj->last_update)) + snprintf(time_str, sizeof(time_str), ""); + time_str[sizeof(time_str) - 1] = '\0'; + + if (! sdb_strfinterval(interval_str, sizeof(interval_str), + obj->interval)) + snprintf(interval_str, sizeof(interval_str), ""); + interval_str[sizeof(interval_str) - 1] = '\0'; + + sdb_strbuf_append(f->buf, "\"last_update\": \"%s\", " + "\"update_interval\": \"%s\", \"backends\": [", + time_str, interval_str); + + for (i = 0; i < obj->backends_num; ++i) { + sdb_strbuf_append(f->buf, "\"%s\"", obj->backends[i]); + if (i < obj->backends_num - 1) + sdb_strbuf_append(f->buf, ","); + } + sdb_strbuf_append(f->buf, "]"); + return 0; +} /* json_emit */ + +static int +emit_host(sdb_store_host_t *host, sdb_object_t *user_data) +{ + sdb_store_json_formatter_t *f = F(user_data); + + if ((! host) || (! user_data)) return -1; - if (obj->type == SDB_HOST) { - trees[0] = HOST(obj)->attributes; - trees[1] = HOST(obj)->metrics; - trees[2] = HOST(obj)->services; + { + obj_t o = { + SDB_HOST, + host->name, + + /* value */ NULL, + /* timeseries */ -1, NULL, 0, + + host->last_update, + host->interval, + host->backends_num, + (const char * const *)host->backends, + }; + + return json_emit(f, &o); } - else if (obj->type == SDB_SERVICE) - trees[0] = SVC(obj)->attributes; - else if (obj->type == SDB_METRIC) - trees[0] = METRIC(obj)->attributes; - else if (obj->type == SDB_ATTRIBUTE) - return 0; - else +} /* emit_host */ + +static int +emit_service(sdb_store_service_t *service, sdb_object_t *user_data) +{ + sdb_store_json_formatter_t *f = F(user_data); + + if ((! service) || (! user_data)) return -1; - for (i = 0; i < SDB_STATIC_ARRAY_LEN(trees); ++i) { - sdb_avltree_iter_t *iter; + { + obj_t o = { + SDB_SERVICE, + service->name, - if (! trees[i]) - continue; + /* value */ NULL, + /* timeseries */ -1, NULL, 0, - iter = sdb_avltree_get_iter(trees[i]); - while (sdb_avltree_iter_has_next(iter)) { - sdb_store_obj_t *child; - child = STORE_OBJ(sdb_avltree_iter_get_next(iter)); + service->last_update, + service->interval, + service->backends_num, + (const char * const *)service->backends, + }; - if (filter && (! sdb_store_matcher_matches(filter, child, NULL))) + return json_emit(f, &o); + } +} /* emit_service */ + +static int +emit_metric(sdb_store_metric_t *metric, sdb_object_t *user_data) +{ + sdb_store_json_formatter_t *f = F(user_data); + int status; + size_t i; + + if ((! metric) || (! user_data)) + return -1; + + { + obj_t o = { + SDB_METRIC, + metric->name, + + /* value */ NULL, + /* timeseries */ metric->stores_num > 0, NULL, 0, + + metric->last_update, + metric->interval, + metric->backends_num, + (const char * const *)metric->backends, + }; + + for (i = 0; i < metric->stores_num; i++) { + const sdb_metric_store_t *s = metric->stores + i; + size_t j; + + if (! s->info) continue; - if (sdb_store_json_emit_full(f, child, filter)) { - sdb_avltree_iter_destroy(iter); - return -1; + if (! o.data_names) { + stringv_copy(&o.data_names, &o.data_names_len, + (const char * const *)s->info->data_names, + s->info->data_names_len); + continue; } + + for (j = 0; j < s->info->data_names_len; j++) + stringv_append_if_missing(&o.data_names, &o.data_names_len, + s->info->data_names[j]); } - sdb_avltree_iter_destroy(iter); + + status = json_emit(f, &o); + stringv_free(&o.data_names, &o.data_names_len); + return status; } - return 0; -} /* sdb_store_json_emit_full */ +} /* emit_metric */ + +static int +emit_attribute(sdb_store_attribute_t *attr, sdb_object_t *user_data) +{ + sdb_store_json_formatter_t *f = F(user_data); + + if ((! attr) || (! user_data)) + return -1; + + { + obj_t o = { + SDB_ATTRIBUTE, + attr->key, + + /* value */ &attr->value, + /* timeseries */ -1, NULL, 0, + + attr->last_update, + attr->interval, + attr->backends_num, + (const char * const *)attr->backends, + }; + + return json_emit(f, &o); + } +} /* emit_attribute */ + +/* + * public API + */ + +sdb_store_writer_t sdb_store_json_writer = { + emit_host, emit_service, emit_metric, emit_attribute, +}; + +sdb_store_json_formatter_t * +sdb_store_json_formatter(sdb_strbuf_t *buf, int type, int flags) +{ + return F(sdb_object_create("json-formatter", formatter_type, + buf, type, flags)); +} /* sdb_store_json_formatter */ int sdb_store_json_finish(sdb_store_json_formatter_t *f) @@ -281,12 +434,7 @@ sdb_store_json_finish(sdb_store_json_formatter_t *f) sdb_strbuf_append(f->buf, "}]"); --f->current; } - if (f->context[0] != SDB_HOST) { - assert(f->type != SDB_HOST); - sdb_strbuf_append(f->buf, "}]}"); - } - else - sdb_strbuf_append(f->buf, "}"); + sdb_strbuf_append(f->buf, "}"); if (f->flags & SDB_WANT_ARRAY) sdb_strbuf_append(f->buf, "]");