mirror of http://gerrit.asterisk.org/asterisk
This commit merges in the rest of the code needed to support distributed device state. There are two main parts to this commit. Core changes: - The device state handling in the core has been updated to understand device state across a cluster of Asterisk servers. Every time the state of a device changes, it looks at all of the device states on each node, and determines the aggregate device state. That resulting device state is what is provided to modules in Asterisk that take actions based on the state of a device. New module, res_ais: - A module has been written to facilitate the communication of events between nodes in a cluster of Asterisk servers. This module uses the SAForum AIS (Service Availability Forum Application Interface Specification) CLM and EVT services (Cluster Management and Event) to handle this task. This module currently supports sharing Voicemail MWI (Message Waiting Indication) and device state events between servers. It has been tested with openais, though other implementations of the spec do exist. For more information on testing distributed device state, see the following doc: - doc/distributed_devstate.txt git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@121559 65c4cc65-6c06-0410-ace0-fbb531ad65f31.6.1
Russell Bryant
17 years ago
parent
823d1c7ea9
commit
e9d72e0cb2
@ -0,0 +1,76 @@
|
||||
;
|
||||
; Sample configuration file for res_ais
|
||||
; * SAForum AIS (Application Interface Specification)
|
||||
;
|
||||
; More information on the AIS specification is available from the SAForum.
|
||||
; * http://www.saforum.org/
|
||||
;
|
||||
; A nice open source implementation of AIS is available called openais. Visit
|
||||
; the openais website for downloads and more information.
|
||||
; * http://www.openais.org/
|
||||
;
|
||||
|
||||
;
|
||||
; [general]
|
||||
; The general section is reserved but not currently used.
|
||||
;
|
||||
|
||||
;
|
||||
; Event channels are named distributed groups that share events. Each node
|
||||
; that is the member of the event channel should have an entry in their
|
||||
; ais.conf file that indicates that they are a member of the event channel.
|
||||
; Each node's entry for the event channel also indicates which event types
|
||||
; will be published to other nodes, as well as which event types this node
|
||||
; will subscribe to from other nodes in the event channel.
|
||||
;
|
||||
; The name of the event channel is the name in brackets that begin a section
|
||||
; in the configuration file.
|
||||
; [mwi]
|
||||
;
|
||||
; To define an event channel, this entry must be in the configuration section:
|
||||
; type=event_channel
|
||||
;
|
||||
; Indicate that a node is capable of publishing events of a certain type by
|
||||
; using the publish_event directive.
|
||||
; publish_event=mwi
|
||||
;
|
||||
; Indicate that a node is interested in receiving events of a certain type
|
||||
; from other nodes in the event channel by using the subscribe_event directive.
|
||||
; subscribe_event=mwi
|
||||
;
|
||||
; Supported event types include: mwi, device_state
|
||||
;
|
||||
|
||||
;
|
||||
; This example is for a node that can provide MWI state information, but should
|
||||
; also be listening for MWI state changes from other nodes. Examples of when
|
||||
; this would be used are when this is both a voicemail server and also has
|
||||
; phones directly registered to it.
|
||||
;
|
||||
; [mwi]
|
||||
; type=event_channel
|
||||
; publish_event=mwi
|
||||
; subscribe_event=mwi
|
||||
;
|
||||
|
||||
;
|
||||
; This example would be used for a node that can provide MWI state to other
|
||||
; nodes, but does not need to know about MWI state changes that happen on
|
||||
; any other node. This would most likely be a voicemail server where no
|
||||
; phones are directly registered.
|
||||
;
|
||||
; [mwi]
|
||||
; type=event_channel
|
||||
; publish_event=mwi
|
||||
;
|
||||
|
||||
;
|
||||
; This example would be used for a node that has phones directly registered
|
||||
; to it, but does not have direct access to voicemail. So, this node wants
|
||||
; to be informed about MWI state changes on other voicemail server nodes, but
|
||||
; is not capable of publishing any state changes.
|
||||
;
|
||||
; [mwi]
|
||||
; type=event_channel
|
||||
; subscribe_event=mwi
|
||||
;
|
||||
@ -0,0 +1,310 @@
|
||||
===============================================================================
|
||||
===
|
||||
=== Distributed Device State
|
||||
===
|
||||
=== Copyright (C) 2007-2008, Digium, Inc.
|
||||
=== Russell Bryant <russell@digium.com>
|
||||
===
|
||||
===============================================================================
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
--- INTRODUCTION
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
Various changes have been made related to "event handling" in Asterisk.
|
||||
One of the most important things included in these changes is the ability
|
||||
to share certain events between servers. The two types of events that can
|
||||
currently be shared between servers are:
|
||||
|
||||
1) MWI - Message Waiting Indication
|
||||
- This gives you a high performance option for letting servers in a
|
||||
cluster be aware of changes in the state of a mailbox. Instead of
|
||||
having each server have to poll an ODBC database, this lets the server
|
||||
that actually made the change to the mailbox generate an event which
|
||||
will get distributed to the other servers that have subscribed to this
|
||||
information.
|
||||
|
||||
2) Device State
|
||||
- This lets servers in a local cluster inform each other about changes in
|
||||
the state of a device on that particular server. When the state of a
|
||||
device changes on any server, the overall state of that device across
|
||||
the cluster will get recalculated. So, any subscriptions to the state
|
||||
of a device, such as hints in the dialplan or an application like
|
||||
Queue() which reads device state, will then reflect the state of a
|
||||
device across a cluster.
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
--- OpenAIS Installation
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
--- Description ---
|
||||
|
||||
The current solution for providing distributed events with Asterisk is done by
|
||||
using the AIS (Application Interface Specification), which provides an API for
|
||||
a distributed event service. While this API is standardized, this code has
|
||||
been developed exclusively against the open source implementation of AIS called
|
||||
OpenAIS.
|
||||
|
||||
For more information about OpenAIS, visit their web site:
|
||||
|
||||
http://www.openais.org/
|
||||
|
||||
--- Download ---
|
||||
|
||||
To quickly downlaod OpenAIS, just check it out of svn:
|
||||
|
||||
$ svn co http://svn.osdl.org/openais/trunk openais-trunk
|
||||
|
||||
--- Compile ---
|
||||
|
||||
$ cd openais-trunk
|
||||
$ make PREFIX=/usr
|
||||
|
||||
--- Install ---
|
||||
|
||||
By default, the current Makefile installs the libraries into /usr/lib/openais/,
|
||||
which is a little bit inconvenient. So, open up the Makefile, find the lines
|
||||
that start with "LIBDIR=" to define the lib installation directory, and remove
|
||||
the trailing "openais" so it just gets installed in /usr/lib/.
|
||||
|
||||
$ sudo make install PREFIX=/usr
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
--- OpenAIS Configuration
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
Basic OpenAIS configuration to get this working is actually pretty easy. When
|
||||
you install it, it will put some default configuration files into /etc/ais/.
|
||||
Edit openais.conf ...
|
||||
|
||||
$ ${EDITOR:-vim} /etc/ais/openais.conf
|
||||
|
||||
The only section that you should need to change is the totem - interface
|
||||
section.
|
||||
|
||||
totem {
|
||||
...
|
||||
interface {
|
||||
interface {
|
||||
ringnumber: 0
|
||||
bindnetaddr: 10.19.0.0
|
||||
mcastaddr: 226.94.1.1
|
||||
mcastport: 5405
|
||||
}
|
||||
}
|
||||
|
||||
The default mcastaddr and mcastport is probably fine. But, you need to change
|
||||
the bindnetaddr to match the network address that the nodes of your cluster
|
||||
will communicate on.
|
||||
|
||||
The one other thing that you need to do is create a user called "ais".
|
||||
|
||||
$ sudo adduser ais
|
||||
|
||||
See the OpenAIS QUICKSTART file for more information on installing,
|
||||
configuring, and testing OpenAIS.
|
||||
|
||||
$ cd openais-trunk
|
||||
$ less QUICKSTART
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
--- Running OpenAIS
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
While testing, I would recommend starting the aisexec application in the
|
||||
foreground so that you can see debug messages that verify that the nodes have
|
||||
discovered each other and joined the cluster.
|
||||
|
||||
$ sudo aisexec -f
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
--- Installing Asterisk
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
Install Asterisk as usual. Just make sure that you run the configure script
|
||||
after OpenAIS gets installed. That way, it will find the AIS header files and
|
||||
will let you build the res_ais module. Check menuselect to make sure that
|
||||
res_ais is going to get compiled and installed.
|
||||
|
||||
$ cd asterisk-events
|
||||
$ ./configure
|
||||
|
||||
$ make menuselect
|
||||
---> Resource Modules
|
||||
|
||||
If you have existing configuration on the system being used for testing, just
|
||||
be sure to install the addition configuration file needed for res_ais.
|
||||
|
||||
$ sudo cp configs/ais.conf.sample /etc/asterisk/ais.conf
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
--- Configuring Asterisk
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
First, ensure that you have a unique "entity ID" set for each server.
|
||||
|
||||
*CLI> core show settings
|
||||
...
|
||||
Entity ID: 01:23:45:67:89:ab
|
||||
|
||||
The code will attempt to generate a unique entity ID for you by reading
|
||||
MAC addresses off of a network interface. However, you can also set it
|
||||
manually in the [options] section of asterisk.conf.
|
||||
|
||||
$ sudo ${EDITOR:-vim} /etc/asterisk/asterisk.conf
|
||||
|
||||
[options]
|
||||
...
|
||||
entity_id=01:23:45:67:89:ab
|
||||
|
||||
|
||||
Edit the Asterisk ais.conf to enable distributed events. For example, if you
|
||||
would like to enable distributed device state, you should add the following
|
||||
section to the file:
|
||||
|
||||
$ sudo ${EDITOR:-vim} /etc/asterisk/ais.conf
|
||||
|
||||
[device_state]
|
||||
type=event_channel
|
||||
publish_event=device_state
|
||||
subscribe_event=device_state
|
||||
|
||||
For more information on the contents and available options in this configuration
|
||||
file, please see the sample configuration file:
|
||||
|
||||
$ cd asterisk-events
|
||||
$ less configs/ais.conf.sample
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
--- Basic Testing of Asterisk with OpenAIS
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
If you have OpenAIS successfully installed and running, as well as Asterisk
|
||||
with OpenAIS support successfully installed, configured, and running, then you
|
||||
are ready to test out some of the AIS functionality in Asterisk.
|
||||
|
||||
The first thing to test is to verify that all of the nodes that you think should
|
||||
be in your cluster are actually there. There is an Asterisk CLI command which
|
||||
will list the current cluster members using the AIS Cluster Membership Service
|
||||
(CLM).
|
||||
|
||||
*CLI> ais clm show members
|
||||
|
||||
=============================================================
|
||||
=== Cluster Members =========================================
|
||||
=============================================================
|
||||
===
|
||||
=== ---------------------------------------------------------
|
||||
=== Node Name: 10.19.2.255
|
||||
=== ==> ID: 0xa1302ff
|
||||
=== ==> Address: 10.19.2.255
|
||||
=== ==> Member: Yes
|
||||
=== ---------------------------------------------------------
|
||||
===
|
||||
=== ---------------------------------------------------------
|
||||
=== Node Name: 10.19.6.187
|
||||
=== ==> ID: 0xa1306bb
|
||||
=== ==> Address: 10.19.6.187
|
||||
=== ==> Member: Yes
|
||||
=== ---------------------------------------------------------
|
||||
===
|
||||
=============================================================
|
||||
|
||||
|
||||
The next thing to do is to verify that you have successfully configured some
|
||||
event channels in the Asterisk ais.conf file. This command is related to the
|
||||
event service (EVT), so like the previous command, uses the syntax:
|
||||
"ais <service name> <command>".
|
||||
|
||||
*CLI> ais evt show event channels
|
||||
|
||||
=============================================================
|
||||
=== Event Channels ==========================================
|
||||
=============================================================
|
||||
===
|
||||
=== ---------------------------------------------------------
|
||||
=== Event Channel Name: mwi
|
||||
=== ==> Publishing Event Type: mwi
|
||||
=== ==> Subscribing to Event Type: mwi
|
||||
=== ---------------------------------------------------------
|
||||
===
|
||||
=== ---------------------------------------------------------
|
||||
=== Event Channel Name: device_state
|
||||
=== ==> Publishing Event Type: device_state
|
||||
=== ==> Subscribing to Event Type: device_state
|
||||
=== ---------------------------------------------------------
|
||||
===
|
||||
=============================================================
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
--- Testing Distributed Device State
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
The easiest way to test distributed device state is to use the DEVICE_STATE()
|
||||
diaplan function. For example, you could have the following piece of dialplan
|
||||
on every server:
|
||||
|
||||
[devstate_test]
|
||||
|
||||
exten => 1234,hint,Custom:mystate
|
||||
|
||||
exten => set_inuse,1,Set(DEVICE_STATE(Custom:mystate)=INUSE)
|
||||
exten => set_not_inuse,1,Set(DEVICE_STATE(Custom:mystate)=NOT_INUSE)
|
||||
|
||||
exten => check,1,NoOp(Custom:mystate is ${DEVICE_STATE(Custom:mystate)})
|
||||
|
||||
|
||||
Now, you can test that the cluster-wide state of "Custom:mystate" is what
|
||||
you would expect after going to the CLI of each server and adjusting the state.
|
||||
|
||||
server1*CLI> console dial set_inuse@devstate_test
|
||||
...
|
||||
|
||||
server2*CLI> console dial check@devstate_test
|
||||
-- Executing [check@devstate_test:1] NoOp("OSS/dsp", "Custom:mystate is INUSE") in new stack
|
||||
|
||||
Various combinations of setting and checking the state on different servers can
|
||||
be used to verify that it works as expected. Also, you can see the status of
|
||||
the hint on each server, as well, to see how extension state would reflect the
|
||||
state change with distributed device state:
|
||||
|
||||
server2*CLI> core show hints
|
||||
-= Registered Asterisk Dial Plan Hints =-
|
||||
1234@devstate_test : Custom:mystate State:InUse Watchers 0
|
||||
|
||||
|
||||
One other helpful thing here during testing and debugging is to enable debug
|
||||
logging. To do so, enable debug on the console in /etc/asterisk/logger.conf.
|
||||
Also, enable debug at the Asterisk CLI.
|
||||
|
||||
*CLI> core set debug 1
|
||||
|
||||
When you have this debug enabled, you will see output during the processing of
|
||||
every device state change. The important thing to look for is where the known
|
||||
state of the device for each server is added together to determine the overall
|
||||
state.
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
--- Question, Comments, and Bug Reports
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
For now, please direct all feedback to Russell Bryant <russell@digium.com>.
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
@ -0,0 +1,48 @@
|
||||
/*
|
||||
* Asterisk -- An open source telephony toolkit.
|
||||
*
|
||||
* Copyright (C) 2007, Digium, Inc.
|
||||
*
|
||||
* Russell Bryant <russell@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
|
||||
* \author Russell Bryant <russell@digium.com>
|
||||
*
|
||||
* \brief Usage of the SAForum AIS (Application Interface Specification)
|
||||
*
|
||||
* \arg http://www.openais.org/
|
||||
*/
|
||||
|
||||
#ifndef AST_AIS_H
|
||||
#define AST_AIS_H
|
||||
|
||||
#include <openais/saAis.h>
|
||||
#include <openais/saClm.h>
|
||||
#include <openais/saEvt.h>
|
||||
|
||||
extern SaVersionT ais_version;
|
||||
|
||||
extern SaClmHandleT clm_handle;
|
||||
extern SaEvtHandleT evt_handle;
|
||||
|
||||
int ast_ais_clm_load_module(void);
|
||||
int ast_ais_clm_unload_module(void);
|
||||
|
||||
int ast_ais_evt_load_module(void);
|
||||
int ast_ais_evt_unload_module(void);
|
||||
|
||||
const char *ais_err2str(SaAisErrorT error);
|
||||
|
||||
#endif /* AST_AIS_H */
|
||||
@ -0,0 +1,89 @@
|
||||
/*
|
||||
* Asterisk -- An open source telephony toolkit.
|
||||
*
|
||||
* Copyright (C) 2007, Digium, Inc.
|
||||
*
|
||||
* Russell Bryant <russell@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
|
||||
* \author Russell Bryant <russell@digium.com>
|
||||
*
|
||||
* \brief Usage of the SAForum AIS (Application Interface Specification)
|
||||
*
|
||||
* \arg http://www.openais.org/
|
||||
*
|
||||
* This file contains the code specific to the use of the AMF (Application
|
||||
* Management Framework).
|
||||
*/
|
||||
|
||||
#include "asterisk.h"
|
||||
|
||||
ASTERISK_FILE_VERSION(__FILE__, "$Revision$");
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include "ais.h"
|
||||
|
||||
#include "asterisk/module.h"
|
||||
#include "asterisk/utils.h"
|
||||
#include "asterisk/cli.h"
|
||||
#include "asterisk/logger.h"
|
||||
|
||||
SaAmfHandleT amf_handle;
|
||||
|
||||
static const SaAmfCallbacksT amf_callbacks = {
|
||||
.saAmfHealthcheckCallback = NULL,
|
||||
.saAmfComponentTerminateCallback = NULL,
|
||||
.saAmfCSISetCallback = NULL,
|
||||
.saAmfProtectionGroupTrackCallback = NULL,
|
||||
#if 0
|
||||
/*! XXX \todo These appear to be define in the B.02.01 spec, but this won't
|
||||
* compile with them in there. Look into it some more ... */
|
||||
.saAmfProxiedComponentInstantiateCallback = NULL,
|
||||
.saAmfProxiedComponentCleanupCallback = NULL,
|
||||
#endif
|
||||
};
|
||||
|
||||
int ast_ais_amf_load_module(void)
|
||||
{
|
||||
SaAisErrorT ais_res;
|
||||
|
||||
ais_res = saAmfInitialize(&amf_handle, &amf_callbacks, &ais_version);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Could not initialize AMF: %s\n",
|
||||
ais_err2str(ais_res));
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ast_ais_amf_unload_module(void)
|
||||
{
|
||||
SaAisErrorT ais_res;
|
||||
|
||||
ais_res = saAmfFinalize(amf_handle);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Problem stopping AMF: %s\n",
|
||||
ais_err2str(ais_res));
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,78 @@
|
||||
/*
|
||||
* Asterisk -- An open source telephony toolkit.
|
||||
*
|
||||
* Copyright (C) 2007, Digium, Inc.
|
||||
*
|
||||
* Russell Bryant <russell@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
|
||||
* \author Russell Bryant <russell@digium.com>
|
||||
*
|
||||
* \brief Usage of the SAForum AIS (Application Interface Specification)
|
||||
*
|
||||
* \arg http://www.openais.org/
|
||||
*
|
||||
* This file contains the code specific to the use of the CKPT (Checkpoint)
|
||||
* service.
|
||||
*/
|
||||
|
||||
#include "asterisk.h"
|
||||
|
||||
ASTERISK_FILE_VERSION(__FILE__, "$Revision$");
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include "ais.h"
|
||||
|
||||
#include "asterisk/module.h"
|
||||
#include "asterisk/utils.h"
|
||||
#include "asterisk/cli.h"
|
||||
#include "asterisk/logger.h"
|
||||
|
||||
SaCkptHandleT ckpt_handle;
|
||||
|
||||
static const SaCkptCallbacksT ckpt_callbacks;
|
||||
|
||||
int ast_ais_ckpt_load_module(void)
|
||||
{
|
||||
SaAisErrorT ais_res;
|
||||
|
||||
ais_res = saCkptInitialize(&ckpt_handle, &ckpt_callbacks, &ais_version);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Could not initialize CKPT service: %s\n",
|
||||
ais_err2str(ais_res));
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ast_ais_ckpt_unload_module(void)
|
||||
{
|
||||
SaAisErrorT ais_res;
|
||||
|
||||
ais_res = saCkptFinalize(amf_handle);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Problem stopping CKPT service: %s\n",
|
||||
ais_err2str(ais_res));
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,165 @@
|
||||
/*
|
||||
* Asterisk -- An open source telephony toolkit.
|
||||
*
|
||||
* Copyright (C) 2007, Digium, Inc.
|
||||
*
|
||||
* Russell Bryant <russell@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
|
||||
* \author Russell Bryant <russell@digium.com>
|
||||
*
|
||||
* \brief Usage of the SAForum AIS (Application Interface Specification)
|
||||
*
|
||||
* \arg http://www.openais.org/
|
||||
*
|
||||
* This file contains the code specific to the use of the CLM
|
||||
* (Cluster Membership) Service.
|
||||
*/
|
||||
|
||||
#include "asterisk.h"
|
||||
|
||||
ASTERISK_FILE_VERSION(__FILE__, "$Revision$");
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include "ais.h"
|
||||
|
||||
#include "asterisk/module.h"
|
||||
#include "asterisk/utils.h"
|
||||
#include "asterisk/cli.h"
|
||||
#include "asterisk/logger.h"
|
||||
|
||||
SaClmHandleT clm_handle;
|
||||
|
||||
static void clm_node_get_cb(SaInvocationT invocation,
|
||||
const SaClmClusterNodeT *cluster_node, SaAisErrorT error);
|
||||
static void clm_track_cb(const SaClmClusterNotificationBufferT *notif_buffer,
|
||||
SaUint32T num_members, SaAisErrorT error);
|
||||
|
||||
static const SaClmCallbacksT clm_callbacks = {
|
||||
.saClmClusterNodeGetCallback = clm_node_get_cb,
|
||||
.saClmClusterTrackCallback = clm_track_cb,
|
||||
};
|
||||
|
||||
static void clm_node_get_cb(SaInvocationT invocation,
|
||||
const SaClmClusterNodeT *cluster_node, SaAisErrorT error)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
static void clm_track_cb(const SaClmClusterNotificationBufferT *notif_buffer,
|
||||
SaUint32T num_members, SaAisErrorT error)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
static char *ais_clm_show_members(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
||||
{
|
||||
int i;
|
||||
SaClmClusterNotificationBufferT buf;
|
||||
SaClmClusterNotificationT notif[64];
|
||||
SaAisErrorT ais_res;
|
||||
|
||||
switch (cmd) {
|
||||
case CLI_INIT:
|
||||
e->command = "ais clm show members";
|
||||
e->usage =
|
||||
"Usage: ais clm show members\n"
|
||||
" List members of the cluster using the CLM (Cluster Membership) service.\n";
|
||||
return NULL;
|
||||
|
||||
case CLI_GENERATE:
|
||||
return NULL; /* no completion */
|
||||
}
|
||||
|
||||
if (a->argc != e->args)
|
||||
return CLI_SHOWUSAGE;
|
||||
|
||||
buf.notification = notif;
|
||||
buf.numberOfItems = ARRAY_LEN(notif);
|
||||
|
||||
ais_res = saClmClusterTrack(clm_handle, SA_TRACK_CURRENT, &buf);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_cli(a->fd, "Error retrieving current cluster members.\n");
|
||||
return CLI_FAILURE;
|
||||
}
|
||||
|
||||
ast_cli(a->fd, "\n"
|
||||
"=============================================================\n"
|
||||
"=== Cluster Members =========================================\n"
|
||||
"=============================================================\n"
|
||||
"===\n");
|
||||
|
||||
for (i = 0; i < buf.numberOfItems; i++) {
|
||||
SaClmClusterNodeT *node = &buf.notification[i].clusterNode;
|
||||
|
||||
ast_cli(a->fd, "=== ---------------------------------------------------------\n"
|
||||
"=== Node Name: %s\n"
|
||||
"=== ==> ID: 0x%x\n"
|
||||
"=== ==> Address: %s\n"
|
||||
"=== ==> Member: %s\n",
|
||||
(char *) node->nodeName.value, (int) node->nodeId,
|
||||
(char *) node->nodeAddress.value,
|
||||
node->member ? "Yes" : "No");
|
||||
|
||||
ast_cli(a->fd, "=== ---------------------------------------------------------\n"
|
||||
"===\n");
|
||||
}
|
||||
|
||||
ast_cli(a->fd, "=============================================================\n"
|
||||
"\n");
|
||||
|
||||
return CLI_SUCCESS;
|
||||
}
|
||||
|
||||
static struct ast_cli_entry ais_cli[] = {
|
||||
AST_CLI_DEFINE(ais_clm_show_members, "List current members of the cluster"),
|
||||
};
|
||||
|
||||
int ast_ais_clm_load_module(void)
|
||||
{
|
||||
SaAisErrorT ais_res;
|
||||
|
||||
ais_res = saClmInitialize(&clm_handle, &clm_callbacks, &ais_version);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Could not initialize cluster membership service: %s\n",
|
||||
ais_err2str(ais_res));
|
||||
return -1;
|
||||
}
|
||||
|
||||
ast_cli_register_multiple(ais_cli, ARRAY_LEN(ais_cli));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ast_ais_clm_unload_module(void)
|
||||
{
|
||||
SaAisErrorT ais_res;
|
||||
|
||||
ast_cli_unregister_multiple(ais_cli, ARRAY_LEN(ais_cli));
|
||||
|
||||
ais_res = saClmFinalize(clm_handle);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Problem stopping cluster membership service: %s\n",
|
||||
ais_err2str(ais_res));
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,588 @@
|
||||
/*
|
||||
* Asterisk -- An open source telephony toolkit.
|
||||
*
|
||||
* Copyright (C) 2007, Digium, Inc.
|
||||
*
|
||||
* Russell Bryant <russell@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
|
||||
* \author Russell Bryant <russell@digium.com>
|
||||
*
|
||||
* \brief Usage of the SAForum AIS (Application Interface Specification)
|
||||
*
|
||||
* \arg http://www.openais.org/
|
||||
*
|
||||
* This file contains the code specific to the use of the EVT
|
||||
* (Event) Service.
|
||||
*/
|
||||
|
||||
#include "asterisk.h"
|
||||
|
||||
ASTERISK_FILE_VERSION(__FILE__, "$Revision$");
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include "ais.h"
|
||||
|
||||
#include "asterisk/module.h"
|
||||
#include "asterisk/utils.h"
|
||||
#include "asterisk/cli.h"
|
||||
#include "asterisk/logger.h"
|
||||
#include "asterisk/event.h"
|
||||
#include "asterisk/config.h"
|
||||
#include "asterisk/linkedlists.h"
|
||||
|
||||
#ifndef AST_MODULE
|
||||
/* XXX HACK */
|
||||
#define AST_MODULE "res_ais"
|
||||
#endif
|
||||
|
||||
SaEvtHandleT evt_handle;
|
||||
|
||||
void evt_channel_open_cb(SaInvocationT invocation, SaEvtChannelHandleT channel_handle,
|
||||
SaAisErrorT error);
|
||||
void evt_event_deliver_cb(SaEvtSubscriptionIdT subscription_id,
|
||||
const SaEvtEventHandleT event_handle, const SaSizeT event_datalen);
|
||||
|
||||
static const SaEvtCallbacksT evt_callbacks = {
|
||||
.saEvtChannelOpenCallback = evt_channel_open_cb,
|
||||
.saEvtEventDeliverCallback = evt_event_deliver_cb,
|
||||
};
|
||||
|
||||
static const struct {
|
||||
const char *str;
|
||||
enum ast_event_type type;
|
||||
} supported_event_types[] = {
|
||||
{ "mwi", AST_EVENT_MWI },
|
||||
{ "device_state", AST_EVENT_DEVICE_STATE_CHANGE },
|
||||
};
|
||||
|
||||
/*! Used to provide unique id's to egress subscriptions */
|
||||
static int unique_id;
|
||||
|
||||
struct subscribe_event {
|
||||
AST_LIST_ENTRY(subscribe_event) entry;
|
||||
/*! This is a unique identifier to identify this subscription in the event
|
||||
* channel through the different API calls, subscribe, unsubscribe, and
|
||||
* the event deliver callback. */
|
||||
SaEvtSubscriptionIdT id;
|
||||
enum ast_event_type type;
|
||||
};
|
||||
|
||||
struct publish_event {
|
||||
AST_LIST_ENTRY(publish_event) entry;
|
||||
/*! We subscribe to events internally so that we can publish them
|
||||
* on this event channel. */
|
||||
struct ast_event_sub *sub;
|
||||
enum ast_event_type type;
|
||||
};
|
||||
|
||||
struct event_channel {
|
||||
AST_RWLIST_ENTRY(event_channel) entry;
|
||||
AST_LIST_HEAD_NOLOCK(, subscribe_event) subscribe_events;
|
||||
AST_LIST_HEAD_NOLOCK(, publish_event) publish_events;
|
||||
SaEvtChannelHandleT handle;
|
||||
char name[1];
|
||||
};
|
||||
|
||||
static AST_RWLIST_HEAD_STATIC(event_channels, event_channel);
|
||||
|
||||
void evt_channel_open_cb(SaInvocationT invocation, SaEvtChannelHandleT channel_handle,
|
||||
SaAisErrorT error)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
static void queue_event(struct ast_event *ast_event)
|
||||
{
|
||||
enum ast_event_type type;
|
||||
|
||||
/*!
|
||||
* \todo This hack macks me sad. I need to come up with a better way to
|
||||
* figure out whether an event should be cached or not, and what
|
||||
* parameters to cache on.
|
||||
*
|
||||
* As long as the types of events that are supported is limited,
|
||||
* this isn't *terrible*, I guess. Perhaps we should just define
|
||||
* caching rules in the core, and make them configurable, and not
|
||||
* have it be the job of the event publishers.
|
||||
*/
|
||||
|
||||
type = ast_event_get_type(ast_event);
|
||||
|
||||
if (type == AST_EVENT_MWI) {
|
||||
ast_event_queue_and_cache(ast_event,
|
||||
AST_EVENT_IE_MAILBOX, AST_EVENT_IE_PLTYPE_STR,
|
||||
AST_EVENT_IE_CONTEXT, AST_EVENT_IE_PLTYPE_STR,
|
||||
AST_EVENT_IE_END);
|
||||
} else if (type == AST_EVENT_DEVICE_STATE_CHANGE) {
|
||||
ast_event_queue_and_cache(ast_event,
|
||||
AST_EVENT_IE_DEVICE, AST_EVENT_IE_PLTYPE_STR,
|
||||
AST_EVENT_IE_EID, AST_EVENT_IE_PLTYPE_RAW, sizeof(struct ast_eid),
|
||||
AST_EVENT_IE_END);
|
||||
} else {
|
||||
ast_event_queue(ast_event);
|
||||
}
|
||||
}
|
||||
|
||||
void evt_event_deliver_cb(SaEvtSubscriptionIdT sub_id,
|
||||
const SaEvtEventHandleT event_handle, const SaSizeT event_datalen)
|
||||
{
|
||||
/* It is important to note that this works because we *know* that this
|
||||
* function will only be called by a single thread, the dispatch_thread.
|
||||
* If this module gets changed such that this is no longer the case, this
|
||||
* should get changed to a thread-local buffer, instead. */
|
||||
static unsigned char buf[4096];
|
||||
struct ast_event *event_dup, *event = (void *) buf;
|
||||
SaAisErrorT ais_res;
|
||||
SaSizeT len = sizeof(buf);
|
||||
|
||||
if (event_datalen > len) {
|
||||
ast_log(LOG_ERROR, "Event received with size %u, which is too big\n"
|
||||
"for the allocated size %u. Change the code to increase the size.\n",
|
||||
(unsigned int) event_datalen, (unsigned int) len);
|
||||
return;
|
||||
}
|
||||
|
||||
ais_res = saEvtEventDataGet(event_handle, event, &len);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Error retrieving event payload: %s\n",
|
||||
ais_err2str(ais_res));
|
||||
return;
|
||||
}
|
||||
|
||||
if (!ast_eid_cmp(&g_eid, ast_event_get_ie_raw(event, AST_EVENT_IE_EID))) {
|
||||
/* Don't feed events back in that originated locally. */
|
||||
return;
|
||||
}
|
||||
|
||||
if (!(event_dup = ast_malloc(len)))
|
||||
return;
|
||||
|
||||
memcpy(event_dup, event, len);
|
||||
|
||||
queue_event(event_dup);
|
||||
}
|
||||
|
||||
static const char *type_to_filter_str(enum ast_event_type type)
|
||||
{
|
||||
const char *filter_str = NULL;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < ARRAY_LEN(supported_event_types); i++) {
|
||||
if (supported_event_types[i].type == type) {
|
||||
filter_str = supported_event_types[i].str;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return filter_str;
|
||||
}
|
||||
|
||||
static void ast_event_cb(const struct ast_event *ast_event, void *data)
|
||||
{
|
||||
SaEvtEventHandleT event_handle;
|
||||
SaAisErrorT ais_res;
|
||||
struct event_channel *event_channel = data;
|
||||
SaClmClusterNodeT local_node;
|
||||
SaEvtEventPatternArrayT pattern_array;
|
||||
SaEvtEventPatternT pattern;
|
||||
SaSizeT len;
|
||||
const char *filter_str;
|
||||
SaEvtEventIdT event_id;
|
||||
|
||||
ast_log(LOG_DEBUG, "Got an event to forward\n");
|
||||
|
||||
if (ast_eid_cmp(&g_eid, ast_event_get_ie_raw(ast_event, AST_EVENT_IE_EID))) {
|
||||
/* If the event didn't originate from this server, don't send it back out. */
|
||||
ast_log(LOG_DEBUG, "Returning here\n");
|
||||
return;
|
||||
}
|
||||
|
||||
ais_res = saEvtEventAllocate(event_channel->handle, &event_handle);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Error allocating event: %s\n", ais_err2str(ais_res));
|
||||
ast_log(LOG_DEBUG, "Returning here\n");
|
||||
return;
|
||||
}
|
||||
|
||||
ais_res = saClmClusterNodeGet(clm_handle, SA_CLM_LOCAL_NODE_ID,
|
||||
SA_TIME_ONE_SECOND, &local_node);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Error getting local node name: %s\n", ais_err2str(ais_res));
|
||||
goto return_event_free;
|
||||
}
|
||||
|
||||
filter_str = type_to_filter_str(ast_event_get_type(ast_event));
|
||||
len = strlen(filter_str) + 1;
|
||||
pattern.pattern = (SaUint8T *) filter_str;
|
||||
pattern.patternSize = len;
|
||||
pattern.allocatedSize = len;
|
||||
|
||||
pattern_array.allocatedNumber = 1;
|
||||
pattern_array.patternsNumber = 1;
|
||||
pattern_array.patterns = &pattern;
|
||||
|
||||
/*!
|
||||
* /todo Make retention time configurable
|
||||
* /todo Make event priorities configurable
|
||||
*/
|
||||
ais_res = saEvtEventAttributesSet(event_handle, &pattern_array,
|
||||
SA_EVT_LOWEST_PRIORITY, SA_TIME_ONE_MINUTE, &local_node.nodeName);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Error setting event attributes: %s\n", ais_err2str(ais_res));
|
||||
goto return_event_free;
|
||||
}
|
||||
|
||||
ais_res = saEvtEventPublish(event_handle,
|
||||
ast_event, ast_event_get_size(ast_event), &event_id);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Error publishing event: %s\n", ais_err2str(ais_res));
|
||||
goto return_event_free;
|
||||
}
|
||||
|
||||
return_event_free:
|
||||
ais_res = saEvtEventFree(event_handle);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Error freeing allocated event: %s\n", ais_err2str(ais_res));
|
||||
}
|
||||
ast_log(LOG_DEBUG, "Returning here (event_free)\n");
|
||||
}
|
||||
|
||||
static char *ais_evt_show_event_channels(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
||||
{
|
||||
struct event_channel *event_channel;
|
||||
|
||||
switch (cmd) {
|
||||
case CLI_INIT:
|
||||
e->command = "ais evt show event channels";
|
||||
e->usage =
|
||||
"Usage: ais evt show event channels\n"
|
||||
" List configured event channels for the (EVT) Eventing service.\n";
|
||||
return NULL;
|
||||
|
||||
case CLI_GENERATE:
|
||||
return NULL; /* no completion */
|
||||
}
|
||||
|
||||
if (a->argc != e->args)
|
||||
return CLI_SHOWUSAGE;
|
||||
|
||||
ast_cli(a->fd, "\n"
|
||||
"=============================================================\n"
|
||||
"=== Event Channels ==========================================\n"
|
||||
"=============================================================\n"
|
||||
"===\n");
|
||||
|
||||
AST_RWLIST_RDLOCK(&event_channels);
|
||||
AST_RWLIST_TRAVERSE(&event_channels, event_channel, entry) {
|
||||
struct publish_event *publish_event;
|
||||
struct subscribe_event *subscribe_event;
|
||||
|
||||
ast_cli(a->fd, "=== ---------------------------------------------------------\n"
|
||||
"=== Event Channel Name: %s\n", event_channel->name);
|
||||
|
||||
AST_LIST_TRAVERSE(&event_channel->publish_events, publish_event, entry) {
|
||||
ast_cli(a->fd, "=== ==> Publishing Event Type: %s\n",
|
||||
type_to_filter_str(publish_event->type));
|
||||
}
|
||||
|
||||
AST_LIST_TRAVERSE(&event_channel->subscribe_events, subscribe_event, entry) {
|
||||
ast_cli(a->fd, "=== ==> Subscribing to Event Type: %s\n",
|
||||
type_to_filter_str(subscribe_event->type));
|
||||
}
|
||||
|
||||
ast_cli(a->fd, "=== ---------------------------------------------------------\n"
|
||||
"===\n");
|
||||
}
|
||||
AST_RWLIST_UNLOCK(&event_channels);
|
||||
|
||||
ast_cli(a->fd, "=============================================================\n"
|
||||
"\n");
|
||||
|
||||
return CLI_SUCCESS;
|
||||
}
|
||||
|
||||
static struct ast_cli_entry ais_cli[] = {
|
||||
AST_CLI_DEFINE(ais_evt_show_event_channels, "Show configured event channels"),
|
||||
};
|
||||
|
||||
static void add_publish_event(struct event_channel *event_channel, const char *event_type)
|
||||
{
|
||||
int i;
|
||||
enum ast_event_type type = -1;
|
||||
struct publish_event *publish_event;
|
||||
|
||||
for (i = 0; i < ARRAY_LEN(supported_event_types); i++) {
|
||||
if (!strcasecmp(event_type, supported_event_types[i].str)) {
|
||||
type = supported_event_types[i].type;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (type == -1) {
|
||||
ast_log(LOG_WARNING, "publish_event option given with invalid value '%s'\n", event_type);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!(publish_event = ast_calloc(1, sizeof(*publish_event))))
|
||||
return;
|
||||
|
||||
publish_event->type = type;
|
||||
ast_log(LOG_DEBUG, "Subscribing to event type %d\n", type);
|
||||
publish_event->sub = ast_event_subscribe(type, ast_event_cb, event_channel,
|
||||
AST_EVENT_IE_END);
|
||||
ast_event_dump_cache(publish_event->sub);
|
||||
|
||||
AST_LIST_INSERT_TAIL(&event_channel->publish_events, publish_event, entry);
|
||||
}
|
||||
|
||||
static SaAisErrorT set_egress_subscription(struct event_channel *event_channel,
|
||||
struct subscribe_event *subscribe_event)
|
||||
{
|
||||
SaAisErrorT ais_res;
|
||||
SaEvtEventFilterArrayT filter_array;
|
||||
SaEvtEventFilterT filter;
|
||||
const char *filter_str = NULL;
|
||||
SaSizeT len;
|
||||
|
||||
/* We know it's going to be valid. It was checked earlier. */
|
||||
filter_str = type_to_filter_str(subscribe_event->type);
|
||||
|
||||
filter.filterType = SA_EVT_EXACT_FILTER;
|
||||
len = strlen(filter_str) + 1;
|
||||
filter.filter.allocatedSize = len;
|
||||
filter.filter.patternSize = len;
|
||||
filter.filter.pattern = (SaUint8T *) filter_str;
|
||||
|
||||
filter_array.filtersNumber = 1;
|
||||
filter_array.filters = &filter;
|
||||
|
||||
ais_res = saEvtEventSubscribe(event_channel->handle, &filter_array,
|
||||
subscribe_event->id);
|
||||
|
||||
return ais_res;
|
||||
}
|
||||
|
||||
static void add_subscribe_event(struct event_channel *event_channel, const char *event_type)
|
||||
{
|
||||
int i;
|
||||
enum ast_event_type type = -1;
|
||||
struct subscribe_event *subscribe_event;
|
||||
SaAisErrorT ais_res;
|
||||
|
||||
for (i = 0; i < ARRAY_LEN(supported_event_types); i++) {
|
||||
if (!strcasecmp(event_type, supported_event_types[i].str)) {
|
||||
type = supported_event_types[i].type;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (type == -1) {
|
||||
ast_log(LOG_WARNING, "subscribe_event option given with invalid value '%s'\n", event_type);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!(subscribe_event = ast_calloc(1, sizeof(*subscribe_event))))
|
||||
return;
|
||||
|
||||
subscribe_event->type = type;
|
||||
subscribe_event->id = ast_atomic_fetchadd_int(&unique_id, +1);
|
||||
|
||||
ais_res = set_egress_subscription(event_channel, subscribe_event);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Error setting up egress subscription: %s\n",
|
||||
ais_err2str(ais_res));
|
||||
free(subscribe_event);
|
||||
return;
|
||||
}
|
||||
|
||||
AST_LIST_INSERT_TAIL(&event_channel->subscribe_events, subscribe_event, entry);
|
||||
}
|
||||
|
||||
static void build_event_channel(struct ast_config *cfg, const char *cat)
|
||||
{
|
||||
struct ast_variable *var;
|
||||
struct event_channel *event_channel;
|
||||
SaAisErrorT ais_res;
|
||||
SaNameT sa_name = { 0, };
|
||||
|
||||
AST_RWLIST_WRLOCK(&event_channels);
|
||||
AST_RWLIST_TRAVERSE(&event_channels, event_channel, entry) {
|
||||
if (!strcasecmp(event_channel->name, cat))
|
||||
break;
|
||||
}
|
||||
AST_RWLIST_UNLOCK(&event_channels);
|
||||
if (event_channel) {
|
||||
ast_log(LOG_WARNING, "Event channel '%s' was specified twice in "
|
||||
"configuration. Second instance ignored.\n", cat);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!(event_channel = ast_calloc(1, sizeof(*event_channel) + strlen(cat))))
|
||||
return;
|
||||
|
||||
strcpy(event_channel->name, cat);
|
||||
ast_copy_string((char *) sa_name.value, cat, sizeof(sa_name.value));
|
||||
sa_name.length = strlen((char *) sa_name.value);
|
||||
ais_res = saEvtChannelOpen(evt_handle, &sa_name,
|
||||
SA_EVT_CHANNEL_PUBLISHER | SA_EVT_CHANNEL_SUBSCRIBER | SA_EVT_CHANNEL_CREATE,
|
||||
SA_TIME_MAX, &event_channel->handle);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Error opening event channel: %s\n", ais_err2str(ais_res));
|
||||
free(event_channel);
|
||||
return;
|
||||
}
|
||||
|
||||
for (var = ast_variable_browse(cfg, cat); var; var = var->next) {
|
||||
if (!strcasecmp(var->name, "type")) {
|
||||
continue;
|
||||
} else if (!strcasecmp(var->name, "publish_event")) {
|
||||
add_publish_event(event_channel, var->value);
|
||||
} else if (!strcasecmp(var->name, "subscribe_event")) {
|
||||
add_subscribe_event(event_channel, var->value);
|
||||
} else {
|
||||
ast_log(LOG_WARNING, "Event channel '%s' contains invalid option '%s'\n",
|
||||
event_channel->name, var->name);
|
||||
}
|
||||
}
|
||||
|
||||
AST_RWLIST_WRLOCK(&event_channels);
|
||||
AST_RWLIST_INSERT_TAIL(&event_channels, event_channel, entry);
|
||||
AST_RWLIST_UNLOCK(&event_channels);
|
||||
}
|
||||
|
||||
static void load_config(void)
|
||||
{
|
||||
static const char filename[] = "ais.conf";
|
||||
struct ast_config *cfg;
|
||||
const char *cat = NULL;
|
||||
struct ast_flags config_flags = { 0 };
|
||||
|
||||
if (!(cfg = ast_config_load(filename, config_flags)))
|
||||
return;
|
||||
|
||||
while ((cat = ast_category_browse(cfg, cat))) {
|
||||
const char *type;
|
||||
|
||||
if (!strcasecmp(cat, "general"))
|
||||
continue;
|
||||
|
||||
if (!(type = ast_variable_retrieve(cfg, cat, "type"))) {
|
||||
ast_log(LOG_WARNING, "Invalid entry in %s defined with no type!\n",
|
||||
filename);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!strcasecmp(type, "event_channel")) {
|
||||
build_event_channel(cfg, cat);
|
||||
} else {
|
||||
ast_log(LOG_WARNING, "Entry in %s defined with invalid type '%s'\n",
|
||||
filename, type);
|
||||
}
|
||||
}
|
||||
|
||||
ast_config_destroy(cfg);
|
||||
}
|
||||
|
||||
static void publish_event_destroy(struct publish_event *publish_event)
|
||||
{
|
||||
ast_event_unsubscribe(publish_event->sub);
|
||||
|
||||
free(publish_event);
|
||||
}
|
||||
|
||||
static void subscribe_event_destroy(const struct event_channel *event_channel,
|
||||
struct subscribe_event *subscribe_event)
|
||||
{
|
||||
SaAisErrorT ais_res;
|
||||
|
||||
/* saEvtChannelClose() will actually do this automatically, but it just
|
||||
* feels cleaner to go ahead and do it manually ... */
|
||||
ais_res = saEvtEventUnsubscribe(event_channel->handle, subscribe_event->id);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Error unsubscribing: %s\n", ais_err2str(ais_res));
|
||||
}
|
||||
|
||||
free(subscribe_event);
|
||||
}
|
||||
|
||||
static void event_channel_destroy(struct event_channel *event_channel)
|
||||
{
|
||||
struct publish_event *publish_event;
|
||||
struct subscribe_event *subscribe_event;
|
||||
SaAisErrorT ais_res;
|
||||
|
||||
while ((publish_event = AST_LIST_REMOVE_HEAD(&event_channel->publish_events, entry)))
|
||||
publish_event_destroy(publish_event);
|
||||
while ((subscribe_event = AST_LIST_REMOVE_HEAD(&event_channel->subscribe_events, entry)))
|
||||
subscribe_event_destroy(event_channel, subscribe_event);
|
||||
|
||||
ais_res = saEvtChannelClose(event_channel->handle);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Error closing event channel '%s': %s\n",
|
||||
event_channel->name, ais_err2str(ais_res));
|
||||
}
|
||||
|
||||
free(event_channel);
|
||||
}
|
||||
|
||||
static void destroy_event_channels(void)
|
||||
{
|
||||
struct event_channel *event_channel;
|
||||
|
||||
AST_RWLIST_WRLOCK(&event_channels);
|
||||
while ((event_channel = AST_RWLIST_REMOVE_HEAD(&event_channels, entry)))
|
||||
event_channel_destroy(event_channel);
|
||||
AST_RWLIST_UNLOCK(&event_channels);
|
||||
}
|
||||
|
||||
int ast_ais_evt_load_module(void)
|
||||
{
|
||||
SaAisErrorT ais_res;
|
||||
|
||||
ais_res = saEvtInitialize(&evt_handle, &evt_callbacks, &ais_version);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Could not initialize eventing service: %s\n",
|
||||
ais_err2str(ais_res));
|
||||
return -1;
|
||||
}
|
||||
|
||||
load_config();
|
||||
|
||||
ast_cli_register_multiple(ais_cli, ARRAY_LEN(ais_cli));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ast_ais_evt_unload_module(void)
|
||||
{
|
||||
SaAisErrorT ais_res;
|
||||
|
||||
destroy_event_channels();
|
||||
|
||||
ais_res = saEvtFinalize(evt_handle);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Problem stopping eventing service: %s\n",
|
||||
ais_err2str(ais_res));
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,551 @@
|
||||
/*
|
||||
* Asterisk -- An open source telephony toolkit.
|
||||
*
|
||||
* Copyright (C) 2007, Digium, Inc.
|
||||
*
|
||||
* Russell Bryant <russell@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
|
||||
* \author Russell Bryant <russell@digium.com>
|
||||
*
|
||||
* \brief Usage of the SAForum AIS (Application Interface Specification)
|
||||
*
|
||||
* \arg http://www.openais.org/
|
||||
*
|
||||
* This file contains the code specific to the use of the LCK
|
||||
* (Distributed Locks) Service.
|
||||
*/
|
||||
|
||||
#include "asterisk.h"
|
||||
|
||||
ASTERISK_FILE_VERSION(__FILE__, "$Revision$");
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include "ais.h"
|
||||
|
||||
#include "asterisk/module.h"
|
||||
#include "asterisk/utils.h"
|
||||
#include "asterisk/cli.h"
|
||||
#include "asterisk/logger.h"
|
||||
#include "asterisk/pbx.h"
|
||||
#include "asterisk/app.h"
|
||||
#include "asterisk/astobj2.h"
|
||||
#include "asterisk/strings.h"
|
||||
#include "asterisk/channel.h"
|
||||
|
||||
SaLckHandleT lck_handle;
|
||||
|
||||
/*!
|
||||
* \brief Callbacks available in the Lock Service
|
||||
*
|
||||
* None of these are actually required if only synchronous locking is used.
|
||||
* However, some of them must be implemented should the asynchronous locks
|
||||
* be used.
|
||||
*/
|
||||
static SaLckCallbacksT lck_callbacks = {
|
||||
/*! Get notified when a cluster-wide lock gets created */
|
||||
.saLckResourceOpenCallback = NULL,
|
||||
/*! Get notified when an asynchronous lock request gets granted */
|
||||
.saLckLockGrantCallback = NULL,
|
||||
/*! Be informed when a currently held lock is blocking another node */
|
||||
.saLckLockWaiterCallback = NULL,
|
||||
/*! Get notified when an asynchronous unlock request is done */
|
||||
.saLckResourceUnlockCallback = NULL,
|
||||
};
|
||||
|
||||
enum lock_type {
|
||||
RDLOCK,
|
||||
WRLOCK,
|
||||
TRY_RDLOCK,
|
||||
TRY_WRLOCK,
|
||||
};
|
||||
|
||||
#define LOCK_BUCKETS 101
|
||||
|
||||
/*!
|
||||
* Every thread that wants to use a distributed lock must open its own handle
|
||||
* to the lock. So, a thread-local container of opened locks is used to keep
|
||||
* track of what locks have been opened.
|
||||
*
|
||||
* \todo It would be nice to be able to have a thread-local container, instead
|
||||
* of using a thread-local wrapper like this.
|
||||
*/
|
||||
struct lock_resources {
|
||||
struct ao2_container *locks;
|
||||
};
|
||||
|
||||
static int lock_resources_init(void *);
|
||||
static void lock_resources_destroy(void *);
|
||||
|
||||
AST_THREADSTORAGE_CUSTOM(locks_ts_key,
|
||||
lock_resources_init, lock_resources_destroy);
|
||||
|
||||
struct lock_resource {
|
||||
SaLckResourceHandleT handle;
|
||||
SaLckLockIdT id;
|
||||
SaNameT ais_name;
|
||||
const char *name;
|
||||
};
|
||||
|
||||
static int lock_hash_cb(const void *obj, int flags)
|
||||
{
|
||||
const struct lock_resource *lock = obj;
|
||||
|
||||
return ast_str_hash(lock->name);
|
||||
}
|
||||
|
||||
static int lock_cmp_cb(void *obj, void *arg, int flags)
|
||||
{
|
||||
struct lock_resource *lock1 = obj, *lock2 = arg;
|
||||
|
||||
return !strcasecmp(lock1->name, lock2->name) ? CMP_MATCH : 0;
|
||||
}
|
||||
|
||||
static int lock_resources_init(void *data)
|
||||
{
|
||||
struct lock_resources *lock_resources = data;
|
||||
|
||||
if (!(lock_resources->locks = ao2_container_alloc(LOCK_BUCKETS,
|
||||
lock_hash_cb, lock_cmp_cb))) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
||||
static void lock_resources_destroy(void *data)
|
||||
{
|
||||
struct lock_resources *lock_resources = data;
|
||||
|
||||
ao2_ref(lock_resources->locks, -1);
|
||||
|
||||
ast_free(lock_resources);
|
||||
}
|
||||
|
||||
static void lock_destructor(void *obj)
|
||||
{
|
||||
struct lock_resource *lock = obj;
|
||||
|
||||
if (lock->name)
|
||||
ast_free((void *) lock->name);
|
||||
}
|
||||
|
||||
static inline struct lock_resource *lock_ref(struct lock_resource *lock)
|
||||
{
|
||||
ao2_ref(lock, +1);
|
||||
return lock;
|
||||
}
|
||||
|
||||
static inline struct lock_resource *lock_unref(struct lock_resource *lock)
|
||||
{
|
||||
ao2_ref(lock, -1);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void lock_datastore_destroy(void *data)
|
||||
{
|
||||
struct lock_resource *lock = data;
|
||||
SaAisErrorT ais_res;
|
||||
|
||||
ais_res = saLckResourceUnlock(lock->id, SA_TIME_ONE_SECOND * 3);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Error unlocking '%s': %s\n", lock->name,
|
||||
ais_err2str(ais_res));
|
||||
}
|
||||
|
||||
lock_unref(lock);
|
||||
}
|
||||
|
||||
static struct lock_resource *find_lock(const char *name)
|
||||
{
|
||||
struct lock_resource *lock, tmp_lock = {
|
||||
.name = name,
|
||||
};
|
||||
SaAisErrorT ais_res;
|
||||
struct lock_resources *lock_resources;
|
||||
|
||||
if (!(lock_resources = ast_threadstorage_get(&locks_ts_key,
|
||||
sizeof(*lock_resources)))) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Return the lock if it has already been opened by this thread */
|
||||
if ((lock = ao2_find(lock_resources->locks, &tmp_lock, OBJ_POINTER)))
|
||||
return lock;
|
||||
|
||||
/* Allocate and open the lock */
|
||||
if (!(lock = ao2_alloc(sizeof(*lock), lock_destructor)))
|
||||
return NULL;
|
||||
|
||||
if (!(lock->name = ast_strdup(name)))
|
||||
return lock_unref(lock);
|
||||
|
||||
/* Map the name into the SaNameT for convenience */
|
||||
ast_copy_string((char *) lock->ais_name.value, lock->name,
|
||||
sizeof(lock->ais_name.value));
|
||||
lock->ais_name.length = strlen(lock->name);
|
||||
|
||||
ais_res = saLckResourceOpen(lck_handle, &lock->ais_name,
|
||||
SA_LCK_RESOURCE_CREATE, SA_TIME_ONE_SECOND * 3, &lock->handle);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Failed to open lock: %s\n", ais_err2str(ais_res));
|
||||
return lock_unref(lock);
|
||||
}
|
||||
|
||||
return lock;
|
||||
}
|
||||
|
||||
const struct ast_datastore_info dlock_datastore_info = {
|
||||
.type = "DLOCK",
|
||||
.destroy = lock_datastore_destroy,
|
||||
};
|
||||
|
||||
static void add_lock_to_chan(struct ast_channel *chan, struct lock_resource *lock,
|
||||
enum lock_type lock_type, double timeout, char *buf, size_t len)
|
||||
{
|
||||
struct ast_datastore *datastore;
|
||||
SaAisErrorT ais_res;
|
||||
SaLckLockModeT mode = 0;
|
||||
SaLckLockFlagsT flags = 0;
|
||||
SaLckLockStatusT status;
|
||||
|
||||
ast_channel_lock(chan);
|
||||
datastore = ast_channel_datastore_find(chan, &dlock_datastore_info, lock->name);
|
||||
|
||||
if (datastore) {
|
||||
ast_log(LOG_ERROR, "The DLOCK '%s' is already locked by channel '%s'\n",
|
||||
lock->name, chan->name);
|
||||
ast_channel_unlock(chan);
|
||||
ast_copy_string(buf, "FAILURE", len);
|
||||
return;
|
||||
}
|
||||
ast_channel_unlock(chan);
|
||||
|
||||
switch (lock_type) {
|
||||
case TRY_RDLOCK:
|
||||
flags = SA_LCK_LOCK_NO_QUEUE;
|
||||
mode = SA_LCK_PR_LOCK_MODE;
|
||||
break;
|
||||
case RDLOCK:
|
||||
flags = SA_LCK_LOCK_NO_QUEUE;
|
||||
mode = SA_LCK_PR_LOCK_MODE;
|
||||
break;
|
||||
case TRY_WRLOCK:
|
||||
flags = SA_LCK_LOCK_NO_QUEUE;
|
||||
mode = SA_LCK_EX_LOCK_MODE;
|
||||
break;
|
||||
case WRLOCK:
|
||||
flags = SA_LCK_LOCK_NO_QUEUE;
|
||||
mode = SA_LCK_EX_LOCK_MODE;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Actually acquire the lock now */
|
||||
ais_res = saLckResourceLock(lock->handle, &lock->id, mode, flags, 0,
|
||||
(SaTimeT) timeout * SA_TIME_ONE_SECOND, &status);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Problem acquiring lock '%s': %s\n",
|
||||
lock->name, ais_err2str(ais_res));
|
||||
ast_copy_string(buf, (ais_res == SA_AIS_ERR_TIMEOUT) ? "TIMEOUT" :
|
||||
"FAILURE", len);
|
||||
return;
|
||||
}
|
||||
|
||||
switch (status) {
|
||||
case SA_LCK_LOCK_GRANTED:
|
||||
ast_copy_string(buf, "SUCCESS", len);
|
||||
break;
|
||||
case SA_LCK_LOCK_DEADLOCK:
|
||||
ast_copy_string(buf, "DEADLOCK", len);
|
||||
return;
|
||||
/*! XXX \todo Need to look at handling these other cases in a different way */
|
||||
case SA_LCK_LOCK_NOT_QUEUED:
|
||||
case SA_LCK_LOCK_ORPHANED:
|
||||
case SA_LCK_LOCK_NO_MORE:
|
||||
case SA_LCK_LOCK_DUPLICATE_EX:
|
||||
ast_copy_string(buf, "FAILURE", len);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!(datastore = ast_channel_datastore_alloc(&dlock_datastore_info,
|
||||
lock->name))) {
|
||||
ast_copy_string(buf, "FAILURE", len);
|
||||
return;
|
||||
}
|
||||
|
||||
datastore->data = lock_ref(lock);
|
||||
|
||||
ast_channel_lock(chan);
|
||||
ast_channel_datastore_add(chan, datastore);
|
||||
ast_channel_unlock(chan);
|
||||
}
|
||||
|
||||
static int handle_lock(struct ast_channel *chan, enum lock_type lock_type,
|
||||
char *data, char *buf, size_t len)
|
||||
{
|
||||
AST_DECLARE_APP_ARGS(args,
|
||||
AST_APP_ARG(name);
|
||||
AST_APP_ARG(timeout);
|
||||
);
|
||||
int res = 0;
|
||||
double timeout = 3;
|
||||
struct lock_resource *lock = NULL;
|
||||
|
||||
ast_autoservice_start(chan);
|
||||
|
||||
AST_STANDARD_APP_ARGS(args, data);
|
||||
if (ast_strlen_zero(args.name)) {
|
||||
ast_log(LOG_ERROR, "The DLOCK functions require a lock name\n");
|
||||
res = -1;
|
||||
goto return_cleanup;
|
||||
}
|
||||
switch (lock_type) {
|
||||
case RDLOCK:
|
||||
case WRLOCK:
|
||||
if (!ast_strlen_zero(args.timeout) && ((timeout = atof(args.timeout)) < 0)) {
|
||||
ast_log(LOG_ERROR, "Timeout value '%s' not valid\n", args.timeout);
|
||||
res = -1;
|
||||
goto return_cleanup;
|
||||
}
|
||||
break;
|
||||
case TRY_RDLOCK:
|
||||
case TRY_WRLOCK:
|
||||
if (!ast_strlen_zero(args.timeout)) {
|
||||
ast_log(LOG_ERROR, "The trylock functions only take one argument\n");
|
||||
res = -1;
|
||||
goto return_cleanup;
|
||||
}
|
||||
}
|
||||
|
||||
if (!(lock = find_lock(args.name))) {
|
||||
ast_copy_string(buf, "FAILURE", len);
|
||||
res = -1;
|
||||
goto return_cleanup;
|
||||
}
|
||||
|
||||
add_lock_to_chan(chan, lock, lock_type, timeout, buf, len);
|
||||
|
||||
lock = lock_unref(lock);
|
||||
|
||||
return_cleanup:
|
||||
ast_autoservice_stop(chan);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
static int handle_rdlock(struct ast_channel *chan, const char *cmd, char *data,
|
||||
char *buf, size_t len)
|
||||
{
|
||||
return handle_lock(chan, RDLOCK, data, buf, len);
|
||||
}
|
||||
|
||||
static int handle_wrlock(struct ast_channel *chan, const char *cmd, char *data,
|
||||
char *buf, size_t len)
|
||||
{
|
||||
return handle_lock(chan, WRLOCK, data, buf, len);
|
||||
}
|
||||
|
||||
static int handle_tryrdlock(struct ast_channel *chan, const char *cmd, char *data,
|
||||
char *buf, size_t len)
|
||||
{
|
||||
return handle_lock(chan, TRY_RDLOCK, data, buf, len);
|
||||
}
|
||||
|
||||
static int handle_trywrlock(struct ast_channel *chan, const char *cmd, char *data,
|
||||
char *buf, size_t len)
|
||||
{
|
||||
return handle_lock(chan, TRY_WRLOCK, data, buf, len);
|
||||
}
|
||||
|
||||
static int handle_unlock(struct ast_channel *chan, const char *cmd, char *data,
|
||||
char *buf, size_t len)
|
||||
{
|
||||
struct ast_datastore *datastore;
|
||||
struct lock_resource *lock;
|
||||
SaAisErrorT ais_res;
|
||||
int res = 0;
|
||||
|
||||
if (ast_strlen_zero(data)) {
|
||||
ast_log(LOG_ERROR, "DLOCK_UNLOCK requires a lock name\n");
|
||||
ast_copy_string(buf, "FAILURE", len);
|
||||
return -1;
|
||||
}
|
||||
|
||||
ast_autoservice_start(chan);
|
||||
|
||||
ast_channel_lock(chan);
|
||||
datastore = ast_channel_datastore_find(chan, &dlock_datastore_info, data);
|
||||
if (!datastore) {
|
||||
ast_log(LOG_ERROR, "The DLOCK '%s' is not locked by channel '%s'\n",
|
||||
data, chan->name);
|
||||
ast_channel_unlock(chan);
|
||||
ast_copy_string(buf, "FAILURE", len);
|
||||
return -1;
|
||||
}
|
||||
ast_channel_datastore_remove(chan, datastore);
|
||||
ast_channel_unlock(chan);
|
||||
|
||||
lock = datastore->data;
|
||||
ais_res = saLckResourceUnlock(lock->id, SA_TIME_ONE_SECOND * 3);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Error unlocking '%s': %s\n", lock->name,
|
||||
ais_err2str(ais_res));
|
||||
res = -1;
|
||||
ast_copy_string(buf, (ais_res == SA_AIS_ERR_TIMEOUT) ? "TIMEOUT" :
|
||||
"FAILURE", len);
|
||||
} else {
|
||||
ast_copy_string(buf, "SUCCESS", len);
|
||||
}
|
||||
|
||||
datastore->data = lock_unref(lock);
|
||||
ast_channel_datastore_free(datastore);
|
||||
|
||||
ast_autoservice_stop(chan);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
#define LOCK_DESC_COMMON \
|
||||
" The name of the lock can be anything. The first time a named lock gets\n" \
|
||||
"used, it will be automatically created and maintained amongst the cluster.\n" \
|
||||
" The result of this function will be one of the following:\n" \
|
||||
" SUCCESS | TIMEOUT | FAILURE | DEADLOCK\n" DEADLOCK_DESC
|
||||
|
||||
#define DEADLOCK_DESC \
|
||||
" The result, DEADLOCK, can only be provided if the AIS implementation in\n" \
|
||||
"use provides the optional feature of deadlock detection. If the lock fails\n" \
|
||||
"with the result of DEADLOCK, it means that the AIS implementation has\n" \
|
||||
"determined that if this lock were acquired, it would cause a deadlock.\n"
|
||||
|
||||
static struct ast_custom_function dlock_rdlock = {
|
||||
.name = "DLOCK_RDLOCK",
|
||||
.synopsis = "Read-lock a distributed lock",
|
||||
.desc =
|
||||
" This function will read-lock a distributed lock provided by the locking\n"
|
||||
"service of AIS. This is a blocking operation. However, a timeout can be\n"
|
||||
"specified to avoid deadlocks. The default timeout used if one is not\n"
|
||||
"provided as an argument is 3 seconds.\n"
|
||||
LOCK_DESC_COMMON
|
||||
"",
|
||||
.syntax = "DLOCK_RDLOCK(<lock_name>,[timeout])",
|
||||
.read = handle_rdlock,
|
||||
};
|
||||
|
||||
static struct ast_custom_function dlock_wrlock = {
|
||||
.name = "DLOCK_WRLOCK",
|
||||
.synopsis = "Write-lock a distributed lock",
|
||||
.desc =
|
||||
" This function will write-lock a distributed lock provided by the locking\n"
|
||||
"service of AIS. This is a blocking operation. However, a timeout can be\n"
|
||||
"specified to avoid deadlocks. The default timeout used if one is not\n"
|
||||
"provided as an argument is 3 seconds.\n"
|
||||
LOCK_DESC_COMMON
|
||||
"",
|
||||
.syntax = "DLOCK_WRLOCK(<lock_name>,[timeout])",
|
||||
.read = handle_wrlock,
|
||||
};
|
||||
|
||||
static struct ast_custom_function dlock_tryrdlock = {
|
||||
.name = "DLOCK_TRYRDLOCK",
|
||||
.synopsis = "Try to read-lock a distributed lock",
|
||||
.desc =
|
||||
" This function will attempt to read-lock a distributed lock provided by the\n"
|
||||
"locking service of AIS. This is a non-blocking operation.\n"
|
||||
" The name of the lock can be anything. The first time a named lock gets\n"
|
||||
"used, it will be automatically created and maintained amongst the cluster.\n"
|
||||
" The result of this function will be one of the following:\n"
|
||||
" SUCCESS | FAILURE | DEADLOCK\n"
|
||||
DEADLOCK_DESC
|
||||
"",
|
||||
.syntax = "DLOCK_TRYRDLOCK(<lock_name>)",
|
||||
.read = handle_tryrdlock,
|
||||
};
|
||||
|
||||
static struct ast_custom_function dlock_trywrlock = {
|
||||
.name = "DLOCK_TRYWRLOCK",
|
||||
.synopsis = "Try to write-lock a distributed lock",
|
||||
.desc =
|
||||
" This function will attempt to write-lock a distributed lock provided by\n"
|
||||
"the locking service of AIS. This is a non-blocking operation.\n"
|
||||
" The name of the lock can be anything. The first time a named lock gets\n"
|
||||
"used, it will be automatically created and maintained amongst the cluster.\n"
|
||||
" The result of this function will be one of the following:\n"
|
||||
" SUCCESS | FAILURE | DEADLOCK\n"
|
||||
DEADLOCK_DESC
|
||||
"",
|
||||
.syntax = "DLOCK_TRYWRLOCK(<lock_name>)",
|
||||
.read = handle_trywrlock,
|
||||
};
|
||||
|
||||
static struct ast_custom_function dlock_unlock = {
|
||||
.name = "DLOCK_UNLOCK",
|
||||
.synopsis = "Unlock a distributed lock",
|
||||
.desc =
|
||||
" This function will unlock a currently held distributed lock. This should\n"
|
||||
"be used regardless of the lock was read or write locked. The result of\n"
|
||||
"this funtion will be one of the following:\n"
|
||||
" SUCCESS | TIMEOUT | FAILURE\n"
|
||||
"",
|
||||
.syntax = "DLOCK_UNLOCK(<lock_name>)",
|
||||
.read = handle_unlock,
|
||||
};
|
||||
|
||||
int ast_ais_lck_load_module(void)
|
||||
{
|
||||
SaAisErrorT ais_res;
|
||||
int res;
|
||||
|
||||
ais_res = saLckInitialize(&lck_handle, &lck_callbacks, &ais_version);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Could not initialize distributed locking service: %s\n",
|
||||
ais_err2str(ais_res));
|
||||
return -1;
|
||||
}
|
||||
|
||||
res = ast_custom_function_register(&dlock_rdlock);
|
||||
res |= ast_custom_function_register(&dlock_wrlock);
|
||||
res |= ast_custom_function_register(&dlock_tryrdlock);
|
||||
res |= ast_custom_function_register(&dlock_trywrlock);
|
||||
res |= ast_custom_function_register(&dlock_unlock);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
int ast_ais_lck_unload_module(void)
|
||||
{
|
||||
SaAisErrorT ais_res;
|
||||
int res = 0;
|
||||
|
||||
ast_custom_function_unregister(&dlock_rdlock);
|
||||
ast_custom_function_unregister(&dlock_wrlock);
|
||||
ast_custom_function_unregister(&dlock_tryrdlock);
|
||||
ast_custom_function_unregister(&dlock_trywrlock);
|
||||
ast_custom_function_unregister(&dlock_unlock);
|
||||
|
||||
ais_res = saLckFinalize(lck_handle);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Problem stopping distributed locking service: %s\n",
|
||||
ais_err2str(ais_res));
|
||||
res = -1;
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
@ -0,0 +1,193 @@
|
||||
/*
|
||||
* Asterisk -- An open source telephony toolkit.
|
||||
*
|
||||
* Copyright (C) 2007 - 2008, Digium, Inc.
|
||||
*
|
||||
* Russell Bryant <russell@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
|
||||
* \author Russell Bryant <russell@digium.com>
|
||||
*
|
||||
* \brief Usage of the SAForum AIS (Application Interface Specification)
|
||||
*
|
||||
* \arg http://www.openais.org/
|
||||
*
|
||||
* This file contains the common code between the uses of the different AIS
|
||||
* services.
|
||||
*/
|
||||
|
||||
/*** MODULEINFO
|
||||
<depend>SaClm</depend>
|
||||
<depend>SaEvt</depend>
|
||||
***/
|
||||
|
||||
#include "asterisk.h"
|
||||
|
||||
ASTERISK_FILE_VERSION(__FILE__, "$Revision$");
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
#include <signal.h>
|
||||
#include <pthread.h>
|
||||
|
||||
#include "ais/ais.h"
|
||||
|
||||
#include "asterisk/module.h"
|
||||
#include "asterisk/options.h"
|
||||
#include "asterisk/logger.h"
|
||||
#include "asterisk/channel.h"
|
||||
#include "asterisk/utils.h"
|
||||
#include "asterisk/cli.h"
|
||||
|
||||
static struct {
|
||||
pthread_t id;
|
||||
unsigned int stop:1;
|
||||
} dispatch_thread = {
|
||||
.id = AST_PTHREADT_NULL,
|
||||
};
|
||||
|
||||
SaVersionT ais_version = { 'B', 1, 1 };
|
||||
|
||||
static const struct ais_error {
|
||||
SaAisErrorT error;
|
||||
const char *desc;
|
||||
} ais_errors[] = {
|
||||
{ SA_AIS_OK, "OK" },
|
||||
{ SA_AIS_ERR_LIBRARY, "Library Error" },
|
||||
{ SA_AIS_ERR_VERSION, "Version Not Compatible" },
|
||||
{ SA_AIS_ERR_INIT, "Callback Not Registered" },
|
||||
{ SA_AIS_ERR_TIMEOUT, "Timeout" },
|
||||
{ SA_AIS_ERR_TRY_AGAIN , "Try Again" },
|
||||
{ SA_AIS_ERR_INVALID_PARAM, "Invalid Parameter" },
|
||||
{ SA_AIS_ERR_NO_MEMORY, "No Memory" },
|
||||
{ SA_AIS_ERR_BAD_HANDLE, "Invalid Handle" },
|
||||
{ SA_AIS_ERR_BUSY, "Resource Already In Use" },
|
||||
{ SA_AIS_ERR_ACCESS, "Access Denied" },
|
||||
{ SA_AIS_ERR_NOT_EXIST, "Does Not Exist" },
|
||||
{ SA_AIS_ERR_NAME_TOO_LONG, "Name Too Long" },
|
||||
{ SA_AIS_ERR_EXIST, "Already Exists" },
|
||||
{ SA_AIS_ERR_NO_SPACE, "Buffer Too Small" },
|
||||
{ SA_AIS_ERR_INTERRUPT, "Request Interrupted" },
|
||||
{ SA_AIS_ERR_NAME_NOT_FOUND, "Name Not Found" },
|
||||
{ SA_AIS_ERR_NO_RESOURCES, "Not Enough Resources" },
|
||||
{ SA_AIS_ERR_NOT_SUPPORTED, "Requested Function Not Supported" },
|
||||
{ SA_AIS_ERR_BAD_OPERATION, "Operation Not Allowed" },
|
||||
{ SA_AIS_ERR_FAILED_OPERATION, "Operation Failed" },
|
||||
{ SA_AIS_ERR_MESSAGE_ERROR, "Communication Error" },
|
||||
{ SA_AIS_ERR_QUEUE_FULL, "Destination Queue Full" },
|
||||
{ SA_AIS_ERR_QUEUE_NOT_AVAILABLE, "Destination Queue Not Available" },
|
||||
{ SA_AIS_ERR_BAD_FLAGS, "Invalid Flags" },
|
||||
{ SA_AIS_ERR_TOO_BIG, "Value Too Large" },
|
||||
{ SA_AIS_ERR_NO_SECTIONS, "No More Sections to Initialize" },
|
||||
};
|
||||
|
||||
const char *ais_err2str(SaAisErrorT error)
|
||||
{
|
||||
int x;
|
||||
|
||||
for (x = 0; x < ARRAY_LEN(ais_errors); x++) {
|
||||
if (ais_errors[x].error == error)
|
||||
return ais_errors[x].desc;
|
||||
}
|
||||
|
||||
return "Unknown";
|
||||
}
|
||||
|
||||
static void *dispatch_thread_handler(void *data)
|
||||
{
|
||||
SaSelectionObjectT clm_fd, evt_fd, max_fd;
|
||||
int res;
|
||||
fd_set read_fds;
|
||||
SaAisErrorT ais_res;
|
||||
|
||||
ais_res = saClmSelectionObjectGet(clm_handle, &clm_fd);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Failed to retrieve select fd for CLM service. "
|
||||
"This module will not operate.\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ais_res = saEvtSelectionObjectGet(evt_handle, &evt_fd);
|
||||
if (ais_res != SA_AIS_OK) {
|
||||
ast_log(LOG_ERROR, "Failed to retrieve select fd for EVT service. "
|
||||
"This module will not operate.\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
max_fd = clm_fd > evt_fd ? clm_fd : evt_fd;
|
||||
|
||||
while (!dispatch_thread.stop) {
|
||||
FD_ZERO(&read_fds);
|
||||
FD_SET(clm_fd, &read_fds);
|
||||
FD_SET(evt_fd, &read_fds);
|
||||
|
||||
res = ast_select(max_fd + 1, &read_fds, NULL, NULL, NULL);
|
||||
if (res == -1 && errno != EINTR && errno != EAGAIN) {
|
||||
ast_log(LOG_ERROR, "Select error (%s) dispatch thread going away now, "
|
||||
"and the module will no longer operate.\n", strerror(errno));
|
||||
break;
|
||||
}
|
||||
|
||||
if (FD_ISSET(clm_fd, &read_fds))
|
||||
saClmDispatch(clm_handle, SA_DISPATCH_ALL);
|
||||
if (FD_ISSET(evt_fd, &read_fds))
|
||||
saEvtDispatch(evt_handle, SA_DISPATCH_ALL);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int load_module(void)
|
||||
{
|
||||
if (ast_ais_clm_load_module())
|
||||
goto return_error;
|
||||
|
||||
if (ast_ais_evt_load_module())
|
||||
goto evt_failed;
|
||||
|
||||
if (ast_pthread_create_background(&dispatch_thread.id, NULL,
|
||||
dispatch_thread_handler, NULL)) {
|
||||
ast_log(LOG_ERROR, "Error starting AIS dispatch thread.\n");
|
||||
goto dispatch_failed;
|
||||
}
|
||||
|
||||
return AST_MODULE_LOAD_SUCCESS;
|
||||
|
||||
dispatch_failed:
|
||||
ast_ais_evt_unload_module();
|
||||
evt_failed:
|
||||
ast_ais_clm_unload_module();
|
||||
return_error:
|
||||
return AST_MODULE_LOAD_DECLINE;
|
||||
}
|
||||
|
||||
static int unload_module(void)
|
||||
{
|
||||
ast_ais_clm_unload_module();
|
||||
ast_ais_evt_unload_module();
|
||||
|
||||
if (dispatch_thread.id != AST_PTHREADT_NULL) {
|
||||
dispatch_thread.stop = 1;
|
||||
pthread_kill(dispatch_thread.id, SIGURG); /* poke! */
|
||||
pthread_join(dispatch_thread.id, NULL);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "SAForum AIS");
|
||||
Loading…
Reference in new issue