Fri Jul 24 00:42:00 2009

Asterisk developer's documentation


taskprocessor.c File Reference

Maintain a container of uniquely-named taskprocessor threads that can be shared across modules. More...

#include "asterisk.h"
#include <signal.h>
#include <sys/time.h>
#include "asterisk/_private.h"
#include "asterisk/module.h"
#include "asterisk/time.h"
#include "asterisk/astobj2.h"
#include "asterisk/cli.h"
#include "asterisk/taskprocessor.h"

Go to the source code of this file.

Data Structures

struct  ast_taskprocessor
 A ast_taskprocessor structure is a singleton by name. More...
struct  ast_taskprocessor::tps_queue
 Taskprocessor queue. More...
struct  tps_task
 tps_task structure is queued to a taskprocessor More...
struct  tps_taskprocessor_stats
 tps_taskprocessor_stats maintain statistics for a taskprocessor. More...

Defines

#define TPS_MAX_BUCKETS   7

Functions

ast_taskprocessorast_taskprocessor_get (char *name, enum ast_tps_options create)
 Get a reference to a taskprocessor with the specified name and create the taskprocessor if necessary.
const char * ast_taskprocessor_name (struct ast_taskprocessor *tps)
 Return the name of the taskprocessor singleton.
int ast_taskprocessor_push (struct ast_taskprocessor *tps, int(*task_exe)(void *datap), void *datap)
 Push a task into the specified taskprocessor queue and signal the taskprocessor thread.
void * ast_taskprocessor_unreference (struct ast_taskprocessor *tps)
 Unreference the specified taskprocessor and its reference count will decrement.
int ast_tps_init (void)
static char * cli_tps_ping (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char * cli_tps_report (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int tps_cmp_cb (void *obj, void *arg, int flags)
 The astobj2 compare callback for taskprocessors.
static int tps_hash_cb (const void *obj, const int flags)
 The astobj2 hash callback for taskprocessors.
static int tps_ping_handler (void *datap)
 CLI 'taskprocessor ping <blah>' handler function.
static void * tps_processing_function (void *data)
 The task processing function executed by a taskprocessor.
static struct tps_tasktps_task_alloc (int(*task_exe)(void *datap), void *datap)
static void * tps_task_free (struct tps_task *task)
static int tps_taskprocessor_depth (struct ast_taskprocessor *tps)
 Return the size of the taskprocessor queue.
static void tps_taskprocessor_destroy (void *tps)
 Destroy the taskprocessor when its refcount reaches zero.
static struct tps_tasktps_taskprocessor_pop (struct ast_taskprocessor *tps)
 Remove the front task off the taskprocessor queue.
static char * tps_taskprocessor_tab_complete (struct ast_taskprocessor *p, struct ast_cli_args *a)

Variables

static ast_cond_t cli_ping_cond
 CLI 'taskprocessor ping <blah>' operation requires a ping condition.
static ast_mutex_t cli_ping_cond_lock = ((ast_mutex_t) PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP )
 CLI 'taskprocessor ping <blah>' operation requires a ping condition lock.
static struct ast_cli_entry taskprocessor_clis []
static struct ao2_containertps_singletons
 tps_singletons is the astobj2 container for taskprocessor singletons


Detailed Description

Maintain a container of uniquely-named taskprocessor threads that can be shared across modules.

Author:
Dwayne Hubbard <dhubbard@digium.com>

Definition in file taskprocessor.c.


Define Documentation

#define TPS_MAX_BUCKETS   7

Definition at line 83 of file taskprocessor.c.

Referenced by ast_tps_init().


Function Documentation

struct ast_taskprocessor* ast_taskprocessor_get ( char *  name,
enum ast_tps_options  create 
)

Get a reference to a taskprocessor with the specified name and create the taskprocessor if necessary.

The default behavior of instantiating a taskprocessor if one does not already exist can be disabled by specifying the TPS_REF_IF_EXISTS ast_tps_options as the second argument to ast_taskprocessor_get().

Parameters:
name The name of the taskprocessor
create Use 0 by default or specify TPS_REF_IF_EXISTS to return NULL if the taskprocessor does not already exist return A pointer to a reference counted taskprocessor under normal conditions, or NULL if the TPS_REF_IF_EXISTS reference type is specified and the taskprocessor does not exist
Since:
1.6.1

Definition at line 407 of file taskprocessor.c.

References ao2_alloc, ao2_find, ao2_link, ao2_lock(), ao2_ref, ao2_unlock(), ast_calloc, ast_cond_init(), ast_log(), ast_mutex_init(), ast_pthread_create, AST_PTHREADT_NULL, ast_strdup, ast_strlen_zero(), LOG_ERROR, LOG_WARNING, ast_taskprocessor::name, OBJ_POINTER, tps_processing_function(), TPS_REF_IF_EXISTS, tps_singletons, and tps_taskprocessor_destroy().

Referenced by ast_event_init(), cli_tps_ping(), load_module(), and load_pbx().

00408 {
00409    struct ast_taskprocessor *p, tmp_tps = {
00410       .name = name,
00411    };
00412       
00413    if (ast_strlen_zero(name)) {
00414       ast_log(LOG_ERROR, "requesting a nameless taskprocessor!!!\n");
00415       return NULL;
00416    }
00417    ao2_lock(tps_singletons);
00418    p = ao2_find(tps_singletons, &tmp_tps, OBJ_POINTER);
00419    if (p) {
00420       ao2_unlock(tps_singletons);
00421       return p;
00422    }
00423    if (create & TPS_REF_IF_EXISTS) {
00424       /* calling function does not want a new taskprocessor to be created if it doesn't already exist */
00425       ao2_unlock(tps_singletons);
00426       return NULL;
00427    }
00428    /* create a new taskprocessor */
00429    if (!(p = ao2_alloc(sizeof(*p), tps_taskprocessor_destroy))) {
00430       ao2_unlock(tps_singletons);
00431       ast_log(LOG_WARNING, "failed to create taskprocessor '%s'\n", name);
00432       return NULL;
00433    }
00434 
00435    ast_cond_init(&p->poll_cond, NULL);
00436    ast_mutex_init(&p->taskprocessor_lock);
00437 
00438    if (!(p->stats = ast_calloc(1, sizeof(*p->stats)))) {
00439       ao2_unlock(tps_singletons);
00440       ast_log(LOG_WARNING, "failed to create taskprocessor stats for '%s'\n", name);
00441       ao2_ref(p, -1);
00442       return NULL;
00443    }
00444    if (!(p->name = ast_strdup(name))) {
00445       ao2_unlock(tps_singletons);
00446       ao2_ref(p, -1);
00447       return NULL;
00448    }
00449    p->poll_thread_run = 1;
00450    p->poll_thread = AST_PTHREADT_NULL;
00451    if (ast_pthread_create(&p->poll_thread, NULL, tps_processing_function, p) < 0) {
00452       ao2_unlock(tps_singletons);
00453       ast_log(LOG_ERROR, "Taskprocessor '%s' failed to create the processing thread.\n", p->name);
00454       ao2_ref(p, -1);
00455       return NULL;
00456    }
00457    if (!(ao2_link(tps_singletons, p))) {
00458       ao2_unlock(tps_singletons);
00459       ast_log(LOG_ERROR, "Failed to add taskprocessor '%s' to container\n", p->name);
00460       ao2_ref(p, -1);
00461       return NULL;
00462    }
00463    ao2_unlock(tps_singletons);
00464    return p;
00465 }

const char* ast_taskprocessor_name ( struct ast_taskprocessor tps  ) 

Return the name of the taskprocessor singleton.

Since:
1.6.1

Definition at line 395 of file taskprocessor.c.

References ast_log(), LOG_ERROR, and ast_taskprocessor::name.

00396 {
00397    if (!tps) {
00398       ast_log(LOG_ERROR, "no taskprocessor specified!\n");
00399       return NULL;
00400    }
00401    return tps->name;
00402 }

int ast_taskprocessor_push ( struct ast_taskprocessor tps,
int(*)(void *datap)  task_exe,
void *  datap 
)

Push a task into the specified taskprocessor queue and signal the taskprocessor thread.

Parameters:
tps The taskprocessor structure
task_exe The task handling function to push into the taskprocessor queue
datap The data to be used by the task handling function
Returns:
zero on success, -1 on failure
Since:
1.6.1

Definition at line 482 of file taskprocessor.c.

References ast_cond_signal(), AST_LIST_INSERT_TAIL, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), LOG_ERROR, ast_taskprocessor::name, ast_taskprocessor::poll_cond, ast_taskprocessor::taskprocessor_lock, ast_taskprocessor::tps_queue, ast_taskprocessor::tps_queue_size, and tps_task_alloc().

Referenced by ast_event_queue(), cli_tps_ping(), device_state_cb(), mwi_sub_event_cb(), and mwi_unsub_event_cb().

00483 {
00484    struct tps_task *t;
00485 
00486    if (!tps || !task_exe) {
00487       ast_log(LOG_ERROR, "%s is missing!!\n", (tps) ? "task callback" : "taskprocessor");
00488       return -1;
00489    }
00490    if (!(t = tps_task_alloc(task_exe, datap))) {
00491       ast_log(LOG_ERROR, "failed to allocate task!  Can't push to '%s'\n", tps->name);
00492       return -1;
00493    }
00494    ast_mutex_lock(&tps->taskprocessor_lock);
00495    AST_LIST_INSERT_TAIL(&tps->tps_queue, t, list);
00496    tps->tps_queue_size++;
00497    ast_cond_signal(&tps->poll_cond);
00498    ast_mutex_unlock(&tps->taskprocessor_lock);
00499    return 0;
00500 }

void* ast_taskprocessor_unreference ( struct ast_taskprocessor tps  ) 

Unreference the specified taskprocessor and its reference count will decrement.

Taskprocessors use astobj2 and will unlink from the taskprocessor singleton container and destroy themself when the taskprocessor reference count reaches zero.

Parameters:
tps taskprocessor to unreference
Returns:
NULL
Since:
1.6.1

Definition at line 468 of file taskprocessor.c.

References ao2_link, ao2_lock(), ao2_ref, ao2_unlink, ao2_unlock(), and tps_singletons.

Referenced by unload_module().

00469 {
00470    if (tps) {
00471       ao2_lock(tps_singletons);
00472       ao2_unlink(tps_singletons, tps);
00473       if (ao2_ref(tps, -1) > 1) {
00474          ao2_link(tps_singletons, tps);
00475       }
00476       ao2_unlock(tps_singletons);
00477    }
00478    return NULL;
00479 }

int ast_tps_init ( void   ) 

Provided by taskprocessor.c

Definition at line 122 of file taskprocessor.c.

References ao2_container_alloc, ARRAY_LEN, ast_cli_register_multiple(), ast_cond_init(), ast_log(), cli_ping_cond, LOG_ERROR, taskprocessor_clis, tps_cmp_cb(), tps_hash_cb(), TPS_MAX_BUCKETS, and tps_singletons.

Referenced by main().

00123 {
00124    if (!(tps_singletons = ao2_container_alloc(TPS_MAX_BUCKETS, tps_hash_cb, tps_cmp_cb))) {
00125       ast_log(LOG_ERROR, "taskprocessor container failed to initialize!\n");
00126       return -1;
00127    }
00128 
00129    ast_cond_init(&cli_ping_cond, NULL);
00130 
00131    ast_cli_register_multiple(taskprocessor_clis, ARRAY_LEN(taskprocessor_clis));
00132    return 0;
00133 }

static char * cli_tps_ping ( struct ast_cli_entry e,
int  cmd,
struct ast_cli_args a 
) [static]

Definition at line 189 of file taskprocessor.c.

References ao2_ref, ast_cli_args::argc, ast_cli_args::argv, ast_cli(), ast_cond_timedwait(), ast_mutex_lock(), ast_mutex_unlock(), ast_samp2tv(), ast_taskprocessor_get(), ast_taskprocessor_push(), ast_tvadd(), ast_tvnow(), ast_tvsub(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, cli_ping_cond, cli_ping_cond_lock, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, name, tps_ping_handler(), TPS_REF_IF_EXISTS, tps_taskprocessor_tab_complete(), and ast_cli_entry::usage.

00190 {
00191    struct timeval begin, end, delta;
00192    char *name;
00193    struct timeval when;
00194    struct timespec ts;
00195    struct ast_taskprocessor *tps = NULL;
00196 
00197    switch (cmd) {
00198    case CLI_INIT:
00199       e->command = "core taskprocessor ping";
00200       e->usage = 
00201          "Usage: core taskprocessor ping <taskprocessor>\n"
00202          "  Displays the time required for a task to be processed\n";
00203       return NULL;
00204    case CLI_GENERATE:
00205       return tps_taskprocessor_tab_complete(tps, a);
00206    }
00207 
00208    if (a->argc != 4)
00209       return CLI_SHOWUSAGE;
00210 
00211    name = a->argv[3];
00212    if (!(tps = ast_taskprocessor_get(name, TPS_REF_IF_EXISTS))) {
00213       ast_cli(a->fd, "\nping failed: %s not found\n\n", name);
00214       return CLI_SUCCESS;
00215    }
00216    ast_cli(a->fd, "\npinging %s ...", name);
00217    when = ast_tvadd((begin = ast_tvnow()), ast_samp2tv(1000, 1000));
00218    ts.tv_sec = when.tv_sec;
00219    ts.tv_nsec = when.tv_usec * 1000;
00220    ast_mutex_lock(&cli_ping_cond_lock);
00221    if (ast_taskprocessor_push(tps, tps_ping_handler, 0) < 0) {
00222       ast_cli(a->fd, "\nping failed: could not push task to %s\n\n", name);
00223       ao2_ref(tps, -1);
00224       return CLI_FAILURE;
00225    }
00226    ast_cond_timedwait(&cli_ping_cond, &cli_ping_cond_lock, &ts);
00227    ast_mutex_unlock(&cli_ping_cond_lock);
00228    end = ast_tvnow();
00229    delta = ast_tvsub(end, begin);
00230    ast_cli(a->fd, "\n\t%24s ping time: %.1ld.%.6ld sec\n\n", name, (long)delta.tv_sec, (long int)delta.tv_usec);
00231    ao2_ref(tps, -1);
00232    return CLI_SUCCESS;  
00233 }

static char * cli_tps_report ( struct ast_cli_entry e,
int  cmd,
struct ast_cli_args a 
) [static]

Definition at line 235 of file taskprocessor.c.

References tps_taskprocessor_stats::_tasks_processed_count, ao2_container_count(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_cli_args::argc, ast_cli_entry::args, ast_cli(), ast_copy_string(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, tps_taskprocessor_stats::max_qsize, ast_taskprocessor::name, name, ast_taskprocessor::stats, ast_taskprocessor::tps_queue_size, tps_singletons, and ast_cli_entry::usage.

00236 {
00237    char name[256];
00238    int tcount;
00239    unsigned long qsize;
00240    unsigned long maxqsize;
00241    unsigned long processed;
00242    struct ast_taskprocessor *p;
00243    struct ao2_iterator i;
00244 
00245    switch (cmd) {
00246    case CLI_INIT:
00247       e->command = "core show taskprocessors";
00248       e->usage = 
00249          "Usage: core show taskprocessors\n"
00250          "  Shows a list of instantiated task processors and their statistics\n";
00251       return NULL;
00252    case CLI_GENERATE:
00253       return NULL;   
00254    }
00255 
00256    if (a->argc != e->args)
00257       return CLI_SHOWUSAGE;
00258 
00259    ast_cli(a->fd, "\n\t+----- Processor -----+--- Processed ---+- In Queue -+- Max Depth -+");
00260    i = ao2_iterator_init(tps_singletons, 0);
00261    while ((p = ao2_iterator_next(&i))) {
00262       ast_copy_string(name, p->name, sizeof(name));
00263       qsize = p->tps_queue_size;
00264       maxqsize = p->stats->max_qsize;
00265       processed = p->stats->_tasks_processed_count;
00266       ast_cli(a->fd, "\n%24s   %17ld %12ld %12ld", name, processed, qsize, maxqsize);
00267       ao2_ref(p, -1);
00268    }
00269    tcount = ao2_container_count(tps_singletons); 
00270    ast_cli(a->fd, "\n\t+---------------------+-----------------+------------+-------------+\n\t%d taskprocessors\n\n", tcount);
00271    return CLI_SUCCESS;  
00272 }

static int tps_cmp_cb ( void *  obj,
void *  arg,
int  flags 
) [static]

The astobj2 compare callback for taskprocessors.

Definition at line 338 of file taskprocessor.c.

References CMP_MATCH, CMP_STOP, and ast_taskprocessor::name.

Referenced by ast_tps_init().

00339 {
00340    struct ast_taskprocessor *lhs = obj, *rhs = arg;
00341 
00342    return !strcasecmp(lhs->name, rhs->name) ? CMP_MATCH | CMP_STOP : 0;
00343 }

static int tps_hash_cb ( const void *  obj,
const int  flags 
) [static]

The astobj2 hash callback for taskprocessors.

Definition at line 330 of file taskprocessor.c.

References ast_str_case_hash(), and ast_taskprocessor::name.

Referenced by ast_tps_init().

00331 {
00332    const struct ast_taskprocessor *tps = obj;
00333 
00334    return ast_str_case_hash(tps->name);
00335 }

static int tps_ping_handler ( void *  datap  )  [static]

CLI 'taskprocessor ping <blah>' handler function.

Definition at line 180 of file taskprocessor.c.

References ast_cond_signal(), ast_mutex_lock(), ast_mutex_unlock(), cli_ping_cond, and cli_ping_cond_lock.

Referenced by cli_tps_ping().

00181 {
00182    ast_mutex_lock(&cli_ping_cond_lock);
00183    ast_cond_signal(&cli_ping_cond);
00184    ast_mutex_unlock(&cli_ping_cond_lock);
00185    return 0;
00186 }

static void * tps_processing_function ( void *  data  )  [static]

The task processing function executed by a taskprocessor.

Definition at line 275 of file taskprocessor.c.

References tps_taskprocessor_stats::_tasks_processed_count, ast_cond_wait(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), tps_task::datap, tps_task::execute, LOG_ERROR, LOG_WARNING, tps_taskprocessor_stats::max_qsize, ast_taskprocessor::poll_cond, ast_taskprocessor::poll_thread_run, ast_taskprocessor::stats, ast_taskprocessor::taskprocessor_lock, tps_task_free(), tps_taskprocessor_depth(), and tps_taskprocessor_pop().

Referenced by ast_taskprocessor_get().

00276 {
00277    struct ast_taskprocessor *i = data;
00278    struct tps_task *t;
00279    int size;
00280 
00281    if (!i) {
00282       ast_log(LOG_ERROR, "cannot start thread_function loop without a ast_taskprocessor structure.\n");
00283       return NULL;
00284    }
00285 
00286    while (i->poll_thread_run) {
00287       ast_mutex_lock(&i->taskprocessor_lock);
00288       if (!i->poll_thread_run) {
00289          ast_mutex_unlock(&i->taskprocessor_lock);
00290          break;
00291       }
00292       if (!(size = tps_taskprocessor_depth(i))) {
00293          ast_cond_wait(&i->poll_cond, &i->taskprocessor_lock);
00294          if (!i->poll_thread_run) {
00295             ast_mutex_unlock(&i->taskprocessor_lock);
00296             break;
00297          }
00298       }
00299       ast_mutex_unlock(&i->taskprocessor_lock);
00300       /* stuff is in the queue */
00301       if (!(t = tps_taskprocessor_pop(i))) {
00302          ast_log(LOG_ERROR, "Wtf?? %d tasks in the queue, but we're popping blanks!\n", size);
00303          continue;
00304       }
00305       if (!t->execute) {
00306          ast_log(LOG_WARNING, "Task is missing a function to execute!\n");
00307          tps_task_free(t);
00308          continue;
00309       }
00310       t->execute(t->datap);
00311  
00312       ast_mutex_lock(&i->taskprocessor_lock);
00313       if (i->stats) {
00314          i->stats->_tasks_processed_count++;
00315          if (size > i->stats->max_qsize) {
00316             i->stats->max_qsize = size;
00317          }
00318       }
00319       ast_mutex_unlock(&i->taskprocessor_lock);
00320  
00321       tps_task_free(t);
00322    }
00323    while ((t = tps_taskprocessor_pop(i))) {
00324       tps_task_free(t);
00325    }
00326    return NULL;
00327 }

static struct tps_task* tps_task_alloc ( int(*)(void *datap)  task_exe,
void *  datap 
) [static]

Definition at line 136 of file taskprocessor.c.

References ast_calloc, and tps_task::execute.

Referenced by ast_taskprocessor_push().

00137 {
00138    struct tps_task *t;
00139    if ((t = ast_calloc(1, sizeof(*t)))) {
00140       t->execute = task_exe;
00141       t->datap = datap;
00142    }
00143    return t;
00144 }

static void* tps_task_free ( struct tps_task task  )  [static]

Definition at line 147 of file taskprocessor.c.

References ast_free.

Referenced by tps_processing_function().

00148 {
00149    if (task) {
00150       ast_free(task);
00151    }
00152    return NULL;
00153 }

static int tps_taskprocessor_depth ( struct ast_taskprocessor tps  )  [static]

Return the size of the taskprocessor queue.

Definition at line 389 of file taskprocessor.c.

References ast_taskprocessor::tps_queue_size.

Referenced by tps_processing_function().

00390 {
00391    return (tps) ? tps->tps_queue_size : -1;
00392 }

static void tps_taskprocessor_destroy ( void *  tps  )  [static]

Destroy the taskprocessor when its refcount reaches zero.

Definition at line 346 of file taskprocessor.c.

References ast_cond_destroy(), ast_cond_signal(), ast_free, ast_log(), ast_mutex_destroy(), ast_mutex_lock(), ast_mutex_unlock(), AST_PTHREADT_NULL, LOG_DEBUG, LOG_ERROR, ast_taskprocessor::name, ast_taskprocessor::poll_cond, ast_taskprocessor::poll_thread, ast_taskprocessor::poll_thread_run, ast_taskprocessor::stats, and ast_taskprocessor::taskprocessor_lock.

Referenced by ast_taskprocessor_get().

00347 {
00348    struct ast_taskprocessor *t = tps;
00349    
00350    if (!tps) {
00351       ast_log(LOG_ERROR, "missing taskprocessor\n");
00352       return;
00353    }
00354    ast_log(LOG_DEBUG, "destroying taskprocessor '%s'\n", t->name);
00355    /* kill it */  
00356    ast_mutex_lock(&t->taskprocessor_lock);
00357    t->poll_thread_run = 0;
00358    ast_cond_signal(&t->poll_cond);
00359    ast_mutex_unlock(&t->taskprocessor_lock);
00360    pthread_join(t->poll_thread, NULL);
00361    t->poll_thread = AST_PTHREADT_NULL;
00362    ast_mutex_destroy(&t->taskprocessor_lock);
00363    ast_cond_destroy(&t->poll_cond);
00364    /* free it */
00365    if (t->stats) {
00366       ast_free(t->stats);
00367       t->stats = NULL;
00368    }
00369    ast_free(t->name);
00370 }

static struct tps_task * tps_taskprocessor_pop ( struct ast_taskprocessor tps  )  [static]

Remove the front task off the taskprocessor queue.

Definition at line 373 of file taskprocessor.c.

References AST_LIST_REMOVE_HEAD, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), LOG_ERROR, ast_taskprocessor::taskprocessor_lock, ast_taskprocessor::tps_queue, and ast_taskprocessor::tps_queue_size.

Referenced by tps_processing_function().

00374 {
00375    struct tps_task *task;
00376 
00377    if (!tps) {
00378       ast_log(LOG_ERROR, "missing taskprocessor\n");
00379       return NULL;
00380    }
00381    ast_mutex_lock(&tps->taskprocessor_lock);
00382    if ((task = AST_LIST_REMOVE_HEAD(&tps->tps_queue, list))) {
00383       tps->tps_queue_size--;
00384    }
00385    ast_mutex_unlock(&tps->taskprocessor_lock);
00386    return task;
00387 }

static char* tps_taskprocessor_tab_complete ( struct ast_taskprocessor p,
struct ast_cli_args a 
) [static]

Definition at line 156 of file taskprocessor.c.

References ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_strdup, ast_cli_args::n, ast_taskprocessor::name, name, ast_cli_args::pos, tps_singletons, and ast_cli_args::word.

Referenced by cli_tps_ping().

00157 {
00158    int tklen;
00159    int wordnum = 0;
00160    char *name = NULL;
00161    struct ao2_iterator i;
00162 
00163    if (a->pos != 3)
00164       return NULL;
00165 
00166    tklen = strlen(a->word);
00167    i = ao2_iterator_init(tps_singletons, 0);
00168    while ((p = ao2_iterator_next(&i))) {
00169       if (!strncasecmp(a->word, p->name, tklen) && ++wordnum > a->n) {
00170          name = ast_strdup(p->name);
00171          ao2_ref(p, -1);
00172          break;
00173       }
00174       ao2_ref(p, -1);
00175    }
00176    return name;
00177 }


Variable Documentation

ast_cond_t cli_ping_cond [static]

CLI 'taskprocessor ping <blah>' operation requires a ping condition.

Definition at line 88 of file taskprocessor.c.

Referenced by ast_tps_init(), cli_tps_ping(), and tps_ping_handler().

ast_mutex_t cli_ping_cond_lock = ((ast_mutex_t) PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP ) [static]

CLI 'taskprocessor ping <blah>' operation requires a ping condition lock.

Definition at line 91 of file taskprocessor.c.

Referenced by cli_tps_ping(), and tps_ping_handler().

struct ast_cli_entry taskprocessor_clis[] [static]

Initial value:

 {
   { .handler =  cli_tps_ping , .summary =  "Ping a named task processors" ,__VA_ARGS__ },
   { .handler =  cli_tps_report , .summary =  "List instantiated task processors and statistics" ,__VA_ARGS__ },
}

Definition at line 116 of file taskprocessor.c.

Referenced by ast_tps_init().

struct ao2_container* tps_singletons [static]

tps_singletons is the astobj2 container for taskprocessor singletons

Definition at line 85 of file taskprocessor.c.

Referenced by ast_taskprocessor_get(), ast_taskprocessor_unreference(), ast_tps_init(), cli_tps_report(), and tps_taskprocessor_tab_complete().


Generated on Fri Jul 24 00:42:00 2009 for Asterisk - the Open Source PBX by  doxygen 1.4.7