bool CClientReConnectManager::CloseByClient(int nServerID)
{
//如果是因为远程连接断开，则只删除ProConnectClient的指针
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
mapReactorConnectInfo::iterator f = m_mapConnectInfo.find(nServerID);
if (f == m_mapConnectInfo.end())
{
//如果这个链接已经存在，则不创建新的链接
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Close]nServerID =(%d) is exist.\n", nServerID));
return false;
}
CReactorClientInfo* pClientInfo = (CReactorClientInfo*)f->second;
if (NULL == pClientInfo)
{
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Close]nServerID =(%d) pClientInfo is NULL.\n", nServerID));
return false;
}
pClientInfo->SetConnectClient(NULL);
pClientInfo->SetServerConnectState(SERVER_CONNECT_FAIL);
return true;
}
bool CClientReConnectManager::ReConnect(int nServerID)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
char szServerID[10] = {'\0'};
sprintf_safe(szServerID, 10, "%d", nServerID);
CReactorClientInfo* pClientInfo = m_objClientTCPList.Get_Hash_Box_Data(szServerID);
if (NULL == pClientInfo)
{
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Close]nServerID =(%d) pClientInfo is NULL.\n", nServerID));
return false;
}
if (NULL == pClientInfo->GetConnectClient())
{
//如果连接不存在，则重新建立连接
if (false == pClientInfo->Run(m_blReactorFinish, SERVER_CONNECT_RECONNECT))
{
OUR_DEBUG((LM_INFO, "[CClientReConnectManager::Close]Run error.\n"));
}
return true;
}
else
{
return true;
}
}
void CClientReConnectManager::GetConnectInfo(vecClientConnectInfo& VecClientConnectInfo)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
VecClientConnectInfo.clear();
for (mapReactorConnectInfo::iterator b = m_mapConnectInfo.begin(); b != m_mapConnectInfo.end(); b++)
{
CReactorClientInfo* pClientInfo = (CReactorClientInfo*)b->second;
if (NULL != pClientInfo)
{
if (NULL != pClientInfo->GetConnectClient())
{
_ClientConnectInfo ClientConnectInfo = pClientInfo->GetConnectClient()->GetClientConnectInfo();
ClientConnectInfo.m_addrRemote = pClientInfo->GetServerAddr();
VecClientConnectInfo.push_back(ClientConnectInfo);
}
else
{
_ClientConnectInfo ClientConnectInfo;
ClientConnectInfo.m_blValid = false;
ClientConnectInfo.m_addrRemote = pClientInfo->GetServerAddr();
VecClientConnectInfo.push_back(ClientConnectInfo);
}
}
}
}
bool CClientReConnectManager::DeleteIClientMessage(IClientMessage* pClientMessage)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
//将异步回调有效队列中此pClientMessage设置为无效
App_ServerMessageTask::instance()->DelClientMessage(pClientMessage);
//一一寻找与之对应的连接以及相关信息并删除之
vector<CReactorClientInfo*> vecReactorClientInfo;
m_objClientTCPList.Get_All_Used(vecReactorClientInfo);
for(int i = 0; i < (int)vecReactorClientInfo.size(); i++)
{
CReactorClientInfo* pClientInfo = vecReactorClientInfo[i];
if(NULL != pClientInfo && pClientInfo->GetClientMessage() == pClientMessage)
{
//关闭连接，并删除对象。
//关闭链接对象
if (NULL != pClientInfo->GetConnectClient())
{
pClientInfo->GetConnectClient()->ClientClose();
}
char szServerID[10] = {'\0'};
sprintf_safe(szServerID, 10, "%d", pClientInfo->GetServerID());
SAFE_DELETE(pClientInfo);
m_objClientTCPList.Del_Hash_Data(szServerID);
return true;
}
}
return true;
}
bool CClientReConnectManager::ReConnect(int nServerID)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
mapReactorConnectInfo::iterator f = m_mapConnectInfo.find(nServerID);
if (f == m_mapConnectInfo.end())
{
//如果这个链接不存在，则不创建新的链接
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Close]nServerID =(%d) is not exist.\n", nServerID));
return false;
}
CReactorClientInfo* pClientInfo = (CReactorClientInfo*)f->second;
if (NULL == pClientInfo)
{
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Close]nServerID =(%d) pClientInfo is NULL.\n", nServerID));
return false;
}
if (NULL == pClientInfo->GetConnectClient())
{
//如果连接不存在，则重新建立连接
pClientInfo->Run(m_blReactorFinish);
return true;
}
else
{
return true;
}
}
void CClientReConnectManager::GetConnectInfo(vecClientConnectInfo& VecClientConnectInfo)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
VecClientConnectInfo.clear();
vector<CReactorClientInfo*> vecReactorClientInfo;
m_objClientTCPList.Get_All_Used(vecReactorClientInfo);
for (int i = 0; i < (int)vecReactorClientInfo.size(); i++)
{
CReactorClientInfo* pClientInfo = vecReactorClientInfo[i];
if (NULL != pClientInfo)
{
if (NULL != pClientInfo->GetConnectClient())
{
_ClientConnectInfo ClientConnectInfo = pClientInfo->GetConnectClient()->GetClientConnectInfo();
ClientConnectInfo.m_addrRemote = pClientInfo->GetServerAddr();
VecClientConnectInfo.push_back(ClientConnectInfo);
}
else
{
_ClientConnectInfo ClientConnectInfo;
ClientConnectInfo.m_blValid = false;
ClientConnectInfo.m_addrRemote = pClientInfo->GetServerAddr();
VecClientConnectInfo.push_back(ClientConnectInfo);
}
}
}
}
bool CClientReConnectManager::Close(int nServerID)
{
//如果是因为服务器断开，则只删除ProConnectClient的指针
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
//查找已有连接
char szServerID[10] = {'\0'};
sprintf_safe(szServerID, 10, "%d", nServerID);
CReactorClientInfo* pClientInfo = m_objClientTCPList.Get_Hash_Box_Data(szServerID);
if (NULL == pClientInfo)
{
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Close]nServerID =(%d) pClientInfo is NULL.\n", nServerID));
return false;
}
//关闭链接对象
if (NULL != pClientInfo->GetConnectClient())
{
pClientInfo->GetConnectClient()->ClientClose();
SAFE_DELETE(pClientInfo);
}
//从Hash里面删除当前存在的对象
m_objClientTCPList.Del_Hash_Data(szServerID);
return true;
}
void CClientReConnectManager::Close()
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Close]Begin.\n"));
//如果有定时器，则删除定时器
CancelConnectTask();
//关闭所有已存在的链接
for (mapReactorConnectInfo::iterator b = m_mapConnectInfo.begin(); b != m_mapConnectInfo.end(); b++)
{
CReactorClientInfo* pClientInfo = (CReactorClientInfo*)b->second;
pClientInfo->Close();
SAFE_DELETE(pClientInfo);
}
for (mapReactorUDPConnectInfo::iterator ub = m_mapReactorUDPConnectInfo.begin(); ub != m_mapReactorUDPConnectInfo.end(); ub++)
{
CReactorUDPClient* pClientInfo = (CReactorUDPClient*)ub->second;
pClientInfo->Close();
SAFE_DELETE(pClientInfo);
}
m_mapConnectInfo.clear();
m_mapReactorUDPConnectInfo.clear();
m_ActiveTimer.deactivate();
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Close]End.\n"));
}
bool CClientReConnectManager::ConnectFrame(int nServerID, const char* pIP, int nPort, uint8 u1IPType, const char* pLocalIP, int nLocalPort, uint8 u1LocalIPType, uint32 u4PacketParseID)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
CReactorClientInfo* pClientInfo = NULL;
//连接初始化动作
if (false == ConnectTcpInit(nServerID, pIP, nPort, u1IPType, pLocalIP, nLocalPort, u1LocalIPType, NULL, pClientInfo, u4PacketParseID))
{
return false;
}
//开始链接
if (false == pClientInfo->Run(m_blReactorFinish, SERVER_CONNECT_FIRST))
{
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::ConnectFrame]Run Error.\n"));
delete pClientInfo;
pClientInfo = NULL;
if (false == Close(nServerID))
{
OUR_DEBUG((LM_INFO, "[CClientReConnectManager::ConnectFrame]Close Error.\n"));
}
return false;
}
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::ConnectFrame]nServerID =(%d) connect is OK.\n", nServerID));
return true;
}
bool CClientReConnectManager::Connect(int nServerID, const char* pIP, int nPort, uint8 u1IPType, const char* pLocalIP, int nLocalPort, uint8 u1LocalIPType, IClientMessage* pClientMessage)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
mapReactorConnectInfo::iterator f = m_mapConnectInfo.find(nServerID);
if (f != m_mapConnectInfo.end())
{
//如果这个链接已经存在，则不创建新的链接
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Connect]nServerID =(%d) is exist.\n", nServerID));
return false;
}
//初始化链接信息
CReactorClientInfo* pClientInfo = new CReactorClientInfo();
if (NULL == pClientInfo)
{
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Connect]pClientInfo is NULL.\n"));
return false;
}
//链接已经建立，添加进map
m_mapConnectInfo[nServerID] = pClientInfo;
if (false == pClientInfo->Init(nServerID, pIP, nPort, u1IPType, &m_ReactorConnect, pClientMessage, m_pReactor))
{
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Connect]pClientInfo Init Error.\n"));
delete pClientInfo;
pClientInfo = NULL;
Close(nServerID);
return false;
}
//设置本地IP和端口
pClientInfo->SetLocalAddr(pLocalIP, nLocalPort, u1LocalIPType);
//开始链接
if (false == pClientInfo->Run(m_blReactorFinish, SERVER_CONNECT_FIRST))
{
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Connect]Run Error.\n"));
delete pClientInfo;
pClientInfo = NULL;
Close(nServerID);
return false;
}
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Connect]nServerID =(%d) connect is OK.\n", nServerID));
return true;
}
EM_Server_Connect_State CClientReConnectManager::GetConnectState( int nServerID )
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
mapReactorConnectInfo::iterator f = m_mapConnectInfo.find(nServerID);
if (f == m_mapConnectInfo.end())
{
//如果这个链接已经存在，则不创建新的链接
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::GetConnectState]nServerID =(%d) is not exist.\n", nServerID));
return SERVER_CONNECT_FAIL;
}
CReactorClientInfo* pClientInfo = (CReactorClientInfo*)f->second;
return pClientInfo->GetServerConnectState();
}
uint32 CClientReConnectManager::GetPacketParseID(int nServerID)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
char szServerID[10] = { '\0' };
sprintf_safe(szServerID, 10, "%d", nServerID);
CReactorClientInfo* pClientInfo = m_objClientTCPList.Get_Hash_Box_Data(szServerID);
if (NULL != pClientInfo)
{
return pClientInfo->GetPacketParseID();
}
return 0;
}
void CClientReConnectManager::Close()
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Close]Begin.\n"));
//如果有定时器，则删除定时器
CancelConnectTask();
//关闭所有已存在的链接
vector<CReactorClientInfo*> vecReactorClientInfo;
m_objClientTCPList.Get_All_Used(vecReactorClientInfo);
for(int i = 0; i < (int)vecReactorClientInfo.size(); i++)
{
CReactorClientInfo* pClientInfo = vecReactorClientInfo[i];
if(NULL != pClientInfo)
{
pClientInfo->GetConnectClient()->ClientClose();
SAFE_DELETE(pClientInfo);
}
}
m_objClientTCPList.Close();
vector<CReactorUDPClient*> vecReactorUDPClient;
m_objClientUDPList.Get_All_Used(vecReactorUDPClient);
for(int i = 0; i < (int)vecReactorUDPClient.size(); i++)
{
CReactorUDPClient* pClientInfo = vecReactorUDPClient[i];
if(NULL != pClientInfo)
{
pClientInfo->Close();
SAFE_DELETE(pClientInfo);
}
}
m_objClientUDPList.Close();
m_u4MaxPoolCount = 0;
//等待各自的连接对象自己关闭，因为不是在当前线程关闭，所以这里要等一下。
ACE_Time_Value tvSleep(0, 10000);
ACE_OS::sleep(tvSleep);
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Close]End.\n"));
}
bool CClientReConnectManager::SendData(int nServerID, char*& pData, int nSize, bool blIsDelete)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
//查找已有连接
char szServerID[10] = {'\0'};
sprintf_safe(szServerID, 10, "%d", nServerID);
CReactorClientInfo* pClientInfo = m_objClientTCPList.Get_Hash_Box_Data(szServerID);
if (NULL == pClientInfo)
{
//如果这个链接已经存在，则不创建新的链接
OUR_DEBUG((LM_ERROR, "[CProConnectManager::SendData]nServerID =(%d) is not exist.\n", nServerID));
if (true == blIsDelete)
{
SAFE_DELETE_ARRAY(pData);
}
return false;
}
ACE_Message_Block* pmblk = App_MessageBlockManager::instance()->Create(nSize);
if (NULL == pmblk)
{
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::SendData]nServerID =(%d) pmblk is NULL.\n", nServerID));
if (true == blIsDelete)
{
SAFE_DELETE_ARRAY(pData);
}
return false;
}
memcpy_safe((char* )pData, (uint32)nSize, pmblk->wr_ptr(), (uint32)nSize);
pmblk->wr_ptr(nSize);
if (true == blIsDelete)
{
SAFE_DELETE_ARRAY(pData);
}
//发送数据
return pClientInfo->SendData(pmblk);
}
EM_Server_Connect_State CClientReConnectManager::GetConnectState( int nServerID )
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
char szServerID[10] = {'\0'};
sprintf_safe(szServerID, 10, "%d", nServerID);
CReactorClientInfo* pClientInfo = m_objClientTCPList.Get_Hash_Box_Data(szServerID);
if (NULL == pClientInfo)
{
//如果这个链接已经存在，则不创建新的链接
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::GetConnectState]nServerID =(%d) is not exist.\n", nServerID));
return SERVER_CONNECT_FAIL;
}
return pClientInfo->GetServerConnectState();
}
bool CClientReConnectManager::CloseByClient(int nServerID)
{
//如果是因为远程连接断开，则只删除ProConnectClient的指针
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
char szServerID[10] = {'\0'};
sprintf_safe(szServerID, 10, "%d", nServerID);
CReactorClientInfo* pClientInfo = m_objClientTCPList.Get_Hash_Box_Data(szServerID);
if (NULL != pClientInfo)
{
pClientInfo->SetConnectClient(NULL);
pClientInfo->SetServerConnectState(SERVER_CONNECT_FAIL);
}
return true;
}
bool CClientReConnectManager::SetServerConnectState(int nServerID, EM_Server_Connect_State objState)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
mapReactorConnectInfo::iterator f = m_mapConnectInfo.find(nServerID);
if (f == m_mapConnectInfo.end())
{
//如果这个链接已经存在，则不创建新的链接
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Close]nServerID =(%d) is exist.\n", nServerID));
return false;
}
else
{
CReactorClientInfo* pClientInfo = (CReactorClientInfo*)f->second;
pClientInfo->SetServerConnectState(objState);
return true;
}
}
bool CClientReConnectManager::SendData(int nServerID, const char* pData, int nSize, bool blIsDelete)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
mapReactorConnectInfo::iterator f = m_mapConnectInfo.find(nServerID);
if (f == m_mapConnectInfo.end())
{
//如果这个链接已经存在，则不创建新的链接
OUR_DEBUG((LM_ERROR, "[CProConnectManager::SendData]nServerID =(%d) is not exist.\n", nServerID));
if (true == blIsDelete)
{
SAFE_DELETE_ARRAY(pData);
}
return false;
}
CReactorClientInfo* pClientInfo = (CReactorClientInfo*)f->second;
ACE_Message_Block* pmblk = App_MessageBlockManager::instance()->Create(nSize);
if (NULL == pmblk)
{
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::SendData]nServerID =(%d) pmblk is NULL.\n", nServerID));
if (true == blIsDelete)
{
SAFE_DELETE_ARRAY(pData);
}
return false;
}
memcpy_safe((char* )pData, (uint32)nSize, pmblk->wr_ptr(), (uint32)nSize);
pmblk->wr_ptr(nSize);
if (true == blIsDelete)
{
SAFE_DELETE_ARRAY(pData);
}
//发送数据
return pClientInfo->SendData(pmblk);
}
ACE_INET_Addr CClientReConnectManager::GetServerAddr(int nServerID)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
ACE_INET_Addr remote_addr;
mapReactorConnectInfo::iterator f = m_mapConnectInfo.find(nServerID);
if (f == m_mapConnectInfo.end())
{
//如果这个链接已经存在，则不创建新的链接
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Close]nServerID =(%d) is exist.\n", nServerID));
return remote_addr;
}
else
{
CReactorClientInfo* pClientInfo = (CReactorClientInfo*)f->second;
remote_addr = pClientInfo->GetServerAddr();
return remote_addr;
}
}
bool CClientReConnectManager::Close(int nServerID, EM_s2s ems2s)
{
//如果是因为服务器断开，则只删除ProConnectClient的指针
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
mapReactorConnectInfo::iterator f = m_mapConnectInfo.find(nServerID);
if (f == m_mapConnectInfo.end())
{
//如果这个链接已经存在，则不创建新的链接
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Close]nServerID =(%d) is not exist.\n", nServerID));
return false;
}
CReactorClientInfo* pClientInfo = (CReactorClientInfo*)f->second;
if (NULL == pClientInfo)
{
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Close]nServerID =(%d) pClientInfo is NULL.\n", nServerID));
return false;
}
//关闭链接对象
if (NULL != pClientInfo->GetConnectClient())
{
pClientInfo->GetConnectClient()->ClinetClose(ems2s);
}
if(S2S_NEED_CALLBACK == ems2s)
{
//SAFE_DELETE(pClientInfo);
//从map里面删除当前存在的对象
//m_mapConnectInfo.erase(f);
}
else
{
pClientInfo->Close();
SAFE_DELETE(pClientInfo);
//从map里面删除当前存在的对象
m_mapConnectInfo.erase(f);
}
return true;
}
IClientMessage* CClientReConnectManager::GetClientMessage(int nServerID)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
mapReactorConnectInfo::iterator f = m_mapConnectInfo.find(nServerID);
if (f == m_mapConnectInfo.end())
{
//如果这个链接已经存在，则不创建新的链接
return NULL;
}
CReactorClientInfo* pClientInfo = (CReactorClientInfo*)f->second;
if (NULL != pClientInfo)
{
return pClientInfo->GetClientMessage();
}
return NULL;
}
bool CClientReConnectManager::SetServerConnectState(int nServerID, EM_Server_Connect_State objState)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
char szServerID[10] = {'\0'};
sprintf_safe(szServerID, 10, "%d", nServerID);
CReactorClientInfo* pClientInfo = m_objClientTCPList.Get_Hash_Box_Data(szServerID);
if (NULL == pClientInfo)
{
//如果这个链接不存在，则不创建新的链接
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Close]nServerID =(%d) is not exist.\n", nServerID));
return false;
}
else
{
pClientInfo->SetServerConnectState(objState);
return true;
}
}
bool CClientReConnectManager::GetServerIPInfo( int nServerID, _ClientIPInfo& objServerIPInfo )
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
mapReactorConnectInfo::iterator f = m_mapConnectInfo.find(nServerID);
if (f == m_mapConnectInfo.end())
{
//如果这个链接已经存在，则不创建新的链接
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Close]nServerID =(%d) is exist.\n", nServerID));
return false;
}
else
{
CReactorClientInfo* pClientInfo = (CReactorClientInfo*)f->second;
ACE_INET_Addr remote_addr = pClientInfo->GetServerAddr();
sprintf_safe(objServerIPInfo.m_szClientIP, MAX_BUFF_50, remote_addr.get_host_addr());
objServerIPInfo.m_nPort = remote_addr.get_port_number();
return true;
}
}
ACE_INET_Addr CClientReConnectManager::GetServerAddr(int nServerID)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
ACE_INET_Addr remote_addr;
char szServerID[10] = {'\0'};
sprintf_safe(szServerID, 10, "%d", nServerID);
CReactorClientInfo* pClientInfo = m_objClientTCPList.Get_Hash_Box_Data(szServerID);
if (NULL == pClientInfo)
{
//如果这个链接不存在，则不创建新的链接
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Close]nServerID =(%d) is not exist.\n", nServerID));
return remote_addr;
}
else
{
remote_addr = pClientInfo->GetServerAddr();
return remote_addr;
}
}
int CClientReConnectManager::handle_timeout(const ACE_Time_Value& tv, const void* arg)
{
ACE_UNUSED_ARG(arg);
ACE_UNUSED_ARG(tv);
m_ThreadWritrLock.acquire();
vector<CReactorClientInfo*> vecCReactorClientInfo;
m_objClientTCPList.Get_All_Used(vecCReactorClientInfo);
m_ThreadWritrLock.release();
for (int i = 0; i < (int)vecCReactorClientInfo.size(); i++)
{
CReactorClientInfo* pClientInfo = vecCReactorClientInfo[i];
if(NULL != pClientInfo)
{
if (NULL == pClientInfo->GetConnectClient())
{
//如果连接不存在，则重新建立连接
if (false == pClientInfo->Run(m_blReactorFinish, SERVER_CONNECT_RECONNECT))
{
OUR_DEBUG((LM_INFO, "[CClientReConnectManager::handle_timeout]Run error.\n"));
}
}
else
{
//检查当前连接，是否已挂起或死锁
ACE_Time_Value tvNow = ACE_OS::gettimeofday();
//如果是异步模式，则需要检查处理线程是否被挂起
if(GetXmlConfigAttribute(xmlConnectServer)->RunType == 1)
{
App_ServerMessageTask::instance()->CheckServerMessageThread(tvNow);
}
}
}
}
return 0;
}
bool CClientReConnectManager::GetServerIPInfo( int nServerID, _ClientIPInfo& objServerIPInfo )
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
char szServerID[10] = {'\0'};
sprintf_safe(szServerID, 10, "%d", nServerID);
CReactorClientInfo* pClientInfo = m_objClientTCPList.Get_Hash_Box_Data(szServerID);
if (NULL == pClientInfo)
{
//如果这个链接不存在，则不创建新的链接
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::Close]nServerID =(%d) is not exist.\n", nServerID));
return false;
}
else
{
ACE_INET_Addr remote_addr = pClientInfo->GetServerAddr();
sprintf_safe(objServerIPInfo.m_szClientIP, MAX_BUFF_50, remote_addr.get_host_addr());
objServerIPInfo.m_nPort = remote_addr.get_port_number();
return true;
}
}
bool CClientReConnectManager::SetHandler(int nServerID, CConnectClient* pConnectClient)
{
if (NULL == pConnectClient)
{
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::SetHandler]pProConnectClient is NULL.\n"));
return false;
}
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
mapReactorConnectInfo::iterator f = m_mapConnectInfo.find(nServerID);
if (f == m_mapConnectInfo.end())
{
//如果这个链接已经存在，则不再添加到已经存在的客户端map管理中
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::SetHandler]nServerID =(%d) is not exist.\n", nServerID));
return false;
}
CReactorClientInfo* pClientInfo = (CReactorClientInfo* )f->second;
pClientInfo->SetConnectClient(pConnectClient);
return true;
}
bool CClientReConnectManager::SetHandler(int nServerID, CConnectClient* pConnectClient)
{
if (NULL == pConnectClient)
{
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::SetHandler]pProConnectClient is NULL.\n"));
return false;
}
//查找已有连接
char szServerID[10] = {'\0'};
sprintf_safe(szServerID, 10, "%d", nServerID);
CReactorClientInfo* pClientInfo = m_objClientTCPList.Get_Hash_Box_Data(szServerID);
if (NULL == pClientInfo)
{
//如果这个链接已经存在，则不再添加到已经存在的客户端Hash数组管理中
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::SetHandler]nServerID =(%d) is not exist.\n", nServerID));
return false;
}
pClientInfo->SetConnectClient(pConnectClient);
return true;
}
int CClientReConnectManager::handle_timeout(const ACE_Time_Value& tv, const void* arg)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
if (arg != NULL)
{
OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::handle_timeout] arg is not NULL, tv = %d.\n", tv.sec()));
}
for (mapReactorConnectInfo::iterator b = m_mapConnectInfo.begin(); b != m_mapConnectInfo.end(); b++)
{
//int nServerID = (int)b->first;
CReactorClientInfo* pClientInfo = (CReactorClientInfo*)b->second;
if (NULL == pClientInfo->GetConnectClient())
{
//如果连接不存在，则重新建立连接
pClientInfo->Run(m_blReactorFinish);
}
}
return 0;
}
