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. More...
#define	CACHE_HEAP_INIT_HEIGHT   5
	Height of heap for cache object heap. Allows 31 initial objects. More...
#define	CACHES_CONTAINER_BUCKET_SIZE   53
	The bucket size for the container of caches. More...
#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	__init_passthru_update_id_storage (void)
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)
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 void	memory_cache_populate (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 = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .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. More...
static struct ast_cli_entry	cli_memory_cache []
static struct ast_sorcery_wizard	memory_cache_object_wizard
static struct ast_threadstorage	passthru_update_id_storage = { .once = PTHREAD_ONCE_INIT , .key_init = __init_passthru_update_id_storage , .custom_init = NULL , }
static struct ast_sched_context *	sched
	Scheduler for cache management. More...

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 235 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 238 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 232 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 246 of file res_sorcery_memory_cache.c.

Function Documentation

__init_passthru_update_id_storage()

static void __init_passthru_update_id_storage ( void  )

static

Definition at line 247 of file res_sorcery_memory_cache.c.

{

__reg_module()

static void __reg_module ( void  )

static

Definition at line 3603 of file res_sorcery_memory_cache.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 3603 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 728 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 object_add_to_cache_callback(), and sorcery_memory_cache_create().

age_cmp()

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

static

Definition at line 1493 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 3603 of file res_sorcery_memory_cache.c.

configuration_parse_unsigned_integer()

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

static

Definition at line 1484 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 281 of file res_sorcery_memory_cache.c.

{
    set_passthru_update(0);
}

References set_passthru_update().

Referenced by memory_cache_populate(), stale_cache_update(), and stale_item_update().

expire_objects_from_cache()

static int expire_objects_from_cache ( const void *  data )

static

Definition at line 498 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 249 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(), passthru_update_id_storage, 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 3538 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 632 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 605 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 1077 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(sorcery, type, cache);
    }
    ao2_unlock(cache->objects);
}

References ao2_container_count(), ao2_unlock, ao2_wrlock, cache, memory_cache_populate(), 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()

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

static

Definition at line 1034 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);
        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(), sorcery_memory_cache_ami_populate(), and sorcery_memory_cache_populate().

memory_cache_stale_check()

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

static

Definition at line 1191 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 1158 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 1098 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 1126 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 855 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(), and stale_cache_update().

object_stale_callback()

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

static

Definition at line 577 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 554 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(), sorcery_memory_cache_ami_expire(), sorcery_memory_cache_ami_populate(), sorcery_memory_cache_close(), sorcery_memory_cache_expire(), sorcery_memory_cache_populate(), 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 465 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 695 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 648 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 262 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, passthru_update_id_storage, 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 2115 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 2069 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 2230 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, "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;
    }
 
    ao2_wrlock(cache->objects);
    if (!cache->sorcery) {
        astman_send_error(s, m, "The provided cache is no longer active\n");
        ao2_unlock(cache->objects);
        ao2_ref(cache, -1);
        return 0;
    }
 
    remove_all_from_cache(cache);
    memory_cache_populate(cache->sorcery, cache->object_type, cache);
 
    ao2_unlock(cache->objects);
 
    ao2_ref(cache, -1);
 
    astman_send_ack(s, m, "Cache has been expired and populated\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, memory_cache_populate(), OBJ_SEARCH_KEY, and remove_all_from_cache().

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 2199 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 2146 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 1620 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 329 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 1652 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 1825 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 805 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 1598 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 422 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);
}

References ao2_cleanup, ast_free, ast_heap_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 1768 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 1861 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 1254 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 295 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 1436 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 1508 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;
    }
 
    /* 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_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 2001 of file res_sorcery_memory_cache.c.

{
    struct sorcery_memory_cache *cache;
 
    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;
    }
 
    ao2_wrlock(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);
        ao2_ref(cache, -1);
        return CLI_FAILURE;
    }
 
    remove_all_from_cache(cache);
    memory_cache_populate(cache->sorcery, cache->object_type, cache);
 
    ast_cli(a->fd, "Specified sorcery memory cache '%s' has been populated with '%d' objects from the backend\n",
        a->argv[4], ao2_container_count(cache->objects));
 
    ao2_unlock(cache->objects);
 
    ao2_ref(cache, -1);
 
    return CLI_SUCCESS;
}

References a, ao2_container_count(), 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, memory_cache_populate(), NULL, OBJ_SEARCH_KEY, remove_all_from_cache(), 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 1744 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 1461 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 1299 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 1219 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 1336 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 1404 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 1369 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 1679 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 1917 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 766 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 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 394 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 440 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 360 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 908 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 886 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 877 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 989 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 971 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 962 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 276 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(), stale_cache_update(), and stale_item_update().

unload_module()

static int unload_module ( void  )

static

Definition at line 3500 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 = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .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 3603 of file res_sorcery_memory_cache.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 3603 of file res_sorcery_memory_cache.c.

caches

struct ao2_container* caches

static

Container of created caches.

Definition at line 241 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 2057 of file res_sorcery_memory_cache.c.

Referenced by load_module(), and unload_module().

memory_cache_object_wizard

struct ast_sorcery_wizard memory_cache_object_wizard

static

Definition at line 215 of file res_sorcery_memory_cache.c.

Referenced by load_module(), and unload_module().

passthru_update_id_storage

struct ast_threadstorage passthru_update_id_storage = { .once = PTHREAD_ONCE_INIT , .key_init = __init_passthru_update_id_storage , .custom_init = NULL , }

static

Definition at line 247 of file res_sorcery_memory_cache.c.

Referenced by is_passthru_update(), and set_passthru_update().

sched

struct ast_sched_context* sched

static

Scheduler for cache management.

Definition at line 244 of file res_sorcery_memory_cache.c.