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_attribute_create(attr->hostname,
 147                         obj->name, 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_service_create(svc->hostname, obj->name);
 185         if (! new)
 186                 return NULL;
 187
 188         new->_last_update = svc->_last_update;
 189         return SDB_OBJ(new);
 190 } /* sdb_svc_clone */
 191
 192 const sdb_type_t sdb_host_type = {
 193         sizeof(sdb_host_t),
 194
 195         sdb_host_init,
 196         sdb_host_destroy,
 197         sdb_host_do_clone
 198 };
 199
 200 const sdb_type_t sdb_attribute_type = {
 201         sizeof(sdb_attribute_t),
 202
 203         sdb_attr_init,
 204         sdb_attr_destroy,
 205         sdb_attr_clone
 206 };
 207
 208 const sdb_type_t sdb_service_type = {
 209         sizeof(sdb_service_t),
 210
 211         sdb_svc_init,
 212         sdb_svc_destroy,
 213         sdb_svc_clone
 214 };
 215
 216 /*
 217  * public API
 218  */
 219
 220 int
 221 sdb_store_host(const char *name, sdb_time_t last_update)
 222 {
 223         sdb_host_t *old;
 224
 225         char *cname;
 226         int status = 0;
 227
 228         if (! name)
 229                 return -1;
 230
 231         cname = sdb_plugin_cname(strdup(name));
 232         if (! cname) {
 233                 sdb_log(SDB_LOG_ERR, "store: strdup failed");
 234                 return -1;
 235         }
 236
 237         last_update = last_update;
 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 const sdb_host_t *
 314 sdb_store_get_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         if (! host)
 323                 return NULL;
 324         return host;
 325 } /* sdb_store_get_host */
 326
 327 sdb_attribute_t *
 328 sdb_attribute_create(const char *hostname,
 329                 const char *name, const char *value)
 330 {
 331         sdb_object_t *obj;
 332
 333         if ((! hostname) || (! name) || (! value))
 334                 return NULL;
 335
 336         obj = sdb_object_create(name, sdb_attribute_type, hostname, value);
 337         if (! obj)
 338                 return NULL;
 339         return SDB_ATTR(obj);
 340 } /* sdb_attribute_create */
 341
 342 int
 343 sdb_store_attribute(const sdb_attribute_t *attr)
 344 {
 345         sdb_host_t *host;
 346         sdb_attribute_t *old;
 347         sdb_time_t last_update;
 348
 349         int status = 0;
 350
 351         if (! attr)
 352                 return -1;
 353
 354         last_update = attr->_last_update;
 355         if (last_update <= 0)
 356                 last_update = sdb_gettime();
 357
 358         if (! host_list)
 359                 return -1;
 360
 361         pthread_rwlock_wrlock(&host_lock);
 362
 363         host = SDB_HOST(sdb_llist_search_by_name(host_list, attr->hostname));
 364         if (! host) {
 365                 pthread_rwlock_unlock(&host_lock);
 366                 return -1;
 367         }
 368
 369         old = SDB_ATTR(sdb_llist_search_by_name(host->attributes,
 370                                 SDB_CONST_OBJ(attr)->name));
 371         if (old) {
 372                 if (old->_last_update > last_update) {
 373                         sdb_log(SDB_LOG_DEBUG, "store: Cannot update attribute "
 374                                         "'%s/%s' - value too old (%"PRIscTIME" < %"PRIscTIME")",
 375                                         attr->hostname, SDB_CONST_OBJ(attr)->name, last_update,
 376                                         old->_last_update);
 377                         status = 1;
 378                 }
 379                 else {
 380                         old->_last_update = last_update;
 381                 }
 382         }
 383         else {
 384                 sdb_attribute_t *new = SDB_ATTR(sdb_object_clone(SDB_CONST_OBJ(attr)));
 385                 if (! new) {
 386                         char errbuf[1024];
 387                         sdb_log(SDB_LOG_ERR, "store: Failed to clone attribute "
 388                                         "object: %s", sdb_strerror(errno, errbuf, sizeof(errbuf)));
 389                         pthread_rwlock_unlock(&host_lock);
 390                         return -1;
 391                 }
 392
 393                 status = sdb_llist_insert_sorted(host->attributes, SDB_OBJ(new),
 394                                 sdb_object_cmp_by_name);
 395
 396                 /* pass control to the list or destroy in case of an error */
 397                 sdb_object_deref(SDB_OBJ(new));
 398         }
 399
 400         pthread_rwlock_unlock(&host_lock);
 401         return status;
 402 } /* sdb_store_attribute */
 403
 404 sdb_service_t *
 405 sdb_service_create(const char *hostname, const char *name)
 406 {
 407         sdb_object_t *obj;
 408
 409         if ((! hostname) || (! name))
 410                 return NULL;
 411
 412         obj = sdb_object_create(name, sdb_service_type, hostname);
 413         if (! obj)
 414                 return NULL;
 415         return SDB_SVC(obj);
 416 } /* sdb_service_create */
 417
 418 int
 419 sdb_store_service(const sdb_service_t *svc)
 420 {
 421         sdb_host_t *host;
 422         sdb_service_t *old;
 423         sdb_time_t last_update;
 424
 425         int status = 0;
 426
 427         if (! svc)
 428                 return -1;
 429
 430         last_update = svc->_last_update;
 431         if (last_update <= 0)
 432                 last_update = sdb_gettime();
 433
 434         if (! host_list)
 435                 return -1;
 436
 437         pthread_rwlock_wrlock(&host_lock);
 438
 439         host = SDB_HOST(sdb_llist_search_by_name(host_list, svc->hostname));
 440         if (! host) {
 441                 pthread_rwlock_unlock(&host_lock);
 442                 return -1;
 443         }
 444
 445         old = SDB_SVC(sdb_llist_search_by_name(host->services,
 446                                 SDB_CONST_OBJ(svc)->name));
 447         if (old) {
 448                 if (old->_last_update > last_update) {
 449                         sdb_log(SDB_LOG_DEBUG, "store: Cannot update service "
 450                                         "'%s/%s' - value too old (%"PRIscTIME" < %"PRIscTIME")",
 451                                         svc->hostname, SDB_CONST_OBJ(svc)->name, last_update,
 452                                         old->_last_update);
 453                         status = 1;
 454                 }
 455                 else {
 456                         old->_last_update = last_update;
 457                 }
 458         }
 459         else {
 460                 sdb_service_t *new = SDB_SVC(sdb_object_clone(SDB_CONST_OBJ(svc)));
 461                 if (! new) {
 462                         char errbuf[1024];
 463                         sdb_log(SDB_LOG_ERR, "store: Failed to clone service "
 464                                         "object: %s", sdb_strerror(errno, errbuf, sizeof(errbuf)));
 465                         pthread_rwlock_unlock(&host_lock);
 466                         return -1;
 467                 }
 468
 469                 status = sdb_llist_insert_sorted(host->services, SDB_OBJ(new),
 470                                 sdb_object_cmp_by_name);
 471
 472                 /* pass control to the list or destroy in case of an error */
 473                 sdb_object_deref(SDB_OBJ(new));
 474         }
 475
 476         pthread_rwlock_unlock(&host_lock);
 477         return status;
 478 } /* sdb_store_service */
 479
 480 const sdb_service_t *
 481 sdb_store_get_service(const sdb_host_t *host, const char *name)
 482 {
 483         sdb_service_t *svc;
 484
 485         if ((! host) || (! name))
 486                 return NULL;
 487
 488         svc = SDB_SVC(sdb_llist_search_by_name(host->services, name));
 489         if (! svc)
 490                 return NULL;
 491         return svc;
 492 } /* sdb_store_get_service */
 493
 494 int
 495 sdb_store_dump(FILE *fh)
 496 {
 497         sdb_llist_iter_t *host_iter;
 498
 499         if (! fh)
 500                 return -1;
 501
 502         pthread_rwlock_rdlock(&host_lock);
 503
 504         host_iter = sdb_llist_get_iter(host_list);
 505         if (! host_iter) {
 506                 pthread_rwlock_unlock(&host_lock);
 507                 return -1;
 508         }
 509
 510         while (sdb_llist_iter_has_next(host_iter)) {
 511                 sdb_host_t *host = SDB_HOST(sdb_llist_iter_get_next(host_iter));
 512                 sdb_llist_iter_t *svc_iter;
 513                 sdb_llist_iter_t *attr_iter;
 514
 515                 char time_str[64];
 516
 517                 assert(host);
 518
 519                 if (! sdb_strftime(time_str, sizeof(time_str),
 520                                         "%F %T %z", host->_last_update))
 521                         snprintf(time_str, sizeof(time_str), "<error>");
 522                 time_str[sizeof(time_str) - 1] = '\0';
 523
 524                 fprintf(fh, "Host '%s' (last updated: %s):\n",
 525                                 SDB_OBJ(host)->name, time_str);
 526
 527                 attr_iter = sdb_llist_get_iter(host->attributes);
 528                 if (! attr_iter) {
 529                         char errbuf[1024];
 530                         fprintf(fh, "Failed to retrieve attributes: %s\n",
 531                                         sdb_strerror(errno, errbuf, sizeof(errbuf)));
 532                         continue;
 533                 }
 534
 535                 while (sdb_llist_iter_has_next(attr_iter)) {
 536                         sdb_attribute_t *attr = SDB_ATTR(sdb_llist_iter_get_next(attr_iter));
 537                         assert(attr);
 538
 539                         if (! sdb_strftime(time_str, sizeof(time_str),
 540                                                 "%F %T %z", attr->_last_update))
 541                                 snprintf(time_str, sizeof(time_str), "<error>");
 542                         time_str[sizeof(time_str) - 1] = '\0';
 543
 544                         fprintf(fh, "\tAttribute '%s' -> '%s' (last updated: %s)\n",
 545                                         SDB_OBJ(attr)->name, attr->attr_value, time_str);
 546                 }
 547
 548                 sdb_llist_iter_destroy(attr_iter);
 549
 550                 svc_iter = sdb_llist_get_iter(host->services);
 551                 if (! svc_iter) {
 552                         char errbuf[1024];
 553                         fprintf(fh, "Failed to retrieve services: %s\n",
 554                                         sdb_strerror(errno, errbuf, sizeof(errbuf)));
 555                         continue;
 556                 }
 557
 558                 while (sdb_llist_iter_has_next(svc_iter)) {
 559                         sdb_service_t *svc = SDB_SVC(sdb_llist_iter_get_next(svc_iter));
 560                         assert(svc);
 561
 562                         if (! sdb_strftime(time_str, sizeof(time_str),
 563                                                 "%F %T %z", svc->_last_update))
 564                                 snprintf(time_str, sizeof(time_str), "<error>");
 565                         time_str[sizeof(time_str) - 1] = '\0';
 566
 567                         fprintf(fh, "\tService '%s' (last updated: %s)\n",
 568                                         SDB_OBJ(svc)->name, time_str);
 569                 }
 570
 571                 sdb_llist_iter_destroy(svc_iter);
 572         }
 573
 574         sdb_llist_iter_destroy(host_iter);
 575         pthread_rwlock_unlock(&host_lock);
 576         return 0;
 577 } /* sdb_store_dump */
 578
 579 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 580