command.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 application command support.
 *
 * \author David M. Lee, II <[email protected]>
 */

#include "asterisk.h"

#include "command.h"

#include "asterisk/lock.h"
#include "asterisk/stasis_app_impl.h"

struct stasis_app_command {
   ast_mutex_t lock;
   ast_cond_t condition;
   stasis_app_command_cb callback;
   void *data;
   command_data_destructor_fn data_destructor;
   int retval;
   unsigned int is_done:1;
};

static void command_dtor(void *obj)
{
   struct stasis_app_command *command = obj;

   if (command->data_destructor) {
      command->data_destructor(command->data);
   }

   ast_mutex_destroy(&command->lock);
   ast_cond_destroy(&command->condition);
}

struct stasis_app_command *command_create(
   stasis_app_command_cb callback, void *data, command_data_destructor_fn data_destructor)
{
   struct stasis_app_command *command;

   command = ao2_alloc(sizeof(*command), command_dtor);
   if (!command) {
      if (data_destructor) {
         data_destructor(data);
      }
      return NULL;
   }

   ast_mutex_init(&command->lock);
   ast_cond_init(&command->condition, 0);
   command->callback = callback;
   command->data = data;
   command->data_destructor = data_destructor;

   return command;
}

void command_complete(struct stasis_app_command *command, int retval)
{
   ast_mutex_lock(&command->lock);
   command->is_done = 1;
   command->retval = retval;
   ast_cond_signal(&command->condition);
   ast_mutex_unlock(&command->lock);
}

int command_join(struct stasis_app_command *command)
{
   int ret;

   ast_mutex_lock(&command->lock);
   while (!command->is_done) {
      ast_cond_wait(&command->condition, &command->lock);
   }

   ret = command->retval;
   ast_mutex_unlock(&command->lock);

   return ret;
}

void command_invoke(struct stasis_app_command *command,
   struct stasis_app_control *control, struct ast_channel *chan)
{
   int retval = command->callback(control, chan, command->data);
   if (command->data_destructor) {
      command->data_destructor(command->data);
      command->data_destructor = NULL;
   }
   command_complete(command, retval);
}

static void command_queue_prestart_destroy(void *obj)
{
   /* Clean up the container */
   ao2_cleanup(obj);
}

static const struct ast_datastore_info command_queue_prestart = {
   .type = "stasis-command-prestart-queue",
   .destroy = command_queue_prestart_destroy,
};

int command_prestart_queue_command(struct ast_channel *chan,
   stasis_app_command_cb command_fn, void *data, command_data_destructor_fn data_destructor)
{
   struct ast_datastore *datastore;
   struct ao2_container *command_queue;
   RAII_VAR(struct stasis_app_command *, command,
      command_create(command_fn, data, data_destructor), ao2_cleanup);

   if (!command) {
      return -1;
   }

   datastore = ast_channel_datastore_find(chan, &command_queue_prestart, NULL);
   if (datastore) {
      command_queue = datastore->data;
      ao2_link(command_queue, command);
      return 0;
   }

   command_queue = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL);
   if (!command_queue) {
      return -1;
   }

   datastore = ast_datastore_alloc(&command_queue_prestart, NULL);
   if (!datastore) {
      ao2_cleanup(command_queue);
      return -1;
   }
   ast_channel_datastore_add(chan, datastore);

   datastore->data = command_queue;
   ao2_link(command_queue, command);

   return 0;
}

struct ao2_container *command_prestart_get_container(struct ast_channel *chan)
{
   struct ast_datastore *datastore = ast_channel_datastore_find(chan, &command_queue_prestart, NULL);

   if (!datastore) {
      return NULL;
   }

   return ao2_bump(datastore->data);
}