void CUnit_LogicThreadManager::Test_LogicThreadManager(void)
{
bool blRet = false;
int nRet = App_MessageQueueManager::instance()->CreateLogicThread(1,
120,
m_pLogicTestQueue);
if (0 != nRet)
{
blRet = true;
CPPUNIT_ASSERT_MESSAGE("[Test_TimerManager]CreateLogicThread is fail.", true == blRet);
}
nRet = App_MessageQueueManager::instance()->MessageMappingLogicThread(1, m_nMessage);
if (0 != nRet)
{
blRet = true;
CPPUNIT_ASSERT_MESSAGE("[Test_TimerManager]MessageMappingLogicThread is fail.", true == blRet);
}
nRet = App_MessageQueueManager::instance()->SendLogicThreadMessage(m_nMessage, NULL);
if (0 != nRet)
{
blRet = true;
CPPUNIT_ASSERT_MESSAGE("[Test_TimerManager]SendLogicThreadMessage is fail.", true == blRet);
}
ACE_Time_Value tvSleep(0, 1000);
ACE_OS::sleep(tvSleep);
OUR_DEBUG((LM_INFO, "[CUnit_LogicThreadManager]objActiveTimer is close.\n"));
}
bool CClientProConnectManager::ReConnect( int nServerID )
{
//检查当前连接是否是活跃的
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
mapProactorClientInfo::iterator f = m_mapClientInfo.find(nServerID);
if(f == m_mapClientInfo.end())
{
//如果这个链接已经存在，则不创建新的链接
//OUR_DEBUG((LM_ERROR, "[GetConnectState::Close]nServerID =(%d) is exist.\n", nServerID));
return false;
}
CProactorClientInfo* pClientInfo = (CProactorClientInfo* )f->second;
if(NULL == pClientInfo)
{
//OUR_DEBUG((LM_ERROR, "[GetConnectState::Close]nServerID =(%d) pClientInfo is NULL.\n", nServerID));
return false;
}
if(NULL == pClientInfo->GetProConnectClient())
{
//如果连接不存在，则重新建立连接
pClientInfo->Run(m_blProactorFinish);
//自动休眠0.1秒
ACE_Time_Value tvSleep(0, m_u4ConnectServerTimeout);
ACE_OS::sleep(tvSleep);
return true;
}
else
{
return true;
}
}
bool CBaseCommand::Do_SleepWorkThread(IMessage* pMessage)
{
uint32 u4PacketLen = 0;
uint16 u2CommandID = 0;
uint32 u4Index = 0;
//OUR_DEBUG((LM_INFO, "[CBaseCommand::DoMessage] CommandID = %d", COMMAND_BASE));
IBuffPacket* pBodyPacket = m_pServerObject->GetPacketManager()->Create();
if(NULL == pBodyPacket)
{
OUR_DEBUG((LM_ERROR, "[CBaseCommand::DoMessage] pBodyPacket is NULL.\n"));
return false;
}
_PacketInfo BodyPacket;
pMessage->GetPacketBody(BodyPacket);
pBodyPacket->WriteStream(BodyPacket.m_pData, BodyPacket.m_nDataLen);
(*pBodyPacket) >> u2CommandID;
(*pBodyPacket) >> u4Index;
m_pServerObject->GetPacketManager()->Delete(pBodyPacket);
m_pServerObject->GetLogManager()->WriteLog(LOG_SYSTEM, "[Do_SleepWorkThread]LogData nIdex=%d.", u4Index);
//如果是第一个包，沉睡10秒
if(u4Index == 0)
{
//沉睡10秒
ACE_Time_Value tvSleep(10, 0);
ACE_OS::sleep(tvSleep);
}
IBuffPacket* pResponsesPacket = m_pServerObject->GetPacketManager()->Create();
uint16 u2PostCommandID = COMMAND_AUTOTEST_RETURN_WORKTIMEOUT;
(*pResponsesPacket) << u2PostCommandID;
(*pResponsesPacket) << (uint32)0;
if(NULL != m_pServerObject->GetConnectManager())
{
//发送全部数据
m_pServerObject->GetConnectManager()->PostMessage(pMessage->GetMessageBase()->m_u4ConnectID, pResponsesPacket, SENDMESSAGE_NOMAL, u2PostCommandID, PACKET_SEND_IMMEDIATLY, PACKET_IS_FRAMEWORK_RECYC);
}
else
{
OUR_DEBUG((LM_INFO, "[CBaseCommand::DoMessage] m_pConnectManager = NULL"));
m_pServerObject->GetPacketManager()->Delete(pResponsesPacket);
}
return true;
}
void CLogManager::ResetLogData(uint16 u2LogLevel)
{
//重新设置日志等级，加载日志文件
SetReset(true);
//这里等待一段时间，等待其他日志全部写入完成，在重载日志模块。
//这样做少加一个锁
ACE_Time_Value tvSleep(0, 1000);
ACE_OS::sleep(tvSleep);
m_pServerLogger->ReSet(u2LogLevel);
SetReset(false);
}
int CMessageService::svc(void)
{
ACE_Message_Block* mb = NULL;
//稍微休息一下，等一下其他线程再如主循环
ACE_Time_Value tvSleep(0, MAX_MSG_SENDCHECKTIME*MAX_BUFF_1000);
ACE_OS::sleep(tvSleep);
while(IsRun())
{
mb = NULL;
//xtime = ACE_OS::gettimeofday() + ACE_Time_Value(0, MAX_MSG_PUTTIMEOUT);
if(getq(mb, 0) == -1)
{
OUR_DEBUG((LM_ERROR,"[CMessageService::svc] PutMessage error errno = [%d].\n", errno));
m_blRun = false;
break;
}
if(mb == NULL)
{
continue;
}
while(m_emThreadState != THREAD_RUN)
{
//如果模块正在卸载或者重载，线程在这里等加载完毕（等1ms）。
ACE_Time_Value tvsleep(0, 1000);
ACE_OS::sleep(tvsleep);
}
CMessage* msg = *((CMessage**)mb->base());
if(! msg)
{
OUR_DEBUG((LM_ERROR,"[CMessageService::svc] mb msg == NULL CurrthreadNo=[%d]!\n", m_u4ThreadID));
continue;
}
this->ProcessMessage(msg, m_u4ThreadID);
//使用内存池，这块内存不必再释放
}
OUR_DEBUG((LM_INFO,"[CMessageService::svc] svc finish!\n"));
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 CProactorClientInfo::SendData(ACE_Message_Block* pmblk)
{
if(NULL == m_pProConnectClient)
{
//如果连接正在建立中，等5ms看看连接是否建立
if(SERVER_CONNECT_FIRST == m_emConnectState || SERVER_CONNECT_RECONNECT == m_emConnectState)
{
ACE_Time_Value tvSleep(0, 5000);
ACE_OS::sleep(tvSleep);
}
if(NULL == m_pProConnectClient)
{
//如果连接不存在，则建立链接。
if(SERVER_CONNECT_FIRST != m_emConnectState && SERVER_CONNECT_RECONNECT != m_emConnectState)
{
//如果连接不存在，则建立链接。
Run(true);
}
if(NULL != pmblk)
{
pmblk->release();
}
//如果消息有处理接口，则返回失败接口
if(NULL != m_pClientMessage)
{
//服务器已经断开，需要等待重新连接的结果
_ClientIPInfo objServerIPInfo;
sprintf_safe(objServerIPInfo.m_szClientIP, MAX_BUFF_20, "%s", m_AddrServer.get_host_addr());
objServerIPInfo.m_nPort = m_AddrServer.get_port_number();
m_pClientMessage->ConnectError(101, objServerIPInfo);
}
return false;
}
}
//发送数据
return m_pProConnectClient->SendData(pmblk);
}
int CClientProConnectManager::handle_timeout(const ACE_Time_Value &tv, const void *arg)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock);
//OUR_DEBUG((LM_DEBUG, "[CClientProConnectManager::handle_timeout]Begin.\n"));
if(m_ProAsynchConnect.GetConnectState() == true)
{
return 0;
}
mapProactorClientInfo::iterator b = m_mapClientInfo.begin();
mapProactorClientInfo::iterator e = m_mapClientInfo.end();
for(b; b!= e; b++)
{
int nServerID = (int)b->first;
/*
//测试代码
if(GetConnectState(nServerID) == false)
{
OUR_DEBUG((LM_ERROR, "[CClientProConnectManager::handle_timeout]nServerID == false (%d).\n", nServerID));
}
else
{
OUR_DEBUG((LM_ERROR, "[CClientProConnectManager::handle_timeout]nServerID == true (%d).\n", nServerID));
}
*/
CProactorClientInfo* pClientInfo = (CProactorClientInfo* )b->second;
if(NULL == pClientInfo->GetProConnectClient())
{
//如果连接不存在，则重新建立连接
pClientInfo->Run(m_blProactorFinish);
//自动休眠0.1秒
ACE_Time_Value tvSleep(0, m_u4ConnectServerTimeout);
ACE_OS::sleep(tvSleep);
}
}
return 0;
}
bool CClientProConnectManager::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);
mapProactorClientInfo::iterator f = m_mapClientInfo.find(nServerID);
if(f != m_mapClientInfo.end())
{
//如果这个链接已经存在，则不创建新的链接
OUR_DEBUG((LM_ERROR, "[CClientProConnectManager::Connect]nServerID =(%d) is exist.\n", nServerID));
return false;
}
//初始化链接信息
CProactorClientInfo* pClientInfo = new CProactorClientInfo();
if(false == pClientInfo->Init(pIP, nPort, u1IPType, nServerID, &m_ProAsynchConnect, pClientMessage))
{
delete pClientInfo;
pClientInfo = NULL;
return false;
}
//设置本地IP和端口
pClientInfo->SetLocalAddr(pLocalIP, nLocalPort, u1LocalIPType);
//第一次开始链接
if(false == pClientInfo->Run(m_blProactorFinish, SERVER_CONNECT_FIRST))
{
delete pClientInfo;
pClientInfo = NULL;
return false;
}
//链接已经建立，添加进map
m_mapClientInfo[nServerID] = pClientInfo;
OUR_DEBUG((LM_ERROR, "[CClientProConnectManager::Connect]nServerID =(%d) connect is OK.\n", nServerID));
//自动休眠0.1秒
ACE_Time_Value tvSleep(0, m_u4ConnectServerTimeout);
ACE_OS::sleep(tvSleep);
return true;
}
void CUnit_TimerManager::Test_TimerManager(void)
{
bool blRet = false;
ActiveTimer objActiveTimer;
objActiveTimer.activate();
ACE_Time_Value tvNow = ACE_OS::gettimeofday();
long lTimerID = objActiveTimer.schedule(m_pTimeTask, NULL, tvNow + ACE_Time_Value(0, 1000));
if (-1 == lTimerID)
{
CPPUNIT_ASSERT_MESSAGE("[Test_TimerManager]schedule is fail.", true == blRet);
}
ACE_Time_Value tvSleep(0, 2000);
ACE_OS::sleep(tvSleep);
objActiveTimer.deactivate();
objActiveTimer.close();
ACE_Time_Value tvSleepClose(0, 1000);
ACE_OS::sleep(tvSleepClose);
OUR_DEBUG((LM_INFO, "[CUnit_TimerManager]objActiveTimer is close.\n"));
}
bool CConsoleHandler::PutSendPacket(ACE_Message_Block* pMbData)
{
ACE_Time_Value nowait(MAX_MSG_PACKETTIMEOUT);
if(NULL == pMbData)
{
OUR_DEBUG((LM_ERROR, "[CConsoleHandler::SendPacket] ConnectID = %d, get_handle() == ACE_INVALID_HANDLE.\n", GetConnectID()));
Close();
return false;
}
if(get_handle() == ACE_INVALID_HANDLE)
{
OUR_DEBUG((LM_ERROR, "[CConsoleHandler::SendPacket] ConnectID = %d, get_handle() == ACE_INVALID_HANDLE.\n", GetConnectID()));
sprintf_safe(m_szError, MAX_BUFF_500, "[CConsoleHandler::SendPacket] ConnectID = %d, get_handle() == ACE_INVALID_HANDLE.\n", GetConnectID());
pMbData->release();
Close();
return false;
}
//发送数据
char* pData = pMbData->rd_ptr();
if(NULL == pData)
{
OUR_DEBUG((LM_ERROR, "[CConsoleHandler::SendPacket] ConnectID = %d, pData is NULL.\n", GetConnectID()));
pMbData->release();
Close();
return false;
}
int nIsSendSize = 0;
//循环发送，直到数据发送完成。
while(true)
{
int nCurrSendSize = (int)(pMbData->length() - nIsSendSize);
if(nCurrSendSize <= 0)
{
OUR_DEBUG((LM_ERROR, "[CConsoleHandler::SendPacket] ConnectID = %d, nCurrSendSize error is %d.\n", GetConnectID(), nCurrSendSize));
pMbData->release();
return false;
}
int nDataLen = this->peer().send(pMbData->rd_ptr(), nCurrSendSize, &nowait);
int nErr = ACE_OS::last_error();
if(nDataLen <= 0)
{
if(nErr == EWOULDBLOCK)
{
//如果发送堵塞，则等10毫秒后再发送。
ACE_Time_Value tvSleep(0, 10 * MAX_BUFF_1000);
ACE_OS::sleep(tvSleep);
continue;
}
OUR_DEBUG((LM_ERROR, "[CConsoleHandler::SendPacket] ConnectID = %d, error = %d.\n", GetConnectID(), errno));
pMbData->release();
m_atvOutput = ACE_OS::gettimeofday();
Close();
return false;
}
else if(nDataLen >= nCurrSendSize) //当数据包全部发送完毕，清空。
{
//OUR_DEBUG((LM_ERROR, "[CConsoleHandler::handle_output] ConnectID = %d, send (%d) OK.\n", GetConnectID(), msg_queue()->is_empty()));
m_u4AllSendCount += 1;
m_u4AllSendSize += (uint32)pMbData->length();
pMbData->release();
m_atvOutput = ACE_OS::gettimeofday();
Close();
return true;
}
else
{
pMbData->rd_ptr(nDataLen);
nIsSendSize += nDataLen;
m_atvOutput = ACE_OS::gettimeofday();
continue;
}
}
return true;
}
int ACE_TMAIN(int argc, ACE_TCHAR* argv[])
{
if(argc > 0)
{
OUR_DEBUG((LM_INFO, "[main]argc = %d.\n", argc));
for(int i = 0; i < argc; i++)
{
OUR_DEBUG((LM_INFO, "[main]argc(%d) = %s.\n", argc, argv[i]));
}
}
//首先设置当前工作路径
SetAppPath();
//读取配置文件
if(!App_MainConfig::instance()->Init())
{
OUR_DEBUG((LM_INFO, "[main]%s\n", App_MainConfig::instance()->GetError()));
}
else
{
App_MainConfig::instance()->Display();
}
//隐式加载PacketParse
bool blState = App_PacketParseLoader::instance()->LoadPacketInfo(App_MainConfig::instance()->GetPacketParseInfo()->m_szPacketParseName);
if(true == blState)
{
//判断是否是需要以服务的状态启动
if(App_MainConfig::instance()->GetServerType() == 1)
{
OUR_DEBUG((LM_INFO, "[main]Procress is run background.\n"));
//daemon(1,1);
Gdaemon();
}
//判断当前并行连接数是否支持框架
//if(-1 == Checkfilelimit(App_MainConfig::instance()->GetMaxHandlerCount()))
//{
// return 0;
//}
//判断当前Core文件尺寸是否需要调整
if(-1 == CheckCoreLimit(App_MainConfig::instance()->GetCoreFileSize()))
{
return 0;
}
//设置监控信号量的线程
WaitQuitSignal::init();
pthread_t tid;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
pthread_create(&tid, &attr, thread_Monitor, NULL);
//第二步，启动主服务器监控
if(!App_ServerManager::instance()->Init())
{
OUR_DEBUG((LM_INFO, "[main]App_ServerManager::instance()->Init() error.\n"));
getchar();
}
OUR_DEBUG((LM_INFO, "[CServerManager::Start]Begin.\n"));
if(!App_ServerManager::instance()->Start())
{
OUR_DEBUG((LM_INFO, "[main]App_ServerManager::instance()->Start() error.\n"));
getchar();
}
OUR_DEBUG((LM_INFO, "[main]Server Run is End.\n"));
ACE_Time_Value tvSleep(2, 0);
ACE_OS::sleep(tvSleep);
OUR_DEBUG((LM_INFO, "[main]Server Exit.\n"));
pthread_exit(NULL);
}
return 0;
}
bool CMessageServiceGroup::UnloadModule(const char* pModuleName, uint8 u1State)
{
OUR_DEBUG((LM_ERROR, "[CMessageServiceGroup::UnloadModule] Begin.\n"));
for(int i = 0; i < (int)m_vecMessageService.size(); i++)
{
CMessageService* pMessageService = (CMessageService*)m_vecMessageService[i];
if(NULL != pMessageService)
{
pMessageService->SetThreadState(THREAD_MODULE_UNLOAD);
}
}
OUR_DEBUG((LM_ERROR, "[CMessageServiceGroup::UnloadModule] SET THREAD_MODULE_UNLOAD.\n"));
//等待所有进程执行结果
bool blWait = true;
while(blWait)
{
blWait = false;
for(int i = 0; i < (int)m_vecMessageService.size(); i++)
{
CMessageService* pMessageService = (CMessageService*)m_vecMessageService[i];
if(NULL != pMessageService)
{
uint32 u4State = pMessageService->GetStepState();
if(THREAD_RUNBEGIN == u4State || THREAD_BLOCK == u4State)
{
//不是所有线程都执行完了，继续等
blWait = true;
break;
}
}
}
if(blWait == true)
{
ACE_Time_Value tvSleep(0, 1000);
ACE_OS::sleep(tvSleep);
}
}
OUR_DEBUG((LM_ERROR, "[CMessageServiceGroup::UnloadModule] THREAD_MODULE_UNLOAD OVER.\n"));
//等待结束，开始重载
App_MessageManager::instance()->UnloadModuleCommand(pModuleName, u1State);
OUR_DEBUG((LM_ERROR, "[CMessageServiceGroup::UnloadModule] UnloadModuleCommand OK.\n"));
//重载结束，全部恢复线程工作
for(int i = 0; i < (int)m_vecMessageService.size(); i++)
{
CMessageService* pMessageService = (CMessageService*)m_vecMessageService[i];
if(NULL != pMessageService)
{
pMessageService->SetThreadState(THREAD_RUN);
}
}
OUR_DEBUG((LM_ERROR, "[CMessageServiceGroup::UnloadModule] End.\n"));
return true;
}
bool CConnectClient::SendData(ACE_Message_Block* pmblk)
{
//如果是DEBUG状态，记录当前接受包的二进制数据
if (App_MainConfig::instance()->GetDebug() == DEBUG_ON)
{
char szDebugData[MAX_BUFF_1024] = {'\0'};
char szLog[10] = {'\0'};
int nDebugSize = 0;
bool blblMore = false;
if (pmblk->length() >= MAX_BUFF_200)
{
nDebugSize = MAX_BUFF_200;
blblMore = true;
}
else
{
nDebugSize = (int)pmblk->length();
}
char* pData = pmblk->rd_ptr();
for (int i = 0; i < nDebugSize; i++)
{
sprintf_safe(szLog, 10, "0x%02X ", (unsigned char)pData[i]);
sprintf_safe(szDebugData + 5 * i, MAX_BUFF_1024 - 5 * i, "%s", szLog);
}
if (blblMore == true)
{
AppLogManager::instance()->WriteLog(LOG_SYSTEM_DEBUG_CLIENTRECV, "[%s:%d]%s.(数据包过长只记录前200字节)", m_addrRemote.get_host_addr(), m_addrRemote.get_port_number(), szDebugData);
}
else
{
AppLogManager::instance()->WriteLog(LOG_SYSTEM_DEBUG_CLIENTRECV, "[%s:%d]%s.", m_addrRemote.get_host_addr(), m_addrRemote.get_port_number(), szDebugData);
}
}
ACE_Time_Value nowait(MAX_MSG_PACKETTIMEOUT);
if (NULL == pmblk)
{
OUR_DEBUG((LM_ERROR, "[CConnectClient::SendData] ConnectID = %d, get_handle() == ACE_INVALID_HANDLE.\n", GetServerID()));
return false;
}
if (get_handle() == ACE_INVALID_HANDLE)
{
OUR_DEBUG((LM_ERROR, "[CConnectClient::SendData] ConnectID = %d, get_handle() == ACE_INVALID_HANDLE.\n", GetServerID()));
sprintf_safe(m_szError, MAX_BUFF_500, "[CConnectClient::SendData] ConnectID = %d, get_handle() == ACE_INVALID_HANDLE.\n", GetServerID());
pmblk->release();
return false;
}
char* pData = pmblk->rd_ptr();
if (NULL == pData)
{
OUR_DEBUG((LM_ERROR, "[CConnectClient::SendData] ConnectID = %d, pData is NULL.\n", GetServerID()));
pmblk->release();
return false;
}
int nSendLen = (int)pmblk->length(); //发送数据的总长度
int nIsSendSize = 0;
//循环发送，直到数据发送完成。
while (true)
{
if (nSendLen <= 0)
{
OUR_DEBUG((LM_ERROR, "[CConnectClient::SendData] ConnectID = %d, nCurrSendSize error is %d.\n", GetServerID(), nSendLen));
pmblk->release();
return false;
}
int nDataLen = this->peer().send(pmblk->rd_ptr(), nSendLen - nIsSendSize, &nowait);
int nErr = ACE_OS::last_error();
if (nDataLen <= 0)
{
if (nErr == EWOULDBLOCK)
{
//如果发送堵塞，则等10毫秒后再发送。
ACE_Time_Value tvSleep(0, 10 * MAX_BUFF_1000);
ACE_OS::sleep(tvSleep);
continue;
}
_ClientIPInfo objServerIPInfo;
sprintf_safe(objServerIPInfo.m_szClientIP, MAX_BUFF_20, "%s", m_addrRemote.get_host_addr());
objServerIPInfo.m_nPort = m_addrRemote.get_port_number();
m_pClientMessage->ConnectError((int)ACE_OS::last_error(), objServerIPInfo);
OUR_DEBUG((LM_ERROR, "[CConnectClient::SendData] ConnectID = %d, error = %d.\n", GetServerID(), errno));
pmblk->release();
return false;
}
else if (nDataLen + nIsSendSize >= nSendLen) //当数据包全部发送完毕，清空。
{
//OUR_DEBUG((LM_ERROR, "[CConnectHandler::handle_output] ConnectID = %d, send (%d) OK.\n", GetConnectID(), msg_queue()->is_empty()));
pmblk->release();
m_u4SendSize += (uint32)nSendLen;
m_u4SendCount++;
return true;
}
else
{
pmblk->rd_ptr(nDataLen);
nIsSendSize += nDataLen;
continue;
}
}
return true;
}
int ACE_TMAIN(int argc, ACE_TCHAR* argv[])
{
if(argc > 0)
{
OUR_DEBUG((LM_INFO, "[main]argc = %d.\n", argc));
for(int i = 0; i < argc; i++)
{
OUR_DEBUG((LM_INFO, "[main]argc(%d) = %s.\n", argc, argv[i]));
}
}
//首先设置当前工作路径
SetAppPath();
//读取配置文件
if(!App_MainConfig::instance()->Init())
{
OUR_DEBUG((LM_INFO, "[main]%s\n", App_MainConfig::instance()->GetError()));
}
else
{
App_MainConfig::instance()->Display();
}
/*
#ifndef WIN32
signal(SIGTERM, sig_term);
#endif //WIN32
*/
//判断当前并行连接数是否支持框架
if(-1 == Checkfilelimit(App_MainConfig::instance()->GetMaxHandlerCount()))
{
return 0;
}
//判断当前Core文件尺寸是否需要调整
if(-1 == CheckCoreLimit(App_MainConfig::instance()->GetCoreFileSize()))
{
return 0;
}
//判断是否是需要以服务的状态启动
if(App_MainConfig::instance()->GetServerType() == 1)
{
OUR_DEBUG((LM_INFO, "[main]Procress is run background.\n"));
//ACE::daemonize();
//daemonize();
daemon(1,1);
}
//第二步，启动主服务器监控
if(!App_ServerManager::instance()->Init())
{
OUR_DEBUG((LM_INFO, "[main]App_ServerManager::instance()->Init() error.\n"));
getchar();
}
if(!App_ServerManager::instance()->Start())
{
OUR_DEBUG((LM_INFO, "[main]App_ServerManager::instance()->Start() error.\n"));
getchar();
}
OUR_DEBUG((LM_INFO, "[main]Server Run is End.\n"));
ACE_Time_Value tvSleep(2, 0);
ACE_OS::sleep(tvSleep);
OUR_DEBUG((LM_INFO, "[main]Server Exit.\n"));
return 0;
}
bool Start()
{
//为了统计准确，找到分钟的整点启动
while(true)
{
ACE_Date_Time dtNow(ACE_OS::gettimeofday());
if(dtNow.second() == 59)
{
break;
}
else
{
OUR_DEBUG((LM_INFO, "[Start]Wait for second 59,runtime wait[%d].\n", 59 - dtNow.second()));
ACE_Time_Value tvSleep(1, 0);
ACE_OS::sleep(tvSleep);
}
}
for(uint32 i = 0; i < App_MainConfig::instance()->GerServerInfoCount(); i++)
{
_ServerInfo* pServerInfo = App_MainConfig::instance()->GetServerInfo(i);
if(NULL != pServerInfo)
{
MonitorFSM* pMonitorFSM = g_MonitorFSMManager.Create(pServerInfo, App_MainConfig::instance()->GetMailAlert());
if(NULL == pMonitorFSM)
{
OUR_DEBUG((LM_INFO, "[Start]pMonitorFSM new fail.\n"));
return false;
}
#ifdef WIN32
App_ClientProConnectManager::instance()->Connect(i,
pServerInfo->m_szServerIP,
pServerInfo->m_nPort,
pServerInfo->m_u1IPType,
pMonitorFSM->GetClientMessage());
#else
App_ClientReConnectManager::instance()->Connect(i,
pServerInfo->m_szServerIP,
pServerInfo->m_nPort,
pServerInfo->m_u1IPType,
pMonitorFSM->GetClientMessage());
#endif
ACE_Time_Value tvSleep(0, 10000);
ACE_OS::sleep(tvSleep);
}
}
#ifdef WIN32
//启动主反应器
App_ProactorManager::instance()->StartProactor();
#else
App_ReactorManager::instance()->StartReactor();
#endif
//注册定时器
ACE_Time_Value tvInterval(App_MainConfig::instance()->GetTimeInterval(), 0);
App_TimerManager::instance()->schedule(&g_MonitorFSMManager,
NULL,
ACE_OS::gettimeofday(), tvInterval);
//启动定时器
App_TimerManager::instance()->activate();
OUR_DEBUG((LM_INFO, "[Init]Start OK.\n"));
return true;
}
