//-------------------------------------------------------------------------------------
int TelnetServer::handleInputNotification(int fd)
{
KBE_ASSERT(listener_ == fd);
int tickcount = 0;
while(tickcount ++ < 1024)
{
Mercury::EndPoint* pNewEndPoint = listener_.accept();
if(pNewEndPoint == NULL){
if(tickcount == 1)
{
WARNING_MSG(fmt::format("TelnetServer::handleInputNotification: accept endpoint({}) {}!\n",
fd, kbe_strerror()));
}
break;
}
else
{
TelnetHandler* pTelnetHandler = new TelnetHandler(pNewEndPoint, this, pNetworkInterface_, passwd_.size() > 0 ?
TelnetHandler::TELNET_STATE_PASSWD : (TelnetHandler::TELNET_STATE)this->deflayer());
if(!pDispatcher_->registerFileDescriptor((*pNewEndPoint), pTelnetHandler))
{
ERROR_MSG(fmt::format("TelnetServer::start:: registerFileDescriptor(pTelnetHandler) is failed! addr={}\n",
pNewEndPoint->c_str()));
delete pTelnetHandler;
continue;
}
INFO_MSG(fmt::format("TelnetServer::handleInputNotification: new handler({})!\n",
pNewEndPoint->c_str()));
handlers_[(*pNewEndPoint)].reset(pTelnetHandler);
std::string s;
if(passwd_.size() > 0)
{
s = "password:";
}
else
{
s = pTelnetHandler->getWelcome();
}
pNewEndPoint->send(s.c_str(), s.size());
}
}
return 0;
}
//-------------------------------------------------------------------------------------
Mercury::Channel* ClientObjectBase::initBaseappChannel()
{
Mercury::EndPoint* pEndpoint = new Mercury::EndPoint();
pEndpoint->socket(SOCK_STREAM);
if (!pEndpoint->good())
{
ERROR_MSG("ClientObjectBase::initBaseappChannel: couldn't create a socket\n");
delete pEndpoint;
return false;
}
u_int32_t address;
pEndpoint->convertAddress(ip_.c_str(), address);
if(pEndpoint->connect(htons(port_), address) == -1)
{
ERROR_MSG(boost::format("ClientObjectBase::initBaseappChannel: connect server is error(%1%)!\n") %
kbe_strerror());
delete pEndpoint;
return NULL;
}
Mercury::Address addr(ip_.c_str(), port_);
pEndpoint->addr(addr);
pServerChannel_->endpoint(pEndpoint);
pEndpoint->setnonblocking(true);
pEndpoint->setnodelay(true);
connectedGateway_ = true;
return pServerChannel_;
}
//-------------------------------------------------------------------------------------
Mercury::Channel* ClientObjectBase::initLoginappChannel(std::string accountName, std::string passwd, std::string ip, KBEngine::uint32 port)
{
Mercury::EndPoint* pEndpoint = new Mercury::EndPoint();
pEndpoint->socket(SOCK_STREAM);
if (!pEndpoint->good())
{
ERROR_MSG("ClientObjectBase::initLoginappChannel: couldn't create a socket\n");
delete pEndpoint;
return NULL;
}
u_int32_t address;
pEndpoint->convertAddress(ip.c_str(), address);
if(pEndpoint->connect(htons(port), address) == -1)
{
ERROR_MSG(boost::format("ClientObjectBase::initLoginappChannel: connect server is error(%1%)!\n") %
kbe_strerror());
delete pEndpoint;
return NULL;
}
Mercury::Address addr(ip.c_str(), port);
pEndpoint->addr(addr);
pServerChannel_->endpoint(pEndpoint);
pEndpoint->setnonblocking(true);
pEndpoint->setnodelay(true);
password_ = passwd;
name_ = accountName;
return pServerChannel_;
}
//-------------------------------------------------------------------------------------
bool ClientObject::initCreate()
{
Mercury::EndPoint* pEndpoint = new Mercury::EndPoint();
pEndpoint->socket(SOCK_STREAM);
if (!pEndpoint->good())
{
ERROR_MSG("ClientObject::initNetwork: couldn't create a socket\n");
delete pEndpoint;
error_ = C_ERROR_INIT_NETWORK_FAILED;
return false;
}
ENGINE_COMPONENT_INFO& infos = g_kbeSrvConfig.getBots();
u_int32_t address;
pEndpoint->convertAddress(infos.login_ip, address);
if(pEndpoint->connect(htons(infos.login_port), address) == -1)
{
ERROR_MSG(boost::format("ClientObject::initNetwork(%2%): connect server(%3%:%4%) is error(%1%)!\n") %
kbe_strerror() % name_ % infos.login_ip % infos.login_port);
delete pEndpoint;
// error_ = C_ERROR_INIT_NETWORK_FAILED;
state_ = C_STATE_INIT;
return false;
}
Mercury::Address addr(infos.login_ip, infos.login_port);
pEndpoint->addr(addr);
pServerChannel_->endpoint(pEndpoint);
pEndpoint->setnonblocking(true);
pEndpoint->setnodelay(true);
pServerChannel_->pMsgHandlers(&ClientInterface::messageHandlers);
Bots::getSingleton().pEventPoller()->registerForRead((*pEndpoint), this);
Mercury::Bundle* pBundle = Mercury::Bundle::ObjPool().createObject();
(*pBundle).newMessage(LoginappInterface::hello);
(*pBundle) << KBEVersion::versionString() << KBEVersion::scriptVersionString();
if(Mercury::g_channelExternalEncryptType == 1)
{
pBlowfishFilter_ = new Mercury::BlowfishFilter();
(*pBundle).appendBlob(pBlowfishFilter_->key());
}
else
{
std::string key = "";
(*pBundle).appendBlob(key);
}
pServerChannel_->pushBundle(pBundle);
this->pEndpoint_ = pEndpoint;
return true;
}
//-------------------------------------------------------------------------------------
bool ClientObject::initLoginGateWay()
{
Bots::getSingleton().pEventPoller()->deregisterForRead(*pServerChannel_->endpoint());
Mercury::EndPoint* pEndpoint = new Mercury::EndPoint();
pEndpoint->socket(SOCK_STREAM);
if (!pEndpoint->good())
{
ERROR_MSG("ClientObject::initLogin: couldn't create a socket\n");
delete pEndpoint;
error_ = C_ERROR_INIT_NETWORK_FAILED;
return false;
}
u_int32_t address;
pEndpoint->convertAddress(ip_.c_str(), address);
if(pEndpoint->connect(htons(port_), address) == -1)
{
ERROR_MSG(boost::format("ClientObject::initLogin(%2%): connect server is error(%1%)!\n") %
kbe_strerror() % name_);
delete pEndpoint;
// error_ = C_ERROR_INIT_NETWORK_FAILED;
state_ = C_STATE_LOGIN_GATEWAY_CREATE;
return false;
}
Mercury::Address addr(ip_.c_str(), port_);
pEndpoint->addr(addr);
pServerChannel_->endpoint(pEndpoint);
pEndpoint->setnonblocking(true);
pEndpoint->setnodelay(true);
Bots::getSingleton().pEventPoller()->registerForRead((*pEndpoint), this);
connectedGateway_ = true;
Mercury::Bundle* pBundle = Mercury::Bundle::ObjPool().createObject();
(*pBundle).newMessage(BaseappInterface::hello);
(*pBundle) << KBEVersion::versionString() << KBEVersion::scriptVersionString();
if(Mercury::g_channelExternalEncryptType == 1)
{
pBlowfishFilter_ = new Mercury::BlowfishFilter();
(*pBundle).appendBlob(pBlowfishFilter_->key());
pServerChannel_->pFilter(NULL);
}
else
{
std::string key = "";
(*pBundle).appendBlob(key);
}
pServerChannel_->pushBundle(pBundle);
return true;
}
//-------------------------------------------------------------------------------------
void Machine::onFindInterfaceAddr(Mercury::Channel* pChannel, int32 uid, std::string& username, int8 componentType,
int8 findComponentType, uint32 finderAddr, uint16 finderRecvPort)
{
INFO_MSG("Machine::onFindInterfaceAddr: uid:%d, username:%s, componentType:%s, "
"find:%s, finderaddr:%s, finderRecvPort:%u.\n",
uid, username.c_str(), COMPONENT_NAME_EX((COMPONENT_TYPE)componentType), COMPONENT_NAME_EX((COMPONENT_TYPE)findComponentType),
inet_ntoa((struct in_addr&)finderAddr), ntohs(finderRecvPort));
Mercury::EndPoint ep;
ep.socket(SOCK_DGRAM);
if (!ep.good())
{
ERROR_MSG("Machine::onFindInterfaceAddr: Failed to create socket.\n");
return;
}
const Components::ComponentInfos* pinfos =
Componentbridge::getComponents().findComponent((KBEngine::COMPONENT_TYPE)findComponentType, uid, 0);
Mercury::Bundle bundle;
if(pinfos == NULL)
{
WARNING_MSG("Machine::onFindInterfaceAddr: %s not found %s.\n", COMPONENT_NAME_EX((COMPONENT_TYPE)componentType),
COMPONENT_NAME_EX((COMPONENT_TYPE)findComponentType));
MachineInterface::onBroadcastInterfaceArgs8::staticAddToBundle(bundle, 0,
"", UNKNOWN_COMPONENT_TYPE, 0, 0, 0, 0, 0);
}
else
MachineInterface::onBroadcastInterfaceArgs8::staticAddToBundle(bundle, pinfos->uid,
pinfos->username, findComponentType, pinfos->cid, pinfos->pIntAddr->ip, pinfos->pIntAddr->port,
pinfos->pExtAddr->ip, pinfos->pExtAddr->port);
if(finderAddr != 0 && finderRecvPort != 0)
bundle.sendto(ep, finderRecvPort, finderAddr);
else
bundle.send(this->getNetworkInterface(), pChannel);
}
//-------------------------------------------------------------------------------------
bool ClientObject::initCreate()
{
Mercury::EndPoint* pEndpoint = new Mercury::EndPoint();
pEndpoint->socket(SOCK_STREAM);
if (!pEndpoint->good())
{
ERROR_MSG("ClientObject::initNetwork: couldn't create a socket\n");
delete pEndpoint;
error_ = C_ERROR_INIT_NETWORK_FAILED;
return false;
}
ENGINE_COMPONENT_INFO& infos = g_kbeSrvConfig.getBots();
u_int32_t address;
pEndpoint->convertAddress(infos.login_ip, address);
if(pEndpoint->connect(htons(infos.login_port), address) == -1)
{
ERROR_MSG(boost::format("ClientObject::initNetwork: connect server is error(%1%)!\n") %
kbe_strerror());
delete pEndpoint;
error_ = C_ERROR_INIT_NETWORK_FAILED;
return false;
}
Mercury::Address addr(infos.login_ip, infos.login_port);
pEndpoint->addr(addr);
pChannel_->endpoint(pEndpoint);
pEndpoint->setnonblocking(true);
pEndpoint->setnodelay(true);
pChannel_->pMsgHandlers(&ClientInterface::messageHandlers);
Bots::getSingleton().pEventPoller()->registerForRead((*pEndpoint), this);
return true;
}
//-------------------------------------------------------------------------------------
bool ClientObject::initLoginGateWay()
{
Bots::getSingleton().pEventPoller()->deregisterForRead(*pChannel_->endpoint());
Mercury::EndPoint* pEndpoint = new Mercury::EndPoint();
pEndpoint->socket(SOCK_STREAM);
if (!pEndpoint->good())
{
ERROR_MSG("ClientObject::initLogin: couldn't create a socket\n");
delete pEndpoint;
error_ = C_ERROR_INIT_NETWORK_FAILED;
return false;
}
u_int32_t address;
pEndpoint->convertAddress(ip_.c_str(), address);
if(pEndpoint->connect(htons(port_), address) == -1)
{
ERROR_MSG(boost::format("ClientObject::initLogin: connect server is error(%1%)!\n") %
kbe_strerror());
delete pEndpoint;
error_ = C_ERROR_INIT_NETWORK_FAILED;
return false;
}
Mercury::Address addr(ip_.c_str(), port_);
pEndpoint->addr(addr);
pChannel_->endpoint(pEndpoint);
pEndpoint->setnonblocking(true);
pEndpoint->setnodelay(true);
Bots::getSingleton().pEventPoller()->registerForRead((*pEndpoint), this);
connectedGateway_ = true;
return true;
}
//-------------------------------------------------------------------------------------
bool Components::checkComponentUsable(const Components::ComponentInfos* info)
{
Mercury::EndPoint epListen;
epListen.socket(SOCK_STREAM);
if (!epListen.good())
{
ERROR_MSG("Components::checkComponentUsable: couldn't create a socket\n");
return true;
}
int trycount = 0;
while(true)
{
if(epListen.connect(info->pIntAddr->port, info->pIntAddr->ip) == -1)
{
KBEngine::sleep(30);
trycount++;
if(trycount > 3)
{
ERROR_MSG("Components::checkComponentUsable: couldn't connect to:%s\n", info->pIntAddr->c_str());
return false;
}
}
break;
}
Mercury::Bundle* pBundle = Mercury::Bundle::ObjPool().createObject();
COMMON_MERCURY_MESSAGE(info->componentType, (*pBundle), lookApp);
epListen.send(pBundle->pCurrPacket()->data(), pBundle->pCurrPacket()->wpos());
Mercury::Bundle::ObjPool().reclaimObject(pBundle);
epListen.setnodelay(true);
epListen.setnonblocking(true);
fd_set fds;
struct timeval tv = { 0, 100000 }; // 100ms
FD_ZERO( &fds );
FD_SET((int)epListen, &fds);
int selgot = select(epListen+1, &fds, NULL, NULL, &tv);
if(selgot == 0)
{
return true; // 超时可能对方繁忙
}
else if(selgot == -1)
{
return true;
}
else
{
COMPONENT_TYPE ctype;
COMPONENT_ID cid;
Mercury::TCPPacket packet;
packet.resize(255);
int recvsize = sizeof(ctype) + sizeof(cid);
int len = epListen.recv(packet.data(), recvsize);
packet.wpos(len);
if(recvsize != len)
{
ERROR_MSG("Components::checkComponentUsable: packet invalid.\n");
return true;
}
packet >> ctype >> cid;
if(ctype != info->componentType || cid != info->cid)
{
ERROR_MSG("Components::checkComponentUsable: invalid component.\n");
return false;
}
}
return true;
}
//-------------------------------------------------------------------------------------
int Components::connectComponent(COMPONENT_TYPE componentType, int32 uid, COMPONENT_ID componentID)
{
Components::ComponentInfos* pComponentInfos = findComponent(componentType, uid, componentID);
KBE_ASSERT(pComponentInfos != NULL);
Mercury::EndPoint * pEndpoint = new Mercury::EndPoint;
pEndpoint->socket(SOCK_STREAM);
if (!pEndpoint->good())
{
ERROR_MSG("Components::connectComponent: couldn't create a socket\n");
delete pEndpoint;
return -1;
}
pEndpoint->addr(*pComponentInfos->pIntAddr);
int ret = pEndpoint->connect(pComponentInfos->pIntAddr->port, pComponentInfos->pIntAddr->ip);
if(ret == 0)
{
pComponentInfos->pChannel = new Mercury::Channel(*_pNetworkInterface, pEndpoint, Mercury::Channel::INTERNAL);
if(!_pNetworkInterface->registerChannel(pComponentInfos->pChannel))
{
ERROR_MSG("Components::connectComponent: registerChannel(%s) is failed!\n",
pComponentInfos->pChannel->c_str());
delete pComponentInfos->pChannel;
pComponentInfos->pChannel = NULL;
return -1;
}
else
{
Mercury::Bundle bundle(pComponentInfos->pChannel);
if(componentType == BASEAPPMGR_TYPE)
{
bundle.newMessage(BaseappmgrInterface::onRegisterNewApp);
BaseappmgrInterface::onRegisterNewAppArgs8::staticAddToBundle(bundle, getUserUID(), getUsername(),
Componentbridge::getSingleton().componentType(), Componentbridge::getSingleton().componentID(),
_pNetworkInterface->intaddr().ip, _pNetworkInterface->intaddr().port,
_pNetworkInterface->extaddr().ip, _pNetworkInterface->extaddr().port);
}
else if(componentType == CELLAPPMGR_TYPE)
{
bundle.newMessage(CellappmgrInterface::onRegisterNewApp);
CellappmgrInterface::onRegisterNewAppArgs8::staticAddToBundle(bundle, getUserUID(), getUsername(),
Componentbridge::getSingleton().componentType(), Componentbridge::getSingleton().componentID(),
_pNetworkInterface->intaddr().ip, _pNetworkInterface->intaddr().port,
_pNetworkInterface->extaddr().ip, _pNetworkInterface->extaddr().port);
}
else if(componentType == CELLAPP_TYPE)
{
bundle.newMessage(CellappInterface::onRegisterNewApp);
CellappInterface::onRegisterNewAppArgs8::staticAddToBundle(bundle, getUserUID(), getUsername(),
Componentbridge::getSingleton().componentType(), Componentbridge::getSingleton().componentID(),
_pNetworkInterface->intaddr().ip, _pNetworkInterface->intaddr().port,
_pNetworkInterface->extaddr().ip, _pNetworkInterface->extaddr().port);
}
else if(componentType == BASEAPP_TYPE)
{
bundle.newMessage(BaseappInterface::onRegisterNewApp);
BaseappInterface::onRegisterNewAppArgs8::staticAddToBundle(bundle, getUserUID(), getUsername(),
Componentbridge::getSingleton().componentType(), Componentbridge::getSingleton().componentID(),
_pNetworkInterface->intaddr().ip, _pNetworkInterface->intaddr().port,
_pNetworkInterface->extaddr().ip, _pNetworkInterface->extaddr().port);
}
else if(componentType == DBMGR_TYPE)
{
bundle.newMessage(DbmgrInterface::onRegisterNewApp);
DbmgrInterface::onRegisterNewAppArgs8::staticAddToBundle(bundle, getUserUID(), getUsername(),
Componentbridge::getSingleton().componentType(), Componentbridge::getSingleton().componentID(),
_pNetworkInterface->intaddr().ip, _pNetworkInterface->intaddr().port,
_pNetworkInterface->extaddr().ip, _pNetworkInterface->extaddr().port);
}
else if(componentType == MESSAGELOG_TYPE)
{
bundle.newMessage(MessagelogInterface::onRegisterNewApp);
MessagelogInterface::onRegisterNewAppArgs8::staticAddToBundle(bundle, getUserUID(), getUsername(),
Componentbridge::getSingleton().componentType(), Componentbridge::getSingleton().componentID(),
_pNetworkInterface->intaddr().ip, _pNetworkInterface->intaddr().port,
_pNetworkInterface->extaddr().ip, _pNetworkInterface->extaddr().port);
}
else if(componentType == RESOURCEMGR_TYPE)
{
bundle.newMessage(ResourcemgrInterface::onRegisterNewApp);
ResourcemgrInterface::onRegisterNewAppArgs8::staticAddToBundle(bundle, getUserUID(), getUsername(),
Componentbridge::getSingleton().componentType(), Componentbridge::getSingleton().componentID(),
_pNetworkInterface->intaddr().ip, _pNetworkInterface->intaddr().port,
_pNetworkInterface->extaddr().ip, _pNetworkInterface->extaddr().port);
}
else
{
KBE_ASSERT(false && "invalid componentType.\n");
}
bundle.send(*_pNetworkInterface, pComponentInfos->pChannel);
}
}
else
{
ERROR_MSG("Components::connectComponent: connect(%s) is failed! %s.\n",
pComponentInfos->pIntAddr->c_str(), kbe_strerror());
return -1;
}
return ret;
}
//-------------------------------------------------------------------------------------
void Machine::stopserver(Mercury::Channel* pChannel, KBEngine::MemoryStream& s)
{
int32 uid = 0;
COMPONENT_TYPE componentType;
uint32 recvip;
uint16 recvport;
Mercury::Bundle bundle;
bool success = true;
s >> uid;
s >> componentType;
s >> recvip;
s >> recvport;
Mercury::EndPoint ep;
ep.socket(SOCK_DGRAM);
if (!ep.good())
{
ERROR_MSG("Machine::stopserver: Failed to create socket.\n");
return;
}
Components::COMPONENTS& components = Componentbridge::getComponents().getComponents(componentType);
Components::COMPONENTS::iterator iter = components.begin();
Components::ComponentInfos* cinfos = NULL;
for(; iter != components.end(); )
{
if((*iter).uid != uid)
continue;
if(componentType != (*iter).componentType)
{
continue;
}
bool usable = Componentbridge::getComponents().checkComponentUsable(&(*iter));
if(!usable)
{
success = true;
break;
}
cinfos = &(*iter);
Mercury::Bundle closebundle;
COMMON_MERCURY_MESSAGE(componentType, closebundle, reqCloseServer);
Mercury::EndPoint ep1;
ep1.socket(SOCK_STREAM);
if (!ep1.good())
{
ERROR_MSG("Machine::stopserver: Failed to create socket.\n");
success = false;
break;
}
if(ep1.connect((*iter).pIntAddr.get()->port, (*iter).pIntAddr.get()->ip) == -1)
{
ERROR_MSG("Machine::stopserver: connect server is error(%s)!\n", kbe_strerror());
success = false;
break;
}
closebundle.send(ep1);
Mercury::TCPPacket recvpacket;
recvpacket.resize(255);
int len = ep1.recv(recvpacket.data(), 1);
if(len != 1)
{
success = false;
break;
}
recvpacket >> success;
break;
}
bundle << success;
bundle.sendto(ep, recvport, recvip);
}
//-------------------------------------------------------------------------------------
void Machine::startserver(Mercury::Channel* pChannel, KBEngine::MemoryStream& s)
{
int32 uid = 0;
COMPONENT_TYPE componentType;
uint32 recvip;
uint16 recvport;
Mercury::Bundle bundle;
bool success = true;
s >> uid;
s >> componentType;
s >> recvip;
s >> recvport;
INFO_MSG("Machine::startserver: uid=%d, [%s], addr:%s, recvPort:%u.\n", uid, COMPONENT_NAME[componentType],
inet_ntoa((struct in_addr&)recvip), ntohs(recvport));
Mercury::EndPoint ep;
ep.socket(SOCK_DGRAM);
if (!ep.good())
{
ERROR_MSG("Machine::startserver: Failed to create socket.\n");
return;
}
#if KBE_PLATFORM == PLATFORM_WIN32
STARTUPINFO si;
PROCESS_INFORMATION pi;
std::string str = Resmgr::getEnv().hybrid_path;
str += COMPONENT_NAME[componentType];
str += ".exe";
wchar_t* szCmdline = KBEngine::char2wchar(str.c_str());
wchar_t* currdir = KBEngine::char2wchar(Resmgr::getEnv().hybrid_path.c_str());
ZeroMemory( &si, sizeof(si));
si.cb = sizeof(si);
ZeroMemory( &pi, sizeof(pi));
if(!CreateProcess( NULL, // No module name (use command line)
szCmdline, // Command line
NULL, // Process handle not inheritable
NULL, // Thread handle not inheritable
FALSE, // Set handle inheritance to FALSE
CREATE_NEW_CONSOLE, // No creation flags
NULL, // Use parent's environment block
currdir, // Use parent's starting directory
&si, // Pointer to STARTUPINFO structure
&pi ) // Pointer to PROCESS_INFORMATION structure
)
{
ERROR_MSG( "Machine::startserver:CreateProcess failed (%d).\n", GetLastError());
success = false;
}
free(szCmdline);
free(currdir);
#else
#endif
bundle << success;
bundle.sendto(ep, recvport, recvip);
}
//-------------------------------------------------------------------------------------
bool CreateAccountTask::process()
{
if(!enable)
{
return false;
}
// 如果没有设置第三方服务地址则我们默认为成功
if(strlen(serviceAddr()) == 0)
{
success = true;
getDatas = postDatas;
return false;
}
Mercury::EndPoint endpoint;
endpoint.socket(SOCK_STREAM);
if (!endpoint.good())
{
ERROR_MSG("BillingTask::process: couldn't create a socket\n");
return false;
}
if(postDatas.size() == 0)
{
ERROR_MSG(boost::format("BillingTask::process: %1% postData is NULL.\n") % commitName);
return false;
}
u_int32_t addr;
KBEngine::Mercury::EndPoint::convertAddress(serviceAddr(), addr);
if(endpoint.connect(htons(servicePort()), addr) == -1)
{
ERROR_MSG(boost::format("BillingTask::process: connect billingserver(%1%:%2%) is error(%3%)!\n") %
serviceAddr() % servicePort() % kbe_strerror());
endpoint.close();
return false;
}
endpoint.setnonblocking(true);
endpoint.setnodelay(true);
Mercury::Bundle::SmartPoolObjectPtr bundle = Mercury::Bundle::createSmartPoolObj();
(*(*bundle)).append(postDatas.data(), postDatas.size());
(*(*bundle)).send(endpoint);
Mercury::TCPPacket packet;
packet.resize(1024);
fd_set frds;
struct timeval tv = { 0, 5000000 }; // 5000ms
FD_ZERO( &frds );
FD_SET((int)endpoint, &frds);
int selgot = select(endpoint+1, &frds, NULL, NULL, &tv);
if(selgot <= 0)
{
ERROR_MSG(boost::format("BillingTask::process: %1% send(%2%).\n") % commitName % postDatas);
ERROR_MSG(boost::format("BillingTask::process: %1% recv is error(%2%).\n") % commitName % KBEngine::kbe_strerror());
endpoint.close();
return false;
}
int len = endpoint.recv(packet.data(), 1024);
if(len <= 0)
{
ERROR_MSG(boost::format("BillingTask::process: %1% recv is size<= 0.\n===>postdatas=%2%\n") % commitName % postDatas);
endpoint.close();
return false;
}
packet.wpos(len);
getDatas.assign((const char *)(packet.data() + packet.rpos()), packet.opsize());
try
{
std::string::size_type fi = getDatas.find("\r\n\r\n");
if(fi != std::string::npos)
{
fi += 4;
MemoryStream s;
s.append(getDatas.data() + fi, getDatas.size() - fi);
while(s.opsize() > 0)
{
int32 type, len;
s >> type >> len;
EndianConvertReverse<int32>(type);
EndianConvertReverse<int32>(len);
int32 error = 0;
switch(type)
{
case 1:
s >> error;
EndianConvertReverse<int32>(error);
if(error != 0)
{
success = false;
endpoint.close();
std::string err;
if(s.opsize() >= (sizeof(int32) * 2))
{
s >> type >> len;
if(len > 0 && len < 1024)
{
char* buf = new char[len + 1];
memcpy(buf, s.data() + s.rpos(), len);
buf[len] = 0;
err = buf;
delete[] buf;
}
}
DEBUG_MSG(boost::format("BillingTask::process: (%1%)op is failed! err=%2%\n<==send(%3%)\n==>recv(%4%).\n") % commitName % err % postDatas % getDatas);
return false;
}
else
{
success = true;
}
break;
case 2:
{
s.read_skip(len);
}
break;
case 3:
{
char* buf = new char[len + 1];
memcpy(buf, s.data() + s.rpos(), len);
buf[len] = 0;
accountName = buf;
delete[] buf;
s.read_skip(len);
}
break;
default:
break;
};
//-------------------------------------------------------------------------------------
bool Components::checkComponentUsable(const Components::ComponentInfos* info)
{
// 不对其他machine做处理
if(info->componentType == MACHINE_TYPE)
{
return true;
}
bool islocal = _pNetworkInterface->intaddr().ip == info->pIntAddr->ip ||
_pNetworkInterface->extaddr().ip == info->pIntAddr->ip;
// 如果是本机应用则判断是否还在运行中
if(islocal && info->pid > 0)
{
SystemInfo::PROCESS_INFOS sysinfos = SystemInfo::getSingleton().getProcessInfo(info->pid);
if(sysinfos.error)
{
WARNING_MSG(boost::format("Components::checkComponentUsable: not found pid(%1%)\n") % info->pid);
//return false;
}
else
{
Components::ComponentInfos* winfo = findComponent(info->cid);
if(winfo)
{
winfo->cpu = sysinfos.cpu;
winfo->usedmem = (uint32)sysinfos.memused;
winfo->mem = float((winfo->usedmem * 1.0 / SystemInfo::getSingleton().totalmem()) * 100.0);
}
}
}
Mercury::EndPoint epListen;
epListen.socket(SOCK_STREAM);
if (!epListen.good())
{
ERROR_MSG("Components::checkComponentUsable: couldn't create a socket\n");
return true;
}
epListen.setnonblocking(true);
while(true)
{
fd_set frds, fwds;
struct timeval tv = { 0, 300000 }; // 100ms
FD_ZERO( &frds );
FD_ZERO( &fwds );
FD_SET((int)epListen, &frds);
FD_SET((int)epListen, &fwds);
if(epListen.connect(info->pIntAddr->port, info->pIntAddr->ip) == -1)
{
int selgot = select(epListen+1, &frds, &fwds, NULL, &tv);
if(selgot > 0)
{
break;
}
ERROR_MSG(boost::format("Components::checkComponentUsable: couldn't connect to:%1%\n") % info->pIntAddr->c_str());
return false;
}
}
epListen.setnodelay(true);
Mercury::Bundle* pBundle = Mercury::Bundle::ObjPool().createObject();
// 由于COMMON_MERCURY_MESSAGE不包含client， 如果是bots， 我们需要单独处理
if(info->componentType != BOTS_TYPE)
{
COMMON_MERCURY_MESSAGE(info->componentType, (*pBundle), lookApp);
}
else
{
(*pBundle).newMessage(BotsInterface::lookApp);
}
epListen.send(pBundle->pCurrPacket()->data(), pBundle->pCurrPacket()->wpos());
Mercury::Bundle::ObjPool().reclaimObject(pBundle);
fd_set fds;
struct timeval tv = { 0, 300000 }; // 100ms
FD_ZERO( &fds );
FD_SET((int)epListen, &fds);
int selgot = select(epListen+1, &fds, NULL, NULL, &tv);
if(selgot == 0)
{
return true; // 超时可能对方繁忙
}
else if(selgot == -1)
{
return true;
}
else
{
COMPONENT_TYPE ctype;
COMPONENT_ID cid;
int8 istate = 0;
ArraySize entitySize = 0, cellSize = 0;
int32 clientsSize = 0, proxicesSize = 0;
uint32 telnet_port = 0;
Mercury::TCPPacket packet;
packet.resize(255);
int recvsize = sizeof(ctype) + sizeof(cid) + sizeof(istate);
if(info->componentType == CELLAPP_TYPE)
{
recvsize += sizeof(entitySize) + sizeof(cellSize) + sizeof(telnet_port);
}
if(info->componentType == BASEAPP_TYPE)
{
recvsize += sizeof(entitySize) + sizeof(clientsSize) + sizeof(proxicesSize) + sizeof(telnet_port);
}
int len = epListen.recv(packet.data(), recvsize);
packet.wpos(len);
if(recvsize != len)
{
ERROR_MSG(boost::format("Components::checkComponentUsable: packet invalid(recvsize(%1%) != ctype_cid_len(%2%).\n")
% len % recvsize);
if(len == 0)
return false;
return true;
}
packet >> ctype >> cid >> istate;
if(ctype == CELLAPP_TYPE)
{
packet >> entitySize >> cellSize >> telnet_port;
}
if(ctype == BASEAPP_TYPE)
{
packet >> entitySize >> clientsSize >> proxicesSize >> telnet_port;
}
//-------------------------------------------------------------------------------------
int Components::connectComponent(COMPONENT_TYPE componentType, int32 uid, COMPONENT_ID componentID)
{
Components::ComponentInfos* pComponentInfos = findComponent(componentType, uid, componentID);
KBE_ASSERT(pComponentInfos != NULL);
Mercury::EndPoint * pEndpoint = new Mercury::EndPoint;
pEndpoint->socket(SOCK_STREAM);
if (!pEndpoint->good())
{
ERROR_MSG("Components::connectComponent: couldn't create a socket\n");
delete pEndpoint;
return -1;
}
pEndpoint->addr(*pComponentInfos->pIntAddr);
int ret = pEndpoint->connect(pComponentInfos->pIntAddr->port, pComponentInfos->pIntAddr->ip);
if(ret == 0)
{
pComponentInfos->pChannel = new Mercury::Channel(*_pNetworkInterface, pEndpoint, Mercury::Channel::INTERNAL);
pComponentInfos->pChannel->componentID(componentID);
if(!_pNetworkInterface->registerChannel(pComponentInfos->pChannel))
{
ERROR_MSG(boost::format("Components::connectComponent: registerChannel(%1%) is failed!\n") %
pComponentInfos->pChannel->c_str());
pComponentInfos->pChannel->destroy();
pComponentInfos->pChannel = NULL;
return -1;
}
else
{
Mercury::Bundle* pBundle = Mercury::Bundle::ObjPool().createObject();
if(componentType == BASEAPPMGR_TYPE)
{
(*pBundle).newMessage(BaseappmgrInterface::onRegisterNewApp);
BaseappmgrInterface::onRegisterNewAppArgs11::staticAddToBundle((*pBundle), getUserUID(), getUsername(),
Componentbridge::getSingleton().componentType(), Componentbridge::getSingleton().componentID(),
g_componentGlobalOrder, g_componentGroupOrder,
_pNetworkInterface->intaddr().ip, _pNetworkInterface->intaddr().port,
_pNetworkInterface->extaddr().ip, _pNetworkInterface->extaddr().port, g_kbeSrvConfig.getConfig().externalAddress);
}
else if(componentType == CELLAPPMGR_TYPE)
{
(*pBundle).newMessage(CellappmgrInterface::onRegisterNewApp);
CellappmgrInterface::onRegisterNewAppArgs11::staticAddToBundle((*pBundle), getUserUID(), getUsername(),
Componentbridge::getSingleton().componentType(), Componentbridge::getSingleton().componentID(),
g_componentGlobalOrder, g_componentGroupOrder,
_pNetworkInterface->intaddr().ip, _pNetworkInterface->intaddr().port,
_pNetworkInterface->extaddr().ip, _pNetworkInterface->extaddr().port, g_kbeSrvConfig.getConfig().externalAddress);
}
else if(componentType == CELLAPP_TYPE)
{
(*pBundle).newMessage(CellappInterface::onRegisterNewApp);
CellappInterface::onRegisterNewAppArgs11::staticAddToBundle((*pBundle), getUserUID(), getUsername(),
Componentbridge::getSingleton().componentType(), Componentbridge::getSingleton().componentID(),
g_componentGlobalOrder, g_componentGroupOrder,
_pNetworkInterface->intaddr().ip, _pNetworkInterface->intaddr().port,
_pNetworkInterface->extaddr().ip, _pNetworkInterface->extaddr().port, g_kbeSrvConfig.getConfig().externalAddress);
}
else if(componentType == BASEAPP_TYPE)
{
(*pBundle).newMessage(BaseappInterface::onRegisterNewApp);
BaseappInterface::onRegisterNewAppArgs11::staticAddToBundle((*pBundle), getUserUID(), getUsername(),
Componentbridge::getSingleton().componentType(), Componentbridge::getSingleton().componentID(),
g_componentGlobalOrder, g_componentGroupOrder,
_pNetworkInterface->intaddr().ip, _pNetworkInterface->intaddr().port,
_pNetworkInterface->extaddr().ip, _pNetworkInterface->extaddr().port, g_kbeSrvConfig.getConfig().externalAddress);
}
else if(componentType == DBMGR_TYPE)
{
(*pBundle).newMessage(DbmgrInterface::onRegisterNewApp);
DbmgrInterface::onRegisterNewAppArgs11::staticAddToBundle((*pBundle), getUserUID(), getUsername(),
Componentbridge::getSingleton().componentType(), Componentbridge::getSingleton().componentID(),
g_componentGlobalOrder, g_componentGroupOrder,
_pNetworkInterface->intaddr().ip, _pNetworkInterface->intaddr().port,
_pNetworkInterface->extaddr().ip, _pNetworkInterface->extaddr().port, g_kbeSrvConfig.getConfig().externalAddress);
}
else if(componentType == MESSAGELOG_TYPE)
{
(*pBundle).newMessage(MessagelogInterface::onRegisterNewApp);
MessagelogInterface::onRegisterNewAppArgs11::staticAddToBundle((*pBundle), getUserUID(), getUsername(),
Componentbridge::getSingleton().componentType(), Componentbridge::getSingleton().componentID(),
g_componentGlobalOrder, g_componentGroupOrder,
_pNetworkInterface->intaddr().ip, _pNetworkInterface->intaddr().port,
_pNetworkInterface->extaddr().ip, _pNetworkInterface->extaddr().port, g_kbeSrvConfig.getConfig().externalAddress);
}
else
{
KBE_ASSERT(false && "invalid componentType.\n");
}
(*pBundle).send(*_pNetworkInterface, pComponentInfos->pChannel);
Mercury::Bundle::ObjPool().reclaimObject(pBundle);
}
}
else
{
ERROR_MSG(boost::format("Components::connectComponent: connect(%1%) is failed! %2%.\n") %
pComponentInfos->pIntAddr->c_str() % kbe_strerror());
return -1;
}
return ret;
}
