media_cache.c File Reference

An in-memory media cache. More...

#include "asterisk.h"
#include <sys/stat.h>
#include "asterisk/config.h"
#include "asterisk/bucket.h"
#include "asterisk/astdb.h"
#include "asterisk/cli.h"
#include "asterisk/file.h"
#include "asterisk/media_cache.h"

Include dependency graph for media_cache.c:

Go to the source code of this file.

Macros
#define	AO2_BUCKETS   61
#define	AST_DB_FAMILY   "MediaCache"
#define	AST_DB_FAMILY_LEN   12
#define	FORMAT_ROW   "%-40s\n\t%-40s\n"
#define	FORMAT_ROW   "\t%20s: %-40.40s\n"

Functions
int	ast_media_cache_create_or_update (const char *uri, const char *file_path, struct ast_variable *metadata)
	Create/update a cached media item. More...
int	ast_media_cache_delete (const char *uri)
	Remove an item from the media cache. More...
int	ast_media_cache_exists (const char *uri)
	Check if an item exists in the cache. More...
int	ast_media_cache_init (void)
	Initialize the media cache. More...
int	ast_media_cache_retrieve (const char *uri, const char *preferred_file_name, char *file_path, size_t len)
	Retrieve an item from the cache. More...
int	ast_media_cache_retrieve_metadata (const char *uri, const char *key, char *value, size_t len)
	Retrieve metadata from an item in the cache. More...
static void	bucket_file_update_path (struct ast_bucket_file *bucket_file, const char *preferred_file_name)
static char *	cli_complete_uri (const char *word)
static char *	media_cache_handle_create_item (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	media_cache_handle_delete_item (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	media_cache_handle_refresh_item (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	media_cache_handle_show_all (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	media_cache_handle_show_item (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void	media_cache_item_del_from_astdb (struct ast_bucket_file *bucket_file)
static int	media_cache_item_populate_from_astdb (const char *uri, const char *hash)
static void	media_cache_item_sync_to_astdb (struct ast_bucket_file *bucket_file)
static void	media_cache_populate_from_astdb (void)
static int	media_cache_prnt_summary (void *obj, void *arg, int flags)
static void	media_cache_remove_from_astdb (const char *uri, const char *hash)
static void	media_cache_shutdown (void)
static int	metadata_sync_to_astdb (void *obj, void *arg, int flags)
static void	normalize_content_type_header (char *content_type)

Variables
static struct ast_cli_entry	cli_media_cache []
static struct ao2_container *	media_cache

Detailed Description

An in-memory media cache.

Author

Matt Jordan <[email protected]> 

Definition in file media_cache.c.

Macro Definition Documentation

AO2_BUCKETS

#define AO2_BUCKETS   61

Number of buckets in the ao2 container holding our media items

Definition at line 48 of file media_cache.c.

Referenced by ast_media_cache_init().

AST_DB_FAMILY

#define AST_DB_FAMILY   "MediaCache"

The name of the AstDB family holding items in the cache.

Definition at line 42 of file media_cache.c.

Referenced by media_cache_item_del_from_astdb(), media_cache_item_sync_to_astdb(), media_cache_populate_from_astdb(), and media_cache_remove_from_astdb().

AST_DB_FAMILY_LEN

#define AST_DB_FAMILY_LEN   12

Length of 'MediaCache' + 2 '/' characters

Definition at line 45 of file media_cache.c.

Referenced by media_cache_populate_from_astdb(), and media_cache_remove_from_astdb().

FORMAT_ROW [1/2]

#define FORMAT_ROW   "%-40s\n\t%-40s\n"

Referenced by media_cache_handle_show_item(), and media_cache_prnt_summary().

FORMAT_ROW [2/2]

#define FORMAT_ROW   "\t%20s: %-40.40s\n"

Function Documentation

ast_media_cache_create_or_update()

int ast_media_cache_create_or_update	(	const char *	uri,
		const char *	file_path,
		struct ast_variable *	metadata
	)

Create/update a cached media item.

Parameters

uri	The unique URI for the media item to store in the cache
file_path	Full path to the media file to be cached
metadata	Metadata to store with the cached item

Return values

0	The item was cached
-1	An error occurred when creating/updating the item

Example Usage:

int res;

res = ast_media_cache_create_or_update("http://localhost/foo.wav",
 "/tmp/foo.wav", NULL);

Note

This method will overwrite whatever has been provided by the AstBucket Bucket File API backend.

While ast_media_cache_retrieve is used to retrieve media from some AstBucket Bucket File API provider, this method allows for overwriting what is provided by a backend with some local media. This is useful for reconstructing or otherwise associating local media with a remote URI, deferring updating of the media from the backend to some later retrieval.

Definition at line 285 of file media_cache.c.

References ao2_find, ao2_link_flags, ao2_ref, ao2_unlink_flags, ast_bucket_file_alloc(), ast_bucket_file_clone(), ast_bucket_file_create(), ast_bucket_file_metadata_set(), ast_log, ast_strdupa, ast_strlen_zero, ast_bucket_file::created, ext, LOG_WARNING, media_cache_item_sync_to_astdb(), ast_bucket_file::modified, ast_variable::name, ast_variable::next, OBJ_NOLOCK, OBJ_SEARCH_KEY, ast_bucket_file::path, SCOPED_AO2LOCK, tmp(), and ast_variable::value.

Referenced by AST_TEST_DEFINE(), and media_cache_handle_create_item().

{
 struct ast_bucket_file *bucket_file;
 struct ast_variable *it_metadata;
 struct stat st;
 char tmp[128];
 char *ext;
 char *file_path_ptr;
 int created = 0;
 SCOPED_AO2LOCK(media_lock, media_cache);

 if (ast_strlen_zero(file_path) || ast_strlen_zero(uri)) {
 return -1;
 }
 file_path_ptr = ast_strdupa(file_path);

 if (stat(file_path, &st)) {
 ast_log(LOG_WARNING, "Unable to obtain information for file %s for URI %s\n",
 file_path, uri);
 return -1;
 }

 bucket_file = ao2_find(media_cache, uri, OBJ_SEARCH_KEY | OBJ_NOLOCK);
 if (bucket_file) {
 struct ast_bucket_file *clone;

 clone = ast_bucket_file_clone(bucket_file);
 if (!clone) {
 ao2_ref(bucket_file, -1);
 return -1;
 }

 /* Remove the old bucket_file. We'll replace it if we succeed below. */
 ao2_unlink_flags(media_cache, bucket_file, OBJ_NOLOCK);
 ao2_ref(bucket_file, -1);

 bucket_file = clone;
 } else {
 bucket_file = ast_bucket_file_alloc(uri);
 if (!bucket_file) {
 ast_log(LOG_WARNING, "Failed to create file storage for %s and %s\n",
 uri, file_path);
 return -1;
 }
 created = 1;
 }

 strcpy(bucket_file->path, file_path);
 bucket_file->created.tv_sec = st.st_ctime;
 bucket_file->modified.tv_sec = st.st_mtime;

 snprintf(tmp, sizeof(tmp), "%ld", (long)st.st_atime);
 ast_bucket_file_metadata_set(bucket_file, "accessed", tmp);

 snprintf(tmp, sizeof(tmp), "%jd", (intmax_t)st.st_size);
 ast_bucket_file_metadata_set(bucket_file, "size", tmp);

 ext = strrchr(file_path_ptr, '.');
 if (ext) {
 ast_bucket_file_metadata_set(bucket_file, "ext", ext + 1);
 }

 for (it_metadata = metadata; it_metadata; it_metadata = it_metadata->next) {
 ast_bucket_file_metadata_set(bucket_file, it_metadata->name, it_metadata->value);
 }

 if (created && ast_bucket_file_create(bucket_file)) {
 ast_log(LOG_WARNING, "Failed to create media for %s\n", uri);
 ao2_ref(bucket_file, -1);
 return -1;
 }
 media_cache_item_sync_to_astdb(bucket_file);

 ao2_link_flags(media_cache, bucket_file, OBJ_NOLOCK);
 ao2_ref(bucket_file, -1);
 return 0;
}

ast_media_cache_delete()

int ast_media_cache_delete

(

const char *

uri

)

Remove an item from the media cache.

Parameters

uri	The unique URI for the media item to store in the cache

Return values

0	success
-1	error

Example Usage:

int res;

res = ast_media_cache_delete("http://localhost/foo.wav");

This removes an item completely from the media cache. Any files local on disk associated with the item are deleted as well.

Note

It is up to the AstBucket Bucket File API implementation whether or not this affects any non-local storage

Definition at line 364 of file media_cache.c.

References ao2_find, ao2_ref, ast_bucket_file_delete(), ast_strlen_zero, media_cache_item_del_from_astdb(), OBJ_SEARCH_KEY, and OBJ_UNLINK.

Referenced by media_cache_handle_delete_item().

{
 struct ast_bucket_file *bucket_file;
 int res;

 if (ast_strlen_zero(uri)) {
 return -1;
 }

 bucket_file = ao2_find(media_cache, uri, OBJ_SEARCH_KEY | OBJ_UNLINK);
 if (!bucket_file) {
 return -1;
 }

 res = ast_bucket_file_delete(bucket_file);
 media_cache_item_del_from_astdb(bucket_file);

 ao2_ref(bucket_file, -1);

 return res;
}

ast_media_cache_exists()

int ast_media_cache_exists

(

const char *

uri

)

Check if an item exists in the cache.

Parameters

uri	The unique URI for the media item

Return values

0	uri does not exist in cache
1	uri does exist in cache

Definition at line 53 of file media_cache.c.

References ao2_find, ao2_ref, ast_bucket_file_retrieve(), ast_strlen_zero, and OBJ_SEARCH_KEY.

Referenced by AST_TEST_DEFINE().

{
 struct ast_bucket_file *bucket_file;

 if (ast_strlen_zero(uri)) {
 return 0;
 }

 bucket_file = ao2_find(media_cache, uri, OBJ_SEARCH_KEY);
 if (bucket_file) {
 ao2_ref(bucket_file, -1);
 return 1;
 }

 /* Check to see if any bucket implementation could return this item */
 bucket_file = ast_bucket_file_retrieve(uri);
 if (bucket_file) {
 ao2_ref(bucket_file, -1);
 return 1;
 }

 return 0;
}

ast_media_cache_init()

int ast_media_cache_init

(

void

)

Initialize the media cache.

Note

This should only be called once, during Asterisk initialization

Return values

0	success
-1	error

Definition at line 688 of file media_cache.c.

References AO2_ALLOC_OPT_LOCK_MUTEX, AO2_BUCKETS, ao2_container_alloc_hash, ARRAY_LEN, ast_cli_register_multiple, ast_register_cleanup(), ast_sorcery_object_id_compare(), ast_sorcery_object_id_hash(), media_cache_populate_from_astdb(), media_cache_shutdown(), and NULL.

Referenced by asterisk_daemon().

{
 ast_register_cleanup(media_cache_shutdown);

 media_cache = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, AO2_BUCKETS,
 ast_sorcery_object_id_hash, NULL, ast_sorcery_object_id_compare);
 if (!media_cache) {
 return -1;
 }

 if (ast_cli_register_multiple(cli_media_cache, ARRAY_LEN(cli_media_cache))) {
 return -1;
 }

 media_cache_populate_from_astdb();

 return 0;
}

ast_media_cache_retrieve()

int ast_media_cache_retrieve	(	const char *	uri,
		const char *	preferred_file_name,
		char *	file_path,
		size_t	len
	)

Retrieve an item from the cache.

Parameters

uri	The unique URI for the media item
preferred_file_name	The preferred name for the file storing the media once it is retrieved. Can be NULL.
file_path	Buffer to store the full path to the media in the cache
len	The length of the buffer pointed to by file_path

Return values

0	The item was retrieved successfully
-1	The item could not be retrieved

Example Usage:

char media[PATH_MAX];
int res;

res = ast_media_cache_retrieve("http://localhost/foo.wav", NULL,
 media, sizeof(media));

Retrieving an item will cause the AstBucket Bucket File API Bucket backend associated with the URI scheme in uri to be queried. If the Bucket backend does not require an update, the cached information is used to find the file associated with uri, and file_path is populated with the location of the media file associated with uri.

If the item is not in the cache, the item will be retrieved using the AstBucket Bucket File API backend. When this occurs, if preferred_file_name is given, it will be used as the destination file for the retrieval. When retrieval of the media from the backend is complete, file_path is then populated as before.

Definition at line 197 of file media_cache.c.

References ao2_find, ao2_link_flags, ao2_ref, ao2_unlink_flags, ast_bucket_file_delete(), ast_bucket_file_is_stale(), ast_bucket_file_retrieve(), ast_copy_string(), ast_debug, ast_file_is_readable(), ast_strlen_zero, bucket_file_update_path(), ext, media_cache_item_sync_to_astdb(), OBJ_NOLOCK, OBJ_SEARCH_KEY, ast_bucket_file::path, and SCOPED_AO2LOCK.

Referenced by AST_TEST_DEFINE(), fileexists_test(), and media_cache_handle_refresh_item().

{
 struct ast_bucket_file *bucket_file;
 char *ext;
 SCOPED_AO2LOCK(media_lock, media_cache);

 if (ast_strlen_zero(uri)) {
 return -1;
 }

 /* First, retrieve from the ao2 cache here. If we find a bucket_file
 * matching the requested URI, ask the appropriate backend if it is
 * stale. If not; return it.
 */
 bucket_file = ao2_find(media_cache, uri, OBJ_SEARCH_KEY | OBJ_NOLOCK);
 if (bucket_file) {
 if (!ast_bucket_file_is_stale(bucket_file)
 && ast_file_is_readable(bucket_file->path)) {
 ast_copy_string(file_path, bucket_file->path, len);
 if ((ext = strrchr(file_path, '.'))) {
 *ext = '\0';
 }
 ao2_ref(bucket_file, -1);

 ast_debug(5, "Returning media at local file: %s\n", file_path);
 return 0;
 }

 /* Stale! Remove the item completely, as we're going to replace it next */
 ao2_unlink_flags(media_cache, bucket_file, OBJ_NOLOCK);
 ast_bucket_file_delete(bucket_file);
 ao2_ref(bucket_file, -1);
 }

 /* Either this is new or the resource is stale; do a full retrieve
 * from the appropriate bucket_file backend
 */
 bucket_file = ast_bucket_file_retrieve(uri);
 if (!bucket_file) {
 ast_debug(2, "Failed to obtain media at '%s'\n", uri);
 return -1;
 }

 /* We can manipulate the 'immutable' bucket_file here, as we haven't
 * let anyone know of its existence yet
 */
 bucket_file_update_path(bucket_file, preferred_file_name);
 media_cache_item_sync_to_astdb(bucket_file);
 ast_copy_string(file_path, bucket_file->path, len);
 if ((ext = strrchr(file_path, '.'))) {
 *ext = '\0';
 }
 ao2_link_flags(media_cache, bucket_file, OBJ_NOLOCK);
 ao2_ref(bucket_file, -1);

 ast_debug(5, "Returning media at local file: %s\n", file_path);

 return 0;
}

ast_media_cache_retrieve_metadata()

int ast_media_cache_retrieve_metadata	(	const char *	uri,
		const char *	key,
		char *	value,
		size_t	len
	)

Retrieve metadata from an item in the cache.

Parameters

uri	The unique URI for the media item
key	The key of the metadata to retrieve
value	Buffer to store the value in
len	The length of the buffer pointed to by value

Return values

0	The metadata was retrieved successfully
-1	The metadata could not be retrieved

Example Usage:

int res;
char file_size[32];

res = ast_media_cache_retrieve_metadata("http://localhost/foo.wav", "size",
 file_size, sizeof(file_size));

Definition at line 258 of file media_cache.c.

References ao2_find, ao2_ref, ast_copy_string(), ast_strlen_zero, ast_bucket_file::metadata, OBJ_SEARCH_KEY, and ast_bucket_metadata::value.

Referenced by AST_TEST_DEFINE().

{
 struct ast_bucket_file *bucket_file;
 struct ast_bucket_metadata *metadata;

 if (ast_strlen_zero(uri) || ast_strlen_zero(key) || !value) {
 return -1;
 }

 bucket_file = ao2_find(media_cache, uri, OBJ_SEARCH_KEY);
 if (!bucket_file) {
 return -1;
 }

 metadata = ao2_find(bucket_file->metadata, key, OBJ_SEARCH_KEY);
 if (!metadata) {
 ao2_ref(bucket_file, -1);
 return -1;
 }
 ast_copy_string(value, metadata->value, len);

 ao2_ref(metadata, -1);
 ao2_ref(bucket_file, -1);
 return 0;
}

bucket_file_update_path()

static void bucket_file_update_path ( struct ast_bucket_file *  bucket_file, const char *  preferred_file_name  )

static

Definition at line 150 of file media_cache.c.

References ao2_ref, ast_bucket_file_metadata_get(), ast_bucket_file_metadata_set(), ast_copy_string(), ast_free, ast_get_extension_for_mime_type(), ast_get_format_for_file_ext(), ast_sorcery_object_get_id(), ast_strdup, ast_strlen_zero, ext, normalize_content_type_header(), ast_bucket_file::path, PATH_MAX, and ast_bucket_metadata::value.

Referenced by ast_media_cache_retrieve().

{
 char *ext;

 if (!ast_strlen_zero(preferred_file_name) && strcmp(bucket_file->path, preferred_file_name)) {
 /* Use the preferred file name if available */

 rename(bucket_file->path, preferred_file_name);
 ast_copy_string(bucket_file->path, preferred_file_name,
 sizeof(bucket_file->path));
 } else if (!strchr(bucket_file->path, '.') && (ext = strrchr(ast_sorcery_object_get_id(bucket_file), '.'))) {
 /* If we don't have a file extension and were provided one in the URI, use it */
 char found_ext[32];
 char new_path[PATH_MAX + sizeof(found_ext)];

 ast_bucket_file_metadata_set(bucket_file, "ext", ext);

 /* Don't pass '.' while checking for supported extension */
 if (!ast_get_format_for_file_ext(ext + 1)) {
 /* If the file extension passed in the URI isn't supported check for the
 * extension based on the MIME type passed in the Content-Type header before
 * giving up.
 * If a match is found then retrieve the extension from the supported list
 * corresponding to the mime-type and use that to rename the file */
 struct ast_bucket_metadata *header = ast_bucket_file_metadata_get(bucket_file, "content-type");
 if (header) {
 char *mime_type = ast_strdup(header->value);
 if (mime_type) {
 normalize_content_type_header(mime_type);
 if (!ast_strlen_zero(mime_type)) {
 if (ast_get_extension_for_mime_type(mime_type, found_ext, sizeof(found_ext))) {
 ext = found_ext;
 }
 }
 ast_free(mime_type);
 }
 ao2_ref(header, -1);
 }
 }

 snprintf(new_path, sizeof(new_path), "%s%s", bucket_file->path, ext);
 rename(bucket_file->path, new_path);
 ast_copy_string(bucket_file->path, new_path, sizeof(bucket_file->path));
 }
}

cli_complete_uri()

static char* cli_complete_uri ( const char *  word )

static

Definition at line 518 of file media_cache.c.

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_cli_completion_add(), ast_sorcery_object_get_id(), ast_strdup, and NULL.

Referenced by media_cache_handle_delete_item(), media_cache_handle_refresh_item(), and media_cache_handle_show_item().

{
 struct ast_bucket_file *bucket_file;
 struct ao2_iterator it_media_items;
 int wordlen = strlen(word);

 it_media_items = ao2_iterator_init(media_cache, 0);
 while ((bucket_file = ao2_iterator_next(&it_media_items))) {
 if (!strncasecmp(word, ast_sorcery_object_get_id(bucket_file), wordlen)) {
 ast_cli_completion_add(ast_strdup(ast_sorcery_object_get_id(bucket_file)));
 }
 ao2_ref(bucket_file, -1);
 }
 ao2_iterator_destroy(&it_media_items);

 return NULL;
}

media_cache_handle_create_item()

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

static

Definition at line 639 of file media_cache.c.

References ast_cli_args::argc, ast_cli_args::argv, ast_cli(), ast_media_cache_create_or_update(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, NULL, and ast_cli_entry::usage.

{
 switch (cmd) {
 case CLI_INIT:
 e->command = "media cache create";
 e->usage =
 "Usage: media cache create <uri> <file>\n"
 " Create an item in the media cache by associating a local media file with\n"
 " some URI.\n";
 return NULL;
 case CLI_GENERATE:
 return NULL;
 }

 if (a->argc != 5) {
 return CLI_SHOWUSAGE;
 }

 if (ast_media_cache_create_or_update(a->argv[3], a->argv[4], NULL)) {
 ast_cli(a->fd, "Unable to create '%s' associated with local file '%s'\n",
 a->argv[3], a->argv[4]);
 } else {
 ast_cli(a->fd, "Created '%s' for '%s' in the media cache\n",
 a->argv[3], a->argv[4]);
 }

 return CLI_SUCCESS;
}

media_cache_handle_delete_item()

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

static

Definition at line 580 of file media_cache.c.

References ast_cli_args::argc, ast_cli_entry::args, ast_cli_args::argv, ast_cli(), ast_media_cache_delete(), cli_complete_uri(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, NULL, ast_cli_args::pos, ast_cli_entry::usage, and ast_cli_args::word.

{
 switch (cmd) {
 case CLI_INIT:
 e->command = "media cache delete";
 e->usage =
 "Usage: media cache delete <uri>\n"
 " Delete an item from the media cache.\n\n"
 " Note that this will also remove any local storage of the media associated\n"
 " with the URI, and will inform the backend supporting the URI scheme that\n"
 " it should remove the item.\n";
 return NULL;
 case CLI_GENERATE:
 return a->pos == e->args ? cli_complete_uri(a->word) : NULL;
 }

 if (a->argc != 4) {
 return CLI_SHOWUSAGE;
 }

 if (ast_media_cache_delete(a->argv[3])) {
 ast_cli(a->fd, "Unable to delete '%s'\n", a->argv[3]);
 } else {
 ast_cli(a->fd, "Deleted '%s' from the media cache\n", a->argv[3]);
 }

 return CLI_SUCCESS;
}

media_cache_handle_refresh_item()

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

static

Definition at line 609 of file media_cache.c.

References ast_cli_args::argc, ast_cli_entry::args, ast_cli_args::argv, ast_cli(), ast_media_cache_retrieve(), cli_complete_uri(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, NULL, PATH_MAX, ast_cli_args::pos, ast_cli_entry::usage, and ast_cli_args::word.

{
 char file_path[PATH_MAX];

 switch (cmd) {
 case CLI_INIT:
 e->command = "media cache refresh";
 e->usage =
 "Usage: media cache refresh <uri>\n"
 " Ask for a refresh of a particular URI.\n\n"
 " If the item does not already exist in the media cache, the item will be\n"
 " populated from the backend supporting the URI scheme.\n";
 return NULL;
 case CLI_GENERATE:
 return a->pos == e->args ? cli_complete_uri(a->word) : NULL;
 }

 if (a->argc != 4) {
 return CLI_SHOWUSAGE;
 }

 if (ast_media_cache_retrieve(a->argv[3], NULL, file_path, sizeof(file_path))) {
 ast_cli(a->fd, "Unable to refresh '%s'\n", a->argv[3]);
 } else {
 ast_cli(a->fd, "Refreshed '%s' to local storage '%s'\n", a->argv[3], file_path);
 }

 return CLI_SUCCESS;
}

media_cache_handle_show_all()

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

static

Definition at line 490 of file media_cache.c.

References ao2_callback, ast_cli_args::argc, ast_cli(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, media_cache_prnt_summary(), NULL, OBJ_MULTIPLE, OBJ_NODATA, and ast_cli_entry::usage.

{
 switch (cmd) {
 case CLI_INIT:
 e->command = "media cache show all";
 e->usage =
 "Usage: media cache show all\n"
 " Display a summary of all current items in the media cache.\n";
 return NULL;
 case CLI_GENERATE:
 return NULL;
 }

 if (a->argc != 4) {
 return CLI_SHOWUSAGE;
 }

 ast_cli(a->fd, "URI\n\tLocal File\n");
 ast_cli(a->fd, "---------------\n");
 ao2_callback(media_cache, OBJ_NODATA | OBJ_MULTIPLE, media_cache_prnt_summary, a);

 return CLI_SUCCESS;
}

media_cache_handle_show_item()

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

static

Definition at line 536 of file media_cache.c.

References ao2_find, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_cli_args::argc, ast_cli_entry::args, ast_cli_args::argv, ast_cli(), ast_sorcery_object_get_id(), cli_complete_uri(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, FORMAT_ROW, ast_bucket_file::metadata, ast_bucket_metadata::name, NULL, OBJ_SEARCH_KEY, ast_bucket_file::path, ast_cli_args::pos, ast_cli_entry::usage, ast_bucket_metadata::value, and ast_cli_args::word.

{
#define FORMAT_ROW "\t%20s: %-40.40s\n"
 struct ast_bucket_file *bucket_file;
 struct ao2_iterator it_metadata;
 struct ast_bucket_metadata *metadata;

 switch (cmd) {
 case CLI_INIT:
 e->command = "media cache show";
 e->usage =
 "Usage: media cache show <uri>\n"
 " Display all information about a particular item in the media cache.\n";
 return NULL;
 case CLI_GENERATE:
 return a->pos == e->args ? cli_complete_uri(a->word) : NULL;
 }

 if (a->argc != 4) {
 return CLI_SHOWUSAGE;
 }

 bucket_file = ao2_find(media_cache, a->argv[3], OBJ_SEARCH_KEY);
 if (!bucket_file) {
 ast_cli(a->fd, "Unable to find '%s' in the media cache\n", a->argv[3]);
 return CLI_SUCCESS;
 }

 ast_cli(a->fd, "URI: %s\n", ast_sorcery_object_get_id(bucket_file));
 ast_cli(a->fd, "%s\n", "----------------------------------------");
 ast_cli(a->fd, FORMAT_ROW, "Path", bucket_file->path);

 it_metadata = ao2_iterator_init(bucket_file->metadata, 0);
 while ((metadata = ao2_iterator_next(&it_metadata))) {
 ast_cli(a->fd, FORMAT_ROW, metadata->name, metadata->value);
 ao2_ref(metadata, -1);
 }
 ao2_iterator_destroy(&it_metadata);

 ao2_ref(bucket_file, -1);
#undef FORMAT_ROW
 return CLI_SUCCESS;
}

media_cache_item_del_from_astdb()

static void media_cache_item_del_from_astdb ( struct ast_bucket_file *  bucket_file )

static

Definition at line 114 of file media_cache.c.

References ast_db_del(), ast_db_deltree(), AST_DB_FAMILY, ast_db_get_allocated(), ast_free, ast_sorcery_object_get_id(), and NULL.

Referenced by ast_media_cache_delete().

{
 char *hash_value;

 if (ast_db_get_allocated(AST_DB_FAMILY, ast_sorcery_object_get_id(bucket_file), &hash_value)) {
 return;
 }

 ast_db_deltree(hash_value, NULL);
 ast_db_del(AST_DB_FAMILY, ast_sorcery_object_get_id(bucket_file));
 ast_free(hash_value);
}

media_cache_item_populate_from_astdb()

static int media_cache_item_populate_from_astdb ( const char *  uri, const char *  hash  )

static

Definition at line 406 of file media_cache.c.

References ao2_link, ao2_ref, ast_bucket_file_alloc(), ast_bucket_file_metadata_set(), ast_db_freetree(), ast_db_gettree(), ast_log, ast_strlen_zero, ast_db_entry::data, ast_db_entry::key, LOG_WARNING, ast_db_entry::next, and NULL.

Referenced by media_cache_populate_from_astdb().

{
 struct ast_bucket_file *bucket_file;
 struct ast_db_entry *db_tree;
 struct ast_db_entry *db_entry;
 struct stat st;

 bucket_file = ast_bucket_file_alloc(uri);
 if (!bucket_file) {
 return -1;
 }

 db_tree = ast_db_gettree(hash, NULL);
 for (db_entry = db_tree; db_entry; db_entry = db_entry->next) {
 const char *key = strchr(db_entry->key + 1, '/');

 if (ast_strlen_zero(key)) {
 continue;
 }
 key++;

 if (!strcasecmp(key, "path")) {
 strcpy(bucket_file->path, db_entry->data);

 if (stat(bucket_file->path, &st)) {
 ast_log(LOG_WARNING, "Unable to obtain information for file %s for URI %s\n",
 bucket_file->path, uri);
 ao2_ref(bucket_file, -1);
 ast_db_freetree(db_tree);
 return -1;
 }
 } else {
 ast_bucket_file_metadata_set(bucket_file, key, db_entry->data);
 }
 }
 ast_db_freetree(db_tree);

 if (ast_strlen_zero(bucket_file->path)) {
 ao2_ref(bucket_file, -1);
 ast_log(LOG_WARNING, "Failed to restore media cache item for '%s' from AstDB: no 'path' specified\n",
 uri);
 return -1;
 }

 ao2_link(media_cache, bucket_file);
 ao2_ref(bucket_file, -1);

 return 0;
}

media_cache_item_sync_to_astdb()

static void media_cache_item_sync_to_astdb ( struct ast_bucket_file *  bucket_file )

static

Definition at line 96 of file media_cache.c.

References ast_bucket_file_metadata_callback(), AST_DB_FAMILY, ast_db_put(), ast_sha1_hash(), ast_sorcery_object_get_id(), metadata_sync_to_astdb(), and ast_bucket_file::path.

Referenced by ast_media_cache_create_or_update(), and ast_media_cache_retrieve().

{
 char hash[41]; /* 40 character SHA1 hash */

 ast_sha1_hash(hash, ast_sorcery_object_get_id(bucket_file));
 if (ast_db_put(AST_DB_FAMILY, ast_sorcery_object_get_id(bucket_file), hash)) {
 return;
 }

 ast_db_put(hash, "path", bucket_file->path);
 ast_bucket_file_metadata_callback(bucket_file, metadata_sync_to_astdb, hash);
}

media_cache_populate_from_astdb()

static void media_cache_populate_from_astdb ( void  )

static

Definition at line 460 of file media_cache.c.

References AST_DB_FAMILY, AST_DB_FAMILY_LEN, ast_db_freetree(), ast_db_gettree(), ast_db_entry::data, ast_db_entry::key, media_cache_item_populate_from_astdb(), media_cache_remove_from_astdb(), ast_db_entry::next, and NULL.

Referenced by ast_media_cache_init().

{
 struct ast_db_entry *db_entry;
 struct ast_db_entry *db_tree;

 db_tree = ast_db_gettree(AST_DB_FAMILY, NULL);
 for (db_entry = db_tree; db_entry; db_entry = db_entry->next) {
 if (media_cache_item_populate_from_astdb(db_entry->key + AST_DB_FAMILY_LEN, db_entry->data)) {
 media_cache_remove_from_astdb(db_entry->key, db_entry->data);
 }
 }
 ast_db_freetree(db_tree);
}

media_cache_prnt_summary()

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

static

Definition at line 478 of file media_cache.c.

References a, ast_cli(), ast_sorcery_object_get_id(), CMP_MATCH, ast_cli_args::fd, FORMAT_ROW, and ast_bucket_file::path.

Referenced by media_cache_handle_show_all().

{
#define FORMAT_ROW "%-40s\n\t%-40s\n"
 struct ast_bucket_file *bucket_file = obj;
 struct ast_cli_args *a = arg;

 ast_cli(a->fd, FORMAT_ROW, ast_sorcery_object_get_id(bucket_file), bucket_file->path);

#undef FORMAT_ROW
 return CMP_MATCH;
}

media_cache_remove_from_astdb()

static void media_cache_remove_from_astdb ( const char *  uri, const char *  hash  )

static

Definition at line 392 of file media_cache.c.

References ast_db_del(), ast_db_deltree(), AST_DB_FAMILY, AST_DB_FAMILY_LEN, and NULL.

Referenced by media_cache_populate_from_astdb().

{
 ast_db_del(AST_DB_FAMILY, uri + AST_DB_FAMILY_LEN);
 ast_db_deltree(hash, NULL);
}

media_cache_shutdown()

static void media_cache_shutdown ( void  )

static

Definition at line 680 of file media_cache.c.

References ao2_cleanup, ARRAY_LEN, ast_cli_unregister_multiple(), and NULL.

Referenced by ast_media_cache_init().

{
 ao2_cleanup(media_cache);
 media_cache = NULL;

 ast_cli_unregister_multiple(cli_media_cache, ARRAY_LEN(cli_media_cache));
}

metadata_sync_to_astdb()

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

static

Definition at line 81 of file media_cache.c.

References ast_db_put(), ast_bucket_metadata::name, and ast_bucket_metadata::value.

Referenced by media_cache_item_sync_to_astdb().

{
 struct ast_bucket_metadata *metadata = obj;
 const char *hash = arg;

 ast_db_put(hash, metadata->name, metadata->value);

 return 0;
}

normalize_content_type_header()

static void normalize_content_type_header ( char *  content_type )

static

Definition at line 133 of file media_cache.c.

Referenced by bucket_file_update_path().

{
 char *params = strchr(content_type, ';');

 if (params) {
 *params-- = 0;
 while (params > content_type && (*params == ' ' || *params == '\t')) {
 *params-- = 0;
 }
 }
}

Variable Documentation

cli_media_cache

struct ast_cli_entry cli_media_cache[]

static

Definition at line 668 of file media_cache.c.

media_cache

struct ao2_container* media_cache

static

Our one and only container holding media items

Definition at line 51 of file media_cache.c.