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