From e16f28d52952790577f68724945cf34231a74bfe Mon Sep 17 00:00:00 2001 From: Anthony Minessale Date: Wed, 14 Dec 2005 20:22:19 +0000 Subject: [PATCH] update git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@151 d0543943-73ff-0310-b7d9-9358b9ac24b2 --- src/include/switch_event.h | 8 ++ src/include/switch_types.h | 6 +- src/mod/mod_event_test/mod_event_test.c | 4 +- src/switch_config.c | 2 +- src/switch_core.c | 22 ++-- src/switch_event.c | 146 ++++++++++++++++++++---- 6 files changed, 152 insertions(+), 36 deletions(-) diff --git a/src/include/switch_event.h b/src/include/switch_event.h index 29ea30588c..8603ca044e 100644 --- a/src/include/switch_event.h +++ b/src/include/switch_event.h @@ -38,6 +38,13 @@ extern "C" { #include +struct switch_event { + switch_event_t event; + int subclass; + char *data; + struct switch_event *next; +}; + struct switch_event_node { char *id; switch_event_t event; @@ -46,6 +53,7 @@ struct switch_event_node { struct switch_event_node *next; }; +SWITCH_DECLARE(switch_status) switch_event_shutdown(void); SWITCH_DECLARE(switch_status) switch_event_init(switch_memory_pool *pool); SWITCH_DECLARE(switch_status) switch_event_fire_subclass(switch_event_t event, int subclass, char *data); SWITCH_DECLARE(switch_status) switch_event_bind(char *id, switch_event_t event, int subclass, switch_event_callback_t callback); diff --git a/src/include/switch_types.h b/src/include/switch_types.h index 211cb9b7ab..27d29db491 100644 --- a/src/include/switch_types.h +++ b/src/include/switch_types.h @@ -135,8 +135,10 @@ typedef enum { SWITCH_EVENT_ALL } switch_event_t; +typedef struct switch_event switch_event; typedef struct switch_event_node switch_event_node; -typedef void (*switch_event_callback_t)(switch_event_t, int, char *); +typedef void (*switch_event_callback_t)(switch_event *); +typedef apr_threadattr_t switch_threadattr_t; typedef struct switch_loadable_module switch_loadable_module; typedef struct switch_frame switch_frame; typedef struct switch_channel switch_channel; @@ -275,6 +277,8 @@ typedef apr_hash_index_t switch_hash_index_t; #define switch_hash_first apr_hash_first #define switch_hash_next apr_hash_next #define switch_hash_this apr_hash_this +#define switch_threadattr_create apr_threadattr_create +#define switch_threadattr_detach_set apr_threadattr_detach_set #define SWITCH_FOPEN_READ APR_FOPEN_READ #define SWITCH_FOPEN_WRITE APR_FOPEN_WRITE diff --git a/src/mod/mod_event_test/mod_event_test.c b/src/mod/mod_event_test/mod_event_test.c index 5f1f82e492..2e21c771ea 100644 --- a/src/mod/mod_event_test/mod_event_test.c +++ b/src/mod/mod_event_test/mod_event_test.c @@ -33,9 +33,9 @@ static const char modname[] = "mod_event_test"; -static void event_handler (switch_event_t event, int subclass, char *data) +static void event_handler (switch_event *event) { - switch_console_printf(SWITCH_CHANNEL_CONSOLE,"*** OK *** I got event [%s] subclass [%d] data [%s]\n", switch_event_name(event), subclass, data); + switch_console_printf(SWITCH_CHANNEL_CONSOLE,"*** OK *** I got event [%s] subclass [%d] data [%s]\n", switch_event_name(event->event), event->subclass, event->data); } static switch_loadable_module_interface event_test_module_interface = { diff --git a/src/switch_config.c b/src/switch_config.c index fcbd46558b..e3014be383 100644 --- a/src/switch_config.c +++ b/src/switch_config.c @@ -108,7 +108,7 @@ SWITCH_DECLARE(int) switch_config_next_pair(switch_config *cfg, char **var, char *end = '\0'; end--; } else if ((end = strchr(*var, '\n'))) { - if (*end - 1 == '\r') { + if (*(end - 1) == '\r') { end--; } *end = '\0'; diff --git a/src/switch_core.c b/src/switch_core.c index ce62813506..bd5a584de9 100644 --- a/src/switch_core.c +++ b/src/switch_core.c @@ -1350,9 +1350,9 @@ SWITCH_DECLARE(void *) switch_core_hash_find(switch_hash *hash, char *key) SWITCH_DECLARE(void) switch_core_launch_module_thread(switch_thread_start_t func, void *obj) { switch_thread *thread; - apr_threadattr_t *thd_attr;; - apr_threadattr_create(&thd_attr, runtime.memory_pool); - apr_threadattr_detach_set(thd_attr, 1); + switch_threadattr_t *thd_attr;; + switch_threadattr_create(&thd_attr, runtime.memory_pool); + switch_threadattr_detach_set(thd_attr, 1); switch_thread_create(&thread, thd_attr, @@ -1388,9 +1388,9 @@ static void * SWITCH_THREAD_FUNC switch_core_session_thread(switch_thread *threa SWITCH_DECLARE(void) switch_core_session_thread_launch(switch_core_session *session) { switch_thread *thread; - apr_threadattr_t *thd_attr;; - apr_threadattr_create(&thd_attr, session->pool); - apr_threadattr_detach_set(thd_attr, 1); + switch_threadattr_t *thd_attr;; + switch_threadattr_create(&thd_attr, session->pool); + switch_threadattr_detach_set(thd_attr, 1); if (switch_thread_create(&thread, thd_attr, @@ -1406,9 +1406,9 @@ SWITCH_DECLARE(void) switch_core_session_thread_launch(switch_core_session *sess SWITCH_DECLARE(void) switch_core_session_launch_thread(switch_core_session *session, switch_thread_start_t func, void *obj) { switch_thread *thread; - apr_threadattr_t *thd_attr;; - apr_threadattr_create(&thd_attr, session->pool); - apr_threadattr_detach_set(thd_attr, 1); + switch_threadattr_t *thd_attr;; + switch_threadattr_create(&thd_attr, session->pool); + switch_threadattr_detach_set(thd_attr, 1); switch_thread_create(&thread, thd_attr, @@ -1548,6 +1548,10 @@ SWITCH_DECLARE(switch_status) switch_core_init(void) SWITCH_DECLARE(switch_status) switch_core_destroy(void) { + + switch_event_shutdown(); + switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Closing Event Engine.\n"); + if (runtime.memory_pool) { apr_pool_destroy(runtime.memory_pool); apr_terminate(); diff --git a/src/switch_event.c b/src/switch_event.c index fc1eef8bd1..17e133ed37 100644 --- a/src/switch_event.c +++ b/src/switch_event.c @@ -31,9 +31,15 @@ */ #include +static switch_event *EVENT_QUEUE_HEAD; +static switch_event *EVENT_QUEUE_WORK; static switch_event_node *EVENT_NODES[SWITCH_EVENT_ALL+1] = {NULL}; static switch_mutex_t *ELOCK = NULL; +static switch_mutex_t *MUTEX = NULL; static switch_memory_pool *EPOOL = NULL; +switch_thread_cond_t *COND; + +static int THREAD_RUNNING = 0; /* make sure this is synced with the switch_event_t enum in switch_types.h also never put any new ones before EVENT_ALL @@ -48,40 +54,130 @@ static char *EVENT_NAMES[] = { "ALL" }; -SWITCH_DECLARE(char *) switch_event_name(switch_event_t event) -{ - return EVENT_NAMES[event]; -} - -SWITCH_DECLARE(switch_status) switch_event_init(switch_memory_pool *pool) -{ - assert(pool != NULL); - EPOOL = pool; - switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Activate Eventing Engine.\n"); - return switch_mutex_init(&ELOCK, SWITCH_MUTEX_NESTED, EPOOL); -} - -SWITCH_DECLARE(switch_status) switch_event_fire_subclass(switch_event_t event, int subclass, char *data) +static void * SWITCH_THREAD_FUNC switch_event_thread(switch_thread *thread, void *obj) { switch_event_node *enp; + switch_event *event = NULL, *out_event = NULL; switch_event_t e; assert(ELOCK != NULL); assert(EPOOL != NULL); - for(e = event;; e = SWITCH_EVENT_ALL) { - for(enp = EVENT_NODES[e]; enp; enp = enp->next) { - if ((enp->event == event || enp->event == SWITCH_EVENT_ALL) && (enp->subclass == subclass || enp->subclass < 0)) { - enp->callback(event, subclass, data); - } - } - - if (e == SWITCH_EVENT_ALL) { - break; + THREAD_RUNNING = 1; + while(THREAD_RUNNING == 1) { + switch_thread_cond_wait(COND, MUTEX); + + if (THREAD_RUNNING == 1) { + switch_mutex_lock(ELOCK); + /* -----------------------------------------------*/ + EVENT_QUEUE_WORK = EVENT_QUEUE_HEAD; + EVENT_QUEUE_HEAD = NULL; + switch_mutex_unlock(ELOCK); + /* -----------------------------------------------*/ } + for(event = EVENT_QUEUE_WORK; event;) { + out_event = event; + event = event->next; + out_event->next = NULL; + if (THREAD_RUNNING == 1) { + for(e = out_event->event;; e = SWITCH_EVENT_ALL) { + for(enp = EVENT_NODES[e]; enp; enp = enp->next) { + if ((enp->event == out_event->event || enp->event == SWITCH_EVENT_ALL) && (enp->subclass == out_event->subclass || enp->subclass < 0)) { + enp->callback(out_event); + } + } + + if (e == SWITCH_EVENT_ALL) { + break; + } + } + } + free(out_event->data); + free(out_event); + } + } + THREAD_RUNNING = 0; + return NULL; +} + + +SWITCH_DECLARE(char *) switch_event_name(switch_event_t event) +{ + assert(ELOCK != NULL); + assert(EPOOL != NULL); + + return EVENT_NAMES[event]; +} + +SWITCH_DECLARE(switch_status) switch_event_shutdown(void) +{ + THREAD_RUNNING = -1; + + switch_thread_cond_signal(COND); + + while(THREAD_RUNNING) { + switch_yield(100); + } + return SWITCH_STATUS_SUCCESS; +} + +SWITCH_DECLARE(switch_status) switch_event_init(switch_memory_pool *pool) +{ + switch_thread *thread; + switch_threadattr_t *thd_attr;; + switch_threadattr_create(&thd_attr, pool); + switch_threadattr_detach_set(thd_attr, 1); + + + assert(pool != NULL); + EPOOL = pool; + switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Activate Eventing Engine.\n"); + switch_mutex_init(&ELOCK, SWITCH_MUTEX_NESTED, EPOOL); + + switch_mutex_init(&MUTEX, SWITCH_MUTEX_NESTED, pool); + switch_thread_cond_create(&COND, pool); + switch_mutex_lock(MUTEX); + + switch_thread_create(&thread, + thd_attr, + switch_event_thread, + NULL, + pool + ); + + + return SWITCH_STATUS_SUCCESS; + +} + +SWITCH_DECLARE(switch_status) switch_event_fire_subclass(switch_event_t event, int subclass, char *data) +{ + + switch_event *new_event; + + assert(ELOCK != NULL); + assert(EPOOL != NULL); + + if (!(new_event = malloc(sizeof(*new_event)))) { + return SWITCH_STATUS_MEMERR; } + memset(new_event, 0, sizeof(*new_event)); + new_event->event = event; + new_event->subclass = subclass; + new_event->data = strdup(data ? data : ""); + + switch_mutex_lock(ELOCK); + /* -----------------------------------------------*/ + if (EVENT_QUEUE_HEAD) { + new_event->next = EVENT_QUEUE_HEAD; + } + EVENT_QUEUE_HEAD = new_event; + switch_mutex_unlock(ELOCK); + /* -----------------------------------------------*/ + + switch_thread_cond_signal(COND); return SWITCH_STATUS_SUCCESS; } @@ -93,6 +189,8 @@ SWITCH_DECLARE(switch_status) switch_event_bind(char *id, switch_event_t event, assert(EPOOL != NULL); if (event <= SWITCH_EVENT_ALL && (event_node = switch_core_alloc(EPOOL, sizeof(switch_event_node)))) { + switch_mutex_lock(ELOCK); + /* -----------------------------------------------*/ event_node->id = switch_core_strdup(EPOOL, id); event_node->event = event; event_node->subclass = subclass; @@ -101,6 +199,8 @@ SWITCH_DECLARE(switch_status) switch_event_bind(char *id, switch_event_t event, event_node->next = EVENT_NODES[event]; } EVENT_NODES[event] = event_node; + switch_mutex_unlock(ELOCK); + /* -----------------------------------------------*/ return SWITCH_STATUS_SUCCESS; }