//-------------------------------------------------------------------------------------
void Entity::onLeaveTrapID(ENTITY_ID entityID, float range, int controllerID)
{
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
SCRIPT_OBJECT_CALL_ARGS3(this, const_cast<char*>("onLeaveTrapID"),
const_cast<char*>("kfi"), entityID, range, controllerID);
}
//-------------------------------------------------------------------------------------
bool Loginapp::initializeEnd()
{
PythonApp::initializeEnd();
// 添加一个timer， 每秒检查一些状态
mainProcessTimer_ = this->dispatcher().addTimer(1000000 / 50, this,
reinterpret_cast<void *>(TIMEOUT_TICK));
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
// 所有脚本都加载完毕
PyObject* pyResult = PyObject_CallMethod(getEntryScript().get(),
const_cast<char*>("onLoginAppReady"),
const_cast<char*>(""));
if(pyResult != NULL)
Py_DECREF(pyResult);
else
SCRIPT_ERROR_CHECK();
pTelnetServer_ = new TelnetServer(&this->dispatcher(), &this->networkInterface());
pTelnetServer_->pScript(&this->getScript());
bool ret = pTelnetServer_->start(g_kbeSrvConfig.getLoginApp().telnet_passwd,
g_kbeSrvConfig.getLoginApp().telnet_deflayer,
g_kbeSrvConfig.getLoginApp().telnet_port);
Components::getSingleton().extraData4(pTelnetServer_->port());
return ret;
}
//-------------------------------------------------------------------------------------
void Proxy::onStreamComplete(int16 id, bool success)
{
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
SCRIPT_OBJECT_CALL_ARGS2(this, const_cast<char*>("onStreamComplete"),
const_cast<char*>("hO"), id, success ? Py_True : Py_False);
}
//-------------------------------------------------------------------------------------
void Entity::onTeleportSuccess(PyObject* nearbyEntity, SPACE_ID lastSpaceID)
{
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
SCRIPT_OBJECT_CALL_ARGS1(this, const_cast<char*>("onTeleportSuccess"),
const_cast<char*>("O"), nearbyEntity);
}
//-------------------------------------------------------------------------------------
void Entity::onLeaveTrap(Entity* entity, float range, int controllerID)
{
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
SCRIPT_OBJECT_CALL_ARGS3(this, const_cast<char*>("onLeaveTrap"),
const_cast<char*>("Ofi"), entity, range, controllerID);
}
//-------------------------------------------------------------------------------------
bool Interfaces::initializeEnd()
{
PythonApp::initializeEnd();
mainProcessTimer_ = this->dispatcher().addTimer(1000000 / g_kbeSrvConfig.gameUpdateHertz(), this,
reinterpret_cast<void *>(TIMEOUT_TICK));
// 不做频道超时检查
CLOSE_CHANNEL_INACTIVITIY_DETECTION();
if (!initDB())
return false;
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
// 所有脚本都加载完毕
PyObject* pyResult = PyObject_CallMethod(getEntryScript().get(),
const_cast<char*>("onInterfaceAppReady"),
const_cast<char*>(""));
if(pyResult != NULL)
Py_DECREF(pyResult);
else
SCRIPT_ERROR_CHECK();
pTelnetServer_ = new TelnetServer(&this->dispatcher(), &this->networkInterface());
pTelnetServer_->pScript(&this->getScript());
bool ret = pTelnetServer_->start(g_kbeSrvConfig.getInterfaces().telnet_passwd,
g_kbeSrvConfig.getInterfaces().telnet_deflayer,
g_kbeSrvConfig.getInterfaces().telnet_port);
Components::getSingleton().extraData4(pTelnetServer_->port());
return ret;
}
//-------------------------------------------------------------------------------------
std::string Dbmgr::selectAccountDBInterfaceName(const std::string& name)
{
std::string dbInterfaceName = "default";
// 把请求交由脚本处理
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
PyObject* pyResult = PyObject_CallMethod(getEntryScript().get(),
const_cast<char*>("onSelectAccountDBInterface"),
const_cast<char*>("s"),
name.c_str());
if (pyResult != NULL)
{
wchar_t* PyUnicode_AsWideCharStringRet0 = PyUnicode_AsWideCharString(pyResult, NULL);
char* ccattr = strutil::wchar2char(PyUnicode_AsWideCharStringRet0);
dbInterfaceName = ccattr;
PyMem_Free(PyUnicode_AsWideCharStringRet0);
Py_DECREF(pyResult);
free(ccattr);
}
else
{
SCRIPT_ERROR_CHECK();
}
if (dbInterfaceName == "" || g_kbeSrvConfig.dbInterface(dbInterfaceName) == NULL)
{
ERROR_MSG(fmt::format("Dbmgr::selectAccountDBInterfaceName: not found dbInterface({}), accountName={}.\n", dbInterfaceName, name));
return "default";
}
return dbInterfaceName;
}
//-------------------------------------------------------------------------------------
void Entity::onWriteToDB()
{
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
DEBUG_MSG(boost::format("%1%::onWriteToDB(): %2%.\n") %
this->getScriptName() % this->getID());
SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onWriteToDB"));
}
//-------------------------------------------------------------------------------------
void Proxy::onClientGetCell(Network::Channel* pChannel, COMPONENT_ID componentID)
{
// 回调给脚本，获得了cell
if(cellMailbox_ == NULL)
cellMailbox_ = new EntityMailbox(pScriptModule_, NULL, componentID, id_, MAILBOX_TYPE_CELL);
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onClientGetCell"));
}
//-------------------------------------------------------------------------------------
void Dbmgr::onShutdownBegin()
{
PythonApp::onShutdownBegin();
// 通知脚本
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
SCRIPT_OBJECT_CALL_ARGS0(getEntryScript().get(), const_cast<char*>("onDBMgrShutDown"));
scriptTimers_.cancelAll();
}
//-------------------------------------------------------------------------------------
void Loginapp::onReqCreateAccountResult(Network::Channel* pChannel, MemoryStream& s)
{
SERVER_ERROR_CODE failedcode;
std::string accountName;
std::string password;
std::string retdatas = "";
s >> failedcode >> accountName >> password;
s.readBlob(retdatas);
// 把请求交由脚本处理
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
PyObject* pyResult = PyObject_CallMethod(getEntryScript().get(),
const_cast<char*>("onCreateAccountCallbackFromDB"),
const_cast<char*>("sHy#"),
accountName.c_str(),
failedcode,
retdatas.c_str(), retdatas.length());
if(pyResult != NULL)
{
Py_DECREF(pyResult);
}
else
{
SCRIPT_ERROR_CHECK();
}
DEBUG_MSG(fmt::format("Loginapp::onReqCreateAccountResult: accountName={}, failedcode={}.\n",
accountName.c_str(), failedcode));
PendingLoginMgr::PLInfos* ptinfos = pendingCreateMgr_.remove(accountName);
if(ptinfos == NULL)
return;
Network::Channel* pClientChannel = this->networkInterface().findChannel(ptinfos->addr);
if(pClientChannel == NULL)
return;
pClientChannel->extra("");
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
(*pBundle) << failedcode;
(*pBundle).appendBlob(retdatas);
pClientChannel->send(pBundle);
SAFE_RELEASE(ptinfos);
}
//-------------------------------------------------------------------------------------
void Base::onDestroy(bool callScript)
{
if(callScript)
{
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onDestroy"));
}
if(this->hasDB())
{
onCellWriteToDBCompleted(0, -1);
}
eraseEntityLog();
}
//-------------------------------------------------------------------------------------
void Entity::onRemoteMethodCall(Mercury::Channel* pChannel, MemoryStream& s)
{
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
if(isDestroyed())
{
ERROR_MSG(boost::format("%1%::onRemoteMethodCall: %2% is destroyed!\n") %
getScriptName() % getID());
s.read_skip(s.opsize());
return;
}
ENTITY_METHOD_UID utype = 0;
s >> utype;
DEBUG_MSG(boost::format("Entity::onRemoteMethodCall: entityID %1%, methodType %2%.\n") %
id_ % utype);
MethodDescription* md = scriptModule_->findCellMethodDescription(utype);
if(md == NULL)
{
ERROR_MSG(boost::format("Entity::onRemoteMethodCall: can't found method. utype=%1%, callerID:%2%.\n") % utype % id_);
return;
}
md->currCallerID(this->getID());
PyObject* pyFunc = PyObject_GetAttrString(this, const_cast<char*>
(md->getName()));
if(md != NULL)
{
PyObject* pyargs = md->createFromStream(&s);
if(pyargs)
{
md->call(pyFunc, pyargs);
Py_XDECREF(pyargs);
}
else
{
SCRIPT_ERROR_CHECK();
}
}
Py_XDECREF(pyFunc);
}
//-------------------------------------------------------------------------------------
void Entity::onLoseWitness(Mercury::Channel* pChannel)
{
KBE_ASSERT(this->getClientMailbox() != NULL && this->hasWitness());
getClientMailbox()->addr(Mercury::Address::NONE);
Py_DECREF(getClientMailbox());
setClientMailbox(NULL);
pWitness_->detach(this);
Witness::ObjPool().reclaimObject(pWitness_);
pWitness_ = NULL;
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onLoseWitness"));
}
//-------------------------------------------------------------------------------------
void Interfaces::reqCreateAccount(Network::Channel* pChannel, KBEngine::MemoryStream& s)
{
std::string registerName, accountName, password, datas;
COMPONENT_ID cid;
uint8 accountType = 0;
s >> cid >> registerName >> password >> accountType;
s.readBlob(datas);
if(accountType == (uint8)ACCOUNT_TYPE_MAIL)
{
}
REQCREATE_MAP::iterator iter = reqCreateAccount_requests_.find(registerName);
if(iter != reqCreateAccount_requests_.end())
{
return;
}
CreateAccountTask* pinfo = new CreateAccountTask();
pinfo->commitName = registerName;
pinfo->accountName = registerName;
pinfo->getDatas = "";
pinfo->password = password;
pinfo->postDatas = datas;
pinfo->retcode = SERVER_ERR_OP_FAILED;
pinfo->baseappID = cid;
pinfo->dbmgrID = pChannel->componentID();
pinfo->address = pChannel->addr();
pinfo->enable = true;
reqCreateAccount_requests_[pinfo->commitName] = pinfo;
// 把请求交由脚本处理
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
PyObject* pyResult = PyObject_CallMethod(getEntryScript().get(),
const_cast<char*>("onRequestCreateAccount"),
const_cast<char*>("ssy#"),
registerName.c_str(),
password.c_str(),
datas.c_str(), datas.length());
if(pyResult != NULL)
Py_DECREF(pyResult);
else
SCRIPT_ERROR_CHECK();
}
//-------------------------------------------------------------------------------------
void Interfaces::charge(Network::Channel* pChannel, KBEngine::MemoryStream& s)
{
OrdersCharge* pOrdersCharge = new OrdersCharge();
pOrdersCharge->timeout = timestamp() + uint64(g_kbeSrvConfig.interfaces_orders_timeout_ * stampsPerSecond());
pOrdersCharge->dbmgrID = pChannel->componentID();
pOrdersCharge->address = pChannel->addr();
s >> pOrdersCharge->baseappID;
s >> pOrdersCharge->ordersID;
s >> pOrdersCharge->dbid;
s.readBlob(pOrdersCharge->postDatas);
s >> pOrdersCharge->cbid;
INFO_MSG(fmt::format("Interfaces::charge: componentID={4}, chargeID={0}, dbid={1}, cbid={2}, datas={3}!\n",
pOrdersCharge->ordersID, pOrdersCharge->dbid, pOrdersCharge->cbid, pOrdersCharge->postDatas, pOrdersCharge->baseappID));
ORDERS::iterator iter = orders_.find(pOrdersCharge->ordersID);
if(iter != orders_.end())
{
ERROR_MSG(fmt::format("Interfaces::charge: chargeID={} is exist!\n", pOrdersCharge->ordersID));
delete pOrdersCharge;
return;
}
ChargeTask* pinfo = new ChargeTask();
pinfo->orders = *pOrdersCharge;
pinfo->pOrders = pOrdersCharge;
orders_[pOrdersCharge->ordersID].reset(pOrdersCharge);
// 把请求交由脚本处理
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
PyObject* pyResult = PyObject_CallMethod(getEntryScript().get(),
const_cast<char*>("onRequestCharge"),
const_cast<char*>("sKy#"),
pOrdersCharge->ordersID.c_str(),
pOrdersCharge->dbid,
pOrdersCharge->postDatas.c_str(), pOrdersCharge->postDatas.length());
if(pyResult != NULL)
Py_DECREF(pyResult);
else
SCRIPT_ERROR_CHECK();
}
int WINAPI WinMain(HINSTANCE /*hInstance*/, HINSTANCE /*hPrevInstance*/, LPSTR /*lpCmdLine*/, int /*nCmdShow*/ )
{
redirect_io_to_console();
_CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_ERROR, _CRTDBG_FILE_STDERR );
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
//::boost::unit_test::unit_test_main(init_unit_test_suite, 0, 0);
boost::shared_ptr<System> system(new System());
system->init();
boost::shared_ptr<EffectManager> effect_manager(new EffectManager(system->handle_manager()));
// Renderable* renderer = new SpringTest(system, effect_manager);
//Renderable* renderer = new M2Renderer(system, effect_manager);
Renderable *renderer = new MarchingCubes(system, effect_manager);
SCOPED_PROFILE("Loading");
try {
renderer->init();
} catch (std::exception& e) {
LOG_ERROR_LN("%s", e.what());
return 0;
}
Profiler::instance().print();
Serializer::instance().load("codename_ch.dat");
system->run();
system->close();
Serializer::instance().save("codename_ch.dat");
SAFE_DELETE(renderer);
effect_manager.reset();
system.reset();
Profiler::close();
StringIdTable::close();
LogMgr::close();
return 0;
}
//-------------------------------------------------------------------------------------
bool Dbmgr::initializeEnd()
{
// 添加一个timer， 每秒检查一些状态
loopCheckTimerHandle_ = this->dispatcher().addTimer(1000000, this,
reinterpret_cast<void *>(TIMEOUT_CHECK_STATUS));
mainProcessTimer_ = this->dispatcher().addTimer(1000000 / 50, this,
reinterpret_cast<void *>(TIMEOUT_TICK));
// 添加globalData, baseAppData, cellAppData支持
pGlobalData_ = new GlobalDataServer(GlobalDataServer::GLOBAL_DATA);
pBaseAppData_ = new GlobalDataServer(GlobalDataServer::BASEAPP_DATA);
pCellAppData_ = new GlobalDataServer(GlobalDataServer::CELLAPP_DATA);
pGlobalData_->addConcernComponentType(CELLAPP_TYPE);
pGlobalData_->addConcernComponentType(BASEAPP_TYPE);
pBaseAppData_->addConcernComponentType(BASEAPP_TYPE);
pCellAppData_->addConcernComponentType(CELLAPP_TYPE);
INFO_MSG(fmt::format("Dbmgr::initializeEnd: digest({})\n",
EntityDef::md5().getDigestStr()));
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
// 所有脚本都加载完毕
PyObject* pyResult = PyObject_CallMethod(getEntryScript().get(),
const_cast<char*>("onDBMgrReady"),
const_cast<char*>(""));
if(pyResult != NULL)
Py_DECREF(pyResult);
else
SCRIPT_ERROR_CHECK();
pTelnetServer_ = new TelnetServer(&this->dispatcher(), &this->networkInterface());
pTelnetServer_->pScript(&this->getScript());
bool ret = pTelnetServer_->start(g_kbeSrvConfig.getDBMgr().telnet_passwd,
g_kbeSrvConfig.getDBMgr().telnet_deflayer,
g_kbeSrvConfig.getDBMgr().telnet_port);
Components::getSingleton().extraData4(pTelnetServer_->port());
return ret && initInterfacesHandler() && initDB();
}
//-------------------------------------------------------------------------------------
void Interfaces::onAccountLogin(Network::Channel* pChannel, KBEngine::MemoryStream& s)
{
std::string loginName, accountName, password, datas;
COMPONENT_ID cid;
s >> cid >> loginName >> password;
s.readBlob(datas);
REQLOGIN_MAP::iterator iter = reqAccountLogin_requests_.find(loginName);
if(iter != reqAccountLogin_requests_.end())
{
return;
}
LoginAccountTask* pinfo = new LoginAccountTask();
pinfo->commitName = loginName;
pinfo->accountName = loginName;
pinfo->getDatas = "";
pinfo->password = password;
pinfo->postDatas = datas;
pinfo->retcode = SERVER_ERR_OP_FAILED;
pinfo->baseappID = cid;
pinfo->dbmgrID = pChannel->componentID();
pinfo->address = pChannel->addr();
pinfo->enable = true;
reqAccountLogin_requests_[pinfo->commitName] = pinfo;
// 把请求交由脚本处理
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
PyObject* pyResult = PyObject_CallMethod(getEntryScript().get(),
const_cast<char*>("onRequestAccountLogin"),
const_cast<char*>("ssy#"),
loginName.c_str(),
password.c_str(),
datas.c_str(), datas.length());
if(pyResult != NULL)
Py_DECREF(pyResult);
else
SCRIPT_ERROR_CHECK();
}
//-------------------------------------------------------------------------------------
void Witness::update()
{
SCOPED_PROFILE(CLIENT_UPDATE_PROFILE);
if(pEntity_ == NULL)
return;
if(!pEntity_->getClientMailbox())
return;
Mercury::Channel* pChannel = pEntity_->getClientMailbox()->getChannel();
if(!pChannel)
return;
{
// 如果数据大量阻塞发不出去将会报警
AUTO_SCOPED_PROFILE("updateClientSend");
pChannel->send();
}
}
//-------------------------------------------------------------------------------------
void Proxy::onClientDeath(void)
{
if(getClientMailbox() == NULL)
{
ERROR_MSG(boost::format("%1%::onClientDeath: %2%, channel is null!\n") %
this->getScriptName() % this->getID());
return;
}
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
DEBUG_MSG(boost::format("%1%::onClientDeath: %2%.\n") %
this->getScriptName() % this->getID());
Py_DECREF(getClientMailbox());
setClientMailbox(NULL);
addr(Mercury::Address::NONE);
entitiesEnabled_ = false;
SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onClientDeath"));
}
//-------------------------------------------------------------------------------------
void Proxy::onClientDeath(void)
{
if(clientMailbox() == NULL)
{
ERROR_MSG(fmt::format("{}::onClientDeath: {}, channel is null!\n",
this->scriptName(), this->id()));
return;
}
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
DEBUG_MSG(fmt::format("{}::onClientDeath: {}.\n",
this->scriptName(), this->id()));
Py_DECREF(clientMailbox());
clientMailbox(NULL);
addr(Network::Address::NONE);
entitiesEnabled_ = false;
SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onClientDeath"));
}
//-------------------------------------------------------------------------------------
void Base::onDestroy(bool callScript)
{
setDirty();
if(callScript)
{
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onDestroy"));
}
if(this->hasDB())
{
onCellWriteToDBCompleted(0, -1, -1);
}
eraseEntityLog();
// 按照当前的设计来说，有clientMailbox_必定是proxy
// 至于为何跑到base里来和python本身是C语言实现有关
if(clientMailbox_)
static_cast<Proxy*>(this)->kick();
}
//-------------------------------------------------------------------------------------
void Entity::onGetWitness(Mercury::Channel* pChannel)
{
KBE_ASSERT(this->getBaseMailbox() != NULL && !this->hasWitness());
PyObject* clientMailbox = PyObject_GetAttrString(this->getBaseMailbox(), "client");
KBE_ASSERT(clientMailbox != Py_None);
EntityMailbox* client = static_cast<EntityMailbox*>(clientMailbox);
// Py_INCREF(clientMailbox); 这里不需要增加引用， 因为每次都会产生一个新的对象
setClientMailbox(client);
pWitness_ = Witness::ObjPool().createObject();
pWitness_->attach(this);
Space* space = Spaces::findSpace(this->getSpaceID());
if(space)
{
space->onEntityAttachWitness(this);
}
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onGetWitness"));
}
//-------------------------------------------------------------------------------------
int32 Proxy::onLogOnAttempt(const char* addr, uint32 port, const char* password)
{
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
PyObject* pyResult = PyObject_CallMethod(this,
const_cast<char*>("onLogOnAttempt"), const_cast<char*>("sks"),
addr,
port,
password
);
int32 ret = LOG_ON_REJECT;
if(pyResult != NULL)
{
ret = PyLong_AsLong(pyResult);
SCRIPT_ERROR_CHECK();
Py_DECREF(pyResult);
}
else
SCRIPT_ERROR_CHECK();
return ret;
}
//-------------------------------------------------------------------------------------
void Entity::onDestroy(void)
{
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onDestroy"));
if(baseMailbox_ != NULL)
{
this->backupCellData();
Mercury::Bundle* pBundle = Mercury::Bundle::ObjPool().createObject();
(*pBundle).newMessage(BaseappInterface::onLoseCell);
(*pBundle) << id_;
baseMailbox_->postMail((*pBundle));
Mercury::Bundle::ObjPool().reclaimObject(pBundle);
}
// 将entity从场景中剔除
Space* space = Spaces::findSpace(this->getSpaceID());
if(space)
{
space->removeEntity(this);
}
}
//-------------------------------------------------------------------------------------
void Proxy::onGiveClientToFailure()
{
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onGiveClientToFailure"));
}
//-------------------------------------------------------------------------------------
bool Loginapp::_createAccount(Network::Channel* pChannel, std::string& accountName,
std::string& password, std::string& datas, ACCOUNT_TYPE type)
{
AUTO_SCOPED_PROFILE("createAccount");
ACCOUNT_TYPE oldType = type;
if(!g_kbeSrvConfig.getDBMgr().account_registration_enable)
{
WARNING_MSG(fmt::format("Loginapp::_createAccount({}): not available!\n", accountName));
std::string retdatas = "";
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
SERVER_ERROR_CODE retcode = SERVER_ERR_ACCOUNT_REGISTER_NOT_AVAILABLE;
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
accountName = KBEngine::strutil::kbe_trim(accountName);
password = KBEngine::strutil::kbe_trim(password);
if(accountName.size() > ACCOUNT_NAME_MAX_LENGTH)
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: accountName too big, size={}, limit={}.\n",
accountName.size(), ACCOUNT_NAME_MAX_LENGTH));
return false;
}
if(password.size() > ACCOUNT_PASSWD_MAX_LENGTH)
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: password too big, size={}, limit={}.\n",
password.size(), ACCOUNT_PASSWD_MAX_LENGTH));
return false;
}
if(datas.size() > ACCOUNT_DATA_MAX_LENGTH)
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: bindatas too big, size={}, limit={}.\n",
datas.size(), ACCOUNT_DATA_MAX_LENGTH));
return false;
}
std::string retdatas = "";
if(shuttingdown_ != SHUTDOWN_STATE_STOP)
{
WARNING_MSG(fmt::format("Loginapp::_createAccount: shutting down, create {} failed!\n", accountName));
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
SERVER_ERROR_CODE retcode = SERVER_ERR_IN_SHUTTINGDOWN;
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
PendingLoginMgr::PLInfos* ptinfos = pendingCreateMgr_.find(const_cast<std::string&>(accountName));
if(ptinfos != NULL)
{
WARNING_MSG(fmt::format("Loginapp::_createAccount: pendingCreateMgr has {}, request create failed!\n",
accountName));
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
SERVER_ERROR_CODE retcode = SERVER_ERR_BUSY;
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
{
// 把请求交由脚本处理
SERVER_ERROR_CODE retcode = SERVER_SUCCESS;
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
PyObject* pyResult = PyObject_CallMethod(getEntryScript().get(),
const_cast<char*>("onRequestCreateAccount"),
const_cast<char*>("ssy#"),
accountName.c_str(),
password.c_str(),
datas.c_str(), datas.length());
if(pyResult != NULL)
{
if(PySequence_Check(pyResult) && PySequence_Size(pyResult) == 4)
{
char* sname;
char* spassword;
char *extraDatas;
Py_ssize_t extraDatas_size = 0;
if(PyArg_ParseTuple(pyResult, "H|s|s|y#", &retcode, &sname, &spassword, &extraDatas, &extraDatas_size) == -1)
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: {}.onReuqestLogin, Return value error! accountName={}\n",
g_kbeSrvConfig.getLoginApp().entryScriptFile, accountName));
retcode = SERVER_ERR_OP_FAILED;
}
else
{
accountName = sname;
password = spassword;
if (extraDatas && extraDatas_size > 0)
datas.assign(extraDatas, extraDatas_size);
else
SCRIPT_ERROR_CHECK();
}
}
else
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: {}.onReuqestLogin, Return value error, must be errorcode or tuple! accountName={}\n",
g_kbeSrvConfig.getLoginApp().entryScriptFile, accountName));
retcode = SERVER_ERR_OP_FAILED;
}
Py_DECREF(pyResult);
}
else
{
SCRIPT_ERROR_CHECK();
retcode = SERVER_ERR_OP_FAILED;
}
if(retcode != SERVER_SUCCESS)
{
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
else
{
if(accountName.size() == 0)
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: accountName is empty!\n"));
retcode = SERVER_ERR_NAME;
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
}
}
if(type == ACCOUNT_TYPE_SMART)
{
if (email_isvalid(accountName.c_str()))
{
type = ACCOUNT_TYPE_MAIL;
}
else
{
if(!validName(accountName))
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: invalid accountName({})\n",
accountName));
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
SERVER_ERROR_CODE retcode = SERVER_ERR_NAME;
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
type = ACCOUNT_TYPE_NORMAL;
}
}
else if(type == ACCOUNT_TYPE_NORMAL)
{
if(!validName(accountName))
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: invalid accountName({})\n",
accountName));
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
SERVER_ERROR_CODE retcode = SERVER_ERR_NAME;
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
}
else if (!email_isvalid(accountName.c_str()))
{
/*
std::string user_name, domain_name;
user_name = regex_replace(accountName, _g_mail_pattern, std::string("$1") );
domain_name = regex_replace(accountName, _g_mail_pattern, std::string("$2") );
*/
WARNING_MSG(fmt::format("Loginapp::_createAccount: invalid mail={}\n",
accountName));
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
SERVER_ERROR_CODE retcode = SERVER_ERR_NAME_MAIL;
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
DEBUG_MSG(fmt::format("Loginapp::_createAccount: accountName={}, passwordsize={}, type={}, oldType={}.\n",
accountName.c_str(), password.size(), type, oldType));
ptinfos = new PendingLoginMgr::PLInfos;
ptinfos->accountName = accountName;
ptinfos->password = password;
ptinfos->datas = datas;
ptinfos->addr = pChannel->addr();
pendingCreateMgr_.add(ptinfos);
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(fmt::format("Loginapp::_createAccount: create({}), not found dbmgr!\n",
accountName));
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
SERVER_ERROR_CODE retcode = SERVER_ERR_SRV_NO_READY;
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
pChannel->extra(accountName);
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(DbmgrInterface::reqCreateAccount);
uint8 uatype = uint8(type);
(*pBundle) << accountName << password << uatype;
(*pBundle).appendBlob(datas);
dbmgrinfos->pChannel->send(pBundle);
return true;
}
//-------------------------------------------------------------------------------------
void Proxy::onEntitiesEnabled(void)
{
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
entitiesEnabled_ = true;
SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onEntitiesEnabled"));
}
//-------------------------------------------------------------------------------------
void Proxy::onClientGetCell(Mercury::Channel* pChannel)
{
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onClientGetCell"));
}
