[asterisk-commits] mjordan: branch mjordan/confbridgeactionexec r371177 - in /team/mjordan/confb...

SVN commits to the Asterisk project asterisk-commits at lists.digium.com
Sun Aug 12 15:54:33 CDT 2012


Author: mjordan
Date: Sun Aug 12 15:54:27 2012
New Revision: 371177

URL: http://svnview.digium.com/svn/asterisk?view=rev&rev=371177
Log:
Create branch for confbridgeactionexec

Added:
    team/mjordan/confbridgeactionexec/
      - copied from r371170, trunk/
    team/mjordan/confbridgeactionexec/tests/test_bridging.c   (with props)
Modified:
    team/mjordan/confbridgeactionexec/CHANGES
    team/mjordan/confbridgeactionexec/apps/app_confbridge.c
    team/mjordan/confbridgeactionexec/apps/confbridge/conf_config_parser.c
    team/mjordan/confbridgeactionexec/apps/confbridge/include/confbridge.h
    team/mjordan/confbridgeactionexec/include/asterisk/bridging.h
    team/mjordan/confbridgeactionexec/main/bridging.c

Modified: team/mjordan/confbridgeactionexec/CHANGES
URL: http://svnview.digium.com/svn/asterisk/team/mjordan/confbridgeactionexec/CHANGES?view=diff&rev=371177&r1=371170&r2=371177
==============================================================================
--- team/mjordan/confbridgeactionexec/CHANGES (original)
+++ team/mjordan/confbridgeactionexec/CHANGES Sun Aug 12 15:54:27 2012
@@ -58,6 +58,7 @@
    file also allows for the default sounds played to all conference users when
    this occurs to be overriden using sound_participants_unmuted and
    sound_participants_muted.
+ * Added AMI command ConfbridgeExecAction.  See the AMI changes for more details.
 
  * Added menu action participant_count.  This will playback the number of
    current participants in a conference.
@@ -633,7 +634,8 @@
 CDR Adaptive ODBC Driver
 -------------------
  * Added schema option for databases that support specifying a schema.
-
+ * ConfbridgeExecAction executes any confbridge action on a specified channel
+   in a conference.
 
 Resource Modules
 -------------------

Modified: team/mjordan/confbridgeactionexec/apps/app_confbridge.c
URL: http://svnview.digium.com/svn/asterisk/team/mjordan/confbridgeactionexec/apps/app_confbridge.c?view=diff&rev=371177&r1=371170&r2=371177
==============================================================================
--- team/mjordan/confbridgeactionexec/apps/app_confbridge.c (original)
+++ team/mjordan/confbridgeactionexec/apps/app_confbridge.c Sun Aug 12 15:54:27 2012
@@ -255,7 +255,31 @@
 		<description>
 		</description>
 	</manager>
-
+	<manager name="ConfbridgeExecAction" language="en_US">
+		<synopsis>
+			Execute a ConfBridge action on a particular channel.
+		</synopsis>
+		<syntax>
+			<xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
+			<parameter name="Conference" required="true">
+				<para>Conference Number.</para>
+			</parameter>
+			<parameter name="Channel" required="true">
+				<para>The channel to execute the actions on.</para>
+			</parameter>
+			<parameter name="Actions" required="true">
+				<para>A comma delineated list of ConfBridge actions to execute on the particular channel.</para>
+			</parameter>
+		</syntax>
+		<description>
+			<para>Executes a ConfBridge action on a specific channel.  The available actions are defined in
+			<literal>confbridge.conf</literal>.  The actions specified in the <literal>Actions</literal> parameter
+			are executed sequentially on the channel.</para>
+			<para>Executing ConfBridge actions through this mechanism does not lift any user profile
+			based restrictions.  For example, an action requiring a profile with the 'admin' flag will not be
+			able to be executed on a user's channel whose profile does not have that flag.</para>
+		</description>
+	</manager>
 ***/
 
 /*!
@@ -272,6 +296,18 @@
 
 /* Number of buckets our conference bridges container can have */
 #define CONFERENCE_BRIDGE_BUCKETS 53
+
+/*! \brief Object passed to the bridging layer during a deferred callback
+ */
+struct deferred_pvt {
+	/*! The user to perform an action for */
+	struct conference_bridge_user *conference_bridge_user;
+	/*! The menu entry defining the actions to execute */
+	struct conf_menu_entry menu_entry;
+	/*! The menu containing the menu entry */
+	struct conf_menu *menu;
+};
+
 
 /*! \brief Container to hold all conference bridges in progress */
 static struct ao2_container *conference_bridges;
@@ -2734,6 +2770,133 @@
 	return 0;
 }
 
+/*! \internal \brief A callback function passed to the bridging layer that
+ * performs an action upon a channel in the conference
+ */
+static void deferred_action_callback(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, void *pvt_data)
+{
+	struct deferred_pvt *pvt = pvt_data;
+
+	/* Make sure the pvt has all the information required */
+	if (!pvt || !pvt->conference_bridge_user || !pvt->menu) {
+		return;
+	}
+	conf_handle_dtmf(bridge_channel, pvt->conference_bridge_user, &pvt->menu_entry, pvt->menu);
+}
+
+/*! \internal \brief Destructor for a deferred_pvt */
+static void deferred_action_private_destructor(void *pvt_data)
+{
+	struct deferred_pvt *pvt = pvt_data;
+
+	if (!pvt) {
+		return;
+	}
+
+	if (pvt->menu && pvt->menu->entries.first) {
+		conf_menu_entry_destroy(pvt->menu->entries.first);
+	}
+	ast_free(pvt->menu);
+	ast_free(pvt);
+}
+
+/*! \internal \brief Entry point for the ConfbridgeExecAction manager command */
+static int action_confbridgeexecaction(struct mansession *s, const struct message *m)
+{
+	struct conference_bridge_user *participant = NULL;
+	struct conference_bridge *conf_bridge = NULL;
+	struct conf_menu *menu = NULL;
+	struct deferred_pvt *pvt = NULL;
+	struct conference_bridge tmp;
+	const char *conference = astman_get_header(m, "Conference");
+	const char *channel = astman_get_header(m, "Channel");
+	const char *action = astman_get_header(m, "Actions");
+	int deferred_queued = 0;
+
+	if (ast_strlen_zero(conference)) {
+		astman_send_error(s, m, "No Conference name provided.");
+		return 0;
+	}
+	if (ast_strlen_zero(channel)) {
+		astman_send_error(s, m, "No channel name provided.");
+		return 0;
+	}
+	if (ast_strlen_zero(action)) {
+		astman_send_error(s, m, "No actions provided.");
+		return 0;
+	}
+	if (!ao2_container_count(conference_bridges)) {
+		astman_send_error(s, m, "No active conferences.");
+		return 0;
+	}
+
+	/* Build the dummy menu entry that will contain the actions */
+	if (!(menu = ast_calloc(1, sizeof(*menu)))) {
+		astman_send_error(s, m, "Internal error when building actions.");
+		goto action_exec_cleanup;
+	}
+	if (conf_add_menu_entry(menu, "0", action)) {
+		astman_send_error(s, m, "Cannot parse specified actions.");
+		goto action_exec_cleanup;
+	}
+	if (!(pvt = ast_calloc(1, sizeof(*pvt)))) {
+		astman_send_error(s, m, "Internal error when building actions.");
+		goto action_exec_cleanup;
+	}
+	pvt->menu = menu;
+	pvt->menu_entry = *(menu->entries.first);
+
+	/* Find the conference */
+	ast_copy_string(tmp.name, conference, sizeof(tmp.name));
+	conf_bridge = ao2_find(conference_bridges, &tmp, OBJ_POINTER);
+	if (!conf_bridge) {
+		astman_send_error(s, m, "No Conference by that name found.");
+		goto action_exec_cleanup;
+	}
+
+	/* Find the participant in the bridge and ask the bridge layer to execute
+	 * the menu on that participant */
+	ao2_lock(conf_bridge);
+	AST_LIST_TRAVERSE(&conf_bridge->users_list, participant, list) {
+		if (!strncmp(channel, ast_channel_name(participant->chan), strlen(channel))) {
+			pvt->conference_bridge_user = participant;
+			if (ast_bridge_issue_deferred(conf_bridge->bridge,
+				participant->chan,
+				deferred_action_callback,
+				pvt,
+				deferred_action_private_destructor)) {
+				ao2_unlock(conf_bridge);
+				astman_send_error(s, m, "Internal error initiating action on participant.");
+				goto action_exec_cleanup;
+			}
+			deferred_queued = 1;
+			break;
+		}
+	}
+	ao2_unlock(conf_bridge);
+
+	if (!participant) {
+		astman_send_error(s, m, "No channel by that name found in Conference.");
+		goto action_exec_cleanup;
+	}
+
+	astman_send_ack(s, m, "Conference action successfully requested for participant.");
+
+action_exec_cleanup:
+	/* Destroy the pvt we created if we failed to queue it up for action */
+	if (!deferred_queued) {
+		if (menu && menu->entries.first) {
+			conf_menu_entry_destroy(menu->entries.first);
+		}
+		ast_free(menu);
+		ast_free(pvt);
+	}
+	if (conf_bridge) {
+		ao2_ref(conf_bridge, -1);
+	}
+	return 0;
+}
+
 static int func_confbridge_info(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
 {
 	char *parse = NULL;
@@ -2823,6 +2986,7 @@
 	res |= ast_manager_unregister("ConfbridgeLock");
 	res |= ast_manager_unregister("ConfbridgeStartRecord");
 	res |= ast_manager_unregister("ConfbridgeStopRecord");
+	res |= ast_manager_unregister("ConfbridgeExecAction");
 
 	return res;
 }
@@ -2866,6 +3030,7 @@
 	res |= ast_manager_register_xml("ConfbridgeStartRecord", EVENT_FLAG_CALL, action_confbridgestartrecord);
 	res |= ast_manager_register_xml("ConfbridgeStopRecord", EVENT_FLAG_CALL, action_confbridgestoprecord);
 	res |= ast_manager_register_xml("ConfbridgeSetSingleVideoSrc", EVENT_FLAG_CALL, action_confbridgesetsinglevideosrc);
+	res |= ast_manager_register_xml("ConfbridgeExecAction", EVENT_FLAG_CALL, action_confbridgeexecaction);
 	if (res) {
 		return AST_MODULE_LOAD_FAILURE;
 	}

Modified: team/mjordan/confbridgeactionexec/apps/confbridge/conf_config_parser.c
URL: http://svnview.digium.com/svn/asterisk/team/mjordan/confbridgeactionexec/apps/confbridge/conf_config_parser.c?view=diff&rev=371177&r1=371170&r2=371177
==============================================================================
--- team/mjordan/confbridgeactionexec/apps/confbridge/conf_config_parser.c (original)
+++ team/mjordan/confbridgeactionexec/apps/confbridge/conf_config_parser.c Sun Aug 12 15:54:27 2012
@@ -477,7 +477,7 @@
 	return 0;
 }
 
-static int add_menu_entry(struct conf_menu *menu, const char *dtmf, const char *action_names)
+int conf_add_menu_entry(struct conf_menu *menu, const char *dtmf, const char *action_names)
 {
 	struct conf_menu_entry *menu_entry = NULL, *cur = NULL;
 	int res = 0;
@@ -1249,7 +1249,7 @@
 
 static int menu_option_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
 {
-	add_menu_entry(obj, var->name, var->value);
+	conf_add_menu_entry(obj, var->name, var->value);
 	return 0;
 }
 

Modified: team/mjordan/confbridgeactionexec/apps/confbridge/include/confbridge.h
URL: http://svnview.digium.com/svn/asterisk/team/mjordan/confbridgeactionexec/apps/confbridge/include/confbridge.h?view=diff&rev=371177&r1=371170&r2=371177
==============================================================================
--- team/mjordan/confbridgeactionexec/apps/confbridge/include/confbridge.h (original)
+++ team/mjordan/confbridgeactionexec/apps/confbridge/include/confbridge.h Sun Aug 12 15:54:27 2012
@@ -294,6 +294,21 @@
 int conf_find_menu_entry_by_sequence(const char *dtmf_sequence, struct conf_menu *menu, struct conf_menu_entry *result);
 
 /*!
+ * \brief Adds a sequence of actions to a DTMF key in a ConfBridge menu
+ *
+ * \param menu The menu to add an action to
+ * \param dtmf The DTMF key to associate with the menu actions
+ * \param action_names A comma delineated list of ConfBridge action names to execute
+ *
+ * \note If the menu can be accessed by a user when this method is called, the menu
+ * itself should be locked prior to calling this method.
+ *
+ * \retval 0 on success, actions were added to the menu under the associated DTMF key
+ * \retval -1 on error
+ */
+int conf_add_menu_entry(struct conf_menu *menu, const char *dtmf, const char *action_names);
+
+/*!
  * \brief Destroys and frees all the actions stored in a menu_entry structure
  */
 void conf_menu_entry_destroy(struct conf_menu_entry *menu_entry);

Modified: team/mjordan/confbridgeactionexec/include/asterisk/bridging.h
URL: http://svnview.digium.com/svn/asterisk/team/mjordan/confbridgeactionexec/include/asterisk/bridging.h?view=diff&rev=371177&r1=371170&r2=371177
==============================================================================
--- team/mjordan/confbridgeactionexec/include/asterisk/bridging.h (original)
+++ team/mjordan/confbridgeactionexec/include/asterisk/bridging.h Sun Aug 12 15:54:27 2012
@@ -101,6 +101,8 @@
 	AST_BRIDGE_CHANNEL_STATE_START_TALKING,
 	/*! Bridged channel has stopped talking */
 	AST_BRIDGE_CHANNEL_STATE_STOP_TALKING,
+	/*! Bridged channel would like a deferred callback executed */
+	AST_BRIDGE_CHANNEL_STATE_EXECUTE_DEFERRED,
 };
 
 /*! \brief Return values for bridge technology write function */
@@ -132,6 +134,17 @@
 	unsigned int drop_silence:1;
 };
 
+struct bridge_deferred_callback;
+
+/*!
+ * \brief Structure that holds states for bridge_channel transitions
+ */
+struct requested_bridge_state {
+	/*! The state to transition to */
+	enum ast_bridge_channel_state state;
+	AST_LIST_ENTRY(requested_bridge_state) entry;
+};
+
 /*!
  * \brief Structure that contains information regarding a channel in a bridge
  */
@@ -140,6 +153,8 @@
 	ast_mutex_t lock;
 	/*! Condition, used if we want to wake up a thread waiting on the bridged channel */
 	ast_cond_t cond;
+	/*! The next requested state to put the bridge in */
+	AST_LIST_HEAD_NOLOCK(,requested_bridge_state) requested_states;
 	/*! Current bridged channel state */
 	enum ast_bridge_channel_state state;
 	/*! Asterisk channel participating in the bridge */
@@ -160,6 +175,8 @@
 	unsigned int allow_impart_hangup:1;
 	/*! Features structure for features that are specific to this channel */
 	struct ast_bridge_features *features;
+	/*! A list that acts as a FIFO queue of deferred callbacks to execute */
+	AST_LIST_HEAD_NOLOCK(,bridge_deferred_callback) deferreds;
 	/*! Technology optimization parameters used by bridging technologies capable of
 	 *  optimizing based upon talk detection. */
 	struct ast_bridge_tech_optimizations tech_args;
@@ -251,6 +268,31 @@
 	AST_LIST_HEAD_NOLOCK(, ast_bridge_channel) channels;
 	};
 
+/*!
+ * \brief General purpose deferred callback
+ *
+ * \details This represents a general purpose callback function
+ * that will be safely executed in the context of a particular
+ * channel's thread.
+ *
+ * \param bridge The bridge that the channel is part of
+ * \param bridge_channel Channel whose thread the function is executed on
+ * \param pvt_data General data optionally passed to the callback function
+ */
+typedef void (*ast_bridge_deferred_callback)(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, void *pvt);
+
+/*!
+ * \brief Dispose of any general purpose data passed to a deferred callback
+ *
+ * \details If the pvt_data object is provided, an optional destructor can be
+ * provided that will be called after the callback has completed.  This allows
+ * for the memory allocated for the data to be disposed of.
+ *
+ * \param pvt_data General data that was optionally passed to the callback function
+ */
+typedef void (*ast_bridge_deferred_callback_destructor)(void *pvt_data);
+
+
 /*! \brief Create a new bridge
  *
  * \param capabilities The capabilities that we require to be used on the bridge
@@ -557,6 +599,33 @@
  */
 void ast_bridge_remove_video_src(struct ast_bridge *bridge, struct ast_channel *chan);
 
+/*!
+ * \brief Ask the bridging layer to execute a callback function on a particular channel's
+ * bridge channel thread
+ * \param bridge The bridge to issue the deferred callback on
+ * \param chan The channel in the bridge whose thread the callback will be executed on
+ * \param deferred_cb The function to call
+ * \param pvt_data Optional data to pass to the function
+ * \param pvt_destructor Destructor for the private data.  Required if pvt_data is used.
+ *
+ * This method allows user's of the bridging API to request a callback function be executed
+ * in the context of a particular channel's bridge thread.  This safely removes the channel
+ * from the bridge, allowing actions to be executed on the underlying ast_channel.
+ *
+ * \note Since the callback function will typically execute on a separate thread then the
+ * initiator of the request, there is no guarantee when the callback will be executed, or if
+ * it will be executed (for example, the channel can be hung up prior to execution of the
+ * deferred callback).
+ *
+ * \retval 0 if the callback was successfully queued for later execution
+ * \retval -1 on error
+ */
+int ast_bridge_issue_deferred(struct ast_bridge *bridge,
+	struct ast_channel *chan,
+	ast_bridge_deferred_callback deferred_cb,
+	void *pvt_data,
+	ast_bridge_deferred_callback_destructor pvt_destructor);
+
 #if defined(__cplusplus) || defined(c_plusplus)
 }
 #endif

Modified: team/mjordan/confbridgeactionexec/main/bridging.c
URL: http://svnview.digium.com/svn/asterisk/team/mjordan/confbridgeactionexec/main/bridging.c?view=diff&rev=371177&r1=371170&r2=371177
==============================================================================
--- team/mjordan/confbridgeactionexec/main/bridging.c (original)
+++ team/mjordan/confbridgeactionexec/main/bridging.c Sun Aug 12 15:54:27 2012
@@ -55,6 +55,22 @@
 /* Grow rate of bridge array of channels */
 #define BRIDGE_ARRAY_GROW 32
 
+/*!
+ * \internal
+ * \brief An internally object used to hold information about deferred
+ * callbacks issued on a bridge channel
+ */
+struct bridge_deferred_callback {
+	/*! The callback function to execute on the bridge channel's thread */
+	ast_bridge_deferred_callback deferred_cb;
+	/*! Private data to pass to the deferred callback */
+	void *pvt_data;
+	/*! Optional destructor function to execute on the private data */
+	ast_bridge_deferred_callback_destructor pvt_destructor;
+	/* Deferreds exist in a FIFO queue on the bridge channel */
+	AST_LIST_ENTRY(bridge_deferred_callback) entry;
+};
+
 static void cleanup_video_mode(struct ast_bridge *bridge);
 
 /*! Default DTMF keys for built in features */
@@ -118,17 +134,41 @@
 	return current ? 0 : -1;
 }
 
+static void enqueue_bridge_state_change(struct ast_bridge_channel *bridge_channel, struct requested_bridge_state *state)
+{
+	switch (state->state) {
+	/* States that result in the bridge being removed go on the front */
+	case AST_BRIDGE_CHANNEL_STATE_END:
+	case AST_BRIDGE_CHANNEL_STATE_HANGUP:
+	case AST_BRIDGE_CHANNEL_STATE_DEPART:
+		AST_LIST_INSERT_HEAD(&bridge_channel->requested_states, state, entry);
+		break;
+	default:
+		/* Everyone else - get in the back! */
+		AST_LIST_INSERT_TAIL(&bridge_channel->requested_states, state, entry);
+		break;
+	}
+}
+
 void ast_bridge_change_state(struct ast_bridge_channel *bridge_channel, enum ast_bridge_channel_state new_state)
 {
-	/* Change the state on the bridge channel */
-	bridge_channel->state = new_state;
+	struct requested_bridge_state *state;
+
+	if (!(state = ast_calloc(1, sizeof(*state)))) {
+		ast_log(AST_LOG_ERROR, "Failed to allocate memory to enqueue state %d\n", new_state);
+		return;
+	}
+	state->state = new_state;
 
 	/* Only poke the channel's thread if it is not us */
 	if (!pthread_equal(pthread_self(), bridge_channel->thread)) {
 		pthread_kill(bridge_channel->thread, SIGURG);
 		ao2_lock(bridge_channel);
+		enqueue_bridge_state_change(bridge_channel, state);
 		ast_cond_signal(&bridge_channel->cond);
 		ao2_unlock(bridge_channel);
+	} else {
+		enqueue_bridge_state_change(bridge_channel, state);
 	}
 
 	return;
@@ -733,6 +773,21 @@
 	return 0;
 }
 
+/*! \internal \brief Get the latest state change request off of the queue
+ * \note The bridge_channel should be locked prior to calling this method */
+static enum ast_bridge_channel_state refresh_bridge_channel_state(struct ast_bridge_channel *bridge_channel)
+{
+	struct requested_bridge_state *requested_state = NULL;
+
+	requested_state = AST_LIST_REMOVE_HEAD(&bridge_channel->requested_states, entry);
+	if (requested_state) {
+		bridge_channel->state = requested_state->state;
+	}
+	ast_free(requested_state);
+
+	return bridge_channel->state;
+}
+
 /*! \brief Run in a multithreaded model. Each joined channel does writing/reading in their own thread. TODO: Improve */
 static enum ast_bridge_channel_state bridge_channel_join_multithreaded(struct ast_bridge_channel *bridge_channel)
 {
@@ -763,10 +818,16 @@
 	}
 
 	ao2_lock(bridge_channel->bridge);
-
 	if (!bridge_channel->suspended) {
 		ast_bridge_handle_trip(bridge_channel->bridge, bridge_channel, chan, outfd);
 	}
+	ao2_unlock(bridge_channel->bridge);
+
+	ao2_lock(bridge_channel);
+	refresh_bridge_channel_state(bridge_channel);
+	ao2_unlock(bridge_channel);
+
+	ao2_lock(bridge_channel->bridge);
 
 	return bridge_channel->state;
 }
@@ -780,6 +841,7 @@
 		ast_debug(1, "Going into a single threaded signal wait for bridge channel %p of bridge %p\n", bridge_channel, bridge_channel->bridge);
 		ast_cond_wait(&bridge_channel->cond, ao2_object_get_lockaddr(bridge_channel));
 	}
+	refresh_bridge_channel_state(bridge_channel);
 	ao2_unlock(bridge_channel);
 	ao2_lock(bridge_channel->bridge);
 
@@ -817,6 +879,44 @@
 
 
 	return;
+}
+
+/*!
+ * \internal
+ * \brief Internal function that executes a callback on a bridge channel
+ * \note Neither the bridge nor the bridge_channel locks should be held when entering
+ * this function.
+ */
+static void bridge_channel_call_deferred(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
+{
+	struct bridge_deferred_callback *deferred = NULL;
+
+	ao2_lock(bridge_channel);
+	deferred = AST_LIST_REMOVE_HEAD(&bridge_channel->deferreds, entry);
+	ao2_unlock(bridge_channel);
+
+	if (deferred) {
+		/* Execute the deferred */
+		deferred->deferred_cb(bridge, bridge_channel, deferred->pvt_data);
+
+		/* Clean up the private data */
+		if (deferred->pvt_destructor) {
+			deferred->pvt_destructor(deferred->pvt_data);
+		}
+		ast_free(deferred);
+
+		/* If we are handing the channel off to an external callback for ownership,
+		 * we are not guaranteed what kind of state it will come back in.  If
+		 * the channel hungup, we need to detect that here. */
+		if (bridge_channel->chan && ast_check_hangup_locked(bridge_channel->chan)) {
+			ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_END);
+		}
+	}
+
+	/* if the channel is still in deferred state, revert it back to wait state */
+	if (bridge_channel->state == AST_BRIDGE_CHANNEL_STATE_EXECUTE_DEFERRED) {
+		ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_WAIT);
+	}
 }
 
 /*!
@@ -1019,9 +1119,19 @@
 			bridge_channel_talking(bridge_channel->bridge, bridge_channel);
 			ao2_lock(bridge_channel->bridge);
 			break;
+		case AST_BRIDGE_CHANNEL_STATE_EXECUTE_DEFERRED:
+			bridge_channel_suspend(bridge_channel->bridge, bridge_channel);
+			ao2_unlock(bridge_channel->bridge);
+			bridge_channel_call_deferred(bridge_channel->bridge, bridge_channel);
+			ao2_lock(bridge_channel->bridge);
+			bridge_channel_unsuspend(bridge_channel->bridge, bridge_channel);
+			break;
 		default:
 			break;
 		}
+		ao2_lock(bridge_channel);
+		refresh_bridge_channel_state(bridge_channel);
+		ao2_unlock(bridge_channel);
 	}
 
 	ast_channel_internal_bridge_set(bridge_channel->chan, NULL);
@@ -1072,6 +1182,8 @@
 static void bridge_channel_destroy(void *obj)
 {
 	struct ast_bridge_channel *bridge_channel = obj;
+	struct bridge_deferred_callback *deferred;
+	struct requested_bridge_state *state;
 
 	if (bridge_channel->callid) {
 		bridge_channel->callid = ast_callid_unref(bridge_channel->callid);
@@ -1081,8 +1193,18 @@
 		ao2_ref(bridge_channel->bridge, -1);
 		bridge_channel->bridge = NULL;
 	}
+
 	/* Destroy elements of the bridge channel structure and the bridge channel structure itself */
 	ast_cond_destroy(&bridge_channel->cond);
+	while ((deferred = AST_LIST_REMOVE_HEAD(&bridge_channel->deferreds, entry))) {
+		if (deferred->pvt_destructor) {
+			deferred->pvt_destructor(deferred->pvt_data);
+		}
+		ast_free(deferred);
+	}
+	while ((state = AST_LIST_REMOVE_HEAD(&bridge_channel->requested_states, entry))) {
+		ast_free(state);
+	}
 }
 
 static struct ast_bridge_channel *bridge_channel_alloc(struct ast_bridge *bridge)
@@ -1497,6 +1619,49 @@
 
 	return 0;
 }
+
+int ast_bridge_issue_deferred(struct ast_bridge *bridge,
+	struct ast_channel *chan,
+	ast_bridge_deferred_callback deferred_cb,
+	void *pvt_data,
+	ast_bridge_deferred_callback_destructor pvt_destructor)
+{
+	struct ast_bridge_channel *bridge_channel = NULL;
+	struct bridge_deferred_callback *deferred;
+
+	if (pvt_data && !pvt_destructor) {
+		ast_log(AST_LOG_WARNING, "Deferred callback being issued in bridge %p with private data but no destructor\n", bridge);
+		return -1;
+	}
+
+	if (!(deferred = ast_calloc(1, sizeof(*deferred)))) {
+		ast_log(AST_LOG_WARNING, "Failed to create deferred callback container\n");
+		return -1;
+	}
+	deferred->deferred_cb = deferred_cb;
+	deferred->pvt_data = pvt_data;
+	deferred->pvt_destructor = pvt_destructor;
+
+	ao2_lock(bridge);
+
+	if (!(bridge_channel = find_bridge_channel(bridge, chan))) {
+		ao2_unlock(bridge);
+		ast_debug(1, "Unable to find channel %s in bridge %p\n", ast_channel_name(chan), bridge);
+		ast_free(deferred);
+		return -1;
+	}
+
+	ao2_lock(bridge_channel);
+	AST_LIST_INSERT_TAIL(&bridge_channel->deferreds, deferred, entry);
+	ao2_unlock(bridge_channel);
+
+	ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_EXECUTE_DEFERRED);
+
+	ao2_unlock(bridge);
+
+	return 0;
+}
+
 
 void ast_bridge_set_mixing_interval(struct ast_bridge *bridge, unsigned int mixing_interval)
 {

Added: team/mjordan/confbridgeactionexec/tests/test_bridging.c
URL: http://svnview.digium.com/svn/asterisk/team/mjordan/confbridgeactionexec/tests/test_bridging.c?view=auto&rev=371177
==============================================================================
--- team/mjordan/confbridgeactionexec/tests/test_bridging.c (added)
+++ team/mjordan/confbridgeactionexec/tests/test_bridging.c Sun Aug 12 15:54:27 2012
@@ -1,0 +1,781 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2012, Matt Jordan
+ *
+ * Matt Jordan <mjordan at 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 Unit tests for jitterbuf.c
+ *
+ * \author\verbatim Matt Jordan <mjordan at 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/utils.h"
+#include "asterisk/module.h"
+#include "asterisk/test.h"
+#include "asterisk/channel.h"
+#include "asterisk/bridging.h"
+#include "asterisk/bridging_technology.h"
+
+/*! \internal \brief Verify the expected result from two integer values.  Note
+ * that it assumes the mailbox snapshot object is test_mbox_snapshot */
+#define ASSERT_EQUAL(expected, actual) do { \
+	if ((expected) == (actual)) { \
+		ast_test_status_update(test, "Test failed for %s: Expected [%d], Actual [%d]\n", #actual, expected, actual); \
+		return AST_TEST_FAIL; \
+	} } while (0)
+
+#define AST_BRIDGE_CAPABILITY_TEST (1 << 31)
+
+static int mock_bridge_create(struct ast_bridge *bridge);
+static int mock_bridge_destroy(struct ast_bridge *bridge);
+static int mock_bridge_join(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel);
+static int mock_bridge_leave(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel);
+static void mock_bridge_suspend(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel);
+static void mock_bridge_unsuspend(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel);
+static int mock_bridge_compatible(struct ast_bridge_channel *bridge_channel);
+static enum ast_bridge_write_result mock_bridge_write(struct ast_bridge *bridge, struct ast_bridge_channel *bridged_channel, struct ast_frame *frame);
+
+static int mock_channel_write(struct ast_channel *ast, struct ast_frame *frame);
+static struct ast_frame *mock_channel_read(struct ast_channel *ast);
+
+struct bridge_callback_tracking {
+	unsigned int create_calls;
+	unsigned int destroy_calls;
+	unsigned int join_calls;
+	unsigned int leave_calls;
+	unsigned int suspend_calls;
+	unsigned int unsuspend_calls;
+	unsigned int compatible_calls;
+	unsigned int write_calls;
+};
+
+struct mock_channel_pvt {
+	struct ast_test *test;
+};
+
+static struct bridge_callback_tracking test_tracker;
+
+static struct ast_bridge_technology mock_bridge_tech = {
+	.name = "mock_bridge_tech",
+	.capabilities = 0,	/* This should be set by the specific test */
+	.preference = AST_BRIDGE_PREFERENCE_HIGH,
+	.create = mock_bridge_create,
+	.destroy = mock_bridge_destroy,
+	.join = mock_bridge_join,
+	.leave = mock_bridge_leave,
+	.suspend = mock_bridge_suspend,
+	.unsuspend = mock_bridge_unsuspend,
+	.compatible = mock_bridge_compatible,
+	.write = mock_bridge_write,
+};
+
+static struct ast_channel_tech mock_channel_tech = {
+	.type = "mock",
+	.read = mock_channel_read,
+	.write = mock_channel_write,
+};
+
+static void reset_test_tracking(void)
+{
+	test_tracker.create_calls = 0;
+	test_tracker.destroy_calls = 0;
+	test_tracker.join_calls = 0;
+	test_tracker.leave_calls = 0;
+	test_tracker.suspend_calls = 0;
+	test_tracker.unsuspend_calls = 0;
+	test_tracker.compatible_calls = 0;
+	test_tracker.write_calls = 0;
+}
+
+static int mock_bridge_create(struct ast_bridge *bridge)
+{
+	test_tracker.create_calls++;
+	return 0;
+}
+
+static int mock_bridge_destroy(struct ast_bridge *bridge)
+{
+	test_tracker.destroy_calls++;
+	return 0;
+}
+
+static int mock_bridge_join(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
+{
+	test_tracker.join_calls++;
+	return 0;
+}
+
+static int mock_bridge_leave(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
+{
+	test_tracker.leave_calls++;
+	return 0;
+}
+
+static void mock_bridge_suspend(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
+{
+	test_tracker.suspend_calls++;
+}
+
+static void mock_bridge_unsuspend(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
+{
+	test_tracker.unsuspend_calls++;
+}
+
+static int mock_bridge_compatible(struct ast_bridge_channel *bridge_channel)
+{
+	test_tracker.compatible_calls++;
+	return 0;
+}
+
+static enum ast_bridge_write_result mock_bridge_write(struct ast_bridge *bridge, struct ast_bridge_channel *bridged_channel, struct ast_frame *frame)
+{
+	test_tracker.write_calls++;
+	return AST_BRIDGE_WRITE_SUCCESS;
+}
+
+static void mock_tech_cleanup(struct ast_bridge_technology *tech)
+{
+	if (!tech) {
+		return;
+	}
+
+	reset_test_tracking();
+
+	/* A test must set its capabilities - reset during cleanup */
+	tech->capabilities = 0;
+
+	ast_bridge_technology_unregister(tech);
+}
+
+static void bridge_destructor(struct ast_bridge *bridge)
+{
+	if (!bridge) {
+		return;
+	}
+	ast_bridge_destroy(bridge);
+}
+
+static struct ast_channel *create_mock_channel(struct ast_test *test)
+{
+	struct ast_channel *chan;
+	struct ast_format_cap *nativeformats;
+	struct mock_channel_pvt *pvt;
+
+	if (!(pvt = ast_calloc(1, sizeof(*pvt)))) {
+		return NULL;
+	}
+	pvt->test = test;
+
+	if (!(chan = ast_channel_alloc(0, AST_STATE_DOWN, NULL, NULL, NULL,
+		NULL, NULL, 0, 0, "MockChannel"))) {
+		ast_free(pvt);
+		return NULL;
+	}
+	ast_channel_tech_set(chan, &mock_channel_tech);
+	ast_channel_tech_pvt_set(chan, pvt);
+
+	/*	ast_format_set(ast_channel_writeformat(chan), AST_FORMAT_GSM, 0);
+	nativeformats = ast_channel_nativeformats(chan);
+	ast_format_cap_add(nativeformats, ast_channel_writeformat(chan));
+	ast_format_set(ast_channel_rawwriteformat(chan), AST_FORMAT_GSM, 0);
+	ast_format_set(ast_channel_readformat(chan), AST_FORMAT_GSM, 0);
+	ast_format_set(ast_channel_rawreadformat(chan), AST_FORMAT_GSM, 0);*/
+
+
+
+	return chan;
+}
+
+static int mock_channel_write(struct ast_channel *ast, struct ast_frame *frame)
+{
+	return 0;
+}
+
+static struct ast_frame *mock_channel_read(struct ast_channel *ast)
+{
+	struct ast_frame *frame;
+
+	frame = &ast_null_frame;
+
+	return frame;
+}
+
+/* Things to test
+ * ast_bridge_new - get back bridge that you expect based on capabilities.
+ * 	also test ast_bridge_destroy
+ * ast_bridge_check - check if bridge technologies exist.  Nominal / off-nominal
+ * ast_bridge_join: BLOCKING OPERATIONS.  Will need a specific way of doing this
+ *   that does the join and returns success/failure on separate threads of execution.
+ * 		Simple test - make sure you can join in
+ * 		Swap test - join a channel, make another new channel, and swap it out
+ * 		*** IGNORE FEATURES FOR NOW - probably belong in separate tests ***
+ * ast_bridge_impart - same tests.  Will also need to test ast_bridge_depart with this.
+ * ast_bridge_remove: test with:
+ * 		ast_bridge_join
+ * 		ast_bridge_impart
+ * ast_bridge_merge - test merging empty bridge into non-empty, non-empty into empty, and
+ *   two populated
+ * ast_bridge_suspend/unsuspend
+ * ast_bridge_issue_deferred: callback.  test with nominal / off-nominal data.
+
+	Note that more unit tests could be written, but blah.
+ */
+
+AST_TEST_DEFINE(bridging_issue_deferred_off_nominal)
+{
+	enum ast_test_result_state result = AST_TEST_FAIL;
+
+	switch (cmd) {
+	case TEST_INIT:
+		info->name = "bridging_issue_deferred_off_nominal";
+		info->category = "/main/bridging/";
+		info->summary = "";
+		info->description =
+			"";
+		return AST_TEST_NOT_RUN;
+	case TEST_EXECUTE:
+		break;
+	}
+	mock_channel_thread(NULL);
+
+	return result;
+}
+
+AST_TEST_DEFINE(bridging_issue_deferred_chain)
+{
+	enum ast_test_result_state result = AST_TEST_FAIL;
+
+	switch (cmd) {
+	case TEST_INIT:
+		info->name = "bridging_issue_deferred_chain";
+		info->category = "/main/bridging/";
+		info->summary = "";
+		info->description =
+			"";
+		return AST_TEST_NOT_RUN;
+	case TEST_EXECUTE:
+		break;
+	}
+
+	return result;
+}
+
+AST_TEST_DEFINE(bridging_issue_deferred_nominal)
+{
+	enum ast_test_result_state result = AST_TEST_FAIL;
+
+	switch (cmd) {
+	case TEST_INIT:
+		info->name = "bridging_issue_deferred_nominal";
+		info->category = "/main/bridging/";
+		info->summary = "";
+		info->description =
+			"";
+		return AST_TEST_NOT_RUN;
+	case TEST_EXECUTE:
+		break;
+	}
+
+	return result;
+}
+
+AST_TEST_DEFINE(bridging_suspend_unsuspend_off_nominal)
+{
+	enum ast_test_result_state result = AST_TEST_FAIL;
+
+	switch (cmd) {
+	case TEST_INIT:
+		info->name = "bridging_suspend_unsuspend_off_nominal";
+		info->category = "/main/bridging/";
+		info->summary = "";
+		info->description =
+			"";
+		return AST_TEST_NOT_RUN;
+	case TEST_EXECUTE:
+		break;
+	}
+
+	return result;
+}
+
+AST_TEST_DEFINE(bridging_suspend_unsuspend_nominal)
+{
+	enum ast_test_result_state result = AST_TEST_FAIL;
+
+	switch (cmd) {
+	case TEST_INIT:
+		info->name = "bridging_suspend_unsuspend_nominal";
+		info->category = "/main/bridging/";
+		info->summary = "";
+		info->description =
+			"";
+		return AST_TEST_NOT_RUN;
+	case TEST_EXECUTE:
+		break;
+	}
+
+	return result;
+}
+
+AST_TEST_DEFINE(bridging_merge_off_nominal)
+{
+	enum ast_test_result_state result = AST_TEST_FAIL;
+
+	switch (cmd) {
+	case TEST_INIT:
+		info->name = "bridging_merge_off_nominal";
+		info->category = "/main/bridging/";
+		info->summary = "";
+		info->description =
+			"";
+		return AST_TEST_NOT_RUN;
+	case TEST_EXECUTE:
+		break;
+	}
+
+	return result;
+}
+
+AST_TEST_DEFINE(bridging_merge_nominal)
+{
+	enum ast_test_result_state result = AST_TEST_FAIL;
+
+	switch (cmd) {
+	case TEST_INIT:
+		info->name = "bridging_merge_nominal";
+		info->category = "/main/bridging/";
+		info->summary = "";
+		info->description =
+			"";
+		return AST_TEST_NOT_RUN;
+	case TEST_EXECUTE:
+		break;
+	}
+
+	return result;
+}
+
+AST_TEST_DEFINE(bridging_remove_off_nominal)
+{
+	enum ast_test_result_state result = AST_TEST_FAIL;
+
+	switch (cmd) {
+	case TEST_INIT:
+		info->name = "bridging_remove_off_nominal";
+		info->category = "/main/bridging/";
+		info->summary = "";
+		info->description =
+			"";
+		return AST_TEST_NOT_RUN;
+	case TEST_EXECUTE:
+		break;
+	}
+
+	return result;
+}
+
+AST_TEST_DEFINE(bridging_remove_imparted)
+{
+	enum ast_test_result_state result = AST_TEST_FAIL;
+
+	switch (cmd) {
+	case TEST_INIT:
+		info->name = "bridging_remove_imparted";
+		info->category = "/main/bridging/";
+		info->summary = "";
+		info->description =
+			"";
+		return AST_TEST_NOT_RUN;
+	case TEST_EXECUTE:
+		break;
+	}
+
+	return result;
+}
+
+AST_TEST_DEFINE(bridging_remove_joined)
+{
+	enum ast_test_result_state result = AST_TEST_FAIL;
+
+	switch (cmd) {
+	case TEST_INIT:
+		info->name = "bridging_remove_joined";
+		info->category = "/main/bridging/";
+		info->summary = "";
+		info->description =
+			"";
+		return AST_TEST_NOT_RUN;
+	case TEST_EXECUTE:
+		break;
+	}
+
+	return result;
+}
+
+AST_TEST_DEFINE(bridging_impart_off_nominal)
+{
+	enum ast_test_result_state result = AST_TEST_FAIL;
+
+	switch (cmd) {
+	case TEST_INIT:
+		info->name = "bridging_impart_off_nominal";
+		info->category = "/main/bridging/";
+		info->summary = "";
+		info->description =
+			"";
+		return AST_TEST_NOT_RUN;
+	case TEST_EXECUTE:
+		break;
+	}
+
+	return result;
+}
+
+AST_TEST_DEFINE(bridging_impart_swap)
+{
+	enum ast_test_result_state result = AST_TEST_FAIL;
+
+	switch (cmd) {
+	case TEST_INIT:
+		info->name = "bridging_impart_swap";
+		info->category = "/main/bridging/";
+		info->summary = "";
+		info->description =
+			"";
+		return AST_TEST_NOT_RUN;
+	case TEST_EXECUTE:
+		break;
+	}
+
+	return result;
+}
+
+AST_TEST_DEFINE(bridging_impart_simple)
+{
+	enum ast_test_result_state result = AST_TEST_FAIL;
+
+	switch (cmd) {
+	case TEST_INIT:
+		info->name = "bridging_impart_simple";
+		info->category = "/main/bridging/";
+		info->summary = "";
+		info->description =
+			"";
+		return AST_TEST_NOT_RUN;
+	case TEST_EXECUTE:
+		break;
+	}
+
+	return result;
+}
+
+AST_TEST_DEFINE(bridging_join_off_nominal)
+{
+	enum ast_test_result_state result = AST_TEST_FAIL;
+
+	switch (cmd) {
+	case TEST_INIT:
+		info->name = "bridging_join_off_nominal";
+		info->category = "/main/bridging/";
+		info->summary = "";
+		info->description =
+			"";
+		return AST_TEST_NOT_RUN;
+	case TEST_EXECUTE:
+		break;
+	}
+
+	return result;
+}
+
+AST_TEST_DEFINE(bridging_join_swap)
+{
+	enum ast_test_result_state result = AST_TEST_FAIL;
+
+	switch (cmd) {
+	case TEST_INIT:
+		info->name = "bridging_join_swap";
+		info->category = "/main/bridging/";
+		info->summary = "";
+		info->description =
+			"";
+		return AST_TEST_NOT_RUN;
+	case TEST_EXECUTE:
+		break;
+	}
+
+	return result;
+}
+
+static void bridging_join_simple_mock_channel_thread(void *data)
+{
+	struct ast_channel *mock_channel = data;
+	struct mock_channel_pvt *pvt;
+	RAII_VAR(struct ast_bridge *, bridge, ast_bridge_new(AST_BRIDGE_CAPABILITY_TEST, 0), bridge_destructor);
+	enum ast_bridge_channel_state final_state;
+
+	if (!mock_channel) {
+		return;
+	}
+	pvt = ast_channel_tech_pvt(mock_channel);
+
+	if (!bridge) {
+		ast_test_status_update(pvt->test, "Unable to obtain bridge for bridging_join_simple\n");
+		return;
+	}
+
+	final_state = ast_bridge_join(bridge, mock_channel, NULL, NULL, NULL);
+}
+
+AST_TEST_DEFINE(bridging_join_simple)
+{
+	RAII_VAR(struct ast_bridge_technology *, mock_tech, &mock_bridge_tech, mock_tech_cleanup);
+	RAII_VAR(struct ast_channel *, mock_channel, NULL, ao2_cleanup);
+	struct mock_channel_pvt *pvt;
+	pthread_t test_thread;
+
+	switch (cmd) {
+	case TEST_INIT:
+		info->name = "bridging_join_simple";
+		info->category = "/main/bridging/";
+		info->summary = "";
+		info->description =
+			"";
+		return AST_TEST_NOT_RUN;
+	case TEST_EXECUTE:
+		break;
+	}
+
+	mock_tech->capabilities = AST_BRIDGE_CAPABILITY_TEST;
+	ast_bridge_technology_register(mock_tech);
+

[... 218 lines stripped ...]



More information about the asterisk-commits mailing list