HawkProfiler::~HawkProfiler()
{
m_sSocket.Close();
HAWK_RELEASE(m_pThread);
HAWK_RELEASE(m_pRecvBuf);
}
HawkLogServer::~HawkLogServer()
{
m_sSocket.Close();
HawkFree(m_pFmtBuf);
HAWK_RELEASE(m_pRecvBuf);
HAWK_RELEASE(m_pLogCache);
HAWK_RELEASE(m_pLogFile);
}
HsPlayer::~HsPlayer()
{
for (Size_t i=0;i<m_vModule.size();i++)
{
HAWK_RELEASE(m_vModule[i]);
}
m_vModule.clear();
HAWK_RELEASE(m_pData);
}
HawkSession::~HawkSession()
{
if (m_sSocket.IsValid())
m_sSocket.Close();
HAWK_RELEASE(m_pISecurity);
HAWK_RELEASE(m_pOSecurity);
HAWK_RELEASE(m_pInputBuf);
HAWK_RELEASE(m_pOutputBuf);
HAWK_RELEASE(m_pCommonBuf);
}
void HawkThread::RunTaskQueue()
{
while (m_bRunning)
{
HawkTask* pTask = 0;
if (m_qTask.size())
{
HawkAutoMutex(lock, m_pMutex);
if (m_qTask.size())
{
pTask = m_qTask.front();
m_qTask.pop_front();
m_iPopTaskCnt ++;
}
}
if (pTask)
{
pTask->Run(pTask->GetParam());
pTask->Close();
HAWK_RELEASE(pTask);
}
else
{
break;
}
}
}
Bool HsRobot::Run()
{
m_bRunning = true;
for (Int32 i=0;i<m_iCount;i++)
{
HawkThread* pThread = new HawkThread(hawk_RobotEntityRoutine);
pThread->Start();
m_vThreads.push_back(pThread);
}
while (m_bRunning)
{
HawkSleep(DEFAULT_SLEEP);
}
for (Size_t i=0;i<m_vThreads.size();i++)
{
if (m_vThreads[i])
{
m_vThreads[i]->Close();
HAWK_RELEASE(m_vThreads[i]);
}
}
m_vThreads.clear();
return true;
}
void HawkEventNotice::Clear()
{
//释放回调
if (NoticeType == NOTIFY_SESSION)
{
HawkSessionProxy* pProxy = (HawkSessionProxy*)NoticeParam.eSession.SessionProxy;
HAWK_RELEASE(pProxy);
NoticeParam.eSession.SessionProxy = 0;
}
//套接字
else if (NoticeType == NOTIFY_PEER)
{
if (NoticeParam.ePeer.Handle && NoticeParam.ePeer.Handle != INVALID_SOCKET)
closesocket(NoticeParam.ePeer.Handle);
NoticeParam.ePeer.Handle = 0;
}
//释放内存
else if (NoticeType == NOTIFY_WRITE)
{
P_SessionManager->FreeOctets(NoticeParam.eWrite.Octets);
NoticeParam.eWrite.Octets = 0;
}
memset(&NoticeParam, 0, sizeof(NoticeParam));
}
int main(int argc, Char* argv[])
{
HawkUtil::Init();
if (argc >= 2)
{
HawkOSOperator::ClearConsole();
HawkOSOperator::Gotoxy(0, 0);
HawkPrint("==============================================================");
HawkPrint("==================Gateway, Author: Daijunhua==================");
HawkPrint("==============================================================");
HawkGateway* pGateway = new HawkGateway;
AString sGwCfg = argv[1];
AString sGwSecurity = "";
if (argc >= 3)
sGwSecurity = argv[2];
if (pGateway->InitCfg(sGwCfg, sGwSecurity))
{
#ifdef _DEBUG
g_DbgThread = new HawkThread(DoKeyDownExit);
if (g_DbgThread)
g_DbgThread->Start(pGateway);
#endif
pGateway->Run();
}
HAWK_RELEASE(g_DbgThread);
HAWK_RELEASE(pGateway);
}
else
{
printf("usage: gateserver <gw.cfg> <gw-security.cfg>.\r\n");
HawkOSOperator::WaitKeyboardInput();
return -1;
}
HawkUtil::Stop();
HawkUtil::Release();
return 0;
}
HawkProtocolManager::~HawkProtocolManager()
{
ProtocolMap::iterator it = m_mRegister.begin();
for (;it!=m_mRegister.end();++it)
{
HAWK_RELEASE(it->second);
}
m_mRegister.clear();
}
Bool HawkProtocolManager::ReleaseProto(HawkProtocol*& pProto)
{
if (pProto)
{
HAWK_RELEASE(pProto);
return true;
}
return false;
}
void HawkSession::SetISecurity(HawkSecurity* pSecurity)
{
HAWK_RELEASE(m_pISecurity);
if (pSecurity)
{
m_pISecurity = pSecurity;
m_pISecurity->AddRef();
}
}
HawkAppFrame::~HawkAppFrame()
{
m_mSidAddr.Clear();
if (m_mDbHdl.size())
{
DBHdlMap::iterator it = m_mDbHdl.begin();
for (;it!=m_mDbHdl.end();it++)
{
P_DBManager->CloseDatabase(it->second->GetDBName());
}
m_mDbHdl.clear();
}
HAWK_RELEASE(m_pLogProxy);
HAWK_RELEASE(m_pGateProxy);
HAWK_RELEASE(m_pGateway);
}
Bool HawkScriptManager::DestroyState(const AString& sName)
{
StateMap::iterator it = m_mState.find(sName);
if (it!=m_mState.end())
{
HAWK_RELEASE(it->second);
return true;
}
return false;
}
HawkGateProxy::~HawkGateProxy()
{
ThreadProxyMap::iterator it = m_mThreadProxy.begin();
for (; it != m_mThreadProxy.end(); it++)
P_ZmqManager->CloseZmq(it->second);
m_mThreadProxy.clear();
HAWK_RELEASE(m_pOctets);
P_ZmqManager->CloseZmq(m_pCollectZmq);
P_ZmqManager->CloseZmq(m_pProxyZmq);
}
HsRobot::~HsRobot()
{
for (Size_t i=0;i<m_vThreads.size();i++)
{
if (m_vThreads[i])
{
m_vThreads[i]->Close();
HAWK_RELEASE(m_vThreads[i]);
}
}
m_vThreads.clear();
}
HawkGateThread::~HawkGateThread()
{
//删除基础事件
if (m_pBase)
{
event_base_free((event_base*)m_pBase);
m_pBase = 0;
}
//关闭消息队列
P_ZmqManager->CloseZmq(m_pZmq);
//释放消息缓冲
HAWK_RELEASE(m_pOctets);
//释放线程和锁
HAWK_RELEASE(m_pThread);
//释放会话列表
FreeSessionMap();
}
HawkThread::~HawkThread()
{
Close();
if (m_pThread)
{
HawkFree(m_pThread);
m_pThread = 0;
}
HAWK_RELEASE(m_pMutex);
}
Bool HawkMsgManager::FreeMsg(HawkMsg*& pMsg)
{
if (pMsg)
{
if (pMsg->SysFlag & HawkMsg::SYS_CREATE)
{
HAWK_RELEASE(pMsg);
}
return true;
}
return false;
}
Bool HawkSession::Close()
{
//关闭已存在套接字
if (m_sSocket.IsValid())
m_sSocket.Close();
//释放加密组件
HAWK_RELEASE(m_pISecurity);
HAWK_RELEASE(m_pOSecurity);
//情况数据缓冲区
if (m_pInputBuf)
m_pInputBuf->Clear();
if (m_pOutputBuf)
m_pOutputBuf->Clear();
if (m_pCommonBuf)
m_pCommonBuf->Clear();
return true;
}
void HawkThread::ClearTaskQueue()
{
HawkAutoMutex(lock, m_pMutex);
TaskQueue::iterator it = m_qTask.begin();
for (;it!=m_qTask.end();it++)
{
HawkTask* pTask = *it;
if(pTask)
pTask->Close();
HAWK_RELEASE(pTask);
}
m_qTask.clear();
}
Bool HawkBinCfgFile::LoadCfgData(const AString& sFile)
{
HawkDiskFile src_file;
if (src_file.Open(sFile))
{
//长度和CRC获取
Int64 iSize = src_file.GetFileSize();
Int32 iUnSize = 0;
UInt32 iCrc = 0;
if(src_file.Read(&iUnSize,sizeof(iUnSize)) != sizeof(iUnSize))
return false;
Int64 iComSize = iSize - (Int64)sizeof(iUnSize);
if(src_file.Read(&iCrc,sizeof(iCrc)) != sizeof(iCrc))
return false;
iComSize -= (Int64)sizeof(iCrc);
Char* pComData = new Char[(Size_t)iComSize];
HawkScope::DataArrayPtr comdata_scope(pComData);
memset(pComData, 0, (Size_t)iComSize);
if (src_file.Read(pComData,iComSize) != iComSize)
return false;
if (iCrc != HawkOSOperator::CalcCrc((const UChar*)pComData, (UInt32)iComSize))
return false;
//做位反运算
for (Int64 i=0;i<iComSize;i++)
pComData[i] = (~pComData[i]);
Char* pSrcData = new Char[iUnSize];
HawkScope::DataArrayPtr srcdata_scope(pSrcData);
memset(pSrcData,0,iUnSize);
ULong iSrcSize = (ULong)iUnSize;
if (!HawkZip::UnCompress(pSrcData, iSrcSize, pComData, (ULong)iComSize))
return false;
HAWK_RELEASE(m_pFile);
m_pFile = new HawkMemoryFile();
if (!m_pFile->Open(pSrcData, iSrcSize, false))
return false;
return true;
}
return false;
}
Bool HawkGateThread::FreeSession(Session* pSession)
{
if (pSession)
{
//释放事件
if (pSession->Event)
{
bufferevent_free((bufferevent*)pSession->Event);
pSession->Event = 0;
}
//释放内存
HAWK_RELEASE(pSession->Addr);
HAWK_RELEASE(pSession->IBuffer);
HAWK_RELEASE(pSession->ISecurity);
HAWK_RELEASE(pSession->OSecurity);
//释放会话
HawkFree(pSession);
return true;
}
return false;
}
HawkZmq* HawkZmqManager::CreateZmq(Int32 iType)
{
if (m_pZmqCtx || SetupZmqCtx())
{
HawkZmq* pZmq = new HawkZmq();
if (pZmq->Init(iType))
{
m_mZmq[pZmq] = pZmq;
return pZmq;
}
else
{
HAWK_RELEASE(pZmq);
}
}
return 0;
}
Bool HawkZmqManager::CloseZmq(HawkZmq*& pZmq)
{
if (pZmq)
{
ZmqMap::iterator it = m_mZmq.find(pZmq);
if (it != m_mZmq.end())
{
if (pZmq)
pZmq->Close();
m_mZmq.erase(it);
HAWK_RELEASE(pZmq);
return true;
}
}
return false;
}
HawkZmqManager::~HawkZmqManager()
{
ZmqMap::iterator it = m_mZmq.begin();
for (;it != m_mZmq.end();++it)
{
HawkZmq* pZmq = it->second;
if (pZmq)
pZmq->Close();
HAWK_RELEASE(pZmq);
}
m_mZmq.clear();
if(m_pZmqCtx)
{
zmq_ctx_destroy(m_pZmqCtx);
m_pZmqCtx = 0;
}
}
int main(int argc, Char* argv[])
{
HawkUtil::Init();
REGISTER_PROTO(ProtoA);
REGISTER_PROTO(ProtoB);
REGISTER_PROTO(ProtoC);
if (argc >= 2)
g_IpAddr = argv[1];
if (!g_IpAddr.size())
g_IpAddr = HawkOSOperator::ConsoleInput();
Int32 iCount = 1;
if (argc >= 3)
iCount = HawkStringUtil::StringToInt<AString>(argv[2]);
for (Int32 i=0;i<iCount;i++)
{
HawkThread* pThread = new HawkThread(hawk_EchoClientRoutine);
pThread->Start();
g_Threads.push_back(pThread);
HawkSleep(10);
}
while(HawkOSOperator::WaitKeyboardInput("",false) != 'Q');
g_Running = false;
for (Size_t i=0;i<g_Threads.size();i++)
{
g_Threads[i]->Close();
HAWK_RELEASE(g_Threads[i]);
}
HawkUtil::Stop();
HawkUtil::Release();
return 0;
}
Bool HawkBinCfgFile::LoadFromMem(const void* pData, UInt32 iSize)
{
const UChar* pDataPtr = (const UChar*)pData;
if (pData && iSize)
{
//长度和CRC获取
Int32 iUnSize = *((Int32*)pDataPtr);
pDataPtr += sizeof(Int32);
UInt32 iCrc = *((UInt32*)pDataPtr);
pDataPtr += sizeof(UInt32);
Int64 iComSize = iSize - (Int64)(sizeof(iUnSize) + sizeof(iCrc));
if (iCrc != HawkOSOperator::CalcCrc((const UChar *)pDataPtr, (UInt32)iComSize))
return false;
//拷贝数据
Char* pComData = new Char[(Size_t)iComSize];
HawkScope::DataArrayPtr comdata_scope(pComData);
memcpy(pComData, pDataPtr, (Size_t)iComSize);
//做位反运算
for (Int64 i=0;i<iComSize;i++)
pComData[i] = (~pComData[i]);
Char* pSrcData = new Char[iUnSize];
HawkScope::DataArrayPtr srcdata_scope(pSrcData);
memset(pSrcData,0,iUnSize);
ULong iSrcSize = (ULong)iUnSize;
if (!HawkZip::UnCompress(pSrcData, iSrcSize, pComData, (ULong)iComSize))
return false;
HAWK_RELEASE(m_pFile);
m_pFile = new HawkMemoryFile();
if (!m_pFile->Open(pSrcData, iSrcSize, false))
return false;
return true;
}
return false;
}
PVoid HawkThread::RunLoop()
{
m_iId = HawkOSOperator::GetThreadId();
m_iState = STATE_RUNNING;
if (m_pRoutine)
{
return (*m_pRoutine)(m_pArgs);
}
while (m_bRunning)
{
HawkTask* pTask = 0;
if (m_qTask.size())
{
HawkAutoMutex(lock, m_pMutex);
if (m_qTask.size())
{
pTask = m_qTask.front();
m_qTask.pop_front();
m_iPopTaskCnt ++;
}
}
if (pTask)
{
pTask->Run(pTask->GetParam());
pTask->Close();
HAWK_RELEASE(pTask);
}
else
{
HawkSleep(DEFAULT_SLEEP);
}
}
return 0;
}
HawkBinCfgFile::~HawkBinCfgFile()
{
HAWK_RELEASE(m_pFile);
}
HawkMsgManager::~HawkMsgManager()
{
m_mReg.clear();
HAWK_RELEASE(m_pMsgPump);
}
