2013-05-08 13:39:08 +00:00
|
|
|
/*
|
|
|
|
* Asterisk -- An open source telephony toolkit.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2013, Digium, Inc.
|
|
|
|
*
|
|
|
|
* David M. Lee, II <dlee@digium.com>
|
|
|
|
*
|
|
|
|
* See http://www.asterisk.org for more information about
|
|
|
|
* the Asterisk project. Please do not directly contact
|
|
|
|
* any of the maintainers of this project for assistance;
|
|
|
|
* the project provides a web site, mailing lists and IRC
|
|
|
|
* channels for your use.
|
|
|
|
*
|
|
|
|
* This program is free software, distributed under the terms of
|
|
|
|
* the GNU General Public License Version 2. See the LICENSE file
|
|
|
|
* at the top of the source tree.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*! \file
|
|
|
|
*
|
|
|
|
* \brief Asterisk endpoint API.
|
|
|
|
*
|
|
|
|
* \author David M. Lee, II <dlee@digium.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*** MODULEINFO
|
|
|
|
<support_level>core</support_level>
|
|
|
|
***/
|
|
|
|
|
|
|
|
#include "asterisk.h"
|
|
|
|
|
|
|
|
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
|
|
|
|
|
|
|
|
#include "asterisk/astobj2.h"
|
|
|
|
#include "asterisk/endpoints.h"
|
|
|
|
#include "asterisk/stasis.h"
|
|
|
|
#include "asterisk/stasis_channels.h"
|
|
|
|
#include "asterisk/stasis_endpoints.h"
|
|
|
|
#include "asterisk/stasis_message_router.h"
|
|
|
|
#include "asterisk/stringfields.h"
|
2013-10-04 16:01:48 +00:00
|
|
|
#include "asterisk/_private.h"
|
2013-05-08 13:39:08 +00:00
|
|
|
|
|
|
|
/*! Buckets for endpoint->channel mappings. Keep it prime! */
|
2013-10-04 16:01:48 +00:00
|
|
|
#define ENDPOINT_CHANNEL_BUCKETS 127
|
|
|
|
|
|
|
|
/*! Buckets for endpoint hash. Keep it prime! */
|
2013-05-08 13:39:08 +00:00
|
|
|
#define ENDPOINT_BUCKETS 127
|
|
|
|
|
2013-10-04 16:01:48 +00:00
|
|
|
static struct ao2_container *endpoints;
|
|
|
|
|
2013-05-08 13:39:08 +00:00
|
|
|
struct ast_endpoint {
|
|
|
|
AST_DECLARE_STRING_FIELDS(
|
|
|
|
AST_STRING_FIELD(tech); /*!< Technology (SIP, IAX2, etc.). */
|
|
|
|
AST_STRING_FIELD(resource); /*!< Name, unique to the tech. */
|
|
|
|
AST_STRING_FIELD(id); /*!< tech/resource id */
|
|
|
|
);
|
|
|
|
/*! Endpoint's current state */
|
|
|
|
enum ast_endpoint_state state;
|
|
|
|
/*!
|
|
|
|
* \brief Max channels for this endpoint. -1 means unlimited or unknown.
|
|
|
|
*
|
|
|
|
* Note that this simply documents the limits of an endpoint, and does
|
|
|
|
* nothing to try to enforce the limit.
|
|
|
|
*/
|
|
|
|
int max_channels;
|
|
|
|
/*! Topic for this endpoint's messages */
|
2013-08-01 13:49:34 +00:00
|
|
|
struct stasis_cp_single *topics;
|
2013-05-08 13:39:08 +00:00
|
|
|
/*! Router for handling this endpoint's messages */
|
|
|
|
struct stasis_message_router *router;
|
|
|
|
/*! ast_str_container of channels associated with this endpoint */
|
|
|
|
struct ao2_container *channel_ids;
|
|
|
|
};
|
|
|
|
|
2013-10-04 16:01:48 +00:00
|
|
|
static int endpoint_hash(const void *obj, int flags)
|
|
|
|
{
|
|
|
|
const struct ast_endpoint *endpoint;
|
|
|
|
const char *key;
|
|
|
|
|
|
|
|
switch (flags & OBJ_SEARCH_MASK) {
|
|
|
|
case OBJ_SEARCH_KEY:
|
|
|
|
key = obj;
|
|
|
|
return ast_str_hash(key);
|
|
|
|
case OBJ_SEARCH_OBJECT:
|
|
|
|
endpoint = obj;
|
|
|
|
return ast_str_hash(endpoint->id);
|
|
|
|
default:
|
|
|
|
/* Hash can only work on something with a full key. */
|
|
|
|
ast_assert(0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int endpoint_cmp(void *obj, void *arg, int flags)
|
|
|
|
{
|
|
|
|
const struct ast_endpoint *left = obj;
|
|
|
|
const struct ast_endpoint *right = arg;
|
|
|
|
const char *right_key = arg;
|
|
|
|
int cmp;
|
|
|
|
|
|
|
|
switch (flags & OBJ_SEARCH_MASK) {
|
|
|
|
case OBJ_SEARCH_OBJECT:
|
|
|
|
right_key = right->id;
|
|
|
|
/* Fall through */
|
|
|
|
case OBJ_SEARCH_KEY:
|
|
|
|
cmp = strcmp(left->id, right_key);
|
|
|
|
break;
|
|
|
|
case OBJ_SEARCH_PARTIAL_KEY:
|
|
|
|
cmp = strncmp(left->id, right_key, strlen(right_key));
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ast_assert(0);
|
|
|
|
cmp = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (cmp) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return CMP_MATCH;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct ast_endpoint *ast_endpoint_find_by_id(const char *id)
|
|
|
|
{
|
|
|
|
return ao2_find(endpoints, id, OBJ_KEY);
|
|
|
|
}
|
|
|
|
|
2013-08-01 13:49:34 +00:00
|
|
|
struct stasis_topic *ast_endpoint_topic(struct ast_endpoint *endpoint)
|
|
|
|
{
|
|
|
|
if (!endpoint) {
|
|
|
|
return ast_endpoint_topic_all();
|
|
|
|
}
|
|
|
|
return stasis_cp_single_topic(endpoint->topics);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct stasis_topic *ast_endpoint_topic_cached(struct ast_endpoint *endpoint)
|
|
|
|
{
|
|
|
|
if (!endpoint) {
|
|
|
|
return ast_endpoint_topic_all_cached();
|
|
|
|
}
|
|
|
|
return stasis_cp_single_topic_cached(endpoint->topics);
|
|
|
|
}
|
|
|
|
|
2013-05-08 13:39:08 +00:00
|
|
|
const char *ast_endpoint_state_to_string(enum ast_endpoint_state state)
|
|
|
|
{
|
|
|
|
switch (state) {
|
|
|
|
case AST_ENDPOINT_UNKNOWN:
|
|
|
|
return "unknown";
|
|
|
|
case AST_ENDPOINT_OFFLINE:
|
|
|
|
return "offline";
|
|
|
|
case AST_ENDPOINT_ONLINE:
|
|
|
|
return "online";
|
|
|
|
}
|
|
|
|
return "?";
|
|
|
|
}
|
|
|
|
|
|
|
|
static void endpoint_publish_snapshot(struct ast_endpoint *endpoint)
|
|
|
|
{
|
|
|
|
RAII_VAR(struct ast_endpoint_snapshot *, snapshot, NULL, ao2_cleanup);
|
|
|
|
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
|
|
|
|
|
|
|
|
ast_assert(endpoint != NULL);
|
2013-08-01 13:49:34 +00:00
|
|
|
ast_assert(endpoint->topics != NULL);
|
2013-05-08 13:39:08 +00:00
|
|
|
|
|
|
|
snapshot = ast_endpoint_snapshot_create(endpoint);
|
|
|
|
if (!snapshot) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
message = stasis_message_create(ast_endpoint_snapshot_type(), snapshot);
|
|
|
|
if (!message) {
|
|
|
|
return;
|
|
|
|
}
|
2013-08-01 13:49:34 +00:00
|
|
|
stasis_publish(ast_endpoint_topic(endpoint), message);
|
2013-05-08 13:39:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void endpoint_dtor(void *obj)
|
|
|
|
{
|
|
|
|
struct ast_endpoint *endpoint = obj;
|
|
|
|
|
|
|
|
/* The router should be shut down already */
|
2013-05-17 21:10:32 +00:00
|
|
|
ast_assert(stasis_message_router_is_done(endpoint->router));
|
|
|
|
ao2_cleanup(endpoint->router);
|
|
|
|
endpoint->router = NULL;
|
2013-05-08 13:39:08 +00:00
|
|
|
|
2013-08-01 13:49:34 +00:00
|
|
|
stasis_cp_single_unsubscribe(endpoint->topics);
|
|
|
|
endpoint->topics = NULL;
|
2013-05-08 13:39:08 +00:00
|
|
|
|
2013-06-12 02:29:08 +00:00
|
|
|
ao2_cleanup(endpoint->channel_ids);
|
|
|
|
endpoint->channel_ids = NULL;
|
|
|
|
|
2013-05-08 13:39:08 +00:00
|
|
|
ast_string_field_free_memory(endpoint);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-06-13 11:02:16 +00:00
|
|
|
int ast_endpoint_add_channel(struct ast_endpoint *endpoint,
|
|
|
|
struct ast_channel *chan)
|
|
|
|
{
|
|
|
|
ast_assert(chan != NULL);
|
2013-05-08 13:39:08 +00:00
|
|
|
ast_assert(endpoint != NULL);
|
2013-06-13 11:02:16 +00:00
|
|
|
|
|
|
|
ast_channel_forward_endpoint(chan, endpoint);
|
2013-05-08 13:39:08 +00:00
|
|
|
|
|
|
|
ao2_lock(endpoint);
|
2013-06-13 11:02:16 +00:00
|
|
|
ast_str_container_add(endpoint->channel_ids, ast_channel_uniqueid(chan));
|
2013-05-08 13:39:08 +00:00
|
|
|
ao2_unlock(endpoint);
|
2013-06-13 11:02:16 +00:00
|
|
|
|
2013-12-18 20:33:37 +00:00
|
|
|
ast_channel_lock(chan);
|
2013-06-13 11:02:16 +00:00
|
|
|
ast_publish_channel_state(chan);
|
2013-12-18 20:33:37 +00:00
|
|
|
ast_channel_unlock(chan);
|
2013-06-13 11:02:16 +00:00
|
|
|
endpoint_publish_snapshot(endpoint);
|
|
|
|
|
|
|
|
return 0;
|
2013-05-08 13:39:08 +00:00
|
|
|
}
|
|
|
|
|
2013-06-07 12:56:56 +00:00
|
|
|
/*! \brief Handler for channel snapshot cache clears */
|
2013-05-08 13:39:08 +00:00
|
|
|
static void endpoint_cache_clear(void *data,
|
Multiple revisions 399887,400138,400178,400180-400181
........
r399887 | dlee | 2013-09-26 10:41:47 -0500 (Thu, 26 Sep 2013) | 1 line
Minor performance bump by not allocate manager variable struct if we don't need it
........
r400138 | dlee | 2013-09-30 10:24:00 -0500 (Mon, 30 Sep 2013) | 23 lines
Stasis performance improvements
This patch addresses several performance problems that were found in
the initial performance testing of Asterisk 12.
The Stasis dispatch object was allocated as an AO2 object, even though
it has a very confined lifecycle. This was replaced with a straight
ast_malloc().
The Stasis message router was spending an inordinate amount of time
searching hash tables. In this case, most of our routers had 6 or
fewer routes in them to begin with. This was replaced with an array
that's searched linearly for the route.
We more heavily rely on AO2 objects in Asterisk 12, and the memset()
in ao2_ref() actually became noticeable on the profile. This was
#ifdef'ed to only run when AO2_DEBUG was enabled.
After being misled by an erroneous comment in taskprocessor.c during
profiling, the wrong comment was removed.
Review: https://reviewboard.asterisk.org/r/2873/
........
r400178 | dlee | 2013-09-30 13:26:27 -0500 (Mon, 30 Sep 2013) | 24 lines
Taskprocessor optimization; switch Stasis to use taskprocessors
This patch optimizes taskprocessor to use a semaphore for signaling,
which the OS can do a better job at managing contention and waiting
that we can with a mutex and condition.
The taskprocessor execution was also slightly optimized to reduce the
number of locks taken.
The only observable difference in the taskprocessor implementation is
that when the final reference to the taskprocessor goes away, it will
execute all tasks to completion instead of discarding the unexecuted
tasks.
For systems where unnamed semaphores are not supported, a really
simple semaphore implementation is provided. (Which gives identical
performance as the original taskprocessor implementation).
The way we ended up implementing Stasis caused the threadpool to be a
burden instead of a boost to performance. This was switched to just
use taskprocessors directly for subscriptions.
Review: https://reviewboard.asterisk.org/r/2881/
........
r400180 | dlee | 2013-09-30 13:39:34 -0500 (Mon, 30 Sep 2013) | 28 lines
Optimize how Stasis forwards are dispatched
This patch optimizes how forwards are dispatched in Stasis.
Originally, forwards were dispatched as subscriptions that are invoked
on the publishing thread. This did not account for the vast number of
forwards we would end up having in the system, and the amount of work it
would take to walk though the forward subscriptions.
This patch modifies Stasis so that rather than walking the tree of
forwards on every dispatch, when forwards and subscriptions are changed,
the subscriber list for every topic in the tree is changed.
This has a couple of benefits. First, this reduces the workload of
dispatching messages. It also reduces contention when dispatching to
different topics that happen to forward to the same aggregation topic
(as happens with all of the channel, bridge and endpoint topics).
Since forwards are no longer subscriptions, the bulk of this patch is
simply changing stasis_subscription objects to stasis_forward objects
(which, admittedly, I should have done in the first place.)
Since this required me to yet again put in a growing array, I finally
abstracted that out into a set of ast_vector macros in
asterisk/vector.h.
Review: https://reviewboard.asterisk.org/r/2883/
........
r400181 | dlee | 2013-09-30 13:48:57 -0500 (Mon, 30 Sep 2013) | 28 lines
Remove dispatch object allocation from Stasis publishing
While looking for areas for performance improvement, I realized that an
unused feature in Stasis was negatively impacting performance.
When a message is sent to a subscriber, a dispatch object is allocated
for the dispatch, containing the topic the message was published to, the
subscriber the message is being sent to, and the message itself.
The topic is actually unused by any subscriber in Asterisk today. And
the subscriber is associated with the taskprocessor the message is being
dispatched to.
First, this patch removes the unused topic parameter from Stasis
subscription callbacks.
Second, this patch introduces the concept of taskprocessor local data,
data that may be set on a taskprocessor and provided along with the data
pointer when a task is pushed using the ast_taskprocessor_push_local()
call. This allows the task to have both data specific to that
taskprocessor, in addition to data specific to that invocation.
With those two changes, the dispatch object can be removed completely,
and the message is simply refcounted and sent directly to the
taskprocessor.
Review: https://reviewboard.asterisk.org/r/2884/
........
Merged revisions 399887,400138,400178,400180-400181 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@400186 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2013-09-30 18:55:27 +00:00
|
|
|
struct stasis_subscription *sub,
|
2013-05-08 13:39:08 +00:00
|
|
|
struct stasis_message *message)
|
|
|
|
{
|
|
|
|
struct ast_endpoint *endpoint = data;
|
2013-06-07 12:56:56 +00:00
|
|
|
struct stasis_message *clear_msg = stasis_message_data(message);
|
|
|
|
struct ast_channel_snapshot *clear_snapshot;
|
|
|
|
|
|
|
|
if (stasis_message_type(clear_msg) != ast_channel_snapshot_type()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
clear_snapshot = stasis_message_data(clear_msg);
|
2013-05-08 13:39:08 +00:00
|
|
|
|
|
|
|
ast_assert(endpoint != NULL);
|
|
|
|
|
|
|
|
ao2_lock(endpoint);
|
2013-06-07 12:56:56 +00:00
|
|
|
ast_str_container_remove(endpoint->channel_ids, clear_snapshot->uniqueid);
|
2013-05-08 13:39:08 +00:00
|
|
|
ao2_unlock(endpoint);
|
|
|
|
endpoint_publish_snapshot(endpoint);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void endpoint_default(void *data,
|
Multiple revisions 399887,400138,400178,400180-400181
........
r399887 | dlee | 2013-09-26 10:41:47 -0500 (Thu, 26 Sep 2013) | 1 line
Minor performance bump by not allocate manager variable struct if we don't need it
........
r400138 | dlee | 2013-09-30 10:24:00 -0500 (Mon, 30 Sep 2013) | 23 lines
Stasis performance improvements
This patch addresses several performance problems that were found in
the initial performance testing of Asterisk 12.
The Stasis dispatch object was allocated as an AO2 object, even though
it has a very confined lifecycle. This was replaced with a straight
ast_malloc().
The Stasis message router was spending an inordinate amount of time
searching hash tables. In this case, most of our routers had 6 or
fewer routes in them to begin with. This was replaced with an array
that's searched linearly for the route.
We more heavily rely on AO2 objects in Asterisk 12, and the memset()
in ao2_ref() actually became noticeable on the profile. This was
#ifdef'ed to only run when AO2_DEBUG was enabled.
After being misled by an erroneous comment in taskprocessor.c during
profiling, the wrong comment was removed.
Review: https://reviewboard.asterisk.org/r/2873/
........
r400178 | dlee | 2013-09-30 13:26:27 -0500 (Mon, 30 Sep 2013) | 24 lines
Taskprocessor optimization; switch Stasis to use taskprocessors
This patch optimizes taskprocessor to use a semaphore for signaling,
which the OS can do a better job at managing contention and waiting
that we can with a mutex and condition.
The taskprocessor execution was also slightly optimized to reduce the
number of locks taken.
The only observable difference in the taskprocessor implementation is
that when the final reference to the taskprocessor goes away, it will
execute all tasks to completion instead of discarding the unexecuted
tasks.
For systems where unnamed semaphores are not supported, a really
simple semaphore implementation is provided. (Which gives identical
performance as the original taskprocessor implementation).
The way we ended up implementing Stasis caused the threadpool to be a
burden instead of a boost to performance. This was switched to just
use taskprocessors directly for subscriptions.
Review: https://reviewboard.asterisk.org/r/2881/
........
r400180 | dlee | 2013-09-30 13:39:34 -0500 (Mon, 30 Sep 2013) | 28 lines
Optimize how Stasis forwards are dispatched
This patch optimizes how forwards are dispatched in Stasis.
Originally, forwards were dispatched as subscriptions that are invoked
on the publishing thread. This did not account for the vast number of
forwards we would end up having in the system, and the amount of work it
would take to walk though the forward subscriptions.
This patch modifies Stasis so that rather than walking the tree of
forwards on every dispatch, when forwards and subscriptions are changed,
the subscriber list for every topic in the tree is changed.
This has a couple of benefits. First, this reduces the workload of
dispatching messages. It also reduces contention when dispatching to
different topics that happen to forward to the same aggregation topic
(as happens with all of the channel, bridge and endpoint topics).
Since forwards are no longer subscriptions, the bulk of this patch is
simply changing stasis_subscription objects to stasis_forward objects
(which, admittedly, I should have done in the first place.)
Since this required me to yet again put in a growing array, I finally
abstracted that out into a set of ast_vector macros in
asterisk/vector.h.
Review: https://reviewboard.asterisk.org/r/2883/
........
r400181 | dlee | 2013-09-30 13:48:57 -0500 (Mon, 30 Sep 2013) | 28 lines
Remove dispatch object allocation from Stasis publishing
While looking for areas for performance improvement, I realized that an
unused feature in Stasis was negatively impacting performance.
When a message is sent to a subscriber, a dispatch object is allocated
for the dispatch, containing the topic the message was published to, the
subscriber the message is being sent to, and the message itself.
The topic is actually unused by any subscriber in Asterisk today. And
the subscriber is associated with the taskprocessor the message is being
dispatched to.
First, this patch removes the unused topic parameter from Stasis
subscription callbacks.
Second, this patch introduces the concept of taskprocessor local data,
data that may be set on a taskprocessor and provided along with the data
pointer when a task is pushed using the ast_taskprocessor_push_local()
call. This allows the task to have both data specific to that
taskprocessor, in addition to data specific to that invocation.
With those two changes, the dispatch object can be removed completely,
and the message is simply refcounted and sent directly to the
taskprocessor.
Review: https://reviewboard.asterisk.org/r/2884/
........
Merged revisions 399887,400138,400178,400180-400181 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@400186 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2013-09-30 18:55:27 +00:00
|
|
|
struct stasis_subscription *sub,
|
2013-05-08 13:39:08 +00:00
|
|
|
struct stasis_message *message)
|
|
|
|
{
|
|
|
|
struct stasis_endpoint *endpoint = data;
|
|
|
|
|
|
|
|
if (stasis_subscription_final_message(sub, message)) {
|
|
|
|
ao2_cleanup(endpoint);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
struct ast_endpoint *ast_endpoint_create(const char *tech, const char *resource)
|
|
|
|
{
|
|
|
|
RAII_VAR(struct ast_endpoint *, endpoint, NULL, ao2_cleanup);
|
|
|
|
int r = 0;
|
|
|
|
|
|
|
|
if (ast_strlen_zero(tech)) {
|
|
|
|
ast_log(LOG_ERROR, "Endpoint tech cannot be empty\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ast_strlen_zero(resource)) {
|
|
|
|
ast_log(LOG_ERROR, "Endpoint resource cannot be empty\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
endpoint = ao2_alloc(sizeof(*endpoint), endpoint_dtor);
|
|
|
|
if (!endpoint) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
endpoint->max_channels = -1;
|
|
|
|
endpoint->state = AST_ENDPOINT_UNKNOWN;
|
|
|
|
|
|
|
|
if (ast_string_field_init(endpoint, 80) != 0) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_string_field_set(endpoint, tech, tech);
|
|
|
|
ast_string_field_set(endpoint, resource, resource);
|
|
|
|
ast_string_field_build(endpoint, id, "%s/%s", tech, resource);
|
|
|
|
|
|
|
|
/* All access to channel_ids should be covered by the endpoint's
|
|
|
|
* lock; no extra lock needed. */
|
|
|
|
endpoint->channel_ids = ast_str_container_alloc_options(
|
2013-10-04 16:01:48 +00:00
|
|
|
AO2_ALLOC_OPT_LOCK_NOLOCK, ENDPOINT_CHANNEL_BUCKETS);
|
2013-05-08 13:39:08 +00:00
|
|
|
if (!endpoint->channel_ids) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-08-01 13:49:34 +00:00
|
|
|
endpoint->topics = stasis_cp_single_create(ast_endpoint_cache_all(),
|
|
|
|
endpoint->id);
|
|
|
|
if (!endpoint->topics) {
|
2013-05-08 13:39:08 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-08-01 13:49:34 +00:00
|
|
|
endpoint->router = stasis_message_router_create(ast_endpoint_topic(endpoint));
|
2013-05-08 13:39:08 +00:00
|
|
|
if (!endpoint->router) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
r |= stasis_message_router_add(endpoint->router,
|
|
|
|
stasis_cache_clear_type(), endpoint_cache_clear,
|
|
|
|
endpoint);
|
|
|
|
r |= stasis_message_router_set_default(endpoint->router,
|
|
|
|
endpoint_default, endpoint);
|
|
|
|
|
|
|
|
endpoint_publish_snapshot(endpoint);
|
|
|
|
|
2013-10-04 16:01:48 +00:00
|
|
|
ao2_link(endpoints, endpoint);
|
|
|
|
|
2013-05-08 13:39:08 +00:00
|
|
|
ao2_ref(endpoint, +1);
|
|
|
|
return endpoint;
|
|
|
|
}
|
|
|
|
|
2013-06-07 12:56:56 +00:00
|
|
|
static struct stasis_message *create_endpoint_snapshot_message(struct ast_endpoint *endpoint)
|
|
|
|
{
|
|
|
|
RAII_VAR(struct ast_endpoint_snapshot *, snapshot, NULL, ao2_cleanup);
|
|
|
|
snapshot = ast_endpoint_snapshot_create(endpoint);
|
|
|
|
if (!snapshot) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return stasis_message_create(ast_endpoint_snapshot_type(), snapshot);
|
|
|
|
}
|
|
|
|
|
2013-05-08 13:39:08 +00:00
|
|
|
void ast_endpoint_shutdown(struct ast_endpoint *endpoint)
|
|
|
|
{
|
2013-06-07 12:56:56 +00:00
|
|
|
RAII_VAR(struct stasis_message *, clear_msg, NULL, ao2_cleanup);
|
2013-05-08 13:39:08 +00:00
|
|
|
|
|
|
|
if (endpoint == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-10-04 16:01:48 +00:00
|
|
|
ao2_unlink(endpoints, endpoint);
|
|
|
|
|
2013-06-07 12:56:56 +00:00
|
|
|
clear_msg = create_endpoint_snapshot_message(endpoint);
|
|
|
|
if (clear_msg) {
|
|
|
|
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
|
|
|
|
message = stasis_cache_clear_create(clear_msg);
|
|
|
|
if (message) {
|
2013-08-01 13:49:34 +00:00
|
|
|
stasis_publish(ast_endpoint_topic(endpoint), message);
|
2013-06-07 12:56:56 +00:00
|
|
|
}
|
2013-05-08 13:39:08 +00:00
|
|
|
}
|
|
|
|
|
2013-05-17 21:10:32 +00:00
|
|
|
/* Bump refcount to hold on to the router */
|
|
|
|
ao2_ref(endpoint->router, +1);
|
2013-05-08 13:39:08 +00:00
|
|
|
stasis_message_router_unsubscribe(endpoint->router);
|
|
|
|
}
|
|
|
|
|
2013-10-04 16:01:48 +00:00
|
|
|
const char *ast_endpoint_get_tech(const struct ast_endpoint *endpoint)
|
|
|
|
{
|
|
|
|
if (!endpoint) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return endpoint->tech;
|
|
|
|
}
|
|
|
|
|
2013-05-08 13:39:08 +00:00
|
|
|
const char *ast_endpoint_get_resource(const struct ast_endpoint *endpoint)
|
|
|
|
{
|
2013-10-04 16:01:48 +00:00
|
|
|
if (!endpoint) {
|
|
|
|
return NULL;
|
|
|
|
}
|
2013-05-08 13:39:08 +00:00
|
|
|
return endpoint->resource;
|
|
|
|
}
|
|
|
|
|
2013-10-04 16:01:48 +00:00
|
|
|
const char *ast_endpoint_get_id(const struct ast_endpoint *endpoint)
|
|
|
|
{
|
|
|
|
if (!endpoint) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return endpoint->id;
|
|
|
|
}
|
|
|
|
|
2013-05-08 13:39:08 +00:00
|
|
|
void ast_endpoint_set_state(struct ast_endpoint *endpoint,
|
|
|
|
enum ast_endpoint_state state)
|
|
|
|
{
|
|
|
|
ast_assert(endpoint != NULL);
|
|
|
|
ao2_lock(endpoint);
|
|
|
|
endpoint->state = state;
|
|
|
|
ao2_unlock(endpoint);
|
|
|
|
endpoint_publish_snapshot(endpoint);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ast_endpoint_set_max_channels(struct ast_endpoint *endpoint,
|
|
|
|
int max_channels)
|
|
|
|
{
|
|
|
|
ast_assert(endpoint != NULL);
|
|
|
|
ao2_lock(endpoint);
|
|
|
|
endpoint->max_channels = max_channels;
|
|
|
|
ao2_unlock(endpoint);
|
|
|
|
endpoint_publish_snapshot(endpoint);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void endpoint_snapshot_dtor(void *obj)
|
|
|
|
{
|
|
|
|
struct ast_endpoint_snapshot *snapshot = obj;
|
2013-12-09 18:32:02 +00:00
|
|
|
int channel;
|
2013-05-08 13:39:08 +00:00
|
|
|
|
|
|
|
ast_assert(snapshot != NULL);
|
2013-12-09 18:32:02 +00:00
|
|
|
|
|
|
|
for (channel = 0; channel < snapshot->num_channels; channel++) {
|
|
|
|
ao2_ref(snapshot->channel_ids[channel], -1);
|
|
|
|
}
|
|
|
|
|
2013-05-08 13:39:08 +00:00
|
|
|
ast_string_field_free_memory(snapshot);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct ast_endpoint_snapshot *ast_endpoint_snapshot_create(
|
|
|
|
struct ast_endpoint *endpoint)
|
|
|
|
{
|
|
|
|
RAII_VAR(struct ast_endpoint_snapshot *, snapshot, NULL, ao2_cleanup);
|
|
|
|
int channel_count;
|
|
|
|
struct ao2_iterator i;
|
|
|
|
void *obj;
|
|
|
|
SCOPED_AO2LOCK(lock, endpoint);
|
|
|
|
|
|
|
|
channel_count = ao2_container_count(endpoint->channel_ids);
|
|
|
|
|
|
|
|
snapshot = ao2_alloc(
|
|
|
|
sizeof(*snapshot) + channel_count * sizeof(char *),
|
|
|
|
endpoint_snapshot_dtor);
|
|
|
|
|
|
|
|
if (ast_string_field_init(snapshot, 80) != 0) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_string_field_build(snapshot, id, "%s/%s", endpoint->tech,
|
|
|
|
endpoint->resource);
|
|
|
|
ast_string_field_set(snapshot, tech, endpoint->tech);
|
|
|
|
ast_string_field_set(snapshot, resource, endpoint->resource);
|
|
|
|
|
|
|
|
snapshot->state = endpoint->state;
|
|
|
|
snapshot->max_channels = endpoint->max_channels;
|
|
|
|
|
|
|
|
i = ao2_iterator_init(endpoint->channel_ids, 0);
|
|
|
|
while ((obj = ao2_iterator_next(&i))) {
|
2013-12-09 18:32:02 +00:00
|
|
|
/* The reference is kept so the channel id does not go away until the snapshot is gone */
|
|
|
|
snapshot->channel_ids[snapshot->num_channels++] = obj;
|
2013-05-08 13:39:08 +00:00
|
|
|
}
|
2013-06-12 02:29:08 +00:00
|
|
|
ao2_iterator_destroy(&i);
|
2013-05-08 13:39:08 +00:00
|
|
|
|
|
|
|
ao2_ref(snapshot, +1);
|
|
|
|
return snapshot;
|
|
|
|
}
|
2013-10-04 16:01:48 +00:00
|
|
|
|
|
|
|
static void endpoint_cleanup(void)
|
|
|
|
{
|
|
|
|
ao2_cleanup(endpoints);
|
|
|
|
endpoints = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ast_endpoint_init(void)
|
|
|
|
{
|
|
|
|
ast_register_cleanup(endpoint_cleanup);
|
|
|
|
|
|
|
|
endpoints = ao2_container_alloc(ENDPOINT_BUCKETS, endpoint_hash,
|
|
|
|
endpoint_cmp);
|
|
|
|
|
|
|
|
if (!endpoints) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|