Bool HawkGateProxy::Update(Int32 iTimeout)
{
//是否处理事件
Bool bDealEvent = false;
if (!CheckProxyState())
{
if (m_pCollectZmq)
m_pCollectZmq->DiscardMsg();
HawkSleep(DEFAULT_SLEEP);
}
//接收网关来的协议并回调
Protocol* pProto = 0;
GateMsgHeader sHeader;
while (RecvProtocol(sHeader, pProto, iTimeout))
{
bDealEvent = true;
//投递协议
if (!OnRecvProtocol(sHeader, pProto))
{
P_ProtocolManager->ReleaseProto(pProto);
pProto = 0;
}
//接收同时转发, 避免发送堆积
P_ZmqManager->ProxyZmq(m_pCollectZmq, m_pProxyZmq, false, iTimeout, true);
}
//把服务器的协议转发给网关
bDealEvent |= P_ZmqManager->ProxyZmq(m_pCollectZmq, m_pProxyZmq, false, iTimeout, true);
return bDealEvent;
}
PVoid hawk_EchoClientRoutine(void* pArg)
{
HawkSession session;
if (session.Init(g_IpAddr))
{
while (g_Running)
{
//更新
if (!session.Tick(PROTO_TIME))
break;
//发送协议
Int32 iType = HawkRand::RandInt(PROTO_A, PROTO_C);
if (iType == PROTO_A)
{
ProtoA sCmd;
session.SendProtocol(&sCmd);
}
else if (iType == PROTO_B)
{
ProtoB sCmd;
session.SendProtocol(&sCmd);
}
else if (iType == PROTO_C)
{
ProtoC sCmd;
session.SendProtocol(&sCmd);
}
//接收协议
Protocol* pProto = 0;
while (session.DecodeProtocol(pProto) && pProto)
{
#if (PRINT_PROTO == 1)
ProtoType iType = pProto->GetType();
if (iType == PROTO_A)
{
ProtoA* pA = (ProtoA*)pProto;
HawkFmtPrint("Msg: %s",pA->m_sMsg.c_str());
}
else if (iType == PROTO_B)
{
ProtoB* pB = (ProtoB*)pProto;
HawkFmtPrint("Size: %d, Time: %d",pB->m_iSize, pB->m_iTime);
}
else if (iType == PROTO_C)
{
ProtoC* pC = (ProtoC*)pProto;
HawkFmtPrint("X: %f, Y: %f, Z: %f",pC->m_fX, pC->m_fY, pC->m_fZ);
}
#endif
P_ProtocolManager->ReleaseProto(pProto);
}
HawkSleep(PROTO_TIME);
}
}
return 0;
}
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;
}
Bool HawkAppFrame::Run()
{
if (HawkApp::Run())
{
UInt32 iTickTime = 0;
while (m_bRunning && !m_bBreakLoop)
{
m_iSysTime = (UInt32)HawkOSOperator::GetSysTime();
iTickTime = HawkOSOperator::GetTickCount();
m_iElapseTime = iTickTime - m_iTickTime;
m_iTickTime = iTickTime;
//Hawk体系帧更新
HawkUtil::Tick(m_iElapseTime);
//网关代理器更新
if (m_pGateProxy && !m_pGateProxy->Update())
{
HawkSleep(DEFAULT_SLEEP);
}
//逻辑帧更新
OnTick(m_iElapseTime);
}
//服务器关闭异常
OnException(0);
//关闭服务器
Stop();
return true;
}
return false;
}
Bool HawkGateThread::OnThreadIdle()
{
//空闲处理
if (m_bIdle)
{
HawkSleep(DEFAULT_SLEEP);
}
return true;
}
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;
}
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;
}
Bool HawkThread::Start(void* pArgs)
{
if(!m_bRunning && !m_pThread)
{
m_pArgs = pArgs;
m_bRunning = true;
m_pThread = HawkMalloc(sizeof(pthread_t));
if (pthread_create((pthread_t*)m_pThread, 0, hawk_ThreadRoutine, this) != HAWK_OK)
{
m_bRunning = false;
m_iState = STATE_CLOSED;
return false;
}
while (m_iState != STATE_RUNNING)
{
HawkSleep(DEFAULT_SLEEP);
}
return true;
}
return false;
}
Bool HawkLogServer::Run()
{
if (!m_pLogFile && !m_pLogDB)
return false;
if (m_bRunning || !m_pRecvBuf || !m_pLogCache)
return false;
m_bRunning = true;
UInt32 iFlushTime = HawkOSOperator::GetTickCount();
while(m_bRunning)
{
UInt32 iCurTime = HawkOSOperator::GetTickCount();
if (!m_sSocket.UpdateEvent(HEVENT_READ))
{
if (iCurTime - iFlushTime >= (UInt32)m_iCacheTime)
{
FlushLogs();
iFlushTime = iCurTime;
}
else
{
HawkSleep(DEFAULT_SLEEP);
}
continue;
}
m_pRecvBuf->Clear();
Size_t iRecv = (Size_t)m_pRecvBuf->Capacity();
SocketAddr sAddr;
if(!m_sSocket.ReceiveFrom(m_pRecvBuf->Begin(), iRecv, sAddr))
continue;
m_pRecvBuf->Resize((UInt32)iRecv);
Protocol* pProto = 0;
try
{
pProto = P_ProtocolManager->Decode(*m_pRecvBuf);
if (!pProto) continue;
}
catch (HawkException& rhsExcep)
{
#ifdef _DEBUG
HawkFmtPrint("Exception: %s", rhsExcep.GetMsg().c_str());
#endif
continue;
}
ProtoType eType = pProto->GetType();
if(eType == SysProtocol::SYS_LOG_MSG)
{
SysProtocol::Sys_LogMsg* pCmd = (SysProtocol::Sys_LogMsg*)pProto;
CacheLogs(pCmd->m_iLogId, pCmd->m_iType, pCmd->m_sKey, pCmd->m_sMsg);
}
P_ProtocolManager->ReleaseProto(pProto);
}
FlushLogs();
return true;
}
