mirror of http://gerrit.asterisk.org/asterisk
This patch does the following: * A new Stasis payload has been defined for multi-channel messages. This payload can store multiple ast_channel_snapshot objects along with a single JSON blob. The payload object itself is opaque; the snapshots are stored in a container keyed by roles. APIs have been provided to query for and retrieve the snapshots from the payload object. * The Dial AMI events have been refactored onto Stasis. This includes dial messages in app_dial, as well as the core dialing framework. The AMI events have been modified to send out a DialBegin/DialEnd events, as opposed to the subevent type that was previously used. * Stasis messages, types, and other objects related to channels have been placed in their own file, stasis_channels. Unit tests for some of these objects/messages have also been written. git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@384910 65c4cc65-6c06-0410-ace0-fbb531ad65f3changes/78/78/1
Matthew Jordan
12 years ago
parent
a2a53cc306
commit
b8d4e573f1
@ -0,0 +1,304 @@
|
||||
/*
|
||||
* Asterisk -- An open source telephony toolkit.
|
||||
*
|
||||
* Copyright (C) 2013, Digium, Inc.
|
||||
*
|
||||
* Matt Jordan <mjordan@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.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef STASIS_CHANNELS_H_
|
||||
#define STASIS_CHANNELS_H_
|
||||
|
||||
#include "asterisk/stringfields.h"
|
||||
#include "asterisk/stasis.h"
|
||||
#include "asterisk/json.h"
|
||||
#include "asterisk/channel.h"
|
||||
|
||||
/*! \addtogroup StasisTopicsAndMessages
|
||||
* @{
|
||||
*/
|
||||
|
||||
/*!
|
||||
* \since 12
|
||||
* \brief Structure representing a snapshot of channel state.
|
||||
*
|
||||
* While not enforced programmatically, this object is shared across multiple
|
||||
* threads, and should be threated as an immutable object.
|
||||
*/
|
||||
struct ast_channel_snapshot {
|
||||
AST_DECLARE_STRING_FIELDS(
|
||||
AST_STRING_FIELD(name); /*!< ASCII unique channel name */
|
||||
AST_STRING_FIELD(accountcode); /*!< Account code for billing */
|
||||
AST_STRING_FIELD(peeraccount); /*!< Peer account code for billing */
|
||||
AST_STRING_FIELD(userfield); /*!< Userfield for CEL billing */
|
||||
AST_STRING_FIELD(uniqueid); /*!< Unique Channel Identifier */
|
||||
AST_STRING_FIELD(linkedid); /*!< Linked Channel Identifier -- gets propagated by linkage */
|
||||
AST_STRING_FIELD(parkinglot); /*!< Default parking lot, if empty, default parking lot */
|
||||
AST_STRING_FIELD(hangupsource); /*!< Who is responsible for hanging up this channel */
|
||||
AST_STRING_FIELD(appl); /*!< Current application */
|
||||
AST_STRING_FIELD(data); /*!< Data passed to current application */
|
||||
AST_STRING_FIELD(context); /*!< Dialplan: Current extension context */
|
||||
AST_STRING_FIELD(exten); /*!< Dialplan: Current extension number */
|
||||
AST_STRING_FIELD(caller_name); /*!< Caller ID Name */
|
||||
AST_STRING_FIELD(caller_number); /*!< Caller ID Number */
|
||||
AST_STRING_FIELD(connected_name); /*!< Connected Line Name */
|
||||
AST_STRING_FIELD(connected_number); /*!< Connected Line Number */
|
||||
);
|
||||
|
||||
struct timeval creationtime; /*!< The time of channel creation */
|
||||
enum ast_channel_state state; /*!< State of line */
|
||||
int priority; /*!< Dialplan: Current extension priority */
|
||||
int amaflags; /*!< AMA flags for billing */
|
||||
int hangupcause; /*!< Why is the channel hanged up. See causes.h */
|
||||
int caller_pres; /*!< Caller ID presentation. */
|
||||
struct ast_flags flags; /*!< channel flags of AST_FLAG_ type */
|
||||
struct varshead *manager_vars; /*!< Variables to be appended to manager events */
|
||||
};
|
||||
|
||||
/*!
|
||||
* \since 12
|
||||
* \brief Blob of data associated with a channel.
|
||||
*
|
||||
* The \c blob is actually a JSON object of structured data. It has a "type" field
|
||||
* which contains the type string describing this blob.
|
||||
*/
|
||||
struct ast_channel_blob {
|
||||
/*! Channel blob is associated with (or NULL for global/all channels) */
|
||||
struct ast_channel_snapshot *snapshot;
|
||||
/*! JSON blob of data */
|
||||
struct ast_json *blob;
|
||||
};
|
||||
|
||||
/*!
|
||||
* \since 12
|
||||
* \brief A set of channels with blob objects - see \ref ast_channel_blob
|
||||
*/
|
||||
struct ast_multi_channel_blob;
|
||||
|
||||
/*!
|
||||
* \since 12
|
||||
* \brief A topic which publishes the events for all channels.
|
||||
* \retval Topic for all channel events.
|
||||
*/
|
||||
struct stasis_topic *ast_channel_topic_all(void);
|
||||
|
||||
/*!
|
||||
* \since 12
|
||||
* \brief A caching topic which caches \ref ast_channel_snapshot messages from
|
||||
* ast_channel_events_all(void).
|
||||
*
|
||||
* \retval Topic for all channel events.
|
||||
*/
|
||||
struct stasis_caching_topic *ast_channel_topic_all_cached(void);
|
||||
|
||||
/*!
|
||||
* \since 12
|
||||
* \brief Message type for \ref ast_channel_snapshot.
|
||||
*
|
||||
* \retval Message type for \ref ast_channel_snapshot.
|
||||
*/
|
||||
struct stasis_message_type *ast_channel_snapshot_type(void);
|
||||
|
||||
/*!
|
||||
* \since 12
|
||||
* \brief Message type for \ref ast_channel_blob messages.
|
||||
*
|
||||
* \retval Message type for \ref ast_channel_blob messages.
|
||||
*/
|
||||
struct stasis_message_type *ast_channel_blob_type(void);
|
||||
|
||||
/*!
|
||||
* \since 12
|
||||
* \brief Generate a snapshot of the channel state. This is an ao2 object, so
|
||||
* ao2_cleanup() to deallocate.
|
||||
*
|
||||
* \param chan The channel from which to generate a snapshot
|
||||
*
|
||||
* \retval pointer on success (must be ast_freed)
|
||||
* \retval NULL on error
|
||||
*/
|
||||
struct ast_channel_snapshot *ast_channel_snapshot_create(struct ast_channel *chan);
|
||||
|
||||
/*!
|
||||
* \since 12
|
||||
* \brief Creates a \ref ast_channel_blob message.
|
||||
*
|
||||
* The \a blob JSON object requires a \c "type" field describing the blob. It
|
||||
* should also be treated as immutable and not modified after it is put into the
|
||||
* message.
|
||||
*
|
||||
* \param chan Channel blob is associated with, or NULL for global/all channels.
|
||||
* \param blob JSON object representing the data.
|
||||
* \return \ref ast_channel_blob message.
|
||||
* \return \c NULL on error
|
||||
*/
|
||||
struct stasis_message *ast_channel_blob_create(struct ast_channel *chan,
|
||||
struct ast_json *blob);
|
||||
|
||||
/*!
|
||||
* \since 12
|
||||
* \brief Extracts the type field from a \ref ast_channel_blob.
|
||||
* Returned \c char* is still owned by \a obj
|
||||
* \param obj Channel blob object.
|
||||
* \return Type field value from the blob.
|
||||
* \return \c NULL on error.
|
||||
*/
|
||||
const char *ast_channel_blob_json_type(struct ast_channel_blob *obj);
|
||||
|
||||
/*!
|
||||
* \since 12
|
||||
* \brief Create a \ref ast_multi_channel_blob suitable for a \ref stasis_message
|
||||
*
|
||||
* \note Similar to a \ref ast_channel_blob, the \ref ast_multi_channel_blob requires
|
||||
* a \a blob JSON object containing a \c "type" field describing the blob. It
|
||||
* should also be treated as immutable and not modified after it is put into the
|
||||
* message.
|
||||
*
|
||||
* \param blob The JSON blob that defines the type of this \ref ast_multi_channel_blob
|
||||
*
|
||||
* \return \ref ast_multi_channel_blob object
|
||||
* \return \c NULL on error
|
||||
*/
|
||||
struct ast_multi_channel_blob *ast_multi_channel_blob_create(struct ast_json *blob);
|
||||
|
||||
/*!
|
||||
* \since 12
|
||||
* \brief Retrieve a channel snapshot associated with a specific role from a
|
||||
* \ref ast_multi_channel_blob
|
||||
*
|
||||
* \note The reference count of the \ref ast_channel_snapshot returned from
|
||||
* this function is not changed. The caller of this function does not own the
|
||||
* reference to the snapshot.
|
||||
*
|
||||
* \param obj The \ref ast_multi_channel_blob containing the channel snapshot
|
||||
* to retrieve
|
||||
* \param role The role associated with the channel snapshot
|
||||
*
|
||||
* \retval \ref ast_channel_snapshot matching the role on success
|
||||
* \retval NULL on error or not found for the role specified
|
||||
*/
|
||||
struct ast_channel_snapshot *ast_multi_channel_blob_get_channel(
|
||||
struct ast_multi_channel_blob *obj,
|
||||
const char *role);
|
||||
|
||||
/*!
|
||||
* \since 12
|
||||
* \brief Retrieve all channel snapshots associated with a specific role from
|
||||
* a \ref ast_multi_channel_blob
|
||||
*
|
||||
* \note Because this function returns an ao2_container (hashed by channel name)
|
||||
* of all channel snapshots that matched the passed in role, the reference of
|
||||
* the snapshots is increased by this function. The caller of this function must
|
||||
* release the reference to the snapshots by disposing of the container
|
||||
* appropriately.
|
||||
*
|
||||
* \param obj The \ref ast_multi_channel_blob containing the channel snapshots to
|
||||
* retrieve
|
||||
* \param role The role associated with the channel snapshots
|
||||
*
|
||||
* \retval A container containing all \ref ast_channel_snapshot objects matching
|
||||
* the role on success.
|
||||
* \retval NULL on error or not found for the role specified
|
||||
*/
|
||||
struct ao2_container *ast_multi_channel_blob_get_channels(
|
||||
struct ast_multi_channel_blob *obj,
|
||||
const char *role);
|
||||
|
||||
/*!
|
||||
* \since 12
|
||||
* \brief Retrieve the JSON blob from a \ref ast_multi_channel_blob.
|
||||
* Returned \ref ast_json is still owned by \a obj
|
||||
*
|
||||
* \param obj Channel blob object.
|
||||
* \return Type field value from the blob.
|
||||
* \return \c NULL on error.
|
||||
*/
|
||||
struct ast_json *ast_multi_channel_blob_get_json(struct ast_multi_channel_blob *obj);
|
||||
|
||||
/*!
|
||||
* \since 12
|
||||
* \brief Extracts the type field from a \ref ast_multi_channel_blob.
|
||||
* Returned \c char* is still owned by \a obj
|
||||
*
|
||||
* \param obj Channel blob object.
|
||||
* \return Type field value from the blob.
|
||||
* \return \c NULL on error.
|
||||
*/
|
||||
const char *ast_multi_channel_blob_get_type(struct ast_multi_channel_blob *obj);
|
||||
|
||||
/*!
|
||||
* \since 12
|
||||
* \brief Add a \ref ast_channel_snapshot to a \ref ast_multi_channel_blob object
|
||||
*
|
||||
* \note This will increase the reference count by 1 for the channel snapshot. It is
|
||||
* assumed that the \ref ast_multi_channel_blob will own a reference to the object.
|
||||
*
|
||||
* \param obj The \ref ast_multi_channel_blob object that will reference the snapshot
|
||||
* \param role A \a role that the snapshot has in the multi channel relationship
|
||||
* \param snapshot The \ref ast_channel_snapshot being added to the
|
||||
* \ref ast_multi_channel_blob object
|
||||
*/
|
||||
void ast_multi_channel_blob_add_channel(struct ast_multi_channel_blob *obj,
|
||||
const char *role,
|
||||
struct ast_channel_snapshot *snapshot);
|
||||
|
||||
/*!
|
||||
* \since 12
|
||||
* \brief Publish a \ref ast_channel_varset for a channel.
|
||||
*
|
||||
* \param chan Channel to pulish the event for, or \c NULL for 'none'.
|
||||
* \param variable Name of the variable being set
|
||||
* \param value Value.
|
||||
*/
|
||||
void ast_channel_publish_varset(struct ast_channel *chan,
|
||||
const char *variable, const char *value);
|
||||
|
||||
/*!
|
||||
* \since 12
|
||||
* \brief Message type for when a channel dials another channel
|
||||
*
|
||||
* \retval A stasis message type
|
||||
*/
|
||||
struct stasis_message_type *ast_channel_dial_type(void);
|
||||
|
||||
/*!
|
||||
* \since 12
|
||||
* \brief Publish in the \ref ast_channel_topic or \ref ast_channel_topic_all
|
||||
* topics a stasis message for the channels involved in a dial operation.
|
||||
*
|
||||
* \param caller The channel performing the dial operation
|
||||
* \param peer The channel being dialed
|
||||
* \param dialstring When beginning a dial, the information passed to the
|
||||
* dialing application
|
||||
* \param dialstatus The current status of the dial operation (NULL if no
|
||||
* status is known)
|
||||
*/
|
||||
void ast_channel_publish_dial(struct ast_channel *caller,
|
||||
struct ast_channel *peer,
|
||||
const char *dialstring,
|
||||
const char *dialstatus);
|
||||
|
||||
/*! @} */
|
||||
|
||||
/*!
|
||||
* \brief Dispose of the stasis channel topics and message types
|
||||
*/
|
||||
void ast_stasis_channels_shutdown(void);
|
||||
|
||||
/*!
|
||||
* \brief Initialize the stasis channel topic and message types
|
||||
*/
|
||||
void ast_stasis_channels_init(void);
|
||||
|
||||
#endif /* STASIS_CHANNELS_H_ */
|
||||
@ -0,0 +1,478 @@
|
||||
/*
|
||||
* Asterisk -- An open source telephony toolkit.
|
||||
*
|
||||
* Copyright (C) 2013, Digium, Inc.
|
||||
*
|
||||
* Matt Jordan <mjordan@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 Stasis Messages and Data Types for Channel Objects
|
||||
*
|
||||
* \author \verbatim Matt Jordan <mjordan@digium.com> \endverbatim
|
||||
*
|
||||
*/
|
||||
|
||||
/*** MODULEINFO
|
||||
<support_level>core</support_level>
|
||||
***/
|
||||
|
||||
#include "asterisk.h"
|
||||
|
||||
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
|
||||
|
||||
#include "asterisk/stasis.h"
|
||||
#include "asterisk/astobj2.h"
|
||||
#include "asterisk/stasis_channels.h"
|
||||
|
||||
#define NUM_MULTI_CHANNEL_BLOB_BUCKETS 7
|
||||
|
||||
/*! \brief Message type for channel snapshot messages */
|
||||
static struct stasis_message_type *channel_snapshot_type;
|
||||
|
||||
/*! \brief Message type for channel blob messages */
|
||||
static struct stasis_message_type *channel_blob_type;
|
||||
|
||||
/*! \brief Message type for channel dial messages */
|
||||
static struct stasis_message_type *channel_dial_type;
|
||||
|
||||
/*! \brief Topic for all channels */
|
||||
struct stasis_topic *channel_topic_all;
|
||||
|
||||
/*! \brief Caching topic for all channels */
|
||||
struct stasis_caching_topic *channel_topic_all_cached;
|
||||
|
||||
struct stasis_message_type *ast_channel_dial_type(void)
|
||||
{
|
||||
return channel_dial_type;
|
||||
}
|
||||
|
||||
struct stasis_message_type *ast_channel_blob_type(void)
|
||||
{
|
||||
return channel_blob_type;
|
||||
}
|
||||
|
||||
struct stasis_message_type *ast_channel_snapshot_type(void)
|
||||
{
|
||||
return channel_snapshot_type;
|
||||
}
|
||||
|
||||
struct stasis_topic *ast_channel_topic_all(void)
|
||||
{
|
||||
return channel_topic_all;
|
||||
}
|
||||
|
||||
struct stasis_caching_topic *ast_channel_topic_all_cached(void)
|
||||
{
|
||||
return channel_topic_all_cached;
|
||||
}
|
||||
|
||||
static const char *channel_snapshot_get_id(struct stasis_message *message)
|
||||
{
|
||||
struct ast_channel_snapshot *snapshot;
|
||||
if (ast_channel_snapshot_type() != stasis_message_type(message)) {
|
||||
return NULL;
|
||||
}
|
||||
snapshot = stasis_message_data(message);
|
||||
return snapshot->uniqueid;
|
||||
}
|
||||
|
||||
/*! \internal \brief Hash function for \ref ast_channel_snapshot objects */
|
||||
static int channel_snapshot_hash_cb(const void *obj, const int flags)
|
||||
{
|
||||
const struct ast_channel_snapshot *snapshot = obj;
|
||||
const char *name = (flags & OBJ_KEY) ? obj : snapshot->name;
|
||||
return ast_str_case_hash(name);
|
||||
}
|
||||
|
||||
/*! \internal \brief Comparison function for \ref ast_channel_snapshot objects */
|
||||
static int channel_snapshot_cmp_cb(void *obj, void *arg, int flags)
|
||||
{
|
||||
struct ast_channel_snapshot *left = obj;
|
||||
struct ast_channel_snapshot *right = arg;
|
||||
const char *match = (flags & OBJ_KEY) ? arg : right->name;
|
||||
return strcasecmp(left->name, match) ? 0 : (CMP_MATCH | CMP_STOP);
|
||||
}
|
||||
|
||||
static void channel_snapshot_dtor(void *obj)
|
||||
{
|
||||
struct ast_channel_snapshot *snapshot = obj;
|
||||
ast_string_field_free_memory(snapshot);
|
||||
}
|
||||
|
||||
struct ast_channel_snapshot *ast_channel_snapshot_create(struct ast_channel *chan)
|
||||
{
|
||||
RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
|
||||
|
||||
snapshot = ao2_alloc(sizeof(*snapshot), channel_snapshot_dtor);
|
||||
if (!snapshot || ast_string_field_init(snapshot, 1024)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ast_string_field_set(snapshot, name, ast_channel_name(chan));
|
||||
ast_string_field_set(snapshot, accountcode, ast_channel_accountcode(chan));
|
||||
ast_string_field_set(snapshot, peeraccount, ast_channel_peeraccount(chan));
|
||||
ast_string_field_set(snapshot, userfield, ast_channel_userfield(chan));
|
||||
ast_string_field_set(snapshot, uniqueid, ast_channel_uniqueid(chan));
|
||||
ast_string_field_set(snapshot, linkedid, ast_channel_linkedid(chan));
|
||||
ast_string_field_set(snapshot, parkinglot, ast_channel_parkinglot(chan));
|
||||
ast_string_field_set(snapshot, hangupsource, ast_channel_hangupsource(chan));
|
||||
if (ast_channel_appl(chan)) {
|
||||
ast_string_field_set(snapshot, appl, ast_channel_appl(chan));
|
||||
}
|
||||
if (ast_channel_data(chan)) {
|
||||
ast_string_field_set(snapshot, data, ast_channel_data(chan));
|
||||
}
|
||||
ast_string_field_set(snapshot, context, ast_channel_context(chan));
|
||||
ast_string_field_set(snapshot, exten, ast_channel_exten(chan));
|
||||
|
||||
ast_string_field_set(snapshot, caller_name,
|
||||
S_COR(ast_channel_caller(chan)->id.name.valid, ast_channel_caller(chan)->id.name.str, ""));
|
||||
ast_string_field_set(snapshot, caller_number,
|
||||
S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, ""));
|
||||
|
||||
ast_string_field_set(snapshot, connected_name,
|
||||
S_COR(ast_channel_connected(chan)->id.name.valid, ast_channel_connected(chan)->id.name.str, ""));
|
||||
ast_string_field_set(snapshot, connected_number,
|
||||
S_COR(ast_channel_connected(chan)->id.number.valid, ast_channel_connected(chan)->id.number.str, ""));
|
||||
|
||||
snapshot->creationtime = ast_channel_creationtime(chan);
|
||||
snapshot->state = ast_channel_state(chan);
|
||||
snapshot->priority = ast_channel_priority(chan);
|
||||
snapshot->amaflags = ast_channel_amaflags(chan);
|
||||
snapshot->hangupcause = ast_channel_hangupcause(chan);
|
||||
snapshot->flags = *ast_channel_flags(chan);
|
||||
|
||||
ao2_ref(snapshot, +1);
|
||||
return snapshot;
|
||||
}
|
||||
|
||||
static void publish_message_for_channel_topics(struct stasis_message *message, struct ast_channel *chan)
|
||||
{
|
||||
if (chan) {
|
||||
stasis_publish(ast_channel_topic(chan), message);
|
||||
} else {
|
||||
stasis_publish(ast_channel_topic_all(), message);
|
||||
}
|
||||
}
|
||||
|
||||
static void channel_blob_dtor(void *obj)
|
||||
{
|
||||
struct ast_channel_blob *event = obj;
|
||||
ao2_cleanup(event->snapshot);
|
||||
ast_json_unref(event->blob);
|
||||
}
|
||||
|
||||
void ast_channel_publish_dial(struct ast_channel *caller, struct ast_channel *peer, const char *dialstring, const char *dialstatus)
|
||||
{
|
||||
RAII_VAR(struct ast_multi_channel_blob *, payload, NULL, ao2_cleanup);
|
||||
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
|
||||
RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
|
||||
struct ast_channel_snapshot *caller_snapshot;
|
||||
struct ast_channel_snapshot *peer_snapshot;
|
||||
|
||||
ast_assert(peer != NULL);
|
||||
blob = ast_json_pack("{s: s, s: s, s: s}",
|
||||
"type", "dial",
|
||||
"dialstatus", S_OR(dialstatus, ""),
|
||||
"dialstring", S_OR(dialstring, ""));
|
||||
if (!blob) {
|
||||
return;
|
||||
}
|
||||
payload = ast_multi_channel_blob_create(blob);
|
||||
if (!payload) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (caller) {
|
||||
caller_snapshot = ast_channel_snapshot_create(caller);
|
||||
if (!caller_snapshot) {
|
||||
return;
|
||||
}
|
||||
ast_multi_channel_blob_add_channel(payload, "caller", caller_snapshot);
|
||||
}
|
||||
|
||||
peer_snapshot = ast_channel_snapshot_create(peer);
|
||||
if (!peer_snapshot) {
|
||||
return;
|
||||
}
|
||||
ast_multi_channel_blob_add_channel(payload, "peer", peer_snapshot);
|
||||
|
||||
msg = stasis_message_create(ast_channel_dial_type(), payload);
|
||||
if (!msg) {
|
||||
return;
|
||||
}
|
||||
|
||||
publish_message_for_channel_topics(msg, caller);
|
||||
}
|
||||
|
||||
struct stasis_message *ast_channel_blob_create(struct ast_channel *chan,
|
||||
struct ast_json *blob)
|
||||
{
|
||||
RAII_VAR(struct ast_channel_blob *, obj, NULL, ao2_cleanup);
|
||||
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
|
||||
struct ast_json *type;
|
||||
|
||||
ast_assert(blob != NULL);
|
||||
|
||||
type = ast_json_object_get(blob, "type");
|
||||
if (type == NULL) {
|
||||
ast_log(LOG_ERROR, "Invalid ast_channel_blob; missing type field\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
obj = ao2_alloc(sizeof(*obj), channel_blob_dtor);
|
||||
if (!obj) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (chan) {
|
||||
obj->snapshot = ast_channel_snapshot_create(chan);
|
||||
if (obj->snapshot == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
obj->blob = ast_json_ref(blob);
|
||||
|
||||
msg = stasis_message_create(ast_channel_blob_type(), obj);
|
||||
if (!msg) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ao2_ref(msg, +1);
|
||||
return msg;
|
||||
}
|
||||
|
||||
const char *ast_channel_blob_json_type(struct ast_channel_blob *obj)
|
||||
{
|
||||
if (obj == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return ast_json_string_get(ast_json_object_get(obj->blob, "type"));
|
||||
}
|
||||
|
||||
/*! \brief A channel snapshot wrapper object used in \ref ast_multi_channel_blob objects */
|
||||
struct channel_role_snapshot {
|
||||
struct ast_channel_snapshot *snapshot; /*!< A channel snapshot */
|
||||
char role[0]; /*!< The role assigned to the channel */
|
||||
};
|
||||
|
||||
/*! \brief A multi channel blob data structure for multi_channel_blob stasis messages */
|
||||
struct ast_multi_channel_blob {
|
||||
struct ao2_container *channel_snapshots; /*!< A container holding the snapshots */
|
||||
struct ast_json *blob; /*< A blob of JSON data */
|
||||
};
|
||||
|
||||
/*! \internal \brief Standard comparison function for \ref channel_role_snapshot objects */
|
||||
static int channel_role_single_cmp_cb(void *obj, void *arg, int flags)
|
||||
{
|
||||
struct channel_role_snapshot *left = obj;
|
||||
struct channel_role_snapshot *right = arg;
|
||||
const char *match = (flags & OBJ_KEY) ? arg : right->role;
|
||||
return strcasecmp(left->role, match) ? 0 : (CMP_MATCH | CMP_STOP);
|
||||
}
|
||||
|
||||
/*! \internal \brief Multi comparison function for \ref channel_role_snapshot objects */
|
||||
static int channel_role_multi_cmp_cb(void *obj, void *arg, int flags)
|
||||
{
|
||||
struct channel_role_snapshot *left = obj;
|
||||
struct channel_role_snapshot *right = arg;
|
||||
const char *match = (flags & OBJ_KEY) ? arg : right->role;
|
||||
return strcasecmp(left->role, match) ? 0 : (CMP_MATCH);
|
||||
}
|
||||
|
||||
/*! \internal \brief Hash function for \ref channel_role_snapshot objects */
|
||||
static int channel_role_hash_cb(const void *obj, const int flags)
|
||||
{
|
||||
const struct channel_role_snapshot *snapshot = obj;
|
||||
const char *name = (flags & OBJ_KEY) ? obj : snapshot->role;
|
||||
return ast_str_case_hash(name);
|
||||
}
|
||||
|
||||
/*! \internal \brief Destructor for \ref ast_multi_channel_blob objects */
|
||||
static void multi_channel_blob_dtor(void *obj)
|
||||
{
|
||||
struct ast_multi_channel_blob *multi_blob = obj;
|
||||
|
||||
ao2_cleanup(multi_blob->channel_snapshots);
|
||||
ast_json_unref(multi_blob->blob);
|
||||
}
|
||||
|
||||
struct ast_multi_channel_blob *ast_multi_channel_blob_create(struct ast_json *blob)
|
||||
{
|
||||
RAII_VAR(struct ast_multi_channel_blob *, obj,
|
||||
ao2_alloc(sizeof(*obj), multi_channel_blob_dtor),
|
||||
ao2_cleanup);
|
||||
struct ast_json *type;
|
||||
|
||||
ast_assert(blob != NULL);
|
||||
|
||||
if (!obj) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
type = ast_json_object_get(blob, "type");
|
||||
if (type == NULL) {
|
||||
ast_log(LOG_ERROR, "Invalid ast_multi_channel_blob; missing type field\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
obj->channel_snapshots = ao2_container_alloc(NUM_MULTI_CHANNEL_BLOB_BUCKETS,
|
||||
channel_role_hash_cb, channel_role_single_cmp_cb);
|
||||
if (!obj->channel_snapshots) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
obj->blob = ast_json_ref(blob);
|
||||
|
||||
ao2_ref(obj, +1);
|
||||
return obj;
|
||||
}
|
||||
|
||||
static void channel_role_snapshot_dtor(void *obj)
|
||||
{
|
||||
struct channel_role_snapshot *role_snapshot = obj;
|
||||
ao2_cleanup(role_snapshot->snapshot);
|
||||
}
|
||||
|
||||
void ast_multi_channel_blob_add_channel(struct ast_multi_channel_blob *obj, const char *role, struct ast_channel_snapshot *snapshot)
|
||||
{
|
||||
RAII_VAR(struct channel_role_snapshot *, role_snapshot, NULL, ao2_cleanup);
|
||||
int role_len = strlen(role) + 1;
|
||||
|
||||
if (!obj || ast_strlen_zero(role) || !snapshot) {
|
||||
return;
|
||||
}
|
||||
|
||||
role_snapshot = ao2_alloc(sizeof(*role_snapshot) + role_len, channel_role_snapshot_dtor);
|
||||
if (!role_snapshot) {
|
||||
return;
|
||||
}
|
||||
ast_copy_string(role_snapshot->role, role, role_len);
|
||||
role_snapshot->snapshot = snapshot;
|
||||
ao2_ref(role_snapshot->snapshot, +1);
|
||||
ao2_link(obj->channel_snapshots, role_snapshot);
|
||||
}
|
||||
|
||||
struct ast_channel_snapshot *ast_multi_channel_blob_get_channel(struct ast_multi_channel_blob *obj, const char *role)
|
||||
{
|
||||
struct channel_role_snapshot *role_snapshot;
|
||||
|
||||
if (!obj || ast_strlen_zero(role)) {
|
||||
return NULL;
|
||||
}
|
||||
role_snapshot = ao2_find(obj->channel_snapshots, role, OBJ_KEY);
|
||||
/* Note that this function does not increase the ref count on snapshot */
|
||||
if (!role_snapshot) {
|
||||
return NULL;
|
||||
}
|
||||
ao2_ref(role_snapshot, -1);
|
||||
return role_snapshot->snapshot;
|
||||
}
|
||||
|
||||
struct ao2_container *ast_multi_channel_blob_get_channels(struct ast_multi_channel_blob *obj, const char *role)
|
||||
{
|
||||
RAII_VAR(struct ao2_container *, ret_container,
|
||||
ao2_container_alloc(NUM_MULTI_CHANNEL_BLOB_BUCKETS, channel_snapshot_hash_cb, channel_snapshot_cmp_cb),
|
||||
ao2_cleanup);
|
||||
struct ao2_iterator *it_role_snapshots;
|
||||
struct channel_role_snapshot *role_snapshot;
|
||||
char *arg;
|
||||
|
||||
if (!obj || ast_strlen_zero(role) || !ret_container) {
|
||||
return NULL;
|
||||
}
|
||||
arg = ast_strdupa(role);
|
||||
|
||||
it_role_snapshots = ao2_callback(obj->channel_snapshots, OBJ_MULTIPLE | OBJ_KEY, channel_role_multi_cmp_cb, arg);
|
||||
if (!it_role_snapshots) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
while ((role_snapshot = ao2_iterator_next(it_role_snapshots))) {
|
||||
ao2_link(ret_container, role_snapshot->snapshot);
|
||||
ao2_ref(role_snapshot, -1);
|
||||
}
|
||||
ao2_iterator_destroy(it_role_snapshots);
|
||||
|
||||
ao2_ref(ret_container, +1);
|
||||
return ret_container;
|
||||
}
|
||||
|
||||
struct ast_json *ast_multi_channel_blob_get_json(struct ast_multi_channel_blob *obj)
|
||||
{
|
||||
if (!obj) {
|
||||
return NULL;
|
||||
}
|
||||
return obj->blob;
|
||||
}
|
||||
|
||||
const char *ast_multi_channel_blob_get_type(struct ast_multi_channel_blob *obj)
|
||||
{
|
||||
if (!obj) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return ast_json_string_get(ast_json_object_get(obj->blob, "type"));
|
||||
}
|
||||
|
||||
void ast_channel_publish_varset(struct ast_channel *chan, const char *name, const char *value)
|
||||
{
|
||||
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
|
||||
RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
|
||||
|
||||
ast_assert(name != NULL);
|
||||
ast_assert(value != NULL);
|
||||
|
||||
blob = ast_json_pack("{s: s, s: s, s: s}",
|
||||
"type", "varset",
|
||||
"variable", name,
|
||||
"value", value);
|
||||
if (!blob) {
|
||||
ast_log(LOG_ERROR, "Error creating message\n");
|
||||
return;
|
||||
}
|
||||
|
||||
msg = ast_channel_blob_create(chan, ast_json_ref(blob));
|
||||
|
||||
if (!msg) {
|
||||
return;
|
||||
}
|
||||
|
||||
publish_message_for_channel_topics(msg, chan);
|
||||
}
|
||||
|
||||
void ast_stasis_channels_shutdown(void)
|
||||
{
|
||||
ao2_cleanup(channel_snapshot_type);
|
||||
channel_snapshot_type = NULL;
|
||||
ao2_cleanup(channel_blob_type);
|
||||
channel_blob_type = NULL;
|
||||
ao2_cleanup(channel_dial_type);
|
||||
channel_dial_type = NULL;
|
||||
ao2_cleanup(channel_topic_all);
|
||||
channel_topic_all = NULL;
|
||||
channel_topic_all_cached = stasis_caching_unsubscribe(channel_topic_all_cached);
|
||||
}
|
||||
|
||||
void ast_stasis_channels_init(void)
|
||||
{
|
||||
channel_snapshot_type = stasis_message_type_create("ast_channel_snapshot");
|
||||
channel_blob_type = stasis_message_type_create("ast_channel_blob");
|
||||
channel_dial_type = stasis_message_type_create("ast_channel_dial");
|
||||
channel_topic_all = stasis_topic_create("ast_channel_topic_all");
|
||||
channel_topic_all_cached = stasis_caching_topic_create(channel_topic_all, channel_snapshot_get_id);
|
||||
}
|
||||
@ -0,0 +1,223 @@
|
||||
/*
|
||||
* Asterisk -- An open source telephony toolkit.
|
||||
*
|
||||
* Copyright (C) 2013, Digium, Inc.
|
||||
*
|
||||
* Matt Jordan <mjordan@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 Test Stasis Channel messages and objects
|
||||
*
|
||||
* \author\verbatim Matt Jordan <mjordan@digium.com> \endverbatim
|
||||
*
|
||||
* \ingroup tests
|
||||
*/
|
||||
|
||||
/*** MODULEINFO
|
||||
<depend>TEST_FRAMEWORK</depend>
|
||||
<support_level>core</support_level>
|
||||
***/
|
||||
|
||||
#include "asterisk.h"
|
||||
|
||||
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
|
||||
|
||||
#include "asterisk/astobj2.h"
|
||||
#include "asterisk/module.h"
|
||||
#include "asterisk/stasis.h"
|
||||
#include "asterisk/stasis_message_router.h"
|
||||
#include "asterisk/test.h"
|
||||
#include "asterisk/stasis_channels.h"
|
||||
#include "asterisk/channel.h"
|
||||
|
||||
static const char *test_category = "/stasis/channels/";
|
||||
|
||||
static void safe_channel_release(struct ast_channel *chan)
|
||||
{
|
||||
if (!chan) {
|
||||
return;
|
||||
}
|
||||
ast_channel_release(chan);
|
||||
}
|
||||
|
||||
AST_TEST_DEFINE(channel_blob_create)
|
||||
{
|
||||
struct ast_channel_blob *blob;
|
||||
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
|
||||
RAII_VAR(struct ast_channel *, chan, NULL, safe_channel_release);
|
||||
RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
|
||||
RAII_VAR(struct ast_json *, bad_json, NULL, ast_json_unref);
|
||||
|
||||
switch (cmd) {
|
||||
case TEST_INIT:
|
||||
info->name = __func__;
|
||||
info->category = test_category;
|
||||
info->summary = "Test creation of ast_channel_blob objects";
|
||||
info->description = "Test creation of ast_channel_blob objects";
|
||||
return AST_TEST_NOT_RUN;
|
||||
case TEST_EXECUTE:
|
||||
break;
|
||||
}
|
||||
|
||||
chan = ast_channel_alloc(0, AST_STATE_DOWN, "100", "Alice", "100", "100", "default", NULL, 0, "TEST/Alice");
|
||||
json = ast_json_pack("{s: s}",
|
||||
"type", "test");
|
||||
bad_json = ast_json_pack("{s: s}",
|
||||
"bad_key", "test");
|
||||
|
||||
/* Off nominal creation */
|
||||
ast_test_validate(test, NULL == ast_channel_blob_create(NULL, bad_json));
|
||||
ast_test_validate(test, NULL == ast_channel_blob_create(chan, bad_json));
|
||||
|
||||
/* Test for single channel */
|
||||
msg = ast_channel_blob_create(chan, json);
|
||||
ast_test_validate(test, NULL != msg);
|
||||
blob = stasis_message_data(msg);
|
||||
ast_test_validate(test, NULL != blob);
|
||||
ast_test_validate(test, NULL != blob->snapshot);
|
||||
ast_test_validate(test, NULL != blob->blob);
|
||||
ast_test_validate(test, 0 == strcmp(ast_channel_blob_json_type(blob), "test"));
|
||||
|
||||
ast_test_validate(test, 1 == ao2_ref(msg, 0));
|
||||
ao2_cleanup(msg);
|
||||
|
||||
/* Test for global channels */
|
||||
msg = ast_channel_blob_create(NULL, json);
|
||||
ast_test_validate(test, NULL != msg);
|
||||
blob = stasis_message_data(msg);
|
||||
ast_test_validate(test, NULL != blob);
|
||||
ast_test_validate(test, NULL == blob->snapshot);
|
||||
ast_test_validate(test, NULL != blob->blob);
|
||||
ast_test_validate(test, 0 == strcmp(ast_channel_blob_json_type(blob), "test"));
|
||||
|
||||
return AST_TEST_PASS;
|
||||
}
|
||||
|
||||
AST_TEST_DEFINE(multi_channel_blob_create)
|
||||
{
|
||||
RAII_VAR(struct ast_multi_channel_blob *, blob, NULL, ao2_cleanup);
|
||||
RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
|
||||
RAII_VAR(struct ast_json *, bad_json, NULL, ast_json_unref);
|
||||
|
||||
switch (cmd) {
|
||||
case TEST_INIT:
|
||||
info->name = __func__;
|
||||
info->category = test_category;
|
||||
info->summary = "Test creation of ast_multi_channel_blob objects";
|
||||
info->description = "Test creation of ast_multi_channel_blob objects";
|
||||
return AST_TEST_NOT_RUN;
|
||||
case TEST_EXECUTE:
|
||||
break;
|
||||
}
|
||||
|
||||
json = ast_json_pack("{s: s}",
|
||||
"type", "test");
|
||||
bad_json = ast_json_pack("{s: s}",
|
||||
"bad_key", "test");
|
||||
|
||||
/* Off nominal creation */
|
||||
ast_test_validate(test, NULL == ast_multi_channel_blob_create(bad_json));
|
||||
|
||||
/* Test for single channel */
|
||||
blob = ast_multi_channel_blob_create(json);
|
||||
ast_test_validate(test, NULL != blob);
|
||||
ast_test_validate(test, 0 == strcmp(ast_multi_channel_blob_get_type(blob), "test"));
|
||||
ast_test_validate(test, NULL != ast_multi_channel_blob_get_json(blob));
|
||||
|
||||
return AST_TEST_PASS;
|
||||
}
|
||||
|
||||
AST_TEST_DEFINE(multi_channel_blob_snapshots)
|
||||
{
|
||||
RAII_VAR(struct ast_multi_channel_blob *, blob, NULL, ao2_cleanup);
|
||||
RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
|
||||
RAII_VAR(struct ast_channel *, chan_alice, NULL, safe_channel_release);
|
||||
RAII_VAR(struct ast_channel *, chan_bob, NULL, safe_channel_release);
|
||||
RAII_VAR(struct ast_channel *, chan_charlie, NULL, safe_channel_release);
|
||||
struct ast_channel_snapshot *snapshot;
|
||||
struct ao2_container *matches;
|
||||
|
||||
switch (cmd) {
|
||||
case TEST_INIT:
|
||||
info->name = __func__;
|
||||
info->category = test_category;
|
||||
info->summary = "Test creation of ast_multi_channel_blob objects";
|
||||
info->description = "Test creation of ast_multi_channel_blob objects";
|
||||
return AST_TEST_NOT_RUN;
|
||||
case TEST_EXECUTE:
|
||||
break;
|
||||
}
|
||||
|
||||
json = ast_json_pack("{s: s}",
|
||||
"type", "test");
|
||||
chan_alice = ast_channel_alloc(0, AST_STATE_DOWN, "100", "Alice", "100", "100", "default", NULL, 0, "TEST/Alice");
|
||||
chan_bob = ast_channel_alloc(0, AST_STATE_DOWN, "200", "Bob", "200", "200", "default", NULL, 0, "TEST/Bob");
|
||||
chan_charlie = ast_channel_alloc(0, AST_STATE_DOWN, "300", "Bob", "300", "300", "default", NULL, 0, "TEST/Charlie");
|
||||
|
||||
blob = ast_multi_channel_blob_create(json);
|
||||
ast_multi_channel_blob_add_channel(blob, "Caller", ast_channel_snapshot_create(chan_alice));
|
||||
ast_multi_channel_blob_add_channel(blob, "Peer", ast_channel_snapshot_create(chan_bob));
|
||||
ast_multi_channel_blob_add_channel(blob, "Peer", ast_channel_snapshot_create(chan_charlie));
|
||||
|
||||
/* Test for unknown role */
|
||||
ast_test_validate(test, NULL == ast_multi_channel_blob_get_channel(blob, "Foobar"));
|
||||
|
||||
/* Test for single match */
|
||||
snapshot = ast_multi_channel_blob_get_channel(blob, "Caller");
|
||||
ast_test_validate(test, NULL != snapshot);
|
||||
ast_test_validate(test, 0 == strcmp("TEST/Alice", snapshot->name));
|
||||
|
||||
/* Test for single match, multiple possibilities */
|
||||
snapshot = ast_multi_channel_blob_get_channel(blob, "Peer");
|
||||
ast_test_validate(test, NULL != snapshot);
|
||||
ast_test_validate(test, 0 != strcmp("TEST/Alice", snapshot->name));
|
||||
|
||||
/* Multi-match */
|
||||
matches = ast_multi_channel_blob_get_channels(blob, "Peer");
|
||||
ast_test_validate(test, NULL != matches);
|
||||
ast_test_validate(test, 2 == ao2_container_count(matches));
|
||||
snapshot = ao2_find(matches, "TEST/Bob", OBJ_KEY);
|
||||
ast_test_validate(test, NULL != snapshot);
|
||||
ao2_cleanup(snapshot);
|
||||
snapshot = ao2_find(matches, "TEST/Charlie", OBJ_KEY);
|
||||
ast_test_validate(test, NULL != snapshot);
|
||||
ao2_cleanup(snapshot);
|
||||
ast_test_validate(test, 1 == ao2_ref(matches, 0));
|
||||
ao2_cleanup(matches);
|
||||
|
||||
return AST_TEST_PASS;
|
||||
}
|
||||
|
||||
static int unload_module(void)
|
||||
{
|
||||
AST_TEST_UNREGISTER(channel_blob_create);
|
||||
AST_TEST_UNREGISTER(multi_channel_blob_create);
|
||||
AST_TEST_UNREGISTER(multi_channel_blob_snapshots);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int load_module(void)
|
||||
{
|
||||
AST_TEST_REGISTER(channel_blob_create);
|
||||
AST_TEST_REGISTER(multi_channel_blob_create);
|
||||
AST_TEST_REGISTER(multi_channel_blob_snapshots);
|
||||
|
||||
return AST_MODULE_LOAD_SUCCESS;
|
||||
}
|
||||
|
||||
AST_MODULE_INFO(ASTERISK_GPL_KEY, 0, "Stasis Channel Testing",
|
||||
.load = load_module,
|
||||
.unload = unload_module
|
||||
);
|
||||
Loading…
Reference in new issue