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	backend_data
	Backend data that the mock sorcery wizard uses to create objects. More...
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
struct	test_data
	Sorcery object created based on backend data. More...
struct	test_sorcery_object
	Dummy sorcery object. More...

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)
static struct ast_sorcery *	alloc_and_initialize_sorcery (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
	AST_TEST_DEFINE (open_with_valid_options)
	AST_TEST_DEFINE (open_with_invalid_options)
	AST_TEST_DEFINE (create_and_retrieve)
	AST_TEST_DEFINE (update)
	AST_TEST_DEFINE (delete)
	AST_TEST_DEFINE (maximum_objects)
	AST_TEST_DEFINE (expiration)
	AST_TEST_DEFINE (stale)
	AST_TEST_DEFINE (full_backend_cache_expiration)
	AST_TEST_DEFINE (full_backend_cache_stale)
static int	check_cache_content (struct ast_test *test, struct ast_sorcery *sorcery, struct sorcery_memory_cache *cache, const char **in_cache, size_t num_in_cache, const char **not_in_cache, size_t num_not_in_cache)
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 void *	mock_retrieve_id (const struct ast_sorcery *sorcery, void *data, const char *type, const char *id)
	Callback for retrieving sorcery object by ID. More...
static void	mock_retrieve_multiple (const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const struct ast_variable *fields)
	Callback for retrieving multiple sorcery objects. More...
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 void *	test_data_alloc (const char *id)
	Allocation callback for test_data sorcery object. More...
static void *	test_sorcery_object_alloc (const char *id)
static int	unload_module (void)
static int	wait_for_cache_update (const struct ast_sorcery *sorcery, void *previous_object, struct test_data **new_object)
	Wait for the cache to be updated after a stale object is retrieved. More...

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_sorcery_wizard	mock_wizard
	A mock sorcery wizard used for the stale test. More...
static struct ast_threadstorage	passthru_update_id_storage = { .once = PTHREAD_ONCE_INIT , .key_init = __init_passthru_update_id_storage , .custom_init = NULL , }
static struct backend_data *	real_backend_data
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.

Referenced by sorcery_memory_cache_open().

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.

Referenced by sorcery_memory_cache_open().

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.

Referenced by load_module().

FORMAT [1/2]

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

Referenced by sorcery_memory_cache_dump(), and sorcery_memory_cache_print_object().

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.

Referenced by is_passthru_update(), and start_passthru_update().

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.

References ao2_find, ao2_link_flags, ast_heap_peek(), ast_heap_push, sorcery_memory_cached_object::created, sorcery_memory_cache::expire_id, sorcery_memory_cache::full_backend_cache, OBJ_NODATA, OBJ_NOLOCK, OBJ_SEARCH_OBJECT, OBJ_UNLINK, sorcery_memory_cache::object_heap, sorcery_memory_cache::objects, and schedule_cache_expiration().

Referenced by object_add_to_cache_callback(), and sorcery_memory_cache_create().

{
   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;
}

age_cmp()

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

static

Definition at line 1493 of file res_sorcery_memory_cache.c.

References ast_tvcmp().

Referenced by sorcery_memory_cache_open().

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

alloc_and_initialize_sorcery()

static struct ast_sorcery* alloc_and_initialize_sorcery ( void  )

static

Definition at line 2300 of file res_sorcery_memory_cache.c.

References ast_sorcery_apply_default, AST_SORCERY_APPLY_SUCCESS, ast_sorcery_internal_object_register, ast_sorcery_open, ast_sorcery_unref, NULL, sorcery_memory_cache::sorcery, and test_sorcery_object_alloc().

Referenced by AST_TEST_DEFINE().

{
   struct ast_sorcery *sorcery;

   if (!(sorcery = ast_sorcery_open())) {
      return NULL;
   }

   if ((ast_sorcery_apply_default(sorcery, "test", "memory", NULL) != AST_SORCERY_APPLY_SUCCESS) ||
      ast_sorcery_internal_object_register(sorcery, "test", test_sorcery_object_alloc, NULL, NULL)) {
      ast_sorcery_unref(sorcery);
      return NULL;
   }

   return sorcery;
}

AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM

(

void

)

Definition at line 3603 of file res_sorcery_memory_cache.c.

AST_TEST_DEFINE() [1/10]

AST_TEST_DEFINE

(

open_with_valid_options

)

Definition at line 2317 of file res_sorcery_memory_cache.c.

References AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, cache, sip_to_pjsip::info(), sorcery_memory_cache::maximum_objects, sorcery_memory_cache::object_lifetime_maximum, sorcery_memory_cache::object_lifetime_stale, sorcery_memory_cache_close(), sorcery_memory_cache_open(), TEST_EXECUTE, and TEST_INIT.

{
   int res = AST_TEST_PASS;
   struct sorcery_memory_cache *cache;

   switch (cmd) {
   case TEST_INIT:
      info->name = "open_with_valid_options";
      info->category = "/res/res_sorcery_memory_cache/";
      info->summary = "Attempt to create sorcery memory caches using valid options";
      info->description = "This test performs the following:\n"
         "\t* Creates a memory cache with default configuration\n"
         "\t* Creates a memory cache with a maximum object count of 10 and verifies it\n"
         "\t* Creates a memory cache with a maximum object lifetime of 60 and verifies it\n"
         "\t* Creates a memory cache with a stale object lifetime of 90 and verifies it";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   cache = sorcery_memory_cache_open("");
   if (!cache) {
      ast_test_status_update(test, "Failed to create a sorcery memory cache using default configuration\n");
      res = AST_TEST_FAIL;
   } else {
      sorcery_memory_cache_close(cache);
   }

   cache = sorcery_memory_cache_open("maximum_objects=10");
   if (!cache) {
      ast_test_status_update(test, "Failed to create a sorcery memory cache with a maximum object count of 10\n");
      res = AST_TEST_FAIL;
   } else {
      if (cache->maximum_objects != 10) {
         ast_test_status_update(test, "Created a sorcery memory cache with a maximum object count of 10 but it has '%u'\n",
            cache->maximum_objects);
      }
      sorcery_memory_cache_close(cache);
   }

   cache = sorcery_memory_cache_open("object_lifetime_maximum=60");
   if (!cache) {
      ast_test_status_update(test, "Failed to create a sorcery memory cache with a maximum object lifetime of 60\n");
      res = AST_TEST_FAIL;
   } else {
      if (cache->object_lifetime_maximum != 60) {
         ast_test_status_update(test, "Created a sorcery memory cache with a maximum object lifetime of 60 but it has '%u'\n",
            cache->object_lifetime_maximum);
      }
      sorcery_memory_cache_close(cache);
   }

   cache = sorcery_memory_cache_open("object_lifetime_stale=90");
   if (!cache) {
      ast_test_status_update(test, "Failed to create a sorcery memory cache with a stale object lifetime of 90\n");
      res = AST_TEST_FAIL;
   } else {
      if (cache->object_lifetime_stale != 90) {
         ast_test_status_update(test, "Created a sorcery memory cache with a stale object lifetime of 90 but it has '%u'\n",
            cache->object_lifetime_stale);
      }
      sorcery_memory_cache_close(cache);
   }


   return res;
}

AST_TEST_DEFINE() [2/10]

AST_TEST_DEFINE

(

open_with_invalid_options

)

Definition at line 2385 of file res_sorcery_memory_cache.c.

References AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, cache, sip_to_pjsip::info(), sorcery_memory_cache_close(), sorcery_memory_cache_open(), TEST_EXECUTE, and TEST_INIT.

{
   int res = AST_TEST_PASS;
   struct sorcery_memory_cache *cache;

   switch (cmd) {
   case TEST_INIT:
      info->name = "open_with_invalid_options";
      info->category = "/res/res_sorcery_memory_cache/";
      info->summary = "Attempt to create sorcery memory caches using invalid options";
      info->description = "This test attempts to perform the following:\n"
         "\t* Create a memory cache with an empty name\n"
         "\t* Create a memory cache with a maximum object count of -1\n"
         "\t* Create a memory cache with a maximum object count of toast\n"
         "\t* Create a memory cache with a maximum object lifetime of -1\n"
         "\t* Create a memory cache with a maximum object lifetime of toast\n"
         "\t* Create a memory cache with a stale object lifetime of -1\n"
         "\t* Create a memory cache with a stale object lifetime of toast";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   cache = sorcery_memory_cache_open("name=");
   if (cache) {
      ast_test_status_update(test, "Created a sorcery memory cache with an empty name\n");
      sorcery_memory_cache_close(cache);
      res = AST_TEST_FAIL;
   }

   cache = sorcery_memory_cache_open("maximum_objects=-1");
   if (cache) {
      ast_test_status_update(test, "Created a sorcery memory cache with a maximum object count of -1\n");
      sorcery_memory_cache_close(cache);
      res = AST_TEST_FAIL;
   }

   cache = sorcery_memory_cache_open("maximum_objects=toast");
   if (cache) {
      ast_test_status_update(test, "Created a sorcery memory cache with a maximum object count of toast\n");
      sorcery_memory_cache_close(cache);
      res = AST_TEST_FAIL;
   }

   cache = sorcery_memory_cache_open("object_lifetime_maximum=-1");
   if (cache) {
      ast_test_status_update(test, "Created a sorcery memory cache with an object lifetime maximum of -1\n");
      sorcery_memory_cache_close(cache);
      res = AST_TEST_FAIL;
   }

   cache = sorcery_memory_cache_open("object_lifetime_maximum=toast");
   if (cache) {
      ast_test_status_update(test, "Created a sorcery memory cache with an object lifetime maximum of toast\n");
      sorcery_memory_cache_close(cache);
      res = AST_TEST_FAIL;
   }

   cache = sorcery_memory_cache_open("object_lifetime_stale=-1");
   if (cache) {
      ast_test_status_update(test, "Created a sorcery memory cache with a stale object lifetime of -1\n");
      sorcery_memory_cache_close(cache);
      res = AST_TEST_FAIL;
   }

   cache = sorcery_memory_cache_open("object_lifetime_stale=toast");
   if (cache) {
      ast_test_status_update(test, "Created a sorcery memory cache with a stale object lifetime of toast\n");
      sorcery_memory_cache_close(cache);
      res = AST_TEST_FAIL;
   }

   cache = sorcery_memory_cache_open("tacos");
   if (cache) {
      ast_test_status_update(test, "Created a sorcery memory cache with an invalid configuration option 'tacos'\n");
      sorcery_memory_cache_close(cache);
      res = AST_TEST_FAIL;
   }

   return res;
}

AST_TEST_DEFINE() [3/10]

AST_TEST_DEFINE

(

create_and_retrieve

)

Definition at line 2467 of file res_sorcery_memory_cache.c.

References alloc_and_initialize_sorcery(), ao2_cleanup, ao2_container_count(), ast_sorcery_alloc(), ast_sorcery_unref, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, cleanup(), sip_to_pjsip::info(), NULL, sorcery_memory_cache::objects, RAII_VAR, sorcery_memory_cache::sorcery, sorcery_memory_cache_close(), sorcery_memory_cache_create(), sorcery_memory_cache_open(), sorcery_memory_cache_retrieve_id(), TEST_EXECUTE, and TEST_INIT.

{
   int res = AST_TEST_FAIL;
   struct ast_sorcery *sorcery = NULL;
   struct sorcery_memory_cache *cache = NULL;
   RAII_VAR(void *, object, NULL, ao2_cleanup);
   RAII_VAR(void *, cached_object, NULL, ao2_cleanup);

   switch (cmd) {
   case TEST_INIT:
      info->name = "create";
      info->category = "/res/res_sorcery_memory_cache/";
      info->summary = "Attempt to create an object in the cache";
      info->description = "This test performs the following:\n"
         "\t* Creates a memory cache with default options\n"
         "\t* Creates a sorcery instance with a test object\n"
         "\t* Creates a test object with an id of test\n"
         "\t* Pushes the test object into the memory cache\n"
         "\t* Confirms that the test object is in the cache";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   cache = sorcery_memory_cache_open("");
   if (!cache) {
      ast_test_status_update(test, "Failed to create a sorcery memory cache using default options\n");
      goto cleanup;
   }

   if (ao2_container_count(cache->objects)) {
      ast_test_status_update(test, "Memory cache contains cached objects before we added one\n");
      goto cleanup;
   }

   sorcery = alloc_and_initialize_sorcery();
   if (!sorcery) {
      ast_test_status_update(test, "Failed to create a test sorcery instance\n");
      goto cleanup;
   }

   object = ast_sorcery_alloc(sorcery, "test", "test");
   if (!object) {
      ast_test_status_update(test, "Failed to allocate a test object\n");
      goto cleanup;
   }

   sorcery_memory_cache_create(sorcery, cache, object);

   if (!ao2_container_count(cache->objects)) {
      ast_test_status_update(test, "Added test object to memory cache but cache remains empty\n");
      goto cleanup;
   }

   cached_object = sorcery_memory_cache_retrieve_id(sorcery, cache, "test", "test");
   if (!cached_object) {
      ast_test_status_update(test, "Object placed into memory cache could not be retrieved\n");
      goto cleanup;
   }

   if (cached_object != object) {
      ast_test_status_update(test, "Object retrieved from memory cached is not the one we cached\n");
      goto cleanup;
   }

   res = AST_TEST_PASS;

cleanup:
   if (cache) {
      sorcery_memory_cache_close(cache);
   }
   if (sorcery) {
      ast_sorcery_unref(sorcery);
   }

   return res;
}

AST_TEST_DEFINE() [4/10]

AST_TEST_DEFINE

(

update

)

Definition at line 2545 of file res_sorcery_memory_cache.c.

References alloc_and_initialize_sorcery(), ao2_cleanup, ao2_container_count(), ast_sorcery_alloc(), ast_sorcery_unref, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, cleanup(), sip_to_pjsip::info(), NULL, sorcery_memory_cache::objects, RAII_VAR, sorcery_memory_cache::sorcery, sorcery_memory_cache_close(), sorcery_memory_cache_create(), sorcery_memory_cache_open(), sorcery_memory_cache_retrieve_id(), TEST_EXECUTE, and TEST_INIT.

{
   int res = AST_TEST_FAIL;
   struct ast_sorcery *sorcery = NULL;
   struct sorcery_memory_cache *cache = NULL;
   RAII_VAR(void *, original_object, NULL, ao2_cleanup);
   RAII_VAR(void *, updated_object, NULL, ao2_cleanup);
   RAII_VAR(void *, cached_object, NULL, ao2_cleanup);

   switch (cmd) {
   case TEST_INIT:
      info->name = "create";
      info->category = "/res/res_sorcery_memory_cache/";
      info->summary = "Attempt to create and then update an object in the cache";
      info->description = "This test performs the following:\n"
         "\t* Creates a memory cache with default options\n"
         "\t* Creates a sorcery instance with a test object\n"
         "\t* Creates a test object with an id of test\n"
         "\t* Pushes the test object into the memory cache\n"
         "\t* Confirms that the test object is in the cache\n"
         "\t* Creates a new test object with the same id of test\n"
         "\t* Pushes the new test object into the memory cache\n"
         "\t* Confirms that the new test object has replaced the old one";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   cache = sorcery_memory_cache_open("");
   if (!cache) {
      ast_test_status_update(test, "Failed to create a sorcery memory cache using default options\n");
      goto cleanup;
   }

   if (ao2_container_count(cache->objects)) {
      ast_test_status_update(test, "Memory cache contains cached objects before we added one\n");
      goto cleanup;
   }

   sorcery = alloc_and_initialize_sorcery();
   if (!sorcery) {
      ast_test_status_update(test, "Failed to create a test sorcery instance\n");
      goto cleanup;
   }

   original_object = ast_sorcery_alloc(sorcery, "test", "test");
   if (!original_object) {
      ast_test_status_update(test, "Failed to allocate a test object\n");
      goto cleanup;
   }

   sorcery_memory_cache_create(sorcery, cache, original_object);

   updated_object = ast_sorcery_alloc(sorcery, "test", "test");
   if (!updated_object) {
      ast_test_status_update(test, "Failed to allocate an updated test object\n");
      goto cleanup;
   }

   sorcery_memory_cache_create(sorcery, cache, updated_object);

   if (ao2_container_count(cache->objects) != 1) {
      ast_test_status_update(test, "Added updated test object to memory cache but cache now contains %d objects instead of 1\n",
         ao2_container_count(cache->objects));
      goto cleanup;
   }

   cached_object = sorcery_memory_cache_retrieve_id(sorcery, cache, "test", "test");
   if (!cached_object) {
      ast_test_status_update(test, "Updated object placed into memory cache could not be retrieved\n");
      goto cleanup;
   }

   if (cached_object == original_object) {
      ast_test_status_update(test, "Updated object placed into memory cache but old one is being retrieved\n");
      goto cleanup;
   } else if (cached_object != updated_object) {
      ast_test_status_update(test, "Updated object placed into memory cache but different one is being retrieved\n");
      goto cleanup;
   }

   res = AST_TEST_PASS;

cleanup:
   if (cache) {
      sorcery_memory_cache_close(cache);
   }
   if (sorcery) {
      ast_sorcery_unref(sorcery);
   }

   return res;
}

AST_TEST_DEFINE() [5/10]

AST_TEST_DEFINE

(

delete

)

Definition at line 2639 of file res_sorcery_memory_cache.c.

References alloc_and_initialize_sorcery(), ao2_cleanup, ao2_container_count(), ao2_ref, ast_sorcery_alloc(), ast_sorcery_unref, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, cleanup(), sip_to_pjsip::info(), NULL, sorcery_memory_cache::objects, RAII_VAR, sorcery_memory_cache::sorcery, sorcery_memory_cache_close(), sorcery_memory_cache_create(), sorcery_memory_cache_delete(), sorcery_memory_cache_open(), sorcery_memory_cache_retrieve_id(), TEST_EXECUTE, and TEST_INIT.

{
   int res = AST_TEST_FAIL;
   struct ast_sorcery *sorcery = NULL;
   struct sorcery_memory_cache *cache = NULL;
   RAII_VAR(void *, object, NULL, ao2_cleanup);
   RAII_VAR(void *, cached_object, NULL, ao2_cleanup);

   switch (cmd) {
   case TEST_INIT:
      info->name = "delete";
      info->category = "/res/res_sorcery_memory_cache/";
      info->summary = "Attempt to create and then delete an object in the cache";
      info->description = "This test performs the following:\n"
         "\t* Creates a memory cache with default options\n"
         "\t* Creates a sorcery instance with a test object\n"
         "\t* Creates a test object with an id of test\n"
         "\t* Pushes the test object into the memory cache\n"
         "\t* Confirms that the test object is in the cache\n"
         "\t* Deletes the test object from the cache\n"
         "\t* Confirms that the test object is no longer in the cache";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   cache = sorcery_memory_cache_open("");
   if (!cache) {
      ast_test_status_update(test, "Failed to create a sorcery memory cache using default options\n");
      goto cleanup;
   }

   if (ao2_container_count(cache->objects)) {
      ast_test_status_update(test, "Memory cache contains cached objects before we added one\n");
      goto cleanup;
   }

   sorcery = alloc_and_initialize_sorcery();
   if (!sorcery) {
      ast_test_status_update(test, "Failed to create a test sorcery instance\n");
      goto cleanup;
   }

   object = ast_sorcery_alloc(sorcery, "test", "test");
   if (!object) {
      ast_test_status_update(test, "Failed to allocate a test object\n");
      goto cleanup;
   }

   sorcery_memory_cache_create(sorcery, cache, object);

   if (!ao2_container_count(cache->objects)) {
      ast_test_status_update(test, "Added test object to memory cache but cache contains no objects\n");
      goto cleanup;
   }

   cached_object = sorcery_memory_cache_retrieve_id(sorcery, cache, "test", "test");
   if (!cached_object) {
      ast_test_status_update(test, "Test object placed into memory cache could not be retrieved\n");
      goto cleanup;
   }

   ao2_ref(cached_object, -1);
   cached_object = NULL;

   sorcery_memory_cache_delete(sorcery, cache, object);

   cached_object = sorcery_memory_cache_retrieve_id(sorcery, cache, "test", "test");
   if (cached_object) {
      ast_test_status_update(test, "Test object deleted from memory cache can still be retrieved\n");
      goto cleanup;
   }

   res = AST_TEST_PASS;

cleanup:
   if (cache) {
      sorcery_memory_cache_close(cache);
   }
   if (sorcery) {
      ast_sorcery_unref(sorcery);
   }

   return res;
}

AST_TEST_DEFINE() [6/10]

AST_TEST_DEFINE

(

maximum_objects

)

Definition at line 2755 of file res_sorcery_memory_cache.c.

References alloc_and_initialize_sorcery(), ao2_cleanup, ao2_container_count(), ast_sorcery_alloc(), ast_sorcery_unref, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, check_cache_content(), cleanup(), sip_to_pjsip::info(), NULL, sorcery_memory_cache::objects, RAII_VAR, sorcery_memory_cache::sorcery, sorcery_memory_cache_close(), sorcery_memory_cache_create(), sorcery_memory_cache_delete(), sorcery_memory_cache_open(), TEST_EXECUTE, and TEST_INIT.

{
   int res = AST_TEST_FAIL;
   struct ast_sorcery *sorcery = NULL;
   struct sorcery_memory_cache *cache = NULL;
   RAII_VAR(void *, alice, NULL, ao2_cleanup);
   RAII_VAR(void *, bob, NULL, ao2_cleanup);
   RAII_VAR(void *, charlie, NULL, ao2_cleanup);
   RAII_VAR(void *, cached_object, NULL, ao2_cleanup);
   const char *in_cache[2];
   const char *not_in_cache[2];

   switch (cmd) {
   case TEST_INIT:
      info->name = "maximum_objects";
      info->category = "/res/res_sorcery_memory_cache/";
      info->summary = "Ensure that the 'maximum_objects' option works as expected";
      info->description = "This test performs the following:\n"
         "\t* Creates a memory cache with maximum_objects=2\n"
         "\t* Creates a sorcery instance\n"
         "\t* Creates a three test objects: alice, bob, charlie, and david\n"
         "\t* Pushes alice and bob into the memory cache\n"
         "\t* Confirms that alice and bob are in the memory cache\n"
         "\t* Pushes charlie into the memory cache\n"
         "\t* Confirms that bob and charlie are in the memory cache\n"
         "\t* Deletes charlie from the memory cache\n"
         "\t* Confirms that only bob is in the memory cache\n"
         "\t* Pushes alice into the memory cache\n"
         "\t* Confirms that bob and alice are in the memory cache";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   cache = sorcery_memory_cache_open("maximum_objects=2");
   if (!cache) {
      ast_test_status_update(test, "Failed to create a sorcery memory cache with maximum_objects=2\n");
      goto cleanup;
   }

   if (ao2_container_count(cache->objects)) {
      ast_test_status_update(test, "Memory cache contains cached objects before we added one\n");
      goto cleanup;
   }

   sorcery = alloc_and_initialize_sorcery();
   if (!sorcery) {
      ast_test_status_update(test, "Failed to create a test sorcery instance\n");
      goto cleanup;
   }

   alice = ast_sorcery_alloc(sorcery, "test", "alice");
   bob = ast_sorcery_alloc(sorcery, "test", "bob");
   charlie = ast_sorcery_alloc(sorcery, "test", "charlie");

   if (!alice || !bob || !charlie) {
      ast_test_status_update(test, "Failed to allocate sorcery object(s)\n");
      goto cleanup;
   }

   sorcery_memory_cache_create(sorcery, cache, alice);
   in_cache[0] = "alice";
   in_cache[1] = NULL;
   not_in_cache[0] = "bob";
   not_in_cache[1] = "charlie";
   if (check_cache_content(test, sorcery, cache, in_cache, 1, not_in_cache, 2)) {
      goto cleanup;
   }

   /* Delays are added to ensure that we are not adding cache entries within the
    * same microsecond
    */
   usleep(1000);

   sorcery_memory_cache_create(sorcery, cache, bob);
   in_cache[0] = "alice";
   in_cache[1] = "bob";
   not_in_cache[0] = "charlie";
   not_in_cache[1] = NULL;
   if (check_cache_content(test, sorcery, cache, in_cache, 2, not_in_cache, 1)) {
      goto cleanup;
   }

   usleep(1000);

   sorcery_memory_cache_create(sorcery, cache, charlie);
   in_cache[0] = "bob";
   in_cache[1] = "charlie";
   not_in_cache[0] = "alice";
   not_in_cache[1] = NULL;
   if (check_cache_content(test, sorcery, cache, in_cache, 2, not_in_cache, 1)) {
      goto cleanup;
   }
   usleep(1000);

   sorcery_memory_cache_delete(sorcery, cache, charlie);
   in_cache[0] = "bob";
   in_cache[1] = NULL;
   not_in_cache[0] = "alice";
   not_in_cache[1] = "charlie";
   if (check_cache_content(test, sorcery, cache, in_cache, 1, not_in_cache, 2)) {
      goto cleanup;
   }
   usleep(1000);

   sorcery_memory_cache_create(sorcery, cache, alice);
   in_cache[0] = "bob";
   in_cache[1] = "alice";
   not_in_cache[0] = "charlie";
   not_in_cache[1] = NULL;
   if (check_cache_content(test, sorcery, cache, in_cache, 2, not_in_cache, 1)) {
      goto cleanup;
   }

   res = AST_TEST_PASS;

cleanup:
   if (cache) {
      sorcery_memory_cache_close(cache);
   }
   if (sorcery) {
      ast_sorcery_unref(sorcery);
   }

   return res;
}

AST_TEST_DEFINE() [7/10]

AST_TEST_DEFINE

(

expiration

)

Definition at line 2882 of file res_sorcery_memory_cache.c.

References alloc_and_initialize_sorcery(), ao2_container_count(), ao2_ref, ast_cond_destroy, ast_cond_init, ast_cond_timedwait, ast_mutex_destroy, ast_mutex_init, ast_mutex_lock, ast_mutex_unlock, ast_sorcery_alloc(), ast_sorcery_unref, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, ast_tvnow(), ast_uuid_generate_str(), AST_UUID_STR_LEN, sorcery_memory_cache::cache_completed, sorcery_memory_cache::cache_notify, cleanup(), sorcery_memory_cache::cond, sip_to_pjsip::info(), sorcery_memory_cache::lock, NULL, sorcery_memory_cache::objects, sorcery_memory_cache::sorcery, sorcery_memory_cache_close(), sorcery_memory_cache_create(), sorcery_memory_cache_open(), TEST_EXECUTE, and TEST_INIT.

{
   int res = AST_TEST_FAIL;
   struct ast_sorcery *sorcery = NULL;
   struct sorcery_memory_cache *cache = NULL;
   int i;

   switch (cmd) {
   case TEST_INIT:
      info->name = "expiration";
      info->category = "/res/res_sorcery_memory_cache/";
      info->summary = "Add objects to a cache configured with maximum lifetime, confirm they are removed";
      info->description = "This test performs the following:\n"
         "\t* Creates a memory cache with a maximum object lifetime of 5 seconds\n"
         "\t* Pushes 10 objects into the memory cache\n"
         "\t* Waits (up to) 10 seconds for expiration to occur\n"
         "\t* Confirms that the objects have been removed from the cache";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   cache = sorcery_memory_cache_open("object_lifetime_maximum=5");
   if (!cache) {
      ast_test_status_update(test, "Failed to create a sorcery memory cache using default options\n");
      goto cleanup;
   }

   sorcery = alloc_and_initialize_sorcery();
   if (!sorcery) {
      ast_test_status_update(test, "Failed to create a test sorcery instance\n");
      goto cleanup;
   }

   cache->cache_notify = 1;
   ast_mutex_init(&cache->lock);
   ast_cond_init(&cache->cond, NULL);

   for (i = 0; i < 5; ++i) {
      char uuid[AST_UUID_STR_LEN];
      void *object;

      object = ast_sorcery_alloc(sorcery, "test", ast_uuid_generate_str(uuid, sizeof(uuid)));
      if (!object) {
         ast_test_status_update(test, "Failed to allocate test object for expiration\n");
         goto cleanup;
      }

      sorcery_memory_cache_create(sorcery, cache, object);

      ao2_ref(object, -1);
   }

   ast_mutex_lock(&cache->lock);
   while (!cache->cache_completed) {
      struct timeval start = ast_tvnow();
      struct timespec end = {
         .tv_sec = start.tv_sec + 10,
         .tv_nsec = start.tv_usec * 1000,
      };

      if (ast_cond_timedwait(&cache->cond, &cache->lock, &end) == ETIMEDOUT) {
         break;
      }
   }
   ast_mutex_unlock(&cache->lock);

   if (ao2_container_count(cache->objects)) {
      ast_test_status_update(test, "Objects placed into the memory cache did not expire and get removed\n");
      goto cleanup;
   }

   res = AST_TEST_PASS;

cleanup:
   if (cache) {
      if (cache->cache_notify) {
         ast_cond_destroy(&cache->cond);
         ast_mutex_destroy(&cache->lock);
      }
      sorcery_memory_cache_close(cache);
   }
   if (sorcery) {
      ast_sorcery_unref(sorcery);
   }

   return res;
}

AST_TEST_DEFINE() [8/10]

AST_TEST_DEFINE

(

stale

)

Definition at line 3118 of file res_sorcery_memory_cache.c.

References ao2_cleanup, ao2_ref, ARRAY_LEN, ast_sorcery_apply_wizard_mapping, ast_sorcery_internal_object_register, ast_sorcery_open, ast_sorcery_retrieve_by_id(), ast_sorcery_unref, ast_sorcery_wizard_register, ast_sorcery_wizard_unregister(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, cleanup(), exists(), sip_to_pjsip::info(), NULL, backend_data::pepper, RAII_VAR, real_backend_data, backend_data::salt, sorcery_memory_cache::sorcery, test_data_alloc(), TEST_EXECUTE, TEST_INIT, and wait_for_cache_update().

{
   int res = AST_TEST_FAIL;
   struct ast_sorcery *sorcery = NULL;
   struct test_data *backend_object;
   struct backend_data iterations[] = {
      { .salt = 1,      .pepper = 2,       .exists = 1 },
      { .salt = 568729, .pepper = -234123, .exists = 1 },
      { .salt = 0,      .pepper = 0,       .exists = 0 },
   };
   struct backend_data initial = {
      .salt = 0,
      .pepper = 0,
      .exists = 1,
   };
   int i;

   switch (cmd) {
   case TEST_INIT:
      info->name = "stale";
      info->category = "/res/res_sorcery_memory_cache/";
      info->summary = "Ensure that stale objects are replaced with updated objects";
      info->description = "This test performs the following:\n"
         "\t* Create a sorcery instance with two wizards"
         "\t\t* The first is a memory cache that marks items stale after 3 seconds\n"
         "\t\t* The second is a mock of a back-end\n"
         "\t* Pre-populates the cache by retrieving some initial data from the backend.\n"
         "\t* Performs iterations of the following:\n"
         "\t\t* Update backend data with new values\n"
         "\t\t* Retrieve item from the cache\n"
         "\t\t* Ensure the retrieved item does not have the new backend values\n"
         "\t\t* Wait for cached object to become stale\n"
         "\t\t* Retrieve the stale cached object\n"
         "\t\t* Ensure that the stale object retrieved is the same as the fresh one from earlier\n"
         "\t\t* Wait for the cache to update with new data\n"
         "\t\t* Ensure that new data in the cache matches backend data";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   ast_sorcery_wizard_register(&mock_wizard);

   sorcery = ast_sorcery_open();
   if (!sorcery) {
      ast_test_status_update(test, "Failed to create sorcery instance\n");
      goto cleanup;
   }

   ast_sorcery_apply_wizard_mapping(sorcery, "test", "memory_cache",
         "object_lifetime_stale=3", 1);
   ast_sorcery_apply_wizard_mapping(sorcery, "test", "mock", NULL, 0);
   ast_sorcery_internal_object_register(sorcery, "test", test_data_alloc, NULL, NULL);

   /* Prepopulate the cache */
   real_backend_data = &initial;

   backend_object = ast_sorcery_retrieve_by_id(sorcery, "test", "test");
   if (!backend_object) {
      ast_test_status_update(test, "Unable to retrieve backend data and populate the cache\n");
      goto cleanup;
   }
   ao2_ref(backend_object, -1);

   for (i = 0; i < ARRAY_LEN(iterations); ++i) {
      RAII_VAR(struct test_data *, cache_fresh, NULL, ao2_cleanup);
      RAII_VAR(struct test_data *, cache_stale, NULL, ao2_cleanup);
      RAII_VAR(struct test_data *, cache_new, NULL, ao2_cleanup);

      real_backend_data = &iterations[i];

      ast_test_status_update(test, "Begininning iteration %d\n", i);

      cache_fresh = ast_sorcery_retrieve_by_id(sorcery, "test", "test");
      if (!cache_fresh) {
         ast_test_status_update(test, "Unable to retrieve fresh cached object\n");
         goto cleanup;
      }

      if (cache_fresh->salt == iterations[i].salt || cache_fresh->pepper == iterations[i].pepper) {
         ast_test_status_update(test, "Fresh cached object has unexpected values. Did we hit the backend?\n");
         goto cleanup;
      }

      sleep(5);

      cache_stale = ast_sorcery_retrieve_by_id(sorcery, "test", "test");
      if (!cache_stale) {
         ast_test_status_update(test, "Unable to retrieve stale cached object\n");
         goto cleanup;
      }

      if (cache_stale != cache_fresh) {
         ast_test_status_update(test, "Stale cache hit retrieved different object than fresh cache hit\n");
         goto cleanup;
      }

      if (wait_for_cache_update(sorcery, cache_stale, &cache_new)) {
         ast_test_status_update(test, "Cache was not updated\n");
         goto cleanup;
      }

      if (iterations[i].exists) {
         if (!cache_new) {
            ast_test_status_update(test, "Failed to retrieve item from cache when there should be one present\n");
            goto cleanup;
         } else if (cache_new->salt != iterations[i].salt ||
               cache_new->pepper != iterations[i].pepper) {
            ast_test_status_update(test, "New cached item has unexpected values\n");
            goto cleanup;
         }
      } else if (cache_new) {
         ast_test_status_update(test, "Retrieved a cached item when there should not have been one present\n");
         goto cleanup;
      }
   }

   res = AST_TEST_PASS;

cleanup:
   if (sorcery) {
      ast_sorcery_unref(sorcery);
   }
   ast_sorcery_wizard_unregister(&mock_wizard);
   return res;
}

AST_TEST_DEFINE() [9/10]

AST_TEST_DEFINE

(

full_backend_cache_expiration

)

Definition at line 3245 of file res_sorcery_memory_cache.c.

References ao2_container_count(), ao2_ref, ast_cond_destroy, ast_cond_init, ast_cond_timedwait, ast_mutex_destroy, ast_mutex_init, ast_mutex_lock, ast_mutex_unlock, AST_RETRIEVE_FLAG_ALL, AST_RETRIEVE_FLAG_MULTIPLE, ast_sorcery_apply_wizard_mapping, ast_sorcery_internal_object_register, ast_sorcery_object_field_register_nodoc, ast_sorcery_open, ast_sorcery_retrieve_by_fields(), ast_sorcery_unref, ast_sorcery_wizard_register, ast_sorcery_wizard_unregister(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, ast_tvnow(), cleanup(), sorcery_memory_cache::cond, backend_data::exists, FLDSET, sip_to_pjsip::info(), sorcery_memory_cache::lock, NULL, sorcery_memory_cache::objects, OPT_UINT_T, real_backend_data, backend_data::salt, sorcery_memory_cache::sorcery, test_data_alloc(), TEST_EXECUTE, and TEST_INIT.

{
   int res = AST_TEST_FAIL;
   struct ast_sorcery *sorcery = NULL;
   struct backend_data initial = {
      .salt = 0,
      .pepper = 0,
      .exists = 4,
   };
   struct ao2_container *objects;
   ast_mutex_t lock;
   ast_cond_t cond;
   struct timeval start;
   struct timespec end;

   switch (cmd) {
   case TEST_INIT:
      info->name = "full_backend_cache_expiration";
      info->category = "/res/res_sorcery_memory_cache/";
      info->summary = "Ensure that the full backend cache actually caches the backend";
      info->description = "This test performs the following:\n"
         "\t* Create a sorcery instance with two wizards"
         "\t\t* The first is a memory cache that expires objects after 3 seconds and does full backend caching\n"
         "\t\t* The second is a mock of a back-end\n"
         "\t* Populates the cache by requesting all objects which returns 4.\n"
         "\t* Updates the backend to contain a different number of objects, 8.\n"
         "\t* Requests all objects and confirms the number returned is only 4.\n"
         "\t* Wait for cached objects to expire.\n"
         "\t* Requests all objects and confirms the number returned is 8.";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   ast_sorcery_wizard_register(&mock_wizard);

   sorcery = ast_sorcery_open();
   if (!sorcery) {
      ast_test_status_update(test, "Failed to create sorcery instance\n");
      goto cleanup;
   }

   ast_sorcery_apply_wizard_mapping(sorcery, "test", "memory_cache",
         "object_lifetime_maximum=3,full_backend_cache=yes", 1);
   ast_sorcery_apply_wizard_mapping(sorcery, "test", "mock", NULL, 0);
   ast_sorcery_internal_object_register(sorcery, "test", test_data_alloc, NULL, NULL);
   ast_sorcery_object_field_register_nodoc(sorcery, "test", "salt", "0", OPT_UINT_T, 0, FLDSET(struct test_data, salt));
   ast_sorcery_object_field_register_nodoc(sorcery, "test", "pepper", "0", OPT_UINT_T, 0, FLDSET(struct test_data, pepper));

   /* Prepopulate the cache */
   real_backend_data = &initial;

   /* Get all current objects in the backend */
   objects = ast_sorcery_retrieve_by_fields(sorcery, "test", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
   if (!objects) {
      ast_test_status_update(test, "Unable to retrieve all objects in backend and populate cache\n");
      goto cleanup;
   }
   ao2_ref(objects, -1);

   /* Update the backend to have a different number of objects */
   initial.exists = 8;

   /* Get all current objects in the backend */
   objects = ast_sorcery_retrieve_by_fields(sorcery, "test", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
   if (!objects) {
      ast_test_status_update(test, "Unable to retrieve all objects in backend and populate cache\n");
      goto cleanup;
   }

   if (ao2_container_count(objects) == initial.exists) {
      ast_test_status_update(test, "Number of objects returned is of the current backend and not the cache\n");
      ao2_ref(objects, -1);
      goto cleanup;
   }

   ao2_ref(objects, -1);

   ast_mutex_init(&lock);
   ast_cond_init(&cond, NULL);

   start = ast_tvnow();
   end.tv_sec = start.tv_sec + 5;
   end.tv_nsec = start.tv_usec * 1000;

   ast_mutex_lock(&lock);
   while (ast_cond_timedwait(&cond, &lock, &end) != ETIMEDOUT) {
   }
   ast_mutex_unlock(&lock);

   ast_mutex_destroy(&lock);
   ast_cond_destroy(&cond);

   /* Get all current objects in the backend */
   objects = ast_sorcery_retrieve_by_fields(sorcery, "test", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
   if (!objects) {
      ast_test_status_update(test, "Unable to retrieve all objects in backend and populate cache\n");
      goto cleanup;
   }

   if (ao2_container_count(objects) != initial.exists) {
      ast_test_status_update(test, "Number of objects returned is NOT of the current backend when it should be\n");
      ao2_ref(objects, -1);
      goto cleanup;
   }

   ao2_ref(objects, -1);

   res = AST_TEST_PASS;

cleanup:
   if (sorcery) {
      ast_sorcery_unref(sorcery);
   }
   ast_sorcery_wizard_unregister(&mock_wizard);
   return res;
}

AST_TEST_DEFINE() [10/10]

AST_TEST_DEFINE

(

full_backend_cache_stale

)

Definition at line 3363 of file res_sorcery_memory_cache.c.

References ao2_container_count(), ao2_ref, ast_cond_destroy, ast_cond_init, ast_cond_timedwait, ast_mutex_destroy, ast_mutex_init, ast_mutex_lock, ast_mutex_unlock, AST_RETRIEVE_FLAG_ALL, AST_RETRIEVE_FLAG_MULTIPLE, ast_sorcery_apply_wizard_mapping, ast_sorcery_internal_object_register, ast_sorcery_object_field_register_nodoc, ast_sorcery_open, ast_sorcery_retrieve_by_fields(), ast_sorcery_unref, ast_sorcery_wizard_register, ast_sorcery_wizard_unregister(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, ast_tvnow(), cleanup(), sorcery_memory_cache::cond, backend_data::exists, FLDSET, sip_to_pjsip::info(), sorcery_memory_cache::lock, NULL, sorcery_memory_cache::objects, OPT_UINT_T, real_backend_data, backend_data::salt, sorcery_memory_cache::sorcery, test_data_alloc(), TEST_EXECUTE, and TEST_INIT.

{
   int res = AST_TEST_FAIL;
   struct ast_sorcery *sorcery = NULL;
   struct backend_data initial = {
      .salt = 0,
      .pepper = 0,
      .exists = 4,
   };
   struct ao2_container *objects;
   ast_mutex_t lock;
   ast_cond_t cond;
   struct timeval start;
   struct timespec end;

   switch (cmd) {
   case TEST_INIT:
      info->name = "full_backend_cache_stale";
      info->category = "/res/res_sorcery_memory_cache/";
      info->summary = "Ensure that the full backend cache works with staleness";
      info->description = "This test performs the following:\n"
         "\t* Create a sorcery instance with two wizards"
         "\t\t* The first is a memory cache that stales objects after 1 second and does full backend caching\n"
         "\t\t* The second is a mock of a back-end\n"
         "\t* Populates the cache by requesting all objects which returns 4.\n"
         "\t* Wait for objects to go stale.\n"
         "\t* Updates the backend to contain a different number of objects, 8.\""
         "\t* Requests all objects and confirms the number returned is only 4.\n"
         "\t* Wait for objects to be refreshed from backend.\n"
         "\t* Requests all objects and confirms the number returned is 8.";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   ast_sorcery_wizard_register(&mock_wizard);

   ast_mutex_init(&lock);
   ast_cond_init(&cond, NULL);

   sorcery = ast_sorcery_open();
   if (!sorcery) {
      ast_test_status_update(test, "Failed to create sorcery instance\n");
      goto cleanup;
   }

   ast_sorcery_apply_wizard_mapping(sorcery, "test", "memory_cache",
         "object_lifetime_stale=1,full_backend_cache=yes", 1);
   ast_sorcery_apply_wizard_mapping(sorcery, "test", "mock", NULL, 0);
   ast_sorcery_internal_object_register(sorcery, "test", test_data_alloc, NULL, NULL);
   ast_sorcery_object_field_register_nodoc(sorcery, "test", "salt", "0", OPT_UINT_T, 0, FLDSET(struct test_data, salt));
   ast_sorcery_object_field_register_nodoc(sorcery, "test", "pepper", "0", OPT_UINT_T, 0, FLDSET(struct test_data, pepper));

   /* Prepopulate the cache */
   real_backend_data = &initial;

   /* Get all current objects in the backend */
   objects = ast_sorcery_retrieve_by_fields(sorcery, "test", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
   if (!objects) {
      ast_test_status_update(test, "Unable to retrieve all objects in backend and populate cache\n");
      goto cleanup;
   }
   ao2_ref(objects, -1);

   start = ast_tvnow();
   end.tv_sec = start.tv_sec + 5;
   end.tv_nsec = start.tv_usec * 1000;

   ast_mutex_lock(&lock);
   while (ast_cond_timedwait(&cond, &lock, &end) != ETIMEDOUT) {
   }
   ast_mutex_unlock(&lock);

   initial.exists = 8;

   /* Get all current objects in the backend */
   objects = ast_sorcery_retrieve_by_fields(sorcery, "test", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
   if (!objects) {
      ast_test_status_update(test, "Unable to retrieve all objects in backend and populate cache\n");
      goto cleanup;
   }

   if (ao2_container_count(objects) == initial.exists) {
      ast_test_status_update(test, "Number of objects returned is of the backend and not the cache\n");
      ao2_ref(objects, -1);
      goto cleanup;
   }

   ao2_ref(objects, -1);

   start = ast_tvnow();
   end.tv_sec = start.tv_sec + 5;
   end.tv_nsec = start.tv_usec * 1000;

   ast_mutex_lock(&lock);
   while (ast_cond_timedwait(&cond, &lock, &end) != ETIMEDOUT) {
   }
   ast_mutex_unlock(&lock);

   /* Get all current objects in the backend */
   objects = ast_sorcery_retrieve_by_fields(sorcery, "test", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
   if (!objects) {
      ast_test_status_update(test, "Unable to retrieve all objects in backend and populate cache\n");
      goto cleanup;
   }

   if (ao2_container_count(objects) != initial.exists) {
      ast_test_status_update(test, "Number of objects returned is not of backend\n");
      ao2_ref(objects, -1);
      goto cleanup;
   }

   ao2_ref(objects, -1);

   start = ast_tvnow();
   end.tv_sec = start.tv_sec + 5;
   end.tv_nsec = start.tv_usec * 1000;

   ast_mutex_lock(&lock);
   while (ast_cond_timedwait(&cond, &lock, &end) != ETIMEDOUT) {
   }
   ast_mutex_unlock(&lock);

   res = AST_TEST_PASS;

cleanup:
   if (sorcery) {
      ast_sorcery_unref(sorcery);
   }
   ast_sorcery_wizard_unregister(&mock_wizard);
   ast_mutex_destroy(&lock);
   ast_cond_destroy(&cond);
   return res;
}

check_cache_content()

static int check_cache_content ( struct ast_test *  test, struct ast_sorcery *  sorcery, struct sorcery_memory_cache *  cache, const char **  in_cache, size_t  num_in_cache, const char **  not_in_cache, size_t  num_not_in_cache  )

static

Definition at line 2725 of file res_sorcery_memory_cache.c.

References ao2_cleanup, ao2_ref, ast_test_status_update, NULL, RAII_VAR, and sorcery_memory_cache_retrieve_id().

Referenced by AST_TEST_DEFINE().

{
   int i;
   int res = 0;
   RAII_VAR(void *, cached_object, NULL, ao2_cleanup);

   for (i = 0; i < num_in_cache; ++i) {
      cached_object = sorcery_memory_cache_retrieve_id(sorcery, cache, "test", in_cache[i]);
      if (!cached_object) {
         ast_test_status_update(test, "Failed to retrieve '%s' object from the cache\n",
               in_cache[i]);
         res = -1;
      }
      ao2_ref(cached_object, -1);
   }

   for (i = 0; i < num_not_in_cache; ++i) {
      cached_object = sorcery_memory_cache_retrieve_id(sorcery, cache, "test", not_in_cache[i]);
      if (cached_object) {
         ast_test_status_update(test, "Retrieved '%s' object from the cache unexpectedly\n",
               not_in_cache[i]);
         ao2_ref(cached_object, -1);
         res = -1;
      }
   }

   return res;
}

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.

References ast_strlen_zero.

Referenced by sorcery_memory_cache_open().

{
   if (ast_strlen_zero(value) || !strncmp(value, "-", 1)) {
      return 0;
   }

   return sscanf(value, "%30u", result);
}

end_passthru_update()

static void end_passthru_update ( void  )

static

Definition at line 281 of file res_sorcery_memory_cache.c.

References set_passthru_update().

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

{
   set_passthru_update(0);
}

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.

References ao2_ref, ao2_trywrlock, ao2_unlock, ast_heap_peek(), ast_samp2tv(), ast_sorcery_object_get_id(), ast_tvadd(), ast_tvdiff_ms(), ast_tvnow(), sorcery_memory_cached_object::created, sorcery_memory_cache::del_expire, sorcery_memory_cache::expire_id, sorcery_memory_cached_object::object, sorcery_memory_cache::object_heap, sorcery_memory_cache::object_lifetime_maximum, sorcery_memory_cache::objects, remove_from_cache(), and schedule_cache_expiration().

Referenced by schedule_cache_expiration().

{
   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;
}

is_passthru_update()

static int is_passthru_update ( void  )

static

Definition at line 249 of file res_sorcery_memory_cache.c.

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().

{
   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;
}

load_module()

static int load_module ( void  )

static

Definition at line 3538 of file res_sorcery_memory_cache.c.

References AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, ARRAY_LEN, ast_cli_register_multiple, ast_log, ast_manager_register_xml, AST_MODFLAG_GLOBAL_SYMBOLS, AST_MODFLAG_LOAD_ORDER, AST_MODPRI_REALTIME_DRIVER, AST_MODULE_INFO(), AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, AST_MODULE_SUPPORT_CORE, ast_sched_context_create(), ast_sched_start_thread(), ast_sorcery_wizard_register, AST_TEST_REGISTER, ASTERISK_GPL_KEY, CACHES_CONTAINER_BUCKET_SIZE, EVENT_FLAG_SYSTEM, LOG_ERROR, sorcery_memory_cache::maximum_objects, 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().

{
   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;
}

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.

References ao2_callback, OBJ_MULTIPLE, OBJ_NODATA, OBJ_NOLOCK, object_stale_callback(), and sorcery_memory_cache::objects.

Referenced by sorcery_memory_cache_ami_stale(), and sorcery_memory_cache_stale().

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

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.

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

Referenced by sorcery_memory_cache_ami_stale_object(), and sorcery_memory_cache_stale().

{
   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;
}

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.

References ao2_container_count(), ao2_unlock, ao2_wrlock, sorcery_memory_cache::full_backend_cache, memory_cache_populate(), and sorcery_memory_cache::objects.

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

{
   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);
}

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.

References ao2_callback_data, ao2_container_count(), ao2_ref, ast_log, AST_RETRIEVE_FLAG_ALL, AST_RETRIEVE_FLAG_MULTIPLE, ast_sorcery_retrieve_by_fields(), end_passthru_update(), LOG_ERROR, LOG_WARNING, sorcery_memory_cache::maximum_objects, sorcery_memory_cache::name, NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_NOLOCK, object_add_to_cache_callback(), sorcery_memory_cache::objects, remove_all_from_cache(), and start_passthru_update().

Referenced by memory_cache_full_update(), sorcery_memory_cache_ami_populate(), and sorcery_memory_cache_populate().

{
   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);
}

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.

References ao2_bump, ao2_rdlock, ao2_ref, ao2_unlock, ast_heap_peek(), memory_cache_stale_check_object(), sorcery_memory_cache::object_heap, and sorcery_memory_cache::objects.

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

{
   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);
}

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.

References ast_sorcery_object_get_type(), ast_tvnow(), ast_tvsub(), sorcery_memory_cached_object::created, sorcery_memory_cache::full_backend_cache, memory_cache_stale_update_full(), memory_cache_stale_update_object(), sorcery_memory_cached_object::object, and sorcery_memory_cache::object_lifetime_stale.

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

{
   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);
   }

}

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.

References ao2_cleanup, ao2_unlock, ao2_wrlock, ast_sched_add(), sorcery_memory_cache::objects, stale_cache_update(), stale_cache_update_task_data_alloc(), and sorcery_memory_cache::stale_update_sched_id.

Referenced by memory_cache_stale_check_object().

{
   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);
}

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.

References ao2_cleanup, ao2_lock, ao2_unlock, ast_debug, ast_log, ast_sched_add(), ast_sorcery_object_get_id(), ast_sorcery_object_get_type(), LOG_ERROR, sorcery_memory_cached_object::object, 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().

{
   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);
}

mock_retrieve_id()

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

static

Callback for retrieving sorcery object by ID.

The mock wizard uses the real_backend_data in order to construct objects. If the backend data is "nonexisent" then no object is returned. Otherwise, an object is created that has the backend data's salt and pepper values copied.

Parameters

sorcery	The sorcery instance
data	Unused
type	The object type. Will always be "test".
id	The object id. Will always be "test".

Return values

NULL	Backend data does not exist
non-NULL	An object representing the backend data

Definition at line 3017 of file res_sorcery_memory_cache.c.

References ast_sorcery_alloc(), backend_data::exists, NULL, backend_data::pepper, test_data::pepper, real_backend_data, backend_data::salt, and test_data::salt.

{
   struct test_data *b_data;

   if (!real_backend_data->exists) {
      return NULL;
   }

   b_data = ast_sorcery_alloc(sorcery, type, id);
   if (!b_data) {
      return NULL;
   }

   b_data->salt = real_backend_data->salt;
   b_data->pepper = real_backend_data->pepper;
   return b_data;
}

mock_retrieve_multiple()

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

static

Callback for retrieving multiple sorcery objects.

The mock wizard uses the real_backend_data in order to construct objects. If the backend data is "nonexisent" then no object is returned. Otherwise, the number of objects matching the exists value will be returned.

Parameters

sorcery	The sorcery instance
data	Unused
type	The object type. Will always be "test".
objects	Container to place objects into.
fields	Fields to search for.

Definition at line 3049 of file res_sorcery_memory_cache.c.

References ao2_link, ao2_ref, ast_sorcery_alloc(), ast_uuid_generate_str(), AST_UUID_STR_LEN, backend_data::exists, backend_data::pepper, test_data::pepper, real_backend_data, backend_data::salt, and test_data::salt.

{
   int i;

   if (fields) {
      return;
   }

   for (i = 0; i < real_backend_data->exists; ++i) {
      char uuid[AST_UUID_STR_LEN];
      struct test_data *b_data;

      b_data = ast_sorcery_alloc(sorcery, type, ast_uuid_generate_str(uuid, sizeof(uuid)));
      if (!b_data) {
         continue;
      }

      b_data->salt = real_backend_data->salt;
      b_data->pepper = real_backend_data->pepper;

      ao2_link(objects, b_data);
      ao2_ref(b_data, -1);
   }
}

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.

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

Referenced by memory_cache_populate(), and stale_cache_update().

{
   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;
}

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.

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

Referenced by mark_all_as_stale_in_cache(), and mark_object_as_stale_in_cache().

{
   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;
}

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.

References ao2_callback, ao2_ref, ast_heap_pop(), AST_SCHED_DEL_UNREF, sorcery_memory_cache::del_expire, sorcery_memory_cache::expire_id, NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_NOLOCK, OBJ_UNLINK, sorcery_memory_cache::object_heap, and sorcery_memory_cache::objects.

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().

{
   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;
}

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.

References ao2_find, ao2_ref, ast_assert, ast_heap_peek(), ast_heap_remove(), ast_sorcery_object_get_id(), OBJ_NOLOCK, OBJ_SEARCH_KEY, OBJ_UNLINK, sorcery_memory_cached_object::object, sorcery_memory_cache::object_heap, sorcery_memory_cache::objects, 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().

{
   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;
}

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.

References ao2_find, ao2_ref, ast_assert, ast_heap_pop(), OBJ_NOLOCK, OBJ_SEARCH_OBJECT, OBJ_UNLINK, sorcery_memory_cache::object_heap, sorcery_memory_cache::objects, and schedule_cache_expiration().

Referenced by sorcery_memory_cache_create().

{
   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;
}

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.

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(), sorcery_memory_cache::cache_completed, sorcery_memory_cache::cond, sorcery_memory_cached_object::created, sorcery_memory_cache::del_expire, sorcery_memory_cache::expire_id, expire_objects_from_cache(), sorcery_memory_cache::lock, MAX, sorcery_memory_cache::object_heap, and sorcery_memory_cache::object_lifetime_maximum.

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

{
   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;
}

set_passthru_update()

static void set_passthru_update ( uint32_t  value )

static

Definition at line 262 of file res_sorcery_memory_cache.c.

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

Referenced by end_passthru_update(), and start_passthru_update().

{
   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;
}

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.

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

Referenced by load_module().

{
   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;
}

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.

References ao2_find, ao2_ref, ao2_unlock, ao2_wrlock, ast_strlen_zero, astman_get_header(), astman_send_ack(), astman_send_error(), cache, sorcery_memory_cache::full_backend_cache, OBJ_SEARCH_KEY, sorcery_memory_cache::objects, and remove_from_cache().

Referenced by load_module().

{
   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;
}

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.

References ao2_find, ao2_ref, ao2_unlock, ao2_wrlock, ast_strlen_zero, astman_get_header(), astman_send_ack(), astman_send_error(), cache, sorcery_memory_cache::full_backend_cache, memory_cache_populate(), OBJ_SEARCH_KEY, sorcery_memory_cache::object_type, sorcery_memory_cache::objects, remove_all_from_cache(), and sorcery_memory_cache::sorcery.

Referenced by load_module().

{
   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;
}

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.

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

Referenced by load_module().

{
   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;
}

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.

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

Referenced by load_module().

{
   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;
}

sorcery_memory_cache_close()

static void sorcery_memory_cache_close ( void *  data )

static

Definition at line 1620 of file res_sorcery_memory_cache.c.

References ao2_ref, ao2_unlink, ao2_unlock, ao2_wrlock, ast_strlen_zero, sorcery_memory_cache::full_backend_cache, sorcery_memory_cache::name, NULL, sorcery_memory_cache::object_lifetime_maximum, sorcery_memory_cache::objects, remove_all_from_cache(), and sorcery_memory_cache::sorcery.

Referenced by AST_TEST_DEFINE().

{
   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);
}

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.

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().

{
   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;
}

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.

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_strdup, cache, sorcery_memory_cache::name, 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().

{
   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;
}

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.

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

Referenced by sorcery_memory_cache_expire(), and sorcery_memory_cache_stale().

{
   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;
}

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.

References add_to_cache(), ao2_container_count(), ao2_ref, ao2_unlock, ao2_wrlock, ast_assert, ast_log, ast_sorcery_object_get_id(), LOG_ERROR, sorcery_memory_cache::maximum_objects, sorcery_memory_cache::objects, remove_from_cache(), remove_oldest_from_cache(), and sorcery_memory_cached_object_alloc().

Referenced by AST_TEST_DEFINE(), and stale_item_update().

{
   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;
}

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.

References ao2_unlock, ao2_wrlock, ast_debug, ast_sorcery_object_get_id(), sorcery_memory_cache::objects, and remove_from_cache().

Referenced by AST_TEST_DEFINE(), and stale_item_update().

{
   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;
}

sorcery_memory_cache_destructor()

static void sorcery_memory_cache_destructor ( void *  obj )

static

Definition at line 422 of file res_sorcery_memory_cache.c.

References ao2_cleanup, ast_free, ast_heap_destroy(), cache, sorcery_memory_cache::name, sorcery_memory_cache::object_heap, sorcery_memory_cache::object_type, and sorcery_memory_cache::objects.

Referenced by sorcery_memory_cache_open().

{
   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);
}

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.

References print_object_details::a, a, ao2_callback, ao2_container_count(), ao2_find, ao2_ref, ast_cli_args::argc, ast_cli_args::argv, ast_cli(), cache, print_object_details::cache, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, FORMAT, ast_cli_args::n, sorcery_memory_cache::name, NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_SEARCH_KEY, sorcery_memory_cache::object_lifetime_maximum, sorcery_memory_cache::object_lifetime_stale, sorcery_memory_cache::objects, ast_cli_args::pos, sorcery_memory_cache_complete_name(), sorcery_memory_cache_print_object(), ast_cli_entry::usage, and ast_cli_args::word.

{
#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
}

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.

References ao2_find, ao2_ref, ao2_unlock, ao2_wrlock, ast_cli_args::argc, ast_cli_args::argv, ast_cli(), cache, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, sorcery_memory_cache::full_backend_cache, ast_cli_args::n, NULL, OBJ_SEARCH_KEY, sorcery_memory_cache::objects, ast_cli_args::pos, remove_all_from_cache(), remove_from_cache(), sorcery_memory_cache_complete_name(), sorcery_memory_cache_complete_object_name(), ast_cli_entry::usage, and ast_cli_args::word.

{
   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;
}

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.

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().

{
   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;
   }
}

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.

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

Referenced by load_module().

{
   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;
}

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.

References ao2_link, ast_asprintf, ast_debug, ast_sorcery_get_module(), ast_strdup, ast_strlen_zero, sorcery_memory_cache::name, sorcery_memory_cache::object_type, and sorcery_memory_cache::sorcery.

{
   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);
}

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.

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_strlen_zero, ast_true(), CACHE_CONTAINER_BUCKET_SIZE, CACHE_HEAP_INIT_HEIGHT, configuration_parse_unsigned_integer(), sorcery_memory_cache::expire_id, sorcery_memory_cache::expire_on_reload, sorcery_memory_cache::full_backend_cache, LOG_ERROR, sorcery_memory_cache::maximum_objects, sorcery_memory_cache::name, NULL, sorcery_memory_cache::object_heap, sorcery_memory_cache::object_lifetime_maximum, sorcery_memory_cache::object_lifetime_stale, sorcery_memory_cache::objects, options, RAII_VAR, sorcery_memory_cache_destructor(), sorcery_memory_cached_object_cmp(), sorcery_memory_cached_object_hash(), sorcery_memory_cache::stale_update_sched_id, strsep(), and value.

Referenced by AST_TEST_DEFINE().

{
   char *options = ast_strdup(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);
}

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.

References ao2_container_count(), ao2_find, ao2_ref, ao2_unlock, ao2_wrlock, ast_cli_args::argc, ast_cli_args::argv, ast_cli(), cache, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, sorcery_memory_cache::full_backend_cache, memory_cache_populate(), ast_cli_args::n, NULL, OBJ_SEARCH_KEY, sorcery_memory_cache::object_type, sorcery_memory_cache::objects, ast_cli_args::pos, remove_all_from_cache(), sorcery_memory_cache::sorcery, sorcery_memory_cache_complete_name(), ast_cli_entry::usage, and ast_cli_args::word.

{
   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;
}

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.

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().

{
#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
}

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.

References ao2_unlock, ao2_wrlock, sorcery_memory_cache::expire_on_reload, sorcery_memory_cache::objects, and remove_all_from_cache().

{
   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);
}

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.

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

{
   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;
}

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.

References ao2_bump, ao2_find, ao2_ref, ast_assert, ast_sorcery_object_get_id(), is_passthru_update(), memory_cache_full_update(), memory_cache_stale_check_object(), NULL, OBJ_SEARCH_KEY, sorcery_memory_cached_object::object, and sorcery_memory_cache::objects.

Referenced by AST_TEST_DEFINE(), and check_cache_content().

{
   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;
}

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.

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

{
   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);
   }
}

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.

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

{
   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);
   }
}

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.

References ao2_callback, ao2_container_count(), cache, sorcery_memory_cache::full_backend_cache, is_passthru_update(), memory_cache_full_update(), memory_cache_stale_check(), sorcery_memory_cache::objects, sorcery_memory_cache::sorcery, sorcery_memory_cache_fields_cmp_params::sorcery, and sorcery_memory_cache_fields_cmp().

{
   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);
   }
}

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.

References ao2_container_count(), ao2_find, ao2_ref, ast_cli_args::argc, ast_cli_args::argv, ast_cli(), AST_CLI_ONOFF, cache, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, sorcery_memory_cache::expire_on_reload, ast_cli_args::fd, sorcery_memory_cache::maximum_objects, ast_cli_args::n, sorcery_memory_cache::name, NULL, OBJ_SEARCH_KEY, sorcery_memory_cache::object_lifetime_maximum, sorcery_memory_cache::object_lifetime_stale, sorcery_memory_cache::objects, ast_cli_args::pos, sorcery_memory_cache_complete_name(), ast_cli_entry::usage, and ast_cli_args::word.

{
   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;
}

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.

References ao2_find, ao2_rdlock, ao2_ref, ao2_unlock, ast_cli_args::argc, ast_cli_args::argv, ast_cli(), ast_cli_complete(), cache, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, mark_all_as_stale_in_cache(), mark_object_as_stale_in_cache(), memory_cache_stale_update_object(), ast_cli_args::n, NULL, OBJ_NOLOCK, OBJ_SEARCH_KEY, sorcery_memory_cache::object_lifetime_stale, sorcery_memory_cache::objects, ast_cli_args::pos, reload(), sorcery_memory_cache::sorcery, sorcery_memory_cache_complete_name(), sorcery_memory_cache_complete_object_name(), ast_cli_entry::usage, and ast_cli_args::word.

{
   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;
}

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.

References ao2_alloc, ao2_bump, ao2_ref, ast_sorcery_objectset_create, ast_tvnow(), sorcery_memory_cached_object::created, sorcery_memory_cache::full_backend_cache, NULL, sorcery_memory_cached_object::object, sorcery_memory_cached_object::objectset, 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().

{
   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;
}

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.

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().

{
   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;
}

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.

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

Referenced by sorcery_memory_cached_object_alloc().

{
   struct sorcery_memory_cached_object *cached = obj;

   ao2_cleanup(cached->object);
   ast_variables_destroy(cached->objectset);
}

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.

References ast_assert, ast_sorcery_object_get_id(), ast_str_hash(), sorcery_memory_cache::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().

{
   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;
}

stale_cache_update()

static int stale_cache_update ( const void *  data )

static

Definition at line 908 of file res_sorcery_memory_cache.c.

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(), stale_cache_update_task_data::cache, end_passthru_update(), LOG_ERROR, LOG_WARNING, sorcery_memory_cache::maximum_objects, sorcery_memory_cache::name, NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_NOLOCK, object_add_to_cache_callback(), sorcery_memory_cache::objects, remove_all_from_cache(), stale_cache_update_task_data::sorcery, sorcery_memory_cache::stale_update_sched_id, start_passthru_update(), and stale_cache_update_task_data::type.

Referenced by memory_cache_stale_update_full().

{
   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;
}

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.

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

Referenced by memory_cache_stale_update_full().

{
   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;
}

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.

References ao2_cleanup, ast_free, ast_sorcery_unref, stale_cache_update_task_data::cache, stale_cache_update_task_data::sorcery, and stale_cache_update_task_data::type.

Referenced by stale_cache_update_task_data_alloc().

{
   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);
}

stale_item_update()

static int stale_item_update ( const void *  data )

static

Definition at line 989 of file res_sorcery_memory_cache.c.

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, stale_update_task_data::cache, end_passthru_update(), sorcery_memory_cache::name, stale_update_task_data::object, stale_update_task_data::sorcery, sorcery_memory_cache_create(), sorcery_memory_cache_delete(), and start_passthru_update().

Referenced by memory_cache_stale_update_object().

{
   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;
}

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.

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

Referenced by memory_cache_stale_update_object().

{
   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;
}

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.

References ao2_cleanup, ast_sorcery_unref, stale_update_task_data::cache, stale_update_task_data::object, and stale_update_task_data::sorcery.

Referenced by stale_update_task_data_alloc().

{
   struct stale_update_task_data *task_data = obj;

   ao2_cleanup(task_data->cache);
   ao2_cleanup(task_data->object);
   ast_sorcery_unref(task_data->sorcery);
}

start_passthru_update()

static void start_passthru_update ( void  )

static

Definition at line 276 of file res_sorcery_memory_cache.c.

References PASSTHRU_UPDATE_THREAD_ID, and set_passthru_update().

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

{
   set_passthru_update(PASSTHRU_UPDATE_THREAD_ID);
}

test_data_alloc()

static void* test_data_alloc ( const char *  id )

static

Allocation callback for test_data sorcery object.

Definition at line 2997 of file res_sorcery_memory_cache.c.

References ast_sorcery_generic_alloc(), and NULL.

Referenced by AST_TEST_DEFINE().

                                             {
   return ast_sorcery_generic_alloc(sizeof(struct test_data), NULL);
}

test_sorcery_object_alloc()

static void* test_sorcery_object_alloc ( const char *  id )

static

Definition at line 2288 of file res_sorcery_memory_cache.c.

References ast_sorcery_generic_alloc(), and NULL.

Referenced by alloc_and_initialize_sorcery().

{
   return ast_sorcery_generic_alloc(sizeof(struct test_sorcery_object), NULL);
}

unload_module()

static int unload_module ( void  )

static

Definition at line 3500 of file res_sorcery_memory_cache.c.

References ao2_cleanup, ARRAY_LEN, ast_cli_unregister_multiple(), ast_manager_unregister(), ast_sched_context_destroy(), ast_sorcery_wizard_unregister(), AST_TEST_UNREGISTER, sorcery_memory_cache::maximum_objects, NULL, and update().

Referenced by load_module().

{
   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;
}

wait_for_cache_update()

static int wait_for_cache_update ( const struct ast_sorcery *  sorcery, void *  previous_object, struct test_data **  new_object  )

static

Wait for the cache to be updated after a stale object is retrieved.

Since the cache does not know what type of objects it is dealing with, and since we do not have the internals of the cache, the only way to make this determination is to continuously retrieve an object from the cache until we retrieve a different object than we had previously retrieved.

Parameters

	sorcery	The sorcery instance
	previous_object	The object we had previously retrieved from the cache
[out]	new_object	The new object we retrieve from the cache

Return values

0	Successfully retrieved a new object from the cache
non-zero	Failed to retrieve a new object from the cache

Definition at line 3099 of file res_sorcery_memory_cache.c.

References ao2_cleanup, ast_remaining_ms(), ast_sorcery_retrieve_by_id(), and ast_tvnow().

Referenced by AST_TEST_DEFINE().

{
   struct timeval start = ast_tvnow();

   while (ast_remaining_ms(start, 5000) > 0) {
      void *object;

      object = ast_sorcery_retrieve_by_id(sorcery, "test", "test");
      if (object != previous_object) {
         *new_object = object;
         return 0;
      }
      ao2_cleanup(object);
   }

   return -1;
}

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.

cli_memory_cache

struct ast_cli_entry cli_memory_cache[]

static

Definition at line 2057 of file res_sorcery_memory_cache.c.

memory_cache_object_wizard

struct ast_sorcery_wizard memory_cache_object_wizard

static

Definition at line 215 of file res_sorcery_memory_cache.c.

mock_wizard

struct ast_sorcery_wizard mock_wizard

static

Initial value:

= {
   .name = "mock",
   .retrieve_id = mock_retrieve_id,
   .retrieve_multiple = mock_retrieve_multiple,
}

A mock sorcery wizard used for the stale test.

Definition at line 3078 of file res_sorcery_memory_cache.c.

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().

real_backend_data

struct backend_data * real_backend_data

static

Referenced by AST_TEST_DEFINE(), mock_retrieve_id(), and mock_retrieve_multiple().

sched

struct ast_sched_context* sched

static

Scheduler for cache management.

Definition at line 244 of file res_sorcery_memory_cache.c.