bool CPacketParsePool::Delete(CPacketParse* pPacketParse, bool blDelete)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadWriteLock);
if (NULL == pPacketParse)
{
OUR_DEBUG((LM_INFO, "[CPacketParsePool::Delete] pPacketParse is NULL.\n"));
return false;
}
if (true == blDelete)
{
//清理包头和包体的内存
if (NULL != pPacketParse->GetMessageHead())
{
App_MessageBlockManager::instance()->Close(pPacketParse->GetMessageHead());
}
if (NULL != pPacketParse->GetMessageBody())
{
App_MessageBlockManager::instance()->Close(pPacketParse->GetMessageBody());
}
}
pPacketParse->Clear();
return CObjectPoolManager<CPacketParse, ACE_Recursive_Thread_Mutex>::Delete(pPacketParse->GetHashID(), pPacketParse);
}
void ClistManager::Add_LG_Info(uint32 u4ConnectID, uint32 u4LGID, const char* pIP, uint32 u4Port, const char* pMD5, const char* pSession, uint16 u2Version)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadLock);
_LG_Info* pInfo = Get_LG_Info_By_LGID(u4LGID);
if(NULL == pInfo)
{
_LG_Info objNewInfo;
objNewInfo.m_u4ConnectID = u4ConnectID;
objNewInfo.m_u4LGID = u4LGID;
objNewInfo.m_u4Port = u4Port;
sprintf_safe(objNewInfo.m_szIP, 50, "%s", pIP);
sprintf_safe(objNewInfo.m_szMD5, 33, "%s", pMD5);
sprintf_safe(objNewInfo.m_szSession, 33, "%s", pSession);
m_vecLGInfo.push_back(objNewInfo);
objNewInfo.m_u2Version = u2Version;
}
else
{
pInfo->m_u4ConnectID = u4ConnectID;
pInfo->m_u4LGID = u4LGID;
pInfo->m_u4Port = u4Port;
sprintf_safe(pInfo->m_szIP, 50, "%s", pIP);
sprintf_safe(pInfo->m_szMD5, 33, "%s", pMD5);
sprintf_safe(pInfo->m_szSession, 33, "%s", pSession);
pInfo->m_u2Version = u2Version;
}
Compare_MD5();
Check_LG_Target(u4ConnectID, u4LGID, pIP, u4Port);
}
void ClistManager::Clear()
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadLock);
m_vecLGInfo.clear();
m_szMD5[0] = '\0';
}
bool CMakePacketPool::Delete(_MakePacket* pBuffPacket)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadWriteLock);
if(NULL == pBuffPacket)
{
return false;
}
pBuffPacket->Clear();
mapPacket::iterator f = m_mapPacketUsed.find(pBuffPacket);
if(f != m_mapPacketUsed.end())
{
m_mapPacketUsed.erase(f);
//添加到Free map里面
mapPacket::iterator f = m_mapPacketFree.find(pBuffPacket);
if(f == m_mapPacketFree.end())
{
m_mapPacketFree.insert(mapPacket::value_type(pBuffPacket, pBuffPacket));
}
}
return true;
}
bool CBuffPacketManager::Delete(IBuffPacket* pBuffPacket)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadWriteLock);
CBuffPacket* pBuff = (CBuffPacket* )pBuffPacket;
if(NULL == pBuff)
{
return false;
}
pBuffPacket->Clear();
pBuffPacket->SetNetSort(m_blSortType);
mapPacket::iterator f = m_mapPacketUsed.find(pBuff);
if(f != m_mapPacketUsed.end())
{
m_mapPacketUsed.erase(f);
//添加到Free map里面
mapPacket::iterator f = m_mapPacketFree.find(pBuff);
if(f == m_mapPacketFree.end())
{
m_mapPacketFree.insert(mapPacket::value_type(pBuff, pBuff));
}
}
return true;
}
ACE_Message_Block* CMessageBlockManager::Create(uint32 u4Size)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadWriteLock);
ACE_Message_Block* pmb = NULL;
if(u4Size <= 0)
{
//如果申请的空间为0,则直接返回空。
return NULL;
}
ACE_NEW_MALLOC_NORETURN(pmb,
static_cast<ACE_Message_Block*>(m_pmsgallocator->malloc(sizeof(ACE_Message_Block))),
ACE_Message_Block(u4Size, // size
ACE_Message_Block::MB_DATA, // type
0,
0,
m_pbuff_allocator, // allocator_strategy
0, // locking strategy
ACE_DEFAULT_MESSAGE_BLOCK_PRIORITY, // priority
ACE_Time_Value::zero,
ACE_Time_Value::max_time,
m_pdata_allocator,
m_pmsgallocator
));
return pmb;
}
bool CMessagePool::Delete(CMessage* pBuffPacket)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadWriteLock);
CMessage* pBuff = (CMessage* )pBuffPacket;
if(NULL == pBuff)
{
return false;
}
pBuffPacket->Clear();
mapMessage::iterator f = m_mapMessageUsed.find(pBuff);
if(f != m_mapMessageUsed.end())
{
m_mapMessageUsed.erase(f);
//添加到Free map里面
mapMessage::iterator f = m_mapMessageFree.find(pBuff);
if(f == m_mapMessageFree.end())
{
m_mapMessageFree.insert(mapMessage::value_type(pBuff, pBuff));
}
}
return true;
}
bool CMessageBlockManager::Close(ACE_Message_Block* pMessageBlock)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadWriteLock);
if(pMessageBlock != NULL)
{
pMessageBlock->release();
}
return true;
}
_SendMessage* CSendMessagePool::Create()
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadWriteLock);
_SendMessage* pMessage = NULL;
//在Hash表中弹出一个已使用的数据
pMessage = m_objHashHandleList.Pop();
//没找到空余的
return pMessage;
}
_LG_Info* ClistManager::Get_LG_Info_By_Index(uint32 u4Index)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadLock);
if(u4Index >= (uint32)m_vecLGInfo.size())
{
return NULL;
}
else
{
return &m_vecLGInfo[u4Index];
}
}
_LG_Info* ClistManager::Get_LG_Info_By_ConnectID(uint32 u4ConnectID)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadLock);
for(uint32 u4Index = 0; u4Index < (uint32)m_vecLGInfo.size(); u4Index++)
{
if(m_vecLGInfo[u4Index].m_u4ConnectID == u4ConnectID)
{
return &m_vecLGInfo[u4Index];
}
}
return NULL;
}
void ClistManager::Del_LG_Info_By_ConnectID(uint32 u4ConnectID)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadLock);
for(vecLGInfo::iterator b = m_vecLGInfo.begin(); b != m_vecLGInfo.end(); b++)
{
if(b->m_u4ConnectID == u4ConnectID)
{
m_vecLGInfo.erase(b);
return;
}
}
Compare_MD5();
}
bool CSendMessagePool::Delete(_SendMessage* pObject)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadWriteLock);
if(NULL == pObject)
{
return false;
}
char szHashID[10] = {'\0'};
sprintf_safe(szHashID, 10, "%d", pObject->GetHashID());
pObject->Clear();
bool blState = m_objHashHandleList.Push(szHashID, pObject);
if(false == blState)
{
OUR_DEBUG((LM_INFO, "[CSendMessagePool::Delete]HashID=%s(0x%08x).\n", szHashID, pObject));
}
return true;
}
IBuffPacket* CBuffPacketManager::Create(uint32 u4BuffID)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadWriteLock);
//如果free池中已经没有了，则添加到free池中。
if(m_mapPacketFree.size() <= 0)
{
CBuffPacket* pBuffPacket = new CBuffPacket();
if(pBuffPacket != NULL)
{
//添加到Free map里面
mapPacket::iterator f = m_mapPacketFree.find(pBuffPacket);
if(f == m_mapPacketFree.end())
{
m_mapPacketFree.insert(mapPacket::value_type(pBuffPacket, pBuffPacket));
}
}
else
{
return NULL;
}
}
//从free池中拿出一个,放入到used池中
mapPacket::iterator itorFreeB = m_mapPacketFree.begin();
CBuffPacket* pBuffPacket = (CBuffPacket* )itorFreeB->second;
m_mapPacketFree.erase(itorFreeB);
//添加到used map里面
mapPacket::iterator f = m_mapPacketUsed.find(pBuffPacket);
if(f == m_mapPacketUsed.end())
{
m_mapPacketUsed.insert(mapPacket::value_type(pBuffPacket, pBuffPacket));
}
pBuffPacket->SetBuffID(u4BuffID);
return (IBuffPacket* )pBuffPacket;
}
CPacketParse* CPacketParsePool::Create()
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadWriteLock);
//如果free池中已经没有了，则添加到free池中。
if(m_mapPacketFree.size() <= 0)
{
CPacketParse* pPacket = new CPacketParse();
if(pPacket != NULL)
{
//添加到Free map里面
mapPacketParse::iterator f = m_mapPacketFree.find(pPacket);
if(f == m_mapPacketFree.end())
{
m_mapPacketFree.insert(mapPacketParse::value_type(pPacket, pPacket));
}
}
else
{
return NULL;
}
}
//从free池中拿出一个,放入到used池中
mapPacketParse::iterator itorFreeB = m_mapPacketFree.begin();
CPacketParse* pPacket = (CPacketParse* )itorFreeB->second;
m_mapPacketFree.erase(itorFreeB);
//添加到used map里面
mapPacketParse::iterator f = m_mapPacketUsed.find(pPacket);
if(f == m_mapPacketUsed.end())
{
m_mapPacketUsed.insert(mapPacketParse::value_type(pPacket, pPacket));
}
pPacket->Init();
return (CPacketParse* )pPacket;
}
void ClistManager::Get_All_LG_List(IBuffPacket* pbpList, uint32& u4Count)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadLock);
if(pbpList == NULL)
{
return;
}
u4Count = Get_LG_Count();
for(uint32 i = 0; i < u4Count; i++)
{
_LG_Info* pInfo = Get_LG_Info_By_Index(i);
_VCHARS_STR strIP;
uint8 u1Len = (uint8)strlen(pInfo->m_szIP);
strIP.SetData(pInfo->m_szIP, u1Len);
(*pbpList) << pInfo->m_u4LGID;
(*pbpList) << strIP;
(*pbpList) << pInfo->m_u4Port;
}
}
bool CCommandAccount::SaveCommandData_Mutex( uint16 u2CommandID, uint64 u8CommandCost, uint8 u1PacketType /*= PACKET_TCP*/, uint32 u4PacketSize /*= 0*/, uint32 u4CommandSize /*= 0*/, uint8 u1CommandType /*= COMMAND_TYPE_IN*/, ACE_Time_Value tvTime /*= ACE_OS::gettimeofday()*/ )
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadLock);
//统计数据到达时间，是否已经超越了限定的阀值，如果超越了，写入日志。
if(m_u8PacketTimeout < u8CommandCost)
{
//记录超时的命令
_CommandTimeOut objCommandTimeOut;
objCommandTimeOut.m_u2CommandID = u2CommandID;
objCommandTimeOut.m_u4TimeOutTime = (uint32)(u8CommandCost); //转换为毫秒
m_vecCommandTimeOut.push_back(objCommandTimeOut);
AppLogManager::instance()->WriteLog(LOG_SYSTEM_PACKETTIME, "u2CommandID=%d, Timeout=[%d].", u2CommandID, (uint32)u8CommandCost);
}
//如果流量开关打开，则记录流量(单位是分钟)
if(m_u1Flow == 1)
{
ACE_Time_Value tvNow = ACE_OS::gettimeofday();
ACE_Date_Time dtNowTime(tvNow);
uint8 u1Minute = (uint8)dtNowTime.minute();
if(m_u1Minute != u1Minute)
{
m_u4PrvFlowIn = m_u4FlowIn;
m_u4PrvFlowOut = m_u4FlowOut;
if(u1CommandType == COMMAND_TYPE_IN)
{
m_u4FlowIn = u4PacketSize;
m_u4FlowOut = 0;
}
else
{
m_u4FlowIn = 0;
m_u4FlowOut = u4PacketSize;
}
m_u1Minute = u1Minute;
}
else
{
if(u1CommandType == COMMAND_TYPE_IN)
{
m_u4FlowIn += u4PacketSize;
}
else
{
m_u4FlowOut += u4PacketSize;
}
}
}
//如果统计开关打开，才开始记录统计信息
if(m_u1CommandAccount == 0)
{
return true;
}
//查找并添加
mapCommandDataList::iterator f = m_mapCommandDataList.find(u2CommandID);
if(f != m_mapCommandDataList.end())
{
//如果已经存在，则直接添加
_CommandData* pCommandData = (_CommandData* )f->second;
if(pCommandData != NULL)
{
pCommandData->m_u4CommandCount++;
pCommandData->m_u8CommandCost += u8CommandCost;
pCommandData->m_u1PacketType = u1PacketType;
pCommandData->m_u4PacketSize += u4PacketSize;
pCommandData->m_u4CommandSize += u4CommandSize;
pCommandData->m_tvCommandTime = tvTime;
}
else
{
return false;
}
}
else
{
//添加新的命令统计信息
_CommandData* pCommandData = new _CommandData();
if(pCommandData != NULL)
{
pCommandData->m_u2CommandID = u2CommandID;
pCommandData->m_u1CommandType = u1CommandType;
pCommandData->m_u8CommandCost = u8CommandCost;
pCommandData->m_u1PacketType = u1PacketType;
pCommandData->m_u4PacketSize += u4PacketSize;
pCommandData->m_u4CommandSize += u4CommandSize;
pCommandData->m_tvCommandTime = tvTime;
m_mapCommandDataList.insert(mapCommandDataList::value_type(u2CommandID, pCommandData));
}
else
{
return false;
}
}
return true;
}
int32 CSendMessagePool::GetFreeCount()
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadWriteLock);
return m_objHashHandleList.Get_Used_Count();
}
int CMakePacketPool::GetUsedCount()
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadWriteLock);
return (int)m_mapPacketUsed.size();
}
char* ClistManager::Get_MD5_Data()
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadLock);
return (char* )m_szMD5;
}
int CPacketParsePool::GetFreeCount()
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadWriteLock);
return CObjectPoolManager<CPacketParse, ACE_Recursive_Thread_Mutex>::GetFreeCount();
}
uint32 ClistManager::Get_LG_Count()
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadLock);
return (uint32)m_vecLGInfo.size();
}
CPacketParse* CPacketParsePool::Create(const char* pFileName, uint32 u4Line)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadWriteLock);
return CObjectPoolManager<CPacketParse, ACE_Recursive_Thread_Mutex>::Create(pFileName, u4Line);
}
int CMessagePool::GetFreeCount()
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadWriteLock);
return (int)m_mapMessageFree.size();
}
int CPacketParsePool::GetFreeCount()
{
ACE_Guard<ACE_Recursive_Thread_Mutex> WGuard(m_ThreadWriteLock);
return (int)m_mapPacketFree.size();
}
