res/stasis/app.h File Reference

Internal API for the Stasis application controller. More...

#include "asterisk/channel.h"
#include "asterisk/stasis.h"
#include "asterisk/stasis_app.h"

Include dependency graph for res/stasis/app.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Enumerations
enum	stasis_app_subscription_model { STASIS_APP_SUBSCRIBE_MANUAL, STASIS_APP_SUBSCRIBE_ALL }

Functions
struct stasis_app *	app_create (const char *name, stasis_app_cb handler, void *data, enum stasis_app_subscription_model subscription_model)
	Create a res_stasis application. More...
void	app_deactivate (struct stasis_app *app)
	Deactivates an application. More...
char *	app_get_replace_channel_app (struct ast_channel *chan)
	Get the app that the replacement channel will be controlled by. More...
int	app_is_active (struct stasis_app *app)
	Checks whether an app is active. More...
int	app_is_finished (struct stasis_app *app)
	Checks whether a deactivated app has no channels. More...
int	app_is_subscribed_bridge_id (struct stasis_app *app, const char *bridge_id)
	Test if an app is subscribed to a bridge. More...
int	app_is_subscribed_channel_id (struct stasis_app *app, const char *channel_id)
	Test if an app is subscribed to a channel. More...
int	app_is_subscribed_endpoint_id (struct stasis_app *app, const char *endpoint_id)
	Test if an app is subscribed to a endpoint. More...
void	app_send (struct stasis_app *app, struct ast_json *message)
	Send a message to an application. More...
int	app_send_end_msg (struct stasis_app *app, struct ast_channel *chan)
	Send StasisEnd message to the listening app. More...
int	app_set_replace_channel_app (struct ast_channel *chan, const char *replace_app)
	Set the app that the replacement channel will be controlled by. More...
int	app_set_replace_channel_snapshot (struct ast_channel *chan, struct ast_channel_snapshot *replace_snapshot)
	Set the snapshot of the channel that this channel will replace. More...
void	app_shutdown (struct stasis_app *app)
	Tears down an application. More...
int	app_subscribe_bridge (struct stasis_app *app, struct ast_bridge *bridge)
	Add a bridge subscription to an existing channel subscription. More...
int	app_subscribe_channel (struct stasis_app *app, struct ast_channel *chan)
	Subscribes an application to a channel. More...
int	app_subscribe_endpoint (struct stasis_app *app, struct ast_endpoint *endpoint)
	Subscribes an application to a endpoint. More...
struct ast_json *	app_to_json (const struct stasis_app *app)
	Create a JSON representation of a stasis_app. More...
int	app_unsubscribe_bridge (struct stasis_app *app, struct ast_bridge *bridge)
	Cancel the bridge subscription for an application. More...
int	app_unsubscribe_bridge_id (struct stasis_app *app, const char *bridge_id)
	Cancel the subscription an app has for a bridge. More...
int	app_unsubscribe_channel (struct stasis_app *app, struct ast_channel *chan)
	Cancel the subscription an app has for a channel. More...
int	app_unsubscribe_channel_id (struct stasis_app *app, const char *channel_id)
	Cancel the subscription an app has for a channel. More...
int	app_unsubscribe_endpoint_id (struct stasis_app *app, const char *endpoint_id)
	Cancel the subscription an app has for a endpoint. More...
void	app_update (struct stasis_app *app, stasis_app_cb handler, void *data)
	Update the handler and data for a res_stasis application. More...

Detailed Description

Internal API for the Stasis application controller.

Author

David M. Lee, II dlee@.nosp@m.digi.nosp@m.um.co.nosp@m.m

Since

12

Definition in file res/stasis/app.h.

Enumeration Type Documentation

stasis_app_subscription_model

enum stasis_app_subscription_model

Enumerator
STASIS_APP_SUBSCRIBE_MANUAL
STASIS_APP_SUBSCRIBE_ALL

Definition at line 39 of file res/stasis/app.h.

                                   {
   /*
    * \brief An application must manually subscribe to each
    * resource that it cares about. This is the default approach.
    */
   STASIS_APP_SUBSCRIBE_MANUAL,
   /*
    * \brief An application is automatically subscribed to all
    * resources in Asterisk, even if it does not control them.
    */
   STASIS_APP_SUBSCRIBE_ALL
};

Function Documentation

app_create()

struct stasis_app* app_create	(	const char *	name,
		stasis_app_cb	handler,
		void *	data,
		enum stasis_app_subscription_model	subscription_model
	)

Create a res_stasis application.

Parameters

name	Name of the application.
handler	Callback for messages sent to the application.
data	Data pointer provided to the callback.

Returns

New res_stasis application.

NULL on error.

Definition at line 915 of file res/stasis/app.c.

References AO2_ALLOC_OPT_LOCK_MUTEX, ao2_alloc_options, ao2_bump, ao2_cleanup, AO2_CONTAINER_ALLOC_OPT_DUPS_OBJ_REJECT, ao2_container_alloc_rbtree, ao2_ref, app, app_dtor(), ast_add_extension(), ast_asprintf, ast_assert, ast_attended_transfer_type(), ast_blind_transfer_type(), ast_bridge_merge_message_type(), ast_bridge_snapshot_type(), ast_bridge_topic_all(), ast_channel_snapshot_type(), ast_context_find(), ast_context_find_or_create(), ast_endpoint_snapshot_type(), ast_free, ast_free_ptr(), ast_log, ast_strdup, ast_verb, bridge_attended_transfer_handler(), bridge_blind_transfer_handler(), bridge_merge_handler(), bridge_subscription_change_handler(), context_name, forwards_sort(), stasis_app::handler, LOG_WARNING, NULL, RAII_VAR, stasis_message_router_add(), stasis_message_router_add_cache_update(), stasis_message_router_create, stasis_message_router_set_formatters_default(), stasis_subscription_change_type(), STASIS_SUBSCRIPTION_FORMATTER_JSON, stasis_topic_create(), sub_bridge_update_handler(), sub_channel_update_handler(), sub_default_handler(), sub_endpoint_update_handler(), sub_subscription_change_handler(), and stasis_app::subscription_model.

Referenced by __stasis_app_register().

{
   RAII_VAR(struct stasis_app *, app, NULL, ao2_cleanup);
   size_t size;
   int res = 0;
   size_t context_size = strlen("stasis-") + strlen(name) + 1;
   char context_name[context_size];
   char *topic_name;
   int ret;

   ast_assert(name != NULL);
   ast_assert(handler != NULL);

   ast_verb(1, "Creating Stasis app '%s'\n", name);

   size = sizeof(*app) + strlen(name) + 1;
   app = ao2_alloc_options(size, app_dtor, AO2_ALLOC_OPT_LOCK_MUTEX);
   if (!app) {
      return NULL;
   }
   app->subscription_model = subscription_model;

   app->forwards = ao2_container_alloc_rbtree(AO2_ALLOC_OPT_LOCK_MUTEX,
      AO2_CONTAINER_ALLOC_OPT_DUPS_OBJ_REJECT,
      forwards_sort, NULL);
   if (!app->forwards) {
      return NULL;
   }

   ret = ast_asprintf(&topic_name, "ari:application/%s", name);
   if (ret < 0) {
      return NULL;
   }

   app->topic = stasis_topic_create(topic_name);
   ast_free(topic_name);
   if (!app->topic) {
      return NULL;
   }

   app->bridge_router = stasis_message_router_create(ast_bridge_topic_all());
   if (!app->bridge_router) {
      return NULL;
   }

   res |= stasis_message_router_add(app->bridge_router,
      ast_bridge_merge_message_type(), bridge_merge_handler, app);

   res |= stasis_message_router_add(app->bridge_router,
      ast_blind_transfer_type(), bridge_blind_transfer_handler, app);

   res |= stasis_message_router_add(app->bridge_router,
      ast_attended_transfer_type(), bridge_attended_transfer_handler, app);

   res |= stasis_message_router_add(app->bridge_router,
      stasis_subscription_change_type(), bridge_subscription_change_handler, app);

   if (res != 0) {
      return NULL;
   }
   /* Bridge router holds a reference */
   ao2_ref(app, +1);

   app->router = stasis_message_router_create(app->topic);
   if (!app->router) {
      return NULL;
   }

   res |= stasis_message_router_add(app->router,
      ast_bridge_snapshot_type(), sub_bridge_update_handler, app);

   res |= stasis_message_router_add(app->router,
      ast_channel_snapshot_type(), sub_channel_update_handler, app);

   res |= stasis_message_router_add_cache_update(app->router,
      ast_endpoint_snapshot_type(), sub_endpoint_update_handler, app);

   res |= stasis_message_router_add(app->router,
      stasis_subscription_change_type(), sub_subscription_change_handler, app);

   stasis_message_router_set_formatters_default(app->router,
      sub_default_handler, app, STASIS_SUBSCRIPTION_FORMATTER_JSON);

   if (res != 0) {
      return NULL;
   }
   /* Router holds a reference */
   ao2_ref(app, +1);

   strncpy(app->name, name, size - sizeof(*app));
   app->handler = handler;
   app->data = ao2_bump(data);

   /* Create a context, a match-all extension, and a 'h' extension for this application. Note that
    * this should only be done if a context does not already exist. */
   strcpy(context_name, "stasis-");
   strcat(context_name, name);
   if (!ast_context_find(context_name)) {
      if (!ast_context_find_or_create(NULL, NULL, context_name, "res_stasis")) {
         ast_log(LOG_WARNING, "Could not create context '%s' for Stasis application '%s'\n", context_name, name);
      } else {
         ast_add_extension(context_name, 0, "_.", 1, NULL, NULL, "Stasis", ast_strdup(name), ast_free_ptr, "res_stasis");
         ast_add_extension(context_name, 0, "h", 1, NULL, NULL, "NoOp", NULL, NULL, "res_stasis");
      }
   } else {
      ast_log(LOG_WARNING, "Not creating context '%s' for Stasis application '%s' because it already exists\n",
         context_name, name);
   }

   ao2_ref(app, +1);
   return app;
}

app_deactivate()

void app_deactivate

(

struct stasis_app *

app

)

Deactivates an application.

Any channels currently in the application remain active (since the app might come back), but new channels are rejected.

Parameters

app	Application to deactivate.

Definition at line 1066 of file res/stasis/app.c.

References ao2_cleanup, ao2_lock, ao2_unlock, ast_verb, stasis_app::data, stasis_app::handler, stasis_app::name, and NULL.

Referenced by stasis_app_unregister().

{
   ao2_lock(app);

   ast_verb(1, "Deactivating Stasis app '%s'\n", app->name);
   app->handler = NULL;
   ao2_cleanup(app->data);
   app->data = NULL;

   ao2_unlock(app);
}

app_get_replace_channel_app()

char* app_get_replace_channel_app

(

struct ast_channel *

chan

)

Get the app that the replacement channel will be controlled by.

Parameters

channel

The channel on which this will be set

Return values

NULL

on error

Returns

the name of the controlling app (must be ast_free()d)

Definition at line 967 of file res_stasis.c.

References replace_channel_store::app, get_replace_channel_store(), NULL, and replace().

Referenced by bridge_stasis_run_cb().

{
   struct replace_channel_store *replace = get_replace_channel_store(chan, 1);
   char *replace_channel_app;

   if (!replace) {
      return NULL;
   }

   replace_channel_app = replace->app;
   replace->app = NULL;

   return replace_channel_app;
}

app_is_active()

int app_is_active

(

struct stasis_app *

app

)

Checks whether an app is active.

Parameters

app	Application to check.

Returns

True (non-zero) if app is active.

False (zero) if app has been deactivated.

Definition at line 1094 of file res/stasis/app.c.

References ao2_lock, ao2_unlock, stasis_app::handler, and NULL.

Referenced by stasis_app_exec().

{
   int ret;

   ao2_lock(app);
   ret = app->handler != NULL;
   ao2_unlock(app);

   return ret;
}

app_is_finished()

int app_is_finished

(

struct stasis_app *

app

)

Checks whether a deactivated app has no channels.

Parameters

app	Application to check.
True	(non-zero) if app is deactivated, and has no associated channels.
False	(zero) otherwise.

Definition at line 1105 of file res/stasis/app.c.

References ao2_container_count(), ao2_lock, ao2_unlock, stasis_app::forwards, stasis_app::handler, and NULL.

Referenced by app_shutdown(), and cleanup_cb().

{
   int ret;

   ao2_lock(app);
   ret = app->handler == NULL && ao2_container_count(app->forwards) == 0;
   ao2_unlock(app);

   return ret;
}

app_is_subscribed_bridge_id()

int app_is_subscribed_bridge_id	(	struct stasis_app *	app,
		const char *	bridge_id
	)

Test if an app is subscribed to a bridge.

Parameters

app	Subscribing application.
bridge_id	Id of bridge to check.

Returns

True (non-zero) if bridge is subscribed to app.

False (zero) if bridge is not subscribed.

Definition at line 1504 of file res/stasis/app.c.

References ao2_cleanup, ao2_find, ast_strlen_zero, BRIDGE_ALL, stasis_app::forwards, NULL, and OBJ_SEARCH_KEY.

{
   struct app_forwards *forwards;

   if (ast_strlen_zero(bridge_id)) {
      bridge_id = BRIDGE_ALL;
   }

   forwards = ao2_find(app->forwards, bridge_id, OBJ_SEARCH_KEY);
   ao2_cleanup(forwards);

   return forwards != NULL;
}

app_is_subscribed_channel_id()

int app_is_subscribed_channel_id	(	struct stasis_app *	app,
		const char *	channel_id
	)

Test if an app is subscribed to a channel.

Parameters

app	Subscribing application.
channel_id	Id of channel to check.

Returns

True (non-zero) if channel is subscribed to app.

False (zero) if channel is not subscribed.

Definition at line 1402 of file res/stasis/app.c.

References ao2_cleanup, ao2_find, ast_strlen_zero, CHANNEL_ALL, stasis_app::forwards, NULL, and OBJ_SEARCH_KEY.

{
   struct app_forwards *forwards;

   if (ast_strlen_zero(channel_id)) {
      channel_id = CHANNEL_ALL;
   }
   forwards = ao2_find(app->forwards, channel_id, OBJ_SEARCH_KEY);
   ao2_cleanup(forwards);

   return forwards != NULL;
}

app_is_subscribed_endpoint_id()

int app_is_subscribed_endpoint_id	(	struct stasis_app *	app,
		const char *	endpoint_id
	)

Test if an app is subscribed to a endpoint.

Parameters

app	Subscribing application.
endpoint_id	Id of endpoint to check.

Returns

True (non-zero) if endpoint is subscribed to app.

False (zero) if endpoint is not subscribed.

Definition at line 1601 of file res/stasis/app.c.

References ao2_cleanup, ao2_find, ast_strlen_zero, ENDPOINT_ALL, stasis_app::forwards, NULL, and OBJ_SEARCH_KEY.

{
   struct app_forwards *forwards;

   if (ast_strlen_zero(endpoint_id)) {
      endpoint_id = ENDPOINT_ALL;
   }
   forwards = ao2_find(app->forwards, endpoint_id, OBJ_SEARCH_KEY);
   ao2_cleanup(forwards);

   return forwards != NULL;
}

app_send()

void app_send	(	struct stasis_app *	app,
		struct ast_json *	message
	)

Send a message to an application.

Parameters

app	Application.
message	Message to send.

Send a message to an application.

Parameters

app	App to send the message to.
message	Message to send.

Definition at line 1038 of file res/stasis/app.c.

References ao2_bump, ao2_cleanup, ao2_lock, ao2_unlock, ast_eid_default, ast_eid_to_str(), ast_json_object_get(), ast_json_object_set(), ast_json_string_create(), ast_json_string_get(), ast_log, AST_LOG_WARNING, ast_verb, stasis_app::data, stasis_app::handler, and stasis_app::name.

Referenced by app_update(), message_received_handler(), stasis_app_exec(), stasis_app_send(), sub_bridge_update_handler(), sub_channel_update_handler(), sub_default_handler(), and sub_endpoint_update_handler().

{
   stasis_app_cb handler;
   char eid[20];
   void *data;

   if (ast_json_object_set(message, "asterisk_id", ast_json_string_create(
         ast_eid_to_str(eid, sizeof(eid), &ast_eid_default)))) {
      ast_log(AST_LOG_WARNING, "Failed to append EID to outgoing event %s\n",
         ast_json_string_get(ast_json_object_get(message, "type")));
   }

   /* Copy off mutable state with lock held */
   ao2_lock(app);
   handler = app->handler;
   data = ao2_bump(app->data);
   ao2_unlock(app);
   /* Name is immutable; no need to copy */

   if (handler) {
      handler(data, app->name, message);
   } else {
      ast_verb(3,
         "Inactive Stasis app '%s' missed message\n", app->name);
   }
   ao2_cleanup(data);
}

app_send_end_msg()

int app_send_end_msg	(	struct stasis_app *	app,
		struct ast_channel *	chan
	)

Send StasisEnd message to the listening app.

Parameters

app	The app that owns the channel
chan	The channel for which the message is being sent

Return values

zero	on success

Returns

non-zero on failure

Definition at line 1083 of file res_stasis.c.

References ao2_cleanup, app_unsubscribe_channel(), ast_app_get_topic(), ast_channel_blob_create(), ast_json_pack(), ast_json_timeval(), ast_json_unref(), ast_log, ast_tvnow(), start_message_blob::blob, stasis_message_sanitizer::channel, LOG_ERROR, NULL, remove_masquerade_store(), stasis_app_get_sanitizer(), stasis_app_name(), and stasis_publish().

Referenced by bridge_stasis_moving(), channel_replaced_cb(), channel_stolen_cb(), and stasis_app_exec().

{
   struct stasis_message_sanitizer *sanitize = stasis_app_get_sanitizer();
   struct ast_json *blob;
   struct stasis_message *msg;

   if (sanitize && sanitize->channel
      && sanitize->channel(chan)) {
      return 0;
   }

   blob = ast_json_pack("{s: s, s: o}",
      "app", stasis_app_name(app),
      "timestamp", ast_json_timeval(ast_tvnow(), NULL)
      );
   if (!blob) {
      ast_log(LOG_ERROR, "Error packing JSON for StasisEnd message\n");
      return -1;
   }

   remove_masquerade_store(chan);
   app_unsubscribe_channel(app, chan);
   msg = ast_channel_blob_create(chan, end_message_type(), blob);
   if (msg) {
      stasis_publish(ast_app_get_topic(app), msg);
   }
   ao2_cleanup(msg);
   ast_json_unref(blob);

   return 0;
}

app_set_replace_channel_app()

int app_set_replace_channel_app	(	struct ast_channel *	chan,
		const char *	replace_app
	)

Set the app that the replacement channel will be controlled by.

Parameters

channel	The channel on which this will be set
replace_app	The app that will be controlling this channel

Return values

zero	success
non-zero	failure

Definition at line 931 of file res_stasis.c.

References replace_channel_store::app, ast_free, ast_strdup, get_replace_channel_store(), NULL, and replace().

Referenced by bridge_stasis_push_peek().

{
   struct replace_channel_store *replace = get_replace_channel_store(chan, 0);

   if (!replace) {
      return -1;
   }

   ast_free(replace->app);
   replace->app = NULL;

   if (replace_app) {
      replace->app = ast_strdup(replace_app);
      if (!replace->app) {
         return -1;
      }
   }

   return 0;
}

app_set_replace_channel_snapshot()

int app_set_replace_channel_snapshot	(	struct ast_channel *	chan,
		struct ast_channel_snapshot *	replace_snapshot
	)

Set the snapshot of the channel that this channel will replace.

Parameters

channel	The channel on which this will be set
replace_snapshot	The snapshot of the channel that is being replaced

Return values

zero	success
non-zero	failure

Definition at line 919 of file res_stasis.c.

References ao2_replace, get_replace_channel_store(), replace(), and replace_channel_store::snapshot.

Referenced by bridge_stasis_push_peek().

{
   struct replace_channel_store *replace = get_replace_channel_store(chan, 0);

   if (!replace) {
      return -1;
   }

   ao2_replace(replace->snapshot, replace_snapshot);
   return 0;
}

app_shutdown()

void app_shutdown

(

struct stasis_app *

app

)

Tears down an application.

It should be finished before calling this.

Parameters

app	Application to unsubscribe.

Definition at line 1078 of file res/stasis/app.c.

References ao2_lock, ao2_unlock, app_is_finished(), ast_assert, stasis_app::bridge_router, stasis_app::endpoint_router, NULL, stasis_app::router, and stasis_message_router_unsubscribe().

Referenced by cleanup_cb().

{
   ao2_lock(app);

   ast_assert(app_is_finished(app));

   stasis_message_router_unsubscribe(app->router);
   app->router = NULL;
   stasis_message_router_unsubscribe(app->bridge_router);
   app->bridge_router = NULL;
   stasis_message_router_unsubscribe(app->endpoint_router);
   app->endpoint_router = NULL;

   ao2_unlock(app);
}

app_subscribe_bridge()

int app_subscribe_bridge	(	struct stasis_app *	app,
		struct ast_bridge *	bridge
	)

Add a bridge subscription to an existing channel subscription.

Parameters

app	Application.
bridge	Bridge to subscribe to.

Returns

0 on success.

Non-zero on error.

Definition at line 1428 of file res/stasis/app.c.

References ao2_find, ao2_link_flags, ao2_lock, ao2_ref, ao2_unlock, ast_debug, BRIDGE_ALL, stasis_app::forwards, forwards_create_bridge(), app_forwards::interested, stasis_app::name, OBJ_NOLOCK, OBJ_SEARCH_KEY, and ast_bridge::uniqueid.

Referenced by control_swap_channel_in_bridge(), stasis_app_exec(), and subscribe_bridge().

{
   struct app_forwards *forwards;

   if (!app) {
      return -1;
   }

   ao2_lock(app->forwards);
   /* If subscribed to all, don't subscribe again */
   forwards = ao2_find(app->forwards, BRIDGE_ALL, OBJ_SEARCH_KEY | OBJ_NOLOCK);
   if (forwards) {
      ao2_unlock(app->forwards);
      ao2_ref(forwards, -1);

      return 0;
   }

   forwards = ao2_find(app->forwards,
      bridge ? bridge->uniqueid : BRIDGE_ALL,
      OBJ_SEARCH_KEY | OBJ_NOLOCK);
   if (!forwards) {
      int res;

      /* Forwards not found, create one */
      forwards = forwards_create_bridge(app, bridge);
      if (!forwards) {
         ao2_unlock(app->forwards);

         return -1;
      }

      res = ao2_link_flags(app->forwards, forwards, OBJ_NOLOCK);
      if (!res) {
         ao2_unlock(app->forwards);
         ao2_ref(forwards, -1);

         return -1;
      }
   }

   ++forwards->interested;
   ast_debug(3, "Bridge '%s' is %d interested in %s\n",
      bridge ? bridge->uniqueid : "ALL",
      forwards->interested,
      app->name);

   ao2_unlock(app->forwards);
   ao2_ref(forwards, -1);

   return 0;
}

app_subscribe_channel()

int app_subscribe_channel	(	struct stasis_app *	app,
		struct ast_channel *	chan
	)

Subscribes an application to a channel.

Parameters

app	Application.
chan	Channel to subscribe to.

Returns

0 on success.

Non-zero on error.

Definition at line 1281 of file res/stasis/app.c.

References ao2_find, ao2_link_flags, ao2_lock, ao2_ref, ao2_unlock, ast_channel_uniqueid(), ast_debug, CHANNEL_ALL, stasis_app::forwards, forwards_create_channel(), app_forwards::interested, stasis_app::name, OBJ_NOLOCK, and OBJ_SEARCH_KEY.

Referenced by call_forwarded_handler(), send_start_msg_snapshots(), stasis_app_subscribe_channel(), and subscribe_channel().

{
   struct app_forwards *forwards;

   if (!app) {
      return -1;
   }

   ao2_lock(app->forwards);
   /* If subscribed to all, don't subscribe again */
   forwards = ao2_find(app->forwards, CHANNEL_ALL, OBJ_SEARCH_KEY | OBJ_NOLOCK);
   if (forwards) {
      ao2_unlock(app->forwards);
      ao2_ref(forwards, -1);

      return 0;
   }

   forwards = ao2_find(app->forwards,
      chan ? ast_channel_uniqueid(chan) : CHANNEL_ALL,
      OBJ_SEARCH_KEY | OBJ_NOLOCK);
   if (!forwards) {
      int res;

      /* Forwards not found, create one */
      forwards = forwards_create_channel(app, chan);
      if (!forwards) {
         ao2_unlock(app->forwards);

         return -1;
      }

      res = ao2_link_flags(app->forwards, forwards, OBJ_NOLOCK);
      if (!res) {
         ao2_unlock(app->forwards);
         ao2_ref(forwards, -1);

         return -1;
      }
   }

   ++forwards->interested;
   ast_debug(3, "Channel '%s' is %d interested in %s\n",
      chan ? ast_channel_uniqueid(chan) : "ALL",
      forwards->interested,
      app->name);

   ao2_unlock(app->forwards);
   ao2_ref(forwards, -1);

   return 0;
}

app_subscribe_endpoint()

int app_subscribe_endpoint	(	struct stasis_app *	app,
		struct ast_endpoint *	endpoint
	)

Subscribes an application to a endpoint.

Parameters

app	Application.
chan	Endpoint to subscribe to.

Returns

0 on success.

Non-zero on error.

Definition at line 1531 of file res/stasis/app.c.

References ao2_find, ao2_link_flags, ao2_lock, ao2_ref, ao2_unlock, ast_debug, ast_endpoint_get_id(), ENDPOINT_ALL, stasis_app::forwards, forwards_create_endpoint(), app_forwards::interested, message_received_handler(), messaging_app_subscribe_endpoint(), stasis_app::name, OBJ_NOLOCK, and OBJ_SEARCH_KEY.

Referenced by subscribe_endpoint().

{
   struct app_forwards *forwards;

   if (!app) {
      return -1;
   }

   ao2_lock(app->forwards);
   /* If subscribed to all, don't subscribe again */
   forwards = ao2_find(app->forwards, ENDPOINT_ALL, OBJ_SEARCH_KEY | OBJ_NOLOCK);
   if (forwards) {
      ao2_unlock(app->forwards);
      ao2_ref(forwards, -1);

      return 0;
   }

   forwards = ao2_find(app->forwards,
      endpoint ? ast_endpoint_get_id(endpoint) : ENDPOINT_ALL,
      OBJ_SEARCH_KEY | OBJ_NOLOCK);
   if (!forwards) {
      int res;

      /* Forwards not found, create one */
      forwards = forwards_create_endpoint(app, endpoint);
      if (!forwards) {
         ao2_unlock(app->forwards);

         return -1;
      }

      res = ao2_link_flags(app->forwards, forwards, OBJ_NOLOCK);
      if (!res) {
         ao2_unlock(app->forwards);
         ao2_ref(forwards, -1);

         return -1;
      }

      /* Subscribe for messages */
      messaging_app_subscribe_endpoint(app->name, endpoint, &message_received_handler, app);
   }

   ++forwards->interested;
   ast_debug(3, "Endpoint '%s' is %d interested in %s\n",
      endpoint ? ast_endpoint_get_id(endpoint) : "ALL",
      forwards->interested,
      app->name);

   ao2_unlock(app->forwards);
   ao2_ref(forwards, -1);

   return 0;
}

app_to_json()

struct ast_json* app_to_json

(

const struct stasis_app *

app

)

Create a JSON representation of a stasis_app.

Parameters

app	The application

Returns

JSON blob on success

NULL on error

Definition at line 1228 of file res/stasis/app.c.

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, array(), ast_json_array_append(), ast_json_object_get(), ast_json_pack(), ast_json_string_create(), ast_json_unref(), ast_log, bridges, channels, endpoints, FORWARD_BRIDGE, FORWARD_CHANNEL, FORWARD_ENDPOINT, app_forwards::forward_type, stasis_app::forwards, app_forwards::id, LOG_ERROR, stasis_app::name, and NULL.

Referenced by stasis_app_object_to_json().

{
   struct ast_json *json;
   struct ast_json *channels;
   struct ast_json *bridges;
   struct ast_json *endpoints;
   struct ao2_iterator i;
   struct app_forwards *forwards;

   json = ast_json_pack("{s: s, s: [], s: [], s: []}",
      "name", app->name,
      "channel_ids", "bridge_ids", "endpoint_ids");
   if (!json) {
      return NULL;
   }
   channels = ast_json_object_get(json, "channel_ids");
   bridges = ast_json_object_get(json, "bridge_ids");
   endpoints = ast_json_object_get(json, "endpoint_ids");

   i = ao2_iterator_init(app->forwards, 0);
   while ((forwards = ao2_iterator_next(&i))) {
      struct ast_json *array = NULL;
      int append_res;

      switch (forwards->forward_type) {
      case FORWARD_CHANNEL:
         array = channels;
         break;
      case FORWARD_BRIDGE:
         array = bridges;
         break;
      case FORWARD_ENDPOINT:
         array = endpoints;
         break;
      }

      /* If forward_type value is unexpected this will safely return an error. */
      append_res = ast_json_array_append(array, ast_json_string_create(forwards->id));
      ao2_ref(forwards, -1);

      if (append_res != 0) {
         ast_log(LOG_ERROR, "Error building response\n");
         ao2_iterator_destroy(&i);
         ast_json_unref(json);

         return NULL;
      }
   }
   ao2_iterator_destroy(&i);

   return json;
}

app_unsubscribe_bridge()

int app_unsubscribe_bridge	(	struct stasis_app *	app,
		struct ast_bridge *	bridge
	)

Cancel the bridge subscription for an application.

Parameters

forwards	Return from app_subscribe_channel().
bridge	Bridge to subscribe to.

Returns

0 on success.

Non-zero on error.

Definition at line 1486 of file res/stasis/app.c.

References app_unsubscribe_bridge_id(), BRIDGE_ALL, and ast_bridge::uniqueid.

Referenced by internal_bridge_after_cb(), and stasis_app_exec().

{
   if (!app) {
      return -1;
   }

   return app_unsubscribe_bridge_id(app, bridge ? bridge->uniqueid : BRIDGE_ALL);
}

app_unsubscribe_bridge_id()

int app_unsubscribe_bridge_id	(	struct stasis_app *	app,
		const char *	bridge_id
	)

Cancel the subscription an app has for a bridge.

Parameters

app	Subscribing application.
bridge_id	Id of bridge to unsubscribe from.

Returns

0 on success.

Non-zero on error.

Definition at line 1495 of file res/stasis/app.c.

References unsubscribe().

Referenced by app_unsubscribe_bridge().

{
   if (!app) {
      return -1;
   }

   return unsubscribe(app, "bridge", bridge_id, 0);
}

app_unsubscribe_channel()

int app_unsubscribe_channel	(	struct stasis_app *	app,
		struct ast_channel *	chan
	)

Cancel the subscription an app has for a channel.

Parameters

app	Subscribing application.
chan	Channel to unsubscribe from.

Returns

0 on success.

Non-zero on error.

Definition at line 1384 of file res/stasis/app.c.

References app_unsubscribe_channel_id(), ast_channel_uniqueid(), and CHANNEL_ALL.

Referenced by app_send_end_msg().

{
   if (!app) {
      return -1;
   }

   return app_unsubscribe_channel_id(app, chan ? ast_channel_uniqueid(chan) : CHANNEL_ALL);
}

app_unsubscribe_channel_id()

int app_unsubscribe_channel_id	(	struct stasis_app *	app,
		const char *	channel_id
	)

Cancel the subscription an app has for a channel.

Parameters

app	Subscribing application.
channel_id	Id of channel to unsubscribe from.

Returns

0 on success.

Non-zero on error.

Definition at line 1393 of file res/stasis/app.c.

References unsubscribe().

Referenced by app_unsubscribe_channel(), and send_start_msg_snapshots().

{
   if (!app) {
      return -1;
   }

   return unsubscribe(app, "channel", channel_id, 0);
}

app_unsubscribe_endpoint_id()

int app_unsubscribe_endpoint_id	(	struct stasis_app *	app,
		const char *	endpoint_id
	)

Cancel the subscription an app has for a endpoint.

Parameters

app	Subscribing application.
endpoint_id	Id of endpoint to unsubscribe from.

Returns

0 on success.

Non-zero on error.

Definition at line 1592 of file res/stasis/app.c.

References unsubscribe().

{
   if (!app) {
      return -1;
   }

   return unsubscribe(app, "endpoint", endpoint_id, 0);
}

app_update()

void app_update	(	struct stasis_app *	app,
		stasis_app_cb	handler,
		void *	data
	)

Update the handler and data for a res_stasis application.

If app has been deactivated, this will reactivate it.

Parameters

app	Application to update.
handler	New application callback.
data	New data pointer for the callback.

Definition at line 1116 of file res/stasis/app.c.

References ao2_lock, ao2_replace, ao2_unlock, app_send(), ast_json_pack(), ast_json_timeval(), ast_json_unref(), ast_tvnow(), ast_verb, stasis_app::data, stasis_app::handler, stasis_app::name, and NULL.

Referenced by __stasis_app_register().

{
   ao2_lock(app);
   if (app->handler && app->data) {
      struct ast_json *msg;

      ast_verb(1, "Replacing Stasis app '%s'\n", app->name);

      msg = ast_json_pack("{s: s, s: o?, s: s}",
         "type", "ApplicationReplaced",
         "timestamp", ast_json_timeval(ast_tvnow(), NULL),
         "application", app->name);
      if (msg) {
         /*
          * The app must be unlocked before calling 'send' since a handler may
          * subsequently attempt to grab the app lock after first obtaining a
          * lock for another object, thus causing a deadlock.
          */
         ao2_unlock(app);
         app_send(app, msg);
         ao2_lock(app);
         ast_json_unref(msg);
         if (!app->handler) {
            /*
             * If the handler disappeared then the app was deactivated. In that
             * case don't replace. Re-activation will reset the handler later.
             */
            ao2_unlock(app);
            return;
         }
      }
   } else {
      ast_verb(1, "Activating Stasis app '%s'\n", app->name);
   }

   app->handler = handler;
   ao2_replace(app->data, data);
   ao2_unlock(app);
}