static void send_subscription_unsubscribe(struct stasis_topic *topic,
struct stasis_subscription *sub)
{
struct stasis_subscription_change *change;
struct stasis_message *msg;
/* This assumes that we have already unsubscribed */
ast_assert(!stasis_subscription_is_subscribed(sub));
if (!stasis_subscription_change_type()) {
return;
}
change = subscription_change_alloc(topic, sub->uniqueid, "Unsubscribe");
if (!change) {
return;
}
msg = stasis_message_create(stasis_subscription_change_type(), change);
if (!msg) {
ao2_cleanup(change);
return;
}
stasis_publish(topic, msg);
/* Now we have to dispatch to the subscription itself */
dispatch_message(sub, msg, 0);
ao2_cleanup(msg);
ao2_cleanup(change);
}
struct stasis_caching_topic *stasis_caching_unsubscribe(struct stasis_caching_topic *caching_topic)
{
if (!caching_topic) {
return NULL;
}
/*
* The subscription may hold the last reference to this caching
* topic, but we want to make sure the unsubscribe finishes
* before kicking of the caching topic's dtor.
*/
ao2_ref(caching_topic, +1);
if (stasis_subscription_is_subscribed(caching_topic->sub)) {
/*
* Increment the reference to hold on to it past the
* unsubscribe. Will be cleaned up in dtor.
*/
ao2_ref(caching_topic->sub, +1);
stasis_unsubscribe(caching_topic->sub);
} else {
ast_log(LOG_ERROR, "stasis_caching_topic unsubscribed multiple times\n");
}
ao2_cleanup(caching_topic);
return NULL;
}
static void router_dtor(void *obj)
{
struct stasis_message_router *router = obj;
ast_assert(!stasis_subscription_is_subscribed(router->subscription));
ast_assert(stasis_subscription_is_done(router->subscription));
router->subscription = NULL;
route_table_dtor(&router->routes);
route_table_dtor(&router->cache_routes);
}
static void subscription_dtor(void *obj)
{
struct stasis_subscription *sub = obj;
/* Subscriptions need to be manually unsubscribed before destruction
* b/c there's a cyclic reference between topics and subscriptions */
ast_assert(!stasis_subscription_is_subscribed(sub));
/* If there are any messages in flight to this subscription; that would
* be bad. */
ast_assert(stasis_subscription_is_done(sub));
ao2_cleanup(sub->topic);
sub->topic = NULL;
ast_taskprocessor_unreference(sub->mailbox);
sub->mailbox = NULL;
ast_cond_destroy(&sub->join_cond);
}
static void stasis_caching_topic_dtor(void *obj) {
struct stasis_caching_topic *caching_topic = obj;
/* Caching topics contain subscriptions, and must be manually
* unsubscribed. */
ast_assert(!stasis_subscription_is_subscribed(caching_topic->sub));
/* If there are any messages in flight to this subscription; that would
* be bad. */
ast_assert(stasis_subscription_is_done(caching_topic->sub));
ao2_cleanup(caching_topic->sub);
caching_topic->sub = NULL;
ao2_cleanup(caching_topic->cache);
caching_topic->cache = NULL;
ao2_cleanup(caching_topic->topic);
caching_topic->topic = NULL;
ao2_cleanup(caching_topic->original_topic);
caching_topic->original_topic = NULL;
}
