Merge the sorcery data access layer API.
authorJoshua Colp <jcolp@digium.com>
Fri, 25 Jan 2013 14:01:04 +0000 (14:01 +0000)
committerJoshua Colp <jcolp@digium.com>
Fri, 25 Jan 2013 14:01:04 +0000 (14:01 +0000)
Sorcery is a unifying data access layer which provides a pluggable mechanism to allow
object creation, retrieval, updating, and deletion using different backends (or wizards).

This is a fancy way of saying "one interface to rule them all" where them is configuration,
realtime, and anything else that comes along.

Review: https://reviewboard.asterisk.org/r/2259/

git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@380069 65c4cc65-6c06-0410-ace0-fbb531ad65f3

configs/sorcery.conf.sample [new file with mode: 0644]
configs/test_sorcery.conf.sample [new file with mode: 0644]
include/asterisk/sorcery.h [new file with mode: 0644]
main/asterisk.c
main/sorcery.c [new file with mode: 0644]
res/res_sorcery_config.c [new file with mode: 0644]
res/res_sorcery_memory.c [new file with mode: 0644]
tests/test_sorcery.c [new file with mode: 0644]

diff --git a/configs/sorcery.conf.sample b/configs/sorcery.conf.sample
new file mode 100644 (file)
index 0000000..899467a
--- /dev/null
@@ -0,0 +1,50 @@
+; Sample configuration file for Sorcery Data Access Layer
+
+;
+; Wizards
+;
+; Wizards are the persistence mechanism for objects. They are loaded as Asterisk modules and register
+; themselves with the sorcery core. All implementation specific details of how objects are persisted is isolated
+; within wizards.
+;
+
+;
+; Caching
+;
+; A wizard can optionally be marked as an object cache by adding "/cache" to the object type within the mapping.
+; If an object is returned from a non-object cache it is immediately given to the cache to be created. Multiple
+; object caches can be configured for a single object type.
+;
+
+;
+; Object Type Mappings
+;
+; To allow configuration of where and how an object is persisted object mappings can be defined within this file
+; on a per-module basis. The mapping consists of the object type, options, wizard name, and wizard configuration
+; data. This has the following format:
+;
+; object type [/options] = wizard name, wizard configuration data
+;
+; For example to configure an in-memory wizard for the 'bob' object type:
+;
+; bob = memory
+;
+; Or to configure the object type 'joe' from a configuration file:
+;
+; joe = config,joe.conf
+;
+; Note that an object type can have multiple mappings defined. Each mapping will be consulted in the order in which
+; it appears within the configuration file. This means that if you are configuring a wizard as a cache it should
+; appear as the first mapping so the cache is consulted before all other mappings.
+;
+
+;
+; The following object mappings are used by the unit test to test certain functionality of sorcery.
+;
+[test_sorcery]
+test=memory
+
+[test_sorcery_cache]
+test/cache=test
+test=memory
+
diff --git a/configs/test_sorcery.conf.sample b/configs/test_sorcery.conf.sample
new file mode 100644 (file)
index 0000000..c465dbf
--- /dev/null
@@ -0,0 +1,14 @@
+; This is a res_sorcery_config compatible file for the sorcery unit tests
+
+[hey]
+bob=98
+joe=41
+
+[hey2]
+type=zombies
+bob=97
+joe=40
+
+[hey3]
+bob=96
+joe=39
diff --git a/include/asterisk/sorcery.h b/include/asterisk/sorcery.h
new file mode 100644 (file)
index 0000000..1a1042f
--- /dev/null
@@ -0,0 +1,537 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2012 - 2013, Digium, Inc.
+ *
+ * Joshua Colp <jcolp@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*! \file
+ * \brief Sorcery Data Access Layer API
+ * \author Joshua Colp <jcolp@digium.com>
+ * \ref AstSorcery
+ */
+
+/*!
+ * \page AstSorcery Data Access Layer API
+ *
+ * Sorcery is a unifying data access layer which utilizes the configuration framework,
+ * realtime, and astdb to allow object creation, retrieval, updating, and deletion.
+ *
+ * \par Initialization
+ *
+ * Usage of sorcery is accomplished by first opening a sorcery structure. This structure holds
+ * all information about the object types, object fields, and object mappings. All API functions
+ * require the sorcery structure to operate. When sorcery is no longer needed the structure can
+ * be unreferenced using \ref ast_sorcery_unref
+ *
+ * Once opened the sorcery structure must have object mappings applied to it. This maps the
+ * object types to their respective wizards (object storage modules). If the developer would like
+ * to allow the user to configure this using the sorcery.conf configuration file the
+ * \ref ast_sorcery_apply_config API call can be used to read in the configuration file and apply the
+ * mappings. If the storage of the object types are such that a default wizard can be used this can
+ * be applied using the \ref ast_sorcery_apply_default API call. Note that the default mappings will not
+ * override configured mappings. They are only used in the case where no configured mapping exists.
+ *
+ * Configuring object mappings implicitly creates a basic version of an object type. The object type
+ * must be fully registered, however, using the \ref ast_sorcery_object_type_register API call before any
+ * objects of the type can be allocated, created, or retrieved.
+ *
+ * Once the object type itself has been fully registered the individual fields within the object must
+ * be registered using the \ref ast_sorcery_object_field_register API call. Note that not all fields *need*
+ * be registered. Only fields that should be accessible using the sorcery API have to be registered.
+ *
+ * \par Creating Objects
+ *
+ * Before an object can be created within the sorcery API it must first be allocated using the
+ * \ref ast_sorcery_alloc API call. This allocates a new instance of the object, sets sorcery specific
+ * details, and applies default values to the object. A unique identifier can optionally be specified
+ * when allocating an object. If it is not provided one will be automatically generated. Allocating
+ * an object does not create it within any object storage mechanisms that are configured for the
+ * object type. Creation must explicitly be done using the \ref ast_sorcery_create API call. This API call
+ * passes the object to each configured object storage mechanism for the object type until one
+ * successfully persists the object.
+ *
+ * \par Retrieving Objects
+ *
+ * To retrieve a single object using its unique identifier the \ref ast_sorcery_retrieve_by_id API call
+ * can be used.
+ *
+ * To retrieve potentially multiple objects using specific fields the \ref ast_sorcery_retrieve_by_fields
+ * API call can be used. The behavior of this API call is controlled using different flags. If the
+ * AST_RETRIEVE_FLAG_MULTIPLE flag is used a container will be returned which contains all matching objects.
+ * To retrieve all objects the AST_RETRIEVE_FLAG_ALL flag can be specified. Note that when specifying this flag
+ * you do not need to pass any fields.
+ *
+ * Both API calls return shared objects. Modification of the object can not occur until it has been copied.
+ *
+ * \par Updating Objects
+ *
+ * As retrieved objects may be shared the first step to updating the object with new details is creating a
+ * copy using the \ref ast_sorcery_copy API call. This will return a new object which is specific to the caller.
+ * Any field within the object may be modified as needed. Once changes are done the changes can be committed
+ * using the \ref ast_sorcery_update API call. Note that as the copied object is specific to the caller it must
+ * be unreferenced after use.
+ *
+ * \par Deleting Objects
+ *
+ * To delete an object simply call the \ref ast_sorcery_delete API call with an object retrieved using the
+ * ast_sorcery_retrieve_by_* API calls or a copy returned from \ref ast_sorcery_copy.
+ */
+
+#ifndef _ASTERISK_SORCERY_H
+#define _ASTERISK_SORCERY_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#include "asterisk/config_options.h"
+#include "asterisk/uuid.h"
+
+/*! \brief Maximum size of an object type */
+#define MAX_OBJECT_TYPE 64
+
+/*!
+ * \brief Retrieval flags
+ */
+enum ast_sorcery_retrieve_flags {
+       /*! \brief Default retrieval flags */
+       AST_RETRIEVE_FLAG_DEFAULT = 0,
+
+       /*! \brief Return all matching objects */
+       AST_RETRIEVE_FLAG_MULTIPLE = (1 << 0),
+
+        /*! \brief Perform no matching, return all objects */
+        AST_RETRIEVE_FLAG_ALL = (1 << 1),
+};
+
+/*! \brief Forward declaration for the sorcery main structure */
+struct ast_sorcery;
+
+/*!
+ * \brief A callback function for translating a value into a string
+ *
+ * \param obj Object to get value from
+ * \param args Where the field is
+ * \param buf Pointer to the buffer that the handler has created which contains the field value
+ *
+ * \retval 0 success
+ * \retval -1 failure
+ */
+typedef int (*sorcery_field_handler)(const void *obj, const intptr_t *args, char **buf);
+
+/*!
+ * \brief A callback function for performing a transformation on an object set
+ *
+ * \param set The existing object set
+ *
+ * \retval non-NULL new object set if changed
+ * \retval NULL if no changes present
+ *
+ * \note The returned ast_variable list must be *new*. You can not return the input set.
+ */
+typedef struct ast_variable *(*sorcery_transform_handler)(struct ast_variable *set);
+
+/*!
+ * \brief A callback function for when an object set is successfully applied to an object
+ *
+ * \param sorcery Sorcery structure in use
+ * \param obj The object itself
+ */
+typedef void (*sorcery_apply_handler)(const struct ast_sorcery *sorcery, void *obj);
+
+/*! \brief Interface for a sorcery wizard */
+struct ast_sorcery_wizard {
+       /*! \brief Name of the wizard */
+       const char *name;
+
+       /*! \brief Pointer to the Asterisk module this wizard is implemented by */
+       struct ast_module *module;
+
+       /*! \brief Callback for opening a wizard */
+       void *(*open)(const char *data);
+
+       /*! \brief Optional callback for loading persistent objects */
+       void (*load)(void *data, const struct ast_sorcery *sorcery, const char *type);
+
+       /*! \brief Optional callback for reloading persistent objects */
+       void (*reload)(void *data, const struct ast_sorcery *sorcery, const char *type);
+
+       /*! \brief Callback for creating an object */
+       int (*create)(void *data, void *object);
+
+       /*! \brief Callback for retrieving an object using an id */
+       void *(*retrieve_id)(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id);
+
+       /*! \brief Optional callback for retrieving an object using fields */
+       void *(*retrieve_fields)(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields);
+
+       /*! \brief Optional callback for retrieving multiple objects using some optional field criteria */
+       void (*retrieve_multiple)(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const struct ast_variable *fields);
+
+       /*! \brief Callback for updating an object */
+       int (*update)(void *data, void *object);
+
+       /*! \brief Callback for deleting an object */
+       int (*delete)(void *data, void *object);
+
+       /*! \brief Callback for closing a wizard */
+       void (*close)(void *data);
+};
+
+/*! \brief Structure which contains details about a sorcery object */
+struct ast_sorcery_object_details {
+       /*! \brief Unique identifier of this object */
+       char id[AST_UUID_STR_LEN];
+
+       /*! \brief Type of object */
+       char type[MAX_OBJECT_TYPE];
+};
+
+/*! \brief Macro which must be used at the beginning of each sorcery capable object */
+#define SORCERY_OBJECT(details)                    \
+struct {                                           \
+       struct ast_sorcery_object_details details; \
+}                                                  \
+
+/*!
+ * \brief Initialize the sorcery API
+ *
+ * \retval 0 success
+ * \retval -1 failure
+ */
+int ast_sorcery_init(void);
+
+/*!
+ * \brief Register a sorcery wizard
+ *
+ * \param interface Pointer to a wizard interface
+ * \param module Pointer to the module implementing the interface
+ *
+ * \retval 0 success
+ * \retval -1 failure
+ */
+int __ast_sorcery_wizard_register(const struct ast_sorcery_wizard *interface, struct ast_module *module);
+
+/*!
+ * \brief See \ref __ast_sorcery_wizard_register()
+ */
+#define ast_sorcery_wizard_register(interface) __ast_sorcery_wizard_register(interface, ast_module_info ? ast_module_info->self : NULL)
+
+/*!
+ * \brief Unregister a sorcery wizard
+ *
+ * \param interface Pointer to the wizard interface
+ *
+ * \retval 0 success
+ * \retval -1 failure
+ */
+int ast_sorcery_wizard_unregister(const struct ast_sorcery_wizard *interface);
+
+/*!
+ * \brief Open a new sorcery structure
+ *
+ * \retval non-NULL success
+ * \retval NULL if allocation failed
+ */
+struct ast_sorcery *ast_sorcery_open(void);
+
+/*!
+ * \brief Apply configured wizard mappings
+ *
+ * \param sorcery Pointer to a sorcery structure
+ * \param name Name of the category to use within the configuration file, normally the module name
+ *
+ * \retval 0 success
+ * \retval -1 failure
+ */
+int ast_sorcery_apply_config(struct ast_sorcery *sorcery, const char *name);
+
+/*!
+ * \brief Apply default object wizard mappings
+ *
+ * \param sorcery Pointer to a sorcery structure
+ * \param type Type of object to apply to
+ * \param name Name of the wizard to use
+ * \param data Data to be passed to wizard
+ *
+ * \retval 0 success
+ * \retval -1 failure
+ *
+ * \note This should be called *after* applying configuration sourced mappings
+ *
+ * \note Only a single default can exist per object type
+ */
+int ast_sorcery_apply_default(struct ast_sorcery *sorcery, const char *type, const char *name, const char *data);
+
+/*!
+ * \brief Register an object type
+ *
+ * \param sorcery Pointer to a sorcery structure
+ * \param type Type of object
+ * \param alloc Required object allocation callback
+ * \param transform Optional transformation callback
+ * \param apply Optional object set apply callback
+ *
+ * \retval 0 success
+ * \retval -1 failure
+ */
+int ast_sorcery_object_register(struct ast_sorcery *sorcery, const char *type, aco_type_item_alloc alloc, sorcery_transform_handler transform, sorcery_apply_handler apply);
+
+/*!
+ * \brief Register a field within an object
+ *
+ * \param sorcery Pointer to a sorcery structure
+ * \param type Type of object
+ * \param name Name of the field
+ * \param default_val Default value of the field
+ * \param opt_type Option type
+ * \param flags Option type specific flags
+ *
+ * \retval 0 success
+ * \retval -1 failure
+ */
+int __ast_sorcery_object_field_register(struct ast_sorcery *sorcery, const char *type, const char *name, const char *default_val, enum aco_option_type opt_type,
+                                        aco_option_handler config_handler, sorcery_field_handler sorcery_handler, unsigned int flags, size_t argc, ...);
+
+/*!
+ * \brief Register a field within an object
+ *
+ * \param sorcery Pointer to a sorcery structure
+ * \param type Type of object
+ * \param name Name of the field
+ * \param default_val Default value of the field
+ * \param opt_type Option type
+ * \param flags Option type specific flags
+ *
+ * \retval 0 success
+ * \retval -1 failure
+ */
+#define ast_sorcery_object_field_register(sorcery, type, name, default_val, opt_type, flags, ...) \
+    __ast_sorcery_object_field_register(sorcery, type, name, default_val, opt_type, NULL, NULL, flags, VA_NARGS(__VA_ARGS__), __VA_ARGS__)
+
+/*!
+ * \brief Register a field within an object with custom handlers
+ *
+ * \param sorcery Pointer to a sorcery structure
+ * \param type Type of object
+ * \param name Name of the field
+ * \param default_val Default value of the field
+ * \param config_handler Custom configuration handler
+ * \param sorcery_handler Custom sorcery handler
+ * \param flags Option type specific flags
+ *
+ * \retval 0 success
+ * \retval -1 failure
+ */
+#define ast_sorcery_object_field_register_custom(sorcery, type, name, default_val, config_handler, sorcery_handler, flags, ...) \
+    __ast_sorcery_object_field_register(sorcery, type, name, default_val, OPT_CUSTOM_T, config_handler, sorcery_handler, flags, VA_NARGS(__VA_ARGS__), __VA_ARGS__);
+
+/*!
+ * \brief Inform any wizards to load persistent objects
+ *
+ * \param sorcery Pointer to a sorcery structure
+ */
+void ast_sorcery_load(const struct ast_sorcery *sorcery);
+
+/*!
+ * \brief Inform any wizards to reload persistent objects
+ *
+ * \param sorcery Pointer to a sorcery structure
+ */
+void ast_sorcery_reload(const struct ast_sorcery *sorcery);
+
+/*!
+ * \brief Increase the reference count of a sorcery structure
+ *
+ * \param sorcery Pointer to a sorcery structure
+ */
+void ast_sorcery_ref(struct ast_sorcery *sorcery);
+
+/*!
+ * \brief Create an object set (KVP list) for an object
+ *
+ * \param sorcery Pointer to a sorcery structure
+ * \param object Pointer to a sorcery object
+ *
+ * \retval non-NULL success
+ * \retval NULL if error occurred
+ *
+ * \note The returned ast_variable list must be destroyed using ast_variables_destroy
+ */
+struct ast_variable *ast_sorcery_objectset_create(const struct ast_sorcery *sorcery, const void *object);
+
+/*!
+ * \brief Apply an object set (KVP list) to an object
+ *
+ * \param sorcery Pointer to a sorcery structure
+ * \param object Pointer to a sorcery object
+ * \param objectset Object set itself
+ *
+ * \retval 0 success
+ * \retval -1 failure
+ *
+ * \note This operation is *not* atomic. If this fails it is possible for the object to be left with a partially
+ *       applied object set.
+ */
+int ast_sorcery_objectset_apply(const struct ast_sorcery *sorcery, void *object, struct ast_variable *objectset);
+
+/*!
+ * \brief Create a changeset given two object sets
+ *
+ * \param original Original object set
+ * \param modified Modified object set
+ * \param changes Pointer to hold any changes between the object sets
+ *
+ * \retval 0 success
+ * \retval -1 failure
+ *
+ * \note The returned ast_variable list must be destroyed using ast_variables_destroy
+ */
+int ast_sorcery_changeset_create(const struct ast_variable *original, const struct ast_variable *modified, struct ast_variable **changes);
+
+/*!
+ * \brief Allocate an object
+ *
+ * \param sorcery Pointer to a sorcery structure
+ * \param type Type of object to allocate
+ * \param id Optional unique identifier, if none is provided one will be generated
+ *
+ * \retval non-NULL success
+ * \retval NULL failure
+ */
+void *ast_sorcery_alloc(const struct ast_sorcery *sorcery, const char *type, const char *id);
+
+/*!
+ * \brief Create a copy of an object
+ *
+ * \param sorcery Pointer to a sorcery structure
+ * \param object Existing object
+ *
+ * \retval non-NULL success
+ * \retval NULL failure
+ */
+void *ast_sorcery_copy(const struct ast_sorcery *sorcery, const void *object);
+
+/*!
+ * \brief Create a changeset of two objects
+ *
+ * \param sorcery Pointer to a sorcery structure
+ * \param original Original object
+ * \param modified Modified object
+ * \param changes Pointer which will be populated with changes if any exist
+ *
+ * \retval 0 success
+ * \retval -1 failure
+ *
+ * \note The returned ast_variable list must be destroyed using ast_variables_destroy
+ *
+ * \note While the objects must be of the same type they do not have to be the same object
+ */
+int ast_sorcery_diff(const struct ast_sorcery *sorcery, const void *original, const void *modified, struct ast_variable **changes);
+
+/*!
+ * \brief Create and potentially persist an object using an available wizard
+ *
+ * \param sorcery Pointer to a sorcery structure
+ * \param object Pointer to a sorcery object
+ *
+ * \retval 0 success
+ * \retval -1 failure
+ */
+int ast_sorcery_create(const struct ast_sorcery *sorcery, void *object);
+
+/*!
+ * \brief Retrieve an object using its unique identifier
+ *
+ * \param sorcery Pointer to a sorcery structure
+ * \param type Type of object to retrieve
+ * \param id Unique object identifier
+ *
+ * \retval non-NULL if found
+ * \retval NULL if not found
+ */
+void *ast_sorcery_retrieve_by_id(const struct ast_sorcery *sorcery, const char *type, const char *id);
+
+/*!
+ * \brief Retrieve an object or multiple objects using specific fields
+ *
+ * \param sorcery Pointer to a sorcery structure
+ * \param type Type of object to retrieve
+ * \param flags Flags to control behavior
+ * \param fields Optional jbject fields and values to match against
+ *
+ * \retval non-NULL if found
+ * \retval NULL if not found
+ *
+ * \note If the AST_RETRIEVE_FLAG_MULTIPLE flag is specified the returned value will be an
+ *       ao2_container that must be unreferenced after use.
+ *
+ * \note If the AST_RETRIEVE_FLAG_ALL flag is used you may omit fields to retrieve all objects
+ *       of the given type.
+ */
+void *ast_sorcery_retrieve_by_fields(const struct ast_sorcery *sorcery, const char *type, unsigned int flags, struct ast_variable *fields);
+
+/*!
+ * \brief Update an object
+ *
+ * \param sorcery Pointer to a sorcery structure
+ * \param object Pointer to a sorcery object
+ *
+ * \retval 0 success
+ * \retval -1 failure
+ */
+int ast_sorcery_update(const struct ast_sorcery *sorcery, void *object);
+
+/*!
+ * \brief Delete an object
+ *
+ * \param sorcery Pointer to a sorcery structure
+ * \param object Pointer to a sorcery object
+ *
+ * \retval 0 success
+ * \retval -1 failure
+ */
+int ast_sorcery_delete(const struct ast_sorcery *sorcery, void *object);
+
+/*!
+ * \brief Decrease the reference count of a sorcery structure
+ *
+ * \param sorcery Pointer to a sorcery structure
+ */
+void ast_sorcery_unref(struct ast_sorcery *sorcery);
+
+/*!
+ * \brief Get the unique identifier of a sorcery object
+ *
+ * \param object Pointer to a sorcery object
+ *
+ * \retval unique identifier
+ */
+const char *ast_sorcery_object_get_id(const void *object);
+
+/*!
+ * \brief Get the type of a sorcery object
+ *
+ * \param object Pointer to a sorcery object
+ *
+ * \retval type of object
+ */
+const char *ast_sorcery_object_get_type(const void *object);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif /* _ASTERISK_SORCERY_H */
index 67d09ff..f7b6261 100644 (file)
@@ -239,6 +239,7 @@ int daemon(int, int);  /* defined in libresolv of all places */
 #include "asterisk/format.h"
 #include "asterisk/aoc.h"
 #include "asterisk/uuid.h"
+#include "asterisk/sorcery.h"
 
 #include "../defaults.h"
 
@@ -4116,6 +4117,11 @@ int main(int argc, char *argv[])
        ast_aoc_cli_init();
        ast_uuid_init();
 
+       if (ast_sorcery_init()) {
+               printf("%s", term_quit());
+               exit(1);
+       }
+
        ast_makesocket();
        sigemptyset(&sigs);
        sigaddset(&sigs, SIGHUP);
diff --git a/main/sorcery.c b/main/sorcery.c
new file mode 100644 (file)
index 0000000..a347094
--- /dev/null
@@ -0,0 +1,965 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2012 - 2013, Digium, Inc.
+ *
+ * Joshua Colp <jcolp@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*! \file
+ *
+ * \brief Sorcery Data Access Layer API
+ *
+ * \author Joshua Colp <jcolp@digium.com>
+ */
+
+/*** MODULEINFO
+       <support_level>core</support_level>
+ ***/
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include "asterisk/logger.h"
+#include "asterisk/sorcery.h"
+#include "asterisk/astobj2.h"
+#include "asterisk/strings.h"
+#include "asterisk/config_options.h"
+#include "asterisk/netsock2.h"
+#include "asterisk/module.h"
+
+/*! \brief Number of buckets for wizards (should be prime for performance reasons) */
+#define WIZARD_BUCKETS 7
+
+/*! \brief Number of buckets for types (should be prime for performance reasons) */
+#define TYPE_BUCKETS 53
+
+/*! \brief Maximum length of an object field name */
+#define MAX_OBJECT_FIELD 128
+
+/*! \brief Structure for registered object type */
+struct ast_sorcery_object_type {
+       /*! \brief Unique name of the object type */
+       char name[MAX_OBJECT_TYPE];
+
+       /*! \brief Optional transformation callback */
+       sorcery_transform_handler transform;
+
+       /*! \brief Optional object set apply callback */
+       sorcery_apply_handler apply;
+
+       /*! \brief Wizard instances */
+       struct ao2_container *wizards;
+
+       /*! \brief Object fields */
+       struct ao2_container *fields;
+
+       /*! \brief Configuration framework general information */
+       struct aco_info *info;
+
+       /*! \brief Configuration framework file information */
+       struct aco_file *file;
+
+       /*! \brief Type details */
+       struct aco_type type;
+};
+
+/*! \brief Structure for registered object field */
+struct ast_sorcery_object_field {
+       /*! \brief Name of the field */
+       char name[MAX_OBJECT_FIELD];
+
+       /*! \brief Callback function for translation */
+       sorcery_field_handler handler;
+
+       /*! \brief Position of the field */
+       intptr_t args[];
+};
+
+/*! \brief Structure for a wizard instance which operates on objects */
+struct ast_sorcery_object_wizard {
+       /*! \brief Wizard interface itself */
+       struct ast_sorcery_wizard *wizard;
+
+       /*! \brief Unique data for the wizard */
+       void *data;
+
+       /*! \brief Wizard is acting as an object cache */
+       unsigned int caching:1;
+};
+
+/*! \brief Full structure for sorcery */
+struct ast_sorcery {
+       /*! \brief Container for known object types */
+       struct ao2_container *types;
+};
+
+/*! \brief Structure for passing load/reload details */
+struct sorcery_load_details {
+       /*! \brief Sorcery structure in use */
+       const struct ast_sorcery *sorcery;
+
+       /*! \brief Type of object being loaded */
+       const char *type;
+
+       /*! \brief Whether this is a reload or not */
+       unsigned int reload:1;
+};
+
+/*! \brief Registered sorcery wizards */
+struct ao2_container *wizards;
+
+static int int_handler_fn(const void *obj, const intptr_t *args, char **buf)
+{
+       int *field = (int *)(obj + args[0]);
+       return (ast_asprintf(buf, "%d", *field) < 0) ? -1 : 0;
+}
+
+static int uint_handler_fn(const void *obj, const intptr_t *args, char **buf)
+{
+       unsigned int *field = (unsigned int *)(obj + args[0]);
+       return (ast_asprintf(buf, "%u", *field) < 0) ? -1 : 0;
+}
+
+static int double_handler_fn(const void *obj, const intptr_t *args, char **buf)
+{
+       double *field = (double *)(obj + args[0]);
+       return (ast_asprintf(buf, "%f", *field) < 0) ? -1 : 0;
+}
+
+static int stringfield_handler_fn(const void *obj, const intptr_t *args, char **buf)
+{
+       ast_string_field *field = (const char **)(obj + args[0]);
+       return !(*buf = ast_strdup(*field)) ? -1 : 0;
+}
+
+static int bool_handler_fn(const void *obj, const intptr_t *args, char **buf)
+{
+       unsigned int *field = (unsigned int *)(obj + args[0]);
+       return !(*buf = ast_strdup(*field ? "true" : "false")) ? -1 : 0;
+}
+
+static int sockaddr_handler_fn(const void *obj, const intptr_t *args, char **buf)
+{
+       struct ast_sockaddr *field = (struct ast_sockaddr *)(obj + args[0]);
+       return !(*buf = ast_strdup(ast_sockaddr_stringify(field))) ? -1 : 0;
+}
+
+static int noop_handler_fn(const void *obj, const intptr_t *args, char **buf)
+{
+       return 0;
+}
+
+static int chararray_handler_fn(const void *obj, const intptr_t *args, char **buf)
+{
+       char *field = (char *)(obj + args[0]);
+       return !(*buf = ast_strdup(field)) ? -1 : 0;
+}
+
+static sorcery_field_handler sorcery_field_default_handler(enum aco_option_type type)
+{
+       switch(type) {
+       case OPT_BOOL_T: return bool_handler_fn;
+       case OPT_CHAR_ARRAY_T: return chararray_handler_fn;
+       case OPT_DOUBLE_T: return double_handler_fn;
+       case OPT_INT_T: return int_handler_fn;
+       case OPT_NOOP_T: return noop_handler_fn;
+       case OPT_SOCKADDR_T: return sockaddr_handler_fn;
+       case OPT_STRINGFIELD_T: return stringfield_handler_fn;
+       case OPT_UINT_T: return uint_handler_fn;
+
+       default:
+       case OPT_CUSTOM_T: return NULL;
+       }
+
+       return NULL;
+}
+
+/*! \brief Hashing function for sorcery wizards */
+static int sorcery_wizard_hash(const void *obj, const int flags)
+{
+       const struct ast_sorcery_wizard *wizard = obj;
+       const char *name = obj;
+
+       return ast_str_hash(flags & OBJ_KEY ? name : wizard->name);
+}
+
+/*! \brief Comparator function for sorcery wizards */
+static int sorcery_wizard_cmp(void *obj, void *arg, int flags)
+{
+       struct ast_sorcery_wizard *wizard1 = obj, *wizard2 = arg;
+       const char *name = arg;
+
+       return !strcmp(wizard1->name, flags & OBJ_KEY ? name : wizard2->name) ? CMP_MATCH | CMP_STOP : 0;
+}
+
+int ast_sorcery_init(void)
+{
+       ast_assert(wizards == NULL);
+
+       if (!(wizards = ao2_container_alloc(WIZARD_BUCKETS, sorcery_wizard_hash, sorcery_wizard_cmp))) {
+               return -1;
+       }
+
+       return 0;
+}
+
+int __ast_sorcery_wizard_register(const struct ast_sorcery_wizard *interface, struct ast_module *module)
+{
+       struct ast_sorcery_wizard *wizard;
+       int res = -1;
+
+       ast_assert(!ast_strlen_zero(interface->name));
+
+       ao2_lock(wizards);
+
+       if ((wizard = ao2_find(wizards, interface->name, OBJ_KEY | OBJ_NOLOCK))) {
+               ast_log(LOG_WARNING, "Attempted to register sorcery wizard '%s' twice\n",
+                       interface->name);
+               goto done;
+       }
+
+       if (!(wizard = ao2_alloc(sizeof(*wizard), NULL))) {
+               goto done;
+       }
+
+       *wizard = *interface;
+       wizard->module = module;
+
+       ao2_link_flags(wizards, wizard, OBJ_NOLOCK);
+       res = 0;
+
+       ast_verb(2, "Sorcery registered wizard '%s'\n", interface->name);
+
+done:
+       ao2_cleanup(wizard);
+       ao2_unlock(wizards);
+
+       return res;
+}
+
+int ast_sorcery_wizard_unregister(const struct ast_sorcery_wizard *interface)
+{
+       RAII_VAR(struct ast_sorcery_wizard *, wizard, ao2_find(wizards, interface->name, OBJ_KEY | OBJ_UNLINK), ao2_cleanup);
+
+       if (wizard) {
+               ast_verb(2, "Sorcery unregistered wizard '%s'\n", interface->name);
+               return 0;
+       } else {
+               return -1;
+       }
+}
+
+/*! \brief Destructor called when sorcery structure is destroyed */
+static void sorcery_destructor(void *obj)
+{
+       struct ast_sorcery *sorcery = obj;
+
+       ao2_cleanup(sorcery->types);
+}
+
+/*! \brief Hashing function for sorcery types */
+static int sorcery_type_hash(const void *obj, const int flags)
+{
+       const struct ast_sorcery_object_type *type = obj;
+       const char *name = obj;
+
+       return ast_str_hash(flags & OBJ_KEY ? name : type->name);
+}
+
+/*! \brief Comparator function for sorcery types */
+static int sorcery_type_cmp(void *obj, void *arg, int flags)
+{
+       struct ast_sorcery_object_type *type1 = obj, *type2 = arg;
+       const char *name = arg;
+
+       return !strcmp(type1->name, flags & OBJ_KEY ? name : type2->name) ? CMP_MATCH | CMP_STOP : 0;
+}
+
+struct ast_sorcery *ast_sorcery_open(void)
+{
+       struct ast_sorcery *sorcery;
+
+       if (!(sorcery = ao2_alloc(sizeof(*sorcery), sorcery_destructor))) {
+               return NULL;
+       }
+
+       if (!(sorcery->types = ao2_container_alloc_options(AO2_ALLOC_OPT_LOCK_NOLOCK, TYPE_BUCKETS, sorcery_type_hash, sorcery_type_cmp))) {
+               ao2_ref(sorcery, -1);
+               sorcery = NULL;
+       }
+
+       return sorcery;
+}
+
+/*! \brief Destructor function for object types */
+static void sorcery_object_type_destructor(void *obj)
+{
+       struct ast_sorcery_object_type *object_type = obj;
+
+       ao2_cleanup(object_type->wizards);
+       ao2_cleanup(object_type->fields);
+
+       if (object_type->info) {
+               aco_info_destroy(object_type->info);
+               ast_free(object_type->info);
+       }
+
+       ast_free(object_type->file);
+}
+
+/*! \brief Internal function which allocates an object type structure */
+static struct ast_sorcery_object_type *sorcery_object_type_alloc(const char *type)
+{
+       struct ast_sorcery_object_type *object_type;
+
+       if (!(object_type = ao2_alloc(sizeof(*object_type), sorcery_object_type_destructor))) {
+               return NULL;
+       }
+
+       /* Order matters for object wizards */
+       if (!(object_type->wizards = ao2_container_alloc_options(AO2_ALLOC_OPT_LOCK_NOLOCK, 1, NULL, NULL))) {
+               ao2_ref(object_type, -1);
+               return NULL;
+       }
+
+       if (!(object_type->fields = ao2_container_alloc_options(AO2_ALLOC_OPT_LOCK_NOLOCK, 1, NULL, NULL))) {
+               ao2_ref(object_type, -1);
+               return NULL;
+       }
+
+       if (!(object_type->info = ast_calloc(1, sizeof(*object_type->info) + 2 * sizeof(object_type->info->files[0])))) {
+               ao2_ref(object_type, -1);
+               return NULL;
+       }
+
+       if (!(object_type->file = ast_calloc(1, sizeof(*object_type->file) + 2 * sizeof(object_type->file->types[0])))) {
+               ao2_ref(object_type, -1);
+               return NULL;
+       }
+
+       object_type->info->files[0] = object_type->file;
+       object_type->info->files[1] = NULL;
+
+       ast_copy_string(object_type->name, type, sizeof(object_type->name));
+
+       return object_type;
+}
+
+/*! \brief Object wizard destructor */
+static void sorcery_object_wizard_destructor(void *obj)
+{
+       struct ast_sorcery_object_wizard *object_wizard = obj;
+
+       if (object_wizard->data) {
+               object_wizard->wizard->close(object_wizard->data);
+       }
+
+       if (object_wizard->wizard) {
+               ast_module_unref(object_wizard->wizard->module);
+       }
+}
+
+/*! \brief Internal function which creates an object type and adds a wizard mapping */
+static int sorcery_apply_wizard_mapping(struct ast_sorcery *sorcery, const char *type, const char *name, const char *data, unsigned int caching)
+{
+       RAII_VAR(struct ast_sorcery_object_type *, object_type,  ao2_find(sorcery->types, type, OBJ_KEY), ao2_cleanup);
+       RAII_VAR(struct ast_sorcery_wizard *, wizard, ao2_find(wizards, name, OBJ_KEY), ao2_cleanup);
+       RAII_VAR(struct ast_sorcery_object_wizard *, object_wizard, ao2_alloc(sizeof(*object_wizard), sorcery_object_wizard_destructor), ao2_cleanup);
+       int created = 0;
+
+       if (!wizard || !object_wizard) {
+               return -1;
+       }
+
+       if (!object_type) {
+               if (!(object_type = sorcery_object_type_alloc(type))) {
+                       return -1;
+               }
+               created = 1;
+       }
+
+       if (wizard->open && !(object_wizard->data = wizard->open(data))) {
+               return -1;
+       }
+
+       ast_module_ref(wizard->module);
+
+       object_wizard->wizard = wizard;
+       object_wizard->caching = caching;
+
+       ao2_link(object_type->wizards, object_wizard);
+
+       if (created) {
+               ao2_link(sorcery->types, object_type);
+       }
+
+       return 0;
+}
+
+int ast_sorcery_apply_config(struct ast_sorcery *sorcery, const char *name)
+{
+       struct ast_flags flags = { 0 };
+       struct ast_config *config = ast_config_load2("sorcery.conf", "sorcery", flags);
+       struct ast_variable *mapping;
+       int res = 0;
+
+       if (!config || (config == CONFIG_STATUS_FILEMISSING) || (config == CONFIG_STATUS_FILEINVALID)) {
+               return -1;
+       }
+
+       for (mapping = ast_variable_browse(config, name); mapping; mapping = mapping->next) {
+               RAII_VAR(char *, mapping_name, ast_strdup(mapping->name), ast_free);
+               RAII_VAR(char *, mapping_value, ast_strdup(mapping->value), ast_free);
+               char *options = mapping_name, *name = strsep(&options, "/");
+               char *data = mapping_value, *wizard = strsep(&data, ",");
+               unsigned int caching = 0;
+
+               /* If no wizard exists just skip, nothing we can do */
+               if (ast_strlen_zero(wizard)) {
+                       continue;
+               }
+
+               /* If the wizard is configured as a cache treat it as such */
+               if (!ast_strlen_zero(options) && strstr(options, "cache")) {
+                       caching = 1;
+               }
+
+               /* Any error immediately causes us to stop */
+               if ((res = sorcery_apply_wizard_mapping(sorcery, name, wizard, data, caching))) {
+                       break;
+               }
+       }
+
+       ast_config_destroy(config);
+
+       return res;
+}
+
+int ast_sorcery_apply_default(struct ast_sorcery *sorcery, const char *type, const char *name, const char *data)
+{
+       RAII_VAR(struct ast_sorcery_object_type *, object_type,  ao2_find(sorcery->types, type, OBJ_KEY), ao2_cleanup);
+
+       /* Defaults can not be added if any existing mapping exists */
+       if (object_type) {
+               return -1;
+       }
+
+       return sorcery_apply_wizard_mapping(sorcery, type, name, data, 0);
+}
+
+int ast_sorcery_object_register(struct ast_sorcery *sorcery, const char *type, aco_type_item_alloc alloc, sorcery_transform_handler transform, sorcery_apply_handler apply)
+{
+       RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, type, OBJ_KEY), ao2_cleanup);
+
+       if (!object_type) {
+               return -1;
+       }
+
+       object_type->type.type = ACO_ITEM;
+       object_type->type.category = "";
+       object_type->type.item_alloc = alloc;
+
+       object_type->transform = transform;
+       object_type->file->types[0] = &object_type->type;
+       object_type->file->types[1] = NULL;
+
+       if (aco_info_init(object_type->info)) {
+               return -1;
+       }
+
+       return 0;
+}
+
+int __ast_sorcery_object_field_register(struct ast_sorcery *sorcery, const char *type, const char *name, const char *default_val, enum aco_option_type opt_type,
+                                       aco_option_handler config_handler, sorcery_field_handler sorcery_handler, unsigned int flags, size_t argc, ...)
+{
+       RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, type, OBJ_KEY), ao2_cleanup);
+       RAII_VAR(struct ast_sorcery_object_field *, object_field, NULL, ao2_cleanup);
+       int pos;
+       va_list args;
+
+       if (!object_type || !object_type->type.item_alloc) {
+               return -1;
+       }
+
+       if (!sorcery_handler) {
+               sorcery_handler = sorcery_field_default_handler(opt_type);
+       }
+
+       if (!(object_field = ao2_alloc(sizeof(*object_field) + argc * sizeof(object_field->args[0]), NULL))) {
+               return -1;
+       }
+
+       ast_copy_string(object_field->name, name, sizeof(object_field->name));
+       object_field->handler = sorcery_handler;
+
+       va_start(args, argc);
+       for (pos = 0; pos < argc; pos++) {
+               object_field->args[pos] = va_arg(args, size_t);
+       }
+       va_end(args);
+
+       ao2_link(object_type->fields, object_field);
+
+       /* TODO: Improve this hack */
+       if (!argc) {
+               __aco_option_register(object_type->info, name, ACO_EXACT, object_type->file->types, default_val, opt_type, config_handler, flags, argc);
+       } else if (argc == 1) {
+               __aco_option_register(object_type->info, name, ACO_EXACT, object_type->file->types, default_val, opt_type, config_handler, flags, argc,
+                                     object_field->args[0]);
+       } else if (argc == 2) {
+               __aco_option_register(object_type->info, name, ACO_EXACT, object_type->file->types, default_val, opt_type, config_handler, flags, argc,
+                                     object_field->args[0], object_field->args[1]);
+       } else if (argc == 3) {
+               __aco_option_register(object_type->info, name, ACO_EXACT, object_type->file->types, default_val, opt_type, config_handler, flags, argc,
+                                     object_field->args[0], object_field->args[1], object_field->args[2]);
+       } else {
+               ast_assert(0); /* The hack... she does us no good for this */
+       }
+
+       return 0;
+}
+
+static int sorcery_wizard_load(void *obj, void *arg, int flags)
+{
+       struct ast_sorcery_object_wizard *wizard = obj;
+       struct sorcery_load_details *details = arg;
+       void (*load)(void *data, const struct ast_sorcery *sorcery, const char *type);
+
+       load = !details->reload ? wizard->wizard->load : wizard->wizard->reload;
+
+       if (load) {
+               load(wizard->data, details->sorcery, details->type);
+       }
+
+       return 0;
+}
+
+static int sorcery_object_load(void *obj, void *arg, int flags)
+{
+       struct ast_sorcery_object_type *type = obj;
+       struct sorcery_load_details *details = arg;
+
+       details->type = type->name;
+       ao2_callback(type->wizards, OBJ_NODATA, sorcery_wizard_load, details);
+
+       return 0;
+}
+
+void ast_sorcery_load(const struct ast_sorcery *sorcery)
+{
+       struct sorcery_load_details details = {
+               .sorcery = sorcery,
+               .reload = 0,
+       };
+
+       ao2_callback(sorcery->types, OBJ_NODATA, sorcery_object_load, &details);
+}
+
+void ast_sorcery_reload(const struct ast_sorcery *sorcery)
+{
+       struct sorcery_load_details details = {
+               .sorcery = sorcery,
+               .reload = 1,
+       };
+
+       ao2_callback(sorcery->types, OBJ_NODATA, sorcery_object_load, &details);
+}
+
+void ast_sorcery_ref(struct ast_sorcery *sorcery)
+{
+       ao2_ref(sorcery, +1);
+}
+
+struct ast_variable *ast_sorcery_objectset_create(const struct ast_sorcery *sorcery, const void *object)
+{
+       const struct ast_sorcery_object_details *details = object;
+       RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, details->type, OBJ_KEY), ao2_cleanup);
+       struct ao2_iterator i;
+       struct ast_sorcery_object_field *object_field;
+       struct ast_variable *fields = NULL;
+       int res = 0;
+
+       if (!object_type) {
+               return NULL;
+       }
+
+       i = ao2_iterator_init(object_type->fields, 0);
+
+       for (; (object_field = ao2_iterator_next(&i)); ao2_ref(object_field, -1)) {
+               RAII_VAR(char *, buf, NULL, ast_free);
+               struct ast_variable *tmp;
+
+               /* Any fields with no handler just get skipped */
+               if (!object_field->handler) {
+                       continue;
+               }
+
+               if ((res = object_field->handler(object, object_field->args, &buf)) ||
+                   !(tmp = ast_variable_new(object_field->name, S_OR(buf, ""), ""))) {
+                       res = -1;
+                       ao2_ref(object_field, -1);
+                       break;
+               }
+
+               tmp->next = fields;
+               fields = tmp;
+       }
+
+       ao2_iterator_destroy(&i);
+
+       /* If any error occurs we destroy all fields handled before so a partial objectset is not returned */
+       if (res) {
+               ast_variables_destroy(fields);
+               fields = NULL;
+       }
+
+       return fields;
+}
+
+int ast_sorcery_objectset_apply(const struct ast_sorcery *sorcery, void *object, struct ast_variable *objectset)
+{
+       const struct ast_sorcery_object_details *details = object;
+       RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, details->type, OBJ_KEY), ao2_cleanup);
+       RAII_VAR(struct ast_variable *, transformed, NULL, ast_variables_destroy);
+       struct ast_variable *field;
+       int res = 0;
+
+       if (!object_type) {
+               return -1;
+       }
+
+       if (object_type->transform && (transformed = object_type->transform(objectset))) {
+               field = transformed;
+       } else {
+               field = objectset;
+       }
+
+       for (; field; field = field->next) {
+               if ((res = aco_process_var(&object_type->type, details->id, field, object))) {
+                       break;
+               }
+       }
+
+       if (!res && object_type->apply) {
+               object_type->apply(sorcery, object);
+       }
+
+       return res;
+}
+
+static const struct ast_variable *sorcery_find_field(const struct ast_variable *fields, const char *name)
+{
+       const struct ast_variable *field;
+
+       /* Search the linked list of fields to find the correct one */
+       for (field = fields; field; field = field->next) {
+               if (!strcmp(field->name, name)) {
+                       return field;
+               }
+       }
+
+       return NULL;
+}
+
+int ast_sorcery_changeset_create(const struct ast_variable *original, const struct ast_variable *modified, struct ast_variable **changes)
+{
+       const struct ast_variable *field;
+       int res = 0;
+
+       *changes = NULL;
+
+       /* Unless the ast_variable list changes when examined... it can't differ from itself */
+       if (original == modified) {
+               return 0;
+       }
+
+       for (field = modified; field; field = field->next) {
+               const struct ast_variable *old = sorcery_find_field(original, field->name);
+
+               if (!old || strcmp(old->value, field->value)) {
+                       struct ast_variable *tmp;
+
+                       if (!(tmp = ast_variable_new(field->name, field->value, ""))) {
+                               res = -1;
+                               break;
+                       }
+
+                       tmp->next = *changes;
+                       *changes = tmp;
+               }
+       }
+
+       /* If an error occurred do not return a partial changeset */
+       if (res) {
+               ast_variables_destroy(*changes);
+               *changes = NULL;
+       }
+
+       return res;
+}
+
+void *ast_sorcery_alloc(const struct ast_sorcery *sorcery, const char *type, const char *id)
+{
+       RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, type, OBJ_KEY), ao2_cleanup);
+       struct ast_sorcery_object_details *details;
+
+       if (!object_type || !object_type->type.item_alloc ||
+           !(details = object_type->type.item_alloc(""))) {
+               return NULL;
+       }
+
+       if (ast_strlen_zero(id)) {
+               struct ast_uuid *uuid = ast_uuid_generate();
+
+               if (!uuid) {
+                       ao2_ref(details, -1);
+                       return NULL;
+               }
+
+               ast_uuid_to_str(uuid, details->id, AST_UUID_STR_LEN);
+               ast_free(uuid);
+       } else {
+               ast_copy_string(details->id, id, sizeof(details->id));
+       }
+
+       ast_copy_string(details->type, type, sizeof(details->type));
+
+       if (aco_set_defaults(&object_type->type, id, details)) {
+               ao2_ref(details, -1);
+               return NULL;
+       }
+
+       return details;
+}
+
+void *ast_sorcery_copy(const struct ast_sorcery *sorcery, const void *object)
+{
+       const struct ast_sorcery_object_details *details = object;
+       struct ast_sorcery_object_details *copy = ast_sorcery_alloc(sorcery, details->type, details->id);
+       RAII_VAR(struct ast_variable *, objectset, NULL, ast_variables_destroy);
+
+       if (!copy ||
+           !(objectset = ast_sorcery_objectset_create(sorcery, object)) ||
+           ast_sorcery_objectset_apply(sorcery, copy, objectset)) {
+               ao2_cleanup(copy);
+               return NULL;
+       }
+
+       return copy;
+}
+
+int ast_sorcery_diff(const struct ast_sorcery *sorcery, const void *original, const void *modified, struct ast_variable **changes)
+{
+       RAII_VAR(struct ast_variable *, objectset1, NULL, ast_variables_destroy);
+       RAII_VAR(struct ast_variable *, objectset2, NULL, ast_variables_destroy);
+
+       *changes = NULL;
+
+       if (strcmp(ast_sorcery_object_get_type(original), ast_sorcery_object_get_type(modified))) {
+               return -1;
+       }
+
+       objectset1 = ast_sorcery_objectset_create(sorcery, original);
+       objectset2 = ast_sorcery_objectset_create(sorcery, modified);
+
+       return ast_sorcery_changeset_create(objectset1, objectset2, changes);
+}
+
+/*! \brief Internal function used to create an object in caching wizards */
+static int sorcery_cache_create(void *obj, void *arg, int flags)
+{
+       struct ast_sorcery_object_wizard *object_wizard = obj;
+
+       if (!object_wizard->caching || !object_wizard->wizard->create) {
+               return 0;
+       }
+
+       object_wizard->wizard->create(object_wizard->data, arg);
+
+       return 0;
+}
+
+void *ast_sorcery_retrieve_by_id(const struct ast_sorcery *sorcery, const char *type, const char *id)
+{
+       RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, type, OBJ_KEY), ao2_cleanup);
+       void *object = NULL;
+       struct ao2_iterator i;
+       struct ast_sorcery_object_wizard *wizard;
+       unsigned int cached = 0;
+
+       if (!object_type || ast_strlen_zero(id)) {
+               return NULL;
+       }
+
+       i = ao2_iterator_init(object_type->wizards, 0);
+       for (; (wizard = ao2_iterator_next(&i)); ao2_ref(wizard, -1)) {
+               if (wizard->wizard->retrieve_id &&
+                   !(object = wizard->wizard->retrieve_id(sorcery, wizard->data, object_type->name, id))) {
+                       continue;
+               }
+
+               cached = wizard->caching;
+
+               ao2_ref(wizard, -1);
+               break;
+       }
+        ao2_iterator_destroy(&i);
+
+       if (!cached && object) {
+               ao2_callback(object_type->wizards, 0, sorcery_cache_create, object);
+       }
+
+       return object;
+}
+
+void *ast_sorcery_retrieve_by_fields(const struct ast_sorcery *sorcery, const char *type, unsigned int flags, struct ast_variable *fields)
+{
+       RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, type, OBJ_KEY), ao2_cleanup);
+       void *object = NULL;
+       struct ao2_iterator i;
+       struct ast_sorcery_object_wizard *wizard;
+       unsigned int cached = 0;
+
+       if (!object_type) {
+               return NULL;
+       }
+
+       /* If returning multiple objects create a container to store them in */
+       if ((flags & AST_RETRIEVE_FLAG_MULTIPLE)) {
+               if (!(object = ao2_container_alloc_options(AO2_ALLOC_OPT_LOCK_NOLOCK, 1, NULL, NULL))) {
+                       return NULL;
+               }
+       }
+
+       /* Inquire with the available wizards for retrieval */
+       i = ao2_iterator_init(object_type->wizards, 0);
+       for (; (wizard = ao2_iterator_next(&i)); ao2_ref(wizard, -1)) {
+               if ((flags & AST_RETRIEVE_FLAG_MULTIPLE)) {
+                       if (wizard->wizard->retrieve_multiple) {
+                               wizard->wizard->retrieve_multiple(sorcery, wizard->data, object_type->name, object, fields);
+                       }
+               } else if (fields && wizard->wizard->retrieve_fields) {
+                       if (wizard->wizard->retrieve_fields) {
+                               object = wizard->wizard->retrieve_fields(sorcery, wizard->data, object_type->name, fields);
+                       }
+               }
+
+               if ((flags & AST_RETRIEVE_FLAG_MULTIPLE) || !object) {
+                       continue;
+               }
+
+               cached = wizard->caching;
+
+               ao2_ref(wizard, -1);
+               break;
+       }
+       ao2_iterator_destroy(&i);
+
+       /* If we are returning a single object and it came from a non-cache source create it in any caches */
+       if (!(flags & AST_RETRIEVE_FLAG_MULTIPLE) && !cached && object) {
+               ao2_callback(object_type->wizards, 0, sorcery_cache_create, object);
+       }
+
+       return object;
+}
+
+/*! \brief Internal function which returns if the wizard has created the object */
+static int sorcery_wizard_create(void *obj, void *arg, int flags)
+{
+       const struct ast_sorcery_object_wizard *object_wizard = obj;
+
+       return (!object_wizard->caching && !object_wizard->wizard->create(object_wizard->data, arg)) ? CMP_MATCH | CMP_STOP : 0;
+}
+
+int ast_sorcery_create(const struct ast_sorcery *sorcery, void *object)
+{
+       const struct ast_sorcery_object_details *details = object;
+       RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, details->type, OBJ_KEY), ao2_cleanup);
+       RAII_VAR(struct ast_sorcery_object_wizard *, object_wizard, NULL, ao2_cleanup);
+
+       if (!object_type) {
+               return -1;
+       }
+
+       object_wizard = ao2_callback(object_type->wizards, 0, sorcery_wizard_create, object);
+
+       return object_wizard ? 0 : -1;
+}
+
+/*! \brief Internal function which returns if a wizard has updated the object */
+static int sorcery_wizard_update(void *obj, void *arg, int flags)
+{
+       const struct ast_sorcery_object_wizard *object_wizard = obj;
+
+       return (object_wizard->wizard->update && !object_wizard->wizard->update(object_wizard->data, arg) &&
+               !object_wizard->caching) ? CMP_MATCH | CMP_STOP : 0;
+}
+
+int ast_sorcery_update(const struct ast_sorcery *sorcery, void *object)
+{
+       const struct ast_sorcery_object_details *details = object;
+       RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, details->type, OBJ_KEY), ao2_cleanup);
+       RAII_VAR(struct ast_sorcery_object_wizard *, object_wizard, NULL, ao2_cleanup);
+
+       if (!object_type) {
+               return -1;
+       }
+
+       object_wizard = ao2_callback(object_type->wizards, 0, sorcery_wizard_update, object);
+
+       return object_wizard ? 0 : -1;
+}
+
+/*! \brief Internal function which returns if a wizard has deleted the object */
+static int sorcery_wizard_delete(void *obj, void *arg, int flags)
+{
+       const struct ast_sorcery_object_wizard *object_wizard = obj;
+
+       return (object_wizard->wizard->delete && !object_wizard->wizard->delete(object_wizard->data, arg) &&
+               !object_wizard->caching) ? CMP_MATCH | CMP_STOP : 0;
+}
+
+int ast_sorcery_delete(const struct ast_sorcery *sorcery, void *object)
+{
+       const struct ast_sorcery_object_details *details = object;
+       RAII_VAR(struct ast_sorcery_object_type *, object_type, ao2_find(sorcery->types, details->type, OBJ_KEY), ao2_cleanup);
+       RAII_VAR(struct ast_sorcery_object_wizard *, object_wizard, NULL, ao2_cleanup);
+
+       if (!object_type) {
+               return -1;
+       }
+
+       object_wizard = ao2_callback(object_type->wizards, 0, sorcery_wizard_delete, object);
+
+       return object_wizard ? 0 : -1;
+}
+
+void ast_sorcery_unref(struct ast_sorcery *sorcery)
+{
+       ao2_cleanup(sorcery);
+}
+
+const char *ast_sorcery_object_get_id(const void *object)
+{
+       const struct ast_sorcery_object_details *details = object;
+       return details->id;
+}
+
+const char *ast_sorcery_object_get_type(const void *object)
+{
+       const struct ast_sorcery_object_details *details = object;
+       return details->type;
+}
diff --git a/res/res_sorcery_config.c b/res/res_sorcery_config.c
new file mode 100644 (file)
index 0000000..9fe636d
--- /dev/null
@@ -0,0 +1,346 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2012 - 2013, Digium, Inc.
+ *
+ * Joshua Colp <jcolp@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*!
+ * \file
+ *
+ * \brief Sorcery Configuration File Object Wizard
+ *
+ * \author Joshua Colp <jcolp@digium.com>
+ */
+
+/*** MODULEINFO
+       <support_level>core</support_level>
+ ***/
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include "asterisk/module.h"
+#include "asterisk/sorcery.h"
+#include "asterisk/astobj2.h"
+#include "asterisk/config.h"
+
+/*! \brief Default number of buckets for sorcery objects */
+#define DEFAULT_OBJECT_BUCKETS 53
+
+/*! \brief Structure for storing configuration file sourced objects */
+struct sorcery_config {
+       /*! \brief Objects retrieved from the configuration file */
+       struct ao2_global_obj objects;
+
+       /*! \brief Any specific variable criteria for considering a defined category for this object */
+       struct ast_variable *criteria;
+
+       /*! \brief Number of buckets to use for objects */
+       unsigned int buckets;
+
+       /*! \brief Enable file level integrity instead of object level */
+       unsigned int file_integrity:1;
+
+       /*! \brief Filename of the configuration file */
+       char filename[];
+};
+
+/*! \brief Structure used for fields comparison */
+struct sorcery_config_fields_cmp_params {
+       /*! \brief Pointer to the sorcery structure */
+       const struct ast_sorcery *sorcery;
+
+       /*! \brief Pointer to the fields to check */
+       const struct ast_variable *fields;
+
+       /*! \brief Optional container to put object into */
+       struct ao2_container *container;
+};
+
+static void *sorcery_config_open(const char *data);
+static void sorcery_config_load(void *data, const struct ast_sorcery *sorcery, const char *type);
+static void sorcery_config_reload(void *data, const struct ast_sorcery *sorcery, const char *type);
+static void *sorcery_config_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id);
+static void *sorcery_config_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields);
+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);
+static void sorcery_config_close(void *data);
+
+static struct ast_sorcery_wizard config_object_wizard = {
+       .name = "config",
+       .open = sorcery_config_open,
+       .load = sorcery_config_load,
+       .reload = sorcery_config_reload,
+       .retrieve_id = sorcery_config_retrieve_id,
+       .retrieve_fields = sorcery_config_retrieve_fields,
+       .retrieve_multiple = sorcery_config_retrieve_multiple,
+       .close = sorcery_config_close,
+};
+
+/*! \brief Destructor function for sorcery config */
+static void sorcery_config_destructor(void *obj)
+{
+       struct sorcery_config *config = obj;
+
+       ao2_global_obj_release(config->objects);
+       ast_rwlock_destroy(&config->objects.lock);
+       ast_variables_destroy(config->criteria);
+}
+
+/*! \brief Hashing function for sorcery objects */
+static int sorcery_config_hash(const void *obj, const int flags)
+{
+       const char *id = obj;
+
+       return ast_str_hash(flags & OBJ_KEY ? id : ast_sorcery_object_get_id(obj));
+}
+
+/*! \brief Comparator function for sorcery objects */
+static int sorcery_config_cmp(void *obj, void *arg, int flags)
+{
+       const char *id = arg;
+
+       return !strcmp(ast_sorcery_object_get_id(obj), flags & OBJ_KEY ? id : ast_sorcery_object_get_id(arg)) ? CMP_MATCH | CMP_STOP : 0;
+}
+
+static int sorcery_config_fields_cmp(void *obj, void *arg, int flags)
+{
+       const struct sorcery_config_fields_cmp_params *params = arg;
+       RAII_VAR(struct ast_variable *, objset, NULL, ast_variables_destroy);
+       RAII_VAR(struct ast_variable *, diff, NULL, ast_variables_destroy);
+
+       /* If we can't turn the object into an object set OR if differences exist between the fields
+        * passed in and what are present on the object they are not a match.
+        */
+       if (params->fields &&
+           (!(objset = ast_sorcery_objectset_create(params->sorcery, obj)) ||
+            (ast_sorcery_changeset_create(objset, params->fields, &diff)) ||
+            diff)) {
+               return 0;
+       }
+
+       if (params->container) {
+               ao2_link(params->container, obj);
+
+               /* As multiple objects are being returned keep going */
+               return 0;
+       } else {
+               /* Immediately stop and return, we only want a single object */
+               return CMP_MATCH | CMP_STOP;
+       }
+}
+
+static void *sorcery_config_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields)
+{
+       struct sorcery_config *config = data;
+       RAII_VAR(struct ao2_container *, objects, ao2_global_obj_ref(config->objects), ao2_cleanup);
+       struct sorcery_config_fields_cmp_params params = {
+               .sorcery = sorcery,
+               .fields = fields,
+               .container = NULL,
+       };
+
+       /* If no fields are present return nothing, we require *something*, same goes if no objects exist yet */
+       if (!objects || !fields) {
+               return NULL;
+       }
+
+       return ao2_callback(objects, 0, sorcery_config_fields_cmp, &params);
+}
+
+static void *sorcery_config_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id)
+{
+       struct sorcery_config *config = data;
+       RAII_VAR(struct ao2_container *, objects, ao2_global_obj_ref(config->objects), ao2_cleanup);
+
+       return objects ? ao2_find(objects, id, OBJ_KEY | OBJ_NOLOCK) : NULL;
+}
+
+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)
+{
+       struct sorcery_config *config = data;
+       RAII_VAR(struct ao2_container *, config_objects, ao2_global_obj_ref(config->objects), ao2_cleanup);
+       struct sorcery_config_fields_cmp_params params = {
+               .sorcery = sorcery,
+               .fields = fields,
+               .container = objects,
+       };
+
+       if (!config_objects) {
+               return;
+       }
+
+       ao2_callback(config_objects, 0, sorcery_config_fields_cmp, &params);
+}
+
+/*! \brief Internal function which determines if criteria has been met for considering an object set applicable */
+static int sorcery_is_criteria_met(struct ast_variable *objset, struct ast_variable *criteria)
+{
+       RAII_VAR(struct ast_variable *, diff, NULL, ast_variables_destroy);
+
+       return (!criteria || (!ast_sorcery_changeset_create(objset, criteria, &diff) && !diff)) ? 1 : 0;
+}
+
+static void sorcery_config_internal_load(void *data, const struct ast_sorcery *sorcery, const char *type, unsigned int reload)
+{
+       struct sorcery_config *config = data;
+       struct ast_flags flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
+       struct ast_config *cfg = ast_config_load2(config->filename, "res_sorcery_config", flags);
+       RAII_VAR(struct ao2_container *, objects, NULL, ao2_cleanup);
+       const char *id = NULL;
+
+       if (!cfg) {
+               ast_log(LOG_ERROR, "Unable to load config file '%s'n", config->filename);
+               return;
+       } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
+               ast_debug(1, "Config file '%s' was unchanged\n", config->filename);
+               return;
+       } else if (cfg == CONFIG_STATUS_FILEINVALID) {
+               ast_log(LOG_ERROR, "Contents of config file '%s' are invalid and cannot be parsed\n", config->filename);
+               return;
+       }
+
+       if (!(objects = ao2_container_alloc(config->buckets, sorcery_config_hash, sorcery_config_cmp))) {
+               ast_log(LOG_ERROR, "Could not create bucket for new objects from '%s', keeping existing objects\n",
+                       config->filename);
+               ast_config_destroy(cfg);
+               return;
+       }
+
+       while ((id = ast_category_browse(cfg, id))) {
+               RAII_VAR(void *, obj, NULL, ao2_cleanup);
+
+               /* If given criteria has not been met skip the category, it is not applicable */
+               if (!sorcery_is_criteria_met(ast_variable_browse(cfg, id), config->criteria)) {
+                       continue;
+               }
+
+               if (!(obj = ast_sorcery_alloc(sorcery, type, id)) ||
+                   ast_sorcery_objectset_apply(sorcery, obj, ast_variable_browse(cfg, id))) {
+                       ast_debug(1, "Could not create an object of type '%s' with id '%s' from configuration file '%s'\n",
+                                 type, id, config->filename);
+
+                       if (config->file_integrity) {
+                               ast_log(LOG_ERROR, "Config file '%s' could not be loaded due to error with object '%s' of type '%s'\n",
+                                       config->filename, id, type);
+                               ast_config_destroy(cfg);
+                               return;
+                       }
+
+                       ao2_cleanup(obj);
+
+                       /* 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 */
+                       if (!(obj = sorcery_config_retrieve_id(sorcery, data, type, id))) {
+                               continue;
+                       }
+               }
+
+               ao2_link_flags(objects, obj, OBJ_NOLOCK);
+       }
+
+       ao2_global_obj_replace_unref(config->objects, objects);
+       ast_config_destroy(cfg);
+}
+
+static void sorcery_config_load(void *data, const struct ast_sorcery *sorcery, const char *type)
+{
+       sorcery_config_internal_load(data, sorcery, type, 0);
+}
+
+static void sorcery_config_reload(void *data, const struct ast_sorcery *sorcery, const char *type)
+{
+       sorcery_config_internal_load(data, sorcery, type, 1);
+}
+
+static void *sorcery_config_open(const char *data)
+{
+       char *tmp = ast_strdupa(data), *filename = strsep(&tmp, ","), *option;
+       struct sorcery_config *config;
+
+       if (ast_strlen_zero(filename) || !(config = ao2_alloc_options(sizeof(*config) + strlen(filename) + 1, sorcery_config_destructor, AO2_ALLOC_OPT_LOCK_NOLOCK))) {
+               return NULL;
+       }
+
+       ast_rwlock_init(&config->objects.lock);
+       config->buckets = DEFAULT_OBJECT_BUCKETS;
+       strcpy(config->filename, filename);
+
+       while ((option = strsep(&tmp, ","))) {
+               char *name = strsep(&option, "="), *value = option;
+
+               if (!strcasecmp(name, "buckets")) {
+                       if (sscanf(value, "%30d", &config->buckets) != 1) {
+                               ast_log(LOG_ERROR, "Unsupported bucket size of '%s' used for configuration file '%s', defaulting to '%d'\n",
+                                       value, filename, DEFAULT_OBJECT_BUCKETS);
+                       }
+               } else if (!strcasecmp(name, "integrity")) {
+                       if (!strcasecmp(value, "file")) {
+                               config->file_integrity = 1;
+                       } else if (!strcasecmp(value, "object")) {
+                               config->file_integrity = 0;
+                       } else {
+                               ast_log(LOG_ERROR, "Unsupported integrity value of '%s' used for configuration file '%s', defaulting to 'object'\n",
+                                       value, filename);
+                       }
+               } else if (!strcasecmp(name, "criteria")) {
+                       char *field = strsep(&value, "=");
+                       struct ast_variable *criteria = ast_variable_new(field, value, "");
+
+                       if (criteria) {
+                               criteria->next = config->criteria;
+                               config->criteria = criteria;
+                       } else {
+                               /* This is fatal since not following criteria would potentially yield invalid objects */
+                               ast_log(LOG_ERROR, "Could not create criteria entry of field '%s' with value '%s' for configuration file '%s'\n",
+                                       field, value, filename);
+                               ao2_ref(config, -1);
+                               return NULL;
+                       }
+               } else {
+                       ast_log(LOG_ERROR, "Unsupported option '%s' used for configuration file '%s'\n", name, filename);
+               }
+       }
+
+       return config;
+}
+
+static void sorcery_config_close(void *data)
+{
+       struct sorcery_config *config = data;
+
+       ao2_ref(config, -1);
+}
+
+static int load_module(void)
+{
+       if (ast_sorcery_wizard_register(&config_object_wizard)) {
+               return AST_MODULE_LOAD_DECLINE;
+       }
+
+       return AST_MODULE_LOAD_SUCCESS;
+}
+
+static int unload_module(void)
+{
+       ast_sorcery_wizard_unregister(&config_object_wizard);
+       return 0;
+}
+
+AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "Sorcery Configuration File Object Wizard",
+       .load = load_module,
+       .unload = unload_module,
+       .load_pri = AST_MODPRI_CHANNEL_DEPEND,
+);
diff --git a/res/res_sorcery_memory.c b/res/res_sorcery_memory.c
new file mode 100644 (file)
index 0000000..cc8ff7f
--- /dev/null
@@ -0,0 +1,211 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2012 - 2013, Digium, Inc.
+ *
+ * Joshua Colp <jcolp@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*!
+ * \file
+ *
+ * \brief Sorcery In-Memory Object Wizard
+ *
+ * \author Joshua Colp <jcolp@digium.com>
+ */
+
+/*** MODULEINFO
+       <support_level>core</support_level>
+ ***/
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include "asterisk/module.h"
+#include "asterisk/sorcery.h"
+#include "asterisk/astobj2.h"
+
+/*! \brief Number of buckets for sorcery objects */
+#define OBJECT_BUCKETS 53
+
+static void *sorcery_memory_open(const char *data);
+static int sorcery_memory_create(void *data, void *object);
+static void *sorcery_memory_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id);
+static void *sorcery_memory_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields);
+static void sorcery_memory_retrieve_multiple(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects,
+                                            const struct ast_variable *fields);
+static int sorcery_memory_update(void *data, void *object);
+static int sorcery_memory_delete(void *data, void *object);
+static void sorcery_memory_close(void *data);
+
+static struct ast_sorcery_wizard memory_object_wizard = {
+       .name = "memory",
+       .open = sorcery_memory_open,
+       .create = sorcery_memory_create,
+       .retrieve_id = sorcery_memory_retrieve_id,
+       .retrieve_fields = sorcery_memory_retrieve_fields,
+       .retrieve_multiple = sorcery_memory_retrieve_multiple,
+       .update = sorcery_memory_update,
+       .delete = sorcery_memory_delete,
+       .close = sorcery_memory_close,
+};
+
+/*! \brief Structure used for fields comparison */
+struct sorcery_memory_fields_cmp_params {
+       /*! \brief Pointer to the sorcery structure */
+       const struct ast_sorcery *sorcery;
+
+       /*! \brief Pointer to the fields to check */
+       const struct ast_variable *fields;
+
+       /*! \brief Optional container to put object into */
+       struct ao2_container *container;
+};
+
+/*! \brief Hashing function for sorcery objects */
+static int sorcery_memory_hash(const void *obj, const int flags)
+{
+       const char *id = obj;
+
+       return ast_str_hash(flags & OBJ_KEY ? id : ast_sorcery_object_get_id(obj));
+}
+
+/*! \brief Comparator function for sorcery objects */
+static int sorcery_memory_cmp(void *obj, void *arg, int flags)
+{
+       const char *id = arg;
+
+       return !strcmp(ast_sorcery_object_get_id(obj), flags & OBJ_KEY ? id : ast_sorcery_object_get_id(arg)) ? CMP_MATCH | CMP_STOP : 0;
+}
+
+static int sorcery_memory_create(void *data, void *object)
+{
+       ao2_link(data, object);
+       return 0;
+}
+
+static int sorcery_memory_fields_cmp(void *obj, void *arg, int flags)
+{
+       const struct sorcery_memory_fields_cmp_params *params = arg;
+       RAII_VAR(struct ast_variable *, objset, NULL, ast_variables_destroy);
+       RAII_VAR(struct ast_variable *, diff, NULL, ast_variables_destroy);
+
+       /* If we can't turn the object into an object set OR if differences exist between the fields
+        * passed in and what are present on the object they are not a match.
+        */
+       if (params->fields &&
+           (!(objset = ast_sorcery_objectset_create(params->sorcery, obj)) ||
+            (ast_sorcery_changeset_create(objset, params->fields, &diff)) ||
+            diff)) {
+               return 0;
+       }
+
+       if (params->container) {
+               ao2_link(params->container, obj);
+
+               /* As multiple objects are being returned keep going */
+               return 0;
+       } else {
+               /* Immediately stop and return, we only want a single object */
+               return CMP_MATCH | CMP_STOP;
+       }
+}
+
+static void *sorcery_memory_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields)
+{
+       struct sorcery_memory_fields_cmp_params params = {
+               .sorcery = sorcery,
+               .fields = fields,
+               .container = NULL,
+       };
+
+       /* If no fields are present return nothing, we require *something* */
+       if (!fields) {
+               return NULL;
+       }
+
+       return ao2_callback(data, 0, sorcery_memory_fields_cmp, &params);
+}
+
+static void *sorcery_memory_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id)
+{
+       return ao2_find(data, id, OBJ_KEY);
+}
+
+static void sorcery_memory_retrieve_multiple(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const struct ast_variable *fields)
+{
+       struct sorcery_memory_fields_cmp_params params = {
+               .sorcery = sorcery,
+               .fields = fields,
+               .container = objects,
+       };
+
+       ao2_callback(data, 0, sorcery_memory_fields_cmp, &params);
+}
+
+static int sorcery_memory_update(void *data, void *object)
+{
+       RAII_VAR(void *, existing, NULL, ao2_cleanup);
+
+       ao2_lock(data);
+
+       if (!(existing = ao2_find(data, ast_sorcery_object_get_id(object), OBJ_KEY | OBJ_UNLINK))) {
+               ao2_unlock(data);
+               return -1;
+       }
+
+       ao2_link(data, object);
+
+       ao2_unlock(data);
+
+       return 0;
+}
+
+static int sorcery_memory_delete(void *data, void *object)
+{
+       RAII_VAR(void *, existing, ao2_find(data, ast_sorcery_object_get_id(object), OBJ_KEY | OBJ_UNLINK), ao2_cleanup);
+
+       return existing ? 0 : -1;
+}
+
+static void *sorcery_memory_open(const char *data)
+{
+       return ao2_container_alloc(OBJECT_BUCKETS, sorcery_memory_hash, sorcery_memory_cmp);
+}
+
+static void sorcery_memory_close(void *data)
+{
+       ao2_ref(data, -1);
+}
+
+static int load_module(void)
+{
+       if (ast_sorcery_wizard_register(&memory_object_wizard)) {
+               return AST_MODULE_LOAD_DECLINE;
+       }
+
+       return AST_MODULE_LOAD_SUCCESS;
+}
+
+static int unload_module(void)
+{
+       ast_sorcery_wizard_unregister(&memory_object_wizard);
+       return 0;
+}
+
+AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "Sorcery In-Memory Object Wizard",
+       .load = load_module,
+       .unload = unload_module,
+       .load_pri = AST_MODPRI_CHANNEL_DEPEND,
+);
diff --git a/tests/test_sorcery.c b/tests/test_sorcery.c
new file mode 100644 (file)
index 0000000..6622102
--- /dev/null
@@ -0,0 +1,1950 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2012 - 2013, Digium, Inc.
+ *
+ * Joshua Colp <jcolp@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*!
+ * \file
+ * \brief Sorcery Unit Tests
+ *
+ * \author Joshua Colp <jcolp@digium.com>
+ *
+ */
+
+/*** MODULEINFO
+       <depend>TEST_FRAMEWORK</depend>
+       <support_level>core</support_level>
+ ***/
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "")
+
+#include "asterisk/test.h"
+#include "asterisk/module.h"
+#include "asterisk/sorcery.h"
+#include "asterisk/logger.h"
+
+/*! \brief Dummy sorcery object */
+struct test_sorcery_object {
+       SORCERY_OBJECT(details);
+       unsigned int bob;
+       unsigned int joe;
+};
+
+/*! \brief Internal function to allocate a test object */
+static void *test_sorcery_object_alloc(const char *id)
+{
+       return ao2_alloc(sizeof(struct test_sorcery_object), NULL);
+}
+
+/*! \brief Internal function for object set transformation */
+static struct ast_variable *test_sorcery_transform(struct ast_variable *set)
+{
+       struct ast_variable *field, *transformed = NULL;
+
+       for (field = set; field; field = field->next) {
+               struct ast_variable *transformed_field;
+
+               if (!strcmp(field->name, "joe")) {
+                       transformed_field = ast_variable_new(field->name, "5000", "");
+               } else {
+                       transformed_field = ast_variable_new(field->name, field->value, "");
+               }
+
+               if (!transformed_field) {
+                       ast_variables_destroy(transformed);
+                       return NULL;
+               }
+
+               transformed_field->next = transformed;
+               transformed = transformed_field;
+       }
+
+       return transformed;
+}
+
+/*! \brief Test structure for caching */
+struct sorcery_test_caching {
+       /*! \brief Whether the object has been created in the cache or not */
+       unsigned int created:1;
+
+       /*! \brief Whether the object has been updated in the cache or not */
+       unsigned int updated:1;
+
+       /*! \brief Whether the object has been deleted from the cache or not */
+       unsigned int deleted:1;
+
+       /*! \brief Object to return when asked */
+       struct test_sorcery_object object;
+};
+
+/*! \brief Global scope caching structure for testing */
+static struct sorcery_test_caching cache = { 0, };
+
+static int sorcery_test_create(void *data, void *object)
+{
+       cache.created = 1;
+       cache.updated = 0;
+       cache.deleted = 0;
+       return 0;
+}
+
+static void *sorcery_test_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id)
+{
+       return (cache.created && !cache.deleted) ? ast_sorcery_alloc(sorcery, type, id) : NULL;
+}
+
+static int sorcery_test_update(void *data, void *object)
+{
+       cache.updated = 1;
+       return 0;
+}
+
+static int sorcery_test_delete(void *data, void *object)
+{
+       cache.deleted = 1;
+       return 0;
+}
+
+/*! \brief Dummy sorcery wizard, not actually used so we only populate the name and nothing else */
+static struct ast_sorcery_wizard test_wizard = {
+       .name = "test",
+       .create = sorcery_test_create,
+       .retrieve_id = sorcery_test_retrieve_id,
+       .update = sorcery_test_update,
+       .delete = sorcery_test_delete,
+};
+
+static struct ast_sorcery *alloc_and_initialize_sorcery(void)
+{
+       struct ast_sorcery *sorcery;
+
+        if (!(sorcery = ast_sorcery_open())) {
+               return NULL;
+        }
+
+        if (ast_sorcery_apply_default(sorcery, "test", "memory", NULL) ||
+           ast_sorcery_object_register(sorcery, "test", test_sorcery_object_alloc, NULL, NULL)) {
+               ast_sorcery_unref(sorcery);
+               return NULL;
+        }
+
+        ast_sorcery_object_field_register(sorcery, "test", "bob", "5", OPT_UINT_T, 0, FLDSET(struct test_sorcery_object, bob));
+        ast_sorcery_object_field_register(sorcery, "test", "joe", "10", OPT_UINT_T, 0, FLDSET(struct test_sorcery_object, joe));
+
+       return sorcery;
+}
+
+AST_TEST_DEFINE(wizard_registration)
+{
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "wizard_registration";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery wizard registration and unregistration unit test";
+               info->description =
+                       "Test registration and unregistration of a sorcery wizard";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (ast_sorcery_wizard_register(&test_wizard)) {
+               ast_test_status_update(test, "Failed to register a perfectly valid sorcery wizard\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!ast_sorcery_wizard_register(&test_wizard)) {
+               ast_test_status_update(test, "Successfully registered a sorcery wizard twice, which is bad\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_wizard_unregister(&test_wizard)) {
+               ast_test_status_update(test, "Failed to unregister a perfectly valid sorcery wizard\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!ast_sorcery_wizard_unregister(&test_wizard)) {
+               ast_test_status_update(test, "Successfully unregistered a sorcery wizard twice, which is bad\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(open)
+{
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "open";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery open unit test";
+               info->description =
+                       "Test opening of sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(sorcery = ast_sorcery_open())) {
+               ast_test_status_update(test, "Failed to open new sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(apply_default)
+{
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "apply_default";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery default wizard unit test";
+               info->description =
+                       "Test setting default type wizard in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(sorcery = ast_sorcery_open())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!ast_sorcery_apply_default(sorcery, "test", "dummy", NULL)) {
+               ast_test_status_update(test, "Successfully set a default wizard that doesn't exist\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_apply_default(sorcery, "test", "memory", NULL)) {
+               ast_test_status_update(test, "Failed to set a known wizard as a default\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!ast_sorcery_apply_default(sorcery, "test", "memory", NULL)) {
+               ast_test_status_update(test, "Successfully set a default wizard on a type twice\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(apply_config)
+{
+       struct ast_flags flags = { CONFIG_FLAG_NOCACHE };
+       struct ast_config *config;
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "apply_config";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery object mapping configuration unit test";
+               info->description =
+                       "Test configured object mapping in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(config = ast_config_load2("sorcery.conf", "test_sorcery", flags))) {
+               ast_test_status_update(test, "Sorcery configuration file not present - skipping apply_config test\n");
+               return AST_TEST_NOT_RUN;
+       }
+
+       if (!ast_category_get(config, "test_sorcery")) {
+               ast_test_status_update(test, "Sorcery configuration file does not have test_sorcery section\n");
+               ast_config_destroy(config);
+               return AST_TEST_NOT_RUN;
+       }
+
+       ast_config_destroy(config);
+
+       if (!(sorcery = ast_sorcery_open())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_apply_config(sorcery, "test_sorcery")) {
+               ast_test_status_update(test, "Failed to apply configured object mappings\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(object_register)
+{
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_register";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery object type registration unit test";
+               info->description =
+                       "Test object type registration in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(sorcery = ast_sorcery_open())) {
+               ast_test_status_update(test, "Failed to open structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_apply_default(sorcery, "test", "memory", NULL)) {
+               ast_test_status_update(test, "Failed to set a known wizard as a default\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_object_register(sorcery, "test", test_sorcery_object_alloc, NULL, NULL)) {
+               ast_test_status_update(test, "Failed to register object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(object_register_without_mapping)
+{
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_register_without_mapping";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery object type registration (without mapping) unit test";
+               info->description =
+                       "Test object type registration when no mapping exists in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(sorcery = ast_sorcery_open())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!ast_sorcery_object_register(sorcery, "test", test_sorcery_object_alloc, NULL, NULL)) {
+               ast_test_status_update(test, "Registered object type when no object mapping exists\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(object_field_register)
+{
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_field_register";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery object field registration unit test";
+               info->description =
+                       "Test object field registration in sorcery with a provided id";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(sorcery = ast_sorcery_open())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!ast_sorcery_object_field_register(sorcery, "test", "bob", "5", OPT_UINT_T, 0, FLDSET(struct test_sorcery_object, bob))) {
+               ast_test_status_update(test, "Registered an object field successfully when no mappings or object types exist\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_apply_default(sorcery, "test", "memory", NULL)) {
+               ast_test_status_update(test, "Failed to set a known wizard as a default\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!ast_sorcery_object_field_register(sorcery, "test", "bob", "5", OPT_UINT_T, 0, FLDSET(struct test_sorcery_object, bob))) {
+               ast_test_status_update(test, "Registered an object field successfully when object type does not exist\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_object_register(sorcery, "test", test_sorcery_object_alloc, NULL, NULL)) {
+               ast_test_status_update(test, "Failed to register object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_object_field_register(sorcery, "test", "bob", "5", OPT_UINT_T, 0, FLDSET(struct test_sorcery_object, bob))) {
+               ast_test_status_update(test, "Could not successfully register object field when mapping and object type exists\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(object_alloc_with_id)
+{
+       int res = AST_TEST_PASS;
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct test_sorcery_object *, obj, NULL, ao2_cleanup);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_alloc_with_id";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery object allocation (with id) unit test";
+               info->description =
+                       "Test object allocation in sorcery with a provided id";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(sorcery = alloc_and_initialize_sorcery())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(obj = ast_sorcery_alloc(sorcery, "test", "blah"))) {
+               ast_test_status_update(test, "Failed to allocate a known object type\n");
+               res = AST_TEST_FAIL;
+       } else if (ast_strlen_zero(ast_sorcery_object_get_id(obj))) {
+               ast_test_status_update(test, "Allocated object has empty id when it should not\n");
+               res = AST_TEST_FAIL;
+       } else if (strcmp(ast_sorcery_object_get_id(obj), "blah")) {
+               ast_test_status_update(test, "Allocated object does not have correct id\n");
+               res = AST_TEST_FAIL;
+       } else if (ast_strlen_zero(ast_sorcery_object_get_type(obj))) {
+               ast_test_status_update(test, "Allocated object has empty type when it should not\n");
+               res = AST_TEST_FAIL;
+       } else if (strcmp(ast_sorcery_object_get_type(obj), "test")) {
+               ast_test_status_update(test, "Allocated object does not have correct type\n");
+               res = AST_TEST_FAIL;
+       } else if ((obj->bob != 5) || (obj->joe != 10)) {
+               ast_test_status_update(test, "Allocated object does not have defaults set as it should\n");
+               res = AST_TEST_FAIL;
+       }
+
+       return res;
+}
+
+AST_TEST_DEFINE(object_alloc_without_id)
+{
+       int res = AST_TEST_PASS;
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct test_sorcery_object *, obj, NULL, ao2_cleanup);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_alloc_without_id";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery object allocation (without id) unit test";
+               info->description =
+                       "Test object allocation in sorcery with no provided id";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(sorcery = alloc_and_initialize_sorcery())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(obj = ast_sorcery_alloc(sorcery, "test", NULL))) {
+               ast_test_status_update(test, "Failed to allocate a known object type\n");
+               res = AST_TEST_FAIL;
+       } else if (ast_strlen_zero(ast_sorcery_object_get_id(obj))) {
+               ast_test_status_update(test, "Allocated object has empty id when it should not\n");
+               res = AST_TEST_FAIL;
+       }
+
+       return res;
+}
+
+
+AST_TEST_DEFINE(object_copy)
+{
+       int res = AST_TEST_PASS;
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct test_sorcery_object *, obj, NULL, ao2_cleanup);
+       RAII_VAR(struct test_sorcery_object *, copy, NULL, ao2_cleanup);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_copy";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery object copy unit test";
+               info->description =
+                       "Test object copy in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(sorcery = alloc_and_initialize_sorcery())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(obj = ast_sorcery_alloc(sorcery, "test", "blah"))) {
+               ast_test_status_update(test, "Failed to allocate a known object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       obj->bob = 50;
+       obj->joe = 100;
+
+       if (!(copy = ast_sorcery_copy(sorcery, obj))) {
+               ast_test_status_update(test, "Failed to create a copy of a known valid object\n");
+               res = AST_TEST_FAIL;
+       } else if (copy == obj) {
+               ast_test_status_update(test, "Created copy is actually the original object\n");
+               res = AST_TEST_FAIL;
+       } else if (copy->bob != obj->bob) {
+               ast_test_status_update(test, "Value of 'bob' on newly created copy is not the same as original\n");
+               res = AST_TEST_FAIL;
+       } else if (copy->joe != obj->joe) {
+               ast_test_status_update(test, "Value of 'joe' on newly created copy is not the same as original\n");
+               res = AST_TEST_FAIL;
+       }
+
+       return res;
+}
+
+AST_TEST_DEFINE(object_diff)
+{
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct test_sorcery_object *, obj1, NULL, ao2_cleanup);
+       RAII_VAR(struct test_sorcery_object *, obj2, NULL, ao2_cleanup);
+       RAII_VAR(struct ast_variable *, changes, NULL, ast_variables_destroy);
+       struct ast_variable *field;
+       int res = AST_TEST_PASS;
+
+       switch (cmd) {
+       case TEST_INIT:
+              info->name = "object_diff";
+              info->category = "/main/sorcery/";
+              info->summary = "sorcery object diff unit test";
+              info->description =
+                      "Test object diffing in sorcery";
+              return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+              break;
+       }
+
+       if (!(sorcery = alloc_and_initialize_sorcery())) {
+              ast_test_status_update(test, "Failed to open sorcery structure\n");
+              return AST_TEST_FAIL;
+       }
+
+       if (!(obj1 = ast_sorcery_alloc(sorcery, "test", "blah"))) {
+              ast_test_status_update(test, "Failed to allocate a known object type\n");
+              return AST_TEST_FAIL;
+       }
+
+       obj1->bob = 99;
+       obj1->joe = 55;
+
+       if (!(obj2 = ast_sorcery_alloc(sorcery, "test", "blah2"))) {
+              ast_test_status_update(test, "Failed to allocate a second known object type\n");
+              return AST_TEST_FAIL;
+       }
+
+       obj2->bob = 99;
+       obj2->joe = 42;
+
+       if (ast_sorcery_diff(sorcery, obj1, obj2, &changes)) {
+              ast_test_status_update(test, "Failed to diff obj1 and obj2\n");
+       } else if (!changes) {
+              ast_test_status_update(test, "Failed to produce a diff of two objects, despite there being differences\n");
+              return AST_TEST_FAIL;
+       }
+
+       for (field = changes; field; field = field->next) {
+              if (!strcmp(field->name, "joe")) {
+                      if (strcmp(field->value, "42")) {
+                              ast_test_status_update(test, "Object diff produced unexpected value '%s' for joe\n", field->value);
+                              res = AST_TEST_FAIL;
+                      }
+              } else {
+                      ast_test_status_update(test, "Object diff produced unexpected field '%s'\n", field->name);
+                      res = AST_TEST_FAIL;
+              }
+       }
+
+       return res;
+}
+
+AST_TEST_DEFINE(objectset_create)
+{
+       int res = AST_TEST_PASS;
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct test_sorcery_object *, obj, NULL, ao2_cleanup);
+       RAII_VAR(struct ast_variable *, objset, NULL, ast_variables_destroy);
+       struct ast_variable *field;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "objectset_create";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery object set creation unit test";
+               info->description =
+                       "Test object set creation in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(sorcery = alloc_and_initialize_sorcery())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(obj = ast_sorcery_alloc(sorcery, "test", "blah"))) {
+               ast_test_status_update(test, "Failed to allocate a known object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(objset = ast_sorcery_objectset_create(sorcery, obj))) {
+               ast_test_status_update(test, "Failed to create an object set for a known sane object\n");
+               return AST_TEST_FAIL;
+       }
+
+       for (field = objset; field; field = field->next) {
+               if (!strcmp(field->name, "bob")) {
+                       if (strcmp(field->value, "5")) {
+                               ast_test_status_update(test, "Object set failed to create proper value for 'bob'\n");
+                               res = AST_TEST_FAIL;
+                       }
+               } else if (!strcmp(field->name, "joe")) {
+                       if (strcmp(field->value, "10")) {
+                               ast_test_status_update(test, "Object set failed to create proper value for 'joe'\n");
+                               res = AST_TEST_FAIL;
+                       }
+               } else {
+                       ast_test_status_update(test, "Object set created field '%s' which is unknown\n", field->name);
+                       res = AST_TEST_FAIL;
+               }
+       }
+
+       return res;
+}
+
+AST_TEST_DEFINE(objectset_apply)
+{
+       int res = AST_TEST_PASS;
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct test_sorcery_object *, obj, NULL, ao2_cleanup);
+       RAII_VAR(struct ast_variable *, objset, NULL, ast_variables_destroy);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "objectset_apply";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery object apply unit test";
+               info->description =
+                       "Test object set applying in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(sorcery = alloc_and_initialize_sorcery())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(obj = ast_sorcery_alloc(sorcery, "test", "blah"))) {
+               ast_test_status_update(test, "Failed to allocate a known object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(objset = ast_variable_new("joe", "25", ""))) {
+               ast_test_status_update(test, "Failed to create an object set, test could not occur\n");
+               res = AST_TEST_FAIL;
+       } else if (ast_sorcery_objectset_apply(sorcery, obj, objset)) {
+               ast_test_status_update(test, "Failed to apply valid object set to object\n");
+               res = AST_TEST_FAIL;
+       } else if (obj->joe != 25) {
+               ast_test_status_update(test, "Object set was not actually applied to object despite it returning success\n");
+               res = AST_TEST_FAIL;
+       }
+
+       return res;
+}
+
+AST_TEST_DEFINE(objectset_apply_invalid)
+{
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct test_sorcery_object *, obj, NULL, ao2_cleanup);
+       RAII_VAR(struct ast_variable *, objset, NULL, ast_variables_destroy);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "objectset_apply_invalid";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery object invalid apply unit test";
+               info->description =
+                       "Test object set applying of an invalid set in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(sorcery = alloc_and_initialize_sorcery())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(obj = ast_sorcery_alloc(sorcery, "test", "blah"))) {
+               ast_test_status_update(test, "Failed to allocate a known object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(objset = ast_variable_new("fred", "99", ""))) {
+               ast_test_status_update(test, "Failed to create an object set, test could not occur\n");
+               return AST_TEST_FAIL;
+       } else if (!ast_sorcery_objectset_apply(sorcery, obj, objset)) {
+               ast_test_status_update(test, "Successfully applied an invalid object set\n");
+               return AST_TEST_FAIL;
+       } else if ((obj->bob != 5) || (obj->joe != 10)) {
+               ast_test_status_update(test, "Object set modified object fields when it should not have\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(objectset_transform)
+{
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct test_sorcery_object *, obj, NULL, ao2_cleanup);
+       RAII_VAR(struct ast_variable *, objset, NULL, ast_variables_destroy);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "objectset_transform";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery object set transformation unit test";
+               info->description =
+                       "Test object set transformation in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(sorcery = ast_sorcery_open())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_apply_default(sorcery, "test", "memory", NULL)) {
+               ast_test_status_update(test, "Failed to set a known wizard as a default\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_object_register(sorcery, "test", test_sorcery_object_alloc, test_sorcery_transform, NULL)) {
+               ast_test_status_update(test, "Failed to register object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       ast_sorcery_object_field_register(sorcery, "test", "bob", "5", OPT_UINT_T, 0, FLDSET(struct test_sorcery_object, bob));
+       ast_sorcery_object_field_register(sorcery, "test", "joe", "10", OPT_UINT_T, 0, FLDSET(struct test_sorcery_object, joe));
+
+       if (!(obj = ast_sorcery_alloc(sorcery, "test", "blah"))) {
+               ast_test_status_update(test, "Failed to allocate a known object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(objset = ast_sorcery_objectset_create(sorcery, obj))) {
+               ast_test_status_update(test, "Failed to create an object set for a known sane object\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_objectset_apply(sorcery, obj, objset)) {
+               ast_test_status_update(test, "Failed to apply properly created object set against object\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (obj->bob != 5) {
+               ast_test_status_update(test, "Application of object set produced incorrect value on 'bob'\n");
+               return AST_TEST_FAIL;
+       } else if (obj->joe == 10) {
+               ast_test_status_update(test, "Transformation callback did not change value of 'joe' from provided value\n");
+               return AST_TEST_FAIL;
+       } else if (obj->joe != 5000) {
+               ast_test_status_update(test, "Value of 'joe' differs from default AND from transformation value\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(changeset_create)
+{
+       int res = AST_TEST_PASS;
+       RAII_VAR(struct ast_variable *, original, NULL, ast_variables_destroy);
+       RAII_VAR(struct ast_variable *, modified, NULL, ast_variables_destroy);
+       RAII_VAR(struct ast_variable *, changes, NULL, ast_variables_destroy);
+       struct ast_variable *tmp;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "changeset_create";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery changeset creation unit test";
+               info->description =
+                       "Test changeset creation in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(tmp = ast_variable_new("bananas", "purple", ""))) {
+               ast_test_status_update(test, "Failed to create first field for original objectset\n");
+               return AST_TEST_FAIL;
+       }
+       tmp->next = original;
+       original = tmp;
+
+       if (!(tmp = ast_variable_new("apples", "orange", ""))) {
+               ast_test_status_update(test, "Failed to create second field for original objectset\n");
+               return AST_TEST_FAIL;
+       }
+       tmp->next = original;
+       original = tmp;
+
+       if (!(tmp = ast_variable_new("bananas", "green", ""))) {
+               ast_test_status_update(test, "Failed to create first field for modified objectset\n");
+               return AST_TEST_FAIL;
+       }
+       tmp->next = modified;
+       modified = tmp;
+
+       if (!(tmp = ast_variable_new("apples", "orange", ""))) {
+               ast_test_status_update(test, "Failed to create second field for modified objectset\n");
+               return AST_TEST_FAIL;
+       }
+       tmp->next = modified;
+       modified = tmp;
+
+       if (ast_sorcery_changeset_create(original, modified, &changes)) {
+               ast_test_status_update(test, "Failed to create a changeset due to an error\n");
+               return AST_TEST_FAIL;
+       } else if (!changes) {
+               ast_test_status_update(test, "Failed to produce a changeset when there should be one\n");
+               return AST_TEST_FAIL;
+       }
+
+       for (tmp = changes; tmp; tmp = tmp->next) {
+               if (!strcmp(tmp->name, "bananas")) {
+                       if (strcmp(tmp->value, "green")) {
+                               ast_test_status_update(test, "Changeset produced had unexpected value '%s' for bananas\n", tmp->value);
+                               res = AST_TEST_FAIL;
+                       }
+               } else {
+                       ast_test_status_update(test, "Changeset produced had unexpected field '%s'\n", tmp->name);
+                       res = AST_TEST_FAIL;
+               }
+       }
+
+       return res;
+}
+
+AST_TEST_DEFINE(changeset_create_unchanged)
+{
+       RAII_VAR(struct ast_variable *, original, NULL, ast_variables_destroy);
+       RAII_VAR(struct ast_variable *, changes, NULL, ast_variables_destroy);
+       RAII_VAR(struct ast_variable *, same, NULL, ast_variables_destroy);
+       struct ast_variable *tmp;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "changeset_create_unchanged";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery changeset creation unit test when no changes exist";
+               info->description =
+                       "Test changeset creation in sorcery when no changes actually exist";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(tmp = ast_variable_new("bananas", "purple", ""))) {
+               ast_test_status_update(test, "Failed to create first field for original objectset\n");
+               return AST_TEST_FAIL;
+       }
+       tmp->next = original;
+       original = tmp;
+
+       if (!(tmp = ast_variable_new("apples", "orange", ""))) {
+               ast_test_status_update(test, "Failed to create second field for original objectset\n");
+               return AST_TEST_FAIL;
+       }
+       tmp->next = original;
+       original = tmp;
+
+       if (ast_sorcery_changeset_create(original, original, &changes)) {
+               ast_test_status_update(test, "Failed to create a changeset due to an error\n");
+               return AST_TEST_FAIL;
+       } else if (changes) {
+               ast_test_status_update(test, "Created a changeset when no changes actually exist\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(tmp = ast_variable_new("bananas", "purple", ""))) {
+               ast_test_status_update(test, "Failed to create first field for same objectset\n");
+               return AST_TEST_FAIL;
+       }
+       tmp->next = same;
+       same = tmp;
+
+       if (!(tmp = ast_variable_new("apples", "orange", ""))) {
+               ast_test_status_update(test, "Failed to create second field for same objectset\n");
+               return AST_TEST_FAIL;
+       }
+       tmp->next = same;
+       same = tmp;
+
+       if (ast_sorcery_changeset_create(original, same, &changes)) {
+               ast_test_status_update(test, "Failed to create a changeset due to an error\n");
+               return AST_TEST_FAIL;
+       } else if (changes) {
+               ast_test_status_update(test, "Created a changeset between two different objectsets when no changes actually exist\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(object_create)
+{
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct test_sorcery_object *, obj, NULL, ao2_cleanup);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_create";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery object creation unit test";
+               info->description =
+                       "Test object creation in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(sorcery = alloc_and_initialize_sorcery())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(obj = ast_sorcery_alloc(sorcery, "test", "blah"))) {
+               ast_test_status_update(test, "Failed to allocate a known object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_create(sorcery, obj)) {
+               ast_test_status_update(test, "Failed to create object using in-memory wizard\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(object_retrieve_id)
+{
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct test_sorcery_object *, obj, NULL, ao2_cleanup);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_retrieve_id";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery object retrieval using id unit test";
+               info->description =
+                       "Test object retrieval using id in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(sorcery = alloc_and_initialize_sorcery())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(obj = ast_sorcery_alloc(sorcery, "test", "blah"))) {
+               ast_test_status_update(test, "Failed to allocate a known object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_create(sorcery, obj)) {
+               ast_test_status_update(test, "Failed to create object using in-memory wizard\n");
+               return AST_TEST_FAIL;
+       }
+
+       ao2_cleanup(obj);
+
+       if (!(obj = ast_sorcery_alloc(sorcery, "test", "blah2"))) {
+               ast_test_status_update(test, "Failed to allocate second instance of a known object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_create(sorcery, obj)) {
+               ast_test_status_update(test, "Failed to create second object using in-memory wizard\n");
+               return AST_TEST_FAIL;
+       }
+
+       ao2_cleanup(obj);
+
+       if (!(obj = ast_sorcery_retrieve_by_id(sorcery, "test", "blah"))) {
+               ast_test_status_update(test, "Failed to retrieve properly created object using id of 'blah'\n");
+               return AST_TEST_FAIL;
+       } else if (strcmp(ast_sorcery_object_get_id(obj), "blah")) {
+               ast_test_status_update(test, "Retrieved object does not have correct id\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(object_retrieve_field)
+{
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct test_sorcery_object *, obj, NULL, ao2_cleanup);
+       RAII_VAR(struct ast_variable *, fields, ast_variable_new("joe", "42", ""), ast_variables_destroy);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_retrieve_field";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery object retrieval using a specific field unit test";
+               info->description =
+                       "Test object retrieval using a specific field in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!fields) {
+               ast_test_status_update(test, "Failed to create fields for object retrieval attempt\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(sorcery = alloc_and_initialize_sorcery())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(obj = ast_sorcery_alloc(sorcery, "test", "blah"))) {
+               ast_test_status_update(test, "Failed to allocate a known object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       obj->joe = 42;
+
+       if (ast_sorcery_create(sorcery, obj)) {
+               ast_test_status_update(test, "Failed to create object using in-memory wizard\n");
+               return AST_TEST_FAIL;
+       }
+
+       ao2_cleanup(obj);
+
+       if (!(obj = ast_sorcery_retrieve_by_fields(sorcery, "test", AST_RETRIEVE_FLAG_DEFAULT, fields))) {
+               ast_test_status_update(test, "Failed to retrieve properly created object using 'joe' field\n");
+               return AST_TEST_FAIL;
+       }
+
+       ao2_cleanup(obj);
+       ast_variables_destroy(fields);
+
+       if (!(fields = ast_variable_new("joe", "49", ""))) {
+               ast_test_status_update(test, "Failed to create fields for object retrieval attempt\n");
+               return AST_TEST_FAIL;
+       }
+
+       if ((obj = ast_sorcery_retrieve_by_fields(sorcery, "test", AST_RETRIEVE_FLAG_DEFAULT, fields))) {
+               ast_test_status_update(test, "Retrieved an object using a field with an in-correct value... that should not happen\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(object_retrieve_multiple_all)
+{
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct test_sorcery_object *, obj, NULL, ao2_cleanup);
+       RAII_VAR(struct ao2_container *, objects, NULL, ao2_cleanup);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_retrieve_multiple_all";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery multiple object retrieval unit test";
+               info->description =
+                       "Test multiple object retrieval in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(sorcery = alloc_and_initialize_sorcery())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(obj = ast_sorcery_alloc(sorcery, "test", "blah"))) {
+               ast_test_status_update(test, "Failed to allocate a known object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_create(sorcery, obj)) {
+               ast_test_status_update(test, "Failed to create object using in-memory wizard\n");
+               return AST_TEST_FAIL;
+       }
+
+       ao2_cleanup(obj);
+
+       if (!(obj = ast_sorcery_alloc(sorcery, "test", "blah2"))) {
+               ast_test_status_update(test, "Failed to allocate second instance of a known object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_create(sorcery, obj)) {
+               ast_test_status_update(test, "Failed to create second object using in-memory wizard\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(objects = ast_sorcery_retrieve_by_fields(sorcery, "test", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL))) {
+               ast_test_status_update(test, "Failed to retrieve a container of all objects\n");
+               return AST_TEST_FAIL;
+       } else if (ao2_container_count(objects) != 2) {
+               ast_test_status_update(test, "Received a container with no objects in it when there should be some\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(object_retrieve_multiple_field)
+{
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct test_sorcery_object *, obj, NULL, ao2_cleanup);
+       RAII_VAR(struct ao2_container *, objects, NULL, ao2_cleanup);
+       RAII_VAR(struct ast_variable *, fields, ast_variable_new("joe", "6", ""), ast_variables_destroy);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_retrieve_multiple_field";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery multiple object retrieval unit test";
+               info->description =
+                       "Test multiple object retrieval in sorcery using fields";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!fields) {
+               ast_test_status_update(test, "Failed to create fields for multiple retrieve\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(sorcery = alloc_and_initialize_sorcery())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(obj = ast_sorcery_alloc(sorcery, "test", "blah"))) {
+               ast_test_status_update(test, "Failed to allocate a known object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       obj->joe = 6;
+
+       if (ast_sorcery_create(sorcery, obj)) {
+               ast_test_status_update(test, "Failed to create object using in-memory wizard\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(objects = ast_sorcery_retrieve_by_fields(sorcery, "test", AST_RETRIEVE_FLAG_MULTIPLE, fields))) {
+               ast_test_status_update(test, "Failed to retrieve a container of all objects\n");
+               return AST_TEST_FAIL;
+       } else if (ao2_container_count(objects) != 1) {
+               ast_test_status_update(test, "Received a container with no objects in it when there should be some\n");
+               return AST_TEST_FAIL;
+       }
+
+       ao2_cleanup(objects);
+       ast_variables_destroy(fields);
+
+       if (!(fields = ast_variable_new("joe", "7", ""))) {
+               ast_test_status_update(test, "Failed to create fields for multiple retrieval\n");
+               return AST_TEST_FAIL;
+       } else if (!(objects = ast_sorcery_retrieve_by_fields(sorcery, "test", AST_RETRIEVE_FLAG_MULTIPLE, fields))) {
+               ast_test_status_update(test, "Failed to retrieve an empty container when retrieving multiple\n");
+               return AST_TEST_FAIL;
+       } else if (ao2_container_count(objects)) {
+               ast_test_status_update(test, "Received a container with objects when there should be none in it\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(object_update)
+{
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct test_sorcery_object *, obj, NULL, ao2_cleanup);
+       RAII_VAR(struct test_sorcery_object *, obj2, NULL, ao2_cleanup);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_update";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery object update unit test";
+               info->description =
+                       "Test object updating in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(sorcery = alloc_and_initialize_sorcery())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(obj = ast_sorcery_alloc(sorcery, "test", "blah"))) {
+               ast_test_status_update(test, "Failed to allocate a known object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_create(sorcery, obj)) {
+               ast_test_status_update(test, "Failed to create object using in-memory wizard\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(obj2 = ast_sorcery_copy(sorcery, obj))) {
+               ast_test_status_update(test, "Failed to allocate a known object type for updating\n");
+               return AST_TEST_FAIL;
+       }
+
+       ao2_cleanup(obj);
+
+       if (ast_sorcery_update(sorcery, obj2)) {
+               ast_test_status_update(test, "Failed to update sorcery with new object\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(obj = ast_sorcery_retrieve_by_id(sorcery, "test", "blah"))) {
+               ast_test_status_update(test, "Failed to retrieve properly updated object\n");
+               return AST_TEST_FAIL;
+       } else if (obj != obj2) {
+               ast_test_status_update(test, "Object retrieved is not the updated object\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(object_update_uncreated)
+{
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct test_sorcery_object *, obj, NULL, ao2_cleanup);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_update_uncreated";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery object update unit test";
+               info->description =
+                       "Test updating of an uncreated object in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(sorcery = alloc_and_initialize_sorcery())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(obj = ast_sorcery_alloc(sorcery, "test", "blah"))) {
+               ast_test_status_update(test, "Failed to allocate a known object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!ast_sorcery_update(sorcery, obj)) {
+               ast_test_status_update(test, "Successfully updated an object which has not been created yet\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(object_delete)
+{
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct test_sorcery_object *, obj, NULL, ao2_cleanup);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_delete";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery object deletion unit test";
+               info->description =
+                       "Test object deletion in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(sorcery = alloc_and_initialize_sorcery())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(obj = ast_sorcery_alloc(sorcery, "test", "blah"))) {
+               ast_test_status_update(test, "Failed to allocate a known object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_create(sorcery, obj)) {
+               ast_test_status_update(test, "Failed to create object using in-memory wizard\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_delete(sorcery, obj)) {
+               ast_test_status_update(test, "Failed to delete object using in-memory wizard\n");
+               return AST_TEST_FAIL;
+       }
+
+       ao2_cleanup(obj);
+
+       if ((obj = ast_sorcery_retrieve_by_id(sorcery, "test", "blah"))) {
+               ast_test_status_update(test, "Retrieved deleted object that should not be there\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(object_delete_uncreated)
+{
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct test_sorcery_object *, obj, NULL, ao2_cleanup);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_delete_uncreated";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery object deletion unit test";
+               info->description =
+                       "Test object deletion of an uncreated object in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(sorcery = alloc_and_initialize_sorcery())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(obj = ast_sorcery_alloc(sorcery, "test", "blah"))) {
+               ast_test_status_update(test, "Failed to allocate a known object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!ast_sorcery_delete(sorcery, obj)) {
+               ast_test_status_update(test, "Successfully deleted an object which was never created\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(caching_wizard_behavior)
+{
+       struct ast_flags flags = { CONFIG_FLAG_NOCACHE };
+       struct ast_config *config;
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct test_sorcery_object *, obj, NULL, ao2_cleanup);
+       RAII_VAR(struct test_sorcery_object *, obj2, NULL, ao2_cleanup);
+       int res = AST_TEST_FAIL;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "caching_wizard_behavior";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery caching wizard behavior unit test";
+               info->description =
+                       "Test internal behavior of caching wizards";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(config = ast_config_load2("sorcery.conf", "test_sorcery_cache", flags))) {
+               ast_test_status_update(test, "Sorcery configuration file not present - skipping caching_wizard_behavior test\n");
+               return AST_TEST_NOT_RUN;
+       }
+
+       if (!ast_category_get(config, "test_sorcery_cache")) {
+               ast_test_status_update(test, "Sorcery configuration file does not contain 'test_sorcery_cache' section\n");
+               ast_config_destroy(config);
+               return AST_TEST_NOT_RUN;
+       }
+
+       ast_config_destroy(config);
+
+       if (ast_sorcery_wizard_register(&test_wizard)) {
+               ast_test_status_update(test, "Failed to register a perfectly valid sorcery wizard\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(sorcery = ast_sorcery_open())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               goto end;
+       }
+
+       if (ast_sorcery_apply_config(sorcery, "test_sorcery_cache")) {
+               ast_test_status_update(test, "Failed to apply configured object mappings\n");
+               goto end;
+       }
+
+       if (ast_sorcery_object_register(sorcery, "test", test_sorcery_object_alloc, NULL, NULL)) {
+               ast_test_status_update(test, "Failed to register object type\n");
+               goto end;
+       }
+
+       if (!(obj = ast_sorcery_alloc(sorcery, "test", "blah"))) {
+               ast_test_status_update(test, "Failed to allocate a known object type\n");
+               goto end;
+       }
+
+       if (ast_sorcery_create(sorcery, obj)) {
+               ast_test_status_update(test, "Failed to create object using in-memory wizard\n");
+               goto end;
+       }
+
+       ao2_cleanup(obj);
+
+       if (!(obj = ast_sorcery_retrieve_by_id(sorcery, "test", "blah"))) {
+               ast_test_status_update(test, "Failed to retrieve just created object\n");
+               goto end;
+       } else if (!cache.created) {
+               ast_test_status_update(test, "Caching wizard was not told to cache just created object\n");
+               goto end;
+       } else if (!(obj2 = ast_sorcery_retrieve_by_id(sorcery, "test", "blah"))) {
+               ast_test_status_update(test, "Failed to retrieve just cached object\n");
+               goto end;
+       } else if (obj == obj2) {
+               ast_test_status_update(test, "Returned object is *NOT* a cached object\n");
+               goto end;
+       } else if (ast_sorcery_update(sorcery, obj)) {
+               ast_test_status_update(test, "Failed to update a known stored object\n");
+               goto end;
+       } else if (!cache.updated) {
+               ast_test_status_update(test, "Caching wizard was not told to update object\n");
+               goto end;
+       } else if (ast_sorcery_delete(sorcery, obj)) {
+               ast_test_status_update(test, "Failed to delete a known stored object\n");
+               goto end;
+       } else if (!cache.deleted) {
+               ast_test_status_update(test, "Caching wizard was not told to delete object\n");
+               goto end;
+       }
+
+       ao2_cleanup(obj2);
+
+       if ((obj2 = ast_sorcery_retrieve_by_id(sorcery, "test", "blah"))) {
+               ast_test_status_update(test, "Retrieved an object that should have been deleted\n");
+               goto end;
+       }
+
+       res = AST_TEST_PASS;
+
+end:
+       ast_sorcery_unref(sorcery);
+       sorcery = NULL;
+
+       if (ast_sorcery_wizard_unregister(&test_wizard)) {
+               ast_test_status_update(test, "Failed to unregister test sorcery wizard\n");
+               return AST_TEST_FAIL;
+       }
+
+       return res;
+}
+
+AST_TEST_DEFINE(configuration_file_wizard)
+{
+       struct ast_flags flags = { CONFIG_FLAG_NOCACHE };
+       struct ast_config *config;
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct test_sorcery_object *, obj, NULL, ao2_cleanup);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "configuration_file_wizard";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery configuration file wizard unit test";
+               info->description =
+                       "Test the configuration file wizard in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(config = ast_config_load2("test_sorcery.conf", "test_sorcery", flags))) {
+               ast_test_status_update(test, "Test sorcery configuration file wizard file not present - skipping configuration_file_wizard test\n");
+               return AST_TEST_NOT_RUN;
+       }
+
+       ast_config_destroy(config);
+
+       if (!(sorcery = ast_sorcery_open())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_apply_default(sorcery, "test", "config", "test_sorcery.conf")) {
+               ast_test_status_update(test, "Could not set a default wizard of the 'config' type, so skipping since it may not be loaded\n");
+               return AST_TEST_NOT_RUN;
+       }
+
+       if (ast_sorcery_object_register(sorcery, "test", test_sorcery_object_alloc, NULL, NULL)) {
+               ast_test_status_update(test, "Failed to register object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       ast_sorcery_object_field_register(sorcery, "test", "bob", "5", OPT_UINT_T, 0, FLDSET(struct test_sorcery_object, bob));
+       ast_sorcery_object_field_register(sorcery, "test", "joe", "10", OPT_UINT_T, 0, FLDSET(struct test_sorcery_object, joe));
+
+       ast_sorcery_load(sorcery);
+
+       if ((obj = ast_sorcery_retrieve_by_id(sorcery, "test", "hey2"))) {
+               ast_test_status_update(test, "Retrieved object which has an unknown field\n");
+               return AST_TEST_FAIL;
+       } else if (!(obj = ast_sorcery_retrieve_by_id(sorcery, "test", "hey"))) {
+               ast_test_status_update(test, "Failed to retrieve a known object that has been configured in the configuration file\n");
+               return AST_TEST_FAIL;
+       } else if (obj->bob != 98) {
+               ast_test_status_update(test, "Value of 'bob' on object is not what is configured in configuration file\n");
+               return AST_TEST_FAIL;
+       } else if (obj->joe != 41) {
+               ast_test_status_update(test, "Value of 'joe' on object is not what is configured in configuration file\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(configuration_file_wizard_with_file_integrity)
+{
+       struct ast_flags flags = { CONFIG_FLAG_NOCACHE };
+       struct ast_config *config;
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct test_sorcery_object *, obj, NULL, ao2_cleanup);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "configuration_file_wizard_with_file_integrity";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery configuration file wizard file integrity unit test";
+               info->description =
+                       "Test the configuration file wizard with file integrity turned on in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(config = ast_config_load2("test_sorcery.conf", "test_sorcery", flags))) {
+               ast_test_status_update(test, "Test sorcery configuration file wizard file not present - skipping configuration_file_wizard_with_file_integrity test\n");
+               return AST_TEST_NOT_RUN;
+       }
+
+       ast_config_destroy(config);
+
+       if (!(sorcery = ast_sorcery_open())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_apply_default(sorcery, "test", "config", "test_sorcery.conf,integrity=file")) {
+               ast_test_status_update(test, "Could not set a default wizard of the 'config' type, so skipping since it may not be loaded\n");
+               return AST_TEST_NOT_RUN;
+       }
+
+       if (ast_sorcery_object_register(sorcery, "test", test_sorcery_object_alloc, NULL, NULL)) {
+               ast_test_status_update(test, "Failed to register object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       ast_sorcery_object_field_register(sorcery, "test", "bob", "5", OPT_UINT_T, 0, FLDSET(struct test_sorcery_object, bob));
+       ast_sorcery_object_field_register(sorcery, "test", "joe", "10", OPT_UINT_T, 0, FLDSET(struct test_sorcery_object, joe));
+
+       ast_sorcery_load(sorcery);
+
+       if ((obj = ast_sorcery_retrieve_by_id(sorcery, "test", "hey"))) {
+               ast_test_status_update(test, "Retrieved object which has an unknown field\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(configuration_file_wizard_with_criteria)
+{
+       struct ast_flags flags = { CONFIG_FLAG_NOCACHE };
+       struct ast_config *config;
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct test_sorcery_object *, obj, NULL, ao2_cleanup);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "configuration_file_wizard_with_criteria";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery configuration file wizard with criteria unit test";
+               info->description =
+                       "Test the configuration file wizard with criteria matching in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(config = ast_config_load2("test_sorcery.conf", "test_sorcery", flags))) {
+               ast_test_status_update(test, "Test sorcery configuration file wizard file not present - skipping configuration_file_wizard_with_criteria test\n");
+               return AST_TEST_NOT_RUN;
+       }
+
+       ast_config_destroy(config);
+
+       if (!(sorcery = ast_sorcery_open())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_apply_default(sorcery, "test", "config", "test_sorcery.conf,criteria=type=zombies")) {
+               ast_test_status_update(test, "Could not set a default wizard of the 'config' type, so skipping since it may not be loaded\n");
+               return AST_TEST_NOT_RUN;
+       }
+
+       if (ast_sorcery_object_register(sorcery, "test", test_sorcery_object_alloc, NULL, NULL)) {
+               ast_test_status_update(test, "Failed to register object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       ast_sorcery_object_field_register(sorcery, "test", "bob", "5", OPT_UINT_T, 0, FLDSET(struct test_sorcery_object, bob));
+       ast_sorcery_object_field_register(sorcery, "test", "joe", "10", OPT_UINT_T, 0, FLDSET(struct test_sorcery_object, joe));
+       ast_sorcery_object_field_register(sorcery, "test", "type", NULL, OPT_NOOP_T, 0, NULL);
+
+       ast_sorcery_load(sorcery);
+
+       if ((obj = ast_sorcery_retrieve_by_id(sorcery, "test", "hey"))) {
+               ast_test_status_update(test, "Retrieved object which did not match criteria\n");
+               return AST_TEST_FAIL;
+       } else if (!(obj = ast_sorcery_retrieve_by_id(sorcery, "test", "hey2"))) {
+               ast_test_status_update(test, "Failed to retrieve a known object which matches criteria\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(configuration_file_wizard_retrieve_field)
+{
+       struct ast_flags flags = { CONFIG_FLAG_NOCACHE };
+       struct ast_config *config;
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct test_sorcery_object *, obj, NULL, ao2_cleanup);
+       RAII_VAR(struct ast_variable *, fields, ast_variable_new("joe", "41", ""), ast_variables_destroy);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "configuration_file_wizard_retrieve_field";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery configuration file wizard field retrieval unit test";
+               info->description =
+                       "Test the configuration file wizard retrieval using field in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(config = ast_config_load2("test_sorcery.conf", "test_sorcery", flags))) {
+               ast_test_status_update(test, "Test sorcery configuration file wizard file not present - skipping configuration_file_wizard_retrieve_field test\n");
+               return AST_TEST_NOT_RUN;
+       }
+
+       ast_config_destroy(config);
+
+       if (!(sorcery = ast_sorcery_open())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_apply_default(sorcery, "test", "config", "test_sorcery.conf")) {
+               ast_test_status_update(test, "Could not set a default wizard of the 'config' type, so skipping since it may not be loaded\n");
+               return AST_TEST_NOT_RUN;
+       }
+
+       if (ast_sorcery_object_register(sorcery, "test", test_sorcery_object_alloc, NULL, NULL)) {
+               ast_test_status_update(test, "Failed to register object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       ast_sorcery_object_field_register(sorcery, "test", "bob", "5", OPT_UINT_T, 0, FLDSET(struct test_sorcery_object, bob));
+       ast_sorcery_object_field_register(sorcery, "test", "joe", "10", OPT_UINT_T, 0, FLDSET(struct test_sorcery_object, joe));
+
+       ast_sorcery_load(sorcery);
+
+       if (!(obj = ast_sorcery_retrieve_by_fields(sorcery, "test", AST_RETRIEVE_FLAG_DEFAULT, fields))) {
+               ast_test_status_update(test, "Failed to retrieve a known object that has been configured with the correct field\n");
+               return AST_TEST_FAIL;
+       } else if (strcmp(ast_sorcery_object_get_id(obj), "hey")) {
+               ast_test_status_update(test, "Retrieved object has incorrect object id of '%s'\n", ast_sorcery_object_get_id(obj));
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(configuration_file_wizard_retrieve_multiple)
+{
+       struct ast_flags flags = { CONFIG_FLAG_NOCACHE };
+       struct ast_config *config;
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct ao2_container *, objects, NULL, ao2_cleanup);
+       RAII_VAR(struct ast_variable *, fields, ast_variable_new("joe", "99", ""), ast_variables_destroy);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "configuration_file_wizard_retrieve_multiple";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery configuration file wizard multiple retrieval unit test";
+               info->description =
+                       "Test the configuration file wizard multiple retrieval in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(config = ast_config_load2("test_sorcery.conf", "test_sorcery", flags))) {
+               ast_test_status_update(test, "Test sorcery configuration file wizard file not present - skipping configuration_file_wizard_retrieve_multiple test\n");
+               return AST_TEST_NOT_RUN;
+       }
+
+       ast_config_destroy(config);
+
+       if (!fields) {
+               ast_test_status_update(test, "Failed to create fields for multiple retrieve\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (!(sorcery = ast_sorcery_open())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_apply_default(sorcery, "test", "config", "test_sorcery.conf")) {
+               ast_test_status_update(test, "Could not set a default wizard of the 'config' type, so skipping since it may not be loaded\n");
+               return AST_TEST_NOT_RUN;
+       }
+
+       if (ast_sorcery_object_register(sorcery, "test", test_sorcery_object_alloc, NULL, NULL)) {
+               ast_test_status_update(test, "Failed to register object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       ast_sorcery_object_field_register(sorcery, "test", "bob", "5", OPT_UINT_T, 0, FLDSET(struct test_sorcery_object, bob));
+       ast_sorcery_object_field_register(sorcery, "test", "joe", "10", OPT_UINT_T, 0, FLDSET(struct test_sorcery_object, joe));
+
+       ast_sorcery_load(sorcery);
+
+       if (!(objects = ast_sorcery_retrieve_by_fields(sorcery, "test", AST_RETRIEVE_FLAG_MULTIPLE, fields))) {
+               ast_test_status_update(test, "Failed to retrieve an empty container when retrieving multiple\n");
+               return AST_TEST_FAIL;
+       } else if (ao2_container_count(objects)) {
+               ast_test_status_update(test, "Received a container with objects when there should be none in it\n");
+               return AST_TEST_FAIL;
+       }
+
+       ao2_cleanup(objects);
+       ast_variables_destroy(fields);
+
+       if (!(fields = ast_variable_new("joe", "41", ""))) {
+               ast_test_status_update(test, "Failed to create fields for multiple retrieve\n");
+               return AST_TEST_FAIL;
+       } else if (!(objects = ast_sorcery_retrieve_by_fields(sorcery, "test", AST_RETRIEVE_FLAG_MULTIPLE, fields))) {
+               ast_test_status_update(test, "Failed to retrieve a container when retrieving multiple\n");
+               return AST_TEST_FAIL;
+       } else if (ao2_container_count(objects) != 1) {
+               ast_test_status_update(test, "Received a container with no objects in it when there should be\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(configuration_file_wizard_retrieve_multiple_all)
+{
+       struct ast_flags flags = { CONFIG_FLAG_NOCACHE };
+       struct ast_config *config;
+       RAII_VAR(struct ast_sorcery *, sorcery, NULL, ast_sorcery_unref);
+       RAII_VAR(struct ao2_container *, objects, NULL, ao2_cleanup);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "configuration_file_wizard_retrieve_multiple_all";
+               info->category = "/main/sorcery/";
+               info->summary = "sorcery configuration file wizard multiple retrieve all unit test";
+               info->description =
+                       "Test the configuration file wizard multiple retrieve all in sorcery";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       if (!(config = ast_config_load2("test_sorcery.conf", "test_sorcery", flags))) {
+               ast_test_status_update(test, "Test sorcery configuration file wizard file not present - skipping configuration_file_wizard_retrieve_multiple_all test\n");
+               return AST_TEST_NOT_RUN;
+       }
+
+       ast_config_destroy(config);
+
+       if (!(sorcery = ast_sorcery_open())) {
+               ast_test_status_update(test, "Failed to open sorcery structure\n");
+               return AST_TEST_FAIL;
+       }
+
+       if (ast_sorcery_apply_default(sorcery, "test", "config", "test_sorcery.conf")) {
+               ast_test_status_update(test, "Could not set a default wizard of the 'config' type, so skipping since it may not be loaded\n");
+               return AST_TEST_NOT_RUN;
+       }
+
+       if (ast_sorcery_object_register(sorcery, "test", test_sorcery_object_alloc, NULL, NULL)) {
+               ast_test_status_update(test, "Failed to register object type\n");
+               return AST_TEST_FAIL;
+       }
+
+       ast_sorcery_object_field_register(sorcery, "test", "bob", "5", OPT_UINT_T, 0, FLDSET(struct test_sorcery_object, bob));
+       ast_sorcery_object_field_register(sorcery, "test", "joe", "10", OPT_UINT_T, 0, FLDSET(struct test_sorcery_object, joe));
+
+       ast_sorcery_load(sorcery);
+
+       if (!(objects = ast_sorcery_retrieve_by_fields(sorcery, "test", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL))) {
+               ast_test_status_update(test, "Failed to retrieve a container with all objects when there should be one\n");
+               return AST_TEST_FAIL;
+       } else if (ao2_container_count(objects) != 2) {
+               ast_test_status_update(test, "Returned container does not have the correct number of objects in it\n");
+               return AST_TEST_FAIL;
+       }
+
+       return AST_TEST_PASS;
+}
+
+static int unload_module(void)
+{
+       AST_TEST_UNREGISTER(wizard_registration);
+       AST_TEST_UNREGISTER(open);
+       AST_TEST_UNREGISTER(apply_default);
+       AST_TEST_UNREGISTER(apply_config);
+       AST_TEST_UNREGISTER(object_register);
+       AST_TEST_UNREGISTER(object_register_without_mapping);
+       AST_TEST_UNREGISTER(object_field_register);
+       AST_TEST_UNREGISTER(object_alloc_with_id);
+       AST_TEST_UNREGISTER(object_alloc_without_id);
+       AST_TEST_UNREGISTER(object_copy);
+       AST_TEST_UNREGISTER(object_diff);
+       AST_TEST_UNREGISTER(objectset_create);
+       AST_TEST_UNREGISTER(objectset_apply);
+       AST_TEST_UNREGISTER(objectset_apply_invalid);
+       AST_TEST_UNREGISTER(objectset_transform);
+       AST_TEST_UNREGISTER(changeset_create);
+       AST_TEST_UNREGISTER(changeset_create_unchanged);
+       AST_TEST_UNREGISTER(object_create);
+       AST_TEST_UNREGISTER(object_retrieve_id);
+       AST_TEST_UNREGISTER(object_retrieve_field);
+       AST_TEST_UNREGISTER(object_retrieve_multiple_all);
+       AST_TEST_UNREGISTER(object_retrieve_multiple_field);
+       AST_TEST_UNREGISTER(object_update);
+       AST_TEST_UNREGISTER(object_update_uncreated);
+       AST_TEST_UNREGISTER(object_delete);
+       AST_TEST_UNREGISTER(object_delete_uncreated);
+       AST_TEST_UNREGISTER(caching_wizard_behavior);
+       AST_TEST_UNREGISTER(configuration_file_wizard);
+       AST_TEST_UNREGISTER(configuration_file_wizard_with_file_integrity);
+       AST_TEST_UNREGISTER(configuration_file_wizard_with_criteria);
+       AST_TEST_UNREGISTER(configuration_file_wizard_retrieve_field);
+       AST_TEST_UNREGISTER(configuration_file_wizard_retrieve_multiple);
+       AST_TEST_UNREGISTER(configuration_file_wizard_retrieve_multiple_all);
+       return 0;
+}
+
+static int load_module(void)
+{
+       AST_TEST_REGISTER(wizard_registration);
+       AST_TEST_REGISTER(open);
+       AST_TEST_REGISTER(apply_default);
+       AST_TEST_REGISTER(apply_config);
+       AST_TEST_REGISTER(object_register);
+       AST_TEST_REGISTER(object_register_without_mapping);
+       AST_TEST_REGISTER(object_field_register);
+       AST_TEST_REGISTER(object_alloc_with_id);
+       AST_TEST_REGISTER(object_alloc_without_id);
+       AST_TEST_REGISTER(object_copy);
+       AST_TEST_REGISTER(object_diff);
+       AST_TEST_REGISTER(objectset_create);
+       AST_TEST_REGISTER(objectset_apply);
+       AST_TEST_REGISTER(objectset_apply_invalid);
+       AST_TEST_REGISTER(objectset_transform);
+       AST_TEST_REGISTER(changeset_create);
+       AST_TEST_REGISTER(changeset_create_unchanged);
+       AST_TEST_REGISTER(object_create);
+       AST_TEST_REGISTER(object_retrieve_id);
+       AST_TEST_REGISTER(object_retrieve_field);
+       AST_TEST_REGISTER(object_retrieve_multiple_all);
+       AST_TEST_REGISTER(object_retrieve_multiple_field);
+       AST_TEST_REGISTER(object_update);
+       AST_TEST_REGISTER(object_update_uncreated);
+       AST_TEST_REGISTER(object_delete);
+       AST_TEST_REGISTER(object_delete_uncreated);
+       AST_TEST_REGISTER(caching_wizard_behavior);
+       AST_TEST_REGISTER(configuration_file_wizard);
+       AST_TEST_REGISTER(configuration_file_wizard_with_file_integrity);
+       AST_TEST_REGISTER(configuration_file_wizard_with_criteria);
+       AST_TEST_REGISTER(configuration_file_wizard_retrieve_field);
+       AST_TEST_REGISTER(configuration_file_wizard_retrieve_multiple);
+       AST_TEST_REGISTER(configuration_file_wizard_retrieve_multiple_all);
+       return AST_MODULE_LOAD_SUCCESS;
+}
+
+AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Sorcery test module");