//Init Output
int AdControl::OutputInit(int iPort)
{
int ret;
if(iPort > 0)
m_iPort = iPort;
//Get System path
char path[AD_BYTE512];
getcwd(path,AD_BYTE512);
m_sProjectPath = path;
//init net module
cout<<"***********Output Server Init**************\n"<<endl;
ret = m_ctServer.AdServerInit(m_iPort, 1, 0);
if(ret != AD_SUCCESS)
{
AD_ERROR("AdServer init error\n");
return ret;
}
//create net (server, work, write) task
ret = AdControlNetCreateTask( static_cast<AdNetBase *>(&m_ctServer),
static_cast<AdNetTaskInterface*>(this), 1, 0);
if(ret != AD_SUCCESS)
{
AD_ERROR("AdServer Create error\n");
return ret;
}
return AD_SUCCESS;
}
int AdCharge::ChargeInit(const AdRtbConfig & ctConfig, map<UINT, AdTask *> & TaskList)
{
int ret;
//get charge server info
string sSec = "[ChargeServer]";
ADCONFIG & server = ctConfig.Get(sSec);
ADCONFIG_ITER iterConf;
//init client session
if(m_ltServer.empty())
{
//init clients
ret = m_ctClients.AdClientInit(m_ltServer, 1, 0);
if(ret != AD_SUCCESS)
{
AD_ERROR("AdClient init error\n");
return ret;
}
//create net (server, work) task
ret = AdControlNetCreateTask(static_cast<AdNetBase *>(&m_ctClients),
static_cast<AdNetTaskInterface *>(this), 1, 0);
if(ret != AD_SUCCESS)
{
AD_ERROR("AdServer Create error\n");
return ret;
}
}
else
{
//clear old server and session
list<string>::iterator iterList;
for(iterList = m_ltServer.begin(); iterList != m_ltServer.end(); iterList ++)
{
m_ctClients.AdClientDelSession(*iterList);
}
m_ltServer.clear();
}
//create session
for(iterConf = server.begin(); iterConf != server.end(); iterConf ++)
{
m_ltServer.push_back(iterConf->second);
ret = m_ctClients.AdClientCreateSession(iterConf->second);
if(ret != AD_SUCCESS)
{
AD_ERROR("AdClient Create Session error\n");
}
}
return AD_SUCCESS;
}
AdConHash::AdConHash()
{
m_pHandle = NULL;
int ret = pthread_rwlock_init(&m_pLock, NULL);
if(ret != AD_SUCCESS)
{
AD_ERROR("rwLock init error\n");
}
}
int SharedLibInit(AdProtocolBase * & ctpPro)
{
AdProtocolGdt * pPro = new AdProtocolGdt;
if(pPro == NULL)
{
AD_ERROR("Mem not enough\n");
return AD_FAILURE;
}
ctpPro = static_cast<AdProtocolBase *>(pPro);
return AD_SUCCESS;
}
void AdControl::TaskDetect(int iSecond)
{
map<UINT, AdTask *>::iterator iter;
map<UINT, UINT> mLastCounter;
while(running)
{
Time::wait(iSecond);
for(iter = m_mTasks.begin(); iter != m_mTasks.end(); iter ++)
{
if(iter->second->m_uiLoop == mLastCounter[iter->first])
{
if(!iter->second->TaskWaitting())
iter->second->create();
}
else
{
mLastCounter[iter->first] = iter->second->m_uiLoop;
}
if(iter->second->m_bTaskRun == false)
{
AD_ERROR("Server error , task 0x%x exit\n", iter->second->m_uiTaskId);
goto EXIT;
}
}
}
EXIT:
for(iter = m_mTasks.begin(); iter != m_mTasks.end(); iter ++)
{
iter->second->destroy();
}
Time::wait(1);
for(iter = m_mTasks.begin(); iter != m_mTasks.end(); iter ++)
{
delete iter->second;
}
}
int AdRedisCli::AdRedisConnect()
{
m_pGtCli = redisConnect(m_sIp.c_str(), m_iPort);
if(m_pGtCli == NULL || m_pGtCli->err)
{
AdRedisClose();
return AD_FAILURE;
}
if(m_sPasswd.size()> 0)
{
redisReply *reply;
reply = (redisReply *)redisCommand(m_pGtCli, "AUTH %s", m_sPasswd.c_str());
if (reply->type == REDIS_REPLY_ERROR) {
/* Authentication failed */
AD_ERROR("Redis Authentication failed");
freeReplyObject(reply);
return AD_FAILURE;
}
freeReplyObject(reply);
}
return AD_SUCCESS;
}
//Output Server
int AdControl::Run(AdCache * pCache, AdSession * pSession, AdTask & ctTask)
{
int ret;
int iLen;
map<UINT, AdTask *>::iterator iter;
AdTask * pTask = static_cast<AdTask *>(pSession->AdSessionGetPrivate());
if(pCache != NULL)
{
pSession->AdSessionSetTimeout(100);
//get command info, parse it
if(pCache->Size()== sizeof(AdDebug))
{
struct AdDebug * pDebug = (struct AdDebug *)pCache->Get();
switch(pDebug->uiType)
{
case AD_DEBUG_PRINT_REALTIME:
break;
case AD_DEBUG_PRINT_PROCESS:
iter = m_mTasks.find(pDebug->uiThread);
if(iter != m_mTasks.end())
{
iter->second->m_uiPrint = pDebug->uiData;
pSession->AdSessionSetPrivate(static_cast<void *>(iter->second));
}
break;
case AD_DEBUG_PRINT_INFO:
default:
AD_PRINT("Ad Rtb System Info(%s):\n", m_sProjectPath.c_str());
for(iter = m_mTasks.begin(); iter != m_mTasks.end(); iter ++)
{
AD_PRINT("%02d : %s( 0x%x & 0x%x)\n", iter->first,iter->second->m_sDescription.c_str(),
iter->second->m_uiTaskId, iter->second->getPrivateId());
iter->second->TaskPrintState();
}
break;
}
}
}
if(!pSession->AdSessionOk())
{
if(pTask != NULL)
{
pTask->m_uiPrint = 0;
pSession->AdSessionGetPrivate(true);
pSession->AdSessionSetTimeout(0);
}
}
else
{
const char *pSend = m_ctCache.GetRead(&iLen);
if(pSend != NULL)
{
ret = pSession->AdSessionWrite(pSend, iLen);
if(ret == AD_FAILURE)
{
AD_ERROR("Msg Output Error\n");
}
}
}
ctTask.m_uiLoop++;
return AD_SUCCESS;
}
