//-------------------------------------------------------------------------------------
bool initializePyWatcher(Script* pScript)
{
// Method to register UUID py
APPEND_SCRIPT_MODULE_METHOD(pScript->getModule(), addWatcher, addWatcher, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(pScript->getModule(), delWatcher, delWatcher, METH_VARARGS, 0);
return true;
}
//-------------------------------------------------------------------------------------
bool Cellapp::installPyModules()
{
Entity::installScript(getScript().getModule());
GlobalDataClient::installScript(getScript().getModule());
registerScript(Entity::getScriptType());
// 注册创建entity的方法到py
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), time, __py_gametime, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), createEntity, __py_createEntity, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), executeRawDatabaseCommand, __py_executeRawDatabaseCommand, METH_VARARGS, 0);
return EntityApp<Entity>::installPyModules();
}
//-------------------------------------------------------------------------------------
void Interfaces::onInstallPyModules()
{
PyObject * module = getScript().getModule();
for (int i = 0; i < SERVER_ERR_MAX; i++)
{
if(PyModule_AddIntConstant(module, SERVER_ERR_STR[i], i))
{
ERROR_MSG( fmt::format("Interfaces::onInstallPyModules: Unable to set KBEngine.{}.\n", SERVER_ERR_STR[i]));
}
}
APPEND_SCRIPT_MODULE_METHOD(module, chargeResponse, __py_chargeResponse, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(module, accountLoginResponse, __py_accountLoginResponse, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(module, createAccountResponse, __py_createAccountResponse, METH_VARARGS, 0);
}
//-------------------------------------------------------------------------------------
bool Bots::installPyModules()
{
ClientObject::installScript(NULL);
PyBots::installScript(NULL);
pPyBots_ = new PyBots();
registerPyObjectToScript("bots", pPyBots_);
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), addBots, __py_addBots, METH_VARARGS, 0);
// 注册设置脚本输出类型
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), scriptLogType, __py_setScriptLogType, METH_VARARGS, 0)
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_NORMAL", log4cxx::ScriptLevel::SCRIPT_INT))
{
ERROR_MSG( "Bots::installPyModules: Unable to set KBEngine.LOG_TYPE_NORMAL.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_INFO", log4cxx::ScriptLevel::SCRIPT_INFO))
{
ERROR_MSG( "Bots::installPyModules: Unable to set KBEngine.LOG_TYPE_INFO.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_ERR", log4cxx::ScriptLevel::SCRIPT_ERR))
{
ERROR_MSG( "Bots::installPyModules: Unable to set KBEngine.LOG_TYPE_ERR.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_DBG", log4cxx::ScriptLevel::SCRIPT_DBG))
{
ERROR_MSG( "Bots::installPyModules: Unable to set KBEngine.LOG_TYPE_DBG.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_WAR", log4cxx::ScriptLevel::SCRIPT_WAR))
{
ERROR_MSG( "Bots::installPyModules: Unable to set KBEngine.LOG_TYPE_WAR.\n");
}
registerScript(client::Entity::getScriptType());
// 安装入口模块
PyObject *entryScriptFileName = PyUnicode_FromString(g_kbeSrvConfig.getBots().entryScriptFile);
if(entryScriptFileName != NULL)
{
entryScript_ = PyImport_Import(entryScriptFileName);
SCRIPT_ERROR_CHECK();
S_RELEASE(entryScriptFileName);
if(entryScript_.get() == NULL)
{
return false;
}
}
onInstallPyModules();
return true;
}
//-------------------------------------------------------------------------------------
bool ClientApp::installEntityDef()
{
if(!EntityDef::installScript(getScript().getModule()))
return false;
// 初始化所有扩展模块
// demo/res/scripts/
if(!EntityDef::initialize(scriptBaseTypes_, g_componentType)){
return false;
}
// 注册一些接口到kbengine
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), publish, __py_getAppPublish, METH_VARARGS, 0)
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), fireEvent, __py_fireEvent, METH_VARARGS, 0)
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), player, __py_getPlayer, METH_VARARGS, 0)
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), getSpaceData, __py_GetSpaceData, METH_VARARGS, 0)
return true;
}
//-------------------------------------------------------------------------------------
bool ClientApp::installEntityDef()
{
if(!EntityDef::installScript(getScript().getModule()))
return false;
// 初始化所有扩展模块
// demo/res/scripts/
if(!EntityDef::initialize(Resmgr::getSingleton().respaths()[1] + "res/scripts/", scriptBaseTypes_, g_componentType)){
return false;
}
// 注册创建entity的方法到py
// 向脚本注册app发布状态
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), publish, __py_getAppPublish, METH_VARARGS, 0)
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), fireEvent, __py_fireEvent, METH_VARARGS, 0)
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), player, __py_getPlayer, METH_VARARGS, 0)
return true;
}
//-------------------------------------------------------------------------------------
bool Bots::installPyModules()
{
ClientObject::installScript(NULL);
PyBots::installScript(NULL);
pPyBots_ = new PyBots();
registerPyObjectToScript("bots", pPyBots_);
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), addBots, __py_addBots, METH_VARARGS, 0);
registerScript(client::Entity::getScriptType());
onInstallPyModules();
return true;
}
//-------------------------------------------------------------------------------------
bool Bots::installPyModules()
{
ClientObject::installScript(NULL);
PyBots::installScript(NULL);
pPyBots_ = new PyBots();
registerPyObjectToScript("bots", pPyBots_);
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), addBots, __py_addBots, METH_VARARGS, 0);
// 注册设置脚本输出类型
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), scriptLogType, __py_setScriptLogType, METH_VARARGS, 0)
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_NORMAL", log4cxx::ScriptLevel::SCRIPT_INT))
{
ERROR_MSG( "Bots::installPyModules: Unable to set KBEngine.LOG_TYPE_NORMAL.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_INFO", log4cxx::ScriptLevel::SCRIPT_INFO))
{
ERROR_MSG( "Bots::installPyModules: Unable to set KBEngine.LOG_TYPE_INFO.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_ERR", log4cxx::ScriptLevel::SCRIPT_ERR))
{
ERROR_MSG( "Bots::installPyModules: Unable to set KBEngine.LOG_TYPE_ERR.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_DBG", log4cxx::ScriptLevel::SCRIPT_DBG))
{
ERROR_MSG( "Bots::installPyModules: Unable to set KBEngine.LOG_TYPE_DBG.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_WAR", log4cxx::ScriptLevel::SCRIPT_WAR))
{
ERROR_MSG( "Bots::installPyModules: Unable to set KBEngine.LOG_TYPE_WAR.\n");
}
registerScript(client::Entity::getScriptType());
onInstallPyModules();
return true;
}
//-------------------------------------------------------------------------------------
void Dbmgr::onInstallPyModules()
{
PyObject * module = getScript().getModule();
for (int i = 0; i < SERVER_ERR_MAX; i++)
{
if(PyModule_AddIntConstant(module, SERVER_ERR_STR[i], i))
{
ERROR_MSG( fmt::format("Dbmgr::onInstallPyModules: Unable to set KBEngine.{}.\n", SERVER_ERR_STR[i]));
}
}
APPEND_SCRIPT_MODULE_METHOD(module, addTimer, __py_addTimer, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(module, delTimer, __py_delTimer, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(module, registerReadFileDescriptor, PyFileDescriptor::__py_registerReadFileDescriptor, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(module, registerWriteFileDescriptor, PyFileDescriptor::__py_registerWriteFileDescriptor, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(module, deregisterReadFileDescriptor, PyFileDescriptor::__py_deregisterReadFileDescriptor, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(module, deregisterWriteFileDescriptor, PyFileDescriptor::__py_deregisterWriteFileDescriptor, METH_VARARGS, 0);
}
//-------------------------------------------------------------------------------------
bool Baseapp::installPyModules()
{
Base::installScript(getScript().getModule());
Proxy::installScript(getScript().getModule());
GlobalDataClient::installScript(getScript().getModule());
registerScript(Base::getScriptType());
registerScript(Proxy::getScriptType());
// 注册创建entity的方法到py
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), time, __py_gametime, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), createBase, __py_createBase, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), createBaseLocally, __py_createBase, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), createEntity, __py_createBase, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), createBaseAnywhere, __py_createBaseAnywhere, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), executeRawDatabaseCommand, __py_executeRawDatabaseCommand, METH_VARARGS, 0);
return EntityApp<Base>::installPyModules();
}
//-------------------------------------------------------------------------------------
bool initializePyWatcher(Script* pScript)
{
// 注册产生uuid方法到py
APPEND_SCRIPT_MODULE_METHOD(pScript->getModule(), addWatcher, addWatcher, METH_VARARGS, 0);
return true;
}
//-------------------------------------------------------------------------------------
bool Script::install(const wchar_t* pythonHomeDir, std::wstring pyPaths,
const char* moduleName, COMPONENT_TYPE componentType)
{
std::wstring pySysPaths = SCRIPT_PATH;
wchar_t* pwpySysResPath = strutil::char2wchar(const_cast<char*>(Resmgr::getSingleton().getPySysResPath().c_str()));
strutil::kbe_replace(pySysPaths, L"../../res/", pwpySysResPath);
pyPaths += pySysPaths;
free(pwpySysResPath);
// 先设置python的环境变量
Py_SetPythonHome(const_cast<wchar_t*>(pythonHomeDir));
#if KBE_PLATFORM != PLATFORM_WIN32
std::wstring fs = L";";
std::wstring rs = L":";
size_t pos = 0;
while(true)
{
pos = pyPaths.find(fs, pos);
if (pos == std::wstring::npos) break;
pyPaths.replace(pos, fs.length(), rs);
}
char* tmpchar = strutil::wchar2char(const_cast<wchar_t*>(pyPaths.c_str()));
DEBUG_MSG(fmt::format("Script::install(): paths={}.\n", tmpchar));
free(tmpchar);
#endif
// Initialise python
// Py_VerboseFlag = 2;
Py_FrozenFlag = 1;
// Warn if tab and spaces are mixed in indentation.
// Py_TabcheckFlag = 1;
Py_NoSiteFlag = 1;
Py_IgnoreEnvironmentFlag = 1;
Py_SetPath(pyPaths.c_str());
// python解释器的初始化
Py_Initialize();
if (!Py_IsInitialized())
{
ERROR_MSG("Script::install(): Py_Initialize is failed!\n");
return false;
}
PyObject *m = PyImport_AddModule("__main__");
// 添加一个脚本基础模块
module_ = PyImport_AddModule(moduleName);
if (module_ == NULL)
return false;
const char* componentName = COMPONENT_NAME_EX(componentType);
if (PyModule_AddStringConstant(module_, "component", componentName))
{
ERROR_MSG(fmt::format("Script::install(): Unable to set KBEngine.component to {}\n",
componentName));
return false;
}
// 注册产生uuid方法到py
APPEND_SCRIPT_MODULE_METHOD(module_, genUUID64, __py_genUUID64, METH_VARARGS, 0);
if(!install_py_dlls())
{
ERROR_MSG("Script::install(): install_py_dlls() is failed!\n");
return false;
}
// 安装py重定向模块
ScriptStdOut::installScript(NULL);
ScriptStdErr::installScript(NULL);
/*
static struct PyModuleDef moduleDesc =
{
PyModuleDef_HEAD_INIT,
moduleName,
"This module is created by KBEngine!",
-1,
NULL
};
// 初始化基础模块
PyModule_Create(&moduleDesc);
*/
// 将模块对象加入main
PyObject_SetAttrString(m, moduleName, module_);
PyObject_SetAttrString(module_, "__doc__", PyUnicode_FromString("This module is created by KBEngine!"));
// 重定向python输出
pyStdouterr_ = new ScriptStdOutErr();
// 安装py重定向脚本模块
if(!pyStdouterr_->install()){
ERROR_MSG("Script::install::pyStdouterr_->install() is failed!\n");
delete pyStdouterr_;
SCRIPT_ERROR_CHECK();
return false;
}
PyGC::initialize();
Pickler::initialize();
PyProfile::initialize(this);
PyStruct::initialize();
Copy::initialize();
SCRIPT_ERROR_CHECK();
math::installModule("Math");
INFO_MSG(fmt::format("Script::install(): is successfully, Python=({})!\n", Py_GetVersion()));
return installExtraModule("KBExtra");
}
//-------------------------------------------------------------------------------------
bool ClientApp::installEntityDef()
{
if(!EntityDef::installScript(getScript().getModule()))
return false;
// 初始化所有扩展模块
// assets/scripts/
if(!EntityDef::initialize(scriptBaseTypes_, g_componentType)){
return false;
}
// 注册一些接口到kbengine
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), publish, __py_getAppPublish, METH_VARARGS, 0)
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), fireEvent, __py_fireEvent, METH_VARARGS, 0)
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), player, __py_getPlayer, METH_VARARGS, 0)
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), getSpaceData, __py_GetSpaceData, METH_VARARGS, 0)
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), callback, __py_callback, METH_VARARGS, 0)
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), cancelCallback, __py_cancelCallback, METH_VARARGS, 0)
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), getWatcher, __py_getWatcher, METH_VARARGS, 0)
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), getWatcherDir, __py_getWatcherDir, METH_VARARGS, 0)
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), disconnect, __py_disconnect, METH_VARARGS, 0)
// 获得资源全路径
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), getResFullPath, __py_getResFullPath, METH_VARARGS, 0)
// 是否存在某个资源
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), hasRes, __py_hasRes, METH_VARARGS, 0)
// 打开一个文件
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), open, __py_kbeOpen, METH_VARARGS, 0)
// 列出目录下所有文件
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), listPathRes, __py_listPathRes, METH_VARARGS, 0)
// 匹配相对路径获得全路径
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), matchPath, __py_matchPath, METH_VARARGS, 0)
return true;
}
//-------------------------------------------------------------------------------------
bool Cellapp::installPyModules()
{
Entity::installScript(getScript().getModule());
GlobalDataClient::installScript(getScript().getModule());
registerScript(Entity::getScriptType());
// 注册创建entity的方法到py
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), time, __py_gametime, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), createEntity, __py_createEntity, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), executeRawDatabaseCommand, __py_executeRawDatabaseCommand, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), reloadScript, __py_reloadScript, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), addSpaceGeometryMapping, Space::__py_AddSpaceGeometryMapping,METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), getSpaceGeometryMapping, Space::__py_GetSpaceGeometryMapping,METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), setSpaceData, Space::__py_SetSpaceData, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), getSpaceData, Space::__py_GetSpaceData, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), delSpaceData, Space::__py_DelSpaceData, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), isShuttingDown, __py_isShuttingDown, METH_VARARGS, 0);
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), address, __py_address, METH_VARARGS, 0);
return EntityApp<Entity>::installPyModules();
}
//-------------------------------------------------------------------------------------
bool Script::install(const wchar_t* pythonHomeDir, std::wstring pyPaths,
const char* moduleName, COMPONENT_TYPE componentType)
{
std::wstring pySysPaths = SCRIPT_PATH;
wchar_t* pwpySysResPath = strutil::char2wchar(const_cast<char*>(Resmgr::getSingleton().getPySysResPath().c_str()));
strutil::kbe_replace(pySysPaths, L"../../res/", pwpySysResPath);
pyPaths += pySysPaths;
free(pwpySysResPath);
#if KBE_PLATFORM == PLATFORM_WIN32
Py_SetPythonHome(const_cast<wchar_t*>(pythonHomeDir)); // 先设置python的环境变量
#else
std::wstring fs = L";";
std::wstring rs = L":";
size_t pos = 0;
while(true)
{
pos = pyPaths.find(fs, pos);
if (pos == std::wstring::npos) break;
pyPaths.replace(pos, fs.length(), rs);
}
Py_SetPath(pyPaths.c_str());
char* tmpchar = strutil::wchar2char(const_cast<wchar_t*>(pyPaths.c_str()));
DEBUG_MSG(boost::format("Script::install: paths=%1%.\n") % tmpchar);
free(tmpchar);
#endif
// Initialise python
// Py_VerboseFlag = 2;
Py_FrozenFlag = 1;
// Warn if tab and spaces are mixed in indentation.
// Py_TabcheckFlag = 1;
Py_NoSiteFlag = 1;
Py_IgnoreEnvironmentFlag = 1;
Py_Initialize(); // python解释器的初始化
if (!Py_IsInitialized())
{
ERROR_MSG("Script::install::Py_Initialize is failed!\n");
return false;
}
#if KBE_PLATFORM == PLATFORM_WIN32
PySys_SetPath(pyPaths.c_str());
#endif
PyObject *m = PyImport_AddModule("__main__");
module_ = PyImport_AddModule(moduleName); // 添加一个脚本基础模块
if (module_ == NULL)
return false;
const char* componentName = COMPONENT_NAME_EX(componentType);
if (PyModule_AddStringConstant(module_, "component", componentName))
{
ERROR_MSG(boost::format("Script::init: Unable to set KBEngine.component to %1%\n") %
componentName );
return false;
}
// 注册产生uuid方法到py
APPEND_SCRIPT_MODULE_METHOD(module_, genUUID64, __py_genUUID64, METH_VARARGS, 0);
if(!install_py_dlls())
{
ERROR_MSG("Script::init: install_py_dlls() is failed!\n");
return false;
}
#ifndef KBE_SINGLE_THREADED
s_pOurInitTimeModules = PyDict_Copy( PySys_GetObject( "modules" ) );
s_pMainThreadState = PyThreadState_Get();
s_defaultContext = s_pMainThreadState;
PyEval_InitThreads();
KBEConcurrency::setMainThreadIdleFunctions(
&Script::releaseLock, &Script::acquireLock );
#endif
ScriptStdOutErr::installScript(NULL); // 安装py重定向模块
ScriptStdOutErrHook::installScript(NULL);
static struct PyModuleDef moduleDesc =
{
PyModuleDef_HEAD_INIT,
moduleName,
"This module is created by KBEngine!",
-1,
NULL
};
PyModule_Create(&moduleDesc); // 初始化基础模块
PyObject_SetAttrString(m, moduleName, module_); // 将模块对象加入main
pyStdouterr_ = new ScriptStdOutErr(); // 重定向python输出
pyStdouterrHook_ = new ScriptStdOutErrHook();
if(!pyStdouterr_->install()){ // 安装py重定向脚本模块
ERROR_MSG("Script::install::pyStdouterr_->install() is failed!\n");
SCRIPT_ERROR_CHECK();
return false;
}
Pickler::initialize();
PyProfile::initialize(this);
PyStruct::initialize();
Copy::initialize();
SCRIPT_ERROR_CHECK();
math::installModule("Math");
INFO_MSG("Script::install is successfully!\n");
return installExtraModule("KBExtra");
}
bool EntityApp<E>::installPyModules()
{
Entities<E>::installScript(NULL);
//Entity::installScript(g_script.getModule());
pEntities_ = new Entities<E>();
registerPyObjectToScript("entities", pEntities_);
// 安装入口模块
PyObject *entryScriptFileName = NULL;
if(componentType() == BASEAPP_TYPE)
{
ENGINE_COMPONENT_INFO& info = g_kbeSrvConfig.getBaseApp();
entryScriptFileName = PyUnicode_FromString(info.entryScriptFile);
}
else if(componentType() == CELLAPP_TYPE)
{
ENGINE_COMPONENT_INFO& info = g_kbeSrvConfig.getCellApp();
entryScriptFileName = PyUnicode_FromString(info.entryScriptFile);
}
// 添加pywatcher支持
if(!initializePyWatcher(&this->getScript()))
return false;
// 添加globalData, globalBases支持
pGlobalData_ = new GlobalDataClient(DBMGR_TYPE, GlobalDataServer::GLOBAL_DATA);
registerPyObjectToScript("globalData", pGlobalData_);
// 注册创建entity的方法到py
// 向脚本注册app发布状态
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), publish, __py_getAppPublish, METH_VARARGS, 0);
// 注册设置脚本输出类型
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), scriptLogType, __py_setScriptLogType, METH_VARARGS, 0);
// 获得资源全路径
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), getResFullPath, __py_getResFullPath, METH_VARARGS, 0);
// 是否存在某个资源
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), hasRes, __py_hasRes, METH_VARARGS, 0);
// 打开一个文件
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), open, __py_kbeOpen, METH_VARARGS, 0);
// 列出目录下所有文件
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), listPathRes, __py_listPathRes, METH_VARARGS, 0);
// 匹配相对路径获得全路径
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), matchPath, __py_matchPath, METH_VARARGS, 0);
// 获取watcher值
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), getWatcher, __py_getWatcher, METH_VARARGS, 0);
// 获取watcher目录
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), getWatcherDir, __py_getWatcherDir, METH_VARARGS, 0);
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_NORMAL", log4cxx::ScriptLevel::SCRIPT_INT))
{
ERROR_MSG( "EntityApp::installPyModules: Unable to set KBEngine.LOG_TYPE_NORMAL.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_INFO", log4cxx::ScriptLevel::SCRIPT_INFO))
{
ERROR_MSG( "EntityApp::installPyModules: Unable to set KBEngine.LOG_TYPE_INFO.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_ERR", log4cxx::ScriptLevel::SCRIPT_ERR))
{
ERROR_MSG( "EntityApp::installPyModules: Unable to set KBEngine.LOG_TYPE_ERR.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_DBG", log4cxx::ScriptLevel::SCRIPT_DBG))
{
ERROR_MSG( "EntityApp::installPyModules: Unable to set KBEngine.LOG_TYPE_DBG.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_WAR", log4cxx::ScriptLevel::SCRIPT_WAR))
{
ERROR_MSG( "EntityApp::installPyModules: Unable to set KBEngine.LOG_TYPE_WAR.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "NEXT_ONLY", KBE_NEXT_ONLY))
{
ERROR_MSG( "EntityApp::installPyModules: Unable to set KBEngine.NEXT_ONLY.\n");
}
if(entryScriptFileName != NULL)
{
entryScript_ = PyImport_Import(entryScriptFileName);
SCRIPT_ERROR_CHECK();
S_RELEASE(entryScriptFileName);
if(entryScript_.get() == NULL)
{
return false;
}
}
onInstallPyModules();
return true;
}
//-------------------------------------------------------------------------------------
bool PythonApp::installPyModules()
{
// 安装入口模块
PyObject *entryScriptFileName = NULL;
if(componentType() == BASEAPP_TYPE)
{
ENGINE_COMPONENT_INFO& info = g_kbeSrvConfig.getBaseApp();
entryScriptFileName = PyUnicode_FromString(info.entryScriptFile);
}
else if(componentType() == CELLAPP_TYPE)
{
ENGINE_COMPONENT_INFO& info = g_kbeSrvConfig.getCellApp();
entryScriptFileName = PyUnicode_FromString(info.entryScriptFile);
}
else if(componentType() == INTERFACES_TYPE)
{
ENGINE_COMPONENT_INFO& info = g_kbeSrvConfig.getInterfaces();
entryScriptFileName = PyUnicode_FromString(info.entryScriptFile);
}
else if (componentType() == LOGINAPP_TYPE)
{
ENGINE_COMPONENT_INFO& info = g_kbeSrvConfig.getLoginApp();
entryScriptFileName = PyUnicode_FromString(info.entryScriptFile);
}
else if (componentType() == DBMGR_TYPE)
{
ENGINE_COMPONENT_INFO& info = g_kbeSrvConfig.getDBMgr();
entryScriptFileName = PyUnicode_FromString(info.entryScriptFile);
}
else
{
ERROR_MSG("PythonApp::installPyModules: entryScriptFileName is NULL!\n");
}
// 注册创建entity的方法到py
// 向脚本注册app发布状态
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), publish, __py_getAppPublish, METH_VARARGS, 0);
// 注册设置脚本输出类型
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), scriptLogType, __py_setScriptLogType, METH_VARARGS, 0);
// 获得资源全路径
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), getResFullPath, __py_getResFullPath, METH_VARARGS, 0);
// 是否存在某个资源
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), hasRes, __py_hasRes, METH_VARARGS, 0);
// 打开一个文件
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), open, __py_kbeOpen, METH_VARARGS, 0);
// 列出目录下所有文件
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), listPathRes, __py_listPathRes, METH_VARARGS, 0);
// 匹配相对路径获得全路径
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), matchPath, __py_matchPath, METH_VARARGS, 0);
// debug追踪kbe封装的py对象计数
APPEND_SCRIPT_MODULE_METHOD(getScript().getModule(), debugTracing, script::PyGC::__py_debugTracing, METH_VARARGS, 0);
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_NORMAL", log4cxx::ScriptLevel::SCRIPT_INT))
{
ERROR_MSG( "PythonApp::installPyModules: Unable to set KBEngine.LOG_TYPE_NORMAL.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_INFO", log4cxx::ScriptLevel::SCRIPT_INFO))
{
ERROR_MSG( "PythonApp::installPyModules: Unable to set KBEngine.LOG_TYPE_INFO.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_ERR", log4cxx::ScriptLevel::SCRIPT_ERR))
{
ERROR_MSG( "PythonApp::installPyModules: Unable to set KBEngine.LOG_TYPE_ERR.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_DBG", log4cxx::ScriptLevel::SCRIPT_DBG))
{
ERROR_MSG( "PythonApp::installPyModules: Unable to set KBEngine.LOG_TYPE_DBG.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "LOG_TYPE_WAR", log4cxx::ScriptLevel::SCRIPT_WAR))
{
ERROR_MSG( "PythonApp::installPyModules: Unable to set KBEngine.LOG_TYPE_WAR.\n");
}
if(PyModule_AddIntConstant(this->getScript().getModule(), "NEXT_ONLY", KBE_NEXT_ONLY))
{
ERROR_MSG( "PythonApp::installPyModules: Unable to set KBEngine.NEXT_ONLY.\n");
}
onInstallPyModules();
if (entryScriptFileName != NULL)
{
entryScript_ = PyImport_Import(entryScriptFileName);
SCRIPT_ERROR_CHECK();
S_RELEASE(entryScriptFileName);
if(entryScript_.get() == NULL)
{
return false;
}
}
return true;
}
//-------------------------------------------------------------------------------------
bool PyGC::initialize(void)
{
if(isInit)
return true;
PyObject* gcModule = PyImport_ImportModule("gc");
if(gcModule)
{
collectMethod_ = PyObject_GetAttrString(gcModule, "collect");
if (!collectMethod_)
{
ERROR_MSG("PyGC::initialize: get collect is error!\n");
PyErr_PrintEx(0);
}
set_debugMethod_ = PyObject_GetAttrString(gcModule, "set_debug");
if(!set_debugMethod_)
{
ERROR_MSG("PyGC::init: get set_debug is error!\n");
PyErr_PrintEx(0);
}
PyObject* flag = NULL;
flag = PyObject_GetAttrString(gcModule, "DEBUG_STATS");
if(!flag)
{
ERROR_MSG("PyGC::init: get DEBUG_STATS is error!\n");
PyErr_PrintEx(0);
}
else
{
DEBUG_STATS = PyLong_AsLong(flag);
Py_DECREF(flag);
flag = NULL;
}
flag = PyObject_GetAttrString(gcModule, "DEBUG_COLLECTABLE");
if(!flag)
{
ERROR_MSG("PyGC::init: get DEBUG_COLLECTABLE is error!\n");
PyErr_PrintEx(0);
}
else
{
DEBUG_COLLECTABLE = PyLong_AsLong(flag);
Py_DECREF(flag);
flag = NULL;
}
flag = PyObject_GetAttrString(gcModule, "DEBUG_UNCOLLECTABLE");
if(!flag)
{
ERROR_MSG("PyGC::init: get DEBUG_UNCOLLECTABLE is error!\n");
PyErr_PrintEx(0);
}
else
{
DEBUG_UNCOLLECTABLE = PyLong_AsLong(flag);
Py_DECREF(flag);
flag = NULL;
}
flag = PyObject_GetAttrString(gcModule, "DEBUG_SAVEALL");
if(!flag)
{
ERROR_MSG("PyGC::init: get DEBUG_SAVEALL is error!\n");
PyErr_PrintEx(0);
}
else
{
DEBUG_SAVEALL = PyLong_AsLong(flag);
Py_DECREF(flag);
flag = NULL;
}
flag = PyObject_GetAttrString(gcModule, "DEBUG_LEAK");
if(!flag)
{
ERROR_MSG("PyGC::init: get DEBUG_LEAK is error!\n");
PyErr_PrintEx(0);
}
else
{
DEBUG_LEAK = PyLong_AsLong(flag);
Py_DECREF(flag);
flag = NULL;
}
APPEND_SCRIPT_MODULE_METHOD(gcModule, debugTracing, __py_debugTracing, METH_VARARGS, 0);
Py_DECREF(gcModule);
}
else
{
ERROR_MSG("PyGC::initialize: can't import gc!\n");
PyErr_PrintEx(0);
}
isInit = collectMethod_ && set_debugMethod_;
return isInit;
}
