src/utils_vl_lookup.c

   1 /**
   2  * collectd - src/utils_vl_lookup.c
   3  * Copyright (C) 2012  Florian Forster
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *   Florian Forster <octo at collectd.org>
  25  **/
  26
  27 #include "collectd.h"
  28
  29 #include <regex.h>
  30
  31 #include "common.h"
  32 #include "utils_vl_lookup.h"
  33 #include "utils_avltree.h"
  34
  35 #if BUILD_TEST
  36 # define sstrncpy strncpy
  37 # define plugin_log(s, ...) do { \
  38   printf ("[severity %i] ", s); \
  39   printf (__VA_ARGS__); \
  40   printf ("\n"); \
  41 } while (0)
  42 #endif
  43
  44 /*
  45  * Types
  46  */
  47 struct part_match_s
  48 {
  49   char str[DATA_MAX_NAME_LEN];
  50   regex_t regex;
  51   _Bool is_regex;
  52 };
  53 typedef struct part_match_s part_match_t;
  54
  55 struct identifier_match_s
  56 {
  57   part_match_t host;
  58   part_match_t plugin;
  59   part_match_t plugin_instance;
  60   part_match_t type;
  61   part_match_t type_instance;
  62
  63   unsigned int group_by;
  64 };
  65 typedef struct identifier_match_s identifier_match_t;
  66
  67 struct lookup_s
  68 {
  69   c_avl_tree_t *by_type_tree;
  70
  71   lookup_class_callback_t cb_user_class;
  72   lookup_obj_callback_t cb_user_obj;
  73   lookup_free_class_callback_t cb_free_class;
  74   lookup_free_obj_callback_t cb_free_obj;
  75 };
  76
  77 struct user_obj_s;
  78 typedef struct user_obj_s user_obj_t;
  79 struct user_obj_s
  80 {
  81   void *user_obj;
  82   identifier_t ident;
  83
  84   user_obj_t *next;
  85 };
  86
  87 struct user_class_s
  88 {
  89   void *user_class;
  90   identifier_match_t match;
  91   user_obj_t *user_obj_list; /* list of user_obj */
  92 };
  93 typedef struct user_class_s user_class_t;
  94
  95 struct user_class_list_s;
  96 typedef struct user_class_list_s user_class_list_t;
  97 struct user_class_list_s
  98 {
  99   user_class_t entry;
 100   user_class_list_t *next;
 101 };
 102
 103 struct by_type_entry_s
 104 {
 105   c_avl_tree_t *by_plugin_tree; /* plugin -> user_class_list_t */
 106   user_class_list_t *wildcard_plugin_list;
 107 };
 108 typedef struct by_type_entry_s by_type_entry_t;
 109
 110 /*
 111  * Private functions
 112  */
 113 static _Bool lu_part_matches (part_match_t const *match, /* {{{ */
 114     char const *str)
 115 {
 116   if (match->is_regex)
 117   {
 118     /* Short cut popular catch-all regex. */
 119     if (strcmp (".*", match->str) == 0)
 120       return (1);
 121
 122     int status = regexec (&match->regex, str,
 123         /* nmatch = */ 0, /* pmatch = */ NULL,
 124         /* flags = */ 0);
 125     if (status == 0)
 126       return (1);
 127     else
 128       return (0);
 129   }
 130   else if (strcmp (match->str, str) == 0)
 131     return (1);
 132   else
 133     return (0);
 134 } /* }}} _Bool lu_part_matches */
 135
 136 static int lu_copy_ident_to_match_part (part_match_t *match_part, /* {{{ */
 137     char const *ident_part)
 138 {
 139   size_t len = strlen (ident_part);
 140   int status;
 141
 142   if ((len < 3) || (ident_part[0] != '/') || (ident_part[len - 1] != '/'))
 143   {
 144     sstrncpy (match_part->str, ident_part, sizeof (match_part->str));
 145     match_part->is_regex = 0;
 146     return (0);
 147   }
 148
 149   /* Copy string without the leading slash. */
 150   sstrncpy (match_part->str, ident_part + 1, sizeof (match_part->str));
 151   assert (sizeof (match_part->str) > len);
 152   /* strip trailing slash */
 153   match_part->str[len - 2] = 0;
 154
 155   status = regcomp (&match_part->regex, match_part->str,
 156       /* flags = */ REG_EXTENDED);
 157   if (status != 0)
 158   {
 159     char errbuf[1024];
 160     regerror (status, &match_part->regex, errbuf, sizeof (errbuf));
 161     ERROR ("utils_vl_lookup: Compiling regular expression \"%s\" failed: %s",
 162         match_part->str, errbuf);
 163     return (EINVAL);
 164   }
 165   match_part->is_regex = 1;
 166
 167   return (0);
 168 } /* }}} int lu_copy_ident_to_match_part */
 169
 170 static int lu_copy_ident_to_match (identifier_match_t *match, /* {{{ */
 171     identifier_t const *ident, unsigned int group_by)
 172 {
 173   memset (match, 0, sizeof (*match));
 174
 175   match->group_by = group_by;
 176
 177 #define COPY_FIELD(field) do { \
 178   int status = lu_copy_ident_to_match_part (&match->field, ident->field); \
 179   if (status != 0) \
 180     return (status); \
 181 } while (0)
 182
 183   COPY_FIELD (host);
 184   COPY_FIELD (plugin);
 185   COPY_FIELD (plugin_instance);
 186   COPY_FIELD (type);
 187   COPY_FIELD (type_instance);
 188
 189 #undef COPY_FIELD
 190
 191   return (0);
 192 } /* }}} int lu_copy_ident_to_match */
 193
 194 static void *lu_create_user_obj (lookup_t *obj, /* {{{ */
 195     data_set_t const *ds, value_list_t const *vl,
 196     user_class_t *user_class)
 197 {
 198   user_obj_t *user_obj;
 199
 200   user_obj = malloc (sizeof (*user_obj));
 201   if (user_obj == NULL)
 202   {
 203     ERROR ("utils_vl_lookup: malloc failed.");
 204     return (NULL);
 205   }
 206   memset (user_obj, 0, sizeof (*user_obj));
 207   user_obj->next = NULL;
 208
 209   user_obj->user_obj = obj->cb_user_class (ds, vl, user_class->user_class);
 210   if (user_obj->user_obj == NULL)
 211   {
 212     sfree (user_obj);
 213     WARNING("utils_vl_lookup: User-provided constructor failed.");
 214     return (NULL);
 215   }
 216
 217 #define COPY_FIELD(field, group_mask) do { \
 218   if (user_class->match.field.is_regex \
 219       && ((user_class->match.group_by & group_mask) == 0)) \
 220     sstrncpy (user_obj->ident.field, "/.*/", sizeof (user_obj->ident.field)); \
 221   else \
 222     sstrncpy (user_obj->ident.field, vl->field, sizeof (user_obj->ident.field)); \
 223 } while (0)
 224
 225   COPY_FIELD (host, LU_GROUP_BY_HOST);
 226   COPY_FIELD (plugin, LU_GROUP_BY_PLUGIN);
 227   COPY_FIELD (plugin_instance, LU_GROUP_BY_PLUGIN_INSTANCE);
 228   COPY_FIELD (type, 0);
 229   COPY_FIELD (type_instance, LU_GROUP_BY_TYPE_INSTANCE);
 230
 231 #undef COPY_FIELD
 232
 233   if (user_class->user_obj_list == NULL)
 234   {
 235     user_class->user_obj_list = user_obj;
 236   }
 237   else
 238   {
 239     user_obj_t *last = user_class->user_obj_list;
 240     while (last->next != NULL)
 241       last = last->next;
 242     last->next = user_obj;
 243   }
 244
 245   return (user_obj);
 246 } /* }}} void *lu_create_user_obj */
 247
 248 static user_obj_t *lu_find_user_obj (user_class_t *user_class, /* {{{ */
 249     value_list_t const *vl)
 250 {
 251   user_obj_t *ptr;
 252
 253   for (ptr = user_class->user_obj_list;
 254       ptr != NULL;
 255       ptr = ptr->next)
 256   {
 257     if (user_class->match.host.is_regex
 258         && (user_class->match.group_by & LU_GROUP_BY_HOST)
 259         && (strcmp (vl->host, ptr->ident.host) != 0))
 260       continue;
 261     if (user_class->match.plugin.is_regex
 262         && (user_class->match.group_by & LU_GROUP_BY_PLUGIN)
 263         && (strcmp (vl->plugin, ptr->ident.plugin) != 0))
 264       continue;
 265     if (user_class->match.plugin_instance.is_regex
 266         && (user_class->match.group_by & LU_GROUP_BY_PLUGIN_INSTANCE)
 267         && (strcmp (vl->plugin_instance, ptr->ident.plugin_instance) != 0))
 268       continue;
 269     if (user_class->match.type_instance.is_regex
 270         && (user_class->match.group_by & LU_GROUP_BY_TYPE_INSTANCE)
 271         && (strcmp (vl->type_instance, ptr->ident.type_instance) != 0))
 272       continue;
 273
 274     return (ptr);
 275   }
 276
 277   return (NULL);
 278 } /* }}} user_obj_t *lu_find_user_obj */
 279
 280 static int lu_handle_user_class (lookup_t *obj, /* {{{ */
 281     data_set_t const *ds, value_list_t const *vl,
 282     user_class_t *user_class)
 283 {
 284   user_obj_t *user_obj;
 285   int status;
 286
 287   assert (strcmp (vl->type, user_class->match.type.str) == 0);
 288   assert (user_class->match.plugin.is_regex
 289       || (strcmp (vl->plugin, user_class->match.plugin.str)) == 0);
 290
 291   if (!lu_part_matches (&user_class->match.type_instance, vl->type_instance)
 292       || !lu_part_matches (&user_class->match.plugin_instance, vl->plugin_instance)
 293       || !lu_part_matches (&user_class->match.plugin, vl->plugin)
 294       || !lu_part_matches (&user_class->match.host, vl->host))
 295     return (1);
 296
 297   user_obj = lu_find_user_obj (user_class, vl);
 298   if (user_obj == NULL)
 299   {
 300     /* call lookup_class_callback_t() and insert into the list of user objects. */
 301     user_obj = lu_create_user_obj (obj, ds, vl, user_class);
 302     if (user_obj == NULL)
 303       return (-1);
 304   }
 305
 306   status = obj->cb_user_obj (ds, vl,
 307       user_class->user_class, user_obj->user_obj);
 308   if (status != 0)
 309   {
 310     ERROR ("utils_vl_lookup: The user object callback failed with status %i.",
 311         status);
 312     /* Returning a negative value means: abort! */
 313     if (status < 0)
 314       return (status);
 315     else
 316       return (1);
 317   }
 318
 319   return (0);
 320 } /* }}} int lu_handle_user_class */
 321
 322 static int lu_handle_user_class_list (lookup_t *obj, /* {{{ */
 323     data_set_t const *ds, value_list_t const *vl,
 324     user_class_list_t *user_class_list)
 325 {
 326   user_class_list_t *ptr;
 327   int retval = 0;
 328
 329   for (ptr = user_class_list; ptr != NULL; ptr = ptr->next)
 330   {
 331     int status;
 332
 333     status = lu_handle_user_class (obj, ds, vl, &ptr->entry);
 334     if (status < 0)
 335       return (status);
 336     else if (status == 0)
 337       retval++;
 338   }
 339
 340   return (retval);
 341 } /* }}} int lu_handle_user_class_list */
 342
 343 static by_type_entry_t *lu_search_by_type (lookup_t *obj, /* {{{ */
 344     char const *type, _Bool allocate_if_missing)
 345 {
 346   by_type_entry_t *by_type;
 347   char *type_copy;
 348   int status;
 349
 350   status = c_avl_get (obj->by_type_tree, type, (void *) &by_type);
 351   if (status == 0)
 352     return (by_type);
 353
 354   if (!allocate_if_missing)
 355     return (NULL);
 356
 357   type_copy = strdup (type);
 358   if (type_copy == NULL)
 359   {
 360     ERROR ("utils_vl_lookup: strdup failed.");
 361     return (NULL);
 362   }
 363
 364   by_type = malloc (sizeof (*by_type));
 365   if (by_type == NULL)
 366   {
 367     ERROR ("utils_vl_lookup: malloc failed.");
 368     sfree (type_copy);
 369     return (NULL);
 370   }
 371   memset (by_type, 0, sizeof (*by_type));
 372   by_type->wildcard_plugin_list = NULL;
 373
 374   by_type->by_plugin_tree = c_avl_create ((void *) strcmp);
 375   if (by_type->by_plugin_tree == NULL)
 376   {
 377     ERROR ("utils_vl_lookup: c_avl_create failed.");
 378     sfree (by_type);
 379     sfree (type_copy);
 380     return (NULL);
 381   }
 382
 383   status = c_avl_insert (obj->by_type_tree,
 384       /* key = */ type_copy, /* value = */ by_type);
 385   assert (status <= 0); /* >0 => entry exists => race condition. */
 386   if (status != 0)
 387   {
 388     ERROR ("utils_vl_lookup: c_avl_insert failed.");
 389     c_avl_destroy (by_type->by_plugin_tree);
 390     sfree (by_type);
 391     sfree (type_copy);
 392     return (NULL);
 393   }
 394
 395   return (by_type);
 396 } /* }}} by_type_entry_t *lu_search_by_type */
 397
 398 static int lu_add_by_plugin (by_type_entry_t *by_type, /* {{{ */
 399     user_class_list_t *user_class_list)
 400 {
 401   user_class_list_t *ptr = NULL;
 402   identifier_match_t const *match = &user_class_list->entry.match;
 403
 404   /* Lookup user_class_list from the per-plugin structure. If this is the first
 405    * user_class to be added, the blocks return immediately. Otherwise they will
 406    * set "ptr" to non-NULL. */
 407   if (match->plugin.is_regex)
 408   {
 409     if (by_type->wildcard_plugin_list == NULL)
 410     {
 411       by_type->wildcard_plugin_list = user_class_list;
 412       return (0);
 413     }
 414
 415     ptr = by_type->wildcard_plugin_list;
 416   } /* if (plugin is wildcard) */
 417   else /* (plugin is not wildcard) */
 418   {
 419     int status;
 420
 421     status = c_avl_get (by_type->by_plugin_tree,
 422         match->plugin.str, (void *) &ptr);
 423
 424     if (status != 0) /* plugin not yet in tree */
 425     {
 426       char *plugin_copy = strdup (match->plugin.str);
 427
 428       if (plugin_copy == NULL)
 429       {
 430         ERROR ("utils_vl_lookup: strdup failed.");
 431         sfree (user_class_list);
 432         return (ENOMEM);
 433       }
 434
 435       status = c_avl_insert (by_type->by_plugin_tree,
 436           plugin_copy, user_class_list);
 437       if (status != 0)
 438       {
 439         ERROR ("utils_vl_lookup: c_avl_insert(\"%s\") failed with status %i.",
 440             plugin_copy, status);
 441         sfree (plugin_copy);
 442         sfree (user_class_list);
 443         return (status);
 444       }
 445       else
 446       {
 447         return (0);
 448       }
 449     } /* if (plugin not yet in tree) */
 450   } /* if (plugin is not wildcard) */
 451
 452   assert (ptr != NULL);
 453
 454   while (ptr->next != NULL)
 455     ptr = ptr->next;
 456   ptr->next = user_class_list;
 457
 458   return (0);
 459 } /* }}} int lu_add_by_plugin */
 460
 461 static void lu_destroy_user_obj (lookup_t *obj, /* {{{ */
 462     user_obj_t *user_obj)
 463 {
 464   while (user_obj != NULL)
 465   {
 466     user_obj_t *next = user_obj->next;
 467
 468     if (obj->cb_free_obj != NULL)
 469       obj->cb_free_obj (user_obj->user_obj);
 470     user_obj->user_obj = NULL;
 471
 472     sfree (user_obj);
 473     user_obj = next;
 474   }
 475 } /* }}} void lu_destroy_user_obj */
 476
 477 static void lu_destroy_user_class_list (lookup_t *obj, /* {{{ */
 478     user_class_list_t *user_class_list)
 479 {
 480   while (user_class_list != NULL)
 481   {
 482     user_class_list_t *next = user_class_list->next;
 483
 484     if (obj->cb_free_class != NULL)
 485       obj->cb_free_class (user_class_list->entry.user_class);
 486     user_class_list->entry.user_class = NULL;
 487
 488     lu_destroy_user_obj (obj, user_class_list->entry.user_obj_list);
 489     user_class_list->entry.user_obj_list = NULL;
 490
 491     sfree (user_class_list);
 492     user_class_list = next;
 493   }
 494 } /* }}} void lu_destroy_user_class_list */
 495
 496 static void lu_destroy_by_type (lookup_t *obj, /* {{{ */
 497     by_type_entry_t *by_type)
 498 {
 499
 500   while (42)
 501   {
 502     char *plugin = NULL;
 503     user_class_list_t *user_class_list = NULL;
 504     int status;
 505
 506     status = c_avl_pick (by_type->by_plugin_tree,
 507         (void *) &plugin, (void *) &user_class_list);
 508     if (status != 0)
 509       break;
 510
 511     DEBUG ("utils_vl_lookup: lu_destroy_by_type: Destroying plugin \"%s\".",
 512         plugin);
 513     sfree (plugin);
 514     lu_destroy_user_class_list (obj, user_class_list);
 515   }
 516
 517   c_avl_destroy (by_type->by_plugin_tree);
 518   by_type->by_plugin_tree = NULL;
 519
 520   lu_destroy_user_class_list (obj, by_type->wildcard_plugin_list);
 521   by_type->wildcard_plugin_list = NULL;
 522
 523   sfree (by_type);
 524 } /* }}} int lu_destroy_by_type */
 525
 526 /*
 527  * Public functions
 528  */
 529 lookup_t *lookup_create (lookup_class_callback_t cb_user_class, /* {{{ */
 530     lookup_obj_callback_t cb_user_obj,
 531     lookup_free_class_callback_t cb_free_class,
 532     lookup_free_obj_callback_t cb_free_obj)
 533 {
 534   lookup_t *obj = malloc (sizeof (*obj));
 535   if (obj == NULL)
 536   {
 537     ERROR ("utils_vl_lookup: malloc failed.");
 538     return (NULL);
 539   }
 540   memset (obj, 0, sizeof (*obj));
 541
 542   obj->by_type_tree = c_avl_create ((void *) strcmp);
 543   if (obj->by_type_tree == NULL)
 544   {
 545     ERROR ("utils_vl_lookup: c_avl_create failed.");
 546     sfree (obj);
 547     return (NULL);
 548   }
 549
 550   obj->cb_user_class = cb_user_class;
 551   obj->cb_user_obj = cb_user_obj;
 552   obj->cb_free_class = cb_free_class;
 553   obj->cb_free_obj = cb_free_obj;
 554
 555   return (obj);
 556 } /* }}} lookup_t *lookup_create */
 557
 558 void lookup_destroy (lookup_t *obj) /* {{{ */
 559 {
 560   int status;
 561
 562   if (obj == NULL)
 563     return;
 564
 565   while (42)
 566   {
 567     char *type = NULL;
 568     by_type_entry_t *by_type = NULL;
 569
 570     status = c_avl_pick (obj->by_type_tree, (void *) &type, (void *) &by_type);
 571     if (status != 0)
 572       break;
 573
 574     DEBUG ("utils_vl_lookup: lookup_destroy: Destroying type \"%s\".", type);
 575     sfree (type);
 576     lu_destroy_by_type (obj, by_type);
 577   }
 578
 579   c_avl_destroy (obj->by_type_tree);
 580   obj->by_type_tree = NULL;
 581
 582   sfree (obj);
 583 } /* }}} void lookup_destroy */
 584
 585 int lookup_add (lookup_t *obj, /* {{{ */
 586     identifier_t const *ident, unsigned int group_by, void *user_class)
 587 {
 588   by_type_entry_t *by_type = NULL;
 589   user_class_list_t *user_class_obj;
 590
 591   by_type = lu_search_by_type (obj, ident->type, /* allocate = */ 1);
 592   if (by_type == NULL)
 593     return (-1);
 594
 595   user_class_obj = malloc (sizeof (*user_class_obj));
 596   if (user_class_obj == NULL)
 597   {
 598     ERROR ("utils_vl_lookup: malloc failed.");
 599     return (ENOMEM);
 600   }
 601   memset (user_class_obj, 0, sizeof (*user_class_obj));
 602   user_class_obj->entry.user_class = user_class;
 603   lu_copy_ident_to_match (&user_class_obj->entry.match, ident, group_by);
 604   user_class_obj->entry.user_obj_list = NULL;
 605   user_class_obj->next = NULL;
 606
 607   return (lu_add_by_plugin (by_type, user_class_obj));
 608 } /* }}} int lookup_add */
 609
 610 /* returns the number of successful calls to the callback function */
 611 int lookup_search (lookup_t *obj, /* {{{ */
 612     data_set_t const *ds, value_list_t const *vl)
 613 {
 614   by_type_entry_t *by_type = NULL;
 615   user_class_list_t *user_class_list = NULL;
 616   int retval = 0;
 617   int status;
 618
 619   if ((obj == NULL) || (ds == NULL) || (vl == NULL))
 620     return (-EINVAL);
 621
 622   by_type = lu_search_by_type (obj, vl->type, /* allocate = */ 0);
 623   if (by_type == NULL)
 624     return (0);
 625
 626   status = c_avl_get (by_type->by_plugin_tree,
 627       vl->plugin, (void *) &user_class_list);
 628   if (status == 0)
 629   {
 630     status = lu_handle_user_class_list (obj, ds, vl, user_class_list);
 631     if (status < 0)
 632       return (status);
 633     retval += status;
 634   }
 635
 636   if (by_type->wildcard_plugin_list != NULL)
 637   {
 638     status = lu_handle_user_class_list (obj, ds, vl,
 639         by_type->wildcard_plugin_list);
 640     if (status < 0)
 641       return (status);
 642     retval += status;
 643   }
 644
 645   return (retval);
 646 } /* }}} lookup_search */