res/res_sorcery_realtime.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 Realtime 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
  40 /*! \brief They key field used to store the unique identifier for the object */
  41 #define UUID_FIELD "id"
  42
  43 static void *sorcery_realtime_open(const char *data);
  44 static int sorcery_realtime_create(const struct ast_sorcery *sorcery, void *data, void *object);
  45 static void *sorcery_realtime_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id);
  46 static void *sorcery_realtime_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields);
  47 static void sorcery_realtime_retrieve_multiple(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects,
  48                                              const struct ast_variable *fields);
  49 static void sorcery_realtime_retrieve_regex(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex);
  50 static int sorcery_realtime_update(const struct ast_sorcery *sorcery, void *data, void *object);
  51 static int sorcery_realtime_delete(const struct ast_sorcery *sorcery, void *data, void *object);
  52 static void sorcery_realtime_close(void *data);
  53
  54 static struct ast_sorcery_wizard realtime_object_wizard = {
  55         .name = "realtime",
  56         .open = sorcery_realtime_open,
  57         .create = sorcery_realtime_create,
  58         .retrieve_id = sorcery_realtime_retrieve_id,
  59         .retrieve_fields = sorcery_realtime_retrieve_fields,
  60         .retrieve_multiple = sorcery_realtime_retrieve_multiple,
  61         .retrieve_regex = sorcery_realtime_retrieve_regex,
  62         .update = sorcery_realtime_update,
  63         .delete = sorcery_realtime_delete,
  64         .close = sorcery_realtime_close,
  65 };
  66
  67 static int sorcery_realtime_create(const struct ast_sorcery *sorcery, void *data, void *object)
  68 {
  69         const char *family = data;
  70         RAII_VAR(struct ast_variable *, fields, ast_sorcery_objectset_create(sorcery, object), ast_variables_destroy);
  71         struct ast_variable *id = ast_variable_new(UUID_FIELD, ast_sorcery_object_get_id(object), "");
  72
  73         if (!fields || !id) {
  74                 ast_variables_destroy(id);
  75                 return -1;
  76         }
  77
  78         /* Place the identifier at the front for sanity sake */
  79         id->next = fields;
  80         fields = id;
  81
  82         return (ast_store_realtime_fields(family, fields) <= 0) ? -1 : 0;
  83 }
  84
  85 /*! \brief Internal helper function which returns a filtered objectset.
  86  *
  87  * The following are filtered out of the objectset:
  88  * \li The id field. This is returned to the caller in an out parameter.
  89  * \li Fields that are not registered with sorcery.
  90  *
  91  * \param objectset Objectset to filter.
  92  * \param[out] id The ID of the sorcery object, as found in the objectset.
  93  * \param sorcery The sorcery instance that is requesting an objectset.
  94  * \param type The object type
  95  *
  96  * \return The filtered objectset
  97  */
  98 static struct ast_variable *sorcery_realtime_filter_objectset(struct ast_variable *objectset, struct ast_variable **id,
  99                 const struct ast_sorcery *sorcery, const char *type)
 100 {
 101         struct ast_variable *previous = NULL, *field = objectset;
 102         struct ast_sorcery_object_type *object_type;
 103
 104         object_type = ast_sorcery_get_object_type(sorcery, type);
 105         if (!object_type) {
 106                 ast_log(LOG_WARNING, "Unknown sorcery object type %s. Expect errors\n", type);
 107                 /* Continue since we still want to filter out the id */
 108         }
 109
 110         while (field) {
 111                 int remove_field = 0;
 112                 int delete_field = 0;
 113
 114                 if (!strcmp(field->name, UUID_FIELD)) {
 115                         *id = field;
 116                         remove_field = 1;
 117                 } else if (object_type &&
 118                                 !ast_sorcery_is_object_field_registered(object_type, field->name)) {
 119                         ast_debug(1, "Filtering out realtime field '%s' from retrieval\n", field->name);
 120                         remove_field = 1;
 121                         delete_field = 1;
 122                 }
 123
 124                 if (remove_field) {
 125                         struct ast_variable *removed;
 126
 127                         if (previous) {
 128                                 previous->next = field->next;
 129                         } else {
 130                                 objectset = field->next;
 131                         }
 132
 133                         removed = field;
 134                         field = field->next;
 135                         removed->next = NULL;
 136                         if (delete_field) {
 137                                 ast_variables_destroy(removed);
 138                         }
 139                 } else {
 140                         previous = field;
 141                         field = field->next;
 142                 }
 143         }
 144
 145         return objectset;
 146 }
 147
 148 static void *sorcery_realtime_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields)
 149 {
 150         const char *family = data;
 151         RAII_VAR(struct ast_variable *, objectset, NULL, ast_variables_destroy);
 152         RAII_VAR(struct ast_variable *, id, NULL, ast_variables_destroy);
 153         void *object = NULL;
 154
 155         if (!(objectset = ast_load_realtime_fields(family, fields))) {
 156                 return NULL;
 157         }
 158
 159         objectset = sorcery_realtime_filter_objectset(objectset, &id, sorcery, type);
 160
 161         if (!id
 162                 || !(object = ast_sorcery_alloc(sorcery, type, id->value))
 163                 || ast_sorcery_objectset_apply(sorcery, object, objectset)) {
 164                 return NULL;
 165         }
 166
 167         return object;
 168 }
 169
 170 static void *sorcery_realtime_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id)
 171 {
 172         RAII_VAR(struct ast_variable *, fields, ast_variable_new(UUID_FIELD, id, ""), ast_variables_destroy);
 173
 174         return sorcery_realtime_retrieve_fields(sorcery, data, type, fields);
 175 }
 176
 177 static void sorcery_realtime_retrieve_multiple(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const struct ast_variable *fields)
 178 {
 179         const char *family = data;
 180         RAII_VAR(struct ast_config *, rows, NULL, ast_config_destroy);
 181         RAII_VAR(struct ast_variable *, all, NULL, ast_variables_destroy);
 182         struct ast_category *row = NULL;
 183
 184         if (!fields) {
 185                 char field[strlen(UUID_FIELD) + 6], value[2];
 186
 187                 /* If no fields have been specified we want all rows, so trick realtime into doing it */
 188                 snprintf(field, sizeof(field), "%s LIKE", UUID_FIELD);
 189                 snprintf(value, sizeof(value), "%%");
 190
 191                 if (!(all = ast_variable_new(field, value, ""))) {
 192                         return;
 193                 }
 194
 195                 fields = all;
 196         }
 197
 198         if (!(rows = ast_load_realtime_multientry_fields(family, fields))) {
 199                 return;
 200         }
 201
 202         while ((row = ast_category_browse_filtered(rows, NULL, row, NULL))) {
 203                 struct ast_variable *objectset = ast_category_detach_variables(row);
 204                 RAII_VAR(struct ast_variable *, id, NULL, ast_variables_destroy);
 205                 RAII_VAR(void *, object, NULL, ao2_cleanup);
 206
 207                 objectset = sorcery_realtime_filter_objectset(objectset, &id, sorcery, type);
 208
 209                 if (id && (object = ast_sorcery_alloc(sorcery, type, id->value)) && !ast_sorcery_objectset_apply(sorcery, object, objectset)) {
 210                         ao2_link(objects, object);
 211                 }
 212
 213                 ast_variables_destroy(objectset);
 214         }
 215 }
 216
 217 static void sorcery_realtime_retrieve_regex(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex)
 218 {
 219         char field[strlen(UUID_FIELD) + 6], value[strlen(regex) + 2];
 220         RAII_VAR(struct ast_variable *, fields, NULL, ast_variables_destroy);
 221
 222         /* The realtime API provides no direct ability to do regex so for now we support a limited subset using pattern matching */
 223         if (regex[0] != '^') {
 224                 return;
 225         }
 226
 227         snprintf(field, sizeof(field), "%s LIKE", UUID_FIELD);
 228         snprintf(value, sizeof(value), "%s%%", regex + 1);
 229
 230         if (!(fields = ast_variable_new(field, value, ""))) {
 231                 return;
 232         }
 233
 234         sorcery_realtime_retrieve_multiple(sorcery, data, type, objects, fields);
 235 }
 236
 237 static int sorcery_realtime_update(const struct ast_sorcery *sorcery, void *data, void *object)
 238 {
 239         const char *family = data;
 240         RAII_VAR(struct ast_variable *, fields, ast_sorcery_objectset_create(sorcery, object), ast_variables_destroy);
 241
 242         if (!fields) {
 243                 return -1;
 244         }
 245
 246         return (ast_update_realtime_fields(family, UUID_FIELD, ast_sorcery_object_get_id(object), fields) <= 0) ? -1 : 0;
 247 }
 248
 249 static int sorcery_realtime_delete(const struct ast_sorcery *sorcery, void *data, void *object)
 250 {
 251         const char *family = data;
 252
 253         return (ast_destroy_realtime_fields(family, UUID_FIELD, ast_sorcery_object_get_id(object), NULL) <= 0) ? -1 : 0;
 254 }
 255
 256 static void *sorcery_realtime_open(const char *data)
 257 {
 258         /* We require a prefix for family string generation, or else stuff could mix together */
 259         if (ast_strlen_zero(data) || !ast_realtime_is_mapping_defined(data)) {
 260                 return NULL;
 261         }
 262
 263         return ast_strdup(data);
 264 }
 265
 266 static void sorcery_realtime_close(void *data)
 267 {
 268         ast_free(data);
 269 }
 270
 271 static int load_module(void)
 272 {
 273         if (ast_sorcery_wizard_register(&realtime_object_wizard)) {
 274                 return AST_MODULE_LOAD_DECLINE;
 275         }
 276
 277         return AST_MODULE_LOAD_SUCCESS;
 278 }
 279
 280 static int unload_module(void)
 281 {
 282         ast_sorcery_wizard_unregister(&realtime_object_wizard);
 283         return 0;
 284 }
 285
 286 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER, "Sorcery Realtime Object Wizard",
 287         .support_level = AST_MODULE_SUPPORT_CORE,
 288         .load = load_module,
 289         .unload = unload_module,
 290         .load_pri = AST_MODPRI_REALTIME_DRIVER,
 291 );