[svn-commits] irroot: branch irroot/distrotech-customers-1.8 r344954 - /team/irroot/distrot...
SVN commits to the Digium repositories
svn-commits at lists.digium.com
Sat Nov 12 05:21:05 CST 2011
Author: irroot
Date: Sat Nov 12 05:21:02 2011
New Revision: 344954
URL: http://svnview.digium.com/svn/asterisk?view=rev&rev=344954
Log:
Changes to queue backported from trunk
Modified:
team/irroot/distrotech-customers-1.8/apps/app_queue.c
Modified: team/irroot/distrotech-customers-1.8/apps/app_queue.c
URL: http://svnview.digium.com/svn/asterisk/team/irroot/distrotech-customers-1.8/apps/app_queue.c?view=diff&rev=344954&r1=344953&r2=344954
==============================================================================
--- team/irroot/distrotech-customers-1.8/apps/app_queue.c (original)
+++ team/irroot/distrotech-customers-1.8/apps/app_queue.c Sat Nov 12 05:21:02 2011
@@ -25,6 +25,18 @@
* \arg Config in \ref Config_qu queues.conf
*
* \par Development notes
+ * \note 2011-11-01: Made application more thread safe
+ * Distrotech PTY (LTD) (www.distrotech.co.za)
+ * Gregory Nietsky (irroot) <gregory at distrotech.co.za>
+ *
+ * Split away from locking queues/queue to having locks per
+ * Queue/Member/Device.
+ * Added device state struct to mange device states shared
+ * for multiple members sharing same device.
+ *
+ * Made all functions work with realtime/dynamic/static members.
+ * Added missing CLI/AMI functions for handling callinuse.
+ *
* \note 2004-11-25: Persistent Dynamic Members added by:
* NetNation Communications (www.netnation.com)
* Kevin Lindsay <kevinl at netnation.com>
@@ -99,22 +111,31 @@
#include "asterisk/callerid.h"
#include "asterisk/cel.h"
#include "asterisk/data.h"
-
-/* Define, to debug reference counts on queues, without debugging reference counts on queue members */
-/* #define REF_DEBUG_ONLY_QUEUES */
+#include "asterisk/time.h"
/*!
* \par Please read before modifying this file.
- * There are three locks which are regularly used
- * throughout this file, the queue list lock, the lock
- * for each individual queue, and the interface list lock.
+ * There are locks which are regularly used
+ * throughout this file, the lock
+ * for each individual queue, the individual member lock ,
+ * and the device state lock.
+ * there are container locks for the queues list, the member
+ * list on each queue and the devices container.
* Please be extra careful to always lock in the following order
- * 1) queue list lock
- * 2) individual queue lock
- * 3) interface list lock
+ *
+ * 1) queues container lock (ao2 functions that lock the container)
+ * 2) queue lock
+ * 3) queue member lock
+ * 4) member lock
+ * 5) devices container lock
+ * 6) member device lock
* This order has sort of "evolved" over the lifetime of this
* application, but it is now in place this way, so please adhere
* to this order!
+ *
+ * the only elements that do not require a read lock (ie will not change)
+ * the queue name and members container, the member interface and
+ * device state_interface as they are never altered after been linked.
*/
/*** DOCUMENTATION
@@ -264,9 +285,10 @@
<parameter name="queuename" required="true" />
<parameter name="interface" />
<parameter name="penalty" />
- <parameter name="options" />
+ <parameter name="paused" />
<parameter name="membername" />
<parameter name="stateinterface" />
+ <parameter name="callinuse" />
</syntax>
<description>
<para>Dynamically adds interface to an existing queue. If the interface is
@@ -530,8 +552,8 @@
<enum name="paused">
<para>Gets or sets queue member paused status.</para>
</enum>
- <enum name="ignorebusy">
- <para>Gets or sets queue member ignorebusy.</para>
+ <enum name="callinuse">
+ <para>Gets or sets queue member callinuse.</para>
</enum>
</enumlist>
</parameter>
@@ -846,14 +868,14 @@
<description>
</description>
</manager>
- <manager name="QueueIgnoreBusy" language="en_US">
+ <manager name="QueueCallInuse" language="en_US">
<synopsis>
Set interface to allow multiple calls
</synopsis>
<syntax>
<xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
<parameter name="Interface" required="true" />
- <parameter name="IgnoreBusy" required="true" />
+ <parameter name="CallInuse" required="true" />
<parameter name="Queue" required="true" />
</syntax>
<description>
@@ -883,6 +905,13 @@
QUEUE_RELOAD_MEMBER = (1 << 1),
QUEUE_RELOAD_RULES = (1 << 2),
QUEUE_RESET_STATS = (1 << 3),
+ QUEUE_RELOAD_REALTIME = (1 << 4),
+};
+
+enum member_type {
+ QUEUE_ADD_MEMBER_STATIC = (1 << 0),
+ QUEUE_ADD_MEMBER_REALTIME = (1 << 1),
+ QUEUE_ADD_MEMBER_DYNAMIC = (1 << 2),
};
static const struct strategy {
@@ -925,7 +954,7 @@
#define RES_OUTOFMEMORY (-2) /*!< Out of memory */
#define RES_NOSUCHQUEUE (-3) /*!< No such queue */
#define RES_NOT_DYNAMIC (-4) /*!< Member is not dynamic */
-
+#define RES_ERROR (-5) /*!< Member is mis configured */
static char *app = "Queue";
static char *app_aqm = "AddQueueMember" ;
@@ -1004,49 +1033,32 @@
* use it not only for keeping track of what is in use but
* also for keeping track of who we're dialing.
*
- * There are two "links" defined in this structure, q_next and call_next.
- * q_next links ALL defined callattempt structures into a linked list. call_next is
- * a link which allows for a subset of the callattempts to be traversed. This subset
- * is used in wait_for_answer so that irrelevant callattempts are not traversed. This
- * also is helpful so that queue logs are always accurate in the case where a call to
- * a member times out, especially if using the ringall strategy.
*/
struct callattempt {
- struct callattempt *q_next;
- struct callattempt *call_next;
- struct ast_channel *chan;
- char interface[256];
- int stillgoing;
- int metric;
- time_t lastcall;
- struct call_queue *lastqueue;
- struct member *member;
- /*! Saved connected party info from an AST_CONTROL_CONNECTED_LINE. */
- struct ast_party_connected_line connected;
- /*! TRUE if an AST_CONTROL_CONNECTED_LINE update was saved to the connected element. */
- unsigned int pending_connected_update:1;
- /*! TRUE if caller id is not available for connected line */
- unsigned int dial_callerid_absent:1;
- unsigned int reserved:1;
+ struct ast_channel *chan; /*! Channel called */
+ int stillgoing; /*! This attempt is valid and active */
+ int metric; /*! Metric calculated according to strategy */
+ struct member *member; /*! Member assosiated with this attempt */
+ struct ast_party_connected_line connected; /*! Saved connected party info from an AST_CONTROL_CONNECTED_LINE. */
+ unsigned int reserved:1; /*! Is this attempt been attempted*/
+ unsigned int active:1; /*! Is this attempt active in a call*/
+ unsigned int pending_connected_update:1; /*! TRUE if caller id is not available for connected line*/
+ unsigned int dial_callerid_absent:1; /*! TRUE if caller id is not available for connected line */
struct ast_aoc_decoded *aoc_s_rate_list;
};
-
struct queue_ent {
struct call_queue *parent; /*!< What queue is our parent */
- char moh[80]; /*!< Name of musiconhold to be used */
- char announce[PATH_MAX]; /*!< Announcement to play for member when call is answered */
- char context[AST_MAX_CONTEXT]; /*!< Context when user exits queue */
char digits[AST_MAX_EXTENSION]; /*!< Digits entered while in queue */
int valid_digits; /*!< Digits entered correspond to valid extension. Exited */
int pos; /*!< Where we are in the queue */
int prio; /*!< Our priority */
int last_pos_said; /*!< Last position we told the user */
int ring_when_ringing; /*!< Should we only use ring indication when a channel is ringing? */
- time_t last_periodic_announce_time; /*!< The last time we played a periodic announcement */
+ struct timeval last_pannounce_time; /*!< The last time we played a periodic announcement */
int last_periodic_announce_sound; /*!< The last periodic announcement we made */
- time_t last_pos; /*!< Last time we told the user their position */
+ struct timeval last_pos; /*!< Last time we told the user their position */
int opos; /*!< Where we started in the queue */
int handled; /*!< Whether our call was handled */
int pending; /*!< Non-zero if we are attempting to call a member */
@@ -1054,35 +1066,40 @@
int min_penalty; /*!< Limit the members that can take this call to this penalty or higher */
int linpos; /*!< If using linear strategy, what position are we at? */
int linwrapped; /*!< Is the linpos wrapped? */
- time_t start; /*!< When we started holding */
- time_t expire; /*!< When this entry should expire (time out of queue) */
+ struct timeval start; /*!< When we started holding */
+ struct timeval expire; /*!< When this entry should expire (time out of queue) */
int cancel_answered_elsewhere; /*!< Whether we should force the CAE flag on this call (C) option*/
+ struct ao2_container *attempts; /*!< Container holding all call attempts*/
struct ast_channel *chan; /*!< Our channel */
- AST_LIST_HEAD_NOLOCK(,penalty_rule) qe_rules; /*!< Local copy of the queue's penalty rules */
- struct penalty_rule *pr; /*!< Pointer to the next penalty rule to implement */
- struct queue_ent *next; /*!< The next queue entry */
+ struct rule_list *rules; /*!< Pointer holding the ref for the queue penalty rules */
+ struct penalty_rule *pr; /*!< Active penalty rule */
+ AST_LIST_ENTRY(queue_ent) next; /*!< The next queue entry */
};
+/*! \brief keep track of device state changes */
struct mem_state {
- char state_interface[80]; /*!< Technology/Location from which to read devicestate changes */
- int reserved; /*!< This interface is reserved for pending call */
- int status; /*!< Status of queue member */
+ char state_interface[80]; /*!< Technology/Location from which to read devicestate changes */
+ int reserved; /*!< This interface is reserved for pending call */
+ int active; /*!< This interface is active on a call */
+ int status; /*!< Status of queue member */
};
struct member {
- char interface[80]; /*!< Technology/Location to dial to reach this member*/
- char membername[80]; /*!< Member name to use in queue logs */
- int penalty; /*!< Are we a last resort? */
- int calls; /*!< Number of calls serviced by this member */
- time_t lastcall; /*!< When last successful call was hungup */
- struct call_queue *lastqueue; /*!< Last queue we received a call */
- unsigned int realtime:1; /*!< Is this member realtime? */
- unsigned int paused:1; /*!< Are we paused (not accepting calls)? */
- unsigned int dead:1; /*!< Used to detect members deleted in realtime */
- unsigned int dynamic:1; /*!< Are we dynamically added? */
- unsigned int ignorebusy:1; /*!< Flag to ignore member if the status is not available */
- char rt_uniqueid[80]; /*!< Unique id of realtime member entry */
- struct mem_state *device; /*!< Device information */
+ AST_DECLARE_STRING_FIELDS(
+ AST_STRING_FIELD(interface); /*!< Technology/Location to dial to reach this member*/
+ AST_STRING_FIELD(membername); /*!< Member name to use in queue logs */
+ AST_STRING_FIELD(rt_uniqueid); /*!< Unique id of realtime member entry */
+ );
+ int penalty; /*!< Are we a last resort? */
+ int calls; /*!< Number of calls serviced by this member */
+ struct timeval lastcall; /*!< When last successful call was hungup */
+ int lastwrapup; /*!< Last wrapuptime */
+ unsigned int dynamic:1; /*!< Is this member dynamic? */
+ unsigned int realtime:1; /*!< Is this member realtime? */
+ unsigned int paused:1; /*!< Are we paused (not accepting calls)? */
+ unsigned int dead:1; /*!< Used to detect members deleted in realtime */
+ unsigned int callinuse:1; /*!< Are we dynamically added? */
+ struct mem_state *device; /*!< Device information */
};
enum empty_conditions {
@@ -1165,7 +1182,6 @@
unsigned int setqueuevar:1;
unsigned int setqueueentryvar:1;
unsigned int reportholdtime:1;
- unsigned int wrapped:1;
unsigned int timeoutrestart:1;
unsigned int announceholdtime:2;
unsigned int announceposition:3;
@@ -1185,49 +1201,50 @@
int numperiodicannounce; /*!< The number of periodic announcements configured */
int randomperiodicannounce; /*!< Are periodic announcments randomly chosen */
int roundingseconds; /*!< How many seconds do we round to? */
- int holdtime; /*!< Current avg holdtime, based on an exponential average */
- int talktime; /*!< Current avg talktime, based on the same exponential average */
- int callscompleted; /*!< Number of queue calls completed */
- int callsabandoned; /*!< Number of queue calls abandoned */
int servicelevel; /*!< seconds setting for servicelevel*/
- int callscompletedinsl; /*!< Number of calls answered with servicelevel*/
char monfmt[8]; /*!< Format to use when recording calls */
int montype; /*!< Monitor type Monitor vs. MixMonitor */
- int count; /*!< How many entries */
int maxlen; /*!< Max number of entries */
int wrapuptime; /*!< Wrapup Time */
int penaltymemberslimit; /*!< Disregard penalty when queue has fewer than this many members */
-
int retry; /*!< Retry calling everyone after this amount of time */
int timeout; /*!< How long to wait for an answer */
int weight; /*!< Respective weight */
int autopause; /*!< Auto pause queue members if they fail to answer */
int autopausedelay; /*!< Delay auto pause for autopausedelay seconds since last call */
int timeoutpriority; /*!< Do we allow a fraction of the timeout to occur for a ring? */
-
/* Queue strategy things */
- int rrpos; /*!< Round Robin - position */
int memberdelay; /*!< Seconds to delay connecting member to caller */
int autofill; /*!< Ignore the head call status and ring an available agent */
-
- struct ao2_container *members; /*!< Head of the list of members */
- struct queue_ent *head; /*!< Head of the list of callers */
- AST_LIST_ENTRY(call_queue) list; /*!< Next call queue */
- AST_LIST_HEAD_NOLOCK(, penalty_rule) rules; /*!< The list of penalty rules to invoke */
+ struct timeval reload; /*!< Time the queue will be reloaded from RT */
+ struct queue_data *data; /*!< Queue statistics */
+};
+
+struct queue_data {
+ int qhash; /*!< Hash for queue */
+ unsigned int wrapped:1;
+ int count; /*!< How many entries */
+ int holdtime; /*!< Current avg holdtime, based on an exponential average */
+ int talktime; /*!< Current avg talktime, based on the same exponential average */
+ int callscompleted; /*!< Number of queue calls completed */
+ int callsabandoned; /*!< Number of queue calls abandoned */
+ int callscompletedinsl; /*!< Number of calls answered with servicelevel*/
+ int rrpos; /*!< Round Robin - position */
+ AST_LIST_HEAD(, queue_ent) *head; /*!< Head of the list of callers */
+ struct ao2_container *members; /*!< Head of the list of members */
};
struct rule_list {
char name[80];
- AST_LIST_HEAD_NOLOCK(,penalty_rule) rules;
- AST_LIST_ENTRY(rule_list) list;
+ struct ao2_container *rules;
};
-
-static AST_LIST_HEAD_STATIC(rule_lists, rule_list);
static struct ao2_container *queues;
static struct ao2_container *devices;
-
-static void dump_queue_members(struct call_queue *pm_queue);
+static struct ao2_container *rules;
+static struct ao2_container *qdata;
+
+static int do_set_member_penalty_paused(struct call_queue *q, struct member *mem, int pause, int value, const char *reason);
static void pm_load_member_config(struct call_queue *q);
static char *queue_refshow(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
static struct member *interface_exists(struct call_queue *q, const char *interface);
@@ -1235,7 +1252,6 @@
static void queue_transfer_fixup(void *data, struct ast_channel *old_chan, struct ast_channel *new_chan);
-static struct member *find_member_by_queuename_and_interface(const char *queuename, const char *interface);
/*! \brief sets the QUEUESTATUS channel variable */
static void set_queue_result(struct ast_channel *chan, enum queue_result res)
{
@@ -1249,6 +1265,7 @@
}
}
+/*! \brief return strategy name from strategy*/
static const char *int2strat(int strategy)
{
int x;
@@ -1261,6 +1278,7 @@
return "<unknown>";
}
+/*! brief return strategy from strategy name*/
static int strat2int(const char *strategy)
{
int x;
@@ -1273,6 +1291,7 @@
return -1;
}
+/*! brief return a autopause setting from name*/
static int autopause2int(const char *autopause)
{
int x;
@@ -1293,111 +1312,125 @@
return QUEUE_AUTOPAUSE_OFF;
}
+/*!
+ * \brief ao2 callback to calculate hash of a queue by name
+ */
static int queue_hash_cb(const void *obj, const int flags)
{
const struct call_queue *q = obj;
-
- return ast_str_case_hash(q->name);
-}
-
+ const char *name = q->name;
+
+ return ast_str_case_hash(name);
+}
+
+
+/*!
+ * \brief ao2 callback to find queue by name
+ * \note this is the default function used by ao2_find
+ */
static int queue_cmp_cb(void *obj, void *arg, int flags)
{
- const struct call_queue *q = obj;
- const struct call_queue *q2 = arg;
+ const struct call_queue *q = obj, *q2 = arg;
const char *name = (flags & OBJ_POINTER) ? q2->name : arg;
return !strcasecmp(q->name, name) ? CMP_MATCH | CMP_STOP : 0;
}
-static int device_hash_cb(const void *obj, const int flags)
-{
- const struct mem_state *d = obj;
-
- return ast_str_case_hash(d->state_interface);
-}
-
-static int device_cmp_cb(void *obj, void *arg, int flags)
-{
- const struct mem_state *d = obj;
- const struct mem_state *d2 = arg;
- const char *iface = (flags & OBJ_POINTER) ? d2->state_interface : arg;
-
- return !strcasecmp(d->state_interface, iface) ? CMP_MATCH | CMP_STOP : 0;
-}
-
-#ifdef REF_DEBUG_ONLY_QUEUES
-#define queue_ref(a) __ao2_ref_debug(a,1,"",__FILE__,__LINE__,__PRETTY_FUNCTION__)
-#define queue_unref(a) __ao2_ref_debug(a,-1,"",__FILE__,__LINE__,__PRETTY_FUNCTION__)
-#define queue_t_ref(a,b) __ao2_ref_debug(a,1,b,__FILE__,__LINE__,__PRETTY_FUNCTION__)
-#define queue_t_unref(a,b) __ao2_ref_debug(a,-1,b,__FILE__,__LINE__,__PRETTY_FUNCTION__)
-#define queues_t_link(c,q,tag) __ao2_link_debug(c,q,tag,__FILE__,__LINE__,__PRETTY_FUNCTION__)
-#define queues_t_unlink(c,q,tag) __ao2_unlink_debug(c,q,tag,__FILE__,__LINE__,__PRETTY_FUNCTION__)
-#else
-#define queue_t_ref(a,b) queue_ref(a)
-#define queue_t_unref(a,b) queue_unref(a)
-#define queues_t_link(c,q,tag) ao2_t_link(c,q,tag)
-#define queues_t_unlink(c,q,tag) ao2_t_unlink(c,q,tag)
-static inline struct call_queue *queue_ref(struct call_queue *q)
-{
- ao2_ref(q, 1);
- return q;
-}
-
-static inline struct call_queue *queue_unref(struct call_queue *q)
-{
- ao2_ref(q, -1);
- return NULL;
-}
-#endif
-
-/*! \brief Set variables of queue */
+/*!
+ * \brief ao2 callback to calculate hash of a queue by name
+ */
+static int qdata_hash_cb(const void *obj, const int flags)
+{
+ const struct queue_data *d = obj;
+ int qhash = d->qhash;
+
+ return qhash;
+}
+
+
+/*!
+ * \brief ao2 callback to find queue by name
+ * \note this is the default function used by ao2_find
+ */
+static int qdata_cmp_cb(void *obj, void *arg, int flags)
+{
+ const struct queue_data *d = obj, *d2 = arg;
+ const char *name = arg;
+ int qhash = (flags & OBJ_POINTER) ? d2->qhash : ast_str_case_hash(name);
+
+ return (d->qhash == qhash) ? CMP_MATCH | CMP_STOP : 0;
+}
+
+/*! \brief Set channel variables of queue */
static void set_queue_variables(struct call_queue *q, struct ast_channel *chan)
{
char interfacevar[256]="";
float sl = 0;
-
- ao2_lock(q);
+ struct queue_data *data = q->data;
if (q->setqueuevar) {
sl = 0;
- if (q->callscompleted > 0)
- sl = 100 * ((float) q->callscompletedinsl / (float) q->callscompleted);
+ ao2_lock(data);
+ if (data->callscompleted > 0) {
+ sl = 100 * ((float) data->callscompletedinsl / (float) data->callscompleted);
+ }
snprintf(interfacevar, sizeof(interfacevar),
"QUEUENAME=%s,QUEUEMAX=%d,QUEUESTRATEGY=%s,QUEUECALLS=%d,QUEUEHOLDTIME=%d,QUEUETALKTIME=%d,QUEUECOMPLETED=%d,QUEUEABANDONED=%d,QUEUESRVLEVEL=%d,QUEUESRVLEVELPERF=%2.1f",
- q->name, q->maxlen, int2strat(q->strategy), q->count, q->holdtime, q->talktime, q->callscompleted, q->callsabandoned, q->servicelevel, sl);
-
- ao2_unlock(q);
-
- pbx_builtin_setvar_multiple(chan, interfacevar);
- } else {
- ao2_unlock(q);
- }
-}
-
-/*! \brief Insert the 'new' entry after the 'prev' entry of queue 'q' */
-static inline void insert_entry(struct call_queue *q, struct queue_ent *prev, struct queue_ent *new, int *pos)
-{
- struct queue_ent *cur;
-
- if (!q || !new)
- return;
- if (prev) {
- cur = prev->next;
- prev->next = new;
- } else {
- cur = q->head;
- q->head = new;
- }
- new->next = cur;
-
- /* every queue_ent must have a reference to it's parent call_queue, this
- * reference does not go away until the end of the queue_ent's life, meaning
- * that even when the queue_ent leaves the call_queue this ref must remain. */
- queue_ref(q);
- new->parent = q;
+ q->name, q->maxlen, int2strat(q->strategy), data->count, data->holdtime, data->talktime,
+ data->callscompleted, data->callsabandoned, q->servicelevel, sl);
+
+ pbx_builtin_setvar_multiple(chan, interfacevar);
+ ao2_unlock(data);
+ }
+}
+
+/*! \brief Insert the 'new' callattempt entry after the 'prev' entry of queue 'q' */
+static inline void insert_entry(struct queue_ent *new, int *pos)
+{
new->pos = ++(*pos);
new->opos = *pos;
+ ao2_lock(new->parent->data);
+ new->parent->data->count++;
+ ao2_unlock(new->parent->data);
+}
+
+/*! \brief return the device state for a member*/
+static int get_device_status(struct member *m)
+{
+ int ret;
+ struct mem_state *s = m->device;
+
+ ao2_lock(s);
+
+ ret = s->status;
+ switch (s->status) {
+ case AST_DEVICE_INVALID:
+ case AST_DEVICE_UNAVAILABLE:
+ case AST_DEVICE_BUSY:
+ break;
+ case AST_DEVICE_INUSE:
+ case AST_DEVICE_RINGING:
+ case AST_DEVICE_RINGINUSE:
+ case AST_DEVICE_ONHOLD:
+ /* if im active and may not place calls when INUSE im actually BUSY */
+ if ((s->reserved || s->active) && !m->callinuse) {
+ ret = AST_DEVICE_BUSY;
+ break;
+ }
+ break;
+ case AST_DEVICE_NOT_INUSE:
+ case AST_DEVICE_UNKNOWN:
+ /* it seems that i have this device active but the system does not */
+ if (s->active) {
+ ret = (m->callinuse) ? AST_DEVICE_INUSE : AST_DEVICE_BUSY;
+ } else if (s->reserved) {
+ ret = (m->callinuse) ? AST_DEVICE_RINGING : AST_DEVICE_BUSY;
+ }
+ }
+ ao2_unlock(s);
+
+ return ret;
}
/*! \brief Check if members are available
@@ -1405,26 +1438,35 @@
* This function checks to see if members are available to be called. If any member
* is available, the function immediately returns 0. If no members are available,
* then -1 is returned.
- *
- * It must be called with ref and lock held for q
- *
*/
-static int get_member_status(struct call_queue *q, int max_penalty, int min_penalty, enum empty_conditions conditions)
+static int get_member_status(const struct queue_ent *qe, int join)
{
struct member *member;
struct ao2_iterator mem_iter;
-
- mem_iter = ao2_iterator_init(q->members, 0);
+ struct call_queue *q = qe->parent;
+ int max_penalty = qe->max_penalty;
+ int min_penalty = qe->min_penalty;
+ enum empty_conditions conditions;
+
+ conditions = (join) ? q->joinempty : q->leavewhenempty;
+
+ if (!conditions) {
+ return 0;
+ }
+
+ mem_iter = ao2_iterator_init(q->data->members, 0);
while((member = ao2_iterator_next(&mem_iter))) {
+ ao2_lock(member);
if ((max_penalty && (member->penalty > max_penalty)) || (min_penalty && (member->penalty < min_penalty))) {
if (conditions & QUEUE_EMPTY_PENALTY) {
ast_debug(4, "%s is unavailable because his penalty is not between %d and %d\n", member->membername, min_penalty, max_penalty);
+ ao2_unlock(member);
+ ao2_ref(member, -1);
continue;
}
}
- ao2_lock(member->device);
- switch (member->device->status) {
+ switch (get_device_status(member)) {
case AST_DEVICE_INVALID:
if (conditions & QUEUE_EMPTY_INVALID) {
ast_debug(4, "%s is unavailable because his device state is 'invalid'\n", member->membername);
@@ -1438,6 +1480,7 @@
}
goto default_case;
case AST_DEVICE_INUSE:
+ case AST_DEVICE_BUSY:
if (conditions & QUEUE_EMPTY_INUSE) {
ast_debug(4, "%s is unavailable because his device state is 'inuse'\n", member->membername);
break;
@@ -1460,27 +1503,41 @@
if (member->paused && (conditions & QUEUE_EMPTY_PAUSED)) {
ast_debug(4, "%s is unavailable because he is paused'\n", member->membername);
break;
- } else if ((conditions & QUEUE_EMPTY_WRAPUP) && member->lastcall && q->wrapuptime && (time(NULL) - q->wrapuptime < member->lastcall)) {
- ast_debug(4, "%s is unavailable because it has only been %d seconds since his last call (wrapup time is %d)\n", member->membername, (int) (time(NULL) - member->lastcall), q->wrapuptime);
+ } else if ((conditions & QUEUE_EMPTY_WRAPUP) && !ast_tvzero(member->lastcall) && member->lastwrapup && (ast_tvdiff_sec(ast_tvnow(), member->lastcall) <= member->lastwrapup)) {
+ ast_debug(4, "%s is unavailable because it has only been %d seconds since his last call (wrapup time is %d)\n", member->membername, (int)ast_tvdiff_sec(ast_tvnow(), member->lastcall), member->lastwrapup);
break;
} else {
- ao2_unlock(member->device);
ast_debug(4, "%s is available.\n", member->membername);
+ ao2_unlock(member);
ao2_ref(member, -1);
ao2_iterator_destroy(&mem_iter);
return 0;
}
break;
}
- ao2_unlock(member->device);
+ ao2_unlock(member);
ao2_ref(member, -1);
}
ao2_iterator_destroy(&mem_iter);
return -1;
}
-/*! \brief send a QueueMemberStatus manager_event
-*/
+/*! \brief Un ref a device if im the last consumer unlink it*/
+static void unref_device(struct mem_state *s) {
+ if (!s) {
+ return;
+ }
+
+ ao2_lock(devices);
+ /* remove our ref*/
+ if (ao2_ref(s, -1) == 2) {
+ /* we were the only consumer unlink*/
+ ao2_find(devices, s, OBJ_UNLINK | OBJ_POINTER | OBJ_NODATA);
+ }
+ ao2_unlock(devices);
+}
+
+/*! \brief send a QueueMemberStatus manager_event when device state changes*/
static int update_status(void *data)
{
struct ao2_iterator qiter;
@@ -1491,21 +1548,19 @@
qiter = ao2_iterator_init(queues, 0);
while ((q = ao2_iterator_next(&qiter))) {
- ao2_lock(q);
if (q->maskmemberstatus) {
- ao2_unlock(q);
ao2_ref(q, -1);
continue;
}
- miter = ao2_iterator_init(q->members, 0);
+ miter = ao2_iterator_init(q->data->members, 0);
while((m = ao2_iterator_next(&miter))) {
- ao2_lock(m->device);
- if (strcasecmp(m->device->state_interface, s->state_interface)) {
- ao2_unlock(m->device);
+ ao2_lock(m);
+ if (m->device != s) {
+ ao2_unlock(m);
ao2_ref(m, -1);
continue;
}
- ao2_unlock(m->device);
+ ao2_lock(s);
manager_event(EVENT_FLAG_AGENT, "QueueMemberStatus",
"Queue: %s\r\n"
"Location: %s\r\n"
@@ -1516,18 +1571,47 @@
"CallsTaken: %d\r\n"
"LastCall: %d\r\n"
"Status: %d\r\n"
- "Paused: %d\r\n",
+ "Paused: %d\r\n"
+ "CallInuse: %d\r\n",
q->name, m->interface, m->membername, s->state_interface, m->dynamic ? "dynamic" : m->realtime ? "realtime" : "static",
- m->penalty, m->calls, (int)m->lastcall, s->status, m->paused
+ m->penalty, m->calls, (int)m->lastcall.tv_sec, s->status, m->paused, m->callinuse
);
+ ao2_unlock(s);
+ ao2_unlock(m);
ao2_ref(m, -1);
}
ao2_iterator_destroy(&miter);
- ao2_unlock(q);
ao2_ref(q, -1);
}
ao2_iterator_destroy(&qiter);
- ao2_ref(s, -1);
+
+ unref_device(s);
+
+ return 0;
+}
+
+/*! \brief set the device state of a member explicitly
+ * \note a change update manager event will be sent
+ */
+static int set_device_status(const char *device, int status)
+{
+ struct mem_state *s;
+
+ if (!(s = ao2_find(devices, (char *)device, 0))) {
+ return -1;
+ }
+
+ ao2_lock(s);
+ if (s->status != status) {
+ s->status = status;
+ ao2_unlock(s);
+ if (ast_taskprocessor_push(devicestate_tps, update_status, s)) {
+ unref_device(s);
+ }
+ } else {
+ ao2_unlock(s);
+ unref_device(s);
+ }
return 0;
}
@@ -1537,7 +1621,6 @@
{
enum ast_device_state state;
const char *device;
- struct mem_state *s, *tmp;
state = ast_event_get_ie_uint(event, AST_EVENT_IE_STATE);
device = ast_event_get_ie_str(event, AST_EVENT_IE_DEVICE);
@@ -1547,19 +1630,7 @@
return;
}
- if ((s = ao2_find(devices, (char *)device, 0))) {
- ao2_lock(s);
- if (s->status != state) {
- s->status = state;
- if ((tmp = ao2_alloc(sizeof(*tmp), NULL))) {
- memcpy(tmp, s, sizeof(*tmp));
- if (ast_taskprocessor_push(devicestate_tps, update_status, tmp)) {
- ao2_ref(tmp, -1);
- }
- }
- }
- ao2_unlock(s);
- ao2_ref(s, -1);
+ if (set_device_status(device, state)) {
ast_debug(1, "Device '%s' changed to state '%d' (%s)\n", device, state, ast_devstate2str(state));
} else {
ast_debug(3, "Device '%s' changed to state '%d' (%s) but we don't care because they're not a member of any queue.\n", device, state, ast_devstate2str(state));
@@ -1598,9 +1669,9 @@
return state;
}
+/*! \brief callback called when a extension hint is notified of change*/
static int extension_state_cb(char *context, char *exten, enum ast_extension_states state, void *data)
{
- struct mem_state *s, *tmp;
char *device;
int status = extensionstate2devicestate(state);
@@ -1609,19 +1680,7 @@
return 0;
}
- if ((s = ao2_find(devices, device, 0))) {
- ao2_lock(s);
- if (s->status != status) {
- s->status = status;
- if ((tmp = ao2_alloc(sizeof(*tmp), NULL))) {
- memcpy(tmp, s, sizeof(*tmp));
- if (ast_taskprocessor_push(devicestate_tps, update_status, tmp)) {
- ao2_ref(tmp, -1);
- }
- }
- }
- ao2_unlock(s);
- ao2_ref(s, -1);
+ if (set_device_status(device, status)) {
ast_debug(1, "Extension '%s@%s' changed to state '%d' (%s)\n", exten, context, status, ast_devstate2str(status));
} else {
ast_debug(3, "Extension '%s@%s' changed state but we don't care because they're not a member of any queue.\n",
@@ -1631,21 +1690,7 @@
return 0;
}
-static void remove_queue_member(void *data) {
- struct member *mem = data;
- struct mem_state *s = mem->device;
-
- if (s) {
- /* we have a device lets unlink and unref it*/
- /* remove our ref*/
- if (ao2_ref(s, -1) == 2) {
- /* we were the only consumer unlink*/
- ao2_unlink(devices, s);
- }
- }
-
-}
-
+/* \brief find or create a member device state object*/
static struct mem_state *create_member_state(const char *state_interface) {
struct mem_state *state;
char *exten;
@@ -1666,7 +1711,11 @@
if (context) {
ast_copy_string(state->state_interface, state_interface, sizeof(state->state_interface));
} else {
- asprintf(&device, "%s at default", state_interface);
+ if (!asprintf(&device, "%s at default", state_interface)) {
+ ast_log(AST_LOG_ERROR, "Failed to use state_interface %s at default\n", state_interface);
+ ao2_ref(state, -1);
+ return NULL;
+ }
ast_copy_string(state->state_interface, device, sizeof(state->state_interface));
}
state->status = extensionstate2devicestate(ast_extension_state(NULL, S_OR(context, "default"), exten));
@@ -1679,14 +1728,15 @@
return state;
}
-/*! \brief Set current state of member if needed*/
-static void set_queue_member_status(struct member *m)
+/*! \brief Set current state of member querying channel driver or hint state*/
+static int set_queue_member_status(struct member *m)
{
int status;
- struct mem_state *s = m->device;
- struct mem_state *tmp;
-
- ao2_lock(s);
+ struct mem_state *s;
+
+ ao2_lock(m);
+ s = m->device;
+
if (!strncasecmp(s->state_interface, "hint:", 5)) {
char *context = ast_strdupa(s->state_interface);
char *exten = strsep(&context, "@") + 5;
@@ -1695,80 +1745,35 @@
status = ast_device_state(s->state_interface);
}
+ ao2_lock(s);
if (s->status != status) {
s->status = status;
- if ((tmp = ao2_alloc(sizeof(*tmp), NULL))) {
- memcpy(tmp, s, sizeof(*tmp));
- if (ast_taskprocessor_push(devicestate_tps, update_status, tmp)) {
- ao2_ref(tmp, -1);
- }
+ /* we must pass a ref to the task processor*/
+ if (!ast_taskprocessor_push(devicestate_tps, update_status, s)) {
+ ao2_ref(s, 1);
}
}
ao2_unlock(s);
-}
-
-/*! \brief allocate space for new queue member and set fields based on parameters passed */
-static struct member *create_queue_member(const char *interface, const char *membername, int penalty,
- int paused, const char *state_interface, int ignorebusy)
-{
- struct member *cur;
- const char* state_int;
-
- if (!(cur = ao2_alloc(sizeof(*cur), remove_queue_member))) {
- return NULL;
- }
-
- /* setup device state*/
- state_int = (!ast_strlen_zero(state_interface)) ? state_interface : interface;
- if (!(cur->device = create_member_state(state_int))) {
- ao2_ref(cur, -1);
- return NULL;
- }
-
- cur->penalty = penalty;
- cur->paused = paused;
- cur->ignorebusy = ignorebusy;
- ast_copy_string(cur->interface, interface, sizeof(cur->interface));
- if (!ast_strlen_zero(membername)) {
- ast_copy_string(cur->membername, membername, sizeof(cur->membername));
- } else {
- ast_copy_string(cur->membername, interface, sizeof(cur->membername));
- }
- if (!strchr(cur->interface, '/')) {
- ast_log(LOG_WARNING, "No location at interface '%s'\n", interface);
- }
-
-
- return cur;
-}
-
-
-static int compress_char(const char c)
-{
- if (c < 32)
- return 0;
- else if (c > 96)
- return c - 64;
- else
- return c - 32;
-}
-
+ ao2_unlock(m);
+
+ return status;
+}
+
+/*!
+ * \brief ao2 callback to calculate hash of a member by interface
+ */
static int member_hash_fn(const void *obj, const int flags)
{
const struct member *mem = obj;
const char *interface = mem->interface;
- const char *chname = strchr(interface, '/');
- int ret = 0, i;
-
- if (!chname) {
- chname = interface;
- }
- for (i = 0; i < 5 && chname[i]; i++) {
- ret += compress_char(chname[i]) << (i * 6);
- }
- return ret;
-}
-
+
+ return ast_str_case_hash(interface);
+}
+
+/*!
+ * \brief ao2 callback to find member by interface
+ * \note this is the default function used by ao2_find
+ */
static int member_cmp_fn(void *obj1, void *obj2, int flags)
{
const struct member *mem1 = obj1;
@@ -1778,23 +1783,189 @@
return strcasecmp(mem1->interface, arg) ? 0 : CMP_MATCH | CMP_STOP;
}
+/*!
+ * \brief ao2 callback to find a realtime member by uniqueid
+ */
static int member_cmp_uniqueid_fn(void *obj1, void *arg, int flags)
{
const struct member *mem1 = obj1;
const struct member *mem2 = arg;
const char *uniqueid = (flags & OBJ_POINTER) ? mem2->rt_uniqueid : arg;
- return strcasecmp(mem1->rt_uniqueid, uniqueid) ? 0 : CMP_MATCH | CMP_STOP;
+ if (mem1->realtime && !mem1->dead &&
+ !strcasecmp(mem1->rt_uniqueid, uniqueid)) {
+ return CMP_MATCH | CMP_STOP;
+ }
+
+ return 0;
+}
+
+/*!
+ * \brief ao2 callback to mark realtime members dead
+ */
+static int mark_realtime_member_dead(void *obj, void *arg, int flags)
+{
+ struct member *member = obj;
+
+ if (member->realtime) {
+ member->dead = 1;
+ return CMP_MATCH;
+ }
+ return 0;
+}
+
+/*!
+ * \brief ao2 callback to delete realtime members marked dead
+ */
+static int kill_realtime_dead_members(void *obj, void *arg, void *data, int flags)
+{
+ struct member *m = obj;
+ const struct call_queue *q = data;
+
+ if (m->realtime && m->dead) {
+ ao2_lock(m);
+ if (ast_strlen_zero(m->membername) || !log_membername_as_agent) {
+ ast_queue_log(q->name, "REALTIME", m->interface, "REMOVEMEMBER", "%s", "");
+ } else {
+ ast_queue_log(q->name, "REALTIME", m->membername, "REMOVEMEMBER", "%s", "");
+ }
+ ao2_unlock(m);
+ return CMP_MATCH;
+ }
+ return 0;
+}
+
+/*! \brief ao2 callback to reset member counters */
+static int clear_queue_member_fn(void *obj1, void *arg, int flags)
+{
+ struct member *mem = obj1;
+
+ ao2_lock(mem);
+ mem->calls = 0;
+ mem->lastwrapup = 0;
+ mem->lastcall = ast_tv(0, 0);
+ ao2_unlock(mem);
+
+ return 0;
+}
+
+/*!
+ * \brief ao2 callback to calculate hash of a device by state_interface
+ */
+static int device_hash_cb(const void *obj, const int flags)
+{
+ const struct mem_state *s = obj;
+ const char *state_interface = s->state_interface;
+
+ return ast_str_case_hash(state_interface);
+}
+
+/*!
+ * \brief ao2 callback to find device by state_interface
+ * \note this is the default function used by ao2_find
+ */
+static int device_cmp_cb(void *obj, void *arg, int flags)
+{
+ const struct mem_state *d = obj;
+ const struct mem_state *d2 = arg;
+ const char *iface = (flags & OBJ_POINTER) ? d2->state_interface : arg;
+
+ return !strcasecmp(d->state_interface, iface) ? CMP_MATCH | CMP_STOP : 0;
+}
+
+/*!
+ * \brief ao2 callback to calculate hash of a rule by name
+ */
+static int rules_hash_cb(const void *obj, const int flags)
+{
+ const struct rule_list *rl = obj;
+ const char *name = rl->name;
+
+ return ast_str_case_hash(name);
+}
+
+/*!
+ * \brief ao2 callback to calculate hash of a penalty rule by time
+ */
+static int penalty_hash_cb(const void *obj, const int flags)
+{
+ const struct penalty_rule *pr = obj;
+ int time = pr->time;
+
+ return time;
+}
+
+/*! \brief find the best penalty rule for duration */
+static int get_best_rule_cb(void *obj, void *arg, void *data, int flags)
+{
+ int *time = arg;
+ struct penalty_rule *cur = obj;
+ struct penalty_rule **din = data, *best = *din;
+
+ if ((cur->time >= *time) && (!best || (best && (cur->time < best->time)))) {
+ if (best) {
+ ao2_ref(best, -1);
+ }
+ ao2_ref(cur, 1);
+ *din = cur;
+ return CMP_MATCH;
+ }
+ return 0;
+}
+
+/*!
+ * \brief ao2 callback to find rule by name
+ * \note this is the default function used by ao2_find
+ */
+static int rules_cmp_cb(void *obj, void *arg, int flags)
+{
+ const struct rule_list *rl = obj;
+ const struct rule_list *rl2 = arg;
+ const char *name = (flags & OBJ_POINTER) ? rl2->name : arg;
+
+ return !strcasecmp(rl->name, name) ? CMP_MATCH | CMP_STOP : 0;
+}
+
+/*!
+ * \brief ao2 callback to calculate hash of a callattempt by member interface
+ */
+static int callattempt_hash_fn(const void *obj, const int flags)
+{
+ const struct callattempt *c = obj;
[... 7000 lines stripped ...]
More information about the svn-commits
mailing list