Author: lzwierko
Date: Wed Oct 31 19:45:46 2007
New Revision: 6117
Modified:
freeswitch/trunk/src/mod/endpoints/mod_opal/mod_opal.cpp
freeswitch/trunk/src/mod/endpoints/mod_opal/opal_backend.cpp
Log:
Modified: freeswitch/trunk/src/mod/endpoints/mod_opal/mod_opal.cpp
==============================================================================
--- freeswitch/trunk/src/mod/endpoints/mod_opal/mod_opal.cpp (original)
+++ freeswitch/trunk/src/mod/endpoints/mod_opal/mod_opal.cpp Wed Oct 31 19:45:46 2007
@@ -63,9 +63,196 @@
/**
* Declaration of private variables
*/
-static FSOpalManager *opal_manager = NULL;
static switch_memory_pool_t *opal_pool = NULL;
-static switch_endpoint_interface_t *opalh323_endpoint_interface;
+static switch_endpoint_interface_t *opalh323_endpoint_interface = NULL;
+
+/**
+ * Declaration of PProces ancestor for OpalManager starting
+ *
+ */
+class OpalStartProcess : public PProcess
+{
+ PCLASSINFO(OpalStartProcess, PProcess)
+
+ public:
+
+
+ /**
+ * This dunction creates new instace of
+ * OpalStartProcess and starts it's task
+ */
+ static void createInstance(
+ const char* i_moduleName,
+ switch_memory_pool_t *i_memoryPool,
+ switch_endpoint_interface_t *i_endpointInterface)
+ {
+ assert(!s_startProcess);
+ assert(i_moduleName);
+ assert(i_memoryPool);
+ assert(i_endpointInterface);
+
+ PProcess::PreInitialise(0, NULL, NULL);
+ s_startProcess = new OpalStartProcess(i_moduleName,i_memoryPool,i_endpointInterface);
+ assert(s_startProcess);
+ if(!s_startProcess)
+ {
+ return;
+ }
+ s_startProcess->_main(); /* run process */
+ delete s_startProcess; /* delete opal manager instance */
+ s_startProcess = NULL; /* clear pointer */
+ }
+
+ static OpalStartProcess* getInstance()
+ {
+ assert(s_startProcess);
+ return s_startProcess;
+ }
+
+ OpalStartProcess(
+ const char* i_moduleName,
+ switch_memory_pool_t *i_memoryPool,
+ switch_endpoint_interface_t *i_endpointInterface
+ ):
+ PProcess("FreeSWITCH", "mod_opal"),
+ m_pStopCondition(NULL),
+ m_pWaitCondition(NULL),
+ m_pModuleName(i_moduleName),
+ m_pMemoryPool(i_memoryPool),
+ m_pEndpointInterface(i_endpointInterface)
+ {
+
+
+ switch_status_t status = switch_thread_cond_create(&m_pStopCondition, m_pMemoryPool);
+ assert(status==SWITCH_STATUS_SUCCESS);
+ if(status!=SWITCH_STATUS_SUCCESS)
+ {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Can not init stop condition.");
+ return;
+ }
+
+ status = switch_thread_cond_create(&m_pWaitCondition, m_pMemoryPool);
+ assert(status==SWITCH_STATUS_SUCCESS);
+ if(status!=SWITCH_STATUS_SUCCESS)
+ {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Can not init wait condition.");
+ return;
+ }
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "OpalStartProcess created\n");
+ }
+
+ ~OpalStartProcess()
+ {
+ switch_thread_cond_destroy(m_pWaitCondition);
+ switch_thread_cond_destroy(m_pStopCondition);
+
+ m_pModuleName = NULL;
+ m_pMemoryPool = NULL;
+ m_pEndpointInterface = NULL;
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "OpalStartProcess deleted\n");
+ }
+
+ FSOpalManager *getManager()
+ {
+ assert(!m_pFSOpalManager);
+ return m_pFSOpalManager;
+ }
+
+ /* main task of this PProcess */
+ void Main()
+ {
+ /* backend initialization */
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Begin opal backend init\n");
+ m_pFSOpalManager = new FSOpalManager();
+ assert(m_pFSOpalManager);
+ if(!m_pFSOpalManager) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Can not create opal manger\n");
+ return;
+ }
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Opal manager created\n");
+
+ if(!m_pFSOpalManager->initialize(m_pModuleName, m_pMemoryPool, m_pEndpointInterface))
+ {
+ delete m_pFSOpalManager;
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Can not initialize opal manger\n");
+ return; /* if can't initialize return general error */
+ }
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Opal manager initilaized and running\n");
+ WaitUntilStopped();
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "OpalStartProcess received stop signal\n");
+ delete m_pFSOpalManager;
+ m_pFSOpalManager = NULL;
+ switch_thread_cond_signal(m_pWaitCondition); /* signal task waiting that it's all over ... */
+ }
+
+ /**
+ * Waits until this process is terminated
+ * which means it exits Main() function
+ */
+ void WaitProcess()
+ {
+ switch_mutex_t* mutex = NULL;
+ switch_status_t status = switch_mutex_init(&mutex,SWITCH_MUTEX_NESTED,m_pMemoryPool);
+ if(status!=SWITCH_STATUS_SUCCESS)
+ {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Error acquiring mutex!\n");
+ assert(0);
+ return;
+ }
+ switch_mutex_lock(mutex);
+ switch_thread_cond_wait(m_pWaitCondition,mutex);
+ switch_mutex_unlock(mutex);
+ switch_mutex_destroy(mutex);
+ }
+
+ /**
+ * Waits until this process is terminated
+ * which means it exits Main() function
+ */
+ void StopProcessAndWait()
+ {
+ switch_mutex_lock(m_pStopMutex)
+ switch_thread_cond_signal(m_pStopCondition);
+ }
+
+ protected:
+
+ /*
+ * After entering this functon, process
+ * locks o condition
+ * and stays there until signalled
+ */
+
+ void WaitUntilStopped()
+ {
+ switch_mutex_t* mutex = NULL;
+ switch_status_t status = switch_mutex_init(&mutex, SWITCH_MUTEX_NESTED, m_pMemoryPool);
+ if(status!=SWITCH_STATUS_SUCCESS)
+ {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"Error acquiring mutex!\n");
+ assert(0);
+ return;
+ }
+ switch_mutex_lock(mutex);
+ switch_thread_cond_wait(m_pStopCondition, mutex);
+ switch_mutex_unlock(mutex);
+ switch_mutex_destroy(mutex);
+ }
+
+ static OpalStartProcess *s_startProcess;
+
+ const char *m_pModuleName;
+ switch_memory_pool_t *m_pMemoryPool;
+ switch_endpoint_interface_t *m_pEndpointInterface;
+ FSOpalManager *m_pFSOpalManager;
+ switch_thread_cond_t *m_pStopCondition; /* the main thread waits on this condition until is to be stopped */
+ switch_thread_cond_t *m_pWaitCondition; /* condition for managing thread to wait on until this process exits */
+ switch_mutex_t *m_pStopMutex;
+ switch_mutex_t *m_pWaitMutex;
+
+
+};
+OpalStartProcess* OpalStartProcess::s_startProcess = NULL;
/*
* IO routines handlers set declaration
@@ -99,19 +286,19 @@
*/
SWITCH_MODULE_LOAD_FUNCTION(mod_opal_load);
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_opal_shutdown);
-SWITCH_MODULE_DEFINITION(mod_opal, mod_opal_load, mod_opal_shutdown, NULL);
+SWITCH_MODULE_RUNTIME_FUNCTION(mod_opal_runtime);
+SWITCH_MODULE_DEFINITION(mod_opal, mod_opal_load, mod_opal_shutdown, mod_opal_runtime);
/*
* This function is called on module load
- * It sets up:
- * 1. frontend - interface to FreeSWITCH core
- * 2. backend - inerface to OPAL core
+ * It sets up frontend interface to FS
*
*/
SWITCH_MODULE_LOAD_FUNCTION(mod_opal_load)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"Starting loading mod_opal\n");
+ opal_pool = pool;
/* frontend initialization*/
*module_interface =NULL;
*module_interface = switch_loadable_module_create_module_interface(pool, modname);
@@ -123,28 +310,22 @@
return SWITCH_STATUS_MEMERR;
}
opalh323_endpoint_interface = (switch_endpoint_interface_t*)switch_loadable_module_create_interface(*module_interface, SWITCH_ENDPOINT_INTERFACE);
- opalh323_endpoint_interface->interface_name = "OPALH323";
+ opalh323_endpoint_interface->interface_name = "OpalH323";
opalh323_endpoint_interface->io_routines = &opalh323_io_routines;
opalh323_endpoint_interface->state_handler = &opalh323_event_handlers;
-
- /* backend initialization */
- opal_manager = new FSOpalManager();
- assert(opal_manager);
- if(!opal_manager)
- {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"Can not create opal manger\n");
- return SWITCH_STATUS_MEMERR;
- }
-
- if(!opal_manager->initialize(modname,pool,opalh323_endpoint_interface))
- {
- delete opal_manager;
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"Can not initialize opal manger\n");
- return SWITCH_STATUS_FALSE; /* if can't initialize return general error */
- }
-
- /* indicate that the module should continue to be loaded */
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"mod_opal loaded ok!\n");
+
+ return SWITCH_STATUS_SUCCESS;
+}
+
+/*
+ * This function is called after module initilization
+ * It sets up and run backend interface to opal
+ *
+ */
+
+SWITCH_MODULE_RUNTIME_FUNCTION(mod_opal_runtime)
+{
+ OpalStartProcess::createInstance(modname,opal_pool,opalh323_endpoint_interface);
return SWITCH_STATUS_SUCCESS;
}
@@ -157,7 +338,9 @@
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_opal_shutdown)
{
/* deallocate OPAL manager */
- delete opal_manager;
+
+ OpalStartProcess::getInstance()->StopProcess(); /* terminate process */
+ OpalStartProcess::getInstance()->WaitProcess(); /* wait here until stopped */
return SWITCH_STATUS_SUCCESS;
}
@@ -170,62 +353,62 @@
switch_core_session_t **new_session,
switch_memory_pool_t **pool)
{
- return opal_manager->io_outgoing_channel(session,outbound_profile,new_session,pool);
+ return OpalStartProcess::getInstance()->getManager()->io_outgoing_channel(session,outbound_profile,new_session,pool);
}
static switch_status_t opalh323_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id)
{
- return opal_manager->io_read_frame(session,frame,timeout,flags,stream_id);
+ return OpalStartProcess::getInstance()->getManager()->io_read_frame(session,frame,timeout,flags,stream_id);
}
static switch_status_t opalh323_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id)
{
- return opal_manager->io_write_frame(session,frame,timeout,flags,stream_id);
+ return OpalStartProcess::getInstance()->getManager()->io_write_frame(session,frame,timeout,flags,stream_id);
}
static switch_status_t opalh323_kill_channel(switch_core_session_t *session, int sig)
{
- return opal_manager->io_kill_channel(session,sig);
+ return OpalStartProcess::getInstance()->getManager()->io_kill_channel(session,sig);
}
static switch_status_t opalh323_waitfor_read(switch_core_session_t *session, int ms, int stream_id)
{
- return opal_manager->io_waitfor_read(session,ms,stream_id);
+ return OpalStartProcess::getInstance()->getManager()->io_waitfor_read(session,ms,stream_id);
}
static switch_status_t opalh323_waitfor_write(switch_core_session_t *session, int ms, int stream_id)
{
- return opal_manager->io_waitfor_write(session,ms,stream_id);
+ return OpalStartProcess::getInstance()->getManager()->io_waitfor_write(session,ms,stream_id);
}
static switch_status_t opalh323_send_dtmf(switch_core_session_t *session, char *dtmf)
{
- return opal_manager->io_send_dtmf(session,dtmf);
+ return OpalStartProcess::getInstance()->getManager()->io_send_dtmf(session,dtmf);
}
static switch_status_t opalh323_receive_message(switch_core_session_t *session, switch_core_session_message_t *msg)
{
- return opal_manager->io_receive_message(session,msg);
+ return OpalStartProcess::getInstance()->getManager()->io_receive_message(session,msg);
}
static switch_status_t opalh323_receive_event(switch_core_session_t *session, switch_event_t *event)
{
- return opal_manager->io_receive_event(session,event);
+ return OpalStartProcess::getInstance()->getManager()->io_receive_event(session,event);
}
static switch_status_t opalh323_state_change(switch_core_session_t *session)
{
- return opal_manager->io_state_change(session);
+ return OpalStartProcess::getInstance()->getManager()->io_state_change(session);
}
static switch_status_t opalh323_read_video_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flag, int stream_id)
{
- return opal_manager->io_read_video_frame(session,frame,timeout,flag,stream_id);
+ return OpalStartProcess::getInstance()->getManager()->io_read_video_frame(session,frame,timeout,flag,stream_id);
}
static switch_status_t opalh323_write_video_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flag, int stream_id)
{
- return opal_manager->io_write_video_frame(session,frame,timeout,flag,stream_id);
+ return OpalStartProcess::getInstance()->getManager()->io_write_video_frame(session,frame,timeout,flag,stream_id);
}
/*
@@ -234,30 +417,30 @@
static switch_status_t opalh323_on_init(switch_core_session_t *session)
{
- return opal_manager->callback_on_init(session);
+ return OpalStartProcess::getInstance()->getManager()->callback_on_init(session);
}
static switch_status_t opalh323_on_ring(switch_core_session_t *session)
{
- return opal_manager->callback_on_ring(session);
+ return OpalStartProcess::getInstance()->getManager()->callback_on_ring(session);
}
static switch_status_t opalh323_on_execute(switch_core_session_t *session)
{
- return opal_manager->callback_on_execute(session);
+ return OpalStartProcess::getInstance()->getManager()->callback_on_execute(session);
}
static switch_status_t opalh323_on_hangup(switch_core_session_t *session)
{
- return opal_manager->callback_on_hangup(session);
+ return OpalStartProcess::getInstance()->getManager()->callback_on_hangup(session);
}
static switch_status_t opalh323_on_loopback(switch_core_session_t *session)
{
- return opal_manager->callback_on_loopback(session);
+ return OpalStartProcess::getInstance()->getManager()->callback_on_loopback(session);
}
static switch_status_t opalh323_on_transmit(switch_core_session_t *session)
{
- return opal_manager->callback_on_transmit(session);
+ return OpalStartProcess::getInstance()->getManager()->callback_on_transmit(session);
}
Modified: freeswitch/trunk/src/mod/endpoints/mod_opal/opal_backend.cpp
==============================================================================
--- freeswitch/trunk/src/mod/endpoints/mod_opal/opal_backend.cpp (original)
+++ freeswitch/trunk/src/mod/endpoints/mod_opal/opal_backend.cpp Wed Oct 31 19:45:46 2007
@@ -105,16 +105,14 @@
switch_memory_pool_t* i_memoryPool,
switch_endpoint_interface_t *i_endpointInterface
)
-{
+{
/* check if not initialized */
- assert(m_isInitialized);
-
+ assert(!m_isInitialized);
/* check input parameters */
assert(i_modName);
assert(i_memoryPool);
assert(i_endpointInterface);
-
m_pModuleName = i_modName;
m_pMemoryPool = i_memoryPool;
m_pH323EndpointInterface = i_endpointInterface;
@@ -126,7 +124,7 @@
*/
if(switch_core_hash_init(&m_pSessionsHashTable,m_pMemoryPool)!=SWITCH_STATUS_SUCCESS)
- {
+ {
assert(0);
return false;
}