Code

store: Add separate store-object types for the store writer API.
authorSebastian Harl <sh@tokkee.org>
Tue, 22 Sep 2015 08:09:24 +0000 (10:09 +0200)
committerSebastian Harl <sh@tokkee.org>
Tue, 22 Sep 2015 08:09:24 +0000 (10:09 +0200)
The argument list of some of the callbacks has already gotten kinda long and
we'll want to add more (backends, etc.). Introduce new types which provide all
meta-data of the respective store types.

Also, only use a single callback to store all kinds of attributes, similar to
how it was already done in the "proto" module.

src/core/plugin.c
src/core/store.c
src/include/core/store.h
src/plugins/store/network.c

index 54f3f7f..2cb852e 100644 (file)
@@ -406,8 +406,7 @@ plugin_writer_init(sdb_object_t *obj, va_list ap)
        assert(impl);
 
        if ((! impl->store_host) || (! impl->store_service)
-                       || (! impl->store_metric) || (! impl->store_attribute)
-                       || (! impl->store_service_attr) || (! impl->store_metric_attr)) {
+                       || (! impl->store_metric) || (! impl->store_attribute)) {
                sdb_log(SDB_LOG_ERR, "core: store writer callback '%s' "
                                "does not fully implement the writer interface.",
                                obj->name);
@@ -1470,6 +1469,7 @@ sdb_plugin_query(sdb_ast_node_t *ast, sdb_strbuf_t *buf, sdb_strbuf_t *errbuf)
 int
 sdb_plugin_store_host(const char *name, sdb_time_t last_update)
 {
+       sdb_store_host_t host = { 0 };
        char *cname;
 
        sdb_llist_iter_t *iter;
@@ -1490,12 +1490,15 @@ sdb_plugin_store_host(const char *name, sdb_time_t last_update)
                return -1;
        }
 
+       host.name = cname;
+       host.last_update = last_update;
+
        iter = sdb_llist_get_iter(writer_list);
        while (sdb_llist_iter_has_next(iter)) {
                writer_t *writer = WRITER(sdb_llist_iter_get_next(iter));
                int s;
                assert(writer);
-               s = writer->impl.store_host(cname, last_update, writer->w_user_data);
+               s = writer->impl.store_host(&host, writer->w_user_data);
                if (((s > 0) && (status >= 0)) || (s < 0))
                        status = s;
        }
@@ -1508,10 +1511,12 @@ int
 sdb_plugin_store_service(const char *hostname, const char *name,
                sdb_time_t last_update)
 {
+       sdb_store_service_t service = { 0 };
+       char *cname;
+
        sdb_llist_iter_t *iter;
        sdb_data_t d;
 
-       char *cname;
        int status = 0;
 
        if ((! hostname) || (! name))
@@ -1529,13 +1534,16 @@ sdb_plugin_store_service(const char *hostname, const char *name,
                return -1;
        }
 
+       service.hostname = cname;
+       service.name = name;
+       service.last_update = last_update;
+
        iter = sdb_llist_get_iter(writer_list);
        while (sdb_llist_iter_has_next(iter)) {
                writer_t *writer = WRITER(sdb_llist_iter_get_next(iter));
                int s;
                assert(writer);
-               s = writer->impl.store_service(cname, name, last_update,
-                               writer->w_user_data);
+               s = writer->impl.store_service(&service, writer->w_user_data);
                if (((s > 0) && (status >= 0)) || (s < 0))
                        status = s;
        }
@@ -1558,10 +1566,12 @@ int
 sdb_plugin_store_metric(const char *hostname, const char *name,
                sdb_metric_store_t *store, sdb_time_t last_update)
 {
+       sdb_store_metric_t metric = { 0 };
+       char *cname;
+
        sdb_llist_iter_t *iter;
        sdb_data_t d;
 
-       char *cname;
        int status = 0;
 
        if ((! hostname) || (! name))
@@ -1582,13 +1592,20 @@ sdb_plugin_store_metric(const char *hostname, const char *name,
        if (store && ((! store->type) || (! store->id)))
                store = NULL;
 
+       metric.hostname = cname;
+       metric.name = name;
+       if (store) {
+               metric.store.type = store->type;
+               metric.store.id = store->id;
+       }
+       metric.last_update = last_update;
+
        iter = sdb_llist_get_iter(writer_list);
        while (sdb_llist_iter_has_next(iter)) {
                writer_t *writer = WRITER(sdb_llist_iter_get_next(iter));
                int s;
                assert(writer);
-               s = writer->impl.store_metric(cname, name, store, last_update,
-                               writer->w_user_data);
+               s = writer->impl.store_metric(&metric, writer->w_user_data);
                if (((s > 0) && (status >= 0)) || (s < 0))
                        status = s;
        }
@@ -1611,6 +1628,7 @@ int
 sdb_plugin_store_attribute(const char *hostname, const char *key,
                const sdb_data_t *value, sdb_time_t last_update)
 {
+       sdb_store_attribute_t attr = { 0 };
        char *cname;
 
        sdb_llist_iter_t *iter;
@@ -1631,13 +1649,18 @@ sdb_plugin_store_attribute(const char *hostname, const char *key,
                return -1;
        }
 
+       attr.parent_type = SDB_HOST;
+       attr.parent = cname;
+       attr.key = key;
+       attr.value = *value;
+       attr.last_update = last_update;
+
        iter = sdb_llist_get_iter(writer_list);
        while (sdb_llist_iter_has_next(iter)) {
                writer_t *writer = WRITER(sdb_llist_iter_get_next(iter));
                int s;
                assert(writer);
-               s = writer->impl.store_attribute(cname, key, value, last_update,
-                               writer->w_user_data);
+               s = writer->impl.store_attribute(&attr, writer->w_user_data);
                if (((s > 0) && (status >= 0)) || (s < 0))
                        status = s;
        }
@@ -1650,6 +1673,7 @@ int
 sdb_plugin_store_service_attribute(const char *hostname, const char *service,
                const char *key, const sdb_data_t *value, sdb_time_t last_update)
 {
+       sdb_store_attribute_t attr = { 0 };
        char *cname;
 
        sdb_llist_iter_t *iter;
@@ -1670,13 +1694,19 @@ sdb_plugin_store_service_attribute(const char *hostname, const char *service,
                return -1;
        }
 
+       attr.hostname = cname;
+       attr.parent_type = SDB_SERVICE;
+       attr.parent = service;
+       attr.key = key;
+       attr.value = *value;
+       attr.last_update = last_update;
+
        iter = sdb_llist_get_iter(writer_list);
        while (sdb_llist_iter_has_next(iter)) {
                writer_t *writer = WRITER(sdb_llist_iter_get_next(iter));
                int s;
                assert(writer);
-               s = writer->impl.store_service_attr(cname, service,
-                               key, value, last_update, writer->w_user_data);
+               s = writer->impl.store_attribute(&attr, writer->w_user_data);
                if (((s > 0) && (status >= 0)) || (s < 0))
                        status = s;
        }
@@ -1689,6 +1719,7 @@ int
 sdb_plugin_store_metric_attribute(const char *hostname, const char *metric,
                const char *key, const sdb_data_t *value, sdb_time_t last_update)
 {
+       sdb_store_attribute_t attr = { 0 };
        char *cname;
 
        sdb_llist_iter_t *iter;
@@ -1709,13 +1740,19 @@ sdb_plugin_store_metric_attribute(const char *hostname, const char *metric,
                return -1;
        }
 
+       attr.hostname = cname;
+       attr.parent_type = SDB_METRIC;
+       attr.parent = metric;
+       attr.key = key;
+       attr.value = *value;
+       attr.last_update = last_update;
+
        iter = sdb_llist_get_iter(writer_list);
        while (sdb_llist_iter_has_next(iter)) {
                writer_t *writer = WRITER(sdb_llist_iter_get_next(iter));
                int s;
                assert(writer);
-               s = writer->impl.store_metric_attr(cname, metric,
-                               key, value, last_update, writer->w_user_data);
+               s = writer->impl.store_attribute(&attr, writer->w_user_data);
                if (((s > 0) && (status >= 0)) || (s < 0))
                        status = s;
        }
index 3936020..7772548 100644 (file)
@@ -444,17 +444,17 @@ store_attr(sdb_store_obj_t *parent, sdb_avltree_t *attributes,
 } /* store_attr */
 
 static int
-store_metric_store(sdb_metric_t *metric, sdb_metric_store_t *store)
+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, store->type)) {
-               if (! (type = strdup(store->type)))
+       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, store->id)) {
-               if (! (id = strdup(store->id))) {
+       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;
@@ -554,31 +554,70 @@ ts_tojson(sdb_timeseries_t *ts, sdb_strbuf_t *buf)
  */
 
 static int
-store_attribute(const char *hostname,
-               const char *key, const sdb_data_t *value,
-               sdb_time_t last_update, sdb_object_t *user_data)
+store_attribute(sdb_store_attribute_t *attr, sdb_object_t *user_data)
 {
        sdb_store_t *st = SDB_STORE(user_data);
-
+       const char *hostname;
        host_t *host;
+
+       sdb_store_obj_t *obj = NULL;
+       sdb_avltree_t *children = NULL;
        sdb_avltree_t *attrs;
        int status = 0;
 
-       if ((! hostname) || (! key))
+       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));
-       attrs = get_host_children(host, SDB_ATTRIBUTE);
-       if (! attrs) {
+       if (! host) {
                sdb_log(SDB_LOG_ERR, "store: Failed to store attribute '%s' - "
-                               "host '%s' not found", key, hostname);
+                               "host '%s' not found", attr->key, hostname);
+               status = -1;
+       }
+
+       switch (attr->parent_type) {
+       case SDB_HOST:
+               obj = STORE_OBJ(host);
+               attrs = 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 = STORE_OBJ(sdb_avltree_lookup(children, attr->parent));
+               if (! obj) {
+                       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
+                       attrs = attr->parent_type == SDB_SERVICE
+                               ? SVC(obj)->attributes
+                               : METRIC(obj)->attributes;
        }
 
        if (! status)
-               status = store_attr(STORE_OBJ(host), attrs, key, value, last_update);
+               status = store_attr(obj, attrs, attr->key, &attr->value, attr->last_update);
 
+       if (obj != STORE_OBJ(host))
+               sdb_object_deref(SDB_OBJ(obj));
        sdb_object_deref(SDB_OBJ(host));
        pthread_rwlock_unlock(&st->host_lock);
 
@@ -586,69 +625,24 @@ store_attribute(const char *hostname,
 } /* store_attribute */
 
 static int
-store_host(const char *name, sdb_time_t last_update, sdb_object_t *user_data)
+store_host(sdb_store_host_t *host, sdb_object_t *user_data)
 {
        sdb_store_t *st = SDB_STORE(user_data);
        int status = 0;
 
-       if (! name)
+       if ((! host) || (! host->name))
                return -1;
 
        pthread_rwlock_wrlock(&st->host_lock);
        status = store_obj(NULL, st->hosts,
-                       SDB_HOST, name, last_update, NULL);
+                       SDB_HOST, host->name, host->last_update, NULL);
        pthread_rwlock_unlock(&st->host_lock);
 
        return status;
 } /* store_host */
 
 static int
-store_service_attr(const char *hostname, const char *service,
-               const char *key, const sdb_data_t *value, sdb_time_t last_update,
-               sdb_object_t *user_data)
-{
-       sdb_store_t *st = SDB_STORE(user_data);
-
-       host_t *host;
-       service_t *svc;
-       sdb_avltree_t *services;
-       int status = 0;
-
-       if ((! hostname) || (! service) || (! key))
-               return -1;
-
-       pthread_rwlock_wrlock(&st->host_lock);
-       host = HOST(sdb_avltree_lookup(st->hosts, hostname));
-       services = get_host_children(host, SDB_SERVICE);
-       sdb_object_deref(SDB_OBJ(host));
-       if (! services) {
-               sdb_log(SDB_LOG_ERR, "store: Failed to store attribute '%s' "
-                               "for service '%s' - host '%ss' not found",
-                               key, service, hostname);
-               pthread_rwlock_unlock(&st->host_lock);
-               return -1;
-       }
-
-       svc = SVC(sdb_avltree_lookup(services, service));
-       if (! svc) {
-               sdb_log(SDB_LOG_ERR, "store: Failed to store attribute '%s' - "
-                               "service '%s/%s' not found", key, hostname, service);
-               status = -1;
-       }
-
-       if (! status)
-               status = store_attr(STORE_OBJ(svc), svc->attributes,
-                               key, value, last_update);
-
-       sdb_object_deref(SDB_OBJ(svc));
-       pthread_rwlock_unlock(&st->host_lock);
-
-       return status;
-} /* store_service_attr */
-
-static int
-store_service(const char *hostname, const char *name,
-               sdb_time_t last_update, sdb_object_t *user_data)
+store_service(sdb_store_service_t *service, sdb_object_t *user_data)
 {
        sdb_store_t *st = SDB_STORE(user_data);
 
@@ -657,21 +651,21 @@ store_service(const char *hostname, const char *name,
 
        int status = 0;
 
-       if ((! hostname) || (! name))
+       if ((! service) || (! service->hostname) || (! service->name))
                return -1;
 
        pthread_rwlock_wrlock(&st->host_lock);
-       host = HOST(sdb_avltree_lookup(st->hosts, hostname));
+       host = HOST(sdb_avltree_lookup(st->hosts, service->hostname));
        services = get_host_children(host, SDB_SERVICE);
        if (! services) {
                sdb_log(SDB_LOG_ERR, "store: Failed to store service '%s' - "
-                               "host '%s' not found", name, hostname);
+                               "host '%s' not found", service->name, service->hostname);
                status = -1;
        }
 
        if (! status)
                status = store_obj(STORE_OBJ(host), services, SDB_SERVICE,
-                               name, last_update, NULL);
+                               service->name, service->last_update, NULL);
 
        sdb_object_deref(SDB_OBJ(host));
        pthread_rwlock_unlock(&st->host_lock);
@@ -679,86 +673,34 @@ store_service(const char *hostname, const char *name,
 } /* store_service */
 
 static int
-store_metric_attr(const char *hostname, const char *metric,
-               const char *key, const sdb_data_t *value, sdb_time_t last_update,
-               sdb_object_t *user_data)
-{
-       sdb_store_t *st = SDB_STORE(user_data);
-
-       sdb_avltree_t *metrics;
-       host_t *host;
-       sdb_metric_t *m;
-       int status = 0;
-
-       if ((! hostname) || (! metric) || (! key))
-               return -1;
-
-       pthread_rwlock_wrlock(&st->host_lock);
-       host = HOST(sdb_avltree_lookup(st->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 store attribute '%s' "
-                               "for metric '%s' - host '%s' not found",
-                               key, metric, hostname);
-               pthread_rwlock_unlock(&st->host_lock);
-               return -1;
-       }
-
-       m = METRIC(sdb_avltree_lookup(metrics, metric));
-       if (! m) {
-               sdb_log(SDB_LOG_ERR, "store: Failed to store attribute '%s' - "
-                               "metric '%s/%s' not found", key, hostname, metric);
-               status = -1;
-       }
-
-       if (! status)
-               status = store_attr(STORE_OBJ(m), m->attributes,
-                               key, value, last_update);
-
-       sdb_object_deref(SDB_OBJ(m));
-       pthread_rwlock_unlock(&st->host_lock);
-
-       return status;
-} /* store_metric_attr */
-
-static int
-store_metric(const char *hostname, const char *name,
-               sdb_metric_store_t *store, sdb_time_t last_update,
-               sdb_object_t *user_data)
+store_metric(sdb_store_metric_t *metric, sdb_object_t *user_data)
 {
        sdb_store_t *st = SDB_STORE(user_data);
 
        sdb_store_obj_t *obj = NULL;
-       host_t *host;
-       sdb_metric_t *metric;
-
        sdb_avltree_t *metrics;
+       host_t *host;
 
        int status = 0;
 
-       if ((! hostname) || (! name))
+       if ((! metric) || (! metric->hostname) || (! metric->name))
                return -1;
 
-       if (store) {
-               if ((store->type != NULL) != (store->id != NULL))
-                       return -1;
-               else if (! store->type)
-                       store = NULL;
-       }
+       if ((metric->store.type != NULL) != (metric->store.id != NULL))
+               return -1;
 
        pthread_rwlock_wrlock(&st->host_lock);
-       host = HOST(sdb_avltree_lookup(st->hosts, hostname));
+       host = HOST(sdb_avltree_lookup(st->hosts, metric->hostname));
        metrics = get_host_children(host, SDB_METRIC);
        if (! metrics) {
                sdb_log(SDB_LOG_ERR, "store: Failed to store metric '%s' - "
-                               "host '%s' not found", name, hostname);
+                               "host '%s' not found", metric->name, metric->hostname);
                status = -1;
        }
 
        if (! status)
                status = store_obj(STORE_OBJ(host), metrics, SDB_METRIC,
-                               name, last_update, &obj);
+                               metric->name, metric->last_update, &obj);
        sdb_object_deref(SDB_OBJ(host));
 
        if (status) {
@@ -767,18 +709,15 @@ store_metric(const char *hostname, const char *name,
        }
 
        assert(obj);
-       metric = METRIC(obj);
-
-       if (store)
-               if (store_metric_store(metric, store))
+       if (metric->store.type && metric->store.id)
+               if (store_metric_store(METRIC(obj), 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, store_service_attr, store_metric_attr,
+       store_host, store_service, store_metric, store_attribute,
 };
 
 static sdb_object_t *
@@ -815,28 +754,47 @@ sdb_store_create(void)
 int
 sdb_store_host(sdb_store_t *store, const char *name, sdb_time_t last_update)
 {
-       return store_host(name, last_update, SDB_OBJ(store));
+       sdb_store_host_t host = {
+               name, last_update, 0, NULL, 0,
+       };
+       return store_host(&host, SDB_OBJ(store));
 } /* sdb_store_host */
 
 int
 sdb_store_service(sdb_store_t *store, const char *hostname, const char *name,
                sdb_time_t last_update)
 {
-       return store_service(hostname, name, last_update, SDB_OBJ(store));
+       sdb_store_service_t service = {
+               hostname, name, last_update, 0, NULL, 0,
+       };
+       return store_service(&service, SDB_OBJ(store));
 } /* sdb_store_service */
 
 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)
 {
-       return store_metric(hostname, name, metric_store, last_update, SDB_OBJ(store));
+       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 */
 
 int
 sdb_store_attribute(sdb_store_t *store, const char *hostname,
                const char *key, const sdb_data_t *value, sdb_time_t last_update)
 {
-       return store_attribute(hostname, key, value, last_update, SDB_OBJ(store));
+       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 */
 
 int
@@ -844,8 +802,13 @@ 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)
 {
-       return store_service_attr(hostname, service, key, value,
-                       last_update, SDB_OBJ(store));
+       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 */
 
 int
@@ -853,8 +816,13 @@ 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)
 {
-       return store_metric_attr(hostname, metric, key, value,
-                       last_update, SDB_OBJ(store));
+       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 *
index 678af6f..a1e5e17 100644 (file)
@@ -111,13 +111,71 @@ struct sdb_store_obj;
 typedef struct sdb_store_obj sdb_store_obj_t;
 
 /*
- * A metric store describes how to access a metric's data.
+ * sdb_store_host_t represents the meta-data of a stored host object.
+ */
+typedef struct {
+       const char *name;
+
+       sdb_time_t last_update;
+       sdb_time_t interval;
+       char **backends;
+       size_t backends_num;
+} sdb_store_host_t;
+
+/*
+ * sdb_store_service_t represents the meta-data of a stored service object.
+ */
+typedef struct {
+       const char *hostname;
+       const char *name;
+
+       sdb_time_t last_update;
+       sdb_time_t interval;
+       char **backends;
+       size_t backends_num;
+} sdb_store_service_t;
+
+/*
+ * sdb_metric_store_t specifies how to access a metric's data.
  */
 typedef struct {
        const char *type;
        const char *id;
 } sdb_metric_store_t;
 
+/*
+ * sdb_store_metric_t represents the meta-data of a stored metric object.
+ */
+typedef struct {
+       const char *hostname;
+       const char *name;
+       struct {
+               const char *type;
+               const char *id;
+       } store;
+
+       sdb_time_t last_update;
+       sdb_time_t interval;
+       char **backends;
+       size_t backends_num;
+} sdb_store_metric_t;
+
+/*
+ * sdb_store_attribute_t represents a stored attribute.
+ */
+typedef struct {
+       const char *hostname; /* optional */
+       int parent_type;
+       const char *parent;
+       const char *key;
+       sdb_data_t value;
+
+       sdb_time_t last_update;
+       sdb_time_t interval;
+       char **backends;
+       size_t backends_num;
+} sdb_store_attribute_t;
+
 /*
  * Expressions represent arithmetic expressions based on stored objects and
  * their various attributes.
@@ -175,8 +233,7 @@ typedef struct {
         * specified name and timestamp. Else, a new entry will be created in the
         * store.
         */
-       int (*store_host)(const char *name, sdb_time_t last_update,
-                       sdb_object_t *user_data);
+       int (*store_host)(sdb_store_host_t *host, sdb_object_t *user_data);
 
        /*
         * store_service:
@@ -186,8 +243,7 @@ typedef struct {
         * does not exist, an error will be reported. Else, a new entry will be
         * created in the store.
         */
-       int (*store_service)(const char *hostname, const char *name,
-                       sdb_time_t last_update, sdb_object_t *user_data);
+       int (*store_service)(sdb_store_service_t *service, sdb_object_t *user_data);
 
        /*
         * store_metric:
@@ -197,9 +253,7 @@ typedef struct {
         * exist, an error will be reported. Else, a new entry will be created in
         * the store.
         */
-       int (*store_metric)(const char *hostname, const char *name,
-                       sdb_metric_store_t *store, sdb_time_t last_update,
-                       sdb_object_t *user_data);
+       int (*store_metric)(sdb_store_metric_t *metric, sdb_object_t *user_data);
 
        /*
         * store_attribute:
@@ -209,31 +263,7 @@ typedef struct {
         * exist, an error will be reported. Else, a new entry will be created in
         * the store.
         */
-       int (*store_attribute)(const char *hostname,
-                       const char *key, const sdb_data_t *value, sdb_time_t last_update,
-                       sdb_object_t *user_data);
-
-       /*
-        * store_service_attr:
-        * Add/update a service's attribute in the store. If the attribute,
-        * identified by its key, already exists for the specified service, it
-        * will be updated to the specified value. If the references service (for
-        * the specified host) does not exist, an error will be reported.
-        */
-       int (*store_service_attr)(const char *hostname, const char *service,
-                       const char *key, const sdb_data_t *value, sdb_time_t last_update,
-                       sdb_object_t *user_data);
-
-       /*
-        * store_metric_attr:
-        * Add/update a metric's attribute in the store. If the attribute,
-        * identified by its key, already exists for the specified metric, it will
-        * be updated to the specified value. If the references metric (for the
-        * specified host) does not exist, an error will be reported.
-        */
-       int (*store_metric_attr)(const char *hostname, const char *metric,
-                       const char *key, const sdb_data_t *value, sdb_time_t last_update,
-                       sdb_object_t *user_data);
+       int (*store_attribute)(sdb_store_attribute_t *attr, sdb_object_t *user_data);
 } sdb_store_writer_t;
 
 /*
index c7ee429..8223d38 100644 (file)
@@ -121,91 +121,59 @@ store_rpc(user_data_t *ud, const char *msg, size_t msg_len)
 } /* store_rpc */
 
 static int
-store_host(const char *name, sdb_time_t last_update, sdb_object_t *user_data)
+store_host(sdb_store_host_t *host, sdb_object_t *user_data)
 {
-       sdb_proto_host_t host = { last_update, name };
-       size_t len = sdb_proto_marshal_host(NULL, 0, &host);
+       sdb_proto_host_t h = { host->last_update, host->name };
+       size_t len = sdb_proto_marshal_host(NULL, 0, &h);
        char buf[len];
 
-       sdb_proto_marshal_host(buf, len, &host);
+       sdb_proto_marshal_host(buf, len, &h);
        return store_rpc(UD(user_data), buf, len);
 } /* store_host */
 
 static int
-store_service(const char *hostname, const char *name, sdb_time_t last_update,
-               sdb_object_t *user_data)
+store_service(sdb_store_service_t *service, sdb_object_t *user_data)
 {
-       sdb_proto_service_t svc = { last_update, hostname, name };
-       ssize_t len = sdb_proto_marshal_service(NULL, 0, &svc);
+       sdb_proto_service_t s = {
+               service->last_update, service->hostname, service->name,
+       };
+       ssize_t len = sdb_proto_marshal_service(NULL, 0, &s);
        char buf[len];
 
-       sdb_proto_marshal_service(buf, len, &svc);
+       sdb_proto_marshal_service(buf, len, &s);
        return store_rpc(UD(user_data), buf, len);
 } /* store_service */
 
 static int
-store_metric(const char *hostname, const char *name,
-               sdb_metric_store_t *store, sdb_time_t last_update,
-               sdb_object_t *user_data)
+store_metric(sdb_store_metric_t *metric, sdb_object_t *user_data)
 {
-       sdb_proto_metric_t metric = {
-               last_update, hostname, name,
-               store ? store->type : NULL, store ? store->id : NULL,
+       sdb_proto_metric_t m = {
+               metric->last_update, metric->hostname, metric->name,
+               metric->store.type, metric->store.id,
        };
-       size_t len = sdb_proto_marshal_metric(NULL, 0, &metric);
+       size_t len = sdb_proto_marshal_metric(NULL, 0, &m);
        char buf[len];
 
-       sdb_proto_marshal_metric(buf, len, &metric);
+       sdb_proto_marshal_metric(buf, len, &m);
        return store_rpc(UD(user_data), buf, len);
 } /* store_metric */
 
 static int
-store_attr(const char *hostname, const char *key, const sdb_data_t *value,
-               sdb_time_t last_update, sdb_object_t *user_data)
+store_attr(sdb_store_attribute_t *attr, sdb_object_t *user_data)
 {
-       sdb_proto_attribute_t attr = {
-               last_update, SDB_HOST, NULL, hostname, key, *value,
+       sdb_proto_attribute_t a = {
+               attr->last_update, attr->parent_type, attr->hostname, attr->parent,
+               attr->key, attr->value,
        };
-       size_t len = sdb_proto_marshal_attribute(NULL, 0, &attr);
+       size_t len = sdb_proto_marshal_attribute(NULL, 0, &a);
        char buf[len];
 
-       sdb_proto_marshal_attribute(buf, len, &attr);
+       sdb_proto_marshal_attribute(buf, len, &a);
        return store_rpc(UD(user_data), buf, len);
 } /* store_attr */
 
-static int
-store_service_attr(const char *hostname, const char *service,
-               const char *key, const sdb_data_t *value, sdb_time_t last_update,
-               sdb_object_t *user_data)
-{
-       sdb_proto_attribute_t attr = {
-               last_update, SDB_SERVICE, hostname, service, key, *value,
-       };
-       size_t len = sdb_proto_marshal_attribute(NULL, 0, &attr);
-       char buf[len];
-
-       sdb_proto_marshal_attribute(buf, len, &attr);
-       return store_rpc(UD(user_data), buf, len);
-} /* store_service_attr */
-
-static int
-store_metric_attr(const char *hostname, const char *metric,
-               const char *key, const sdb_data_t *value, sdb_time_t last_update,
-               sdb_object_t *user_data)
-{
-       sdb_proto_attribute_t attr = {
-               last_update, SDB_METRIC, hostname, metric, key, *value,
-       };
-       size_t len = sdb_proto_marshal_attribute(NULL, 0, &attr);
-       char buf[len];
-
-       sdb_proto_marshal_attribute(buf, len, &attr);
-       return store_rpc(UD(user_data), buf, len);
-} /* store_metric_attr */
-
 static sdb_store_writer_t store_impl = {
-       store_host, store_service, store_metric,
-       store_attr, store_service_attr, store_metric_attr,
+       store_host, store_service, store_metric, store_attr,
 };
 
 /*