sorcery/res_pjsip: Refactor for realtime performance
[asterisk/asterisk.git] / res / res_sorcery_config.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2012 - 2013, Digium, Inc.
5  *
6  * Joshua Colp <jcolp@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*!
20  * \file
21  *
22  * \brief Sorcery Configuration File Object Wizard
23  *
24  * \author Joshua Colp <jcolp@digium.com>
25  */
26
27 /*** MODULEINFO
28         <support_level>core</support_level>
29  ***/
30
31 #include "asterisk.h"
32
33 ASTERISK_REGISTER_FILE()
34
35 #include <regex.h>
36
37 #include "asterisk/module.h"
38 #include "asterisk/sorcery.h"
39 #include "asterisk/astobj2.h"
40 #include "asterisk/config.h"
41 #include "asterisk/uuid.h"
42 #include "asterisk/hashtab.h"
43
44 /*! \brief Structure for storing configuration file sourced objects */
45 struct sorcery_config {
46         /*! \brief UUID for identifying us when opening a configuration file */
47         char uuid[AST_UUID_STR_LEN];
48
49         /*! \brief Objects retrieved from the configuration file */
50         struct ao2_global_obj objects;
51
52         /*! \brief Any specific variable criteria for considering a defined category for this object */
53         struct ast_variable *criteria;
54
55         /*! \brief Number of buckets to use for objects */
56         unsigned int buckets;
57
58         /*! \brief Enable file level integrity instead of object level */
59         unsigned int file_integrity:1;
60
61         /*! \brief Filename of the configuration file */
62         char filename[];
63 };
64
65 /*! \brief Structure used for fields comparison */
66 struct sorcery_config_fields_cmp_params {
67         /*! \brief Pointer to the sorcery structure */
68         const struct ast_sorcery *sorcery;
69
70         /*! \brief Pointer to the fields to check */
71         const struct ast_variable *fields;
72
73         /*! \brief Regular expression for checking object id */
74         regex_t *regex;
75
76         /*! \brief Optional container to put object into */
77         struct ao2_container *container;
78 };
79
80 static void *sorcery_config_open(const char *data);
81 static void sorcery_config_load(void *data, const struct ast_sorcery *sorcery, const char *type);
82 static void sorcery_config_reload(void *data, const struct ast_sorcery *sorcery, const char *type);
83 static void *sorcery_config_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id);
84 static void *sorcery_config_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields);
85 static void sorcery_config_retrieve_multiple(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects,
86                                              const struct ast_variable *fields);
87 static void sorcery_config_retrieve_regex(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex);
88 static void sorcery_config_close(void *data);
89
90 static struct ast_sorcery_wizard config_object_wizard = {
91         .name = "config",
92         .open = sorcery_config_open,
93         .load = sorcery_config_load,
94         .reload = sorcery_config_reload,
95         .retrieve_id = sorcery_config_retrieve_id,
96         .retrieve_fields = sorcery_config_retrieve_fields,
97         .retrieve_multiple = sorcery_config_retrieve_multiple,
98         .retrieve_regex = sorcery_config_retrieve_regex,
99         .close = sorcery_config_close,
100 };
101
102 /*! \brief Destructor function for sorcery config */
103 static void sorcery_config_destructor(void *obj)
104 {
105         struct sorcery_config *config = obj;
106
107         ao2_global_obj_release(config->objects);
108         ast_rwlock_destroy(&config->objects.lock);
109         ast_variables_destroy(config->criteria);
110 }
111
112 /*! \brief Hashing function for sorcery objects */
113 static int sorcery_config_hash(const void *obj, const int flags)
114 {
115         const char *id = obj;
116
117         return ast_str_hash(flags & OBJ_KEY ? id : ast_sorcery_object_get_id(obj));
118 }
119
120 /*! \brief Comparator function for sorcery objects */
121 static int sorcery_config_cmp(void *obj, void *arg, int flags)
122 {
123         const char *id = arg;
124
125         return !strcmp(ast_sorcery_object_get_id(obj), flags & OBJ_KEY ? id : ast_sorcery_object_get_id(arg)) ? CMP_MATCH | CMP_STOP : 0;
126 }
127
128 static int sorcery_config_fields_cmp(void *obj, void *arg, int flags)
129 {
130         const struct sorcery_config_fields_cmp_params *params = arg;
131         RAII_VAR(struct ast_variable *, objset, NULL, ast_variables_destroy);
132
133         if (params->regex) {
134                 /* If a regular expression has been provided see if it matches, otherwise move on */
135                 if (!regexec(params->regex, ast_sorcery_object_get_id(obj), 0, NULL, 0)) {
136                         ao2_link(params->container, obj);
137                 }
138                 return 0;
139         } else if (params->fields &&
140             (!(objset = ast_sorcery_objectset_create(params->sorcery, obj)) ||
141              (!ast_variable_lists_match(objset, params->fields, 0)))) {
142                 /* If we can't turn the object into an object set OR if differences exist between the fields
143                  * passed in and what are present on the object they are not a match.
144                  */
145                 return 0;
146         }
147
148         if (params->container) {
149                 ao2_link(params->container, obj);
150
151                 /* As multiple objects are being returned keep going */
152                 return 0;
153         } else {
154                 /* Immediately stop and return, we only want a single object */
155                 return CMP_MATCH | CMP_STOP;
156         }
157 }
158
159 static void *sorcery_config_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields)
160 {
161         struct sorcery_config *config = data;
162         RAII_VAR(struct ao2_container *, objects, ao2_global_obj_ref(config->objects), ao2_cleanup);
163         struct sorcery_config_fields_cmp_params params = {
164                 .sorcery = sorcery,
165                 .fields = fields,
166                 .container = NULL,
167         };
168
169         /* If no fields are present return nothing, we require *something*, same goes if no objects exist yet */
170         if (!objects || !fields) {
171                 return NULL;
172         }
173
174         return ao2_callback(objects, 0, sorcery_config_fields_cmp, &params);
175 }
176
177 static void *sorcery_config_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id)
178 {
179         struct sorcery_config *config = data;
180         RAII_VAR(struct ao2_container *, objects, ao2_global_obj_ref(config->objects), ao2_cleanup);
181
182         return objects ? ao2_find(objects, id, OBJ_KEY) : NULL;
183 }
184
185 static void sorcery_config_retrieve_multiple(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const struct ast_variable *fields)
186 {
187         struct sorcery_config *config = data;
188         RAII_VAR(struct ao2_container *, config_objects, ao2_global_obj_ref(config->objects), ao2_cleanup);
189         struct sorcery_config_fields_cmp_params params = {
190                 .sorcery = sorcery,
191                 .fields = fields,
192                 .container = objects,
193         };
194
195         if (!config_objects) {
196                 return;
197         }
198
199         ao2_callback(config_objects, 0, sorcery_config_fields_cmp, &params);
200 }
201
202 static void sorcery_config_retrieve_regex(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex)
203 {
204         struct sorcery_config *config = data;
205         RAII_VAR(struct ao2_container *, config_objects, ao2_global_obj_ref(config->objects), ao2_cleanup);
206         regex_t expression;
207         struct sorcery_config_fields_cmp_params params = {
208                 .sorcery = sorcery,
209                 .container = objects,
210                 .regex = &expression,
211         };
212
213         if (!config_objects || regcomp(&expression, regex, REG_EXTENDED | REG_NOSUB)) {
214                 return;
215         }
216
217         ao2_callback(config_objects, 0, sorcery_config_fields_cmp, &params);
218         regfree(&expression);
219 }
220
221 /*! \brief Internal function which determines if criteria has been met for considering an object set applicable */
222 static int sorcery_is_criteria_met(struct ast_variable *objset, struct ast_variable *criteria)
223 {
224         RAII_VAR(struct ast_variable *, diff, NULL, ast_variables_destroy);
225
226         return (!criteria || (!ast_sorcery_changeset_create(objset, criteria, &diff) && !diff)) ? 1 : 0;
227 }
228
229 static void sorcery_config_internal_load(void *data, const struct ast_sorcery *sorcery, const char *type, unsigned int reload)
230 {
231         struct sorcery_config *config = data;
232         struct ast_flags flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
233         struct ast_config *cfg = ast_config_load2(config->filename, config->uuid, flags);
234         struct ast_category *category = NULL;
235         RAII_VAR(struct ao2_container *, objects, NULL, ao2_cleanup);
236         const char *id = NULL;
237         unsigned int buckets = 0;
238
239         if (!cfg) {
240                 ast_log(LOG_ERROR, "Unable to load config file '%s'\n", config->filename);
241                 return;
242         } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
243                 ast_debug(1, "Config file '%s' was unchanged\n", config->filename);
244                 return;
245         } else if (cfg == CONFIG_STATUS_FILEINVALID) {
246                 ast_log(LOG_ERROR, "Contents of config file '%s' are invalid and cannot be parsed\n", config->filename);
247                 return;
248         }
249
250         if (!config->buckets) {
251                 while ((category = ast_category_browse_filtered(cfg, NULL, category, NULL))) {
252
253                         /* If given criteria has not been met skip the category, it is not applicable */
254                         if (!sorcery_is_criteria_met(ast_category_first(category), config->criteria)) {
255                                 continue;
256                         }
257
258                         buckets++;
259                 }
260
261                 /* Determine the optimal number of buckets */
262                 while (buckets && !ast_is_prime(buckets)) {
263                         /* This purposely goes backwards to ensure that the container doesn't have a ton of
264                          * empty buckets for objects that will never get added.
265                          */
266                         buckets--;
267                 }
268
269                 if (!buckets) {
270                         buckets = 1;
271                 }
272         } else {
273                 buckets = config->buckets;
274         }
275
276         ast_debug(2, "Using bucket size of '%d' for objects of type '%s' from '%s'\n",
277                 buckets, type, config->filename);
278
279         if (!(objects = ao2_container_alloc_options(AO2_ALLOC_OPT_LOCK_NOLOCK, buckets,
280                 sorcery_config_hash, sorcery_config_cmp))) {
281                 ast_log(LOG_ERROR, "Could not create bucket for new objects from '%s', keeping existing objects\n",
282                         config->filename);
283                 ast_config_destroy(cfg);
284                 return;
285         }
286
287         while ((category = ast_category_browse_filtered(cfg, NULL, category, NULL))) {
288                 RAII_VAR(void *, obj, NULL, ao2_cleanup);
289                 id = ast_category_get_name(category);
290
291                 /* If given criteria has not been met skip the category, it is not applicable */
292                 if (!sorcery_is_criteria_met(ast_category_first(category), config->criteria)) {
293                         continue;
294                 }
295
296                 /*  Confirm an object with this id does not already exist in the bucket.
297                  *  If it exists, however, the configuration is invalid so stop
298                  *  processing and destroy it. */
299                 obj = ao2_find(objects, id, OBJ_KEY);
300
301                 if (obj) {
302                         ast_log(LOG_ERROR, "Config file '%s' could not be loaded; configuration contains a duplicate object: '%s' of type '%s'\n",
303                                 config->filename, id, type);
304                         ast_config_destroy(cfg);
305                         return;
306                 }
307
308                 if (!(obj = ast_sorcery_alloc(sorcery, type, id)) ||
309                     ast_sorcery_objectset_apply(sorcery, obj, ast_category_first(category))) {
310
311                         if (config->file_integrity) {
312                                 ast_log(LOG_ERROR, "Config file '%s' could not be loaded due to error with object '%s' of type '%s'\n",
313                                         config->filename, id, type);
314                                 ast_config_destroy(cfg);
315                                 return;
316                         } else {
317                                 ast_log(LOG_ERROR, "Could not create an object of type '%s' with id '%s' from configuration file '%s'\n",
318                                         type, id, config->filename);
319                         }
320
321                         ao2_cleanup(obj);
322
323                         /* To ensure we don't lose the object that already exists we retrieve it from the old objects container and add it to the new one */
324                         if (!(obj = sorcery_config_retrieve_id(sorcery, data, type, id))) {
325                                 continue;
326                         }
327
328                         ast_log(LOG_NOTICE, "Retaining existing configuration for object of type '%s' with id '%s'\n", type, id);
329                 }
330
331                 ao2_link(objects, obj);
332         }
333
334         ao2_global_obj_replace_unref(config->objects, objects);
335         ast_config_destroy(cfg);
336 }
337
338 static void sorcery_config_load(void *data, const struct ast_sorcery *sorcery, const char *type)
339 {
340         sorcery_config_internal_load(data, sorcery, type, 0);
341 }
342
343 static void sorcery_config_reload(void *data, const struct ast_sorcery *sorcery, const char *type)
344 {
345         sorcery_config_internal_load(data, sorcery, type, 1);
346 }
347
348 static void *sorcery_config_open(const char *data)
349 {
350         char *tmp;
351         char *filename;
352         char *option;
353         struct sorcery_config *config;
354
355         if (ast_strlen_zero(data)) {
356                 return NULL;
357         }
358
359         tmp = ast_strdupa(data);
360         filename = strsep(&tmp, ",");
361
362         if (ast_strlen_zero(filename) || !(config = ao2_alloc_options(sizeof(*config) + strlen(filename) + 1, sorcery_config_destructor, AO2_ALLOC_OPT_LOCK_NOLOCK))) {
363                 return NULL;
364         }
365
366         ast_uuid_generate_str(config->uuid, sizeof(config->uuid));
367
368         ast_rwlock_init(&config->objects.lock);
369         strcpy(config->filename, filename);
370
371         while ((option = strsep(&tmp, ","))) {
372                 char *name = strsep(&option, "="), *value = option;
373
374                 if (!strcasecmp(name, "buckets")) {
375                         if (sscanf(value, "%30u", &config->buckets) != 1) {
376                                 ast_log(LOG_ERROR, "Unsupported bucket size of '%s' used for configuration file '%s', defaulting to automatic determination\n",
377                                         value, filename);
378                         }
379                 } else if (!strcasecmp(name, "integrity")) {
380                         if (!strcasecmp(value, "file")) {
381                                 config->file_integrity = 1;
382                         } else if (!strcasecmp(value, "object")) {
383                                 config->file_integrity = 0;
384                         } else {
385                                 ast_log(LOG_ERROR, "Unsupported integrity value of '%s' used for configuration file '%s', defaulting to 'object'\n",
386                                         value, filename);
387                         }
388                 } else if (!strcasecmp(name, "criteria")) {
389                         char *field = strsep(&value, "=");
390                         struct ast_variable *criteria = ast_variable_new(field, value, "");
391
392                         if (criteria) {
393                                 criteria->next = config->criteria;
394                                 config->criteria = criteria;
395                         } else {
396                                 /* This is fatal since not following criteria would potentially yield invalid objects */
397                                 ast_log(LOG_ERROR, "Could not create criteria entry of field '%s' with value '%s' for configuration file '%s'\n",
398                                         field, value, filename);
399                                 ao2_ref(config, -1);
400                                 return NULL;
401                         }
402                 } else {
403                         ast_log(LOG_ERROR, "Unsupported option '%s' used for configuration file '%s'\n", name, filename);
404                 }
405         }
406
407         return config;
408 }
409
410 static void sorcery_config_close(void *data)
411 {
412         struct sorcery_config *config = data;
413
414         ao2_ref(config, -1);
415 }
416
417 static int load_module(void)
418 {
419         if (ast_sorcery_wizard_register(&config_object_wizard)) {
420                 return AST_MODULE_LOAD_DECLINE;
421         }
422
423         return AST_MODULE_LOAD_SUCCESS;
424 }
425
426 static int unload_module(void)
427 {
428         ast_sorcery_wizard_unregister(&config_object_wizard);
429         return 0;
430 }
431
432 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER, "Sorcery Configuration File Object Wizard",
433         .support_level = AST_MODULE_SUPPORT_CORE,
434         .load = load_module,
435         .unload = unload_module,
436         .load_pri = AST_MODPRI_REALTIME_DRIVER,
437 );