TeamTalk DB_PROXY_SERVER详解
DB_PROXY_Server数据库代理是TeamTalk TTServer中负责与数据库交互的代理服务器，在DB server中负责承载TeamTalk所有业务层面和逻辑层面的数据入库和持久化等服务，是TT_Server中比较重要的一环，在设计中采用了很多实用的技术，比如池化技术，数据库代理，单例模式等，收益匪浅，下面对TealTalk的DB_Server作个详细分析，以封面是自己阅读代码后的学习总结，一方面可以给其他学习TT_Server的人提供参考。
可以通过查看DB_Server的配置文件dbproxyserver.conf文件，DB_SERVER主要分为以下几个部分：
1、TeamTalk_Matser 采用了MYSQL数据库
2、TeamTalk_Slave MYSQL数据库 （由于水平有限，对数据库的学习还不够深入，尚不清楚为什么需要部署主从服务器）
-------------------------------------------------------------
3、unread 未读信息实例 redis 数据库
4、group_set 群组设置实例 redis数据库
5、token 实例 redis数据库
6、sync实例 redis数据库 同步功能
7、group_member redis 数据库
每个数据库实例都会预先打开于数据库的两个链接，不需要在每次使用的时候再打开，使用结束后释放，节省了数据打开和释放需要的时间和资源，在当前可用连接数不够的情况下再新增一个数据库链接，动态调节DB_Server的负载，同时限定了每个实例的最大可用连接数，由于系统资源是有限的，当业务比较繁忙时不能无限制创建新的连接，避免耗尽系统资源，这种场景下，当没有可用连接的时候，新的业务请求必须等待，等待可用的连接，然后再执行相应的业务操作。
DB_Server采用了多线程，在DB_Server启动的时候预先分配了配置文件中指定的线程数，用来处理具体的数据库请求，当一个请求到达DB_Server时，DB_Server将该请求封装成DB相关的额任务类，然后随机加入到预先启动的线程的任务列表中，有线程回调函数不停执行具体的任务请求，者就是整个DB_Serve的设计思路。
下面来看代码的流程：
1、CacheManager的初始化
db_proxy_server的main函数中，依次从配置文件中读取各个实例的名称以及初始DB实例个数，最大连接数等信息。
首先获取CacheManager的对象，在获取对象的同时对该对象以及该对象管理的资源进行了初始化。
CacheManager* pCacheManager = CacheManager::getInstance();
需要明确的是，cacheManager维护了一个map，map
创建CacheManager的对象
CacheManager* CacheManager::getInstance()
{
if (!s_cache_manager) {
s_cache_manager = new CacheManager();
if (s_cache_manager->Init()) {
delete s_cache_manager;
s_cache_manager = NULL;
}
}
return s_cache_manager;
}
int CacheManager::Init()
{
CConfigFileReader config_file("dbproxyserver.conf");
char* cache_instances = config_file.GetConfigName("CacheInstances");
if (!cache_instances) {
log("not configure CacheIntance");
return 1;
}
char host[64];
char port[64];
char db[64];
char maxconncnt[64];
CStrExplode instances_name(cache_instances, ',');
for (uint32_t i = 0; i < instances_name.GetItemCnt(); i++) {
char* pool_name = instances_name.GetItem(i);
//printf("%s", pool_name);
snprintf(host, 64, "%s_host", pool_name);
snprintf(port, 64, "%s_port", pool_name);
snprintf(db, 64, "%s_db", pool_name);
snprintf(maxconncnt, 64, "%s_maxconncnt", pool_name);
char* cache_host = config_file.GetConfigName(host);
char* str_cache_port = config_file.GetConfigName(port);
char* str_cache_db = config_file.GetConfigName(db);
char* str_max_conn_cnt = config_file.GetConfigName(maxconncnt);
if (!cache_host || !str_cache_port || !str_cache_db || !str_max_conn_cnt) {
log("not configure cache instance: %s", pool_name);
return 2;
}
CachePool* pCachePool = new CachePool(pool_name, cache_host, atoi(str_cache_port),
atoi(str_cache_db), atoi(str_max_conn_cnt));
if (pCachePool->Init()) {
log("Init cache pool failed");
return 3;
}
m_cache_pool_map.insert(make_pair(pool_name, pCachePool));
}
return 0;
}
int CachePool::Init()
{
for (int i = 0; i < m_cur_conn_cnt; i++) {
CacheConn* pConn = new CacheConn(this);
if (pConn->Init()) {
delete pConn;
return 1;
}
m_free_list.push_back(pConn);
}
log("cache pool: %s, list size: %lu", m_pool_name.c_str(), m_free_list.size());
return 0;
}/*
* redis初始化连接和重连操作，类似mysql_ping()
*/
int CacheConn::Init()
{
if (m_pContext) {
return 0;
}
// 4s 尝试重连一次
uint64_t cur_time = (uint64_t)time(NULL);
if (cur_time < m_last_connect_time + 4) {
return 1;
}
m_last_connect_time = cur_time;
// 200ms超时
struct timeval timeout = {0, 200000};
m_pContext = redisConnectWithTimeout(m_pCachePool->GetServerIP(), m_pCachePool->GetServerPort(), timeout);
if (!m_pContext || m_pContext->err) {
if (m_pContext) {
log("redisConnect failed: %s", m_pContext->errstr);
redisFree(m_pContext);
m_pContext = NULL;
} else {
log("redisConnect failed");
}
return 1;
}
redisReply* reply = (redisReply *)redisCommand(m_pContext, "SELECT %d", m_pCachePool->GetDBNum());
if (reply && (reply->type == REDIS_REPLY_STATUS) && (strncmp(reply->str, "OK", 2) == 0)) {
freeReplyObject(reply);
return 0;
} else {
log("select cache db failed");
return 2;
}
}2、CDBManager的初始化
CDBManager的初始化流程与CacheManager的初始化流程类似，唯一不同的是CDBManager保存的CDBConn是到MYSQL数据库的连接。其他过程类似，理解上面CacheManager的流程就很容易理解该部分流程，这里不再重复叙述了。
3、资源对象初始化
完成DB相关资源的对象初始化，这些类都用了单例模式，因此初始化这些对象都只需要调用自身的GetInstance方法，
puts("db init success");
// 主线程初始化单例，不然在工作线程可能会出现多次初始化
if (!CAudioModel::getInstance()) {
return -1;
}
if (!CGroupMessageModel::getInstance()) {
return -1;
}
if (!CGroupModel::getInstance()) {
return -1;
}
if (!CMessageModel::getInstance()) {
return -1;
}
if (!CSessionModel::getInstance()) {
return -1;
}
if(!CRelationModel::getInstance())
{
return -1;
}
if (!CUserModel::getInstance()) {
return -1;
}
if (!CFileModel::getInstance()) {
return -1;
}4、工作线程池初始化，任务执行回调初始化。
这个部分可谓是db_proxy_server中重要的一环，所有的DB任务都是通过从工作线程池中的线程通过获取对应命令ID的回调函数来执行所有的数据库操作任务，因此理解了这部分差不多就理解了db_proxy_server的一半，下面介绍这部分流程。
int init_proxy_conn(uint32_t thread_num)
{
s_handler_map = CHandlerMap::getInstance();
g_thread_pool.Init(thread_num);
netlib_add_loop(proxy_loop_callback, NULL);
signal(SIGTERM, sig_handler);
return netlib_register_timer(proxy_timer_callback, NULL, 1000);
}（1）首先获取CHandlerMap的对象，在获取对象的同时完成了所有回调函数的注册。
CHandlerMap* CHandlerMap::getInstance()
{
if (!s_handler_instance) {
s_handler_instance = new CHandlerMap();
s_handler_instance->Init();
}
return s_handler_instance;
}void CHandlerMap::Init()
{
// Login validate
m_handler_map.insert(make_pair(uint32_t(CID_OTHER_VALIDATE_REQ), DB_PROXY::doLogin));
m_handler_map.insert(make_pair(uint32_t(CID_LOGIN_REQ_PUSH_SHIELD), DB_PROXY::doPushShield));
m_handler_map.insert(make_pair(uint32_t(CID_LOGIN_REQ_QUERY_PUSH_SHIELD), DB_PROXY::doQueryPushShield));
// recent session
m_handler_map.insert(make_pair(uint32_t(CID_BUDDY_LIST_RECENT_CONTACT_SESSION_REQUEST), DB_PROXY::getRecentSession));
m_handler_map.insert(make_pair(uint32_t(CID_BUDDY_LIST_REMOVE_SESSION_REQ), DB_PROXY::deleteRecentSession));
// users
m_handler_map.insert(make_pair(uint32_t(CID_BUDDY_LIST_USER_INFO_REQUEST), DB_PROXY::getUserInfo));
m_handler_map.insert(make_pair(uint32_t(CID_BUDDY_LIST_ALL_USER_REQUEST), DB_PROXY::getChangedUser));
m_handler_map.insert(make_pair(uint32_t(CID_BUDDY_LIST_DEPARTMENT_REQUEST), DB_PROXY::getChgedDepart));
m_handler_map.insert(make_pair(uint32_t(CID_BUDDY_LIST_CHANGE_SIGN_INFO_REQUEST), DB_PROXY::changeUserSignInfo));
// message content
m_handler_map.insert(make_pair(uint32_t(CID_MSG_DATA), DB_PROXY::sendMessage));
m_handler_map.insert(make_pair(uint32_t(CID_MSG_LIST_REQUEST), DB_PROXY::getMessage));
m_handler_map.insert(make_pair(uint32_t(CID_MSG_UNREAD_CNT_REQUEST), DB_PROXY::getUnreadMsgCounter));
m_handler_map.insert(make_pair(uint32_t(CID_MSG_READ_ACK), DB_PROXY::clearUnreadMsgCounter));
m_handler_map.insert(make_pair(uint32_t(CID_MSG_GET_BY_MSG_ID_REQ), DB_PROXY::getMessageById));
m_handler_map.insert(make_pair(uint32_t(CID_MSG_GET_LATEST_MSG_ID_REQ), DB_PROXY::getLatestMsgId));
// device token
m_handler_map.insert(make_pair(uint32_t(CID_LOGIN_REQ_DEVICETOKEN), DB_PROXY::setDevicesToken));
m_handler_map.insert(make_pair(uint32_t(CID_OTHER_GET_DEVICE_TOKEN_REQ), DB_PROXY::getDevicesToken));
//push 鎺ㄩ€佽缃?
m_handler_map.insert(make_pair(uint32_t(CID_GROUP_SHIELD_GROUP_REQUEST), DB_PROXY::setGroupPush));
m_handler_map.insert(make_pair(uint32_t(CID_OTHER_GET_SHIELD_REQ), DB_PROXY::getGroupPush));
// group
m_handler_map.insert(make_pair(uint32_t(CID_GROUP_NORMAL_LIST_REQUEST), DB_PROXY::getNormalGroupList));
m_handler_map.insert(make_pair(uint32_t(CID_GROUP_INFO_REQUEST), DB_PROXY::getGroupInfo));
m_handler_map.insert(make_pair(uint32_t(CID_GROUP_CREATE_REQUEST), DB_PROXY::createGroup));
m_handler_map.insert(make_pair(uint32_t(CID_GROUP_CHANGE_MEMBER_REQUEST), DB_PROXY::modifyMember));
// file
m_handler_map.insert(make_pair(uint32_t(CID_FILE_HAS_OFFLINE_REQ), DB_PROXY::hasOfflineFile));
m_handler_map.insert(make_pair(uint32_t(CID_FILE_ADD_OFFLINE_REQ), DB_PROXY::addOfflineFile));
m_handler_map.insert(make_pair(uint32_t(CID_FILE_DEL_OFFLINE_REQ), DB_PROXY::delOfflineFile));
}在ChandleMap注册数据库请求的CommandID对应的回调函数，在处理接收的请求时，根据CmdID查询CHandleMap，获取回调函数处理请求。
（2）初始化工作线程池
g_thread_pool.Init(thread_num);这行代码根据传入的参数创建了指定数量的线程，每个工作线程中都维护了一个任务队列，在有数据请求来的时候，系统随机将任务添加到线程的任务队列中，线程一次执行自己任务队列中的任务。
int CThreadPool::Init(uint32_t worker_size)
{
m_worker_size = worker_size;
m_worker_list = new CWorkerThread [m_worker_size];
if (!m_worker_list) {
return 1;
}
for (uint32_t i = 0; i < m_worker_size; i++) {
m_worker_list[i].SetThreadIdx(i);
m_worker_list[i].Start();
}
return 0;
}void CWorkerThread::Start()
{
(void)pthread_create(&m_thread_id, NULL, StartRoutine, this);
}void* CWorkerThread::StartRoutine(void* arg)
{
CWorkerThread* pThread = (CWorkerThread*)arg;
pThread->Execute();
return NULL;
}void CWorkerThread::Execute()
{
while (true) {
m_thread_notify.Lock();
// put wait in while cause there can be spurious wake up (due to signal/ENITR)
while (m_task_list.empty()) {
m_thread_notify.Wait();
}
CTask* pTask = m_task_list.front();
m_task_list.pop_front();
m_thread_notify.Unlock();
pTask->run();
delete pTask;
m_task_cnt++;
//log("%d have the execute %d task\n", m_thread_idx, m_task_cnt);
}
}（3）环回检查，超时检测处理异常中断
netlib_add_loop(proxy_loop_callback, NULL);
signal(SIGTERM, sig_handler);
return netlib_register_timer(proxy_timer_callback, NULL, 1000);
signal(SIGTERM, sig_handler);static void sig_handler(int sig_no)
{
if (sig_no == SIGTERM) {
log("receive SIGTERM, prepare for exit");
CImPdu cPdu;
IM::Server::IMStopReceivePacket msg;
msg.set_result(0);
cPdu.SetPBMsg(&msg);
cPdu.SetServiceId(IM::BaseDefine::SID_OTHER);
cPdu.SetCommandId(IM::BaseDefine::CID_OTHER_STOP_RECV_PACKET);
for (ConnMap_t::iterator it = g_proxy_conn_map.begin(); it != g_proxy_conn_map.end(); it++) {
CProxyConn* pConn = (CProxyConn*)it->second;
pConn->SendPdu(&cPdu);
}
// Add By ZhangYuanhao
// Before stop we need to stop the sync thread,otherwise maybe will not sync the internal data any more
CSyncCenter::getInstance()->stopSync();
// callback after 4 second to exit process;
netlib_register_timer(exit_callback, NULL, 4000);
}
}
5、同步聊天记录等信息
CSyncCenter::getInstance()->init();
CSyncCenter::getInstance()->startSync();void CSyncCenter::init()
{
// Load total update time
CacheManager* pCacheManager = CacheManager::getInstance();
// increase message count
CacheConn* pCacheConn = pCacheManager->GetCacheConn("unread");
if (pCacheConn)
{
string strTotalUpdate = pCacheConn->get("total_user_updated");
string strLastUpdateGroup = pCacheConn->get("last_update_group");
pCacheManager->RelCacheConn(pCacheConn);
if(strTotalUpdate != "")
{
m_nLastUpdate = string2int(strTotalUpdate);
}
else
{
updateTotalUpdate(time(NULL));
}
if(strLastUpdateGroup.empty())
{
m_nLastUpdateGroup = string2int(strLastUpdateGroup);
}
else
{
updateLastUpdateGroup(time(NULL));
}
}
else
{
log("no cache connection to get total_user_updated");
}
}void CSyncCenter::startSync()
{
#ifdef _WIN32
(void)CreateThread(NULL, 0, doSyncGroupChat, NULL, 0, &m_nGroupChatThreadId);
#else
(void)pthread_create(&m_nGroupChatThreadId, NULL, doSyncGroupChat, NULL);
#endif
}由于主线程执行需要执行其他任务，为了避免主线程耗时，同步聊天记录，群主信息功能在新创建的线程中执行，节省主线程启动时间；所有同步操作均在线程回调函数中完 成doSyncGroupChat.
6、事件分发，主线程助理主流程，接受客户连接，处理客户请求
所有TT_SERVER的网络处理统一在事件分发起中执行，包括从socket中接收连接，读写数据，处理异常void CEventDispatch::StartDispatch(uint32_t wait_timeout)
{
struct epoll_event events[1024];
int nfds = 0;
if(running)
return;
running = true;
while (running)
{
nfds = epoll_wait(m_epfd, events, 1024, wait_timeout);
for (int i = 0; i < nfds; i++)
{
int ev_fd = events[i].data.fd;
CBaseSocket* pSocket = FindBaseSocket(ev_fd);
if (!pSocket)
continue;
//Commit by zhfu @2015-02-28
#ifdef EPOLLRDHUP
if (events[i].events & EPOLLRDHUP)
{
//log("On Peer Close, socket=%d, ev_fd);
pSocket->OnClose();
}
#endif
// Commit End
if (events[i].events & EPOLLIN)
{
//log("OnRead, socket=%d\n", ev_fd);
pSocket->OnRead();
}
if (events[i].events & EPOLLOUT)
{
//log("OnWrite, socket=%d\n", ev_fd);
pSocket->OnWrite();
}
if (events[i].events & (EPOLLPRI | EPOLLERR | EPOLLHUP))
{
//log("OnClose, socket=%d\n", ev_fd);
pSocket->OnClose();
}
pSocket->ReleaseRef();
}
_CheckTimer();
_CheckLoop();
}
}在事件分发中需要详解的是从socket中读取客户请求数据并解析PDU数据包，处理客户请求，回复效应，其他socket连接等部分在之前的文章中已经叙述过了，这里就不再重复了，下面主要陈述db_proxy_server中处理客户请求的流程。
在db_proxy_server中接收到用户的请求数据后都会在如下的函数中解析请求数据。
void CProxyConn::HandlePduBuf(uchar_t* pdu_buf, uint32_t pdu_len)
{
CImPdu* pPdu = NULL;
pPdu = CImPdu::ReadPdu(pdu_buf, pdu_len);
if (pPdu->GetCommandId() == IM::BaseDefine::CID_OTHER_HEARTBEAT) {
return;
}
pdu_handler_t handler = s_handler_map->GetHandler(pPdu->GetCommandId());
if (handler) {
CTask* pTask = new CProxyTask(m_uuid, handler, pPdu);
g_thread_pool.AddTask(pTask);
} else {
log("no handler for packet type: %d", pPdu->GetCommandId());
}
}void CThreadPool::AddTask(CTask* pTask)
{
/*
* select a random thread to push task
* we can also select a thread that has less task to do
* but that will scan the whole thread list and use thread lock to get each task size
*/
uint32_t thread_idx = random() % m_worker_size;
m_worker_list[thread_idx].PushTask(pTask);
}void CProxyTask::run()
{
if (!m_pPdu) {
// tell CProxyConn to close connection with m_conn_uuid
CProxyConn::AddResponsePdu(m_conn_uuid, NULL);
} else {
if (m_pdu_handler) {
m_pdu_handler(m_pPdu, m_conn_uuid);
}
}
}
至此db_proxy_server的整个初始化流程和处理流程都介绍完毕。在整个db server中核心思想就是池化技术，（DB连接池，工作线程池）；整个核心流程是创建线程池，根据命令ID注册对应的处理回调，在线程回调函数中处理任务队列，依次取出任务，根据注册的回调处理任务请求，回响应。
鉴于本人理解有限，在行文的过程中可能存在一些理解或者描述错误的地方，请各位看官指正，TT_SERVER详解系列，是本人学习teamtalk源码的一些理解和心得，看源码主要看的是设计方法，处理思维，在不断学习中进步。