int ConfigCenter::Init(const char* pszHostName ,int port,int dbidx ,int timeout )
{
m_ctx = NULL;
m_reply = NULL;
/////////////////////////////////
struct timeval tvout = { timeout/1000, (timeout%1000)*1000 };
m_ctx = redisConnectWithTimeout(pszHostName, port, tvout);
if (m_ctx == NULL || m_ctx->err)
{
if (m_ctx)
{
LOG_ERROR("redis Connection error: %s\n", m_ctx->errstr);
redisFree(m_ctx);
}
else
{
LOG_ERROR("redis Connection error: can't allocate redis context\n");
}
return -1;
}
m_reply = (redisReply*)redisCommand(m_ctx,"SELECT %d",dbidx);
freeReplyObject(m_reply);
LOG_INFO("config center init ok !");
return HeartBeat();
}
// Connected to INT13 of CPU (use MINT13 mask):
// ISR can be used by the user.
__interrupt void INT13_ISR(void) // INT13 or CPU-Timer1
{
//***********************************WARNING!!********************************************\\
//BE CAREFUL YOU NEED TO ALLOW NESTING FOR ANY INTERRUPT THAT MIGHT HAPPEN IN THIS INTERRUPT\\
EINT; //enable all interrupts
//todo USER: Define Clock ISR
Clock_Ticks.DataOut++;
Clock_Ticks.HeartBeat++;
if (Clock_Ticks.DataOut >= DATAOUT_TICKS)
{
//send data or fill data
Clock_Ticks.DataOut = 0;
}
if (Clock_Ticks.HeartBeat >= HEARTBEAT_TICKS)
{
HeartBeat();
Clock_Ticks.HeartBeat = 0;
}
Buttons();
ReloadCpuTimer1();
StartCpuTimer1();
DINT;
}
int TLServer_IP::ClearStocks(CString clientname)
{
int cid = FindClient(clientname);
if (cid==-1) return CLIENTNOTREGISTERED;
stocks[cid] = clientstocklist(0);
HeartBeat(clientname);
D(CString(_T("Cleared stocks for ")+clientname));
return OK;
}
THREAD(idle, arg)
{
NutTimerInit();
NutThreadCreate("main", WebDemo, 0, 768);
NutThreadSetPriority(254);
for (;;) {
#ifdef HEARTBEAT_BIT
HeartBeat();
#endif
NutThreadYield();
}
}
bool ServerManager::Tick( )
{
bool ret;
ret = Select( );
if(!ret)
{
g_pLog->log_debug("%u,%u,Select Faild",0,0);
}
ret = ProcessExceptions( );
if(!ret)
{
g_pLog->log_debug("%u,%u,ProcessExceptions Faild",0,0);
}
ret = ProcessInputs( );
if(!ret)
{
g_pLog->log_debug("%u,%u,ProcessInputs Faild",0,0);
}
ret = ProcessOutputs( );
if(!ret)
{
g_pLog->log_debug("%u,%u,ProcessOutputs Faild",0,0);
}
ret = ProcessCommands( );
if(!ret)
{
g_pLog->log_debug("%u,%u,ProcessCommands Faild",0,0);
}
ret = ProcessCacheCommands( );
if(!ret)
{
g_pLog->log_debug("%u,%u,ProcessCacheCommands Faild",0,0);
}
ret = HeartBeat( );
if(!ret)
{
g_pLog->log_debug("%u,%u,HeartBeat Faild",0,0);
}
//ret = SendQueuePlayerToWorld( );
return true;
}
/*
* Wait for a character from the serial port.
*/
uint8_t GetChar(void)
{
uint8_t ch;
#ifdef HEARTBEAT_BIT
HeartBeat();
#endif
#if defined (__AVR__)
if ((inb(USR) & _BV(RXC)) == 0)
return 0;
ch = inb(UDR);
#else
ch = 0;
#endif
return ch;
}
VOID GApp::__Tick( INT iSkip, FLOAT fTimePass )
{
__ENTER_FUNCTION
// stub manager tick
m_StubManager.Tick( iSkip, fTimePass );
// app heart beat
HeartBeat( iSkip, fTimePass );
// sub systems tick
SystemPtrMap::iterator itEnd = m_mapSystems.end();
for( SystemPtrMap::iterator it = m_mapSystems.begin(); it != m_mapSystems.end(); ++it )
{
it->second->HeartBeat( iSkip, fTimePass );
}
__LEAVE_FUNCTION
}
void WSL::Singleton::LevelCycle()
{
bool break_ = false;
unsigned int c = 0;
unsigned int size = levels.Array.size();
input->refrence = engine;
if( size != 0 )
{
while( c < size && break_ == false )
{
if( levels.Array[c]->active == true )
{
if( levels.Array[c]->destroy == true )
{
unsigned int objectSize = objects.Array.size();
for( unsigned int i = 0; i < objects.Array.size()/*objectSize*/ && break_ == false; i++ )
{
if( levels.Array[c]->ObjectIsInLevel( i ) == true )
{
if( HeartBeat( i ) == -1 && objects.Array.size() != 1 && i > 0 )
--objectSize;
}
}
WSL::Algorithmic::Level *temp = levels.Array[c];
temp->SetRefrence( this );
BaseSend();
unsigned int clear = temp->SendRenderLayer();
luabind::globals( engine->luaContainer->State )[ temp->name ] = temp;
temp->Destroy();
temp->DeleteRefrence();
WSL::Algorithmic::RenderLayer *r = renderLayers.Array[clear];
r->DeleteRefrence();
temp->DeleteRenderLayer();
levels.Delete( c );
delete temp;
size -= 1;
}
else
{
if( levels.Array[c]->refresh == true )
{
unsigned int objectSize = objects.Array.size();
for( unsigned int i = 0; i < objects.Array.size()/*objectSize*/ && break_ == false; i++ )
{
if( levels.Array[c]->ObjectIsInLevel( i ) == true )
{
if( HeartBeat( i ) == -1 && objects.Array.size() != 1 && i > 0 )
--objectSize;
}
}
if( levels.Array[c]->refreshScript != "NULL" )
{
BaseSend();
levels.Array[c]->SetRefrence( this );
unsigned int clear = levels.Array[c]->SendRenderLayer();
luabind::globals( engine->luaContainer->State )[ levels.Array[c]->name ] = levels.Array[c];
levels.Array[c]->Refresh();
levels.Array[c]->DeleteRefrence();
renderLayers.Array[clear]->DeleteRefrence();
}
}
}
}
//Tee-hee//
c++;
}
}
}
int TLServer_IP::ServiceMessage(int MessageType, CString msg)
{
switch (MessageType)
{
case ORDERCANCELREQUEST :
return CancelRequest((long)atoi(msg.GetBuffer()));
case ACCOUNTREQUEST :
return AccountResponse(msg);
case CLEARCLIENT :
return ClearClient(msg);
case CLEARSTOCKS :
return ClearStocks(msg);
case REGISTERSTOCK :
{
vector<CString> rec;
gsplit(msg,CString("+"),rec);
CString client = rec[0];
vector<CString> hisstocks;
// make sure client sent a basket, otherwise clear the basket
if (rec.size()!=2) return ClearStocks(client);
// get the basket
gsplit(rec[1],CString(","),hisstocks);
// make sure we have the client
unsigned int cid = FindClient(client);
if (cid==-1) return CLIENTNOTREGISTERED; //client not registered
// save the basket
stocks[cid] = hisstocks;
D(CString(_T("Client ")+client+_T(" registered: ")+gjoin(hisstocks,",")));
HeartBeat(client);
return RegisterStocks(client);
}
case POSITIONREQUEST :
{
vector<CString> r;
gsplit(msg,CString("+"),r);
if (r.size()!=2) return UNKNOWN_MESSAGE;
return PositionResponse(r[1],r[0]);
}
case REGISTERCLIENT :
return RegisterClient(msg);
case HEARTBEAT :
return HeartBeat(msg);
case BROKERNAME :
return BrokerName();
case SENDORDER :
return SendOrder(TLOrder::Deserialize(msg));
case FEATUREREQUEST:
{
// get features supported by child class
std::vector<int> stub = GetFeatures();
// append basic feature we provide as parent
stub.push_back(REGISTERCLIENT);
stub.push_back(HEARTBEAT);
stub.push_back(CLEARSTOCKS);
stub.push_back(CLEARCLIENT);
stub.push_back(VERSION);
// send entire feature set back to client
TLSend(FEATURERESPONSE,SerializeIntVec(stub),msg);
return OK;
}
case VERSION :
return MinorVer;
}
return UnknownMessage(MessageType,msg);
}
