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         last_update = last_update;
 239         if (last_update <= 0)
 240                 last_update = sdb_gettime();
 241
 242         pthread_rwlock_wrlock(&host_lock);
 243
 244         if (! host_list) {
 245                 if (! (host_list = sdb_llist_create())) {
 246                         pthread_rwlock_unlock(&host_lock);
 247                         return -1;
 248                 }
 249         }
 250
 251         old = SDB_HOST(sdb_llist_search_by_name(host_list, cname));
 252
 253         if (old) {
 254                 if (old->_last_update > last_update) {
 255                         sdb_log(SDB_LOG_DEBUG, "store: Cannot update host '%s' - "
 256                                         "value too old (%"PRIscTIME" < %"PRIscTIME")",
 257                                         cname, last_update, old->_last_update);
 258                         /* don't report an error; the host may be updated by multiple
 259                          * backends */
 260                         status = 1;
 261                 }
 262                 else {
 263                         old->_last_update = last_update;
 264                 }
 265         }
 266         else {
 267                 sdb_host_t *new = SDB_HOST(sdb_object_create(name, sdb_host_type));
 268                 if (! new) {
 269                         char errbuf[1024];
 270                         sdb_log(SDB_LOG_ERR, "store: Failed to clone host object: %s",
 271                                         sdb_strerror(errno, errbuf, sizeof(errbuf)));
 272                         pthread_rwlock_unlock(&host_lock);
 273                         return -1;
 274                 }
 275
 276                 free(SDB_OBJ(new)->name);
 277                 SDB_OBJ(new)->name = cname;
 278
 279                 if (! new->attributes) {
 280                         if (! (new->attributes = sdb_llist_create())) {
 281                                 char errbuf[1024];
 282                                 sdb_log(SDB_LOG_ERR, "store: Failed to initialize "
 283                                                 "host object '%s': %s", SDB_OBJ(new)->name,
 284                                                 sdb_strerror(errno, errbuf, sizeof(errbuf)));
 285                                 sdb_object_deref(SDB_OBJ(new));
 286                                 pthread_rwlock_unlock(&host_lock);
 287                                 return -1;
 288                         }
 289                 }
 290
 291                 if (! new->services) {
 292                         if (! (new->services = sdb_llist_create())) {
 293                                 char errbuf[1024];
 294                                 sdb_log(SDB_LOG_ERR, "store: Failed to initialize "
 295                                                 "host object '%s': %s", SDB_OBJ(new)->name,
 296                                                 sdb_strerror(errno, errbuf, sizeof(errbuf)));
 297                                 sdb_object_deref(SDB_OBJ(new));
 298                                 pthread_rwlock_unlock(&host_lock);
 299                                 return -1;
 300                         }
 301                 }
 302
 303                 status = sdb_llist_insert_sorted(host_list, SDB_OBJ(new),
 304                                 sdb_object_cmp_by_name);
 305
 306                 /* pass control to the list or destroy in case of an error */
 307                 sdb_object_deref(SDB_OBJ(new));
 308         }
 309
 310         pthread_rwlock_unlock(&host_lock);
 311         return status;
 312 } /* sdb_store_host */
 313
 314 _Bool
 315 sdb_store_has_host(const char *name)
 316 {
 317         sdb_host_t *host;
 318
 319         if (! name)
 320                 return NULL;
 321
 322         host = SDB_HOST(sdb_llist_search_by_name(host_list, name));
 323         return host != NULL;
 324 } /* sdb_store_has_host */
 325
 326 int
 327 sdb_store_attribute(const sdb_attribute_t *attr)
 328 {
 329         sdb_host_t *host;
 330         sdb_attribute_t *old;
 331         sdb_time_t last_update;
 332
 333         int status = 0;
 334
 335         if (! attr)
 336                 return -1;
 337
 338         last_update = attr->_last_update;
 339         if (last_update <= 0)
 340                 last_update = sdb_gettime();
 341
 342         if (! host_list)
 343                 return -1;
 344
 345         pthread_rwlock_wrlock(&host_lock);
 346
 347         host = SDB_HOST(sdb_llist_search_by_name(host_list, attr->hostname));
 348         if (! host) {
 349                 pthread_rwlock_unlock(&host_lock);
 350                 return -1;
 351         }
 352
 353         old = SDB_ATTR(sdb_llist_search_by_name(host->attributes,
 354                                 SDB_CONST_OBJ(attr)->name));
 355         if (old) {
 356                 if (old->_last_update > last_update) {
 357                         sdb_log(SDB_LOG_DEBUG, "store: Cannot update attribute "
 358                                         "'%s/%s' - value too old (%"PRIscTIME" < %"PRIscTIME")",
 359                                         attr->hostname, SDB_CONST_OBJ(attr)->name, last_update,
 360                                         old->_last_update);
 361                         status = 1;
 362                 }
 363                 else {
 364                         old->_last_update = last_update;
 365                 }
 366         }
 367         else {
 368                 sdb_attribute_t *new = SDB_ATTR(sdb_object_clone(SDB_CONST_OBJ(attr)));
 369                 if (! new) {
 370                         char errbuf[1024];
 371                         sdb_log(SDB_LOG_ERR, "store: Failed to clone attribute "
 372                                         "object: %s", sdb_strerror(errno, errbuf, sizeof(errbuf)));
 373                         pthread_rwlock_unlock(&host_lock);
 374                         return -1;
 375                 }
 376
 377                 status = sdb_llist_insert_sorted(host->attributes, SDB_OBJ(new),
 378                                 sdb_object_cmp_by_name);
 379
 380                 /* pass control to the list or destroy in case of an error */
 381                 sdb_object_deref(SDB_OBJ(new));
 382         }
 383
 384         pthread_rwlock_unlock(&host_lock);
 385         return status;
 386 } /* sdb_store_attribute */
 387
 388 int
 389 sdb_store_service(const sdb_service_t *svc)
 390 {
 391         sdb_host_t *host;
 392         sdb_service_t *old;
 393         sdb_time_t last_update;
 394
 395         int status = 0;
 396
 397         if (! svc)
 398                 return -1;
 399
 400         last_update = svc->_last_update;
 401         if (last_update <= 0)
 402                 last_update = sdb_gettime();
 403
 404         if (! host_list)
 405                 return -1;
 406
 407         pthread_rwlock_wrlock(&host_lock);
 408
 409         host = SDB_HOST(sdb_llist_search_by_name(host_list, svc->hostname));
 410         if (! host) {
 411                 pthread_rwlock_unlock(&host_lock);
 412                 return -1;
 413         }
 414
 415         old = SDB_SVC(sdb_llist_search_by_name(host->services,
 416                                 SDB_CONST_OBJ(svc)->name));
 417         if (old) {
 418                 if (old->_last_update > last_update) {
 419                         sdb_log(SDB_LOG_DEBUG, "store: Cannot update service "
 420                                         "'%s/%s' - value too old (%"PRIscTIME" < %"PRIscTIME")",
 421                                         svc->hostname, SDB_CONST_OBJ(svc)->name, last_update,
 422                                         old->_last_update);
 423                         status = 1;
 424                 }
 425                 else {
 426                         old->_last_update = last_update;
 427                 }
 428         }
 429         else {
 430                 sdb_service_t *new = SDB_SVC(sdb_object_clone(SDB_CONST_OBJ(svc)));
 431                 if (! new) {
 432                         char errbuf[1024];
 433                         sdb_log(SDB_LOG_ERR, "store: Failed to clone service "
 434                                         "object: %s", sdb_strerror(errno, errbuf, sizeof(errbuf)));
 435                         pthread_rwlock_unlock(&host_lock);
 436                         return -1;
 437                 }
 438
 439                 status = sdb_llist_insert_sorted(host->services, SDB_OBJ(new),
 440                                 sdb_object_cmp_by_name);
 441
 442                 /* pass control to the list or destroy in case of an error */
 443                 sdb_object_deref(SDB_OBJ(new));
 444         }
 445
 446         pthread_rwlock_unlock(&host_lock);
 447         return status;
 448 } /* sdb_store_service */
 449
 450 const sdb_service_t *
 451 sdb_store_get_service(const sdb_host_t *host, const char *name)
 452 {
 453         sdb_service_t *svc;
 454
 455         if ((! host) || (! name))
 456                 return NULL;
 457
 458         svc = SDB_SVC(sdb_llist_search_by_name(host->services, name));
 459         if (! svc)
 460                 return NULL;
 461         return svc;
 462 } /* sdb_store_get_service */
 463
 464 int
 465 sdb_store_dump(FILE *fh)
 466 {
 467         sdb_llist_iter_t *host_iter;
 468
 469         if (! fh)
 470                 return -1;
 471
 472         pthread_rwlock_rdlock(&host_lock);
 473
 474         host_iter = sdb_llist_get_iter(host_list);
 475         if (! host_iter) {
 476                 pthread_rwlock_unlock(&host_lock);
 477                 return -1;
 478         }
 479
 480         while (sdb_llist_iter_has_next(host_iter)) {
 481                 sdb_host_t *host = SDB_HOST(sdb_llist_iter_get_next(host_iter));
 482                 sdb_llist_iter_t *svc_iter;
 483                 sdb_llist_iter_t *attr_iter;
 484
 485                 char time_str[64];
 486
 487                 assert(host);
 488
 489                 if (! sdb_strftime(time_str, sizeof(time_str),
 490                                         "%F %T %z", host->_last_update))
 491                         snprintf(time_str, sizeof(time_str), "<error>");
 492                 time_str[sizeof(time_str) - 1] = '\0';
 493
 494                 fprintf(fh, "Host '%s' (last updated: %s):\n",
 495                                 SDB_OBJ(host)->name, time_str);
 496
 497                 attr_iter = sdb_llist_get_iter(host->attributes);
 498                 if (! attr_iter) {
 499                         char errbuf[1024];
 500                         fprintf(fh, "Failed to retrieve attributes: %s\n",
 501                                         sdb_strerror(errno, errbuf, sizeof(errbuf)));
 502                         continue;
 503                 }
 504
 505                 while (sdb_llist_iter_has_next(attr_iter)) {
 506                         sdb_attribute_t *attr = SDB_ATTR(sdb_llist_iter_get_next(attr_iter));
 507                         assert(attr);
 508
 509                         if (! sdb_strftime(time_str, sizeof(time_str),
 510                                                 "%F %T %z", attr->_last_update))
 511                                 snprintf(time_str, sizeof(time_str), "<error>");
 512                         time_str[sizeof(time_str) - 1] = '\0';
 513
 514                         fprintf(fh, "\tAttribute '%s' -> '%s' (last updated: %s)\n",
 515                                         SDB_OBJ(attr)->name, attr->attr_value, time_str);
 516                 }
 517
 518                 sdb_llist_iter_destroy(attr_iter);
 519
 520                 svc_iter = sdb_llist_get_iter(host->services);
 521                 if (! svc_iter) {
 522                         char errbuf[1024];
 523                         fprintf(fh, "Failed to retrieve services: %s\n",
 524                                         sdb_strerror(errno, errbuf, sizeof(errbuf)));
 525                         continue;
 526                 }
 527
 528                 while (sdb_llist_iter_has_next(svc_iter)) {
 529                         sdb_service_t *svc = SDB_SVC(sdb_llist_iter_get_next(svc_iter));
 530                         assert(svc);
 531
 532                         if (! sdb_strftime(time_str, sizeof(time_str),
 533                                                 "%F %T %z", svc->_last_update))
 534                                 snprintf(time_str, sizeof(time_str), "<error>");
 535                         time_str[sizeof(time_str) - 1] = '\0';
 536
 537                         fprintf(fh, "\tService '%s' (last updated: %s)\n",
 538                                         SDB_OBJ(svc)->name, time_str);
 539                 }
 540
 541                 sdb_llist_iter_destroy(svc_iter);
 542         }
 543
 544         sdb_llist_iter_destroy(host_iter);
 545         pthread_rwlock_unlock(&host_lock);
 546         return 0;
 547 } /* sdb_store_dump */
 548
 549 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 550