src/core/store.c

   1 /*
   2  * SysDB - src/core/store.c
   3  * Copyright (C) 2012 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 #include "sysdb.h"
  29 #include "core/store.h"
  30 #include "core/error.h"
  31 #include "core/plugin.h"
  32 #include "utils/llist.h"
  33
  34 #include <assert.h>
  35
  36 #include <errno.h>
  37
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41
  42 #include <pthread.h>
  43
  44 /*
  45  * private variables
  46  */
  47
  48 static sdb_llist_t *host_list = NULL;
  49 static pthread_rwlock_t host_lock = PTHREAD_RWLOCK_INITIALIZER;
  50
  51 /*
  52  * public types
  53  */
  54
  55 static int
  56 sdb_host_init(sdb_object_t *obj, va_list __attribute__((unused)) ap)
  57 {
  58         SDB_HOST(obj)->_last_update = sdb_gettime();
  59         /* ignore errors -> last_update will be updated later */
  60
  61         SDB_HOST(obj)->attributes = sdb_llist_create();
  62         if (! SDB_HOST(obj)->attributes)
  63                 return -1;
  64         SDB_HOST(obj)->services = sdb_llist_create();
  65         if (! SDB_HOST(obj)->services)
  66                 return -1;
  67         return 0;
  68 } /* sdb_host_init */
  69
  70 static void
  71 sdb_host_destroy(sdb_object_t *obj)
  72 {
  73         assert(obj);
  74
  75         if (SDB_HOST(obj)->attributes)
  76                 sdb_llist_destroy(SDB_HOST(obj)->attributes);
  77         if (SDB_HOST(obj)->services)
  78                 sdb_llist_destroy(SDB_HOST(obj)->services);
  79 } /* sdb_host_destroy */
  80
  81 static sdb_object_t *
  82 sdb_host_do_clone(const sdb_object_t *obj)
  83 {
  84         const sdb_host_t *host = (const sdb_host_t *)obj;
  85         sdb_host_t *new;
  86
  87         new = SDB_HOST(sdb_object_create(obj->name, sdb_host_type));
  88         if (! new)
  89                 return NULL;
  90
  91         /* make sure these are initialized; else sdb_object_deref() might access
  92          * arbitrary memory in case of an error */
  93         new->services = new->attributes = NULL;
  94
  95         if (host->attributes) {
  96                 new->attributes = sdb_llist_clone(host->attributes);
  97                 if (! new->attributes) {
  98                         sdb_object_deref(SDB_OBJ(new));
  99                         return NULL;
 100                 }
 101         }
 102
 103         new->_last_update = host->_last_update;
 104         if (host->services) {
 105                 new->services = sdb_llist_clone(host->services);
 106                 if (! new->services) {
 107                         sdb_object_deref(SDB_OBJ(new));
 108                         return NULL;
 109                 }
 110         }
 111         return SDB_OBJ(new);
 112 } /* sdb_host_do_clone */
 113
 114 static int
 115 sdb_attr_init(sdb_object_t *obj, va_list ap)
 116 {
 117         const char *hostname = va_arg(ap, const char *);
 118         const char *value = va_arg(ap, const char *);
 119
 120         SDB_ATTR(obj)->hostname = strdup(hostname);
 121         SDB_ATTR(obj)->attr_value = strdup(value);
 122         if ((! SDB_ATTR(obj)->hostname) || (! SDB_ATTR(obj)->attr_value))
 123                 return -1;
 124
 125         SDB_ATTR(obj)->_last_update = sdb_gettime();
 126         return 0;
 127 } /* sdb_attr_init */
 128
 129 static void
 130 sdb_attr_destroy(sdb_object_t *obj)
 131 {
 132         assert(obj);
 133
 134         if (SDB_ATTR(obj)->hostname)
 135                 free(SDB_ATTR(obj)->hostname);
 136         if (SDB_ATTR(obj)->attr_value)
 137                 free(SDB_ATTR(obj)->attr_value);
 138 } /* sdb_attr_destroy */
 139
 140 static sdb_object_t *
 141 sdb_attr_clone(const sdb_object_t *obj)
 142 {
 143         const sdb_attribute_t *attr = (const sdb_attribute_t *)obj;
 144         sdb_attribute_t *new;
 145
 146         new = SDB_ATTR(sdb_object_create(obj->name, sdb_attribute_type,
 147                                 attr->hostname, attr->attr_value));
 148         if (! new)
 149                 return NULL;
 150
 151         new->_last_update = attr->_last_update;
 152         return SDB_OBJ(new);
 153 } /* sdb_attr_clone */
 154
 155 static int
 156 sdb_svc_init(sdb_object_t *obj, va_list ap)
 157 {
 158         const char *hostname = va_arg(ap, const char *);
 159
 160         SDB_SVC(obj)->hostname = strdup(hostname);
 161         if (! SDB_SVC(obj)->hostname)
 162                 return -1;
 163
 164         SDB_SVC(obj)->_last_update = sdb_gettime();
 165         /* ignore errors -> last_update will be updated later */
 166         return 0;
 167 } /* sdb_svc_init */
 168
 169 static void
 170 sdb_svc_destroy(sdb_object_t *obj)
 171 {
 172         assert(obj);
 173
 174         if (SDB_SVC(obj)->hostname)
 175                 free(SDB_SVC(obj)->hostname);
 176 } /* sdb_svc_destroy */
 177
 178 static sdb_object_t *
 179 sdb_svc_clone(const sdb_object_t *obj)
 180 {
 181         const sdb_service_t *svc = (const sdb_service_t *)obj;
 182         sdb_service_t *new;
 183
 184         new = SDB_SVC(sdb_object_create(obj->name, sdb_service_type,
 185                                 svc->hostname));
 186         if (! new)
 187                 return NULL;
 188
 189         new->_last_update = svc->_last_update;
 190         return SDB_OBJ(new);
 191 } /* sdb_svc_clone */
 192
 193 const sdb_type_t sdb_host_type = {
 194         sizeof(sdb_host_t),
 195
 196         sdb_host_init,
 197         sdb_host_destroy,
 198         sdb_host_do_clone
 199 };
 200
 201 const sdb_type_t sdb_attribute_type = {
 202         sizeof(sdb_attribute_t),
 203
 204         sdb_attr_init,
 205         sdb_attr_destroy,
 206         sdb_attr_clone
 207 };
 208
 209 const sdb_type_t sdb_service_type = {
 210         sizeof(sdb_service_t),
 211
 212         sdb_svc_init,
 213         sdb_svc_destroy,
 214         sdb_svc_clone
 215 };
 216
 217 /*
 218  * public API
 219  */
 220
 221 int
 222 sdb_store_host(const char *name, sdb_time_t last_update)
 223 {
 224         sdb_host_t *old;
 225
 226         char *cname;
 227         int status = 0;
 228
 229         if (! name)
 230                 return -1;
 231
 232         cname = sdb_plugin_cname(strdup(name));
 233         if (! cname) {
 234                 sdb_log(SDB_LOG_ERR, "store: strdup failed");
 235                 return -1;
 236         }
 237
 238         if (last_update <= 0)
 239                 last_update = sdb_gettime();
 240
 241         pthread_rwlock_wrlock(&host_lock);
 242
 243         if (! host_list) {
 244                 if (! (host_list = sdb_llist_create())) {
 245                         pthread_rwlock_unlock(&host_lock);
 246                         return -1;
 247                 }
 248         }
 249
 250         old = SDB_HOST(sdb_llist_search_by_name(host_list, cname));
 251
 252         if (old) {
 253                 if (old->_last_update > last_update) {
 254                         sdb_log(SDB_LOG_DEBUG, "store: Cannot update host '%s' - "
 255                                         "value too old (%"PRIscTIME" < %"PRIscTIME")",
 256                                         cname, last_update, old->_last_update);
 257                         /* don't report an error; the host may be updated by multiple
 258                          * backends */
 259                         status = 1;
 260                 }
 261                 else {
 262                         old->_last_update = last_update;
 263                 }
 264         }
 265         else {
 266                 sdb_host_t *new = SDB_HOST(sdb_object_create(name, sdb_host_type));
 267                 if (! new) {
 268                         char errbuf[1024];
 269                         sdb_log(SDB_LOG_ERR, "store: Failed to clone host object: %s",
 270                                         sdb_strerror(errno, errbuf, sizeof(errbuf)));
 271                         pthread_rwlock_unlock(&host_lock);
 272                         return -1;
 273                 }
 274
 275                 free(SDB_OBJ(new)->name);
 276                 SDB_OBJ(new)->name = cname;
 277
 278                 if (! new->attributes) {
 279                         if (! (new->attributes = sdb_llist_create())) {
 280                                 char errbuf[1024];
 281                                 sdb_log(SDB_LOG_ERR, "store: Failed to initialize "
 282                                                 "host object '%s': %s", SDB_OBJ(new)->name,
 283                                                 sdb_strerror(errno, errbuf, sizeof(errbuf)));
 284                                 sdb_object_deref(SDB_OBJ(new));
 285                                 pthread_rwlock_unlock(&host_lock);
 286                                 return -1;
 287                         }
 288                 }
 289
 290                 if (! new->services) {
 291                         if (! (new->services = sdb_llist_create())) {
 292                                 char errbuf[1024];
 293                                 sdb_log(SDB_LOG_ERR, "store: Failed to initialize "
 294                                                 "host object '%s': %s", SDB_OBJ(new)->name,
 295                                                 sdb_strerror(errno, errbuf, sizeof(errbuf)));
 296                                 sdb_object_deref(SDB_OBJ(new));
 297                                 pthread_rwlock_unlock(&host_lock);
 298                                 return -1;
 299                         }
 300                 }
 301
 302                 status = sdb_llist_insert_sorted(host_list, SDB_OBJ(new),
 303                                 sdb_object_cmp_by_name);
 304
 305                 /* pass control to the list or destroy in case of an error */
 306                 sdb_object_deref(SDB_OBJ(new));
 307         }
 308
 309         pthread_rwlock_unlock(&host_lock);
 310         return status;
 311 } /* sdb_store_host */
 312
 313 _Bool
 314 sdb_store_has_host(const char *name)
 315 {
 316         sdb_host_t *host;
 317
 318         if (! name)
 319                 return NULL;
 320
 321         host = SDB_HOST(sdb_llist_search_by_name(host_list, name));
 322         return host != NULL;
 323 } /* sdb_store_has_host */
 324
 325 int
 326 sdb_store_attribute(const char *hostname, const char *key, const char *value,
 327                 sdb_time_t last_update)
 328 {
 329         sdb_host_t *host;
 330         sdb_attribute_t *old;
 331
 332         int status = 0;
 333
 334         if ((! hostname) || (! key))
 335                 return -1;
 336
 337         if (last_update <= 0)
 338                 last_update = sdb_gettime();
 339
 340         if (! host_list)
 341                 return -1;
 342
 343         pthread_rwlock_wrlock(&host_lock);
 344
 345         host = SDB_HOST(sdb_llist_search_by_name(host_list, hostname));
 346         if (! host) {
 347                 pthread_rwlock_unlock(&host_lock);
 348                 return -1;
 349         }
 350
 351         old = SDB_ATTR(sdb_llist_search_by_name(host->attributes, key));
 352         if (old) {
 353                 if (old->_last_update > last_update) {
 354                         sdb_log(SDB_LOG_DEBUG, "store: Cannot update attribute "
 355                                         "'%s/%s' - value too old (%"PRIscTIME" < %"PRIscTIME")",
 356                                         hostname, key, last_update, old->_last_update);
 357                         status = 1;
 358                 }
 359                 else {
 360                         old->_last_update = last_update;
 361                 }
 362         }
 363         else {
 364                 sdb_attribute_t *new = SDB_ATTR(sdb_object_create(key,
 365                                         sdb_attribute_type, hostname, value));
 366                 if (! new) {
 367                         char errbuf[1024];
 368                         sdb_log(SDB_LOG_ERR, "store: Failed to clone attribute "
 369                                         "object: %s", sdb_strerror(errno, errbuf, sizeof(errbuf)));
 370                         pthread_rwlock_unlock(&host_lock);
 371                         return -1;
 372                 }
 373
 374                 status = sdb_llist_insert_sorted(host->attributes, SDB_OBJ(new),
 375                                 sdb_object_cmp_by_name);
 376
 377                 /* pass control to the list or destroy in case of an error */
 378                 sdb_object_deref(SDB_OBJ(new));
 379         }
 380
 381         pthread_rwlock_unlock(&host_lock);
 382         return status;
 383 } /* sdb_store_attribute */
 384
 385 int
 386 sdb_store_service(const char *hostname, const char *name,
 387                 sdb_time_t last_update)
 388 {
 389         sdb_host_t *host;
 390         sdb_service_t *old;
 391
 392         int status = 0;
 393
 394         if ((! hostname) || (! name))
 395                 return -1;
 396
 397         if (last_update <= 0)
 398                 last_update = sdb_gettime();
 399
 400         if (! host_list)
 401                 return -1;
 402
 403         pthread_rwlock_wrlock(&host_lock);
 404
 405         host = SDB_HOST(sdb_llist_search_by_name(host_list, hostname));
 406         if (! host) {
 407                 pthread_rwlock_unlock(&host_lock);
 408                 return -1;
 409         }
 410
 411         old = SDB_SVC(sdb_llist_search_by_name(host->services, name));
 412         if (old) {
 413                 if (old->_last_update > last_update) {
 414                         sdb_log(SDB_LOG_DEBUG, "store: Cannot update service "
 415                                         "'%s/%s' - value too old (%"PRIscTIME" < %"PRIscTIME")",
 416                                         hostname, name, last_update, old->_last_update);
 417                         status = 1;
 418                 }
 419                 else {
 420                         old->_last_update = last_update;
 421                 }
 422         }
 423         else {
 424                 sdb_service_t *new = SDB_SVC(sdb_object_create(name, sdb_service_type,
 425                                         hostname));
 426                 if (! new) {
 427                         char errbuf[1024];
 428                         sdb_log(SDB_LOG_ERR, "store: Failed to clone service "
 429                                         "object: %s", sdb_strerror(errno, errbuf, sizeof(errbuf)));
 430                         pthread_rwlock_unlock(&host_lock);
 431                         return -1;
 432                 }
 433
 434                 status = sdb_llist_insert_sorted(host->services, SDB_OBJ(new),
 435                                 sdb_object_cmp_by_name);
 436
 437                 /* pass control to the list or destroy in case of an error */
 438                 sdb_object_deref(SDB_OBJ(new));
 439         }
 440
 441         pthread_rwlock_unlock(&host_lock);
 442         return status;
 443 } /* sdb_store_service */
 444
 445 int
 446 sdb_store_dump(FILE *fh)
 447 {
 448         sdb_llist_iter_t *host_iter;
 449
 450         if (! fh)
 451                 return -1;
 452
 453         pthread_rwlock_rdlock(&host_lock);
 454
 455         host_iter = sdb_llist_get_iter(host_list);
 456         if (! host_iter) {
 457                 pthread_rwlock_unlock(&host_lock);
 458                 return -1;
 459         }
 460
 461         while (sdb_llist_iter_has_next(host_iter)) {
 462                 sdb_host_t *host = SDB_HOST(sdb_llist_iter_get_next(host_iter));
 463                 sdb_llist_iter_t *svc_iter;
 464                 sdb_llist_iter_t *attr_iter;
 465
 466                 char time_str[64];
 467
 468                 assert(host);
 469
 470                 if (! sdb_strftime(time_str, sizeof(time_str),
 471                                         "%F %T %z", host->_last_update))
 472                         snprintf(time_str, sizeof(time_str), "<error>");
 473                 time_str[sizeof(time_str) - 1] = '\0';
 474
 475                 fprintf(fh, "Host '%s' (last updated: %s):\n",
 476                                 SDB_OBJ(host)->name, time_str);
 477
 478                 attr_iter = sdb_llist_get_iter(host->attributes);
 479                 if (! attr_iter) {
 480                         char errbuf[1024];
 481                         fprintf(fh, "Failed to retrieve attributes: %s\n",
 482                                         sdb_strerror(errno, errbuf, sizeof(errbuf)));
 483                         continue;
 484                 }
 485
 486                 while (sdb_llist_iter_has_next(attr_iter)) {
 487                         sdb_attribute_t *attr = SDB_ATTR(sdb_llist_iter_get_next(attr_iter));
 488                         assert(attr);
 489
 490                         if (! sdb_strftime(time_str, sizeof(time_str),
 491                                                 "%F %T %z", attr->_last_update))
 492                                 snprintf(time_str, sizeof(time_str), "<error>");
 493                         time_str[sizeof(time_str) - 1] = '\0';
 494
 495                         fprintf(fh, "\tAttribute '%s' -> '%s' (last updated: %s)\n",
 496                                         SDB_OBJ(attr)->name, attr->attr_value, time_str);
 497                 }
 498
 499                 sdb_llist_iter_destroy(attr_iter);
 500
 501                 svc_iter = sdb_llist_get_iter(host->services);
 502                 if (! svc_iter) {
 503                         char errbuf[1024];
 504                         fprintf(fh, "Failed to retrieve services: %s\n",
 505                                         sdb_strerror(errno, errbuf, sizeof(errbuf)));
 506                         continue;
 507                 }
 508
 509                 while (sdb_llist_iter_has_next(svc_iter)) {
 510                         sdb_service_t *svc = SDB_SVC(sdb_llist_iter_get_next(svc_iter));
 511                         assert(svc);
 512
 513                         if (! sdb_strftime(time_str, sizeof(time_str),
 514                                                 "%F %T %z", svc->_last_update))
 515                                 snprintf(time_str, sizeof(time_str), "<error>");
 516                         time_str[sizeof(time_str) - 1] = '\0';
 517
 518                         fprintf(fh, "\tService '%s' (last updated: %s)\n",
 519                                         SDB_OBJ(svc)->name, time_str);
 520                 }
 521
 522                 sdb_llist_iter_destroy(svc_iter);
 523         }
 524
 525         sdb_llist_iter_destroy(host_iter);
 526         pthread_rwlock_unlock(&host_lock);
 527         return 0;
 528 } /* sdb_store_dump */
 529
 530 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 531