freeswitch系列6数据库

1. 数据库体系

freeswitch默认使用sqlite3数据库，但也支持odbc使用其它数据库，或者PostgreSQL这是支持的三类数据库类型，从定义可以看出。

 

1. typedef enum {  
2.     SCDB_TYPE_CORE_DB,  
3.     SCDB_TYPE_ODBC,  
4.     SCDB_TYPE_PGSQL  
5. } switch_cache_db_handle_type_t;  

 

 

switch_core_db.c实现sqlite核心数据库，switch_odbc.c实现例如MySQL的数据库，switch_pgsql.c实现PostgreSQL数据库。另外switch_core_sqldb.c是数据库抽象层，屏蔽调用具体的数据库API，向外提供统一的数据库操作API。

 

1. typedef union {  
2.     switch_core_db_t *core_db_dbh;  
3.     switch_odbc_handle_t *odbc_dbh;  
4.     switch_pgsql_handle_t *pgsql_dbh;  
5. } switch_cache_db_native_handle_t;  

 

sqldb统一使用switch_cache_db_native_handle_t作为数据库实例，这是一个联合体。

1. 初始化

1. SWITCH_DECLARE(switch_status_t) switch_core_init(switch_core_flag_t flags, switch_bool_t console, const char **err)  
2. {  
3.     runtime.max_db_handles = 50;  
4.     runtime.db_handle_timeout = 5000000;  
5.     runtime.dbname = "core";  
6.     runtime.odbc_dbtype = DBTYPE_DEFAULT;  
7.     runtime.dbname = NULL;  
8.   
9.     if (sqlite3_initialize() != SQLITE_OK) {  
10.         *err = "FATAL ERROR! Could not initialize SQLite\n";  
11.         return SWITCH_STATUS_MEMERR;  
12.     }  
13.   
14.     if (switch_core_sqldb_start(runtime.memory_pool, switch_test_flag((&runtime), SCF_USE_SQL) ? SWITCH_TRUE : SWITCH_FALSE) != SWITCH_STATUS_SUCCESS) {  
15.         *err = "Error activating database";  
16.         return SWITCH_STATUS_FALSE;  
17.     }  
18.   
19.     return SWITCH_STATUS_SUCCESS;  
20. } 

 

在核心初始化的时候，调用了sqlite初始化核心数据库，然后调用sqldb_start启动数据库。

1. 1. 数据库管理者

 

1. static struct {  
2.     switch_memory_pool_t *memory_pool;  
3.     switch_thread_t *db_thread;  
4.     int db_thread_running;  
5.     switch_bool_t manage;  
6.     switch_mutex_t *io_mutex;  
7.     switch_mutex_t *dbh_mutex;  
8.     switch_mutex_t *ctl_mutex;  
9.     switch_cache_db_handle_t *handle_pool;  
10.     uint32_t total_handles;  
11.     uint32_t total_used_handles;  
12.     switch_cache_db_handle_t *dbh;  
13.     switch_sql_queue_manager_t *qm;  
14.     int paused;  
15. } sql_manager;  

 

sql_manager管理所有的数据库，其中handle_pool是数据实例池，所以freeswitch同时支持多个不同的数据库，比如某个数据库使用sqlite，另一个数据库使用mysql，dbh则指向当前使用的数据库。qm是core.db使用的sql队列，sql的执行是在独立线程上执行的，其它数据库比如sip，需要使用自己的sql_queue。

 

1. 1. 启动数据库

启动数据库，初始化一些sql_manage的成员，然后通过switch_core_sqldb_start打开数据库，并重建表，最后启动数据库线程switch_core_sqldb_start_thread。

 

1. switch_status_t switch_core_sqldb_start(switch_memory_pool_t *pool, switch_bool_t manage)  
2. {  
3.     switch_threadattr_t *thd_attr;  
4.   
5.     sql_manager.memory_pool = pool;  
6.     sql_manager.manage = manage;  
7.   
8.     if (!sql_manager.manage) goto skip;  
9.   
10.  top:     
11.   
12.     /* 打开数据库 */  
13.     if (switch_core_db_handle(&sql_manager.dbh) != SWITCH_STATUS_SUCCESS) {  
14.         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Opening DB!\n");  
15.         return SWITCH_STATUS_FALSE;  
16.     }  
17.   
18.   
19.     switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Opening DB\n");  
20.   
21.     //执行清空表、创建表等操作  
22.     switch (sql_manager.dbh->type) {  
23.     case SCDB_TYPE_PGSQL:  
24.     case SCDB_TYPE_ODBC:  
25.         break;  
26.     case SCDB_TYPE_CORE_DB:  
27.         {  
28.         }  
29.         break;  
30.     }  
31.   
32.  skip:  
33.   
34.     if (sql_manager.manage) {  
35.         switch_threadattr_create(&thd_attr, sql_manager.memory_pool);  
36.         switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);  
37.         switch_threadattr_priority_set(thd_attr, SWITCH_PRI_REALTIME);  
38.         //启动数据库线程  
39.         switch_core_sqldb_start_thread();  
40.         switch_thread_create(&sql_manager.db_thread, thd_attr, switch_core_sql_db_thread, NULL, sql_manager.memory_pool);  
41.   
42.     }  
43.   
44.     switch_cache_db_release_db_handle(&sql_manager.dbh);  
45.   
46.     return SWITCH_STATUS_SUCCESS;  
47. } 

 

 

1. 打开数据库
   1. switch_core_db_handle

1. SWITCH_DECLARE(switch_status_t) _switch_core_db_handle(switch_cache_db_handle_t **dbh, const char *file, const char *func, int line)  
2. {  
3.     switch_status_t r;  
4.     char *dsn;  
5.       
6.     if (!sql_manager.manage) {  
7.         return SWITCH_STATUS_FALSE;  
8.     }  
9.   
10.     if (!zstr(runtime.odbc_dsn)) {  
11.         dsn = runtime.odbc_dsn;  
12.     } else if (!zstr(runtime.dbname)) {  
13.         dsn = runtime.dbname;  
14.     } else {  
15.         dsn = "core";  
16.     }  
17.   
18.     if ((r = _switch_cache_db_get_db_handle_dsn(dbh, dsn, file, func, line)) != SWITCH_STATUS_SUCCESS) {  
19.         *dbh = NULL;  
20.     }  
21.       
22.     return r;  
23. }  

 

打开数据库实际就是使用全局配置runtime.odbc_dsn作为路径，这个参数在解析配置的时候有讲过，这里不再说明，然后调用 _switch_cache_db_get_db_handle_dsn底层接口去打开数据库。

1. 1. _switch_cache_db_get_db_handle_dsn
2. SWITCH_DECLARE(switch_status_t) _switch_cache_db_get_db_handle_dsn(switch_cache_db_handle_t **dbh, const char *dsn,   
3.                                                                    const char *file, const char *func, int line)  
4. {  
5.     switch_cache_db_connection_options_t connection_options = { {0} };  
6.     switch_cache_db_handle_type_t type;  
7.     char tmp[256] = "";  
8.     char *p;  
9.     switch_status_t status = SWITCH_STATUS_FALSE;  
10.     int i;  
11.   
12.     if (!strncasecmp(dsn, "pgsql://", 8)) {  
13.         type = SCDB_TYPE_PGSQL;  
14.         connection_options.pgsql_options.dsn = (char *)(dsn + 8);  
15.     } else if (!strncasecmp(dsn, "sqlite://", 9)) {  
16.         type = SCDB_TYPE_CORE_DB;  
17.         connection_options.core_db_options.db_path = (char *)(dsn + 9);  
18.     } else if ((!(i = strncasecmp(dsn, "odbc://", 7))) || strchr(dsn+2, ':')) {  
19.         type = SCDB_TYPE_ODBC;  
20.         ... 
21.     } else {  
22.         type = SCDB_TYPE_CORE_DB;  
23.         connection_options.core_db_options.db_path = (char *)dsn;  
24.     }  
25.   
26.     status = _switch_cache_db_get_db_handle(dbh, type, &connection_options, file, func, line);  
27.   
28.     if (status != SWITCH_STATUS_SUCCESS) *dbh = NULL;  
29.   
30.     return status;  
31. }  

_switch_cache_db_get_db_handle_dsn接口解析dsn得到数据库类型，然后调用最底层接口去打开连接数据库_switch_cache_db_get_db_handle。

1. 1. _switch_cache_db_get_db_handle
2. SWITCH_DECLARE(switch_status_t) _switch_cache_db_get_db_handle(switch_cache_db_handle_t **dbh,                                                         switch_cache_db_handle_type_t type,                                                             switch_cache_db_connection_options_t *connection_options,                                                               const char *file, const char *func, int line)  
3. {  
4.     switch_cache_db_handle_t *new_dbh = NULL;  
5.   
6. //如果存在实例，直接使用，否则创建新实例  
7.     if ((new_dbh = get_handle(db_str, db_callsite_str, thread_str))) {  
8.         switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_DEBUG10,  
9.                           "Reuse Unused Cached DB handle %s [%s]\n", new_dbh->name, switch_cache_db_type_name(new_dbh->type));  
10.     } else {  
11.         switch_core_db_t *db = NULL;  
12.         switch_odbc_handle_t *odbc_dbh = NULL;  
13.         switch_pgsql_handle_t *pgsql_dbh = NULL;  
14. //根据类型，调用相关的NEW函数创建实例  
15.         switch (type) {  
16.         case SCDB_TYPE_PGSQL:  
17.             {  
18.                 if ((pgsql_dbh = switch_pgsql_handle_new(connection_options->pgsql_options.dsn))) {  
19.                     if (switch_pgsql_handle_connect(pgsql_dbh) != SWITCH_PGSQL_SUCCESS) {  
20.                         switch_pgsql_handle_destroy(&pgsql_dbh);  
21.                     }  
22.                 }  
23.             }  
24.             break;  
25.         case SCDB_TYPE_ODBC:  
26.             {  
27.                 if ((odbc_dbh = switch_odbc_handle_new(connection_options->odbc_options.dsn,  
28.                                                        connection_options->odbc_options.user, connection_options->odbc_options.pass))) {  
29.                     if (switch_odbc_handle_connect(odbc_dbh) != SWITCH_ODBC_SUCCESS) {  
30.                         switch_odbc_handle_destroy(&odbc_dbh);  
31.                     }  
32.                 }  
33.             }  
34.             break;  
35.         case SCDB_TYPE_CORE_DB:  
36.             {  
37.                 db = switch_core_db_open_file(connection_options->core_db_options.db_path);  
38.             }  
39.             break;  
40.   
41.         default:  
42.             goto end;  
43.         }  
44. //创建并添加操作实例  
45.         new_dbh = create_handle(type);  
46.   
47.         if (db) {  
48.             new_dbh->native_handle.core_db_dbh = db;  
49.         } else if (odbc_dbh) {  
50.             new_dbh->native_handle.odbc_dbh = odbc_dbh;  
51.         } else {  
52.             new_dbh->native_handle.pgsql_dbh = pgsql_dbh;  
53.         }  
54.   
55.         add_handle(new_dbh, db_str, db_callsite_str, thread_str);  
56.     }  
57.   
58.  end:  
59.   
60.     *dbh = new_dbh;  
61.     return *dbh ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;  
62. }  

 

流程简化后如上，先看操作实例是否已经在池，没有再创建，创建的时候根据类型创建实例，然后添加到池。这里不同类型创建的实例类型不同，但是会统一到switch_cache_db_handle，

作为native_handle成员，这个数据结构才是sql管理层使用的。

 

1. struct switch_cache_db_handle {  
2.     char name[CACHE_DB_LEN];  
3.     switch_cache_db_handle_type_t type;  
4.     switch_cache_db_native_handle_t native_handle;  
5.     time_t last_used;  
6.     switch_mutex_t *mutex;  
7.     switch_mutex_t *io_mutex;  
8.     switch_memory_pool_t *pool;  
9.     int32_t flags;  
10.     unsigned long hash;  
11.     unsigned long thread_hash;  
12.     char creator[CACHE_DB_LEN];  
13.     char last_user[CACHE_DB_LEN];  
14.     uint32_t use_count;  
15.     uint64_t total_used_count;  
16.     struct switch_cache_db_handle *next;  
17. }; 

1. 启动数据库线程
   1. switch_core_sqldb_start_thread

1. static void switch_core_sqldb_start_thread(void)  
2. {  
3.     switch_mutex_lock(sql_manager.ctl_mutex);  
4.     if (sql_manager.manage) {  
5.         if (!sql_manager.qm) {  
6.             char *dbname = runtime.odbc_dsn;  
7.   
8.             if (zstr(dbname)) {  
9.                 dbname = runtime.dbname;  
10.                 if (zstr(dbname)) {  
11.                     dbname = "core";  
12.                 }  
13.             }  
14.   
15.             switch_sql_queue_manager_init_name("CORE",  
16.                                                &sql_manager.qm,  
17.                                                4,  
18.                                                dbname,  
19.                                                SWITCH_MAX_TRANS,  
20.                                         runtime.core_db_pre_trans_execute,  
21.                                         runtime.core_db_post_trans_execute,  
22.                                        runtime.core_db_inner_pre_trans_execute, 
23.                                        runtime.core_db_inner_post_trans_execute);  
24.   
25.         }  
26.         switch_sql_queue_manager_start(sql_manager.qm);  
27.     } else {  
28.         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SQL is not enabled\n");  
29.     }  
30.     switch_mutex_unlock(sql_manager.ctl_mutex);  

 

开始线程实质上是创建sql队列，这里需要绑定一组sql操作函数，pre_trans、post_trans等。调用switch_sql_queue_manager_init_name创建队列，然后调用switch_sql_queue_manager_start启动队列。注意，这里都是在创建core.db数据库，sip的数据库不是在这里。

1. 1. switch_sql_queue_manager_start
2. SWITCH_DECLARE(switch_status_t) switch_sql_queue_manager_start(switch_sql_queue_manager_t *qm)  
3. {  
4.     switch_threadattr_t *thd_attr;  
5.   
6.     if (!qm->thread_running) {  
7.         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%s Starting SQL thread.\n", qm->name);  
8.         switch_threadattr_create(&thd_attr, qm->pool);  
9.         switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);  
10.         switch_threadattr_priority_set(thd_attr, SWITCH_PRI_NORMAL);  
11.         switch_thread_create(&qm->thread, thd_attr, switch_user_sql_thread, qm, qm->pool);  
12.         return SWITCH_STATUS_SUCCESS;  
13.     }  
14.   
15.     return SWITCH_STATUS_FALSE;  
16. }  

 

这里会创建队列的线程，执行函数为switch_user_sql_thread。

1. 1. switch_user_sql_thread

switch_user_sql_thread@sql_manager.qm  

{  

do_trans  

{  

switch_queue_trypop(qm->sql_queue[i], &pop);  

switch_cache_db_execute_sql  

}  

}  

sql线程简化后，就是从队列里一直读sql，然后去执行。

1. switch_core_sql_db_thread

启动数据库的时候，除了调用switch_core_sqldb_start_thread去创建队列外，还启动一条线程switch_core_sql_db_thread，注意这和switch_user_sql_thread是不一样的。

 

1. static void *SWITCH_THREAD_FUNC switch_core_sql_db_thread(switch_thread_t *thread, void *obj)  
2. {  
3.     int sec = 0, reg_sec = 0;;  
4.   
5.     sql_manager.db_thread_running = 1;  
6.   
7.     while (sql_manager.db_thread_running == 1) {  
8.         if (++sec == SQL_CACHE_TIMEOUT) {  
9.             sql_close(switch_epoch_time_now(NULL));       
10.             sec = 0;  
11.         }  
12.   
13.         if (switch_test_flag((&runtime), SCF_USE_SQL) && ++reg_sec == SQL_REG_TIMEOUT) {  
14.             switch_core_expire_registration(0);  
15.             reg_sec = 0;  
16.         }  
17.         switch_yield(1000000);  
18.     }  
19.   
20.   
21.     return NULL;  
22. }

 

这条线程就是定时检查一些超时状态，没有特别重要的业务。