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)

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 <mjordan@digium.com> 

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.

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.

AST_DB_FAMILY_LEN

#define AST_DB_FAMILY_LEN   12

Length of 'MediaCache' + 2 '/' characters

Definition at line 45 of file media_cache.c.

FORMAT_ROW [1/2]

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

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 Bucket File API backend.

While ast_media_cache_retrieve is used to retrieve media from some 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 268 of file media_cache.c.

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

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, media_cache_item_sync_to_astdb(), ast_bucket_file::metadata, 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().

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 Bucket File API implementation whether or not this affects any non-local storage

Definition at line 347 of file media_cache.c.

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

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

Referenced by AST_TEST_DEFINE(), bucket_http_test_wizard_delete(), and media_cache_handle_delete_item().

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.

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

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

Referenced by AST_TEST_DEFINE().

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 671 of file media_cache.c.

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

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(), cli_media_cache, media_cache, media_cache_populate_from_astdb(), media_cache_shutdown(), and NULL.

Referenced by asterisk_daemon().

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 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 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 157 of file media_cache.c.

{
    struct ast_bucket_file *bucket_file;
    struct ast_bucket_file *tmp_bucket_file;
    char *ext;
    if (ast_strlen_zero(uri)) {
        return -1;
    }
 
    ao2_lock(media_cache);
    ast_debug(5, "Looking for media at local cache, file: %s\n", uri);
 
    /* 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);
            ao2_unlock(media_cache);
            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);
    }
    /* We unlock to retrieve the file, because it can take a long time;
     * and we don't want to lock access to cached files while waiting
     */
    ao2_unlock(media_cache);
 
    /* 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 lock again, before updating cache */
    ao2_lock(media_cache);
 
    /* We can have duplicated buckets here, we check if already exists
     * before saving
     */
    tmp_bucket_file = ao2_find(media_cache, uri, OBJ_SEARCH_KEY | OBJ_NOLOCK);
    if (tmp_bucket_file) {
        ao2_ref(tmp_bucket_file, -1);
        ast_bucket_file_delete(bucket_file);
        ao2_ref(bucket_file, -1);
        ao2_unlock(media_cache);
        return 0;
    }
 
    /* 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);
    ao2_unlock(media_cache);
 
    return 0;
}

References ao2_find, ao2_link_flags, ao2_lock, ao2_ref, ao2_unlink_flags, ao2_unlock, 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, len(), media_cache, media_cache_item_sync_to_astdb(), OBJ_NOLOCK, OBJ_SEARCH_KEY, and ast_bucket_file::path.

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

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 241 of file media_cache.c.

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

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

Referenced by AST_TEST_DEFINE().

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 133 of file media_cache.c.

{
    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, '.')) {
        struct ast_bucket_metadata *ext =
            ast_bucket_file_metadata_get(bucket_file, "ext");
 
        if (ext) {
            char *new_path;
            if (ast_asprintf(&new_path, "%s%s", bucket_file->path, ext->value) != -1) {
                rename(bucket_file->path, new_path);
                ast_copy_string(bucket_file->path, new_path, sizeof(bucket_file->path));
                ast_free(new_path);
            }
            ao2_ref(ext, -1);
        }
    }
}

References ao2_ref, ast_asprintf, ast_bucket_file_metadata_get(), ast_copy_string(), ast_free, ast_strlen_zero(), ext, and ast_bucket_file::path.

Referenced by ast_media_cache_retrieve().

cli_complete_uri()

static char * cli_complete_uri ( const char *  word )

static

Definition at line 501 of file media_cache.c.

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

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

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

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 622 of file media_cache.c.

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

References a, ast_cli(), ast_media_cache_create_or_update(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, and ast_cli_entry::usage.

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 563 of file media_cache.c.

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

References a, ast_cli_entry::args, ast_cli(), ast_media_cache_delete(), cli_complete_uri(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, and ast_cli_entry::usage.

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 592 of file media_cache.c.

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

References a, ast_cli_entry::args, ast_cli(), ast_media_cache_retrieve(), cli_complete_uri(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, PATH_MAX, and ast_cli_entry::usage.

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 473 of file media_cache.c.

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

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

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 519 of file media_cache.c.

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

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

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.

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

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

media_cache_item_populate_from_astdb()

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

static

Definition at line 389 of file media_cache.c.

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

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, media_cache, ast_db_entry::next, NULL, and ast_bucket_file::path.

Referenced by media_cache_populate_from_astdb().

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.

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

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

media_cache_populate_from_astdb()

static void media_cache_populate_from_astdb ( void  )

static

Definition at line 443 of file media_cache.c.

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

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

media_cache_prnt_summary()

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

static

Definition at line 461 of file media_cache.c.

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

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

Referenced by media_cache_handle_show_all().

media_cache_remove_from_astdb()

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

static

Definition at line 375 of file media_cache.c.

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

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

Referenced by media_cache_populate_from_astdb().

media_cache_shutdown()

static void media_cache_shutdown ( void  )

static

Definition at line 663 of file media_cache.c.

{
    ao2_cleanup(media_cache);
    media_cache = NULL;
 
    ast_cli_unregister_multiple(cli_media_cache, ARRAY_LEN(cli_media_cache));
}

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

Referenced by ast_media_cache_init().

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.

{
    struct ast_bucket_metadata *metadata = obj;
    const char *hash = arg;
 
    ast_db_put(hash, metadata->name, metadata->value);
 
    return 0;
}

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

Referenced by media_cache_item_sync_to_astdb().

Variable Documentation

cli_media_cache

struct ast_cli_entry cli_media_cache[]

static

Definition at line 651 of file media_cache.c.

Referenced by ast_media_cache_init(), and media_cache_shutdown().

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.

Referenced by ast_media_cache_create_or_update(), ast_media_cache_delete(), ast_media_cache_exists(), ast_media_cache_init(), ast_media_cache_retrieve(), ast_media_cache_retrieve_metadata(), cli_complete_uri(), media_cache_handle_show_all(), media_cache_handle_show_item(), media_cache_item_populate_from_astdb(), and media_cache_shutdown().