src/core/store.c

   1 /*
   2  * SysDB - src/core/store.c
   3  * Copyright (C) 2012-2013 Sebastian 'tokkee' Harl <sh@tokkee.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  17  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  18  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
  19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #if HAVE_CONFIG_H
  29 #       include "config.h"
  30 #endif /* HAVE_CONFIG_H */
  31
  32 #include "sysdb.h"
  33 #include "core/store-private.h"
  34 #include "core/plugin.h"
  35 #include "utils/avltree.h"
  36 #include "utils/error.h"
  37
  38 #include <assert.h>
  39
  40 #include <errno.h>
  41
  42 #include <stdio.h>
  43 #include <stdlib.h>
  44 #include <string.h>
  45
  46 #include <math.h>
  47 #include <pthread.h>
  48
  49 /*
  50  * private variables
  51  */
  52
  53 struct sdb_store {
  54         sdb_object_t super;
  55
  56         /* hosts are the top-level entries and
  57          * reference everything else */
  58         sdb_avltree_t *hosts;
  59         pthread_rwlock_t host_lock;
  60 };
  61
  62 /*
  63  * private types
  64  */
  65
  66 static sdb_type_t host_type;
  67 static sdb_type_t service_type;
  68 static sdb_type_t metric_type;
  69 static sdb_type_t attribute_type;
  70
  71 static int
  72 store_init(sdb_object_t *obj, va_list __attribute__((unused)) ap)
  73 {
  74         int err;
  75         if (! (SDB_STORE(obj)->hosts = sdb_avltree_create()))
  76                 return -1;
  77         if ((err = pthread_rwlock_init(&SDB_STORE(obj)->host_lock,
  78                                         /* attr = */ NULL))) {
  79                 char errbuf[128];
  80                 sdb_log(SDB_LOG_ERR, "store: Failed to initialize lock: %s",
  81                                 sdb_strerror(err, errbuf, sizeof(errbuf)));
  82                 return -1;
  83         }
  84         return 0;
  85 } /* store_init */
  86
  87 static void
  88 store_destroy(sdb_object_t *obj)
  89 {
  90         int err;
  91         if ((err = pthread_rwlock_destroy(&SDB_STORE(obj)->host_lock))) {
  92                 char errbuf[128];
  93                 sdb_log(SDB_LOG_ERR, "store: Failed to destroy lock: %s",
  94                                 sdb_strerror(err, errbuf, sizeof(errbuf)));
  95                 return;
  96         }
  97         sdb_avltree_destroy(SDB_STORE(obj)->hosts);
  98         SDB_STORE(obj)->hosts = NULL;
  99 } /* store_destroy */
 100
 101 static int
 102 store_obj_init(sdb_object_t *obj, va_list ap)
 103 {
 104         sdb_store_obj_t *sobj = STORE_OBJ(obj);
 105
 106         sobj->type = va_arg(ap, int);
 107
 108         sobj->last_update = va_arg(ap, sdb_time_t);
 109         sobj->interval = 0;
 110         sobj->backends = NULL;
 111         sobj->backends_num = 0;
 112         sobj->parent = NULL;
 113         return 0;
 114 } /* store_obj_init */
 115
 116 static void
 117 store_obj_destroy(sdb_object_t *obj)
 118 {
 119         sdb_store_obj_t *sobj = STORE_OBJ(obj);
 120         size_t i;
 121
 122         for (i = 0; i < sobj->backends_num; ++i)
 123                 free(sobj->backends[i]);
 124         free(sobj->backends);
 125         sobj->backends = NULL;
 126         sobj->backends_num = 0;
 127
 128         // We don't currently keep an extra reference for parent objects to
 129         // avoid circular self-references which are not handled correctly by
 130         // the ref-count base management layer.
 131         //sdb_object_deref(SDB_OBJ(sobj->parent));
 132 } /* store_obj_destroy */
 133
 134 static int
 135 host_init(sdb_object_t *obj, va_list ap)
 136 {
 137         sdb_host_t *sobj = HOST(obj);
 138         int ret;
 139
 140         /* this will consume the first argument (type) of ap */
 141         ret = store_obj_init(obj, ap);
 142         if (ret)
 143                 return ret;
 144
 145         sobj->services = sdb_avltree_create();
 146         if (! sobj->services)
 147                 return -1;
 148         sobj->metrics = sdb_avltree_create();
 149         if (! sobj->metrics)
 150                 return -1;
 151         sobj->attributes = sdb_avltree_create();
 152         if (! sobj->attributes)
 153                 return -1;
 154         return 0;
 155 } /* host_init */
 156
 157 static void
 158 host_destroy(sdb_object_t *obj)
 159 {
 160         sdb_host_t *sobj = HOST(obj);
 161         assert(obj);
 162
 163         store_obj_destroy(obj);
 164
 165         if (sobj->services)
 166                 sdb_avltree_destroy(sobj->services);
 167         if (sobj->metrics)
 168                 sdb_avltree_destroy(sobj->metrics);
 169         if (sobj->attributes)
 170                 sdb_avltree_destroy(sobj->attributes);
 171 } /* host_destroy */
 172
 173 static int
 174 service_init(sdb_object_t *obj, va_list ap)
 175 {
 176         sdb_service_t *sobj = SVC(obj);
 177         int ret;
 178
 179         /* this will consume the first argument (type) of ap */
 180         ret = store_obj_init(obj, ap);
 181         if (ret)
 182                 return ret;
 183
 184         sobj->attributes = sdb_avltree_create();
 185         if (! sobj->attributes)
 186                 return -1;
 187         return 0;
 188 } /* service_init */
 189
 190 static void
 191 service_destroy(sdb_object_t *obj)
 192 {
 193         sdb_service_t *sobj = SVC(obj);
 194         assert(obj);
 195
 196         store_obj_destroy(obj);
 197
 198         if (sobj->attributes)
 199                 sdb_avltree_destroy(sobj->attributes);
 200 } /* service_destroy */
 201
 202 static int
 203 metric_init(sdb_object_t *obj, va_list ap)
 204 {
 205         sdb_metric_t *sobj = METRIC(obj);
 206         int ret;
 207
 208         /* this will consume the first argument (type) of ap */
 209         ret = store_obj_init(obj, ap);
 210         if (ret)
 211                 return ret;
 212
 213         sobj->attributes = sdb_avltree_create();
 214         if (! sobj->attributes)
 215                 return -1;
 216
 217         sobj->store.type = sobj->store.id = NULL;
 218         return 0;
 219 } /* metric_init */
 220
 221 static void
 222 metric_destroy(sdb_object_t *obj)
 223 {
 224         sdb_metric_t *sobj = METRIC(obj);
 225         assert(obj);
 226
 227         store_obj_destroy(obj);
 228
 229         if (sobj->attributes)
 230                 sdb_avltree_destroy(sobj->attributes);
 231
 232         if (sobj->store.type)
 233                 free(sobj->store.type);
 234         if (sobj->store.id)
 235                 free(sobj->store.id);
 236 } /* metric_destroy */
 237
 238 static int
 239 attr_init(sdb_object_t *obj, va_list ap)
 240 {
 241         const sdb_data_t *value;
 242         int ret;
 243
 244         /* this will consume the first two arguments
 245          * (type and last_update) of ap */
 246         ret = store_obj_init(obj, ap);
 247         if (ret)
 248                 return ret;
 249         value = va_arg(ap, const sdb_data_t *);
 250
 251         if (value)
 252                 if (sdb_data_copy(&ATTR(obj)->value, value))
 253                         return -1;
 254         return 0;
 255 } /* attr_init */
 256
 257 static void
 258 attr_destroy(sdb_object_t *obj)
 259 {
 260         assert(obj);
 261
 262         store_obj_destroy(obj);
 263         sdb_data_free_datum(&ATTR(obj)->value);
 264 } /* attr_destroy */
 265
 266 static sdb_type_t store_type = {
 267         /* size = */ sizeof(sdb_store_t),
 268         /* init = */ store_init,
 269         /* destroy = */ store_destroy,
 270 };
 271
 272 static sdb_type_t host_type = {
 273         /* size = */ sizeof(sdb_host_t),
 274         /* init = */ host_init,
 275         /* destroy = */ host_destroy
 276 };
 277
 278 static sdb_type_t service_type = {
 279         /* size = */ sizeof(sdb_service_t),
 280         /* init = */ service_init,
 281         /* destroy = */ service_destroy
 282 };
 283
 284 static sdb_type_t metric_type = {
 285         /* size = */ sizeof(sdb_metric_t),
 286         /* init = */ metric_init,
 287         /* destroy = */ metric_destroy
 288 };
 289
 290 static sdb_type_t attribute_type = {
 291         /* size = */ sizeof(sdb_attribute_t),
 292         /* init = */ attr_init,
 293         /* destroy = */ attr_destroy
 294 };
 295
 296 /*
 297  * private helper functions
 298  */
 299
 300 static sdb_host_t *
 301 lookup_host(sdb_store_t *st, const char *name, bool canonicalize)
 302 {
 303         sdb_host_t *host;
 304         char *cname;
 305
 306         assert(name);
 307         if (! canonicalize)
 308                 return HOST(sdb_avltree_lookup(st->hosts, name));
 309
 310         cname = strdup(name);
 311         cname = sdb_plugin_cname(cname);
 312         if (! cname) {
 313                 sdb_log(SDB_LOG_ERR, "store: strdup failed");
 314                 return NULL;
 315         }
 316
 317         host = HOST(sdb_avltree_lookup(st->hosts, cname));
 318         free(cname);
 319         return host;
 320 } /* lookup_host */
 321
 322 static int
 323 record_backend(sdb_store_obj_t *obj)
 324 {
 325         const sdb_plugin_info_t *info;
 326         char **tmp;
 327         size_t i;
 328
 329         info = sdb_plugin_current();
 330         if (! info)
 331                 return 0;
 332
 333         for (i = 0; i < obj->backends_num; ++i)
 334                 if (!strcasecmp(obj->backends[i], info->plugin_name))
 335                         return 0;
 336
 337         tmp = realloc(obj->backends,
 338                         (obj->backends_num + 1) * sizeof(*obj->backends));
 339         if (! tmp)
 340                 return -1;
 341
 342         obj->backends = tmp;
 343         obj->backends[obj->backends_num] = strdup(info->plugin_name);
 344         if (! obj->backends[obj->backends_num])
 345                 return -1;
 346
 347         ++obj->backends_num;
 348         return 0;
 349 } /* record_backend */
 350
 351 static int
 352 store_obj(sdb_store_obj_t *parent, sdb_avltree_t *parent_tree,
 353                 int type, const char *name, sdb_time_t last_update,
 354                 sdb_store_obj_t **updated_obj)
 355 {
 356         sdb_store_obj_t *old, *new;
 357         int status = 0;
 358
 359         assert(parent_tree);
 360
 361         if (last_update <= 0)
 362                 last_update = sdb_gettime();
 363
 364         old = STORE_OBJ(sdb_avltree_lookup(parent_tree, name));
 365         if (old) {
 366                 if (old->last_update > last_update) {
 367                         sdb_log(SDB_LOG_DEBUG, "store: Cannot update %s '%s' - "
 368                                         "value too old (%"PRIsdbTIME" < %"PRIsdbTIME")",
 369                                         SDB_STORE_TYPE_TO_NAME(type), name,
 370                                         last_update, old->last_update);
 371                         /* don't report an error; the object may be updated by multiple
 372                          * backends */
 373                         status = 1;
 374                 }
 375                 else if (old->last_update == last_update) {
 376                         /* don't report an error and also don't even log this to avoid
 377                          * excessive noise on high sampling frequencies */
 378                         status = 1;
 379                 }
 380                 else {
 381                         sdb_time_t interval = last_update - old->last_update;
 382                         old->last_update = last_update;
 383                         if (interval) {
 384                                 if (old->interval)
 385                                         old->interval = (sdb_time_t)((0.9 * (double)old->interval)
 386                                                         + (0.1 * (double)interval));
 387                                 else
 388                                         old->interval = interval;
 389                         }
 390                 }
 391
 392                 new = old;
 393                 sdb_object_deref(SDB_OBJ(old));
 394         }
 395         else {
 396                 if (type == SDB_ATTRIBUTE) {
 397                         /* the value will be updated by the caller */
 398                         new = STORE_OBJ(sdb_object_create(name, attribute_type,
 399                                                 type, last_update, NULL));
 400                 }
 401                 else {
 402                         sdb_type_t t;
 403                         t = type == SDB_HOST
 404                                 ? host_type
 405                                 : type == SDB_SERVICE
 406                                         ? service_type
 407                                         : metric_type;
 408                         new = STORE_OBJ(sdb_object_create(name, t, type, last_update));
 409                 }
 410
 411                 if (new) {
 412                         status = sdb_avltree_insert(parent_tree, SDB_OBJ(new));
 413
 414                         /* pass control to the tree or destroy in case of an error */
 415                         sdb_object_deref(SDB_OBJ(new));
 416                 }
 417                 else {
 418                         char errbuf[1024];
 419                         sdb_log(SDB_LOG_ERR, "store: Failed to create %s '%s': %s",
 420                                         SDB_STORE_TYPE_TO_NAME(type), name,
 421                                         sdb_strerror(errno, errbuf, sizeof(errbuf)));
 422                         status = -1;
 423                 }
 424         }
 425
 426         if (status < 0)
 427                 return status;
 428         assert(new);
 429
 430         if (new->parent != parent) {
 431                 // Avoid circular self-references which are not handled
 432                 // correctly by the ref-count based management layer.
 433                 //sdb_object_deref(SDB_OBJ(new->parent));
 434                 //sdb_object_ref(SDB_OBJ(parent));
 435                 new->parent = parent;
 436         }
 437
 438         if (updated_obj)
 439                 *updated_obj = new;
 440
 441         if (record_backend(new))
 442                 return -1;
 443         return status;
 444 } /* store_obj */
 445
 446 static int
 447 store_attr(sdb_store_obj_t *parent, sdb_avltree_t *attributes,
 448                 const char *key, const sdb_data_t *value, sdb_time_t last_update)
 449 {
 450         sdb_store_obj_t *attr = NULL;
 451         int status;
 452
 453         status = store_obj(parent, attributes, SDB_ATTRIBUTE,
 454                         key, last_update, &attr);
 455         if (status)
 456                 return status;
 457
 458         /* don't update unchanged values */
 459         if (! sdb_data_cmp(&ATTR(attr)->value, value))
 460                 return status;
 461
 462         assert(attr);
 463         if (sdb_data_copy(&ATTR(attr)->value, value))
 464                 return -1;
 465         return status;
 466 } /* store_attr */
 467
 468 static int
 469 store_metric_store(sdb_metric_t *metric, sdb_metric_store_t *store)
 470 {
 471         char *type = metric->store.type;
 472         char *id = metric->store.id;
 473
 474         if ((! metric->store.type) || strcasecmp(metric->store.type, store->type)) {
 475                 if (! (type = strdup(store->type)))
 476                         return -1;
 477         }
 478         if ((! metric->store.id) || strcasecmp(metric->store.id, store->id)) {
 479                 if (! (id = strdup(store->id))) {
 480                         if (type != metric->store.type)
 481                                 free(type);
 482                         return -1;
 483                 }
 484         }
 485
 486         if (type != metric->store.type) {
 487                 if (metric->store.type)
 488                         free(metric->store.type);
 489                 metric->store.type = type;
 490         }
 491         if (id != metric->store.id) {
 492                 if (metric->store.id)
 493                         free(metric->store.id);
 494                 metric->store.id = id;
 495         }
 496         return 0;
 497 } /* store_metric_store */
 498
 499 /* The store's host_lock has to be acquired before calling this function. */
 500 static sdb_avltree_t *
 501 get_host_children(sdb_host_t *host, int type)
 502 {
 503         if ((type != SDB_SERVICE) && (type != SDB_METRIC)
 504                         && (type != SDB_ATTRIBUTE))
 505                 return NULL;
 506
 507         if (! host)
 508                 return NULL;
 509
 510         if (type == SDB_ATTRIBUTE)
 511                 return host->attributes;
 512         else if (type == SDB_METRIC)
 513                 return host->metrics;
 514         else
 515                 return host->services;
 516 } /* get_host_children */
 517
 518 /*
 519  * ts_tojson serializes a time-series to JSON.
 520  *
 521  * The function never returns an error. Rather, an error message will be part
 522  * of the serialized data.
 523  */
 524 static void
 525 ts_tojson(sdb_timeseries_t *ts, sdb_strbuf_t *buf)
 526 {
 527         char start_str[64];
 528         char end_str[64];
 529
 530         size_t i;
 531
 532         /* TODO: make time format configurable */
 533         if (! sdb_strftime(start_str, sizeof(start_str), ts->start))
 534                 snprintf(start_str, sizeof(start_str), "<error>");
 535         start_str[sizeof(start_str) - 1] = '\0';
 536         if (! sdb_strftime(end_str, sizeof(end_str), ts->end))
 537                 snprintf(end_str, sizeof(end_str), "<error>");
 538         end_str[sizeof(end_str) - 1] = '\0';
 539
 540         sdb_strbuf_append(buf, "{\"start\": \"%s\", \"end\": \"%s\", \"data\": {",
 541                         start_str, end_str);
 542
 543         for (i = 0; i < ts->data_names_len; ++i) {
 544                 size_t j;
 545                 sdb_strbuf_append(buf, "\"%s\": [", ts->data_names[i]);
 546
 547                 for (j = 0; j < ts->data_len; ++j) {
 548                         char time_str[64];
 549
 550                         if (! sdb_strftime(time_str, sizeof(time_str), ts->data[i][j].timestamp))
 551                                 snprintf(time_str, sizeof(time_str), "<error>");
 552                         time_str[sizeof(time_str) - 1] = '\0';
 553
 554                         /* Some GNU libc versions may print '-nan' which we dont' want */
 555                         if (isnan(ts->data[i][j].value))
 556                                 sdb_strbuf_append(buf, "{\"timestamp\": \"%s\", "
 557                                                 "\"value\": \"nan\"}", time_str);
 558                         else
 559                                 sdb_strbuf_append(buf, "{\"timestamp\": \"%s\", "
 560                                                 "\"value\": \"%f\"}", time_str, ts->data[i][j].value);
 561
 562                         if (j < ts->data_len - 1)
 563                                 sdb_strbuf_append(buf, ",");
 564                 }
 565
 566                 if (i < ts->data_names_len - 1)
 567                         sdb_strbuf_append(buf, "],");
 568                 else
 569                         sdb_strbuf_append(buf, "]");
 570         }
 571         sdb_strbuf_append(buf, "}}");
 572 } /* ts_tojson */
 573
 574 /*
 575  * store writer API
 576  */
 577
 578 static int
 579 store_attribute(const char *hostname,
 580                 const char *key, const sdb_data_t *value,
 581                 sdb_time_t last_update, sdb_object_t *user_data)
 582 {
 583         sdb_store_t *st = SDB_STORE(user_data);
 584
 585         sdb_host_t *host;
 586         sdb_avltree_t *attrs;
 587         int status = 0;
 588
 589         if ((! hostname) || (! key))
 590                 return -1;
 591
 592         pthread_rwlock_wrlock(&st->host_lock);
 593         host = lookup_host(st, hostname, /* canonicalize = */ 1);
 594         attrs = get_host_children(host, SDB_ATTRIBUTE);
 595         if (! attrs) {
 596                 sdb_log(SDB_LOG_ERR, "store: Failed to store attribute '%s' - "
 597                                 "host '%s' not found", key, hostname);
 598                 status = -1;
 599         }
 600
 601         if (! status)
 602                 status = store_attr(STORE_OBJ(host), attrs, key, value, last_update);
 603
 604         sdb_object_deref(SDB_OBJ(host));
 605         pthread_rwlock_unlock(&st->host_lock);
 606
 607         return status;
 608 } /* store_attribute */
 609
 610 static int
 611 store_host(const char *name, sdb_time_t last_update, sdb_object_t *user_data)
 612 {
 613         sdb_store_t *st = SDB_STORE(user_data);
 614
 615         char *cname = NULL;
 616         int status = 0;
 617
 618         if (! name)
 619                 return -1;
 620
 621         cname = sdb_plugin_cname(strdup(name));
 622         if (! cname) {
 623                 sdb_log(SDB_LOG_ERR, "store: strdup failed");
 624                 return -1;
 625         }
 626
 627         pthread_rwlock_wrlock(&st->host_lock);
 628         status = store_obj(NULL, st->hosts,
 629                         SDB_HOST, cname, last_update, NULL);
 630         pthread_rwlock_unlock(&st->host_lock);
 631
 632         free(cname);
 633         return status;
 634 } /* store_host */
 635
 636 static int
 637 store_service_attr(const char *hostname, const char *service,
 638                 const char *key, const sdb_data_t *value, sdb_time_t last_update,
 639                 sdb_object_t *user_data)
 640 {
 641         sdb_store_t *st = SDB_STORE(user_data);
 642
 643         sdb_host_t *host;
 644         sdb_service_t *svc;
 645         sdb_avltree_t *services;
 646         int status = 0;
 647
 648         if ((! hostname) || (! service) || (! key))
 649                 return -1;
 650
 651         pthread_rwlock_wrlock(&st->host_lock);
 652         host = lookup_host(st, hostname, /* canonicalize = */ 1);
 653         services = get_host_children(host, SDB_SERVICE);
 654         sdb_object_deref(SDB_OBJ(host));
 655         if (! services) {
 656                 sdb_log(SDB_LOG_ERR, "store: Failed to store attribute '%s' "
 657                                 "for service '%s' - host '%ss' not found",
 658                                 key, service, hostname);
 659                 pthread_rwlock_unlock(&st->host_lock);
 660                 return -1;
 661         }
 662
 663         svc = SVC(sdb_avltree_lookup(services, service));
 664         if (! svc) {
 665                 sdb_log(SDB_LOG_ERR, "store: Failed to store attribute '%s' - "
 666                                 "service '%s/%s' not found", key, hostname, service);
 667                 status = -1;
 668         }
 669
 670         if (! status)
 671                 status = store_attr(STORE_OBJ(svc), svc->attributes,
 672                                 key, value, last_update);
 673
 674         sdb_object_deref(SDB_OBJ(svc));
 675         pthread_rwlock_unlock(&st->host_lock);
 676
 677         return status;
 678 } /* store_service_attr */
 679
 680 static int
 681 store_service(const char *hostname, const char *name,
 682                 sdb_time_t last_update, sdb_object_t *user_data)
 683 {
 684         sdb_store_t *st = SDB_STORE(user_data);
 685
 686         sdb_host_t *host;
 687         sdb_avltree_t *services;
 688         sdb_data_t d;
 689
 690         int status = 0;
 691
 692         if ((! hostname) || (! name))
 693                 return -1;
 694
 695         pthread_rwlock_wrlock(&st->host_lock);
 696         host = lookup_host(st, hostname, /* canonicalize = */ 1);
 697         services = get_host_children(host, SDB_SERVICE);
 698         if (! services) {
 699                 sdb_log(SDB_LOG_ERR, "store: Failed to store service '%s' - "
 700                                 "host '%s' not found", name, hostname);
 701                 status = -1;
 702         }
 703
 704         if (! status)
 705                 status = store_obj(STORE_OBJ(host), services, SDB_SERVICE,
 706                                 name, last_update, NULL);
 707
 708         sdb_object_deref(SDB_OBJ(host));
 709         pthread_rwlock_unlock(&st->host_lock);
 710
 711         if (status)
 712                 return status;
 713
 714         /* record the hostname as an attribute */
 715         d.type = SDB_TYPE_STRING;
 716         d.data.string = SDB_OBJ(host)->name;
 717         if (store_service_attr(hostname, name, "hostname", &d, last_update, user_data))
 718                 status = -1;
 719         return status;
 720 } /* store_service */
 721
 722 static int
 723 store_metric_attr(const char *hostname, const char *metric,
 724                 const char *key, const sdb_data_t *value, sdb_time_t last_update,
 725                 sdb_object_t *user_data)
 726 {
 727         sdb_store_t *st = SDB_STORE(user_data);
 728
 729         sdb_avltree_t *metrics;
 730         sdb_host_t *host;
 731         sdb_metric_t *m;
 732         int status = 0;
 733
 734         if ((! hostname) || (! metric) || (! key))
 735                 return -1;
 736
 737         pthread_rwlock_wrlock(&st->host_lock);
 738         host = lookup_host(st, hostname, /* canonicalize = */ 1);
 739         metrics = get_host_children(host, SDB_METRIC);
 740         sdb_object_deref(SDB_OBJ(host));
 741         if (! metrics) {
 742                 sdb_log(SDB_LOG_ERR, "store: Failed to store attribute '%s' "
 743                                 "for metric '%s' - host '%s' not found",
 744                                 key, metric, hostname);
 745                 pthread_rwlock_unlock(&st->host_lock);
 746                 return -1;
 747         }
 748
 749         m = METRIC(sdb_avltree_lookup(metrics, metric));
 750         if (! m) {
 751                 sdb_log(SDB_LOG_ERR, "store: Failed to store attribute '%s' - "
 752                                 "metric '%s/%s' not found", key, hostname, metric);
 753                 status = -1;
 754         }
 755
 756         if (! status)
 757                 status = store_attr(STORE_OBJ(m), m->attributes,
 758                                 key, value, last_update);
 759
 760         sdb_object_deref(SDB_OBJ(m));
 761         pthread_rwlock_unlock(&st->host_lock);
 762
 763         return status;
 764 } /* store_metric_attr */
 765
 766 static int
 767 store_metric(const char *hostname, const char *name,
 768                 sdb_metric_store_t *store, sdb_time_t last_update,
 769                 sdb_object_t *user_data)
 770 {
 771         sdb_store_t *st = SDB_STORE(user_data);
 772
 773         sdb_store_obj_t *obj = NULL;
 774         sdb_host_t *host;
 775         sdb_metric_t *metric;
 776         sdb_data_t d;
 777
 778         sdb_avltree_t *metrics;
 779
 780         int status = 0;
 781
 782         if ((! hostname) || (! name))
 783                 return -1;
 784
 785         if (store) {
 786                 if ((store->type != NULL) != (store->id != NULL))
 787                         return -1;
 788                 else if (! store->type)
 789                         store = NULL;
 790         }
 791
 792         pthread_rwlock_wrlock(&st->host_lock);
 793         host = lookup_host(st, hostname, /* canonicalize = */ 1);
 794         metrics = get_host_children(host, SDB_METRIC);
 795         if (! metrics) {
 796                 sdb_log(SDB_LOG_ERR, "store: Failed to store metric '%s' - "
 797                                 "host '%s' not found", name, hostname);
 798                 status = -1;
 799         }
 800
 801         if (! status)
 802                 status = store_obj(STORE_OBJ(host), metrics, SDB_METRIC,
 803                                 name, last_update, &obj);
 804         sdb_object_deref(SDB_OBJ(host));
 805
 806         if (status) {
 807                 pthread_rwlock_unlock(&st->host_lock);
 808                 return status;
 809         }
 810
 811         assert(obj);
 812         metric = METRIC(obj);
 813
 814         if (store)
 815                 if (store_metric_store(metric, store))
 816                         status = -1;
 817         pthread_rwlock_unlock(&st->host_lock);
 818
 819         /* record the hostname as an attribute */
 820         d.type = SDB_TYPE_STRING;
 821         d.data.string = SDB_OBJ(host)->name;
 822         if (store_metric_attr(hostname, name, "hostname", &d, last_update, user_data))
 823                 status = -1;
 824         return status;
 825 } /* store_metric */
 826
 827 sdb_store_writer_t sdb_store_writer = {
 828         store_host, store_service, store_metric,
 829         store_attribute, store_service_attr, store_metric_attr,
 830 };
 831
 832 /*
 833  * TODO: let prepare and execute accept a store object as their user_data
 834  * object
 835  */
 836
 837 static sdb_object_t *
 838 prepare_query(sdb_ast_node_t *ast,
 839                 sdb_strbuf_t __attribute__((unused)) *errbuf,
 840                 sdb_object_t __attribute__((unused)) *user_data)
 841 {
 842         return SDB_OBJ(sdb_store_query_prepare(ast));
 843 } /* prepare_query */
 844
 845 static int
 846 execute_query(sdb_object_t *q,
 847                 sdb_strbuf_t *buf, sdb_strbuf_t *errbuf,
 848                 sdb_object_t *user_data)
 849 {
 850         return sdb_store_query_execute(SDB_STORE(user_data),
 851                         QUERY(q), buf, errbuf);
 852 } /* execute_query */
 853
 854 sdb_store_reader_t sdb_store_reader = {
 855         prepare_query, execute_query,
 856 };
 857
 858 /*
 859  * public API
 860  */
 861
 862 sdb_store_t *
 863 sdb_store_create(void)
 864 {
 865         return SDB_STORE(sdb_object_create("store", store_type));
 866 } /* sdb_store_create */
 867
 868 int
 869 sdb_store_host(sdb_store_t *store, const char *name, sdb_time_t last_update)
 870 {
 871         return store_host(name, last_update, SDB_OBJ(store));
 872 } /* sdb_store_host */
 873
 874 int
 875 sdb_store_service(sdb_store_t *store, const char *hostname, const char *name,
 876                 sdb_time_t last_update)
 877 {
 878         return store_service(hostname, name, last_update, SDB_OBJ(store));
 879 } /* sdb_store_service */
 880
 881 int
 882 sdb_store_metric(sdb_store_t *store, const char *hostname, const char *name,
 883                 sdb_metric_store_t *metric_store, sdb_time_t last_update)
 884 {
 885         return store_metric(hostname, name, metric_store, last_update, SDB_OBJ(store));
 886 } /* sdb_store_metric */
 887
 888 int
 889 sdb_store_attribute(sdb_store_t *store, const char *hostname,
 890                 const char *key, const sdb_data_t *value, sdb_time_t last_update)
 891 {
 892         return store_attribute(hostname, key, value, last_update, SDB_OBJ(store));
 893 } /* sdb_store_attribute */
 894
 895 int
 896 sdb_store_service_attr(sdb_store_t *store, const char *hostname,
 897                 const char *service, const char *key, const sdb_data_t *value,
 898                 sdb_time_t last_update)
 899 {
 900         return store_service_attr(hostname, service, key, value,
 901                         last_update, SDB_OBJ(store));
 902 } /* sdb_store_service_attr */
 903
 904 int
 905 sdb_store_metric_attr(sdb_store_t *store, const char *hostname,
 906                 const char *metric, const char *key, const sdb_data_t *value,
 907                 sdb_time_t last_update)
 908 {
 909         return store_metric_attr(hostname, metric, key, value,
 910                         last_update, SDB_OBJ(store));
 911 } /* sdb_store_metric_attr */
 912
 913 sdb_store_obj_t *
 914 sdb_store_get_host(sdb_store_t *store, const char *name)
 915 {
 916         sdb_host_t *host;
 917
 918         if ((! store) || (! name))
 919                 return NULL;
 920
 921         host = lookup_host(store, name, /* canonicalize = */ 0);
 922         if (! host)
 923                 return NULL;
 924
 925         return STORE_OBJ(host);
 926 } /* sdb_store_get_host */
 927
 928 sdb_store_obj_t *
 929 sdb_store_get_child(sdb_store_obj_t *host, int type, const char *name)
 930 {
 931         sdb_avltree_t *children;
 932
 933         if ((! host) || (host->type != SDB_HOST) || (! name))
 934                 return NULL;
 935
 936         children = get_host_children(HOST(host), type);
 937         if (! children)
 938                 return NULL;
 939         return STORE_OBJ(sdb_avltree_lookup(children, name));
 940 } /* sdb_store_get_child */
 941
 942 int
 943 sdb_store_get_field(sdb_store_obj_t *obj, int field, sdb_data_t *res)
 944 {
 945         sdb_data_t tmp;
 946
 947         if (! obj)
 948                 return -1;
 949
 950         switch (field) {
 951                 case SDB_FIELD_NAME:
 952                         tmp.type = SDB_TYPE_STRING;
 953                         tmp.data.string = strdup(SDB_OBJ(obj)->name);
 954                         if (! tmp.data.string)
 955                                 return -1;
 956                         break;
 957                 case SDB_FIELD_LAST_UPDATE:
 958                         tmp.type = SDB_TYPE_DATETIME;
 959                         tmp.data.datetime = obj->last_update;
 960                         break;
 961                 case SDB_FIELD_AGE:
 962                         tmp.type = SDB_TYPE_DATETIME;
 963                         tmp.data.datetime = sdb_gettime() - obj->last_update;
 964                         break;
 965                 case SDB_FIELD_INTERVAL:
 966                         tmp.type = SDB_TYPE_DATETIME;
 967                         tmp.data.datetime = obj->interval;
 968                         break;
 969                 case SDB_FIELD_BACKEND:
 970                         if (! res)
 971                                 return 0;
 972                         tmp.type = SDB_TYPE_ARRAY | SDB_TYPE_STRING;
 973                         tmp.data.array.length = obj->backends_num;
 974                         tmp.data.array.values = obj->backends;
 975                         return sdb_data_copy(res, &tmp);
 976                 case SDB_FIELD_VALUE:
 977                         if (obj->type != SDB_ATTRIBUTE)
 978                                 return -1;
 979                         if (! res)
 980                                 return 0;
 981                         return sdb_data_copy(res, &ATTR(obj)->value);
 982                 case SDB_FIELD_TIMESERIES:
 983                         if (obj->type != SDB_METRIC)
 984                                 return -1;
 985                         tmp.type = SDB_TYPE_BOOLEAN;
 986                         tmp.data.boolean = METRIC(obj)->store.type != NULL;
 987                 default:
 988                         return -1;
 989         }
 990         if (res)
 991                 *res = tmp;
 992         else
 993                 sdb_data_free_datum(&tmp);
 994         return 0;
 995 } /* sdb_store_get_field */
 996
 997 int
 998 sdb_store_get_attr(sdb_store_obj_t *obj, const char *name, sdb_data_t *res,
 999                 sdb_store_matcher_t *filter)
1000 {
1001         sdb_avltree_t *tree = NULL;
1002         sdb_store_obj_t *attr;
1003
1004         if ((! obj) || (! name))
1005                 return -1;
1006
1007         if (obj->type == SDB_HOST)
1008                 tree = HOST(obj)->attributes;
1009         else if (obj->type == SDB_SERVICE)
1010                 tree = SVC(obj)->attributes;
1011         else if (obj->type == SDB_METRIC)
1012                 tree = METRIC(obj)->attributes;
1013
1014         if (! tree)
1015                 return -1;
1016
1017         attr = STORE_OBJ(sdb_avltree_lookup(tree, name));
1018         if (! attr)
1019                 return -1;
1020         if (filter && (! sdb_store_matcher_matches(filter, attr, NULL))) {
1021                 sdb_object_deref(SDB_OBJ(attr));
1022                 return -1;
1023         }
1024
1025         assert(STORE_OBJ(attr)->type == SDB_ATTRIBUTE);
1026         if (res)
1027                 sdb_data_copy(res, &ATTR(attr)->value);
1028         sdb_object_deref(SDB_OBJ(attr));
1029         return 0;
1030 } /* sdb_store_get_attr */
1031
1032 /* TODO: sdb_store_fetch_timeseries should move into the plugin module */
1033
1034 int
1035 sdb_store_fetch_timeseries(sdb_store_t *store,
1036                 const char *hostname, const char *metric,
1037                 sdb_timeseries_opts_t *opts, sdb_strbuf_t *buf)
1038 {
1039         sdb_avltree_t *metrics;
1040         sdb_host_t *host;
1041         sdb_metric_t *m;
1042
1043         sdb_timeseries_t *ts;
1044
1045         int status = 0;
1046
1047         if ((! store) || (! hostname) || (! metric) || (! opts) || (! buf))
1048                 return -1;
1049
1050         pthread_rwlock_rdlock(&store->host_lock);
1051         host = lookup_host(store, hostname, /* canonicalize = */ 1);
1052         metrics = get_host_children(host, SDB_METRIC);
1053         sdb_object_deref(SDB_OBJ(host));
1054         if (! metrics) {
1055                 sdb_log(SDB_LOG_ERR, "store: Failed to fetch time-series '%s/%s' "
1056                                 "- host '%s' not found", hostname, metric, hostname);
1057                 pthread_rwlock_unlock(&store->host_lock);
1058                 return -1;
1059         }
1060
1061         m = METRIC(sdb_avltree_lookup(metrics, metric));
1062         if (! m) {
1063                 sdb_log(SDB_LOG_ERR, "store: Failed to fetch time-series '%s/%s' "
1064                                 "- metric '%s' not found", hostname, metric, metric);
1065                 pthread_rwlock_unlock(&store->host_lock);
1066                 return -1;
1067         }
1068
1069         if ((! m->store.type) || (! m->store.id)) {
1070                 sdb_log(SDB_LOG_ERR, "store: Failed to fetch time-series '%s/%s' "
1071                                 "- no data-store configured for the stored metric",
1072                                 hostname, metric);
1073                 sdb_object_deref(SDB_OBJ(m));
1074                 pthread_rwlock_unlock(&store->host_lock);
1075                 return -1;
1076         }
1077
1078         {
1079                 char type[strlen(m->store.type) + 1];
1080                 char id[strlen(m->store.id) + 1];
1081
1082                 strncpy(type, m->store.type, sizeof(type));
1083                 strncpy(id, m->store.id, sizeof(id));
1084                 pthread_rwlock_unlock(&store->host_lock);
1085
1086                 ts = sdb_plugin_fetch_timeseries(type, id, opts);
1087                 if (! ts) {
1088                         sdb_log(SDB_LOG_ERR, "store: Failed to fetch time-series '%s/%s' "
1089                                         "- %s fetcher callback returned no data for '%s'",
1090                                         hostname, metric, type, id);
1091                         status = -1;
1092                 }
1093         }
1094
1095         ts_tojson(ts, buf);
1096         sdb_object_deref(SDB_OBJ(m));
1097         sdb_timeseries_destroy(ts);
1098         return status;
1099 } /* sdb_store_fetch_timeseries */
1100
1101 int
1102 sdb_store_scan(sdb_store_t *store, int type,
1103                 sdb_store_matcher_t *m, sdb_store_matcher_t *filter,
1104                 sdb_store_lookup_cb cb, void *user_data)
1105 {
1106         sdb_avltree_iter_t *host_iter = NULL;
1107         int status = 0;
1108
1109         if ((! store) || (! cb))
1110                 return -1;
1111
1112         if ((type != SDB_HOST) && (type != SDB_SERVICE) && (type != SDB_METRIC)) {
1113                 sdb_log(SDB_LOG_ERR, "store: Cannot scan objects of type %d", type);
1114                 return -1;
1115         }
1116
1117         pthread_rwlock_rdlock(&store->host_lock);
1118         host_iter = sdb_avltree_get_iter(store->hosts);
1119         if (! host_iter)
1120                 status = -1;
1121
1122         /* has_next returns false if the iterator is NULL */
1123         while (sdb_avltree_iter_has_next(host_iter)) {
1124                 sdb_store_obj_t *host;
1125                 sdb_avltree_iter_t *iter = NULL;
1126
1127                 host = STORE_OBJ(sdb_avltree_iter_get_next(host_iter));
1128                 assert(host);
1129
1130                 if (! sdb_store_matcher_matches(filter, host, NULL))
1131                         continue;
1132
1133                 if (type == SDB_SERVICE)
1134                         iter = sdb_avltree_get_iter(HOST(host)->services);
1135                 else if (type == SDB_METRIC)
1136                         iter = sdb_avltree_get_iter(HOST(host)->metrics);
1137
1138                 if (iter) {
1139                         while (sdb_avltree_iter_has_next(iter)) {
1140                                 sdb_store_obj_t *obj;
1141                                 obj = STORE_OBJ(sdb_avltree_iter_get_next(iter));
1142                                 assert(obj);
1143
1144                                 if (sdb_store_matcher_matches(m, obj, filter)) {
1145                                         if (cb(obj, filter, user_data)) {
1146                                                 sdb_log(SDB_LOG_ERR, "store: Callback returned "
1147                                                                 "an error while scanning");
1148                                                 status = -1;
1149                                                 break;
1150                                         }
1151                                 }
1152                         }
1153                 }
1154                 else if (sdb_store_matcher_matches(m, host, filter)) {
1155                         if (cb(host, filter, user_data)) {
1156                                 sdb_log(SDB_LOG_ERR, "store: Callback returned "
1157                                                 "an error while scanning");
1158                                 status = -1;
1159                         }
1160                 }
1161
1162                 sdb_avltree_iter_destroy(iter);
1163                 if (status)
1164                         break;
1165         }
1166
1167         sdb_avltree_iter_destroy(host_iter);
1168         pthread_rwlock_unlock(&store->host_lock);
1169         return status;
1170 } /* sdb_store_scan */
1171
1172 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
1173