bool LinkageWorker::Run()
{
if (!OnInitialize()) {
return false;
}
HealthTimer *health = new HealthTimer(this);
if (!RegisterTimer(1000000000LL, health, true)) {
delete health;
return false;
}
bool result = true;
while (!_quit) {
if (!ev_run(_loop, 0)) {
CLOG.Error("Linkage: ev_run() returned false.");
result = false;
break;
}
}
OnShutdown();
for (events_t::iterator p = _events.begin(); p != _events.end(); ++p) {
DoRelease(p->second, false);
}
for (timers_t::iterator p = _timers.begin(); p != _timers.end(); ++p) {
DoRelease(*p, false);
}
_events.clear();
_timers.clear();
return result;
}
void ProactorService::open( ACE_HANDLE h, ACE_Message_Block& MessageBlock )
{
this->handle(h);
if (this->m_AsyncReader.open(*this) != 0 || this->m_AsyncWriter.open(*this) != 0)
{
delete this;
return;
}
m_pTimerLock = new InterlockedValue();
m_pTimerLock->Release();
m_bServiceCloseFlag = false;
m_Serial = ProactorServiceMapSingleton::instance()->Register(this);
assert(m_Serial != INVALID_ID);
RegisterTimer();
ISession::OnConnect(this->m_Serial);
PostRecv();
}
void ProactorService::open( ACE_HANDLE h, ACE_Message_Block& MessageBlock )
{
this->handle(h);
if (this->m_AsyncReader.open(*this) != 0 || this->m_AsyncWriter.open(*this) != 0)
{
delete this;
return;
}
m_pTimerLock = new InterlockedValue();
m_pTimerLock->Release();
m_bServiceCloseFlag = false;
if (g_currentSessionCnt > GetEngine()->GetMaxUserAccept())
{
if (this->handle() != ACE_INVALID_HANDLE)
ACE_OS::closesocket(this->handle());
this->handle(ACE_INVALID_HANDLE);
delete this;
return;
}
m_serial = ProactorServiceManagerSinglton::instance()->Register(this);
if (m_serial == INVALID_ID)
{
if (this->handle() != ACE_INVALID_HANDLE)
ACE_OS::closesocket(this->handle());
this->handle(ACE_INVALID_HANDLE);
delete this;
return;
}
RegisterTimer();
sockaddr_in addr;
int addrLen = sizeof(addr);
ACE_OS::getpeername(this->handle(), (sockaddr *)&addr, &addrLen);
m_sessionDesc.port = ntohs(addr.sin_port);
char* szIP = inet_ntoa(addr.sin_addr);
if(szIP != NULL)
m_sessionDesc.szIP = inet_ntoa(addr.sin_addr);
ISession::OnConnect(this->m_serial, m_sessionDesc);
PostRecv();
}
/*****************************************************************
* init timer1
* Init timer hardware if needed here
******************************************************************/
void InitTimers(void)
{
//SETUP ANY HARDWARE AS NEEDED
//CHECKOUT THE TIMERS THAT WILL BE USED IN THE SYSTEM
timer_pb = RegisterTimer(); //register the timer
//START THE TIMERS IF THEY ARE FREE RUNNING
TimerStart(timer_pb, TIME_PB0); //restart the time
}
virtual void Serialize(SActivationInfo *pActInfo, TSerialize ser)
{
if (ser.IsReading())
{
ResetTimer();
// re-enable if it's enabled
const bool bEnabled = GetPortBool(pActInfo, EIP_Enabled);
if (bEnabled)
RegisterTimer(pActInfo);
}
}
/**********************************************************************
* TimerTest
* Description: Basic test of timer functionality
* Notes: Uses 1 timer slot - cannot be unregistered, only use for
* testing and debugging.
***********************************************************************/
void TimerTest( void)
{
uint8_t t1 = 0;
t1 = RegisterTimer(); //register the timer
TimerStart(t1, 1000L); //starts t1, 1 second interval
LED0_ON; //turn on the LED
while(TimerIsOn(t1)); //wait until timer has finished
//SAME THING FOR LED OFF
TimerStart(t1, 1000L); //starts t1, 1 second interval
LED0_OFF;
while(TimerIsOn(t1));
}
virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )
{
switch (event)
{
case eFE_Initialize:
case eFE_Activate:
{
ResetTimer();
m_actInfo = *pActInfo;
const bool bEnabled = IsBoolPortActive(pActInfo, EIP_Enabled);
if (bEnabled)
RegisterTimer(pActInfo);
}
break;
}
}
void ProactorService::open( ACE_HANDLE h, ACE_Message_Block& MessageBlock )
{
this->handle(h);
if (this->m_AsyncReader.open(*this) != 0 || this->m_AsyncWriter.open(*this) != 0)
{
delete this;
return;
}
m_pTimerLock = new InterlockedValue();
m_pTimerLock->Release();
m_bServiceCloseFlag = false;
if (g_currentSessionCnt > GetEngine()->GetMaxUserAccept())
{
if (this->handle() != ACE_INVALID_HANDLE)
ACE_OS::closesocket(this->handle());
this->handle(ACE_INVALID_HANDLE);
delete this;
return;
}
m_serial = ProactorServiceManagerSinglton::instance()->Register(this);
if (m_serial == INVALID_ID)
{
if (this->handle() != ACE_INVALID_HANDLE)
ACE_OS::closesocket(this->handle());
this->handle(ACE_INVALID_HANDLE);
delete this;
return;
}
RegisterTimer();
ISession::OnConnect(this->m_serial, m_sessionDesc);
PostRecv();
}
bool LinkageWorker::Run()
{
if (!OnInitialize()) {
return false;
}
HealthTimer *health = new HealthTimer(this);
if (!RegisterTimer(1000000000LL, health, true)) {
delete health;
return false;
}
_running_thread_id = get_current_thread_id();
LOG(VERBOSE) << "Linkage: enter event loop [" << _running_thread_id << "]";
bool result = true;
while (!_quit) {
if (!ev_run(_loop, 0)) {
CLOG.Error("Linkage: ev_run() returned false.");
result = false;
break;
}
}
LOG(VERBOSE) << "Linkage: leave event loop [" << _running_thread_id << "]";
_running_thread_id = 0;
OnShutdown();
for (events_t::iterator p = _events.begin(); p != _events.end(); ++p) {
DoRelease(p->second, false);
}
for (timers_t::iterator p = _timers.begin(); p != _timers.end(); ++p) {
DoRelease(*p, false);
}
_events.clear();
_timers.clear();
return result;
}
VOID C3DCoordinateAxisMain::Init(VOID)
{
RegisterTimer();
}
