stasis_message_router.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2013, Digium, Inc.
 *
 * David M. Lee, II <[email protected]>
 *
 * 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 message router implementation.
 *
 * \author David M. Lee, II <[email protected]>
 */

/*** MODULEINFO
   <support_level>core</support_level>
 ***/

#include "asterisk.h"

#include "asterisk/astobj2.h"
#include "asterisk/stasis_message_router.h"
#include "asterisk/vector.h"

/*! \internal */
struct stasis_message_route {
   /*! Message type handle by this route. */
   struct stasis_message_type *message_type;
   /*! Callback function for incoming message processing. */
   stasis_subscription_cb callback;
   /*! Data pointer to be handed to the callback. */
   void *data;
};

AST_VECTOR(route_table, struct stasis_message_route);

static struct stasis_message_route *route_table_find(struct route_table *table,
   struct stasis_message_type *message_type)
{
   size_t idx;
   struct stasis_message_route *route;

   /* While a linear search for routes may seem very inefficient, most
    * route tables have six routes or less. For such small data, it's
    * hard to beat a linear search. If we start having larger route
    * tables, then we can look into containers with more efficient
    * lookups.
    */
   for (idx = 0; idx < AST_VECTOR_SIZE(table); ++idx) {
      route = AST_VECTOR_GET_ADDR(table, idx);
      if (route->message_type == message_type) {
         return route;
      }
   }

   return NULL;
}

/*!
 * \brief route_table comparator for AST_VECTOR_REMOVE_CMP_UNORDERED()
 *
 * \param elem Element to compare against
 * \param value Value to compare with the vector element.
 *
 * \return 0 if element does not match.
 * \return Non-zero if element matches.
 */
#define ROUTE_TABLE_ELEM_CMP(elem, value) ((elem).message_type == (value))

/*!
 * \brief route_table vector element cleanup.
 *
 * \param elem Element to cleanup
 *
 * \return Nothing
 */
#define ROUTE_TABLE_ELEM_CLEANUP(elem)  ao2_cleanup((elem).message_type)

static int route_table_remove(struct route_table *table,
   struct stasis_message_type *message_type)
{
   return AST_VECTOR_REMOVE_CMP_UNORDERED(table, message_type, ROUTE_TABLE_ELEM_CMP,
      ROUTE_TABLE_ELEM_CLEANUP);
}

static int route_table_add(struct route_table *table,
   struct stasis_message_type *message_type,
   stasis_subscription_cb callback, void *data)
{
   struct stasis_message_route route;
   int res;

   ast_assert(callback != NULL);
   ast_assert(route_table_find(table, message_type) == NULL);

   route.message_type = ao2_bump(message_type);
   route.callback = callback;
   route.data = data;

   res = AST_VECTOR_APPEND(table, route);
   if (res) {
      ROUTE_TABLE_ELEM_CLEANUP(route);
   }
   return res;
}

static void route_table_dtor(struct route_table *table)
{
   size_t idx;
   struct stasis_message_route *route;

   for (idx = 0; idx < AST_VECTOR_SIZE(table); ++idx) {
      route = AST_VECTOR_GET_ADDR(table, idx);
      ROUTE_TABLE_ELEM_CLEANUP(*route);
   }
   AST_VECTOR_FREE(table);
}

/*! \internal */
struct stasis_message_router {
   /*! Subscription to the upstream topic */
   struct stasis_subscription *subscription;
   /*! Subscribed routes */
   struct route_table routes;
   /*! Subscribed routes for \ref stasis_cache_update messages */
   struct route_table cache_routes;
   /*! Route of last resort */
   struct stasis_message_route default_route;
};

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 int find_route(
   struct stasis_message_router *router,
   struct stasis_message *message,
   struct stasis_message_route *route_out)
{
   struct stasis_message_route *route = NULL;
   struct stasis_message_type *type = stasis_message_type(message);
   SCOPED_AO2LOCK(lock, router);

   ast_assert(route_out != NULL);

   if (type == stasis_cache_update_type()) {
      /* Find a cache route */
      struct stasis_cache_update *update =
         stasis_message_data(message);
      route = route_table_find(&router->cache_routes, update->type);
   }

   if (route == NULL) {
      /* Find a regular route */
      route = route_table_find(&router->routes, type);
   }

   if (route == NULL && router->default_route.callback) {
      /* Maybe the default route, then? */
      route = &router->default_route;
   }

   if (!route) {
      return -1;
   }

   *route_out = *route;
   return 0;
}

static void router_dispatch(void *data,
             struct stasis_subscription *sub,
             struct stasis_message *message)
{
   struct stasis_message_router *router = data;
   struct stasis_message_route route;

   if (find_route(router, message, &route) == 0) {
      route.callback(route.data, sub, message);
   }

   if (stasis_subscription_final_message(sub, message)) {
      ao2_cleanup(router);
   }
}

static struct stasis_message_router *stasis_message_router_create_internal(
   struct stasis_topic *topic, int use_thread_pool, const char *file, int lineno,
   const char *func)
{
   int res;
   struct stasis_message_router *router;

   router = ao2_t_alloc(sizeof(*router), router_dtor, stasis_topic_name(topic));
   if (!router) {
      return NULL;
   }

   res = 0;
   res |= AST_VECTOR_INIT(&router->routes, 0);
   res |= AST_VECTOR_INIT(&router->cache_routes, 0);
   if (res) {
      ao2_ref(router, -1);

      return NULL;
   }

   if (use_thread_pool) {
      router->subscription = __stasis_subscribe_pool(topic, router_dispatch, router, file, lineno, func);
   } else {
      router->subscription = __stasis_subscribe(topic, router_dispatch, router, file, lineno, func);
   }

   if (!router->subscription) {
      ao2_ref(router, -1);

      return NULL;
   }

   /* We need to receive subscription change messages so we know when our subscription goes away */
   stasis_subscription_accept_message_type(router->subscription, stasis_subscription_change_type());

   return router;
}

struct stasis_message_router *__stasis_message_router_create(
   struct stasis_topic *topic, const char *file, int lineno, const char *func)
{
   return stasis_message_router_create_internal(topic, 0, file, lineno, func);
}

struct stasis_message_router *__stasis_message_router_create_pool(
   struct stasis_topic *topic, const char *file, int lineno, const char *func)
{
   return stasis_message_router_create_internal(topic, 1, file, lineno, func);
}

void stasis_message_router_unsubscribe(struct stasis_message_router *router)
{
   if (!router) {
      return;
   }

   ao2_lock(router);
   router->subscription = stasis_unsubscribe(router->subscription);
   ao2_unlock(router);
}

void stasis_message_router_unsubscribe_and_join(
   struct stasis_message_router *router)
{
   if (!router) {
      return;
   }
   stasis_unsubscribe_and_join(router->subscription);
}

int stasis_message_router_is_done(struct stasis_message_router *router)
{
   if (!router) {
      /* Null router is about as done as you can get */
      return 1;
   }

   return stasis_subscription_is_done(router->subscription);
}

void stasis_message_router_publish_sync(struct stasis_message_router *router,
   struct stasis_message *message)
{
   ast_assert(router != NULL);

   ao2_bump(router);
   stasis_publish_sync(router->subscription, message);
   ao2_cleanup(router);
}

int stasis_message_router_set_congestion_limits(struct stasis_message_router *router,
   long low_water, long high_water)
{
   int res = -1;

   if (router) {
      res = stasis_subscription_set_congestion_limits(router->subscription,
         low_water, high_water);
   }
   return res;
}

int stasis_message_router_add(struct stasis_message_router *router,
   struct stasis_message_type *message_type,
   stasis_subscription_cb callback, void *data)
{
   int res;

   ast_assert(router != NULL);

   if (!message_type) {
      /* Cannot route to NULL type. */
      return -1;
   }
   ao2_lock(router);
   res = route_table_add(&router->routes, message_type, callback, data);
   if (!res) {
      stasis_subscription_accept_message_type(router->subscription, message_type);
      /* Until a specific message type was added we would already drop the message, so being
       * selective now doesn't harm us. If we have a default route then we are already forced
       * to filter nothing and messages will come in regardless.
       */
      stasis_subscription_set_filter(router->subscription, STASIS_SUBSCRIPTION_FILTER_SELECTIVE);
   }
   ao2_unlock(router);
   return res;
}

int stasis_message_router_add_cache_update(struct stasis_message_router *router,
   struct stasis_message_type *message_type,
   stasis_subscription_cb callback, void *data)
{
   int res;

   ast_assert(router != NULL);

   if (!message_type) {
      /* Cannot cache a route to NULL type. */
      return -1;
   }
   ao2_lock(router);
   res = route_table_add(&router->cache_routes, message_type, callback, data);
   if (!res) {
      stasis_subscription_accept_message_type(router->subscription, stasis_cache_update_type());
      stasis_subscription_set_filter(router->subscription, STASIS_SUBSCRIPTION_FILTER_SELECTIVE);
   }
   ao2_unlock(router);
   return res;
}

void stasis_message_router_remove(struct stasis_message_router *router,
   struct stasis_message_type *message_type)
{
   ast_assert(router != NULL);

   if (!message_type) {
      /* Cannot remove a NULL type. */
      return;
   }
   ao2_lock(router);
   route_table_remove(&router->routes, message_type);
   ao2_unlock(router);
}

void stasis_message_router_remove_cache_update(
   struct stasis_message_router *router,
   struct stasis_message_type *message_type)
{
   ast_assert(router != NULL);

   if (!message_type) {
      /* Cannot remove a NULL type. */
      return;
   }
   ao2_lock(router);
   route_table_remove(&router->cache_routes, message_type);
   ao2_unlock(router);
}

int stasis_message_router_set_default(struct stasis_message_router *router,
   stasis_subscription_cb callback,
   void *data)
{
   stasis_message_router_set_formatters_default(router, callback, data, STASIS_SUBSCRIPTION_FORMATTER_NONE);

   /* While this implementation can never fail, it used to be able to */
   return 0;
}

void stasis_message_router_set_formatters_default(struct stasis_message_router *router,
   stasis_subscription_cb callback,
   void *data,
   enum stasis_subscription_message_formatters formatters)
{
   ast_assert(router != NULL);
   ast_assert(callback != NULL);

   stasis_subscription_accept_formatters(router->subscription, formatters);

   ao2_lock(router);
   router->default_route.callback = callback;
   router->default_route.data = data;
   ao2_unlock(router);

   if (formatters == STASIS_SUBSCRIPTION_FORMATTER_NONE) {
      /* Formatters govern what messages the default callback get, so it is only if none is
       * specified that we accept all messages regardless.
       */
      stasis_subscription_set_filter(router->subscription, STASIS_SUBSCRIPTION_FILTER_FORCED_NONE);
   }
}

void stasis_message_router_accept_formatters(struct stasis_message_router *router,
   enum stasis_subscription_message_formatters formatters)
{
   ast_assert(router != NULL);

   stasis_subscription_accept_formatters(router->subscription, formatters);

   return;
}