res_sorcery_memory_cache.c File Reference

Sorcery Memory Cache Object Wizard. More...

#include "asterisk.h"
#include "asterisk/module.h"
#include "asterisk/sorcery.h"
#include "asterisk/astobj2.h"
#include "asterisk/sched.h"
#include "asterisk/test.h"
#include "asterisk/heap.h"
#include "asterisk/cli.h"
#include "asterisk/manager.h"

Include dependency graph for res_sorcery_memory_cache.c:

Go to the source code of this file.

Data Structures
struct	print_object_details
	Structure used to pass data for printing cached object information. More...
struct	sorcery_memory_cache
	Structure for storing a memory cache. More...
struct	sorcery_memory_cache_fields_cmp_params
	Structure used for fields comparison. More...
struct	sorcery_memory_cached_object
	Structure for stored a cached object. More...
struct	stale_cache_update_task_data
struct	stale_update_task_data

Macros
#define	CACHE_CONTAINER_BUCKET_SIZE   53
	The default bucket size for the container of objects in the cache.
#define	CACHE_HEAP_INIT_HEIGHT   5
	Height of heap for cache object heap. Allows 31 initial objects.
#define	CACHES_CONTAINER_BUCKET_SIZE   53
	The bucket size for the container of caches.
#define	FORMAT   "%-25.25s %-15u %-15u \n"
#define	FORMAT   "%-25.25s %-15.15s %-15.15s \n"
#define	PASSTHRU_UPDATE_THREAD_ID   0x5EED1E55

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static int	add_to_cache (struct sorcery_memory_cache *cache, struct sorcery_memory_cached_object *cached_object)
static int	age_cmp (void *a, void *b)
struct ast_module *	AST_MODULE_SELF_SYM (void)
	AST_THREADSTORAGE_CUSTOM_SCOPE (passthru_update_id_storage, NULL, ast_free_ptr, static)
static int	configuration_parse_unsigned_integer (const char *value, unsigned int *result)
static void	end_passthru_update (void)
static int	expire_objects_from_cache (const void *data)
static int	is_passthru_update (void)
static int	load_module (void)
static void	mark_all_as_stale_in_cache (struct sorcery_memory_cache *cache)
static int	mark_object_as_stale_in_cache (struct sorcery_memory_cache *cache, const char *id)
static void	memory_cache_full_update (const struct ast_sorcery *sorcery, const char *type, struct sorcery_memory_cache *cache)
static int	memory_cache_populate_external (const struct ast_sorcery *sorcery, const char *type, struct sorcery_memory_cache *cache)
static void	memory_cache_populate_internal (const struct ast_sorcery *sorcery, const char *type, struct sorcery_memory_cache *cache)
static void	memory_cache_stale_check (const struct ast_sorcery *sorcery, struct sorcery_memory_cache *cache)
static void	memory_cache_stale_check_object (const struct ast_sorcery *sorcery, struct sorcery_memory_cache *cache, struct sorcery_memory_cached_object *cached)
static void	memory_cache_stale_update_full (const struct ast_sorcery *sorcery, struct sorcery_memory_cache *cache, const char *type)
static void	memory_cache_stale_update_object (const struct ast_sorcery *sorcery, struct sorcery_memory_cache *cache, struct sorcery_memory_cached_object *cached)
static int	object_add_to_cache_callback (void *obj, void *arg, void *data, int flags)
static int	object_stale_callback (void *obj, void *arg, int flags)
static void	remove_all_from_cache (struct sorcery_memory_cache *cache)
static int	remove_from_cache (struct sorcery_memory_cache *cache, const char *id, int reschedule)
static int	remove_oldest_from_cache (struct sorcery_memory_cache *cache)
static int	schedule_cache_expiration (struct sorcery_memory_cache *cache)
static void	set_passthru_update (uint32_t value)
static int	sorcery_memory_cache_ami_expire (struct mansession *s, const struct message *m)
static int	sorcery_memory_cache_ami_expire_object (struct mansession *s, const struct message *m)
static int	sorcery_memory_cache_ami_populate (struct mansession *s, const struct message *m)
static int	sorcery_memory_cache_ami_stale (struct mansession *s, const struct message *m)
static int	sorcery_memory_cache_ami_stale_object (struct mansession *s, const struct message *m)
static void	sorcery_memory_cache_close (void *data)
static int	sorcery_memory_cache_cmp (void *obj, void *arg, int flags)
static char *	sorcery_memory_cache_complete_name (const char *word, int state)
static char *	sorcery_memory_cache_complete_object_name (const char *cache_name, const char *word, int state)
static int	sorcery_memory_cache_create (const struct ast_sorcery *sorcery, void *data, void *object)
static int	sorcery_memory_cache_delete (const struct ast_sorcery *sorcery, void *data, void *object)
static void	sorcery_memory_cache_destructor (void *obj)
static char *	sorcery_memory_cache_dump (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	sorcery_memory_cache_expire (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	sorcery_memory_cache_fields_cmp (void *obj, void *arg, int flags)
static int	sorcery_memory_cache_hash (const void *obj, int flags)
static void	sorcery_memory_cache_load (void *data, const struct ast_sorcery *sorcery, const char *type)
static void *	sorcery_memory_cache_open (const char *data)
static char *	sorcery_memory_cache_populate (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	sorcery_memory_cache_print_object (void *obj, void *arg, int flags)
static void	sorcery_memory_cache_reload (void *data, const struct ast_sorcery *sorcery, const char *type)
static void *	sorcery_memory_cache_retrieve_fields (const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields)
static void *	sorcery_memory_cache_retrieve_id (const struct ast_sorcery *sorcery, void *data, const char *type, const char *id)
static void	sorcery_memory_cache_retrieve_multiple (const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const struct ast_variable *fields)
static void	sorcery_memory_cache_retrieve_prefix (const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *prefix, const size_t prefix_len)
static void	sorcery_memory_cache_retrieve_regex (const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex)
static char *	sorcery_memory_cache_show (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	sorcery_memory_cache_stale (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static struct sorcery_memory_cached_object *	sorcery_memory_cached_object_alloc (const struct ast_sorcery *sorcery, const struct sorcery_memory_cache *cache, void *object)
static int	sorcery_memory_cached_object_cmp (void *obj, void *arg, int flags)
static void	sorcery_memory_cached_object_destructor (void *obj)
static int	sorcery_memory_cached_object_hash (const void *obj, int flags)
static int	stale_cache_update (const void *data)
static struct stale_cache_update_task_data *	stale_cache_update_task_data_alloc (struct ast_sorcery *sorcery, struct sorcery_memory_cache *cache, const char *type)
static void	stale_cache_update_task_data_destructor (void *obj)
static int	stale_item_update (const void *data)
static struct stale_update_task_data *	stale_update_task_data_alloc (struct ast_sorcery *sorcery, struct sorcery_memory_cache *cache, const char *type, void *object)
static void	stale_update_task_data_destructor (void *obj)
static void	start_passthru_update (void)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Sorcery Memory Cache Object Wizard" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_REALTIME_DRIVER, }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ao2_container *	caches
	Container of created caches.
static struct ast_cli_entry	cli_memory_cache []
static struct ast_sorcery_wizard	memory_cache_object_wizard
static struct ast_sched_context *	sched
	Scheduler for cache management.

Detailed Description

Sorcery Memory Cache Object Wizard.

Author

Joshua Colp jcolp.nosp@m.@dig.nosp@m.ium.c.nosp@m.om

Definition in file res_sorcery_memory_cache.c.

Macro Definition Documentation

CACHE_CONTAINER_BUCKET_SIZE

#define CACHE_CONTAINER_BUCKET_SIZE   53

The default bucket size for the container of objects in the cache.

Definition at line 252 of file res_sorcery_memory_cache.c.

CACHE_HEAP_INIT_HEIGHT

#define CACHE_HEAP_INIT_HEIGHT   5

Height of heap for cache object heap. Allows 31 initial objects.

Definition at line 255 of file res_sorcery_memory_cache.c.

CACHES_CONTAINER_BUCKET_SIZE

#define CACHES_CONTAINER_BUCKET_SIZE   53

The bucket size for the container of caches.

Definition at line 249 of file res_sorcery_memory_cache.c.

FORMAT [1/2]

#define FORMAT   "%-25.25s %-15u %-15u \n"

FORMAT [2/2]

#define FORMAT   "%-25.25s %-15.15s %-15.15s \n"

PASSTHRU_UPDATE_THREAD_ID

#define PASSTHRU_UPDATE_THREAD_ID   0x5EED1E55

Definition at line 263 of file res_sorcery_memory_cache.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 3766 of file res_sorcery_memory_cache.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 3766 of file res_sorcery_memory_cache.c.

add_to_cache()

static int add_to_cache ( struct sorcery_memory_cache *  cache, struct sorcery_memory_cached_object *  cached_object  )

static

Definition at line 746 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cached_object *front;
 
    if (!ao2_link_flags(cache->objects, cached_object, OBJ_NOLOCK)) {
        return -1;
    }
 
    if (cache->full_backend_cache && (front = ast_heap_peek(cache->object_heap, 1))) {
        /* For a full backend cache all objects share the same lifetime */
        cached_object->created = front->created;
    }
 
    if (ast_heap_push(cache->object_heap, cached_object)) {
        ao2_find(cache->objects, cached_object,
            OBJ_SEARCH_OBJECT | OBJ_UNLINK | OBJ_NODATA | OBJ_NOLOCK);
        return -1;
    }
 
    if (cache->expire_id == -1) {
        schedule_cache_expiration(cache);
    }
 
    return 0;
}

References ao2_find, ao2_link_flags, ast_heap_peek(), ast_heap_push, cache, sorcery_memory_cached_object::created, OBJ_NODATA, OBJ_NOLOCK, OBJ_SEARCH_OBJECT, OBJ_UNLINK, and schedule_cache_expiration().

Referenced by memory_cache_populate_external(), object_add_to_cache_callback(), and sorcery_memory_cache_create().

age_cmp()

static int age_cmp ( void *  a, void *  b  )

static

Definition at line 1617 of file res_sorcery_memory_cache.c.

{
    return ast_tvcmp(((struct sorcery_memory_cached_object *) b)->created,
            ((struct sorcery_memory_cached_object *) a)->created);
}

References a, ast_tvcmp(), and b.

Referenced by sorcery_memory_cache_open().

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 3766 of file res_sorcery_memory_cache.c.

AST_THREADSTORAGE_CUSTOM_SCOPE()

AST_THREADSTORAGE_CUSTOM_SCOPE	(	passthru_update_id_storage	,
		NULL	,
		ast_free_ptr	,
		static
	)

configuration_parse_unsigned_integer()

static int configuration_parse_unsigned_integer ( const char *  value, unsigned int *  result  )

static

Definition at line 1608 of file res_sorcery_memory_cache.c.

{
    if (ast_strlen_zero(value) || !strncmp(value, "-", 1)) {
        return 0;
    }
 
    return sscanf(value, "%30u", result);
}

References ast_strlen_zero(), result, and value.

Referenced by sorcery_memory_cache_open().

end_passthru_update()

static void end_passthru_update ( void  )

static

Definition at line 298 of file res_sorcery_memory_cache.c.

{
    set_passthru_update(0);
}

References set_passthru_update().

Referenced by memory_cache_populate_external(), memory_cache_populate_internal(), stale_cache_update(), and stale_item_update().

expire_objects_from_cache()

static int expire_objects_from_cache ( const void *  data )

static

Definition at line 516 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cache *cache = (struct sorcery_memory_cache *)data;
    struct sorcery_memory_cached_object *cached;
 
    /*
     * We need to do deadlock avoidance between a non-scheduler thread
     * blocking when trying to delete the scheduled entry for this
     * callback because the scheduler thread is running this callback
     * and this callback waiting for the cache->objects container lock
     * that the blocked non-scheduler thread already holds.
     */
    while (ao2_trywrlock(cache->objects)) {
        if (cache->del_expire) {
            cache->expire_id = -1;
            ao2_ref(cache, -1);
            return 0;
        }
        sched_yield();
    }
 
    cache->expire_id = -1;
 
    /* This is an optimization for objects which have been cached close to each other */
    while ((cached = ast_heap_peek(cache->object_heap, 1))) {
        int expiration;
 
        expiration = ast_tvdiff_ms(ast_tvadd(cached->created, ast_samp2tv(cache->object_lifetime_maximum, 1)), ast_tvnow());
 
        /* If the current oldest object has not yet expired stop and reschedule for it */
        if (expiration > 0) {
            break;
        }
 
        remove_from_cache(cache, ast_sorcery_object_get_id(cached->object), 0);
    }
 
    schedule_cache_expiration(cache);
 
    ao2_unlock(cache->objects);
 
    ao2_ref(cache, -1);
 
    return 0;
}

References ao2_ref, ao2_trywrlock, ao2_unlock, ast_heap_peek(), ast_samp2tv(), ast_sorcery_object_get_id(), ast_tvadd(), ast_tvdiff_ms(), ast_tvnow(), cache, sorcery_memory_cached_object::created, sorcery_memory_cached_object::object, remove_from_cache(), and schedule_cache_expiration().

Referenced by schedule_cache_expiration().

is_passthru_update()

static int is_passthru_update ( void  )

static

Definition at line 266 of file res_sorcery_memory_cache.c.

{
    uint32_t *passthru_update_thread_id;
 
    passthru_update_thread_id = ast_threadstorage_get(&passthru_update_id_storage,
        sizeof(*passthru_update_thread_id));
    if (!passthru_update_thread_id) {
        return 0;
    }
 
    return *passthru_update_thread_id == PASSTHRU_UPDATE_THREAD_ID;
}

References ast_threadstorage_get(), and PASSTHRU_UPDATE_THREAD_ID.

Referenced by sorcery_memory_cache_retrieve_fields(), sorcery_memory_cache_retrieve_id(), sorcery_memory_cache_retrieve_multiple(), sorcery_memory_cache_retrieve_prefix(), and sorcery_memory_cache_retrieve_regex().

load_module()

static int load_module ( void  )

static

Definition at line 3701 of file res_sorcery_memory_cache.c.

{
    int res;
 
    caches = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        CACHES_CONTAINER_BUCKET_SIZE, sorcery_memory_cache_hash, NULL,
        sorcery_memory_cache_cmp);
    if (!caches) {
        ast_log(LOG_ERROR, "Failed to create container for configured caches\n");
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
 
    sched = ast_sched_context_create();
    if (!sched) {
        ast_log(LOG_ERROR, "Failed to create scheduler for cache management\n");
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
 
    if (ast_sched_start_thread(sched)) {
        ast_log(LOG_ERROR, "Failed to create scheduler thread for cache management\n");
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
 
    if (ast_sorcery_wizard_register(&memory_cache_object_wizard)) {
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
 
    res = ast_cli_register_multiple(cli_memory_cache, ARRAY_LEN(cli_memory_cache));
    res |= ast_manager_register_xml("SorceryMemoryCacheExpireObject", EVENT_FLAG_SYSTEM, sorcery_memory_cache_ami_expire_object);
    res |= ast_manager_register_xml("SorceryMemoryCacheExpire", EVENT_FLAG_SYSTEM, sorcery_memory_cache_ami_expire);
    res |= ast_manager_register_xml("SorceryMemoryCacheStaleObject", EVENT_FLAG_SYSTEM, sorcery_memory_cache_ami_stale_object);
    res |= ast_manager_register_xml("SorceryMemoryCacheStale", EVENT_FLAG_SYSTEM, sorcery_memory_cache_ami_stale);
    res |= ast_manager_register_xml("SorceryMemoryCachePopulate", EVENT_FLAG_SYSTEM, sorcery_memory_cache_ami_populate);
 
    if (res) {
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
 
    /* This causes the stale unit test to execute last, so if a sorcery instance persists
     * longer than expected subsequent unit tests don't fail when setting it up.
     */
    AST_TEST_REGISTER(stale);
    AST_TEST_REGISTER(open_with_valid_options);
    AST_TEST_REGISTER(open_with_invalid_options);
    AST_TEST_REGISTER(create_and_retrieve);
    AST_TEST_REGISTER(update);
    AST_TEST_REGISTER(delete);
    AST_TEST_REGISTER(maximum_objects);
    AST_TEST_REGISTER(expiration);
    AST_TEST_REGISTER(full_backend_cache_expiration);
    AST_TEST_REGISTER(full_backend_cache_stale);
 
    return AST_MODULE_LOAD_SUCCESS;
}

References AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, ARRAY_LEN, ast_cli_register_multiple, ast_log, ast_manager_register_xml, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_sched_context_create(), ast_sched_start_thread(), ast_sorcery_wizard_register, AST_TEST_REGISTER, caches, CACHES_CONTAINER_BUCKET_SIZE, cli_memory_cache, EVENT_FLAG_SYSTEM, LOG_ERROR, memory_cache_object_wizard, NULL, sorcery_memory_cache_ami_expire(), sorcery_memory_cache_ami_expire_object(), sorcery_memory_cache_ami_populate(), sorcery_memory_cache_ami_stale(), sorcery_memory_cache_ami_stale_object(), sorcery_memory_cache_cmp(), sorcery_memory_cache_hash(), unload_module(), and update().

mark_all_as_stale_in_cache()

static void mark_all_as_stale_in_cache ( struct sorcery_memory_cache *  cache )

static

Definition at line 650 of file res_sorcery_memory_cache.c.

{
    ao2_callback(cache->objects, OBJ_NOLOCK | OBJ_NODATA | OBJ_MULTIPLE, object_stale_callback, cache);
}

References ao2_callback, cache, OBJ_MULTIPLE, OBJ_NODATA, OBJ_NOLOCK, and object_stale_callback().

Referenced by sorcery_memory_cache_ami_stale(), and sorcery_memory_cache_stale().

mark_object_as_stale_in_cache()

static int mark_object_as_stale_in_cache ( struct sorcery_memory_cache *  cache, const char *  id  )

static

Definition at line 623 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cached_object *cached;
 
    cached = ao2_find(cache->objects, id, OBJ_SEARCH_KEY | OBJ_NOLOCK);
    if (!cached) {
        return -1;
    }
 
    ast_assert(!strcmp(ast_sorcery_object_get_id(cached->object), id));
 
    object_stale_callback(cached, cache, 0);
    ao2_ref(cached, -1);
 
    return 0;
}

References ao2_find, ao2_ref, ast_assert, ast_sorcery_object_get_id(), cache, OBJ_NOLOCK, OBJ_SEARCH_KEY, sorcery_memory_cached_object::object, and object_stale_callback().

Referenced by sorcery_memory_cache_ami_stale_object(), and sorcery_memory_cache_stale().

memory_cache_full_update()

static void memory_cache_full_update ( const struct ast_sorcery *  sorcery, const char *  type, struct sorcery_memory_cache *  cache  )

static

Definition at line 1201 of file res_sorcery_memory_cache.c.

{
    if (!cache->full_backend_cache) {
        return;
    }
 
    ao2_wrlock(cache->objects);
    if (!ao2_container_count(cache->objects)) {
        memory_cache_populate_internal(sorcery, type, cache);
    }
    ao2_unlock(cache->objects);
}

References ao2_container_count(), ao2_unlock, ao2_wrlock, cache, memory_cache_populate_internal(), sorcery, and type.

Referenced by sorcery_memory_cache_retrieve_id(), sorcery_memory_cache_retrieve_multiple(), sorcery_memory_cache_retrieve_prefix(), and sorcery_memory_cache_retrieve_regex().

memory_cache_populate_external()

static int memory_cache_populate_external ( const struct ast_sorcery *  sorcery, const char *  type, struct sorcery_memory_cache *  cache  )

static

Definition at line 1107 of file res_sorcery_memory_cache.c.

{
    struct ao2_container *backend_objects;
    struct ao2_iterator it_backend;
    void *object;
    AST_VECTOR(, struct sorcery_memory_cached_object *) cached_objects;
    int i, num_cached;
 
    /* Retrieve all backend objects without holding the cache lock */
    start_passthru_update();
    backend_objects = ast_sorcery_retrieve_by_fields(sorcery, type, AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
    end_passthru_update();
 
    if (!backend_objects) {
        /* This will occur in off-nominal memory allocation failure scenarios */
        return -1;
    }
 
    if (cache->maximum_objects && ao2_container_count(backend_objects) >= cache->maximum_objects) {
        ast_log(LOG_ERROR, "The backend contains %d objects while the sorcery memory cache '%s' is explicitly configured to only allow %d\n",
            ao2_container_count(backend_objects), cache->name, cache->maximum_objects);
        ao2_ref(backend_objects, -1);
        return -1;
    }
 
    /* Allocate vector to hold cached objects - do this before any locking */
    if (AST_VECTOR_INIT(&cached_objects, ao2_container_count(backend_objects))) {
        ast_log(LOG_ERROR, "Could not allocate vector for cached objects for sorcery memory cache '%s'\n",
            cache->name);
        ao2_ref(backend_objects, -1);
        return -1;
    }
 
    /* Iterate all backend objects, creating cached objects for each */
    it_backend = ao2_iterator_init(backend_objects, 0);
 
    while ((object = ao2_iterator_next(&it_backend))) {
        struct sorcery_memory_cached_object *cached;
 
        cached = sorcery_memory_cached_object_alloc(sorcery, cache, object);
        ao2_ref(object, -1);
 
        if (!cached || AST_VECTOR_APPEND(&cached_objects, cached)) {
            ao2_cleanup(cached);
            ao2_iterator_destroy(&it_backend);
            ao2_ref(backend_objects, -1);
            /* Clean up any cached objects we already created */
            for (i = 0; i < AST_VECTOR_SIZE(&cached_objects); i++) {
                ao2_ref(AST_VECTOR_GET(&cached_objects, i), -1);
            }
            AST_VECTOR_FREE(&cached_objects);
            return -1;
        }
    }
 
    ao2_iterator_destroy(&it_backend);
 
    /* Now we have all cached objects ready - quickly swap them into the cache */
    ao2_wrlock(cache->objects);
 
    /* Remove all existing objects from cache */
    remove_all_from_cache(cache);
 
    num_cached = AST_VECTOR_SIZE(&cached_objects);
 
    /* Add all new objects to cache */
    for (i = 0; i < num_cached; i++) {
        struct sorcery_memory_cached_object *cached = AST_VECTOR_GET(&cached_objects, i);
        add_to_cache(cache, cached);
    }
 
    ao2_unlock(cache->objects);
 
    /* Cleanup - release all our references to cached objects.
     * Done in a separate loop to avoid holding the cache lock while destroying objects,
     * which reduces lock contention and potential blocking.
     */
    for (i = 0; i < num_cached; i++) {
        ao2_ref(AST_VECTOR_GET(&cached_objects, i), -1);
    }
    AST_VECTOR_FREE(&cached_objects);
 
    ao2_ref(backend_objects, -1);
    return num_cached;
}

References add_to_cache(), ao2_cleanup, ao2_container_count(), ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ao2_unlock, ao2_wrlock, ast_log, AST_RETRIEVE_FLAG_ALL, AST_RETRIEVE_FLAG_MULTIPLE, ast_sorcery_retrieve_by_fields(), AST_VECTOR, AST_VECTOR_APPEND, AST_VECTOR_FREE, AST_VECTOR_GET, AST_VECTOR_INIT, AST_VECTOR_SIZE, cache, end_passthru_update(), LOG_ERROR, NULL, remove_all_from_cache(), sorcery, sorcery_memory_cached_object_alloc(), start_passthru_update(), and type.

Referenced by sorcery_memory_cache_ami_populate(), and sorcery_memory_cache_populate().

memory_cache_populate_internal()

static void memory_cache_populate_internal ( const struct ast_sorcery *  sorcery, const char *  type, struct sorcery_memory_cache *  cache  )

static

Definition at line 1055 of file res_sorcery_memory_cache.c.

{
    struct ao2_container *backend_objects;
 
    start_passthru_update();
    backend_objects = ast_sorcery_retrieve_by_fields(sorcery, type, AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
    end_passthru_update();
 
    if (!backend_objects) {
        /* This will occur in off-nominal memory allocation failure scenarios */
        return;
    }
 
    if (cache->maximum_objects && ao2_container_count(backend_objects) >= cache->maximum_objects) {
        ast_log(LOG_ERROR, "The backend contains %d objects while the sorcery memory cache '%s' is explicitly configured to only allow %d\n",
            ao2_container_count(backend_objects), cache->name, cache->maximum_objects);
        ao2_ref(backend_objects, -1);
        return;
    }
 
    ao2_callback_data(backend_objects, OBJ_NOLOCK | OBJ_NODATA | OBJ_MULTIPLE, object_add_to_cache_callback,
        (struct ast_sorcery*)sorcery, cache);
 
    /* If the number of cached objects does not match the number of backend objects we encountered a memory allocation
     * failure and the cache is incomplete, so drop everything and fall back to querying the backend directly
     * as it may be able to provide what is wanted.
     */
    if (ao2_container_count(cache->objects) != ao2_container_count(backend_objects)) {
        ast_log(LOG_WARNING, "The backend contains %d objects while only %d could be added to sorcery memory cache '%s'\n",
            ao2_container_count(backend_objects), ao2_container_count(cache->objects), cache->name);
        remove_all_from_cache(cache);
    }
 
    ao2_ref(backend_objects, -1);
}

References ao2_callback_data, ao2_container_count(), ao2_ref, ast_log, AST_RETRIEVE_FLAG_ALL, AST_RETRIEVE_FLAG_MULTIPLE, ast_sorcery_retrieve_by_fields(), cache, end_passthru_update(), LOG_ERROR, LOG_WARNING, NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_NOLOCK, object_add_to_cache_callback(), remove_all_from_cache(), sorcery, start_passthru_update(), and type.

Referenced by memory_cache_full_update().

memory_cache_stale_check()

static void memory_cache_stale_check ( const struct ast_sorcery *  sorcery, struct sorcery_memory_cache *  cache  )

static

Definition at line 1315 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cached_object *cached;
 
    ao2_rdlock(cache->objects);
    cached = ao2_bump(ast_heap_peek(cache->object_heap, 1));
    ao2_unlock(cache->objects);
 
    if (!cached) {
        return;
    }
 
    memory_cache_stale_check_object(sorcery, cache, cached);
    ao2_ref(cached, -1);
}

References ao2_bump, ao2_rdlock, ao2_ref, ao2_unlock, ast_heap_peek(), cache, memory_cache_stale_check_object(), and sorcery.

Referenced by sorcery_memory_cache_retrieve_multiple(), sorcery_memory_cache_retrieve_prefix(), and sorcery_memory_cache_retrieve_regex().

memory_cache_stale_check_object()

static void memory_cache_stale_check_object ( const struct ast_sorcery *  sorcery, struct sorcery_memory_cache *  cache, struct sorcery_memory_cached_object *  cached  )

static

Definition at line 1282 of file res_sorcery_memory_cache.c.

{
    struct timeval elapsed;
 
    if (!cache->object_lifetime_stale) {
        return;
    }
 
    /* For a full cache as every object has the same expiration/staleness we can do the same check */
    elapsed = ast_tvsub(ast_tvnow(), cached->created);
 
    if (elapsed.tv_sec < cache->object_lifetime_stale) {
        return;
    }
 
    if (cache->full_backend_cache) {
        memory_cache_stale_update_full(sorcery, cache, ast_sorcery_object_get_type(cached->object));
    } else {
        memory_cache_stale_update_object(sorcery, cache, cached);
    }
 
}

References ast_sorcery_object_get_type(), ast_tvnow(), ast_tvsub(), cache, sorcery_memory_cached_object::created, memory_cache_stale_update_full(), memory_cache_stale_update_object(), sorcery_memory_cached_object::object, and sorcery.

Referenced by memory_cache_stale_check(), sorcery_memory_cache_retrieve_fields(), and sorcery_memory_cache_retrieve_id().

memory_cache_stale_update_full()

static void memory_cache_stale_update_full ( const struct ast_sorcery *  sorcery, struct sorcery_memory_cache *  cache, const char *  type  )

static

Definition at line 1222 of file res_sorcery_memory_cache.c.

{
    ao2_wrlock(cache->objects);
    if (cache->stale_update_sched_id == -1) {
        struct stale_cache_update_task_data *task_data;
 
        task_data = stale_cache_update_task_data_alloc((struct ast_sorcery *) sorcery,
            cache, type);
        if (task_data) {
            cache->stale_update_sched_id = ast_sched_add(sched, 1,
                stale_cache_update, task_data);
        }
        if (cache->stale_update_sched_id < 0) {
            ao2_cleanup(task_data);
        }
    }
    ao2_unlock(cache->objects);
}

References ao2_cleanup, ao2_unlock, ao2_wrlock, ast_sched_add(), cache, sorcery, stale_cache_update(), stale_cache_update_task_data_alloc(), and type.

Referenced by memory_cache_stale_check_object().

memory_cache_stale_update_object()

static void memory_cache_stale_update_object ( const struct ast_sorcery *  sorcery, struct sorcery_memory_cache *  cache, struct sorcery_memory_cached_object *  cached  )

static

Definition at line 1250 of file res_sorcery_memory_cache.c.

{
    ao2_lock(cached);
    if (cached->stale_update_sched_id == -1) {
        struct stale_update_task_data *task_data;
 
        task_data = stale_update_task_data_alloc((struct ast_sorcery *) sorcery,
            cache, ast_sorcery_object_get_type(cached->object), cached->object);
        if (task_data) {
            ast_debug(1, "Cached sorcery object type '%s' ID '%s' is stale. Refreshing\n",
                ast_sorcery_object_get_type(cached->object), ast_sorcery_object_get_id(cached->object));
            cached->stale_update_sched_id = ast_sched_add(sched, 1,
                stale_item_update, task_data);
        }
        if (cached->stale_update_sched_id < 0) {
            ao2_cleanup(task_data);
            ast_log(LOG_ERROR, "Unable to update stale cached object type '%s', ID '%s'.\n",
                ast_sorcery_object_get_type(cached->object), ast_sorcery_object_get_id(cached->object));
        }
    }
    ao2_unlock(cached);
}

References ao2_cleanup, ao2_lock, ao2_unlock, ast_debug, ast_log, ast_sched_add(), ast_sorcery_object_get_id(), ast_sorcery_object_get_type(), cache, LOG_ERROR, sorcery_memory_cached_object::object, sorcery, stale_item_update(), sorcery_memory_cached_object::stale_update_sched_id, and stale_update_task_data_alloc().

Referenced by memory_cache_stale_check_object(), sorcery_memory_cache_ami_stale_object(), and sorcery_memory_cache_stale().

object_add_to_cache_callback()

static int object_add_to_cache_callback ( void *  obj, void *  arg, void *  data, int  flags  )

static

Definition at line 873 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cache *cache = data;
    struct sorcery_memory_cached_object *cached;
 
    cached = sorcery_memory_cached_object_alloc(arg, cache, obj);
    if (!cached) {
        return CMP_STOP;
    }
 
    add_to_cache(cache, cached);
    ao2_ref(cached, -1);
 
    return 0;
}

References add_to_cache(), ao2_ref, cache, CMP_STOP, and sorcery_memory_cached_object_alloc().

Referenced by memory_cache_populate_internal(), and stale_cache_update().

object_stale_callback()

static int object_stale_callback ( void *  obj, void *  arg, int  flags  )

static

Definition at line 595 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cached_object *cached = obj;
    struct sorcery_memory_cache *cache = arg;
 
    /* Since our granularity is seconds it's possible for something to retrieve us within a window
     * where we wouldn't be treated as stale. To ensure that doesn't happen we use the configured stale
     * time plus a second.
     */
    cached->created = ast_tvsub(cached->created, ast_samp2tv(cache->object_lifetime_stale + 1, 1));
 
    return CMP_MATCH;
}

References ast_samp2tv(), ast_tvsub(), cache, CMP_MATCH, and sorcery_memory_cached_object::created.

Referenced by mark_all_as_stale_in_cache(), and mark_object_as_stale_in_cache().

remove_all_from_cache()

static void remove_all_from_cache ( struct sorcery_memory_cache *  cache )

static

Definition at line 572 of file res_sorcery_memory_cache.c.

{
    while (ast_heap_pop(cache->object_heap)) {
    }
 
    ao2_callback(cache->objects, OBJ_UNLINK | OBJ_NOLOCK | OBJ_NODATA | OBJ_MULTIPLE,
        NULL, NULL);
 
    cache->del_expire = 1;
    AST_SCHED_DEL_UNREF(sched, cache->expire_id, ao2_ref(cache, -1));
    cache->del_expire = 0;
}

References ao2_callback, ao2_ref, ast_heap_pop(), AST_SCHED_DEL_UNREF, cache, NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_NOLOCK, and OBJ_UNLINK.

Referenced by memory_cache_populate_external(), memory_cache_populate_internal(), sorcery_memory_cache_ami_expire(), sorcery_memory_cache_close(), sorcery_memory_cache_expire(), sorcery_memory_cache_reload(), and stale_cache_update().

remove_from_cache()

static int remove_from_cache ( struct sorcery_memory_cache *  cache, const char *  id, int  reschedule  )

static

Definition at line 483 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cached_object *hash_object;
    struct sorcery_memory_cached_object *oldest_object;
    struct sorcery_memory_cached_object *heap_object;
 
    hash_object = ao2_find(cache->objects, id, OBJ_SEARCH_KEY | OBJ_UNLINK | OBJ_NOLOCK);
    if (!hash_object) {
        return -1;
    }
 
    ast_assert(!strcmp(ast_sorcery_object_get_id(hash_object->object), id));
 
    oldest_object = ast_heap_peek(cache->object_heap, 1);
    heap_object = ast_heap_remove(cache->object_heap, hash_object);
 
    ast_assert(heap_object == hash_object);
 
    ao2_ref(hash_object, -1);
 
    if (reschedule && (oldest_object == heap_object)) {
        schedule_cache_expiration(cache);
    }
 
    return 0;
}

References ao2_find, ao2_ref, ast_assert, ast_heap_peek(), ast_heap_remove(), ast_sorcery_object_get_id(), cache, OBJ_NOLOCK, OBJ_SEARCH_KEY, OBJ_UNLINK, sorcery_memory_cached_object::object, and schedule_cache_expiration().

Referenced by expire_objects_from_cache(), sorcery_memory_cache_ami_expire_object(), sorcery_memory_cache_create(), sorcery_memory_cache_delete(), and sorcery_memory_cache_expire().

remove_oldest_from_cache()

static int remove_oldest_from_cache ( struct sorcery_memory_cache *  cache )

static

Definition at line 713 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cached_object *heap_old_object;
    struct sorcery_memory_cached_object *hash_old_object;
 
    heap_old_object = ast_heap_pop(cache->object_heap);
    if (!heap_old_object) {
        return -1;
    }
    hash_old_object = ao2_find(cache->objects, heap_old_object,
        OBJ_SEARCH_OBJECT | OBJ_UNLINK | OBJ_NOLOCK);
 
    ast_assert(heap_old_object == hash_old_object);
 
    ao2_ref(hash_old_object, -1);
 
    schedule_cache_expiration(cache);
 
    return 0;
}

References ao2_find, ao2_ref, ast_assert, ast_heap_pop(), cache, OBJ_NOLOCK, OBJ_SEARCH_OBJECT, OBJ_UNLINK, and schedule_cache_expiration().

Referenced by sorcery_memory_cache_create().

schedule_cache_expiration()

static int schedule_cache_expiration ( struct sorcery_memory_cache *  cache )

static

Definition at line 666 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cached_object *cached;
    int expiration = 0;
 
    if (!cache->object_lifetime_maximum) {
        return 0;
    }
 
    cache->del_expire = 1;
    AST_SCHED_DEL_UNREF(sched, cache->expire_id, ao2_ref(cache, -1));
    cache->del_expire = 0;
 
    cached = ast_heap_peek(cache->object_heap, 1);
    if (!cached) {
#ifdef TEST_FRAMEWORK
        ast_mutex_lock(&cache->lock);
        cache->cache_completed = 1;
        ast_cond_signal(&cache->cond);
        ast_mutex_unlock(&cache->lock);
#endif
        return 0;
    }
 
    expiration = MAX(ast_tvdiff_ms(ast_tvadd(cached->created, ast_samp2tv(cache->object_lifetime_maximum, 1)), ast_tvnow()),
        1);
 
    cache->expire_id = ast_sched_add(sched, expiration, expire_objects_from_cache, ao2_bump(cache));
    if (cache->expire_id < 0) {
        ao2_ref(cache, -1);
        return -1;
    }
 
    return 0;
}

References ao2_bump, ao2_ref, ast_cond_signal, ast_heap_peek(), ast_mutex_lock, ast_mutex_unlock, ast_samp2tv(), ast_sched_add(), AST_SCHED_DEL_UNREF, ast_tvadd(), ast_tvdiff_ms(), ast_tvnow(), cache, sorcery_memory_cached_object::created, expire_objects_from_cache(), and MAX.

Referenced by add_to_cache(), expire_objects_from_cache(), remove_from_cache(), and remove_oldest_from_cache().

set_passthru_update()

static void set_passthru_update ( uint32_t  value )

static

Definition at line 279 of file res_sorcery_memory_cache.c.

{
    uint32_t *passthru_update_thread_id;
 
    passthru_update_thread_id = ast_threadstorage_get(&passthru_update_id_storage,
        sizeof(*passthru_update_thread_id));
    if (!passthru_update_thread_id) {
        ast_log(LOG_ERROR, "Could not set passthru update ID for sorcery memory cache thread\n");
        return;
    }
 
    *passthru_update_thread_id = value;
}

References ast_log, ast_threadstorage_get(), LOG_ERROR, and value.

Referenced by end_passthru_update(), and start_passthru_update().

sorcery_memory_cache_ami_expire()

static int sorcery_memory_cache_ami_expire ( struct mansession *  s, const struct message *  m  )

static

Definition at line 2261 of file res_sorcery_memory_cache.c.

{
    const char *cache_name = astman_get_header(m, "Cache");
    struct sorcery_memory_cache *cache;
 
    if (ast_strlen_zero(cache_name)) {
        astman_send_error(s, m, "SorceryMemoryCacheExpire requires that a cache name be provided.\n");
        return 0;
    }
 
    cache = ao2_find(caches, cache_name, OBJ_SEARCH_KEY);
    if (!cache) {
        astman_send_error(s, m, "The provided cache does not exist\n");
        return 0;
    }
 
    ao2_wrlock(cache->objects);
    remove_all_from_cache(cache);
    ao2_unlock(cache->objects);
 
    ao2_ref(cache, -1);
 
    astman_send_ack(s, m, "All objects were expired from the cache\n");
 
    return 0;
}

References ao2_find, ao2_ref, ao2_unlock, ao2_wrlock, ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), cache, caches, OBJ_SEARCH_KEY, and remove_all_from_cache().

Referenced by load_module().

sorcery_memory_cache_ami_expire_object()

static int sorcery_memory_cache_ami_expire_object ( struct mansession *  s, const struct message *  m  )

static

Definition at line 2215 of file res_sorcery_memory_cache.c.

{
    const char *cache_name = astman_get_header(m, "Cache");
    const char *object_name = astman_get_header(m, "Object");
    struct sorcery_memory_cache *cache;
    int res;
 
    if (ast_strlen_zero(cache_name)) {
        astman_send_error(s, m, "SorceryMemoryCacheExpireObject requires that a cache name be provided.\n");
        return 0;
    } else if (ast_strlen_zero(object_name)) {
        astman_send_error(s, m, "SorceryMemoryCacheExpireObject requires that an object name be provided\n");
        return 0;
    }
 
    cache = ao2_find(caches, cache_name, OBJ_SEARCH_KEY);
    if (!cache) {
        astman_send_error(s, m, "The provided cache does not exist\n");
        return 0;
    }
 
    ao2_wrlock(cache->objects);
    if (cache->full_backend_cache) {
        res = 1;
    } else {
        res = remove_from_cache(cache, object_name, 1);
    }
    ao2_unlock(cache->objects);
 
    ao2_ref(cache, -1);
 
    if (res == 1) {
        astman_send_error(s, m, "Due to full backend caching per-object expiration is not available, consider using SorceryMemoryCachePopulate or SorceryMemoryCacheExpire instead\n");
    } else if (!res) {
        astman_send_ack(s, m, "The provided object was expired from the cache\n");
    } else {
        astman_send_error(s, m, "The provided object could not be expired from the cache\n");
    }
 
    return 0;
}

References ao2_find, ao2_ref, ao2_unlock, ao2_wrlock, ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), cache, caches, OBJ_SEARCH_KEY, and remove_from_cache().

Referenced by load_module().

sorcery_memory_cache_ami_populate()

static int sorcery_memory_cache_ami_populate ( struct mansession *  s, const struct message *  m  )

static

Definition at line 2376 of file res_sorcery_memory_cache.c.

{
    const char *cache_name = astman_get_header(m, "Cache");
    struct sorcery_memory_cache *cache;
    struct ast_sorcery *sorcery;
    const char *object_type;
    int cache_population_result;
 
    if (ast_strlen_zero(cache_name)) {
        astman_send_error(s, m, "SorceryMemoryCachePopulate requires that a cache name be provided.\n");
        return 0;
    }
 
    cache = ao2_find(caches, cache_name, OBJ_SEARCH_KEY);
    if (!cache) {
        astman_send_error(s, m, "The provided cache does not exist\n");
        return 0;
    }
 
    if (!cache->full_backend_cache) {
        astman_send_error(s, m, "The provided cache does not have full backend caching enabled\n");
        ao2_ref(cache, -1);
        return 0;
    }
 
    /* Acquire the populate lock to ensure only one population at a time */
    ast_mutex_lock(&cache->populate_lock);
 
    /* Quick check with read lock to see if cache is still active */
    ao2_rdlock(cache->objects);
    if (!cache->sorcery) {
        astman_send_error(s, m, "The provided cache is no longer active\n");
        ao2_unlock(cache->objects);
        ast_mutex_unlock(&cache->populate_lock);
        ao2_ref(cache, -1);
        return 0;
    }
 
    /* Get sorcery reference while we have the lock, safe to un-const as the ao2 ref change is allowed and safe */
    sorcery = ao2_bump((struct ast_sorcery *)cache->sorcery);
    object_type = cache->object_type;
 
    /* Unlock and populate the cache - memory_cache_populate_external will handle locking internally */
    ao2_unlock(cache->objects);
    cache_population_result = memory_cache_populate_external(sorcery, object_type, cache);
 
    ao2_ref(sorcery, -1);
    ast_mutex_unlock(&cache->populate_lock);
    ao2_ref(cache, -1);
 
    if (cache_population_result < 0) {
        astman_send_error(s, m, "An error occurred while populating the cache\n");
    } else {
        astman_send_ack(s, m, "Cache has been expired and populated\n");
    }
 
    return 0;
}

References ao2_bump, ao2_find, ao2_rdlock, ao2_ref, ao2_unlock, ast_mutex_lock, ast_mutex_unlock, ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), cache, caches, memory_cache_populate_external(), OBJ_SEARCH_KEY, and sorcery.

Referenced by load_module().

sorcery_memory_cache_ami_stale()

static int sorcery_memory_cache_ami_stale ( struct mansession *  s, const struct message *  m  )

static

Definition at line 2345 of file res_sorcery_memory_cache.c.

{
    const char *cache_name = astman_get_header(m, "Cache");
    struct sorcery_memory_cache *cache;
 
    if (ast_strlen_zero(cache_name)) {
        astman_send_error(s, m, "SorceryMemoryCacheStale requires that a cache name be provided.\n");
        return 0;
    }
 
    cache = ao2_find(caches, cache_name, OBJ_SEARCH_KEY);
    if (!cache) {
        astman_send_error(s, m, "The provided cache does not exist\n");
        return 0;
    }
 
    ao2_rdlock(cache->objects);
    mark_all_as_stale_in_cache(cache);
    ao2_unlock(cache->objects);
 
    ao2_ref(cache, -1);
 
    astman_send_ack(s, m, "All objects were marked as stale in the cache\n");
 
    return 0;
}

References ao2_find, ao2_rdlock, ao2_ref, ao2_unlock, ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), cache, caches, mark_all_as_stale_in_cache(), and OBJ_SEARCH_KEY.

Referenced by load_module().

sorcery_memory_cache_ami_stale_object()

static int sorcery_memory_cache_ami_stale_object ( struct mansession *  s, const struct message *  m  )

static

Definition at line 2292 of file res_sorcery_memory_cache.c.

{
    const char *cache_name = astman_get_header(m, "Cache");
    const char *object_name = astman_get_header(m, "Object");
    const char *reload = astman_get_header(m, "Reload");
    struct sorcery_memory_cache *cache;
    int res;
 
    if (ast_strlen_zero(cache_name)) {
        astman_send_error(s, m, "SorceryMemoryCacheStaleObject requires that a cache name be provided.\n");
        return 0;
    } else if (ast_strlen_zero(object_name)) {
        astman_send_error(s, m, "SorceryMemoryCacheStaleObject requires that an object name be provided\n");
        return 0;
    }
 
    cache = ao2_find(caches, cache_name, OBJ_SEARCH_KEY);
    if (!cache) {
        astman_send_error(s, m, "The provided cache does not exist\n");
        return 0;
    }
 
    ao2_rdlock(cache->objects);
 
    res = mark_object_as_stale_in_cache(cache, object_name);
 
    if (ast_true(reload)) {
        struct sorcery_memory_cached_object *cached;
 
        cached = ao2_find(cache->objects, object_name, OBJ_SEARCH_KEY | OBJ_NOLOCK);
        if (cached) {
            memory_cache_stale_update_object(cache->sorcery, cache, cached);
            ao2_ref(cached, -1);
        }
    }
 
    ao2_unlock(cache->objects);
 
    ao2_ref(cache, -1);
 
    if (!res) {
        astman_send_ack(s, m, "The provided object was marked as stale in the cache\n");
    } else {
        astman_send_error(s, m, "The provided object could not be marked as stale in the cache\n");
    }
 
    return 0;
}

References ao2_find, ao2_rdlock, ao2_ref, ao2_unlock, ast_strlen_zero(), ast_true(), astman_get_header(), astman_send_ack(), astman_send_error(), cache, caches, mark_object_as_stale_in_cache(), memory_cache_stale_update_object(), OBJ_NOLOCK, OBJ_SEARCH_KEY, and reload().

Referenced by load_module().

sorcery_memory_cache_close()

static void sorcery_memory_cache_close ( void *  data )

static

Definition at line 1749 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cache *cache = data;
 
    /* This can occur if a cache is created but never loaded */
    if (!ast_strlen_zero(cache->name)) {
        ao2_unlink(caches, cache);
    }
 
    if (cache->object_lifetime_maximum) {
        /* If object lifetime support is enabled we need to explicitly drop all cached objects here
         * and stop the scheduled task. Failure to do so could potentially keep the cache around for
         * a prolonged period of time.
         */
        ao2_wrlock(cache->objects);
        remove_all_from_cache(cache);
        ao2_unlock(cache->objects);
    }
 
    if (cache->full_backend_cache) {
        ao2_wrlock(cache->objects);
        cache->sorcery = NULL;
        ao2_unlock(cache->objects);
    }
 
    ao2_ref(cache, -1);
}

References ao2_ref, ao2_unlink, ao2_unlock, ao2_wrlock, ast_strlen_zero(), cache, caches, NULL, and remove_all_from_cache().

sorcery_memory_cache_cmp()

static int sorcery_memory_cache_cmp ( void *  obj, void *  arg, int  flags  )

static

Definition at line 346 of file res_sorcery_memory_cache.c.

{
    const struct sorcery_memory_cache *left = obj;
    const struct sorcery_memory_cache *right = arg;
    const char *right_name = arg;
    int cmp;
 
    switch (flags & OBJ_SEARCH_MASK) {
    default:
    case OBJ_SEARCH_OBJECT:
        right_name = right->name;
        /* Fall through */
    case OBJ_SEARCH_KEY:
        cmp = strcmp(left->name, right_name);
        break;
    case OBJ_SEARCH_PARTIAL_KEY:
        cmp = strncmp(left->name, right_name, strlen(right_name));
        break;
    }
    return cmp ? 0 : CMP_MATCH;
}

References CMP_MATCH, sorcery_memory_cache::name, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, and OBJ_SEARCH_PARTIAL_KEY.

Referenced by load_module().

sorcery_memory_cache_complete_name()

static char * sorcery_memory_cache_complete_name ( const char *  word, int  state  )

static

Definition at line 1781 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cache *cache;
    struct ao2_iterator it_caches;
    int wordlen = strlen(word);
    int which = 0;
    char *result = NULL;
 
    it_caches = ao2_iterator_init(caches, 0);
    while ((cache = ao2_iterator_next(&it_caches))) {
        if (!strncasecmp(word, cache->name, wordlen)
            && ++which > state) {
            result = ast_strdup(cache->name);
        }
        ao2_ref(cache, -1);
        if (result) {
            break;
        }
    }
    ao2_iterator_destroy(&it_caches);
    return result;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_strdup, cache, caches, NULL, and result.

Referenced by sorcery_memory_cache_dump(), sorcery_memory_cache_expire(), sorcery_memory_cache_populate(), sorcery_memory_cache_show(), and sorcery_memory_cache_stale().

sorcery_memory_cache_complete_object_name()

static char * sorcery_memory_cache_complete_object_name ( const char *  cache_name, const char *  word, int  state  )

static

Definition at line 1954 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cache *cache;
    struct sorcery_memory_cached_object *cached;
    struct ao2_iterator it_cached;
    int wordlen = strlen(word);
    int which = 0;
    char *result = NULL;
 
    cache = ao2_find(caches, cache_name, OBJ_SEARCH_KEY);
    if (!cache) {
        return NULL;
    }
 
    it_cached = ao2_iterator_init(cache->objects, 0);
    while ((cached = ao2_iterator_next(&it_cached))) {
        if (!strncasecmp(word, ast_sorcery_object_get_id(cached->object), wordlen)
            && ++which > state) {
            result = ast_strdup(ast_sorcery_object_get_id(cached->object));
        }
        ao2_ref(cached, -1);
        if (result) {
            break;
        }
    }
    ao2_iterator_destroy(&it_cached);
 
    ao2_ref(cache, -1);
 
    return result;
}

References ao2_find, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_sorcery_object_get_id(), ast_strdup, cache, caches, NULL, OBJ_SEARCH_KEY, sorcery_memory_cached_object::object, and result.

Referenced by sorcery_memory_cache_expire(), and sorcery_memory_cache_stale().

sorcery_memory_cache_create()

static int sorcery_memory_cache_create ( const struct ast_sorcery *  sorcery, void *  data, void *  object  )

static

Definition at line 823 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cache *cache = data;
    struct sorcery_memory_cached_object *cached;
 
    cached = sorcery_memory_cached_object_alloc(sorcery, cache, object);
    if (!cached) {
        return -1;
    }
 
    /* As there is no guarantee that this won't be called by multiple threads wanting to cache
     * the same object we remove any old ones, which turns this into a create/update function
     * in reality. As well since there's no guarantee that the object in the cache is the same
     * one here we remove any old objects using the object identifier.
     */
 
    ao2_wrlock(cache->objects);
    remove_from_cache(cache, ast_sorcery_object_get_id(object), 1);
    if (cache->maximum_objects && ao2_container_count(cache->objects) >= cache->maximum_objects) {
        if (remove_oldest_from_cache(cache)) {
            ast_log(LOG_ERROR, "Unable to make room in cache for sorcery object '%s'.\n",
                ast_sorcery_object_get_id(object));
            ao2_unlock(cache->objects);
            ao2_ref(cached, -1);
            return -1;
        }
        ast_assert(ao2_container_count(cache->objects) != cache->maximum_objects);
    }
    if (add_to_cache(cache, cached)) {
        ast_log(LOG_ERROR, "Unable to add object '%s' to the cache\n",
            ast_sorcery_object_get_id(object));
        ao2_unlock(cache->objects);
        ao2_ref(cached, -1);
        return -1;
    }
    ao2_unlock(cache->objects);
 
    ao2_ref(cached, -1);
    return 0;
}

References add_to_cache(), ao2_container_count(), ao2_ref, ao2_unlock, ao2_wrlock, ast_assert, ast_log, ast_sorcery_object_get_id(), cache, LOG_ERROR, remove_from_cache(), remove_oldest_from_cache(), sorcery, and sorcery_memory_cached_object_alloc().

Referenced by stale_item_update().

sorcery_memory_cache_delete()

static int sorcery_memory_cache_delete ( const struct ast_sorcery *  sorcery, void *  data, void *  object  )

static

Definition at line 1727 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cache *cache = data;
    int res;
 
    ao2_wrlock(cache->objects);
    res = remove_from_cache(cache, ast_sorcery_object_get_id(object), 1);
    ao2_unlock(cache->objects);
 
    if (res) {
        ast_debug(1, "Unable to delete object '%s' from sorcery cache\n", ast_sorcery_object_get_id(object));
    }
 
    return res;
}

References ao2_unlock, ao2_wrlock, ast_debug, ast_sorcery_object_get_id(), cache, and remove_from_cache().

Referenced by stale_item_update().

sorcery_memory_cache_destructor()

static void sorcery_memory_cache_destructor ( void *  obj )

static

Definition at line 439 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cache *cache = obj;
 
    ast_free(cache->name);
    if (cache->object_heap) {
        ast_heap_destroy(cache->object_heap);
    }
    ao2_cleanup(cache->objects);
    ast_free(cache->object_type);
    ast_mutex_destroy(&cache->populate_lock);
}

References ao2_cleanup, ast_free, ast_heap_destroy(), ast_mutex_destroy, and cache.

Referenced by sorcery_memory_cache_open().

sorcery_memory_cache_dump()

static char * sorcery_memory_cache_dump ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 1897 of file res_sorcery_memory_cache.c.

{
#define FORMAT "%-25.25s %-15.15s %-15.15s \n"
    struct sorcery_memory_cache *cache;
    struct print_object_details details;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "sorcery memory cache dump";
        e->usage =
            "Usage: sorcery memory cache dump <name>\n"
            "       Dump a list of the objects within the cache, listed by object identifier.\n";
        return NULL;
    case CLI_GENERATE:
        if (a->pos == 4) {
            return sorcery_memory_cache_complete_name(a->word, a->n);
        } else {
            return NULL;
        }
    }
 
    if (a->argc != 5) {
        return CLI_SHOWUSAGE;
    }
 
    cache = ao2_find(caches, a->argv[4], OBJ_SEARCH_KEY);
    if (!cache) {
        ast_cli(a->fd, "Specified sorcery memory cache '%s' does not exist\n", a->argv[4]);
        return CLI_FAILURE;
    }
 
    details.cache = cache;
    details.a = a;
 
    ast_cli(a->fd, "Dumping sorcery memory cache '%s':\n", cache->name);
    if (!cache->object_lifetime_stale) {
        ast_cli(a->fd, " * Staleness is not enabled - objects will not go stale\n");
    }
    if (!cache->object_lifetime_maximum) {
        ast_cli(a->fd, " * Object lifetime is not enabled - objects will not expire\n");
    }
    ast_cli(a->fd, FORMAT, "Object Name", "Stale In", "Expires In");
    ast_cli(a->fd, FORMAT, "-------------------------", "---------------", "---------------");
    ao2_callback(cache->objects, OBJ_NODATA | OBJ_MULTIPLE, sorcery_memory_cache_print_object, &details);
    ast_cli(a->fd, FORMAT, "-------------------------", "---------------", "---------------");
    ast_cli(a->fd, "Total number of objects cached: %d\n", ao2_container_count(cache->objects));
 
    ao2_ref(cache, -1);
 
    return CLI_SUCCESS;
#undef FORMAT
}

References print_object_details::a, a, ao2_callback, ao2_container_count(), ao2_find, ao2_ref, ast_cli(), cache, print_object_details::cache, caches, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, FORMAT, NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_SEARCH_KEY, sorcery_memory_cache_complete_name(), sorcery_memory_cache_print_object(), and ast_cli_entry::usage.

sorcery_memory_cache_expire()

static char * sorcery_memory_cache_expire ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 1990 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cache *cache;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "sorcery memory cache expire";
        e->usage =
            "Usage: sorcery memory cache expire <cache name> [object name]\n"
            "       Expire a specific object or ALL objects within a sorcery memory cache.\n";
        return NULL;
    case CLI_GENERATE:
        if (a->pos == 4) {
            return sorcery_memory_cache_complete_name(a->word, a->n);
        } else if (a->pos == 5) {
            return sorcery_memory_cache_complete_object_name(a->argv[4], a->word, a->n);
        } else {
            return NULL;
        }
    }
 
    if (a->argc < 5 || a->argc > 6) {
        return CLI_SHOWUSAGE;
    }
 
    cache = ao2_find(caches, a->argv[4], OBJ_SEARCH_KEY);
    if (!cache) {
        ast_cli(a->fd, "Specified sorcery memory cache '%s' does not exist\n", a->argv[4]);
        return CLI_FAILURE;
    }
 
    ao2_wrlock(cache->objects);
    if (a->argc == 5) {
        remove_all_from_cache(cache);
        ast_cli(a->fd, "All objects have been removed from cache '%s'\n", a->argv[4]);
    } else {
        if (cache->full_backend_cache) {
            ast_cli(a->fd, "Due to full backend caching per-object expiration is not available on cache '%s'\n", a->argv[4]);
        } else if (!remove_from_cache(cache, a->argv[5], 1)) {
            ast_cli(a->fd, "Successfully expired object '%s' from cache '%s'\n", a->argv[5], a->argv[4]);
        } else {
            ast_cli(a->fd, "Object '%s' was not expired from cache '%s' as it was not found\n", a->argv[5],
                a->argv[4]);
        }
    }
    ao2_unlock(cache->objects);
 
    ao2_ref(cache, -1);
 
    return CLI_SUCCESS;
}

References a, ao2_find, ao2_ref, ao2_unlock, ao2_wrlock, ast_cli(), cache, caches, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, OBJ_SEARCH_KEY, remove_all_from_cache(), remove_from_cache(), sorcery_memory_cache_complete_name(), sorcery_memory_cache_complete_object_name(), and ast_cli_entry::usage.

sorcery_memory_cache_fields_cmp()

static int sorcery_memory_cache_fields_cmp ( void *  obj, void *  arg, int  flags  )

static

Definition at line 1378 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cached_object *cached = obj;
    const struct sorcery_memory_cache_fields_cmp_params *params = arg;
    RAII_VAR(struct ast_variable *, diff, NULL, ast_variables_destroy);
 
    if (params->regex) {
        /* If a regular expression has been provided see if it matches, otherwise move on */
        if (!regexec(params->regex, ast_sorcery_object_get_id(cached->object), 0, NULL, 0)) {
            ao2_link(params->container, cached->object);
        }
        return 0;
    } else if (params->prefix) {
        if (!strncmp(params->prefix, ast_sorcery_object_get_id(cached->object), params->prefix_len)) {
            ao2_link(params->container, cached->object);
        }
        return 0;
    } else if (params->fields &&
         (!ast_variable_lists_match(cached->objectset, params->fields, 0))) {
        /* 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.
         */
        return 0;
    }
 
    if (params->container) {
        ao2_link(params->container, cached->object);
 
        /* 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;
    }
}

References ao2_link, ast_sorcery_object_get_id(), ast_variable_lists_match(), ast_variables_destroy(), CMP_MATCH, CMP_STOP, sorcery_memory_cache_fields_cmp_params::container, sorcery_memory_cache_fields_cmp_params::fields, NULL, sorcery_memory_cached_object::object, sorcery_memory_cached_object::objectset, sorcery_memory_cache_fields_cmp_params::prefix, sorcery_memory_cache_fields_cmp_params::prefix_len, RAII_VAR, and sorcery_memory_cache_fields_cmp_params::regex.

Referenced by sorcery_memory_cache_retrieve_fields(), sorcery_memory_cache_retrieve_multiple(), sorcery_memory_cache_retrieve_prefix(), and sorcery_memory_cache_retrieve_regex().

sorcery_memory_cache_hash()

static int sorcery_memory_cache_hash ( const void *  obj, int  flags  )

static

Definition at line 312 of file res_sorcery_memory_cache.c.

{
    const struct sorcery_memory_cache *cache = obj;
    const char *name = obj;
    int hash;
 
    switch (flags & OBJ_SEARCH_MASK) {
    default:
    case OBJ_SEARCH_OBJECT:
        name = cache->name;
        /* Fall through */
    case OBJ_SEARCH_KEY:
        hash = ast_str_hash(name);
        break;
    case OBJ_SEARCH_PARTIAL_KEY:
        /* Should never happen in hash callback. */
        ast_assert(0);
        hash = 0;
        break;
    }
    return hash;
}

References ast_assert, ast_str_hash(), cache, name, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, and OBJ_SEARCH_PARTIAL_KEY.

Referenced by load_module().

sorcery_memory_cache_load()

static void sorcery_memory_cache_load ( void *  data, const struct ast_sorcery *  sorcery, const char *  type  )

static

Definition at line 1560 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cache *cache = data;
 
    /* If no name was explicitly specified generate one given the sorcery instance and object type */
    if (ast_strlen_zero(cache->name)) {
        ast_asprintf(&cache->name, "%s/%s", ast_sorcery_get_module(sorcery), type);
    }
 
    ao2_link(caches, cache);
    ast_debug(1, "Memory cache '%s' associated with sorcery instance '%p' of module '%s' with object type '%s'\n",
        cache->name, sorcery, ast_sorcery_get_module(sorcery), type);
 
    cache->sorcery = sorcery;
    cache->object_type = ast_strdup(type);
}

References ao2_link, ast_asprintf, ast_debug, ast_sorcery_get_module(), ast_strdup, ast_strlen_zero(), cache, caches, sorcery, and type.

sorcery_memory_cache_open()

static void * sorcery_memory_cache_open ( const char *  data )

static

Definition at line 1632 of file res_sorcery_memory_cache.c.

{
    char *options = ast_strdupa(data), *option;
    RAII_VAR(struct sorcery_memory_cache *, cache, NULL, ao2_cleanup);
 
    cache = ao2_alloc_options(sizeof(*cache), sorcery_memory_cache_destructor, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!cache) {
        return NULL;
    }
 
    cache->expire_id = -1;
    cache->stale_update_sched_id = -1;
 
    /* If no configuration options have been provided this memory cache will operate in a default
     * configuration.
     */
    while (!ast_strlen_zero(options) && (option = strsep(&options, ","))) {
        char *name = strsep(&option, "="), *value = option;
 
        if (!strcasecmp(name, "name")) {
            if (ast_strlen_zero(value)) {
                ast_log(LOG_ERROR, "A name must be specified for the memory cache\n");
                return NULL;
            }
            ast_free(cache->name);
            cache->name = ast_strdup(value);
        } else if (!strcasecmp(name, "maximum_objects")) {
            if (configuration_parse_unsigned_integer(value, &cache->maximum_objects) != 1) {
                ast_log(LOG_ERROR, "Unsupported maximum objects value of '%s' used for memory cache\n",
                    value);
                return NULL;
            }
        } else if (!strcasecmp(name, "object_lifetime_maximum")) {
            if (configuration_parse_unsigned_integer(value, &cache->object_lifetime_maximum) != 1) {
                ast_log(LOG_ERROR, "Unsupported object maximum lifetime value of '%s' used for memory cache\n",
                    value);
                return NULL;
            }
        } else if (!strcasecmp(name, "object_lifetime_stale")) {
            if (configuration_parse_unsigned_integer(value, &cache->object_lifetime_stale) != 1) {
                ast_log(LOG_ERROR, "Unsupported object stale lifetime value of '%s' used for memory cache\n",
                    value);
                return NULL;
            }
        } else if (!strcasecmp(name, "expire_on_reload")) {
            cache->expire_on_reload = ast_true(value);
        } else if (!strcasecmp(name, "full_backend_cache")) {
            cache->full_backend_cache = ast_true(value);
        } else {
            ast_log(LOG_ERROR, "Unsupported option '%s' used for memory cache\n", name);
            return NULL;
        }
    }
 
    cache->objects = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_RWLOCK, 0,
        cache->maximum_objects ? cache->maximum_objects : CACHE_CONTAINER_BUCKET_SIZE,
        sorcery_memory_cached_object_hash, NULL, sorcery_memory_cached_object_cmp);
    if (!cache->objects) {
        ast_log(LOG_ERROR, "Could not create a container to hold cached objects for memory cache\n");
        return NULL;
    }
 
    cache->object_heap = ast_heap_create(CACHE_HEAP_INIT_HEIGHT, age_cmp,
        offsetof(struct sorcery_memory_cached_object, __heap_index));
    if (!cache->object_heap) {
        ast_log(LOG_ERROR, "Could not create heap to hold cached objects\n");
        return NULL;
    }
 
    if (ast_mutex_init(&cache->populate_lock)) {
        ast_log(LOG_ERROR, "Could not create populate lock for cache\n");
        return NULL;
    }
 
    /* The memory cache is not linked to the caches container until the load callback is invoked.
     * Linking occurs there so an intelligent cache name can be constructed using the module of
     * the sorcery instance and the specific object type if no cache name was specified as part
     * of the configuration.
     */
 
    /* This is done as RAII_VAR will drop the reference */
    return ao2_bump(cache);
}

References age_cmp(), AO2_ALLOC_OPT_LOCK_NOLOCK, AO2_ALLOC_OPT_LOCK_RWLOCK, ao2_alloc_options, ao2_bump, ao2_cleanup, ao2_container_alloc_hash, ast_free, ast_heap_create, ast_log, ast_mutex_init, ast_strdup, ast_strdupa, ast_strlen_zero(), ast_true(), cache, CACHE_CONTAINER_BUCKET_SIZE, CACHE_HEAP_INIT_HEIGHT, configuration_parse_unsigned_integer(), LOG_ERROR, name, NULL, options, RAII_VAR, sorcery_memory_cache_destructor(), sorcery_memory_cached_object_cmp(), sorcery_memory_cached_object_hash(), strsep(), and value.

sorcery_memory_cache_populate()

static char * sorcery_memory_cache_populate ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 2130 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cache *cache;
    struct ast_sorcery *sorcery;
    const char *object_type;
    int num_cached;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "sorcery memory cache populate";
        e->usage =
            "Usage: sorcery memory cache populate <cache name>\n"
            "       Expire all objects in the cache and populate it with ALL objects from backend.\n";
        return NULL;
    case CLI_GENERATE:
        if (a->pos == 4) {
            return sorcery_memory_cache_complete_name(a->word, a->n);
        } else {
            return NULL;
        }
    }
 
    if (a->argc != 5) {
        return CLI_SHOWUSAGE;
    }
 
    cache = ao2_find(caches, a->argv[4], OBJ_SEARCH_KEY);
    if (!cache) {
        ast_cli(a->fd, "Specified sorcery memory cache '%s' does not exist\n", a->argv[4]);
        return CLI_FAILURE;
    }
 
    if (!cache->full_backend_cache) {
        ast_cli(a->fd, "Specified sorcery memory cache '%s' does not have full backend caching enabled\n", a->argv[4]);
        ao2_ref(cache, -1);
        return CLI_FAILURE;
    }
 
    /* Acquire the populate lock to ensure only one population at a time */
    ast_mutex_lock(&cache->populate_lock);
 
    /* Quick check with read lock to see if cache is still active */
    ao2_rdlock(cache->objects);
    if (!cache->sorcery) {
        ast_cli(a->fd, "Specified sorcery memory cache '%s' is no longer active\n", a->argv[4]);
        ao2_unlock(cache->objects);
        ast_mutex_unlock(&cache->populate_lock);
        ao2_ref(cache, -1);
        return CLI_FAILURE;
    }
 
    /* Get sorcery reference while we have the lock, safe to un-const as the ao2 ref change is allowed and safe */
    sorcery = ao2_bump((struct ast_sorcery *)cache->sorcery);
    object_type = cache->object_type;
 
    /* Unlock and populate the cache - memory_cache_populate_external will handle locking internally */
    ao2_unlock(cache->objects);
    num_cached = memory_cache_populate_external(sorcery, object_type, cache);
 
    ao2_ref(sorcery, -1);
    ast_mutex_unlock(&cache->populate_lock);
    ao2_ref(cache, -1);
 
    if (num_cached < 0) {
        ast_cli(a->fd, "An error occurred while populating sorcery memory cache '%s'\n", a->argv[4]);
    } else {
        ast_cli(a->fd, "Specified sorcery memory cache '%s' has been populated with '%d' objects from the backend\n",
        a->argv[4], num_cached);
    }
 
    return CLI_SUCCESS;
}

References a, ao2_bump, ao2_find, ao2_rdlock, ao2_ref, ao2_unlock, ast_cli(), ast_mutex_lock, ast_mutex_unlock, cache, caches, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, memory_cache_populate_external(), NULL, OBJ_SEARCH_KEY, sorcery, sorcery_memory_cache_complete_name(), and ast_cli_entry::usage.

sorcery_memory_cache_print_object()

static int sorcery_memory_cache_print_object ( void *  obj, void *  arg, int  flags  )

static

Definition at line 1873 of file res_sorcery_memory_cache.c.

{
#define FORMAT "%-25.25s %-15u %-15u \n"
    struct sorcery_memory_cached_object *cached = obj;
    struct print_object_details *details = arg;
    int seconds_until_expire = 0, seconds_until_stale = 0;
 
    if (details->cache->object_lifetime_maximum) {
        seconds_until_expire = ast_tvdiff_ms(ast_tvadd(cached->created, ast_samp2tv(details->cache->object_lifetime_maximum, 1)), ast_tvnow()) / 1000;
    }
    if (details->cache->object_lifetime_stale) {
        seconds_until_stale = ast_tvdiff_ms(ast_tvadd(cached->created, ast_samp2tv(details->cache->object_lifetime_stale, 1)), ast_tvnow()) / 1000;
    }
 
    ast_cli(details->a->fd, FORMAT, ast_sorcery_object_get_id(cached->object), MAX(seconds_until_stale, 0), MAX(seconds_until_expire, 0));
 
    return CMP_MATCH;
#undef FORMAT
}

References print_object_details::a, ast_cli(), ast_samp2tv(), ast_sorcery_object_get_id(), ast_tvadd(), ast_tvdiff_ms(), ast_tvnow(), print_object_details::cache, CMP_MATCH, sorcery_memory_cached_object::created, ast_cli_args::fd, FORMAT, MAX, sorcery_memory_cached_object::object, sorcery_memory_cache::object_lifetime_maximum, and sorcery_memory_cache::object_lifetime_stale.

Referenced by sorcery_memory_cache_dump().

sorcery_memory_cache_reload()

static void sorcery_memory_cache_reload ( void *  data, const struct ast_sorcery *  sorcery, const char *  type  )

static

Definition at line 1585 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cache *cache = data;
 
    if (!cache->expire_on_reload) {
        return;
    }
 
    ao2_wrlock(cache->objects);
    remove_all_from_cache(cache);
    ao2_unlock(cache->objects);
}

References ao2_unlock, ao2_wrlock, cache, and remove_all_from_cache().

sorcery_memory_cache_retrieve_fields()

static void * sorcery_memory_cache_retrieve_fields ( const struct ast_sorcery *  sorcery, void *  data, const char *  type, const struct ast_variable *  fields  )

static

Definition at line 1423 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cache *cache = data;
    struct sorcery_memory_cache_fields_cmp_params params = {
        .sorcery = sorcery,
        .cache = cache,
        .fields = fields,
    };
    struct sorcery_memory_cached_object *cached;
    void *object = NULL;
 
    if (is_passthru_update() || !cache->full_backend_cache || !fields) {
        return NULL;
    }
 
    cached = ao2_callback(cache->objects, 0, sorcery_memory_cache_fields_cmp, &params);
 
    if (cached) {
        memory_cache_stale_check_object(sorcery, cache, cached);
        object = ao2_bump(cached->object);
        ao2_ref(cached, -1);
    }
 
    return object;
}

References ao2_bump, ao2_callback, ao2_ref, cache, sorcery_memory_cache_fields_cmp_params::fields, is_passthru_update(), memory_cache_stale_check_object(), NULL, sorcery_memory_cached_object::object, sorcery, sorcery_memory_cache_fields_cmp_params::sorcery, and sorcery_memory_cache_fields_cmp().

sorcery_memory_cache_retrieve_id()

static void * sorcery_memory_cache_retrieve_id ( const struct ast_sorcery *  sorcery, void *  data, const char *  type, const char *  id  )

static

Definition at line 1343 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cache *cache = data;
    struct sorcery_memory_cached_object *cached;
    void *object;
 
    if (is_passthru_update()) {
        return NULL;
    }
 
    memory_cache_full_update(sorcery, type, cache);
 
    cached = ao2_find(cache->objects, id, OBJ_SEARCH_KEY);
    if (!cached) {
        return NULL;
    }
 
    ast_assert(!strcmp(ast_sorcery_object_get_id(cached->object), id));
 
    memory_cache_stale_check_object(sorcery, cache, cached);
 
    object = ao2_bump(cached->object);
    ao2_ref(cached, -1);
 
    return object;
}

References ao2_bump, ao2_find, ao2_ref, ast_assert, ast_sorcery_object_get_id(), cache, is_passthru_update(), memory_cache_full_update(), memory_cache_stale_check_object(), NULL, OBJ_SEARCH_KEY, sorcery_memory_cached_object::object, sorcery, and type.

sorcery_memory_cache_retrieve_multiple()

static void sorcery_memory_cache_retrieve_multiple ( const struct ast_sorcery *  sorcery, void *  data, const char *  type, struct ao2_container *  objects, const struct ast_variable *  fields  )

static

Definition at line 1460 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cache *cache = data;
    struct sorcery_memory_cache_fields_cmp_params params = {
        .sorcery = sorcery,
        .cache = cache,
        .fields = fields,
        .container = objects,
    };
 
    if (is_passthru_update() || !cache->full_backend_cache) {
        return;
    }
 
    memory_cache_full_update(sorcery, type, cache);
    ao2_callback(cache->objects, 0, sorcery_memory_cache_fields_cmp, &params);
 
    if (ao2_container_count(objects)) {
        memory_cache_stale_check(sorcery, cache);
    }
}

References ao2_callback, ao2_container_count(), cache, sorcery_memory_cache_fields_cmp_params::fields, is_passthru_update(), memory_cache_full_update(), memory_cache_stale_check(), sorcery, sorcery_memory_cache_fields_cmp_params::sorcery, sorcery_memory_cache_fields_cmp(), and type.

sorcery_memory_cache_retrieve_prefix()

static void sorcery_memory_cache_retrieve_prefix ( const struct ast_sorcery *  sorcery, void *  data, const char *  type, struct ao2_container *  objects, const char *  prefix, const size_t  prefix_len  )

static

Definition at line 1528 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cache *cache = data;
    struct sorcery_memory_cache_fields_cmp_params params = {
        .sorcery = sorcery,
        .cache = cache,
        .container = objects,
        .prefix = prefix,
        .prefix_len = prefix_len,
    };
 
    if (is_passthru_update() || !cache->full_backend_cache) {
        return;
    }
 
    memory_cache_full_update(sorcery, type, cache);
    ao2_callback(cache->objects, 0, sorcery_memory_cache_fields_cmp, &params);
 
    if (ao2_container_count(objects)) {
        memory_cache_stale_check(sorcery, cache);
    }
}

References ao2_callback, ao2_container_count(), cache, is_passthru_update(), memory_cache_full_update(), memory_cache_stale_check(), prefix, sorcery_memory_cache_fields_cmp_params::prefix_len, sorcery, sorcery_memory_cache_fields_cmp_params::sorcery, sorcery_memory_cache_fields_cmp(), and type.

sorcery_memory_cache_retrieve_regex()

static void sorcery_memory_cache_retrieve_regex ( const struct ast_sorcery *  sorcery, void *  data, const char *  type, struct ao2_container *  objects, const char *  regex  )

static

Definition at line 1493 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cache *cache = data;
    regex_t expression;
    struct sorcery_memory_cache_fields_cmp_params params = {
        .sorcery = sorcery,
        .cache = cache,
        .container = objects,
        .regex = &expression,
    };
 
    if (is_passthru_update() || !cache->full_backend_cache || regcomp(&expression, regex, REG_EXTENDED | REG_NOSUB)) {
        return;
    }
 
    memory_cache_full_update(sorcery, type, cache);
    ao2_callback(cache->objects, 0, sorcery_memory_cache_fields_cmp, &params);
    regfree(&expression);
 
    if (ao2_container_count(objects)) {
        memory_cache_stale_check(sorcery, cache);
    }
}

References ao2_callback, ao2_container_count(), cache, is_passthru_update(), memory_cache_full_update(), memory_cache_stale_check(), regex(), sorcery, sorcery_memory_cache_fields_cmp_params::sorcery, sorcery_memory_cache_fields_cmp(), and type.

sorcery_memory_cache_show()

static char * sorcery_memory_cache_show ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 1808 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cache *cache;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "sorcery memory cache show";
        e->usage =
            "Usage: sorcery memory cache show <name>\n"
            "       Show sorcery memory cache configuration and statistics.\n";
        return NULL;
    case CLI_GENERATE:
        if (a->pos == 4) {
            return sorcery_memory_cache_complete_name(a->word, a->n);
        } else {
            return NULL;
        }
    }
 
    if (a->argc != 5) {
        return CLI_SHOWUSAGE;
    }
 
    cache = ao2_find(caches, a->argv[4], OBJ_SEARCH_KEY);
    if (!cache) {
        ast_cli(a->fd, "Specified sorcery memory cache '%s' does not exist\n", a->argv[4]);
        return CLI_FAILURE;
    }
 
    ast_cli(a->fd, "Sorcery memory cache: %s\n", cache->name);
    ast_cli(a->fd, "Number of objects within cache: %d\n", ao2_container_count(cache->objects));
    if (cache->maximum_objects) {
        ast_cli(a->fd, "Maximum allowed objects: %d\n", cache->maximum_objects);
    } else {
        ast_cli(a->fd, "There is no limit on the maximum number of objects in the cache\n");
    }
    if (cache->object_lifetime_maximum) {
        ast_cli(a->fd, "Number of seconds before object expires: %d\n", cache->object_lifetime_maximum);
    } else {
        ast_cli(a->fd, "Object expiration is not enabled - cached objects will not expire\n");
    }
    if (cache->object_lifetime_stale) {
        ast_cli(a->fd, "Number of seconds before object becomes stale: %d\n", cache->object_lifetime_stale);
    } else {
        ast_cli(a->fd, "Object staleness is not enabled - cached objects will not go stale\n");
    }
    ast_cli(a->fd, "Expire all objects on reload: %s\n", AST_CLI_ONOFF(cache->expire_on_reload));
 
    ao2_ref(cache, -1);
 
    return CLI_SUCCESS;
}

References a, ao2_container_count(), ao2_find, ao2_ref, ast_cli(), AST_CLI_ONOFF, cache, caches, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, OBJ_SEARCH_KEY, sorcery_memory_cache_complete_name(), and ast_cli_entry::usage.

sorcery_memory_cache_stale()

static char * sorcery_memory_cache_stale ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 2046 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cache *cache;
    int reload = 0;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "sorcery memory cache stale";
        e->usage =
            "Usage: sorcery memory cache stale <cache name> [object name [reload]]\n"
            "       Mark a specific object or ALL objects as stale in a sorcery memory cache.\n"
            "       If \"reload\" is specified, then the object is marked stale and immediately\n"
            "       retrieved from backend storage to repopulate the cache\n";
        return NULL;
    case CLI_GENERATE:
        if (a->pos == 4) {
            return sorcery_memory_cache_complete_name(a->word, a->n);
        } else if (a->pos == 5) {
            return sorcery_memory_cache_complete_object_name(a->argv[4], a->word, a->n);
        } else if (a->pos == 6) {
            static const char * const completions[] = { "reload", NULL };
            return ast_cli_complete(a->word, completions, a->n);
        } else {
            return NULL;
        }
    }
 
    if (a->argc < 5 || a->argc > 7) {
        return CLI_SHOWUSAGE;
    }
 
    if (a->argc == 7) {
        if (!strcasecmp(a->argv[6], "reload")) {
            reload = 1;
        } else {
            return CLI_SHOWUSAGE;
        }
    }
 
    cache = ao2_find(caches, a->argv[4], OBJ_SEARCH_KEY);
    if (!cache) {
        ast_cli(a->fd, "Specified sorcery memory cache '%s' does not exist\n", a->argv[4]);
        return CLI_FAILURE;
    }
 
    if (!cache->object_lifetime_stale) {
        ast_cli(a->fd, "Specified sorcery memory cache '%s' does not have staleness enabled\n", a->argv[4]);
        ao2_ref(cache, -1);
        return CLI_FAILURE;
    }
 
    ao2_rdlock(cache->objects);
    if (a->argc == 5) {
        mark_all_as_stale_in_cache(cache);
        ast_cli(a->fd, "Marked all objects in sorcery memory cache '%s' as stale\n", a->argv[4]);
    } else {
        if (!mark_object_as_stale_in_cache(cache, a->argv[5])) {
            ast_cli(a->fd, "Successfully marked object '%s' in memory cache '%s' as stale\n",
                a->argv[5], a->argv[4]);
            if (reload) {
                struct sorcery_memory_cached_object *cached;
 
                cached = ao2_find(cache->objects, a->argv[5], OBJ_SEARCH_KEY | OBJ_NOLOCK);
                if (cached) {
                    memory_cache_stale_update_object(cache->sorcery, cache, cached);
                    ao2_ref(cached, -1);
                }
            }
        } else {
            ast_cli(a->fd, "Object '%s' in sorcery memory cache '%s' could not be marked as stale as it was not found\n",
                a->argv[5], a->argv[4]);
        }
    }
    ao2_unlock(cache->objects);
 
    ao2_ref(cache, -1);
 
    return CLI_SUCCESS;
}

References a, ao2_find, ao2_rdlock, ao2_ref, ao2_unlock, ast_cli(), ast_cli_complete(), cache, caches, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, mark_all_as_stale_in_cache(), mark_object_as_stale_in_cache(), memory_cache_stale_update_object(), NULL, OBJ_NOLOCK, OBJ_SEARCH_KEY, reload(), sorcery_memory_cache_complete_name(), sorcery_memory_cache_complete_object_name(), and ast_cli_entry::usage.

sorcery_memory_cached_object_alloc()

static struct sorcery_memory_cached_object * sorcery_memory_cached_object_alloc ( const struct ast_sorcery *  sorcery, const struct sorcery_memory_cache *  cache, void *  object  )

static

Definition at line 784 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cached_object *cached;
 
    cached = ao2_alloc(sizeof(*cached), sorcery_memory_cached_object_destructor);
    if (!cached) {
        return NULL;
    }
 
    cached->object = ao2_bump(object);
    cached->created = ast_tvnow();
    cached->stale_update_sched_id = -1;
 
    if (cache->full_backend_cache) {
        /* A cached objectset allows us to easily perform all retrieval operations in a
         * minimal of time.
         */
        cached->objectset = ast_sorcery_objectset_create(sorcery, object);
        if (!cached->objectset) {
            ao2_ref(cached, -1);
            return NULL;
        }
    }
 
    return cached;
}

References ao2_alloc, ao2_bump, ao2_ref, ast_sorcery_objectset_create, ast_tvnow(), cache, sorcery_memory_cached_object::created, NULL, sorcery_memory_cached_object::object, sorcery_memory_cached_object::objectset, sorcery, sorcery_memory_cached_object_destructor(), and sorcery_memory_cached_object::stale_update_sched_id.

Referenced by memory_cache_populate_external(), object_add_to_cache_callback(), and sorcery_memory_cache_create().

sorcery_memory_cached_object_cmp()

static int sorcery_memory_cached_object_cmp ( void *  obj, void *  arg, int  flags  )

static

Definition at line 411 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cached_object *left = obj;
    struct sorcery_memory_cached_object *right = arg;
    const char *right_name = arg;
    int cmp;
 
    switch (flags & OBJ_SEARCH_MASK) {
    default:
    case OBJ_SEARCH_OBJECT:
        right_name = ast_sorcery_object_get_id(right->object);
        /* Fall through */
    case OBJ_SEARCH_KEY:
        cmp = strcmp(ast_sorcery_object_get_id(left->object), right_name);
        break;
    case OBJ_SEARCH_PARTIAL_KEY:
        cmp = strncmp(ast_sorcery_object_get_id(left->object), right_name, strlen(right_name));
        break;
    }
    return cmp ? 0 : CMP_MATCH;
}

References ast_sorcery_object_get_id(), CMP_MATCH, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, OBJ_SEARCH_PARTIAL_KEY, and sorcery_memory_cached_object::object.

Referenced by sorcery_memory_cache_open().

sorcery_memory_cached_object_destructor()

static void sorcery_memory_cached_object_destructor ( void *  obj )

static

Definition at line 458 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cached_object *cached = obj;
 
    ao2_cleanup(cached->object);
    ast_variables_destroy(cached->objectset);
}

References ao2_cleanup, ast_variables_destroy(), sorcery_memory_cached_object::object, and sorcery_memory_cached_object::objectset.

Referenced by sorcery_memory_cached_object_alloc().

sorcery_memory_cached_object_hash()

static int sorcery_memory_cached_object_hash ( const void *  obj, int  flags  )

static

Definition at line 377 of file res_sorcery_memory_cache.c.

{
    const struct sorcery_memory_cached_object *cached = obj;
    const char *name = obj;
    int hash;
 
    switch (flags & OBJ_SEARCH_MASK) {
    default:
    case OBJ_SEARCH_OBJECT:
        name = ast_sorcery_object_get_id(cached->object);
        /* Fall through */
    case OBJ_SEARCH_KEY:
        hash = ast_str_hash(name);
        break;
    case OBJ_SEARCH_PARTIAL_KEY:
        /* Should never happen in hash callback. */
        ast_assert(0);
        hash = 0;
        break;
    }
    return hash;
}

References ast_assert, ast_sorcery_object_get_id(), ast_str_hash(), name, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, OBJ_SEARCH_PARTIAL_KEY, and sorcery_memory_cached_object::object.

Referenced by sorcery_memory_cache_open().

stale_cache_update()

static int stale_cache_update ( const void *  data )

static

Definition at line 926 of file res_sorcery_memory_cache.c.

{
    struct stale_cache_update_task_data *task_data = (struct stale_cache_update_task_data *) data;
    struct ao2_container *backend_objects;
 
    start_passthru_update();
    backend_objects = ast_sorcery_retrieve_by_fields(task_data->sorcery, task_data->type,
        AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
    end_passthru_update();
 
    if (!backend_objects) {
        task_data->cache->stale_update_sched_id = -1;
        ao2_ref(task_data, -1);
        return 0;
    }
 
    if (task_data->cache->maximum_objects && ao2_container_count(backend_objects) >= task_data->cache->maximum_objects) {
        ast_log(LOG_ERROR, "The backend contains %d objects while the sorcery memory cache '%s' is explicitly configured to only allow %d\n",
            ao2_container_count(backend_objects), task_data->cache->name, task_data->cache->maximum_objects);
        task_data->cache->stale_update_sched_id = -1;
        ao2_ref(task_data, -1);
        return 0;
    }
 
    ao2_wrlock(task_data->cache->objects);
    remove_all_from_cache(task_data->cache);
    ao2_callback_data(backend_objects, OBJ_NOLOCK | OBJ_NODATA | OBJ_MULTIPLE, object_add_to_cache_callback,
        task_data->sorcery, task_data->cache);
 
    /* If the number of cached objects does not match the number of backend objects we encountered a memory allocation
     * failure and the cache is incomplete, so drop everything and fall back to querying the backend directly
     * as it may be able to provide what is wanted.
     */
    if (ao2_container_count(task_data->cache->objects) != ao2_container_count(backend_objects)) {
        ast_log(LOG_WARNING, "The backend contains %d objects while only %d could be added to sorcery memory cache '%s'\n",
            ao2_container_count(backend_objects), ao2_container_count(task_data->cache->objects), task_data->cache->name);
        remove_all_from_cache(task_data->cache);
    }
 
    ao2_unlock(task_data->cache->objects);
    ao2_ref(backend_objects, -1);
 
    task_data->cache->stale_update_sched_id = -1;
    ao2_ref(task_data, -1);
 
    return 0;
}

References ao2_callback_data, ao2_container_count(), ao2_ref, ao2_unlock, ao2_wrlock, ast_log, AST_RETRIEVE_FLAG_ALL, AST_RETRIEVE_FLAG_MULTIPLE, ast_sorcery_retrieve_by_fields(), end_passthru_update(), LOG_ERROR, LOG_WARNING, NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_NOLOCK, object_add_to_cache_callback(), remove_all_from_cache(), and start_passthru_update().

Referenced by memory_cache_stale_update_full().

stale_cache_update_task_data_alloc()

static struct stale_cache_update_task_data * stale_cache_update_task_data_alloc ( struct ast_sorcery *  sorcery, struct sorcery_memory_cache *  cache, const char *  type  )

static

Definition at line 904 of file res_sorcery_memory_cache.c.

{
    struct stale_cache_update_task_data *task_data;
 
    task_data = ao2_alloc_options(sizeof(*task_data), stale_cache_update_task_data_destructor,
        AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!task_data) {
        return NULL;
    }
 
    task_data->sorcery = ao2_bump(sorcery);
    task_data->cache = ao2_bump(cache);
    task_data->type = ast_strdup(type);
    if (!task_data->type) {
        ao2_ref(task_data, -1);
        return NULL;
    }
 
    return task_data;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_bump, ao2_ref, ast_strdup, cache, NULL, sorcery, stale_cache_update_task_data_destructor(), and type.

Referenced by memory_cache_stale_update_full().

stale_cache_update_task_data_destructor()

static void stale_cache_update_task_data_destructor ( void *  obj )

static

Definition at line 895 of file res_sorcery_memory_cache.c.

{
    struct stale_cache_update_task_data *task_data = obj;
 
    ao2_cleanup(task_data->cache);
    ast_sorcery_unref(task_data->sorcery);
    ast_free(task_data->type);
}

References ao2_cleanup, ast_free, and ast_sorcery_unref.

Referenced by stale_cache_update_task_data_alloc().

stale_item_update()

static int stale_item_update ( const void *  data )

static

Definition at line 1007 of file res_sorcery_memory_cache.c.

{
    struct stale_update_task_data *task_data = (struct stale_update_task_data *) data;
    void *object;
 
    start_passthru_update();
 
    object = ast_sorcery_retrieve_by_id(task_data->sorcery,
        ast_sorcery_object_get_type(task_data->object),
        ast_sorcery_object_get_id(task_data->object));
    if (!object) {
        ast_debug(1, "Backend no longer has object type '%s' ID '%s'. Removing from cache\n",
            ast_sorcery_object_get_type(task_data->object),
            ast_sorcery_object_get_id(task_data->object));
        sorcery_memory_cache_delete(task_data->sorcery, task_data->cache,
            task_data->object);
    } else {
        ast_debug(1, "Refreshing stale cache object type '%s' ID '%s'\n",
            ast_sorcery_object_get_type(task_data->object),
            ast_sorcery_object_get_id(task_data->object));
        sorcery_memory_cache_create(task_data->sorcery, task_data->cache,
            object);
        ao2_ref(object, -1);
    }
 
    ast_test_suite_event_notify("SORCERY_MEMORY_CACHE_REFRESHED", "Cache: %s\r\nType: %s\r\nName: %s\r\n",
        task_data->cache->name, ast_sorcery_object_get_type(task_data->object),
        ast_sorcery_object_get_id(task_data->object));
 
    ao2_ref(task_data, -1);
    end_passthru_update();
 
    return 0;
}

References ao2_ref, ast_debug, ast_sorcery_object_get_id(), ast_sorcery_object_get_type(), ast_sorcery_retrieve_by_id(), ast_test_suite_event_notify, end_passthru_update(), stale_update_task_data::object, sorcery_memory_cache_create(), sorcery_memory_cache_delete(), and start_passthru_update().

Referenced by memory_cache_stale_update_object().

stale_update_task_data_alloc()

static struct stale_update_task_data * stale_update_task_data_alloc ( struct ast_sorcery *  sorcery, struct sorcery_memory_cache *  cache, const char *  type, void *  object  )

static

Definition at line 989 of file res_sorcery_memory_cache.c.

{
    struct stale_update_task_data *task_data;
 
    task_data = ao2_alloc_options(sizeof(*task_data), stale_update_task_data_destructor,
        AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!task_data) {
        return NULL;
    }
 
    task_data->sorcery = ao2_bump(sorcery);
    task_data->cache = ao2_bump(cache);
    task_data->object = ao2_bump(object);
 
    return task_data;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_bump, cache, NULL, sorcery, and stale_update_task_data_destructor().

Referenced by memory_cache_stale_update_object().

stale_update_task_data_destructor()

static void stale_update_task_data_destructor ( void *  obj )

static

Definition at line 980 of file res_sorcery_memory_cache.c.

{
    struct stale_update_task_data *task_data = obj;
 
    ao2_cleanup(task_data->cache);
    ao2_cleanup(task_data->object);
    ast_sorcery_unref(task_data->sorcery);
}

References ao2_cleanup, and ast_sorcery_unref.

Referenced by stale_update_task_data_alloc().

start_passthru_update()

static void start_passthru_update ( void  )

static

Definition at line 293 of file res_sorcery_memory_cache.c.

{
    set_passthru_update(PASSTHRU_UPDATE_THREAD_ID);
}

References PASSTHRU_UPDATE_THREAD_ID, and set_passthru_update().

Referenced by memory_cache_populate_external(), memory_cache_populate_internal(), stale_cache_update(), and stale_item_update().

unload_module()

static int unload_module ( void  )

static

Definition at line 3663 of file res_sorcery_memory_cache.c.

{
    AST_TEST_UNREGISTER(open_with_valid_options);
    AST_TEST_UNREGISTER(open_with_invalid_options);
    AST_TEST_UNREGISTER(create_and_retrieve);
    AST_TEST_UNREGISTER(update);
    AST_TEST_UNREGISTER(delete);
    AST_TEST_UNREGISTER(maximum_objects);
    AST_TEST_UNREGISTER(expiration);
    AST_TEST_UNREGISTER(stale);
    AST_TEST_UNREGISTER(full_backend_cache_expiration);
    AST_TEST_UNREGISTER(full_backend_cache_stale);
 
    ast_manager_unregister("SorceryMemoryCacheExpireObject");
    ast_manager_unregister("SorceryMemoryCacheExpire");
    ast_manager_unregister("SorceryMemoryCacheStaleObject");
    ast_manager_unregister("SorceryMemoryCacheStale");
    ast_manager_unregister("SorceryMemoryCachePopulate");
 
    ast_cli_unregister_multiple(cli_memory_cache, ARRAY_LEN(cli_memory_cache));
 
    ast_sorcery_wizard_unregister(&memory_cache_object_wizard);
 
    /*
     * XXX There is the potential to leak memory if there are pending
     * next-cache-expiration and stale-cache-update tasks in the scheduler.
     */
    if (sched) {
        ast_sched_context_destroy(sched);
        sched = NULL;
    }
 
    ao2_cleanup(caches);
    caches = NULL;
 
    return 0;
}

References ao2_cleanup, ARRAY_LEN, ast_cli_unregister_multiple(), ast_manager_unregister(), ast_sched_context_destroy(), ast_sorcery_wizard_unregister(), AST_TEST_UNREGISTER, caches, cli_memory_cache, memory_cache_object_wizard, NULL, and update().

Referenced by load_module().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Sorcery Memory Cache Object Wizard" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_REALTIME_DRIVER, }

static

Definition at line 3766 of file res_sorcery_memory_cache.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 3766 of file res_sorcery_memory_cache.c.

caches

struct ao2_container* caches

static

Container of created caches.

Definition at line 258 of file res_sorcery_memory_cache.c.

Referenced by load_module(), sorcery_memory_cache_ami_expire(), sorcery_memory_cache_ami_expire_object(), sorcery_memory_cache_ami_populate(), sorcery_memory_cache_ami_stale(), sorcery_memory_cache_ami_stale_object(), sorcery_memory_cache_close(), sorcery_memory_cache_complete_name(), sorcery_memory_cache_complete_object_name(), sorcery_memory_cache_dump(), sorcery_memory_cache_expire(), sorcery_memory_cache_load(), sorcery_memory_cache_populate(), sorcery_memory_cache_show(), sorcery_memory_cache_stale(), and unload_module().

cli_memory_cache

struct ast_cli_entry cli_memory_cache[]

static

Definition at line 2203 of file res_sorcery_memory_cache.c.

                                                 {
    AST_CLI_DEFINE(sorcery_memory_cache_show, "Show sorcery memory cache information"),
    AST_CLI_DEFINE(sorcery_memory_cache_dump, "Dump all objects within a sorcery memory cache"),
    AST_CLI_DEFINE(sorcery_memory_cache_expire, "Expire a specific object or ALL objects within a sorcery memory cache"),
    AST_CLI_DEFINE(sorcery_memory_cache_stale, "Mark a specific object or ALL objects as stale within a sorcery memory cache"),
    AST_CLI_DEFINE(sorcery_memory_cache_populate, "Clear and populate the sorcery memory cache with objects from the backend"),
};

Referenced by load_module(), and unload_module().

memory_cache_object_wizard

struct ast_sorcery_wizard memory_cache_object_wizard

static

Definition at line 232 of file res_sorcery_memory_cache.c.

                                                              {
    .name = "memory_cache",
    .open = sorcery_memory_cache_open,
    .create = sorcery_memory_cache_create,
    .update = sorcery_memory_cache_create,
    .delete = sorcery_memory_cache_delete,
    .load = sorcery_memory_cache_load,
    .reload = sorcery_memory_cache_reload,
    .retrieve_id = sorcery_memory_cache_retrieve_id,
    .retrieve_fields = sorcery_memory_cache_retrieve_fields,
    .retrieve_multiple = sorcery_memory_cache_retrieve_multiple,
    .retrieve_regex = sorcery_memory_cache_retrieve_regex,
    .retrieve_prefix = sorcery_memory_cache_retrieve_prefix,
    .close = sorcery_memory_cache_close,
};

Referenced by load_module(), and unload_module().

sched

struct ast_sched_context* sched

static

Scheduler for cache management.

Definition at line 261 of file res_sorcery_memory_cache.c.