//-------------------------------------------------------------------------------------
bool ForwardAnywhere_MessageBuffer::process()
{
if(pBundles_.size() <= 0)
{
start_ = false;
return false;
}
Components::COMPONENTS cts = Components::getSingleton().getComponents(forwardComponentType_);
size_t idx = 0;
if(cts.size() > 0)
{
// 必须所有的组件频道都被设置， 如果不是则等待。
Components::COMPONENTS::iterator ctiter = cts.begin();
for(; ctiter != cts.end(); ctiter++)
{
if((*ctiter).pChannel == NULL)
return true;
}
std::vector<ForwardItem*>::iterator iter = pBundles_.begin();
for(; iter != pBundles_.end(); iter++)
{
(*iter)->pBundle->send(networkInterface_, cts[idx].pChannel);
Mercury::Bundle::ObjPool().reclaimObject((*iter)->pBundle);
(*iter)->pBundle = NULL;
idx++;
if(idx >= cts.size())
idx = 0;
if((*iter)->pHandler != NULL)
{
(*iter)->pHandler->process();
SAFE_RELEASE((*iter)->pHandler);
}
SAFE_RELEASE((*iter));
}
DEBUG_MSG(boost::format("ForwardAnywhere_MessageBuffer::process(): size:%1%.\n") % pBundles_.size());
pBundles_.clear();
start_ = false;
return false;
}
return true;
}
//-------------------------------------------------------------------------------------
void EntityIDClient::onAlloc(void)
{
if(hasReqServerAlloc() || getSize() > ID_ENOUGH_LIMIT || idList_.size() > 0)
return;
Mercury::Bundle bundle;
bundle.newMessage(DbmgrInterface::onReqAllocEntityID);
DbmgrInterface::onReqAllocEntityIDArgs2::staticAddToBundle(bundle, pApp_->componentType(), pApp_->componentID());
Components::COMPONENTS cts = Components::getSingleton().getComponents(DBMGR_TYPE);
KBE_ASSERT(cts.size() > 0);
Components::ComponentInfos* cinfos = &(*cts.begin());
KBE_ASSERT(cinfos->pChannel != NULL);
bundle.send(pApp_->getNetworkInterface(), cinfos->pChannel);
ERROR_MSG("EntityIDClient::onAlloc: not enough(%d) entityIDs!\n", ID_ENOUGH_LIMIT);
}
//-------------------------------------------------------------------------------------
void Baseapp::onGetEntityAppFromDbmgr(Mercury::Channel* pChannel, int32 uid, std::string& username,
int8 componentType, uint64 componentID,
uint32 intaddr, uint16 intport, uint32 extaddr, uint16 extport)
{
if(pChannel->isExternal())
return;
EntityApp<Base>::onRegisterNewApp(pChannel, uid, username, componentType, componentID,
intaddr, intport, extaddr, extport);
KBEngine::COMPONENT_TYPE tcomponentType = (KBEngine::COMPONENT_TYPE)componentType;
Components::COMPONENTS cts = Componentbridge::getComponents().getComponents(DBMGR_TYPE);
KBE_ASSERT(cts.size() >= 1);
Components::ComponentInfos* cinfos = Componentbridge::getComponents().findComponent(tcomponentType, uid, componentID);
cinfos->pChannel = NULL;
int ret = Components::getSingleton().connectComponent(tcomponentType, uid, componentID);
KBE_ASSERT(ret != -1);
Mercury::Bundle bundle;
switch(tcomponentType)
{
case BASEAPP_TYPE:
bundle.newMessage(BaseappInterface::onRegisterNewApp);
BaseappInterface::onRegisterNewAppArgs8::staticAddToBundle(bundle, getUserUID(), getUsername(), BASEAPP_TYPE, componentID_,
this->getNetworkInterface().intaddr().ip, this->getNetworkInterface().intaddr().port,
this->getNetworkInterface().extaddr().ip, this->getNetworkInterface().extaddr().port);
break;
case CELLAPP_TYPE:
bundle.newMessage(CellappInterface::onRegisterNewApp);
CellappInterface::onRegisterNewAppArgs8::staticAddToBundle(bundle, getUserUID(), getUsername(), BASEAPP_TYPE, componentID_,
this->getNetworkInterface().intaddr().ip, this->getNetworkInterface().intaddr().port,
this->getNetworkInterface().extaddr().ip, this->getNetworkInterface().extaddr().port);
break;
default:
KBE_ASSERT(false && "no support!\n");
break;
};
bundle.send(this->getNetworkInterface(), cinfos->pChannel);
}
//-------------------------------------------------------------------------------------
void Base::onCellWriteToDBCompleted()
{
PyObject* pyResult = PyObject_CallMethod(this,
const_cast<char*>("onPreArchive"), const_cast<char*>(""));
if(pyResult != NULL)
Py_DECREF(pyResult);
else
PyErr_PrintEx(0);
hasDB(true);
onWriteToDB();
isArchiveing_ = false;
MemoryStream* s = MemoryStream::ObjPool().createObject();
addPersistentsDataToStream(ED_FLAG_ALL, s);
Components::COMPONENTS cts = Components::getSingleton().getComponents(DBMGR_TYPE);
Components::ComponentInfos* dbmgrinfos = NULL;
if(cts.size() > 0)
dbmgrinfos = &(*cts.begin());
if(dbmgrinfos == NULL || dbmgrinfos->pChannel == NULL || dbmgrinfos->cid == 0)
{
ERROR_MSG("Base::onCellWriteToDBCompleted: not found dbmgr!\n");
return;
}
Mercury::Bundle bundle;
bundle.newMessage(DbmgrInterface::writeEntity);
bundle << this->getID();
bundle << this->getScriptModule()->getUType();
bundle.append(*s);
bundle.send(Baseapp::getSingleton().getNetworkInterface(), dbmgrinfos->pChannel);
MemoryStream::ObjPool().reclaimObject(s);
}
//-------------------------------------------------------------------------------------
void Cellapp::executeRawDatabaseCommand(const char* datas, uint32 size, PyObject* pycallback)
{
if(datas == NULL)
{
ERROR_MSG("Cellapp::executeRawDatabaseCommand: execute is error!\n");
return;
}
Components::COMPONENTS cts = Components::getSingleton().getComponents(DBMGR_TYPE);
Components::ComponentInfos* dbmgrinfos = NULL;
if(cts.size() > 0)
dbmgrinfos = &(*cts.begin());
if(dbmgrinfos == NULL || dbmgrinfos->pChannel == NULL || dbmgrinfos->cid == 0)
{
ERROR_MSG("Cellapp::executeRawDatabaseCommand: not found dbmgr!\n");
return;
}
DEBUG_MSG(boost::format("KBEngine::executeRawDatabaseCommand:%1%.\n") % datas);
Mercury::Bundle* pBundle = Mercury::Bundle::ObjPool().createObject();
(*pBundle).newMessage(DbmgrInterface::executeRawDatabaseCommand);
(*pBundle) << componentID_ << componentType_;
CALLBACK_ID callbackID = 0;
if(pycallback && PyCallable_Check(pycallback))
callbackID = callbackMgr().save(pycallback);
(*pBundle) << callbackID;
(*pBundle) << size;
(*pBundle).append(datas, size);
(*pBundle).send(this->getNetworkInterface(), dbmgrinfos->pChannel);
Mercury::Bundle::ObjPool().reclaimObject(pBundle);
}
//-------------------------------------------------------------------------------------
void Dbmgr::onRegisterNewApp(Mercury::Channel* pChannel, int32 uid, std::string& username,
int8 componentType, uint64 componentID,
uint32 intaddr, uint16 intport, uint32 extaddr, uint16 extport)
{
ServerApp::onRegisterNewApp(pChannel, uid, username, componentType, componentID,
intaddr, intport, extaddr, extport);
KBEngine::COMPONENT_TYPE tcomponentType = (KBEngine::COMPONENT_TYPE)componentType;
// 下一步:
// 如果是连接到dbmgr则需要等待接收app初始信息
// 例如：初始会分配entityID段以及这个app启动的顺序信息（是否第一个baseapp启动）
if(tcomponentType == BASEAPP_TYPE ||
tcomponentType == CELLAPP_TYPE ||
tcomponentType == LOGINAPP_TYPE)
{
Mercury::Bundle* pBundle = Mercury::Bundle::ObjPool().createObject();
int32 startGlobalOrder = Componentbridge::getComponents().getGlobalOrderLog()[getUserUID()];
int32 startGroupOrder = 0;
switch(tcomponentType)
{
case BASEAPP_TYPE:
{
startGroupOrder = Componentbridge::getComponents().getBaseappGroupOrderLog()[getUserUID()];
onGlobalDataClientLogon(pChannel, BASEAPP_TYPE);
std::pair<ENTITY_ID, ENTITY_ID> idRange = idServer_.allocRange();
(*pBundle).newMessage(BaseappInterface::onDbmgrInitCompleted);
BaseappInterface::onDbmgrInitCompletedArgs5::staticAddToBundle((*pBundle), g_kbetime, idRange.first,
idRange.second, startGlobalOrder, startGroupOrder);
}
break;
case CELLAPP_TYPE:
{
startGroupOrder = Componentbridge::getComponents().getCellappGroupOrderLog()[getUserUID()];
onGlobalDataClientLogon(pChannel, CELLAPP_TYPE);
std::pair<ENTITY_ID, ENTITY_ID> idRange = idServer_.allocRange();
(*pBundle).newMessage(CellappInterface::onDbmgrInitCompleted);
CellappInterface::onDbmgrInitCompletedArgs5::staticAddToBundle((*pBundle), g_kbetime, idRange.first,
idRange.second, startGlobalOrder, startGroupOrder);
}
break;
case LOGINAPP_TYPE:
startGroupOrder = Componentbridge::getComponents().getLoginappGroupOrderLog()[getUserUID()];
(*pBundle).newMessage(LoginappInterface::onDbmgrInitCompleted);
LoginappInterface::onDbmgrInitCompletedArgs2::staticAddToBundle((*pBundle),
startGlobalOrder, startGroupOrder);
break;
default:
break;
}
(*pBundle).send(networkInterface_, pChannel);
Mercury::Bundle::ObjPool().reclaimObject(pBundle);
}
// 如果是baseapp或者cellapp则将自己注册到所有其他baseapp和cellapp
if(tcomponentType == BASEAPP_TYPE ||
tcomponentType == CELLAPP_TYPE)
{
KBEngine::COMPONENT_TYPE broadcastCpTypes[2] = {BASEAPP_TYPE, CELLAPP_TYPE};
for(int idx = 0; idx < 2; idx++)
{
Components::COMPONENTS cts = Components::getSingleton().getComponents(broadcastCpTypes[idx]);
Components::COMPONENTS::iterator fiter = cts.begin();
for(; fiter != cts.end(); fiter++)
{
if((*fiter).cid == componentID)
continue;
Mercury::Bundle* pBundle = Mercury::Bundle::ObjPool().createObject();
ENTITTAPP_COMMON_MERCURY_MESSAGE(broadcastCpTypes[idx], (*pBundle), onGetEntityAppFromDbmgr);
if(tcomponentType == BASEAPP_TYPE)
{
BaseappInterface::onGetEntityAppFromDbmgrArgs8::staticAddToBundle((*pBundle),
uid, username, componentType, componentID,
intaddr, intport, extaddr, extport);
}
else
{
CellappInterface::onGetEntityAppFromDbmgrArgs8::staticAddToBundle((*pBundle),
uid, username, componentType, componentID,
intaddr, intport, extaddr, extport);
}
KBE_ASSERT((*fiter).pChannel != NULL);
(*pBundle).send(networkInterface_, (*fiter).pChannel);
Mercury::Bundle::ObjPool().reclaimObject(pBundle);
}
}
}
}
