//------------------------------------------------------------------------------------- bool FixedDict::checkDataChanged(const char* keyName, PyObject* value, bool isDelete) { FixedDictType::FIXEDDICT_KEYTYPE_MAP& keyTypes = _dataType->getKeyTypes(); FixedDictType::FIXEDDICT_KEYTYPE_MAP::const_iterator iter = keyTypes.begin(); for(; iter != keyTypes.end(); ++iter) { if((*iter).first == keyName) { if(isDelete) { char err[255]; kbe_snprintf(err, 255, "can't delete from FIXED_DICT key[%s].\n", keyName); PyErr_SetString(PyExc_TypeError, err); PyErr_PrintEx(0); return false; } else { DataType* dataType = (*iter).second->dataType; if(!dataType->isSameType(value)){ return false; } } return true; } } char err[255]; kbe_snprintf(err, 255, "set FIXED_DICT to a unknown key[%s].\n", keyName); PyErr_SetString(PyExc_TypeError, err); PyErr_PrintEx(0); return false; }
//------------------------------------------------------------------------------------- bool KBEEntityLogTableMysql::logEntity(DBInterface * dbi, const char* ip, uint32 port, DBID dbid, COMPONENT_ID componentID, ENTITY_ID entityID, ENTITY_SCRIPT_UID entityType) { std::string sqlstr = "insert into kbe_entitylog (entityDBID, entityType, entityID, ip, port, componentID) values("; char* tbuf = new char[MAX_BUF * 3]; kbe_snprintf(tbuf, MAX_BUF, "%"PRDBID, dbid); sqlstr += tbuf; sqlstr += ","; kbe_snprintf(tbuf, MAX_BUF, "%u", entityType); sqlstr += tbuf; sqlstr += ","; kbe_snprintf(tbuf, MAX_BUF, "%d", entityID); sqlstr += tbuf; sqlstr += ",\""; mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(), tbuf, ip, strlen(ip)); sqlstr += tbuf; sqlstr += "\","; kbe_snprintf(tbuf, MAX_BUF, "%u", port); sqlstr += tbuf; sqlstr += ","; kbe_snprintf(tbuf, MAX_BUF, "%"PRDBID, componentID); sqlstr += tbuf; sqlstr += ")"; SAFE_RELEASE_ARRAY(tbuf); try { if(!dbi->query(sqlstr.c_str(), sqlstr.size(), false)) { // 1062 int err = dbi->getlasterror(); return false; } } catch (std::exception & e) { DBException& dbe = static_cast<DBException&>(e); if(dbe.isLostConnection()) { if(dbi->processException(e)) return true; } return false; } return true; }
//------------------------------------------------------------------------------------- DBInterface* DBUtil::createInterface(const std::string& name, bool showinfo) { DBInterfaceInfo* pDBInfo = g_kbeSrvConfig.dbInterface(name); if (!pDBInfo) { ERROR_MSG(fmt::format("DBUtil::createInterface: not found dbInterface({})\n", name)); return NULL; } DBInterface* dbinterface = NULL; if (strcmp(pDBInfo->db_type, "mysql") == 0) { dbinterface = new DBInterfaceMysql(name.c_str(), pDBInfo->db_unicodeString_characterSet, pDBInfo->db_unicodeString_collation); } else if (strcmp(pDBInfo->db_type, "redis") == 0) { dbinterface = new DBInterfaceRedis(name.c_str()); } if(dbinterface == NULL) { ERROR_MSG(fmt::format("DBUtil::createInterface: create db_interface error! type={}\n", pDBInfo->db_type)); return NULL; } kbe_snprintf(dbinterface->db_type_, MAX_BUF, "%s", pDBInfo->db_type); dbinterface->db_port_ = pDBInfo->db_port; kbe_snprintf(dbinterface->db_ip_, MAX_IP, "%s", pDBInfo->db_ip); kbe_snprintf(dbinterface->db_username_, MAX_BUF, "%s", pDBInfo->db_username); dbinterface->db_numConnections_ = pDBInfo->db_numConnections; kbe_snprintf(dbinterface->db_password_, MAX_BUF, "%s", pDBInfo->db_password); if (!dbinterface->attach(pDBInfo->db_name)) { ERROR_MSG(fmt::format("DBUtil::createInterface: attach to database failed!\n\tdbinterface={0:p}\n\targs={1}\n", (void*)&dbinterface, dbinterface->c_str())); delete dbinterface; return NULL; } else { if(showinfo) { INFO_MSG(fmt::format("DBUtil::createInterface[{0:p}]: {1}\n", (void*)&dbinterface, dbinterface->c_str())); } } return dbinterface; }
//------------------------------------------------------------------------------------- void TelnetCProfileHandler::sendStream(MemoryStream* s) { if(isDestroyed_) return; std::string datas; uint32 timinglen; ArraySize size; (*s) >> timinglen >> size; datas = "ncalls\ttottime\tpercall\tcumtime\tpercall\tfilename:lineno(function)\r\n"; while(size-- > 0) { uint32 count; float lastTime; float sumTime; float lastIntTime; float sumIntTime; std::string name; (*s) >> name >> count >> lastTime >> sumTime >> lastIntTime >> sumIntTime; char buf[256]; kbe_snprintf(buf, 256, "%u", count); datas += buf; datas += "\t"; kbe_snprintf(buf, 256, "%.3f", sumTime); datas += buf; datas += "\t"; kbe_snprintf(buf, 256, "%.3f", lastTime); datas += buf; datas += "\t"; kbe_snprintf(buf, 256, "%.3f", sumIntTime); datas += buf; datas += "\t"; kbe_snprintf(buf, 256, "%.3f", lastIntTime); datas += buf; datas += "\t"; datas += name; datas += "\r\n"; }; pTelnetHandler_->onProfileEnd(datas); }
//------------------------------------------------------------------------------------- bool ProfileVal::initializeWatcher() { if(initWatcher_) return false; initWatcher_ = true; char buf[MAX_BUF]; kbe_snprintf(buf, MAX_BUF, "cprofiles/%s/%s/lastTime", pProfileGroup_->name(), name_.c_str()); WATCH_OBJECT(buf, &lastTime_, &TimeStamp::stamp); kbe_snprintf(buf, MAX_BUF, "cprofiles/%s/%s/sumTime", pProfileGroup_->name(), name_.c_str()); WATCH_OBJECT(buf, &sumTime_, &TimeStamp::stamp); kbe_snprintf(buf, MAX_BUF, "cprofiles/%s/%s/lastIntTime", pProfileGroup_->name(), name_.c_str()); WATCH_OBJECT(buf, &lastIntTime_, &TimeStamp::stamp); kbe_snprintf(buf, MAX_BUF, "cprofiles/%s/%s/sumIntTime", pProfileGroup_->name(), name_.c_str()); WATCH_OBJECT(buf, &sumIntTime_, &TimeStamp::stamp); kbe_snprintf(buf, MAX_BUF, "cprofiles/%s/%s/lastQuantity", pProfileGroup_->name(), name_.c_str()); WATCH_OBJECT(buf, lastQuantity_); kbe_snprintf(buf, MAX_BUF, "cprofiles/%s/%s/sumQuantity", pProfileGroup_->name(), name_.c_str()); WATCH_OBJECT(buf, sumQuantity_); kbe_snprintf(buf, MAX_BUF, "cprofiles/%s/%s/count", pProfileGroup_->name(), name_.c_str()); WATCH_OBJECT(buf, count_); kbe_snprintf(buf, MAX_BUF, "cprofiles/%s/%s/inProgress", pProfileGroup_->name(), name_.c_str()); WATCH_OBJECT(buf, inProgress_); return true; }
//------------------------------------------------------------------------------------- bool KBEEmailVerificationTableMysql::logAccount(DBInterface * dbi, int8 type, const std::string& name, const std::string& datas, const std::string& code) { std::string sqlstr = "insert into kbe_email_verification (accountName, type, datas, code, logtime) values("; char* tbuf = new char[MAX_BUF > datas.size() ? MAX_BUF * 3 : (code.size() > datas.size() ? code.size() * 3 : datas.size() * 3)]; mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(), tbuf, name.c_str(), name.size()); sqlstr += "\""; sqlstr += tbuf; sqlstr += "\","; kbe_snprintf(tbuf, MAX_BUF, "%d,", type); sqlstr += tbuf; mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(), tbuf, datas.c_str(), datas.size()); sqlstr += "\""; sqlstr += tbuf; sqlstr += "\","; mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(), tbuf, code.c_str(), code.size()); sqlstr += "\""; sqlstr += tbuf; sqlstr += "\","; kbe_snprintf(tbuf, MAX_BUF, "%"PRTime, time(NULL)); sqlstr += tbuf; sqlstr += ")"; SAFE_RELEASE_ARRAY(tbuf); if(!dbi->query(sqlstr.c_str(), sqlstr.size(), false)) { ERROR_MSG(fmt::format("KBEEmailVerificationTableMysql::logAccount({}): sql({}) is failed({})!\n", code, sqlstr, dbi->getstrerror())); return false; } return true; }
//------------------------------------------------------------------------------------- DBInterface* DBUtil::createInterface(bool showinfo) { ENGINE_COMPONENT_INFO& dbcfg = g_kbeSrvConfig.getDBMgr(); DBInterface* dbinterface = NULL; if(strcmp(dbcfg.db_type, "mysql") == 0) { dbinterface = new DBInterfaceMysql(dbcfg.db_unicodeString_characterSet, dbcfg.db_unicodeString_collation); } else if(strcmp(dbcfg.db_type, "redis") == 0) { dbinterface = new DBInterfaceRedis(); } if(dbinterface == NULL) { ERROR_MSG(fmt::format("DBUtil::createInterface: create db_interface error! type={}\n", dbcfg.db_type)); return NULL; } kbe_snprintf(dbinterface->db_type_, MAX_BUF, "%s", dbcfg.db_type); dbinterface->db_port_ = dbcfg.db_port; kbe_snprintf(dbinterface->db_ip_, MAX_IP, "%s", dbcfg.db_ip); kbe_snprintf(dbinterface->db_username_, MAX_BUF, "%s", dbcfg.db_username); dbinterface->db_numConnections_ = dbcfg.db_numConnections; kbe_snprintf(dbinterface->db_password_, MAX_BUF, "%s", dbcfg.db_password); if(!dbinterface->attach(DBUtil::dbname())) { ERROR_MSG(fmt::format("DBUtil::createInterface: attach to database failed!\n\tdbinterface={0:p}\n\targs={1}\n", (void*)&dbinterface, dbinterface->c_str())); delete dbinterface; return NULL; } else { if(showinfo) { INFO_MSG(fmt::format("DBUtil::createInterface[{0:p}]: {1}\n", (void*)&dbinterface, dbinterface->c_str())); } } return dbinterface; }
//------------------------------------------------------------------------------------- bool DBUtil::initialize() { ENGINE_COMPONENT_INFO& dbcfg = g_kbeSrvConfig.getDBMgr(); if(dbcfg.db_passwordEncrypt) { // 如果小于64则表示目前还是明文密码 if(strlen(dbcfg.db_password) < 64) { WARNING_MSG(boost::format("DBUtil::createInterface: db password is not encrypted!\nplease use password(rsa):\n%1%\n") % KBEKey::getSingleton().encrypt(dbcfg.db_password)); } else { std::string out = KBEKey::getSingleton().decrypt(dbcfg.db_password); if(out.size() == 0) return false; kbe_snprintf(dbcfg.db_password, MAX_BUF, "%s", out.c_str()); } } return true; }
//------------------------------------------------------------------------------------- bool PyProfile::stop(std::string profile) { PyProfile::PROFILES::iterator iter = profiles_.find(profile); if(iter == profiles_.end()) { ERROR_MSG(boost::format("PyProfile::stop: profile(%1%) is not exists!\n") % profile); return false; } PyObject* pyRet = PyObject_CallMethod(iter->second.get(), const_cast<char*>("disable"), const_cast<char*>("")); if(!pyRet) { SCRIPT_ERROR_CHECK(); return false; } Py_DECREF(pyRet); char buf[MAX_BUF]; kbe_snprintf(buf, MAX_BUF, "print(\"PyProfile::stop: profile=%s.\")", profile.c_str()); pScript_->run_simpleString(buf, NULL); return true; }
//------------------------------------------------------------------------------------- bool KBEEmailVerificationTableMysql::delAccount(DBInterface * dbi, int8 type, const std::string& name) { std::string sqlstr = "delete from kbe_email_verification where accountName="; char* tbuf = new char[MAX_BUF * 3]; mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(), tbuf, name.c_str(), name.size()); sqlstr += "\""; sqlstr += tbuf; sqlstr += "\" and type="; kbe_snprintf(tbuf, MAX_BUF, "%d", type); sqlstr += tbuf; SAFE_RELEASE_ARRAY(tbuf); if(!dbi->query(sqlstr.c_str(), sqlstr.size(), false)) { ERROR_MSG(fmt::format("KBEEmailVerificationTableMysql::delAccount({}): sql({}) is failed({})!\n", name, sqlstr, dbi->getstrerror())); return false; } return true; }
//------------------------------------------------------------------------------------- bool KBEAccountTableMysql::logAccount(DBInterface * dbi, ACCOUNT_INFOS& info) { std::string sqlstr = "insert into kbe_accountinfos (accountName, password, entityDBID) values("; char* tbuf = new char[MAX_BUF * 3]; mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(), tbuf, info.name.c_str(), info.name.size()); sqlstr += "\""; sqlstr += tbuf; sqlstr += "\","; mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(), tbuf, info.password.c_str(), info.password.size()); sqlstr += "md5(\""; sqlstr += tbuf; sqlstr += "\"),"; kbe_snprintf(tbuf, MAX_BUF, "%"PRDBID, info.dbid); sqlstr += tbuf; sqlstr += ")"; SAFE_RELEASE_ARRAY(tbuf); // 如果查询失败则返回存在, 避免可能产生的错误 if(!dbi->query(sqlstr.c_str(), sqlstr.size(), false)) return false; return true; }
// 获得系统产生的最后一次错误描述 inline char* kbe_strerror(int ierrorno = 0) { #if KBE_PLATFORM == PLATFORM_WIN32 if(ierrorno == 0) ierrorno = GetLastError(); static char lpMsgBuf[256] = {0}; /* FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, ierrorno, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language (LPTSTR) &lpMsgBuf, 1024, NULL ); */ kbe_snprintf(lpMsgBuf, 256, "errorno=%d", ierrorno); return lpMsgBuf; #else if(ierrorno != 0) return strerror(ierrorno); return strerror(errno); #endif }
//------------------------------------------------------------------------------------- void ServerApp::hello(Network::Channel* pChannel, MemoryStream& s) { std::string verInfo, scriptVerInfo, encryptedKey; s >> verInfo >> scriptVerInfo; s.readBlob(encryptedKey); char buf[MAX_BUF]; std::string encryptedKey_str; if (encryptedKey.size() > 3 && encryptedKey.size() <= 65535) { for (int i = 0; i < (int)encryptedKey.size(); ++i) { memset(buf, 0, MAX_BUF); kbe_snprintf(buf, MAX_BUF / 2, "%02hhX ", (unsigned char)encryptedKey.data()[i]); encryptedKey_str += buf; } } else { encryptedKey = ""; encryptedKey_str = "None"; } INFO_MSG(fmt::format("ServerApp::onHello: verInfo={}, scriptVerInfo={}, encryptedKey={}, addr:{}\n", verInfo, scriptVerInfo, encryptedKey_str, pChannel->c_str())); if(verInfo != KBEVersion::versionString()) onVersionNotMatch(pChannel); else if(scriptVerInfo != KBEVersion::scriptVersionString()) onScriptVersionNotMatch(pChannel); else onHello(pChannel, verInfo, scriptVerInfo, encryptedKey); }
void myassert(const char * exp, const char * func, const char * file, unsigned int line) { kbe_snprintf(_g_buf, DBG_PT_SIZE, "assertion failed: %s, file %s, line %d, at: %s\n", exp, file, line, func); dbghelper.print_msg(_g_buf); printf("%s", _g_buf); abort(); }
void DebugHelper::critical_msg(const char * str, ...) { if(str == NULL) return; KBEngine::thread::ThreadGuard tg(&this->logMutex); #ifdef NO_USE_LOG4CXX #else va_list ap; va_start(ap, str); #if KBE_PLATFORM == PLATFORM_WIN32 uint32 size = _vsnprintf(_g_buf, DBG_PT_SIZE, str, ap); #else uint32 size = vsnprintf(_g_buf, DBG_PT_SIZE, str, ap); #endif va_end(ap); char buf[DBG_PT_SIZE]; kbe_snprintf(buf, DBG_PT_SIZE, "%s(%d) -> %s\n\t%s\n", _currFile.c_str(), _currLine, _currFuncName.c_str(), _g_buf); LOG4CXX_FATAL(g_logger, buf); #endif setFile("", "", 0); onMessage(LOG_CRITICAL, _g_buf, size); }
//------------------------------------------------------------------------------------- const char* DBInterfaceMysql::c_str() { static char strdescr[MAX_BUF]; kbe_snprintf(strdescr, MAX_BUF, "dbtype=mysql, ip=%s, port=%u, currdatabase=%s, username=%s, connected=%s.\n", db_ip_, db_port_, db_name_, db_username_, pMysql_ == NULL ? "no" : "yes"); return strdescr; }
//------------------------------------------------------------------------------------- void Proxy::giveClientTo(Proxy* proxy) { if(clientMailbox_ == NULL || clientMailbox_->getChannel() == NULL) { char err[255]; kbe_snprintf(err, 255, "Proxy[%s]::giveClientTo: no has client.", getScriptName()); PyErr_SetString(PyExc_TypeError, err); PyErr_PrintEx(0); onGiveClientToFailure(); return; } Mercury::Channel* lpChannel = clientMailbox_->getChannel(); if(proxy) { EntityMailbox* mb = proxy->getClientMailbox(); if(mb != NULL) { ERROR_MSG(boost::format("Proxy::giveClientTo: %1%[%2%] give client to %3%[%4%], %5% have clientMailbox.\n") % getScriptName() % getID() % proxy->getScriptName() % proxy->getID() % proxy->getScriptName()); onGiveClientToFailure(); return; } if(getCellMailbox()) { // 通知cell丢失客户端 Mercury::Bundle* pBundle = Mercury::Bundle::ObjPool().createObject(); (*pBundle).newMessage(CellappInterface::onResetWitness); (*pBundle) << this->getID(); getCellMailbox()->postMail((*pBundle)); Mercury::Bundle::ObjPool().reclaimObject(pBundle); } entitiesEnabled_ = false; getClientMailbox()->addr(Mercury::Address::NONE); Py_DECREF(getClientMailbox()); proxy->onGiveClientTo(lpChannel); setClientMailbox(NULL); addr(Mercury::Address::NONE); if(proxy->getClientMailbox() != NULL) { // 通知client销毁当前entity Mercury::Bundle* pBundle = Mercury::Bundle::ObjPool().createObject(); (*pBundle).newMessage(ClientInterface::onEntityDestroyed); (*pBundle) << this->getID(); proxy->getClientMailbox()->postMail((*pBundle)); Mercury::Bundle::ObjPool().reclaimObject(pBundle); } } }
//------------------------------------------------------------------------------------- void Messagelog::writeLog(Mercury::Channel* pChannel, KBEngine::MemoryStream& s) { uint32 logtype; COMPONENT_TYPE componentType = UNKNOWN_COMPONENT_TYPE; COMPONENT_ID componentID = 0; COMPONENT_ORDER componentOrder = 0; int64 t; GAME_TIME kbetime = 0; std::string str; std::stringstream logstream; s >> logtype; s >> componentType; s >> componentID; s >> componentOrder; s >> t >> kbetime; s >> str; time_t tt = static_cast<time_t>(t); tm* aTm = localtime(&tt); // YYYY year // MM month (2 digits 01-12) // DD day (2 digits 01-31) // HH hour (2 digits 00-23) // MM minutes (2 digits 00-59) // SS seconds (2 digits 00-59) if(aTm == NULL) { ERROR_MSG("Messagelog::writeLog: log is error!\n"); return; } char timebuf[MAX_BUF]; kbe_snprintf(timebuf, MAX_BUF, " [%-4d-%02d-%02d %02d:%02d:%02d %02d] ", aTm->tm_year+1900, aTm->tm_mon+1, aTm->tm_mday, aTm->tm_hour, aTm->tm_min, aTm->tm_sec, kbetime); logstream << KBELOG_TYPE_NAME_EX(logtype); logstream << " "; logstream << COMPONENT_NAME_EX_1(componentType); logstream << " "; logstream << componentID; logstream << " "; logstream << (int)componentOrder; logstream << timebuf; logstream << "- "; logstream << str; DebugHelper::getSingleton().changeLogger(COMPONENT_NAME_EX(componentType)); PRINT_MSG(logstream.str()); DebugHelper::getSingleton().changeLogger("default"); LOG_WATCHERS::iterator iter = logWatchers_.begin(); for(; iter != logWatchers_.end(); iter++) { iter->second.onMessage(logtype, componentType, componentID, componentOrder, t, kbetime, str, logstream); } }
//------------------------------------------------------------------------------------- void DebugHelper::initHelper(COMPONENT_TYPE componentType) { #ifndef NO_USE_LOG4CXX g_logger = log4cxx::Logger::getLogger(COMPONENT_NAME_EX(componentType)); char helpConfig[256]; if(componentType == CLIENT_TYPE) { kbe_snprintf(helpConfig, 256, "log4j.properties"); } else { kbe_snprintf(helpConfig, 256, "server/log4cxx_properties/%s.properties", COMPONENT_NAME_EX(componentType)); } log4cxx::PropertyConfigurator::configure(Resmgr::getSingleton().matchRes(helpConfig).c_str()); #endif }
SqlStatementQuery(DBInterface* dbi, std::string tableName, DBID parentDBID, DBID dbid, DB_OP_TABLE_ITEM_DATAS& tableItemDatas): SqlStatement(dbi, tableName, parentDBID, dbid, tableItemDatas), sqlstr1_() { // select id,xxx from tbl_SpawnPoint where id=123; sqlstr_ = "select "; sqlstr1_ += " from "ENTITY_TABLE_PERFIX"_"; sqlstr1_ += tableName; char strdbid[MAX_BUF]; if(parentDBID <= 0) { sqlstr1_ += " where id="; kbe_snprintf(strdbid, MAX_BUF, "%"PRDBID, dbid); } else { sqlstr1_ += " where "TABLE_PARENTID_CONST_STR"="; kbe_snprintf(strdbid, MAX_BUF, "%"PRDBID, parentDBID); } // 无论哪种情况都查询出ID字段 sqlstr_ += "id,"; sqlstr1_ += strdbid; DB_OP_TABLE_ITEM_DATAS::iterator tableValIter = tableItemDatas.begin(); for(; tableValIter != tableItemDatas.end(); tableValIter++) { KBEShared_ptr<DB_OP_TABLE_ITEM_DATA> pSotvs = (*tableValIter); sqlstr_ += pSotvs->sqlkey; sqlstr_ += ","; } if(sqlstr_.at(sqlstr_.size() - 1) == ',') sqlstr_.erase(sqlstr_.size() - 1); sqlstr_ += sqlstr1_; }
//------------------------------------------------------------------------------------- bool DBInterfaceMysql::dropEntityTableFromDB(const char* tablename) { KBE_ASSERT(tablename != NULL); DEBUG_MSG(boost::format("DBInterfaceMysql::dropEntityTableFromDB: %1%.\n") % tablename); char sql_str[MAX_BUF]; kbe_snprintf(sql_str, MAX_BUF, "Drop table if exists %s;", tablename); return query(sql_str, strlen(sql_str)); }
//------------------------------------------------------------------------------------- bool DBInterfaceMysql::dropEntityTableItemFromDB(const char* tablename, const char* tableItemName) { KBE_ASSERT(tablename != NULL && tableItemName != NULL); DEBUG_MSG(boost::format("DBInterfaceMysql::dropEntityTableItemFromDB: %1% %2%.\n") % tablename % tableItemName); char sql_str[MAX_BUF]; kbe_snprintf(sql_str, MAX_BUF, "alter table %s drop column %s;", tablename, tableItemName); return query(sql_str, strlen(sql_str)); }
const std::string & versionString() { if(g_versionString.size() == 0) { char buf[ 256 ]; kbe_snprintf( buf, 256, "%d.%d.%d", KBE_VERSION_MAJOR, KBE_VERSION_MINOR, KBE_VERSION_PATCH ); g_versionString = buf; } return g_versionString; }
//------------------------------------------------------------------------------------- bool KBEEntityLogTableMysql::eraseEntityLog(DBInterface * dbi, DBID dbid, ENTITY_SCRIPT_UID entityType) { std::string sqlstr = "delete from kbe_entitylog where entityDBID="; char tbuf[MAX_BUF]; kbe_snprintf(tbuf, MAX_BUF, "%"PRDBID, dbid); sqlstr += tbuf; sqlstr += " and entityType="; kbe_snprintf(tbuf, MAX_BUF, "%u", entityType); sqlstr += tbuf; if(!dbi->query(sqlstr.c_str(), sqlstr.size(), false)) { return false; } return true; }
//------------------------------------------------------------------------------------- bool KBEEntityLogTableMysql::queryEntity(DBInterface * dbi, DBID dbid, EntityLog& entitylog, ENTITY_SCRIPT_UID entityType) { std::string sqlstr = "select entityID,ip,port,componentID from kbe_entitylog where entityDBID="; char tbuf[MAX_BUF]; kbe_snprintf(tbuf, MAX_BUF, "%"PRDBID, dbid); sqlstr += tbuf; sqlstr += " and entityType="; kbe_snprintf(tbuf, MAX_BUF, "%u", entityType); sqlstr += tbuf; if(!dbi->query(sqlstr.c_str(), sqlstr.size(), false)) { return true; } entitylog.dbid = dbid; entitylog.componentID = 0; entitylog.entityID = 0; entitylog.ip = 0; entitylog.port = 0; MYSQL_RES * pResult = mysql_store_result(static_cast<DBInterfaceMysql*>(dbi)->mysql()); if(pResult) { MYSQL_ROW arow; while((arow = mysql_fetch_row(pResult)) != NULL) { StringConv::str2value(entitylog.entityID, arow[0]); StringConv::str2value(entitylog.ip, arow[1]); StringConv::str2value(entitylog.port, arow[2]); StringConv::str2value(entitylog.componentID, arow[3]); break; } mysql_free_result(pResult); } return entitylog.componentID > 0; }
//------------------------------------------------------------------------------------- DBInterface* DBUtil::createInterface(bool showinfo) { ENGINE_COMPONENT_INFO& dbcfg = g_kbeSrvConfig.getDBMgr(); DBInterface* dbinterface = NULL; if(strcmp(dbcfg.db_type, "mysql") == 0) { dbinterface = new DBInterfaceMysql; } kbe_snprintf(dbinterface->db_type_, MAX_BUF, "%s", dbcfg.db_type); dbinterface->db_port_ = dbcfg.db_port; kbe_snprintf(dbinterface->db_ip_, MAX_IP, "%s", dbcfg.db_ip); kbe_snprintf(dbinterface->db_username_, MAX_BUF, "%s", dbcfg.db_username); kbe_snprintf(dbinterface->db_password_, MAX_BUF, "%s", dbcfg.db_password); dbinterface->db_numConnections_ = dbcfg.db_numConnections; if(dbinterface == NULL) { ERROR_MSG("DBUtil::createInterface: can't create dbinterface!\n"); return NULL; } if(!dbinterface->attach(DBUtil::dbname())) { ERROR_MSG("DBUtil::createInterface: can't attach to database!\n\tdbinterface=%p\n\targs=%s", &dbinterface, dbinterface->c_str()); delete dbinterface; return NULL; } else { if(showinfo) { INFO_MSG("DBUtil::createInterface[%p]: %s\n", &dbinterface, dbinterface->c_str()); } } return dbinterface; }
//------------------------------------------------------------------------------------- const char * Channel::c_str() const { static char dodgyString[ MAX_BUF ] = {"None"}; char tdodgyString[ MAX_BUF ] = {0}; if(pEndPoint_ && !pEndPoint_->addr().isNone()) pEndPoint_->addr().writeToString(tdodgyString, MAX_BUF); kbe_snprintf(dodgyString, MAX_BUF, "%s/%d", tdodgyString, id_); return dodgyString; }
SqlStatementInsert(DBInterface* dbi, std::string tableName, DBID parentDBID, DBID dbid, DB_OP_TABLE_ITEM_DATAS& tableItemDatas): SqlStatement(dbi, tableName, parentDBID, dbid, tableItemDatas) { // insert into tbl_Account (sm_accountName) values("fdsafsad\0\fdsfasfsa\0fdsafsda"); sqlstr_ = "insert into "ENTITY_TABLE_PERFIX"_"; sqlstr_ += tableName; sqlstr_ += " ("; sqlstr1_ = ") values("; if(parentDBID > 0) { sqlstr_ += TABLE_PARENTID_CONST_STR; sqlstr_ += ","; char strdbid[MAX_BUF]; kbe_snprintf(strdbid, MAX_BUF, "%"PRDBID, parentDBID); sqlstr1_ += strdbid; sqlstr1_ += ","; } DB_OP_TABLE_ITEM_DATAS::iterator tableValIter = tableItemDatas.begin(); for(; tableValIter != tableItemDatas.end(); tableValIter++) { KBEShared_ptr<DB_OP_TABLE_ITEM_DATA> pSotvs = (*tableValIter); if(dbid > 0) { } else { sqlstr_ += pSotvs->sqlkey; if(pSotvs->extraDatas.size() > 0) sqlstr1_ += pSotvs->extraDatas; else sqlstr1_ += pSotvs->sqlval; sqlstr_ += ","; sqlstr1_ += ","; } } if(parentDBID > 0 || sqlstr_.at(sqlstr_.size() - 1) == ',') sqlstr_.erase(sqlstr_.size() - 1); if(parentDBID > 0 || sqlstr1_.at(sqlstr1_.size() - 1) == ',') sqlstr1_.erase(sqlstr1_.size() - 1); sqlstr1_ += ")"; sqlstr_ += sqlstr1_; }
//------------------------------------------------------------------------------------- void DebugHelper::critical_msg(std::string s) { KBEngine::thread::ThreadGuard tg(&this->logMutex); char buf[DBG_PT_SIZE]; kbe_snprintf(buf, DBG_PT_SIZE, "%s(%d) -> %s\n\t%s\n", _currFile.c_str(), _currLine, _currFuncName.c_str(), s.c_str()); #ifdef NO_USE_LOG4CXX #else LOG4CXX_FATAL(g_logger, buf); #endif onMessage(KBELOG_CRITICAL, buf, strlen(buf)); backtrace_msg(); }
//------------------------------------------------------------------------------------- bool MessageHandlers::initializeWatcher() { std::vector< std::string >::iterator siter = exposedMessages_.begin(); for(; siter != exposedMessages_.end(); siter++) { MessageHandlerMap::iterator iter = msgHandlers_.begin(); for(; iter != msgHandlers_.end(); iter++) { if((*siter) == iter->second->name) { iter->second->exposed = true; } } } MessageHandlerMap::iterator iter = msgHandlers_.begin(); for(; iter != msgHandlers_.end(); iter++) { char buf[MAX_BUF]; kbe_snprintf(buf, MAX_BUF, "network/messages/%s/id", iter->second->name.c_str()); WATCH_OBJECT(buf, iter->second->msgID); kbe_snprintf(buf, MAX_BUF, "network/messages/%s/len", iter->second->name.c_str()); WATCH_OBJECT(buf, iter->second->msgLen); kbe_snprintf(buf, MAX_BUF, "network/messages/%s/sentSize", iter->second->name.c_str()); WATCH_OBJECT(buf, iter->second, &MessageHandler::sendsize); kbe_snprintf(buf, MAX_BUF, "network/messages/%s/sentCount", iter->second->name.c_str()); WATCH_OBJECT(buf, iter->second, &MessageHandler::sendcount); kbe_snprintf(buf, MAX_BUF, "network/messages/%s/sentAvgSize", iter->second->name.c_str()); WATCH_OBJECT(buf, iter->second, &MessageHandler::sendavgsize); kbe_snprintf(buf, MAX_BUF, "network/messages/%s/recvSize", iter->second->name.c_str()); WATCH_OBJECT(buf, iter->second, &MessageHandler::recvsize); kbe_snprintf(buf, MAX_BUF, "network/messages/%s/recvCount", iter->second->name.c_str()); WATCH_OBJECT(buf, iter->second, &MessageHandler::recvsize); kbe_snprintf(buf, MAX_BUF, "network/messages/%s/recvAvgSize", iter->second->name.c_str()); WATCH_OBJECT(buf, iter->second, &MessageHandler::recvavgsize); } return true; }