LWRESULT Cx_ZmqBackend::RunServer()
{
// Initialize poll set
LWDP_POLLITEM_T items [] = {
{ mFrontend, 0, LWDP_POLLIN, 0 },
{ mBackend, 0, LWDP_POLLIN, 0 }
};
GET_OBJECT_RET(ZmqMgr, iZmqMgr, LWDP_GET_OBJECT_ERROR);
// Switch messages between sockets
int more = 0; // Multipart detection
uint32_ more_size = sizeof (more);
while (1) {
more = 0;
iZmqMgr->Poll(items, 2, -1);
if (items [0].revents & LWDP_POLLIN)
{
while (1)
{
GET_OBJECT_RET(ZMessage, iZMessage, LWDP_GET_OBJECT_ERROR);
// Process all parts of the message
iZMessage->InitZMessage();
iZmqMgr->Recv(mFrontend, iZMessage, 0);
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::DEBUG,
"Revc From Tcp Frontend(%d)", iZMessage->Size());
iZmqMgr->Getsockopt(mFrontend, LWDP_RCVMORE, &more, &more_size);
iZmqMgr->Send(mBackend, iZMessage, more? LWDP_SNDMORE: 0);
if (!more)
break; // Last message part
Api_TaskDelay (1);
}
}
if (items [1].revents & LWDP_POLLIN)
{
while (1)
{
GET_OBJECT_RET(ZMessage, iZMessage, LWDP_GET_OBJECT_ERROR);
// Process all parts of the message
iZMessage->InitZMessage();
iZmqMgr->Recv(mBackend, iZMessage, 0);
//LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::DEBUG,
// "Revc From Zmq Backend(%d)", iZMessage->Size());
iZmqMgr->Getsockopt(mBackend, LWDP_RCVMORE, &more, &more_size);
iZmqMgr->Send(mFrontend, iZMessage, more? LWDP_SNDMORE: 0);
if (!more)
break; // Last message part
Api_TaskDelay (1);
}
}
Api_TaskDelay (1);
}
return LWDP_OK;
}
int32_ Cx_ZmqBackend::ConsoleSendToWorker(COMMAND_LINE& command_line)
{
GET_OBJECT_RET(ZmqMgr, iZmqMgr, LWDP_GET_OBJECT_ERROR);
COMMAND_LINE::iterator iter;
std::string sendBuf("");
FOREACH_STL(iter, command_line)
{
sendBuf.append(*iter);
sendBuf.append("@");
}
LWRESULT ConnectPool::GetConnect(ConnectVal& ret_connect, int32_ timeout_ms)
{
GET_OBJECT_RET(TimerTick, iTimerTick, LWDP_GET_OBJECT_ERROR);
uint32_ startTimeout = iTimerTick->GetMilliseconds();
pthread_mutex_lock(&setMutex);
while(!mIdleIndex.size())
{
if(mConnectSet.size() < mMaxConnNum)
{
MYSQL* pDb = openDb();
if(!pDb)
{
pthread_mutex_unlock(&setMutex);
return LWDP_OPEN_DB_ERROR;
}
mConnectSet.push_back(pDb);
mIdleIndex.push_back(mConnectSet.size() - 1);
}
else if(mConnectSet.size() == mMaxConnNum)
{
if(timeout_ms < 0)
{
pthread_mutex_unlock(&setMutex);
return LWDP_GET_POOL_CONNECT_TIMEOUT;
}
uint32_ nowTimeout = iTimerTick->GetMilliseconds();
uint32_ diff = nowTimeout - startTimeout;
if(diff > timeout_ms)
{
pthread_mutex_unlock(&setMutex);
return LWDP_GET_POOL_CONNECT_TIMEOUT;
}
pthread_cond_wait(&timeOutCond, &setMutex);
continue;
}
}
uint32_ selectIndex = randof(mIdleIndex.size());
ConnectVal retVal;
retVal.index = mIdleIndex[selectIndex];
retVal.connect = mConnectSet[retVal.index];
ret_connect = retVal;
return LWDP_OK;
}
void *
thr(void * arg)
{
int i = 5 ;
GET_OBJECT_RET(LogMgr, iLogMgr, 0);
while(1)
{
iLogMgr->LogPrint("Test", LWDP_LOG_MGR::DEBUG, __FILE__, __LINE__, "Thr Hello World3!!");
printf("TTTTTTT %d\n", i++);
#ifdef WIN32
Sleep(1000);
#else
sleep(1);
#endif
}
}
LWRESULT Cx_TSFrontend::createTcpServer(int port)
{
mServerSocket = socket(AF_INET, SOCK_STREAM, 0);
if(mServerSocket <= 0)
{
LWDP_LOG_PRINT("TSFRONTEND", LWDP_LOG_MGR::ERR, "Socket Create Failed");
return TSFRONTEND::LWDP_CREATE_SOCKET_ERR;
}
setNonblock(mServerSocket);
setReuseaddr(mServerSocket);
sockaddr_in addr;
setAddress("0.0.0.0", port, &addr);
int ret = bind(mServerSocket, (struct sockaddr*)&addr, sizeof(addr));
if(ret)
{
LWDP_LOG_PRINT("TSFRONTEND", LWDP_LOG_MGR::ERR,
"Bind(port:%d) Socket Failed", port);
return TSFRONTEND::LWDP_BIND_SOCKET_ERR;
}
GET_OBJECT_RET(ConfigMgr, iConfigMgr, LWDP_GET_OBJECT_ERROR);
XPropertys propBlock;
iConfigMgr->GetModulePropEntry(LW_TSFRONTEND_MODULE_NAME, LW_TSFRONTEND_MODULE_BLOCK_NAME, propBlock);
uint32_ blockNum = LW_TSFRONTEND_BLOCK;
if(!propBlock[0].propertyText.empty())
{
blockNum = atol(propBlock[0].propertyText.c_str());
}
else
{
LWDP_LOG_PRINT("TSFRONTEND", LWDP_LOG_MGR::WARNING,
"Can't Find <ListenBlock> In Config File, Default(%d)", blockNum);
}
ret = listen(mServerSocket, blockNum); //
if(ret)
{
LWDP_LOG_PRINT("TSFRONTEND", LWDP_LOG_MGR::ERR,
"Listen Socket Failed");
return TSFRONTEND::LWDP_LISTEN_SOCKET_ERR;
}
return LWDP_OK;
}
void* worker_task (void *args)
{
GET_OBJECT_RET(DbMgr, iDbMgr, 0);
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::INFO,
"Connect to Db Server Ip:%s User:%s DbName:%s Port:%d",
strDbIp.c_str(), strDbUserName.c_str(), strDbName.c_str(), DbPort);
DBHandle dbHandle = iDbMgr->Open(strDbIp.c_str(),
strDbUserName.c_str(),
strDbPassword.c_str(),
strDbName.c_str(),
DbPort, 0);
if(!dbHandle)
{
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::INFO,
"Worke Thread Connect Db Error!");
return NULL;
}
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::INFO,
"Worke Thread Connect Db Ok!");
GET_OBJECT_RET(ZmqMgr, iZmqMgr, 0);
////////////////////////////////////////////////
ContextHandle context = (ContextHandle)Cx_ZmqBackend::mContext;
SocketHandle responder = iZmqMgr->GetNewSocket(context, LWDP_REP);
s_set_id(responder);
GET_OBJECT_RET(ConfigMgr, iConfigMgr, 0);
//backend
std::string strWorkThread = std::string(LW_ZMQBACKEND_WORKTHREAD_TARGET);
XPropertys propWorkThread;
iConfigMgr->GetModulePropEntry(LW_ZMQBACKEND_MODULE_NAME, LW_ZMQBACKEND_WORKTHREAD_TARGET_NAME, propWorkThread);
if(!propWorkThread[0].propertyText.empty())
{
strWorkThread = propWorkThread[0].propertyText;
}
else
{
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::WARNING,
"Can't Find <ConnetTarget> In Config File, Default(%s)", strWorkThread.c_str());
}
if(iZmqMgr->Connect(responder, strWorkThread.c_str()) != LWDP_OK)
{
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::ERR,
"Connect to Backend Error(%s)", strWorkThread.c_str());
return NULL;
}
/////////////////////////////////////////////
SocketHandle ctrlClient = iZmqMgr->GetNewSocket(context, LWDP_SUB);
s_set_id(ctrlClient);
//ctrl_client
std::string strCtrlClient = std::string(LW_ZMQBACKEND_CTRL_CLIENT_TARGET);
XPropertys propCtrlClient;
iConfigMgr->GetModulePropEntry(LW_ZMQBACKEND_MODULE_NAME, LW_ZMQBACKEND_CTRL_CLIENT_NAME, propCtrlClient);
if(!propCtrlClient[0].propertyText.empty())
{
strCtrlClient = propCtrlClient[0].propertyText;
}
else
{
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::WARNING,
"Can't Find <CtrlConnect> In Config File, Default(%s)", strCtrlClient.c_str());
}
if(iZmqMgr->Connect(ctrlClient, strCtrlClient.c_str()) != LWDP_OK)
{
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::ERR,
"Connect to Backend Ctrl Error(%s)", strCtrlClient.c_str());
return NULL;
}
iZmqMgr->Setsockopt(ctrlClient, LWDP_SUBSCRIBE, "", 0);
// Initialize poll set
LWDP_POLLITEM_T items [] = {
{ responder, 0, LWDP_POLLIN, 0 },
{ ctrlClient, 0, LWDP_POLLIN, 0 }
};
// Switch messages between sockets
Cx_Interface<Ix_ZMessage> iZMessage;
int more = 0; // Multipart detection
uint32_ more_size = sizeof (more);
while (1) {
more = 0;
iZmqMgr->Poll(items, 2, -1);
if (items [0].revents & LWDP_POLLIN)
{
while (1)
{
GET_OBJECT_RET(ZMessage, iTmpMsg, 0);
// Wait for next request from client
// Process all parts of the message
iTmpMsg->InitZMessage();
iZmqMgr->Recv(responder, iTmpMsg, 0);
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::DEBUG,
"Work Thread Revc(%d)", iTmpMsg->Size());
iZmqMgr->Getsockopt(responder, LWDP_RCVMORE, &more, &more_size);
if (!more)
{
iZMessage = iTmpMsg;
break; // Last message part
}
//Api_TaskDelay (1);
}
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::NOTICE,
"ZMQ Server Received request: [%d]", iZMessage->Size());
// Do some 'work'
GET_OBJECT_RET(ZmqBackend, iZmqBackend, 0);
Data_Ptr sendData;
sendData.reset();
uint32_ sendLen = 0;
LWRESULT res = iZmqBackend->CallBackZmqMsg(dbHandle, (uint8_*)iZMessage->Data(), iZMessage->Size(), sendData, sendLen);
if(res != LWDP_OK)
{
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::ERR,
"CallBackZmqMsg ret Error(%x)", res);
//continue;
}
if(sendLen < 0)
{
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::ERR,
"Zmq Send Data Length is too Small(%d)", sendLen);
//continue;
}
// Send reply back to client
GET_OBJECT_RET(ZMessage, iZSMessage, 0);
iZSMessage->InitZMessage();
iZSMessage->SetValue(sendData.get(), sendLen);
iZmqMgr->Send(responder, iZSMessage, 0);
//Api_TaskDelay(1);
}
if (items [1].revents & LWDP_POLLIN)
{
while (1)
{
GET_OBJECT_RET(ZMessage, iTmpMsg, 0);
// Wait for next request from client
// Process all parts of the message
iTmpMsg->InitZMessage();
iZmqMgr->Recv(ctrlClient, iTmpMsg, 0);
//LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::DEBUG,
// "Work Thread Revc(%d)", iTmpMsg->Size());
iZmqMgr->Getsockopt(ctrlClient, LWDP_RCVMORE, &more, &more_size);
if (!more)
{
iZMessage = iTmpMsg;
break; // Last message part
}
//Api_TaskDelay (1);
}
// Do some 'work'
GET_OBJECT_RET(ZmqBackend, iZmqBackend, 0);
iZmqBackend->CallBackCtrl((const char_ *)iZMessage->Data(), iZMessage->Size());
}
}
iZmqMgr->CloseSocket(responder);
iZmqMgr->CloseContext(context);
return 0;
}
LWRESULT Cx_ZmqBackend::Init()
{
mMsgDelegateMap.clear();
GET_OBJECT_RET(ZmqMgr, iZmqMgr, LWDP_GET_OBJECT_ERROR);
Cx_ZmqBackend::mContext = iZmqMgr->GetNewContext();
mFrontend = iZmqMgr->GetNewSocket(Cx_ZmqBackend::mContext, LWDP_ROUTER);
mBackend = iZmqMgr->GetNewSocket(Cx_ZmqBackend::mContext, LWDP_DEALER);
GET_OBJECT_RET(ConfigMgr, iConfigMgr, LWDP_GET_OBJECT_ERROR);
XPropertys propDbIp;
iConfigMgr->GetModulePropEntry(LW_ZMQBACKEND_MODULE_NAME, LW_ZMQBACKEND_DB_IP_NAME, propDbIp);
if(!propDbIp[0].propertyText.empty())
{
strDbIp = propDbIp[0].propertyText;
}
else
{
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::WARNING,
"Can't Find <DbIp> In Config File, Default(%s)", strDbIp.c_str());
}
XPropertys propDbUserName;
iConfigMgr->GetModulePropEntry(LW_ZMQBACKEND_MODULE_NAME, LW_ZMQBACKEND_DB_USER_NAME, propDbUserName);
if(!propDbUserName[0].propertyText.empty())
{
strDbUserName = propDbUserName[0].propertyText;
}
else
{
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::WARNING,
"Can't Find <DbUser> In Config File, Default(%s)", strDbUserName.c_str());
}
XPropertys propDbPassword;
iConfigMgr->GetModulePropEntry(LW_ZMQBACKEND_MODULE_NAME, LW_ZMQBACKEND_DB_PASSWORD_NAME, propDbPassword);
if(!propDbPassword[0].propertyText.empty())
{
strDbPassword = propDbPassword[0].propertyText;
}
else
{
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::WARNING,
"Can't Find <DbPassword> In Config File, Default(%s)", strDbPassword.c_str());
}
XPropertys propDbName;
iConfigMgr->GetModulePropEntry(LW_ZMQBACKEND_MODULE_NAME, LW_ZMQBACKEND_DB_SELECT_DB_NAME, propDbName);
if(!propDbName[0].propertyText.empty())
{
strDbName = propDbName[0].propertyText;
}
else
{
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::WARNING,
"Can't Find <DbName> In Config File, Default(%s)", strDbName.c_str());
}
XPropertys propDbPort;
iConfigMgr->GetModulePropEntry(LW_ZMQBACKEND_MODULE_NAME, LW_ZMQBACKEND_DB_PORT_NAME, propDbPort);
if(!propDbPort[0].propertyText.empty())
{
DbPort = atol(propDbPort[0].propertyText.c_str());
}
else
{
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::WARNING,
"Can't Find <DbPort> In Config File, Default(%d)", DbPort);
}
//frontend
std::string strFrontend = std::string(LW_ZMQBACKEND_FRONTEND_TARGET);
XPropertys propFrontend;
iConfigMgr->GetModulePropEntry(LW_ZMQBACKEND_MODULE_NAME, LW_ZMQBACKEND_FRONTEND_TARGET_NAME, propFrontend);
if(!propFrontend[0].propertyText.empty())
{
strFrontend = propFrontend[0].propertyText;
}
else
{
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::WARNING,
"Can't Find <FrontendTarget> In Config File, Default(%s)", strFrontend.c_str());
}
iZmqMgr->Bind(mFrontend, strFrontend.c_str());
//backend
std::string strBackend = std::string(LW_ZMQBACKEND_BACKEND_TARGET);
XPropertys propBackend;
iConfigMgr->GetModulePropEntry(LW_ZMQBACKEND_MODULE_NAME, LW_ZMQBACKEND_BACKEND_TARGET_NAME, propBackend);
if(!propBackend[0].propertyText.empty())
{
strBackend = propBackend[0].propertyText;
}
else
{
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::WARNING,
"Can't Find <BackendTarget> In Config File, Default(%s)",
strBackend.c_str());
}
iZmqMgr->Bind(mBackend, strBackend.c_str());
//Ctrl
Cx_ZmqBackend::mCtrlend = iZmqMgr->GetNewSocket(Cx_ZmqBackend::mContext, LWDP_PUB);
//ctrl_client
std::string strCtrlClient = std::string(LW_ZMQBACKEND_CTRL_CLIENT_TARGET);
XPropertys propCtrlClient;
iConfigMgr->GetModulePropEntry(LW_ZMQBACKEND_MODULE_NAME, LW_ZMQBACKEND_CTRL_CLIENT_NAME, propCtrlClient);
if(!propCtrlClient[0].propertyText.empty())
{
strCtrlClient = propCtrlClient[0].propertyText;
}
else
{
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::WARNING,
"Can't Find <CtrlConnect> In Config File, Default(%s)",
strCtrlClient.c_str());
}
if(iZmqMgr->Bind(Cx_ZmqBackend::mCtrlend, strCtrlClient.c_str()) != LWDP_OK)
{
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::ERR,
"Bind Ctrl Error(%s)",
strCtrlClient.c_str());
return NULL;
}
Cx_Interface<Ix_ConsoleMgr> iConsoleMgr(CLSID_ConsoleMgr);
if(!iConsoleMgr.IsNull())
{
ConsoleCBDelegate regFun = MakeDelegate(this, &Cx_ZmqBackend::ConsoleSendToWorker);
RINOK(iConsoleMgr->RegisteCommand(LW_ZMQBACKEND_COMMAND_SENDTOWORKER_NAME, regFun,
LW_ZMQBACKEND_COMMAND_SENDTOWORKER_INFO));
}
//////////////////////////////////////////////
// thread
int32_ workThreadNum = LW_ZMQBACKEND_WORKTHREAD_NUM;
XPropertys propWorkThreadNum;
iConfigMgr->GetModulePropEntry(LW_ZMQBACKEND_MODULE_NAME, LW_ZMQBACKEND_WORKTHREAD_NUM_NAME, propWorkThreadNum);
if(!propWorkThreadNum[0].propertyText.empty())
{
workThreadNum = atol(propWorkThreadNum[0].propertyText.c_str());
}
else
{
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::WARNING,
"Can't Find <WorkThreadNum> In Config File, Default(%d)", workThreadNum);
}
for(int i = 0; i < workThreadNum; ++i)
{
pthread_t t;
int result;
result = pthread_create(&t, NULL, worker_task, NULL);
if(result != 0){
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::ERR,
"Can't Create Thread Ret: %d", result);
return ZMQBACKEND::LWDP_CREATE_WORK_THREAD_ERR;
}
result = pthread_detach(t);
if(result != 0){
LWDP_LOG_PRINT("ZMQBACKEND", LWDP_LOG_MGR::ERR,
"Can't Detach Thread Ret: %d", result);
return ZMQBACKEND::LWDP_CREATE_DETACH_THREAD_ERR;
}
}
return LWDP_OK;
}
void* thread_callback(void* vfd)
{
LWDP_LOG_PRINT("TSFRONTEND", LWDP_LOG_MGR::DEBUG, "Thread Callback fd(%x)!", vfd);
TimerProcessController NumCount(cb, &gProcessStatic);
if(!vfd)
{
LWDP_LOG_PRINT("TSFRONTEND", LWDP_LOG_MGR::ERR,
"Thread Param is NULL");
return NULL;
}
GET_OBJECT_RET(ZmqMgr, iZmqMgr, NULL);
Cx_Interface<Ix_ZMessage> iZMessage;
int accept_conn = *(int*)vfd;
free(vfd);
int more = 0;
uint32_ more_size = sizeof(more);
uint32_ indexSend = 0;
uint32_ indexRecv = 0;
TS_TCP_SERVER_MSG* sendMsgStru = NULL;
uint8_* sendBuf = NULL;
TS_TCP_SERVER_MSG* clientMsg = NULL;
uint32_ headLen = sizeof(uint32_) * 2;
uint32_ zmq_ret_len = 0;
SocketHandle requester = NULL;
//////////////////////////////////////////////////////////////
// Recv Tcp Message from Client
//////////////////////////////////////////////////////////////
int32_ ret_len = 0;
uint32_ totleSize = gRecvBufMaxLen;
uint8_* recvBuf = (uint8_*)malloc(totleSize * sizeof(uint8_));
ASSERT_CHECK_RET(LWDP_PLUGIN_LOG, NULL, recvBuf, "Malloc Recv Buffer Error!");
uint32_ recvCheckPacketLen = 0;
while(1)
{
//Recv Data Length
ret_len = recv(accept_conn, (char *)recvBuf+indexRecv, totleSize-indexRecv, 0);
if(ret_len == 0)
{
LWDP_LOG_PRINT("TSFRONTEND", LWDP_LOG_MGR::WARNING,
"Remote Socket Closed fd(%x)", accept_conn);
goto ERR_TCP_TAG;
}
else if(ret_len < 0)
{
#ifdef LWDP_PLATFORM_DEF_WIN32
errno = WSAGetLastError();
if(errno == EAGAIN || errno == WSAEWOULDBLOCK)
#else
if (errno == EAGAIN || errno == EWOULDBLOCK)
#endif
{
Api_TaskDelay(10);
continue;
}
else
{
LWDP_LOG_PRINT("TSFRONTEND", LWDP_LOG_MGR::WARNING,
"Remote Socket Closed fd(%x)", accept_conn);
goto ERR_TCP_TAG;
}
}
//first read
if(!recvCheckPacketLen)
{
clientMsg = (TS_TCP_SERVER_MSG*)recvBuf;
totleSize = clientMsg->msgLength;
recvCheckPacketLen++;
if(totleSize > gRecvBufMaxLen)
{
clientMsg->statusCode = TS_SERVER_TCP_MSG_LEN_ERROR;
clientMsg->msgLength = sizeof(TS_TCP_SERVER_MSG);
send(accept_conn, (char *)clientMsg, clientMsg->msgLength, 0);
LWDP_LOG_PRINT("TSFRONTEND", LWDP_LOG_MGR::WARNING,
"Tcp Recv Packet is Too Long: recvlen(%d) the Max Packet Length is(%d)",
totleSize, gRecvBufMaxLen);
goto ERR_TCP_TAG;
}
gThreadMbps->Update(totleSize);
}
LWDP_LOG_PRINT("TSFRONTEND", LWDP_LOG_MGR::NOTICE,
"Tcp Recv Packet Size: (%d)", ret_len);
if((ret_len + indexRecv) < totleSize)
{
indexRecv += ret_len;
Api_TaskDelay(1);
continue;
}
break;
};
LWDP_LOG_PRINT("TSFRONTEND", LWDP_LOG_MGR::NOTICE,
"Recv Client Message: (%d)", clientMsg->msgLength);
//if(clientMsg->msgLength > ret_len)
//{
// clientMsg->statusCode = TS_SERVER_TCP_MSG_LEN_ERROR;
// clientMsg->msgLength = sizeof(TS_TCP_SERVER_MSG);
// send(accept_conn, (char *)clientMsg, clientMsg->msgLength, 0);
// goto ERR_TCP_TAG;
//}
requester = iZmqMgr->GetNewSocket(gContextHandle, LWDP_REQ);
RINOKR(iZmqMgr->Connect(requester, gConnStr.c_str()), NULL);
//Set Option
{
//Set Send Timeout
//RINOKR(iZmqMgr->Setsockopt (requester, LWDP_SNDTIMEO,
// &gSendTimeout, sizeof(gSendTimeout)), NULL);
//Set Recv Timeout
//RINOKR(iZmqMgr->Setsockopt (requester, LWDP_RCVTIMEO,
// &gRecvTimeout, sizeof(gRecvTimeout)), NULL);
}
//////////////////////////////////////////////////////////////
// Send Message to ZMQ
//////////////////////////////////////////////////////////////
headLen = sizeof(uint32_) * 2;
zmq_ret_len = iZmqMgr->Send(requester, recvBuf + headLen, totleSize - headLen, 0);
if(zmq_ret_len != totleSize - headLen)
{
LWDP_LOG_PRINT("TSFRONTEND", LWDP_LOG_MGR::ERR,
"Send Message Timeout or Error fd(%x) ret(%d) send(%d)", accept_conn, totleSize, zmq_ret_len);
goto ERR_ZMQ_TAG;
}
//////////////////////////////////////////////////////////////
// Recv Message from ZMQ
//////////////////////////////////////////////////////////////
while (1)
{
GET_OBJECT_RET(ZMessage, iMsg, 0);
// Process all parts of the message
iMsg->InitZMessage();
iZmqMgr->Recv(requester, iMsg, 0);
iZmqMgr->Getsockopt(requester, LWDP_RCVMORE, &more, &more_size);
if (!more)
{
iZMessage = iMsg;
break; // Last message part
}
Api_TaskDelay (1);
}
iZmqMgr->CloseSocket(requester);
if(!iZMessage->Size())
{
LWDP_LOG_PRINT("TSFRONTEND", LWDP_LOG_MGR::ERR,
"Recv ZMQ Message Timeout or Error fd(%x) ret(%d)", accept_conn, ret_len);
goto ERR_ZMQ_TAG;
}
LWDP_LOG_PRINT("TSFRONTEND", LWDP_LOG_MGR::NOTICE,
"Recv Message from ZMQ: Len (%d)", iZMessage->Size());
//////////////////////////////////////////////////////////////
// Tcp Send to Client
//////////////////////////////////////////////////////////////
sendBuf = (uint8_ *)malloc(sizeof(TS_TCP_SERVER_MSG) + iZMessage->Size());
ASSERT_CHECK_RET(LWDP_PLUGIN_LOG, 0, sendBuf, "TSFrontend thread Malloc Send Buf ERROR");
sendMsgStru = (TS_TCP_SERVER_MSG*)sendBuf;
sendMsgStru->msgLength = sizeof(TS_TCP_SERVER_MSG) + iZMessage->Size();
sendMsgStru->statusCode = 0;
memcpy(sendMsgStru->tcpMsgBody, iZMessage->Data(), iZMessage->Size());
while(1)
{
//Send Data Length
ret_len = send(accept_conn, (char *)sendMsgStru + indexSend, sendMsgStru->msgLength - indexSend, 0);
if(ret_len == 0)
{
LWDP_LOG_PRINT("TSFRONTEND", LWDP_LOG_MGR::WARNING,
"Remote Socket Closed fd(%x)", accept_conn);
free(sendBuf);
goto ERR_ZMQ_TAG;
}
else if(ret_len < 0)
{
#ifdef LWDP_PLATFORM_DEF_WIN32
errno = WSAGetLastError();
if(errno == EAGAIN || errno == WSAEWOULDBLOCK)
#else
if (errno == EAGAIN || errno == EWOULDBLOCK)
#endif
{
Api_TaskDelay(1);
continue;
}
else
{
LWDP_LOG_PRINT("TSFRONTEND", LWDP_LOG_MGR::WARNING,
"Remote Socket Closed fd(%x)", accept_conn);
free(sendBuf);
goto ERR_ZMQ_TAG;
}
}
if(ret_len + indexSend < iZMessage->Size())
{
indexSend += ret_len;
Api_TaskDelay(1);
continue;
}
break;
};
free(sendBuf);
ERR_ZMQ_TAG:
//iZmqMgr->CloseSocket(requester);
//iZmqMgr->CloseContext(context);
ERR_TCP_TAG:
free(recvBuf);
#ifdef LWDP_PLATFORM_DEF_WIN32
int rc = closesocket(accept_conn);
#else
::close (accept_conn);
#endif
Api_TaskDelay(5);
return NULL;
}
LWRESULT Cx_TSFrontend::RunServer()
{
GET_OBJECT_RET(EventMgr, iEventMgr, LWDP_GET_OBJECT_ERROR);
return iEventMgr->RunLoop(0);
}
LWRESULT Cx_TSFrontend::Init()
{
GET_OBJECT_RET(PerfMgr_Cps, iPerfMgr_Cps_Io, LWDP_GET_OBJECT_ERROR);
gIoPerSecond = iPerfMgr_Cps_Io;
GET_OBJECT_RET(PerfMgr_Cps, iPerfMgr_Cps_Create, LWDP_GET_OBJECT_ERROR);
gThreadPerCreate = iPerfMgr_Cps_Create;
GET_OBJECT_RET(PerfMgr_Cps, iPerfMgr_Cps_Destory, LWDP_GET_OBJECT_ERROR);
gThreadPerRelease = iPerfMgr_Cps_Destory;
GET_OBJECT_RET(PerfMgr_Cps, iPerfMgr_Cps_MBPS, LWDP_GET_OBJECT_ERROR);
gThreadMbps = iPerfMgr_Cps_MBPS;
GET_OBJECT_RET(ConfigMgr, iConfigMgr, LWDP_GET_OBJECT_ERROR);
XPropertys propMax;
iConfigMgr->GetModulePropEntry(LW_TSFRONTEND_MODULE_NAME, LW_TSFRONTEND_BUF_MAX_LEN_NAME, propMax);
if(!propMax[0].propertyText.empty())
{
gRecvBufMaxLen = atol(propMax[0].propertyText.c_str());
}
else
{
LWDP_LOG_PRINT("TSFRONTEND", LWDP_LOG_MGR::WARNING,
"Can't Find <RecvBufMaxLen> In Config File, Default(%d)", gRecvBufMaxLen);
}
//Connect
XPropertys propConnet;
iConfigMgr->GetModulePropEntry(LW_TSFRONTEND_MODULE_NAME, LW_TSFRONTEND_CONNECT_TARGET_NAME, propConnet);
if(!propConnet[0].propertyText.empty())
{
gConnStr = propConnet[0].propertyText;
}
else
{
LWDP_LOG_PRINT("TSFRONTEND", LWDP_LOG_MGR::WARNING,
"Can't Find <ConnetTarget> In Config File, Default(%s)", gConnStr.c_str());
}
//Set Send Timeout
XPropertys propSend;
iConfigMgr->GetModulePropEntry(LW_TSFRONTEND_MODULE_NAME, LW_TSFRONTEND_SEND_TIMEOUT_NAME, propSend);
if(!propSend[0].propertyText.empty())
{
gSendTimeout = atol(propSend[0].propertyText.c_str());
}
else
{
LWDP_LOG_PRINT("TSFRONTEND", LWDP_LOG_MGR::WARNING,
"Can't Find <SendTimeout> In Config File, Default(%d)", gSendTimeout);
}
//Set Recv Timeout
XPropertys propRecv;
iConfigMgr->GetModulePropEntry(LW_TSFRONTEND_MODULE_NAME, LW_TSFRONTEND_RECV_TIMEOUT_NAME, propRecv);
if(!propRecv[0].propertyText.empty())
{
gRecvTimeout = atol(propRecv[0].propertyText.c_str());
}
else
{
LWDP_LOG_PRINT("TSFRONTEND", LWDP_LOG_MGR::WARNING,
"Can't Find <RecvTimeout> In Config File, Default(%d)", gRecvTimeout);
}
XPropertys propPort;
iConfigMgr->GetModulePropEntry(LW_TSFRONTEND_MODULE_NAME, LW_TSFRONTEND_MODULE_PORT_NAME, propPort);
uint32_ portNum = LW_TSFRONTEND_SERVER_PORT;
if(!propPort[0].propertyText.empty())
{
portNum = atol(propPort[0].propertyText.c_str());
}
else
{
LWDP_LOG_PRINT("TSFRONTEND", LWDP_LOG_MGR::WARNING,
"Can't Find <ServerPort> In Config File, Default(%d)", portNum);
}
RINOK(createTcpServer(portNum));
GET_OBJECT_RET(EventMgr, iEventMgr, 0);
RINOK(iEventMgr->InitLoop(0));
mIoWatcher = iEventMgr->CreateWatcher(LWEV::WATCHER_IO, (WATCHER_CALLBACK)io_callback, mServerSocket, LW_READ);
if(!mIoWatcher)
{
LWDP_LOG_PRINT("TSFRONTEND", LWDP_LOG_MGR::ERR, "iEventMgr->CreateWatcher Create IO Watcher Error");
return TSFRONTEND::LWDP_CREATE_IO_WATCHER_ERR;
}
GET_OBJECT_RET(ZmqMgr, iZmqMgr, -1);
gContextHandle = iZmqMgr->GetNewContext();
//Start Watcher
iEventMgr->WatcherStart(mIoWatcher);
Cx_Interface<Ix_ConsoleMgr> iConsoleMgr(CLSID_ConsoleMgr);
if(!iConsoleMgr.IsNull())
{
ConsoleCBDelegate regFun = MakeDelegate(this, &Cx_TSFrontend::ConsoleGetTsInfo);
RINOK(iConsoleMgr->RegisteCommand(LW_TSFRONTEND_COMMAND_GET_INFO_NAME, regFun,
LW_TSFRONTEND_COMMAND_GET_INFO_INFO));
}
return LWDP_OK;
}
