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