sorcery/res_pjsip: Refactor for realtime performance
[asterisk/asterisk.git] / res / res_sorcery_astdb.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 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 Astdb 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/astdb.h"
40 #include "asterisk/json.h"
41
42 static void *sorcery_astdb_open(const char *data);
43 static int sorcery_astdb_create(const struct ast_sorcery *sorcery, void *data, void *object);
44 static void *sorcery_astdb_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id);
45 static void *sorcery_astdb_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields);
46 static void sorcery_astdb_retrieve_multiple(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects,
47                                              const struct ast_variable *fields);
48 static void sorcery_astdb_retrieve_regex(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex);
49 static int sorcery_astdb_update(const struct ast_sorcery *sorcery, void *data, void *object);
50 static int sorcery_astdb_delete(const struct ast_sorcery *sorcery, void *data, void *object);
51 static void sorcery_astdb_close(void *data);
52
53 static struct ast_sorcery_wizard astdb_object_wizard = {
54         .name = "astdb",
55         .open = sorcery_astdb_open,
56         .create = sorcery_astdb_create,
57         .retrieve_id = sorcery_astdb_retrieve_id,
58         .retrieve_fields = sorcery_astdb_retrieve_fields,
59         .retrieve_multiple = sorcery_astdb_retrieve_multiple,
60         .retrieve_regex = sorcery_astdb_retrieve_regex,
61         .update = sorcery_astdb_update,
62         .delete = sorcery_astdb_delete,
63         .close = sorcery_astdb_close,
64 };
65
66 static int sorcery_astdb_create(const struct ast_sorcery *sorcery, void *data, void *object)
67 {
68         RAII_VAR(struct ast_json *, objset, ast_sorcery_objectset_json_create(sorcery, object), ast_json_unref);
69         RAII_VAR(char *, value, NULL, ast_json_free);
70         const char *prefix = data;
71         char family[strlen(prefix) + strlen(ast_sorcery_object_get_type(object)) + 2];
72
73         if (!objset || !(value = ast_json_dump_string(objset))) {
74                 return -1;
75         }
76
77         snprintf(family, sizeof(family), "%s/%s", prefix, ast_sorcery_object_get_type(object));
78
79         return ast_db_put(family, ast_sorcery_object_get_id(object), value);
80 }
81
82 /*! \brief Internal helper function which retrieves an object, or multiple objects, using fields for criteria */
83 static void *sorcery_astdb_retrieve_fields_common(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields, struct ao2_container *objects)
84 {
85         const char *prefix = data;
86         char family[strlen(prefix) + strlen(type) + 2];
87         RAII_VAR(struct ast_db_entry *, entries, NULL, ast_db_freetree);
88         struct ast_db_entry *entry;
89
90         snprintf(family, sizeof(family), "%s/%s", prefix, type);
91
92         if (!(entries = ast_db_gettree(family, NULL))) {
93                 return NULL;
94         }
95
96         for (entry = entries; entry; entry = entry->next) {
97                 const char *key = entry->key + strlen(family) + 2;
98                 RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
99                 struct ast_json_error error;
100                 RAII_VAR(struct ast_variable *, objset, NULL, ast_variables_destroy);
101                 RAII_VAR(struct ast_variable *, existing, NULL, ast_variables_destroy);
102                 void *object = NULL;
103
104                 if (!(json = ast_json_load_string(entry->data, &error))) {
105                         return NULL;
106                 }
107                 if (ast_json_to_ast_variables(json, &existing) != AST_JSON_TO_AST_VARS_CODE_SUCCESS) {
108                         return NULL;
109                 }
110
111                 if (fields && !ast_variable_lists_match(existing, fields, 0)) {
112                         continue;
113                 }
114
115                 if (!(object = ast_sorcery_alloc(sorcery, type, key)) ||
116                         ast_sorcery_objectset_apply(sorcery, object, objset)) {
117                         ao2_cleanup(object);
118                         return NULL;
119                 }
120
121                 if (!objects) {
122                         return object;
123                 }
124
125                 ao2_link(objects, object);
126                 ao2_cleanup(object);
127         }
128
129         return NULL;
130 }
131
132 static void *sorcery_astdb_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields)
133 {
134         return sorcery_astdb_retrieve_fields_common(sorcery, data, type, fields, NULL);
135 }
136
137 static void *sorcery_astdb_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id)
138 {
139         const char *prefix = data;
140         char family[strlen(prefix) + strlen(type) + 2];
141         RAII_VAR(char *, value, NULL, ast_free_ptr);
142         RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
143         struct ast_json_error error;
144         RAII_VAR(struct ast_variable *, objset, NULL, ast_variables_destroy);
145         void *object = NULL;
146
147         snprintf(family, sizeof(family), "%s/%s", prefix, type);
148
149         if (ast_db_get_allocated(family, id, &value)
150                 || !(json = ast_json_load_string(value, &error))
151                 || (ast_json_to_ast_variables(json, &objset) != AST_JSON_TO_AST_VARS_CODE_SUCCESS)
152                 || !(object = ast_sorcery_alloc(sorcery, type, id))
153                 || ast_sorcery_objectset_apply(sorcery, object, objset)) {
154                 ast_debug(3, "Failed to retrieve object '%s' from astdb\n", id);
155                 ao2_cleanup(object);
156                 return NULL;
157         }
158
159         return object;
160 }
161
162 static void sorcery_astdb_retrieve_multiple(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const struct ast_variable *fields)
163 {
164         sorcery_astdb_retrieve_fields_common(sorcery, data, type, fields, objects);
165 }
166
167 /*!
168  * \internal
169  * \brief Convert regex prefix pattern to astDB prefix pattern if possible.
170  *
171  * \param tree astDB prefix pattern buffer to fill.
172  * \param regex Extended regular expression with the start anchor character '^'.
173  *
174  * \note Since this is a helper function, the tree buffer is
175  * assumed to always be large enough.
176  *
177  * \retval 0 on success.
178  * \retval -1 on error.  regex is invalid.
179  */
180 static int make_astdb_prefix_pattern(char *tree, const char *regex)
181 {
182         const char *src;
183         char *dst;
184
185         for (dst = tree, src = regex + 1; *src; ++src) {
186                 if (*src == '\\') {
187                         /* Escaped regex char. */
188                         ++src;
189                         if (!*src) {
190                                 /* Invalid regex.  The caller escaped the string terminator. */
191                                 return -1;
192                         }
193                 } else if (*src == '$') {
194                         if (!src[1]) {
195                                 /* Remove the tail anchor character. */
196                                 *dst = '\0';
197                                 return 0;
198                         }
199                 } else if (strchr(".?*+{[(|", *src)) {
200                         /*
201                          * The regex is not a simple prefix pattern.
202                          *
203                          * XXX With more logic, it is possible to simply
204                          * use the current prefix pattern.  The last character
205                          * needs to be removed if possible when the current regex
206                          * token is "?*{".  Also the rest of the regex pattern
207                          * would need to be checked for subgroup/alternation.
208                          * Subgroup/alternation is too complex for a simple prefix
209                          * match.
210                          */
211                         dst = tree;
212                         break;
213                 }
214                 *dst++ = *src;
215         }
216         if (dst != tree) {
217                 *dst++ = '%';
218         }
219         *dst = '\0';
220         return 0;
221 }
222
223 static void sorcery_astdb_retrieve_regex(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex)
224 {
225         const char *prefix = data;
226         char family[strlen(prefix) + strlen(type) + 2];
227         char tree[strlen(regex) + 1];
228         RAII_VAR(struct ast_db_entry *, entries, NULL, ast_db_freetree);
229         regex_t expression;
230         struct ast_db_entry *entry;
231
232         snprintf(family, sizeof(family), "%s/%s", prefix, type);
233
234         if (regex[0] == '^') {
235                 /*
236                  * For performance reasons, try to create an astDB prefix
237                  * pattern from the regex to reduce the number of entries
238                  * retrieved from astDB for regex to then match.
239                  */
240                 if (make_astdb_prefix_pattern(tree, regex)) {
241                         return;
242                 }
243         } else {
244                 tree[0] = '\0';
245         }
246
247         if (!(entries = ast_db_gettree(family, tree))
248                 || regcomp(&expression, regex, REG_EXTENDED | REG_NOSUB)) {
249                 return;
250         }
251
252         for (entry = entries; entry; entry = entry->next) {
253                 /* The key in the entry includes the family, so we need to strip it out for regex purposes */
254                 const char *key = entry->key + strlen(family) + 2;
255                 RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
256                 struct ast_json_error error;
257                 RAII_VAR(void *, object, NULL, ao2_cleanup);
258                 RAII_VAR(struct ast_variable *, objset, NULL, ast_variables_destroy);
259
260                 if (regexec(&expression, key, 0, NULL, 0)) {
261                         continue;
262                 } else if (!(json = ast_json_load_string(entry->data, &error))
263                         || (ast_json_to_ast_variables(json, &objset) != AST_JSON_TO_AST_VARS_CODE_SUCCESS)
264                         || !(object = ast_sorcery_alloc(sorcery, type, key))
265                         || ast_sorcery_objectset_apply(sorcery, object, objset)) {
266                         regfree(&expression);
267                         return;
268                 }
269
270                 ao2_link(objects, object);
271         }
272
273         regfree(&expression);
274 }
275
276 static int sorcery_astdb_update(const struct ast_sorcery *sorcery, void *data, void *object)
277 {
278         const char *prefix = data;
279         char family[strlen(prefix) + strlen(ast_sorcery_object_get_type(object)) + 2], value[2];
280
281         snprintf(family, sizeof(family), "%s/%s", prefix, ast_sorcery_object_get_type(object));
282
283         /* It is okay for the value to be truncated, we are only checking that it exists */
284         if (ast_db_get(family, ast_sorcery_object_get_id(object), value, sizeof(value))) {
285                 return -1;
286         }
287
288         /* The only difference between update and create is that for update the object must already exist */
289         return sorcery_astdb_create(sorcery, data, object);
290 }
291
292 static int sorcery_astdb_delete(const struct ast_sorcery *sorcery, void *data, void *object)
293 {
294         const char *prefix = data;
295         char family[strlen(prefix) + strlen(ast_sorcery_object_get_type(object)) + 2];
296         char value[2];
297
298         snprintf(family, sizeof(family), "%s/%s", prefix, ast_sorcery_object_get_type(object));
299
300         if (ast_db_get(family, ast_sorcery_object_get_id(object), value, sizeof(value))) {
301                 return -1;
302         }
303
304         return ast_db_del(family, ast_sorcery_object_get_id(object));
305 }
306
307 static void *sorcery_astdb_open(const char *data)
308 {
309         /* We require a prefix for family string generation, or else stuff could mix together */
310         if (ast_strlen_zero(data)) {
311                 return NULL;
312         }
313
314         return ast_strdup(data);
315 }
316
317 static void sorcery_astdb_close(void *data)
318 {
319         ast_free(data);
320 }
321
322 static int load_module(void)
323 {
324         if (ast_sorcery_wizard_register(&astdb_object_wizard)) {
325                 return AST_MODULE_LOAD_DECLINE;
326         }
327
328         return AST_MODULE_LOAD_SUCCESS;
329 }
330
331 static int unload_module(void)
332 {
333         ast_sorcery_wizard_unregister(&astdb_object_wizard);
334         return 0;
335 }
336
337 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER, "Sorcery Astdb Object Wizard",
338         .support_level = AST_MODULE_SUPPORT_CORE,
339         .load = load_module,
340         .unload = unload_module,
341         .load_pri = AST_MODPRI_REALTIME_DRIVER,
342 );