From c7095d6ea8efbf2338180a042a18dbf4adc49cb6 Mon Sep 17 00:00:00 2001 From: aozhiwei Date: Fri, 18 Sep 2020 15:04:08 +0800 Subject: [PATCH] 1 --- server/groupserver/CMakeLists.txt | 125 +++++++++ server/groupserver/IMListener.cc | 112 ++++++++ server/groupserver/IMListener.h | 38 +++ server/groupserver/app.cc | 428 ++++++++++++++++++++++++++++++ server/groupserver/app.h | 86 ++++++ server/groupserver/constant.h | 27 ++ server/groupserver/handlermgr.cc | 81 ++++++ server/groupserver/handlermgr.h | 36 +++ server/groupserver/jsondatamgr.cc | 50 ++++ server/groupserver/jsondatamgr.h | 22 ++ server/groupserver/main.cc | 11 + server/groupserver/perfmonitor.cc | 64 +++++ server/groupserver/perfmonitor.h | 22 ++ server/groupserver/precompile.h | 19 ++ server/groupserver/typeconvert.cc | 53 ++++ server/groupserver/typeconvert.h | 23 ++ server/groupserver/types.cc | 3 + server/groupserver/types.h | 41 +++ 18 files changed, 1241 insertions(+) create mode 100644 server/groupserver/CMakeLists.txt create mode 100644 server/groupserver/IMListener.cc create mode 100644 server/groupserver/IMListener.h create mode 100755 server/groupserver/app.cc create mode 100644 server/groupserver/app.h create mode 100755 server/groupserver/constant.h create mode 100644 server/groupserver/handlermgr.cc create mode 100644 server/groupserver/handlermgr.h create mode 100644 server/groupserver/jsondatamgr.cc create mode 100644 server/groupserver/jsondatamgr.h create mode 100644 server/groupserver/main.cc create mode 100644 server/groupserver/perfmonitor.cc create mode 100644 server/groupserver/perfmonitor.h create mode 100644 server/groupserver/precompile.h create mode 100644 server/groupserver/typeconvert.cc create mode 100644 server/groupserver/typeconvert.h create mode 100644 server/groupserver/types.cc create mode 100755 server/groupserver/types.h diff --git a/server/groupserver/CMakeLists.txt b/server/groupserver/CMakeLists.txt new file mode 100644 index 0000000..f6ebaf4 --- /dev/null +++ b/server/groupserver/CMakeLists.txt @@ -0,0 +1,125 @@ +project(friend_groupserver) +cmake_minimum_required(VERSION 2.8) + +set(GAME_ID 9003) + +if (${RELEASE}) + set(CMAKE_BUILD_TYPE "Release") + message("release mode") +else() + set(CMAKE_BUILD_TYPE "Debug") + message("debug mode") +endif() +set(CMAKE_CXX_FLAGS_RELEASE "-O3 -Wall -g -std=gnu++11 -DNDEBUG -DGAME_ID=${GAME_ID} ") +set(CMAKE_CXX_FLAGS_DEBUG "-Wall -g -std=gnu++11 -DDEBUG -DGAME_ID=${GAME_ID} ") + +include_directories( + AFTER + ../../third_party/a8engine + /usr/include/mysql + /usr/include/jsoncpp + /usr/include/hiredis + /usr/include/eigen3 + /usr/include/glm + ../../third_party + ../../third_party/behaviac/inc + ../../third_party/recastnavigation/Recast/Include + ../../third_party/recastnavigation/Detour/Include + ../../third_party/recastnavigation/DetourTileCache/Include + . +) + +link_directories( + /usr/lib64/mysql + /usr/local/lib + ../../third_party/behaviac/lib +) + +aux_source_directory(../../third_party/a8engine/a8 + SRC_LIST +) + +aux_source_directory(../../third_party/framework/cpp + SRC_LIST +) + +aux_source_directory(../../third_party/recastnavigation/Detour/Source + SRC_LIST +) + +aux_source_directory(../../third_party/recastnavigation/Recast/Source + SRC_LIST +) + +aux_source_directory(../../third_party/recastnavigation/DetourTileCache/Source + SRC_LIST +) + +execute_process( + COMMAND touch -a ss_proto.pb.h + COMMAND touch -a ss_proto.pb.cc + COMMAND touch -a ss_msgid.pb.h + COMMAND touch -a ss_msgid.pb.cc + COMMAND touch -a cs_proto.pb.h + COMMAND touch -a cs_proto.pb.cc + COMMAND touch -a cs_msgid.pb.h + COMMAND touch -a cs_msgid.pb.cc + ) +aux_source_directory(. + SRC_LIST +) + +set(EXECUTABLE_OUTPUT_PATH + ${PROJECT_BINARY_DIR}/../bin +) + +add_executable( + friend_groupserver ${SRC_LIST} +) + +add_custom_target(script_pb_protocol ALL) +add_custom_command(TARGET script_pb_protocol + PRE_BUILD + COMMAND python ../../third_party/tools/scripts/construct/build_pb.py --cpp_out=. --pb_files=ss_proto,ss_msgid,cs_msgid,cs_proto --python_out=../tools/robot/virtualclient +) +add_dependencies(friend_groupserver script_pb_protocol) + + +if (CMAKE_BUILD_TYPE STREQUAL "Debug") + target_link_libraries( + friend_groupserver + pthread + mysqlclient + protobuf + rt + dl + util + crypto + ssl + jsoncpp + curl + hiredis + tinyxml2 + tcmalloc + behaviac_gcc_debug + ) +else() + target_link_libraries( + friend_groupserver + pthread + mysqlclient + protobuf + rt + dl + util + crypto + ssl + jsoncpp + curl + hiredis + tinyxml2 + tcmalloc + behaviac_gcc_release + ) +endif() + diff --git a/server/groupserver/IMListener.cc b/server/groupserver/IMListener.cc new file mode 100644 index 0000000..bf6026f --- /dev/null +++ b/server/groupserver/IMListener.cc @@ -0,0 +1,112 @@ +#include "precompile.h" + +#include +#include +#include + +#include "framework/cpp/netmsghandler.h" + +#include "app.h" +#include "IMListener.h" +#include "jsondatamgr.h" +#include "handlermgr.h" + +class IMServerSession: public a8::MixedSession +{ +public: + + virtual void DecodeUserPacket(char* buf, int& offset, unsigned int buflen) override + { + #if 1 + is_activite = true; + #endif + bool warning = false; + while (buflen - offset >= sizeof(f8::PackHead)) { + f8::PackHead* p = (f8::PackHead*)&buf[offset]; + if (p->magic_code == f8::MAGIC_CODE) { + if (buflen - offset < sizeof(f8::PackHead) + p->packlen) { + break; + } + App::Instance()->AddSocketMsg(SF_IMServer, + socket_handle, + saddr, + p->msgid, + p->seqid, + &buf[offset + sizeof(f8::PackHead)], + p->packlen); + offset += sizeof(f8::PackHead) + p->packlen; + } else { + warning = true; + offset++; + continue; + } + } + + if (warning) { + a8::UdpLog::Instance()->Warning("收到imserver非法数据包", {}); + } + } + + virtual void OnRawHttpGet(const std::string& url, const std::string& querystr, + std::string& response) override + { + App::Instance()->AddIMMsg(IM_ExecGM, + a8::XParams() + .SetSender(socket_handle) + .SetParam1(url) + .SetParam2(querystr) + .SetParam3(saddr) + ); + } + + virtual void OnDisConnect() override + { + App::Instance()->AddIMMsg(IM_IMSSocketDisconnect, + a8::XParams() + .SetSender(socket_handle) + .SetParam1(1)); + } + +}; + +static void CreateIMServerSocket(a8::TcpSession **p) +{ + *p = new IMServerSession(); +} + +static void GSListeneron_error(a8::TcpListener*, int type, int errorid) +{ + a8::UdpLog::Instance()->Debug("IMListeneron_error %d %d", {type, errorid}); +} + +void IMListener::Init() +{ + tcp_listener_ = new a8::TcpListener(); + tcp_listener_->on_create_client_socket = CreateIMServerSocket; + tcp_listener_->on_error = GSListeneron_error; + + tcp_listener_->bind_address = "0.0.0.0"; + tcp_listener_->bind_port = JsonDataMgr::Instance()->GetConf()->At("imserver_listen_port")->AsXValue(); + tcp_listener_->Open(); +} + +void IMListener::UnInit() +{ + delete tcp_listener_; + tcp_listener_ = nullptr; +} + +void IMListener::SendText(int sockhandle, const std::string& text) +{ + tcp_listener_->SendClientMsg(sockhandle, text.data(), text.size()); +} + +void IMListener::ForceCloseClient(int sockhandle) +{ + tcp_listener_->ForceCloseClient(sockhandle); +} + +void IMListener::MarkClient(int sockhandle, bool is_active) +{ + tcp_listener_->MarkClient(sockhandle, is_active); +} diff --git a/server/groupserver/IMListener.h b/server/groupserver/IMListener.h new file mode 100644 index 0000000..e4f3224 --- /dev/null +++ b/server/groupserver/IMListener.h @@ -0,0 +1,38 @@ +#pragma once + +#include "framework/cpp/netmsghandler.h" + +//imserver listener +namespace a8 +{ + class TcpListener; +} + +class IMListener : public a8::Singleton +{ + private: + IMListener() {}; + friend class a8::Singleton; + + public: + void Init(); + void UnInit(); + + template + void SendMsg(int sockhandle, T& msg) + { + static int msgid = f8::Net_GetMessageId(msg); + f8::Net_SendMsg(tcp_listener_, sockhandle, 0, msgid, msg); + #ifdef DEBUG + f8::DumpMsgToLog(msg, "<<<<<< +#include +#include +#include +#include + +#include +#include +#include + +#include "framework/cpp/netmsghandler.h" + +#include "app.h" +#include "jsondatamgr.h" +#include "handlermgr.h" +#include "IMListener.h" +#include "perfmonitor.h" + +#include "ss_msgid.pb.h" +#include "ss_proto.pb.h" + +#include "framework/cpp/msgqueue.h" +#include "framework/cpp/tglog.h" + +struct MsgNode +{ + SocketFrom_e sockfrom; + int sockhandle; + unsigned short msgid; + unsigned int seqid; + long ip_saddr; + char* buf; + int buflen; + MsgNode* next; +}; + +struct IMMsgNode +{ + unsigned short msgid; + a8::XParams params; + IMMsgNode* next = nullptr; + +}; + +const char* const PROJ_LOG_ROOT_FMT = "/data/logs/%s/logs"; +const char* const PROJ_LOG_FILENAME_FMT = "log_$pid_%Y%m%d.log"; + +void App::Init(int argc, char* argv[]) +{ + signal(SIGPIPE, SIG_IGN); + this->argc = argc; + this->argv = argv; + + if (!ParseOpt()) { + terminated = true; + if (instance_id <= 0) { + a8::XPrintf("friend_groupserver启动失败,缺少-i参数\n", {}); + } else if (instance_id > MAX_INSTANCE_ID) { + a8::XPrintf("friend_groupserver启动失败,-i参数不能大于%d\n", {MAX_INSTANCE_ID}); + } + return; + } + a8::XPrintf("groupserver starting instance_id:%d pid:%d\n", {instance_id, getpid()}); + + loop_mutex_ = new std::mutex(); + loop_cond_ = new std::condition_variable(); + msg_mutex_ = new std::mutex(); + im_msg_mutex_ = new std::mutex(); + + srand(time(nullptr)); + InitLog(); + HandlerMgr::Instance()->Init(); + a8::Timer::Instance()->Init(); + PerfMonitor::Instance()->Init(); + f8::MsgQueue::Instance()->Init(); + f8::TGLog::Instance()->Init(a8::Format(PROJ_NAME_FMT, {}), false); + JsonDataMgr::Instance()->Init(); + uuid.SetMachineId(instance_id); + IMListener::Instance()->Init(); + + a8::UdpLog::Instance()->Info("groupserver starting instance_id:%d pid:%d", {instance_id, getpid()}); +} + +void App::UnInit() +{ + if (terminated) { + return; + } + IMListener::Instance()->UnInit(); + JsonDataMgr::Instance()->UnInit(); + f8::MsgQueue::Instance()->UnInit(); + PerfMonitor::Instance()->UnInit(); + a8::Timer::Instance()->UnInit(); + HandlerMgr::Instance()->UnInit(); + f8::TGLog::Instance()->UnInit(); + UnInitLog(); + + A8_SAFE_DELETE(im_msg_mutex_); + A8_SAFE_DELETE(msg_mutex_); + A8_SAFE_DELETE(loop_cond_); + A8_SAFE_DELETE(loop_mutex_); +} + +int App::Run() +{ + if (terminated) { + return 0; + } + int ret = 0; + a8::UdpLog::Instance()->Info("groupserver running", {}); + last_run_tick_ = a8::XGetTickCount(); + int delta_time = 0; + while (!terminated) { + a8::tick_t begin_tick = a8::XGetTickCount(); + nowtime = time(nullptr); + QuickExecute(delta_time); + SlowerExecute(delta_time); + Schedule(); + a8::tick_t end_tick = a8::XGetTickCount(); + if (end_tick - begin_tick > PerfMonitor::Instance()->max_run_delay_time) { + PerfMonitor::Instance()->max_run_delay_time = end_tick - begin_tick; + } + delta_time = end_tick - begin_tick; + } + return ret; +} + +void App::AddSocketMsg(SocketFrom_e sockfrom, + int sockhandle, + long ip_saddr, + unsigned short msgid, + unsigned int seqid, + const char *msgbody, + int bodylen) +{ + MsgNode *p = (MsgNode*) malloc(sizeof(MsgNode)); + memset(p, 0, sizeof(MsgNode)); + p->sockfrom = sockfrom; + p->ip_saddr = ip_saddr; + p->sockhandle = sockhandle; + p->msgid = msgid; + p->seqid = seqid; + p->buf = nullptr; + p->buflen = bodylen; + if (bodylen > 0) { + p->buf = (char*)malloc(bodylen); + memmove(p->buf, msgbody, bodylen); + } + msg_mutex_->lock(); + if (bot_node_) { + bot_node_->next = p; + bot_node_ = p; + } else { + top_node_ = p; + bot_node_ = p; + } + ++msgnode_size_; + msg_mutex_->unlock(); + NotifyLoopCond(); +} + +void App::AddIMMsg(unsigned short imcmd, a8::XParams params) +{ + IMMsgNode *p = new IMMsgNode; + p->msgid = imcmd; + p->params = params; + p->next = nullptr; + im_msg_mutex_->lock(); + if (im_bot_node_) { + im_bot_node_->next = p; + im_bot_node_ = p; + } else { + im_top_node_ = p; + im_bot_node_ = p; + } + im_msg_mutex_->unlock(); + NotifyLoopCond(); +} + +void App::QuickExecute(int delta_time) +{ + ProcessIMMsg(); + DispatchMsg(); + a8::Timer::Instance()->Update(); +} + +void App::SlowerExecute(int delta_time) +{ +} + +void App::NotifyLoopCond() +{ + std::unique_lock lk(*loop_mutex_); + loop_cond_->notify_all(); +} + +void App::Schedule() +{ + #if 1 + { + std::unique_lock lk(*loop_mutex_); + loop_cond_->wait_for(lk, std::chrono::milliseconds(1)); + } + #else + std::unique_lock lk(*loop_mutex_); + if (!HasTask()) { + int sleep_time = a8::Timer::Instance()->GetIdleableMillSeconds(); + loop_cond_->wait_for(lk, std::chrono::milliseconds(sleep_time)); + if (sleep_time > perf.max_timer_idle) { + perf.max_timer_idle = sleep_time; + } + } + #endif +} + +bool App::HasTask() +{ + { + if (!im_work_node_) { + im_msg_mutex_->lock(); + if (!im_work_node_ && im_top_node_) { + im_work_node_ = im_top_node_; + im_top_node_ = nullptr; + im_bot_node_ = nullptr; + } + im_msg_mutex_->unlock(); + } + if (im_work_node_) { + return true; + } + } + { + if (!work_node_) { + msg_mutex_->lock(); + if (!work_node_ && top_node_) { + work_node_ = top_node_; + top_node_ = nullptr; + bot_node_ = nullptr; + } + msg_mutex_->unlock(); + } + if (work_node_) { + return true; + } + } + return false; +} + +void App::DispatchMsg() +{ + long long starttick = a8::XGetTickCount(); + if (!work_node_ && top_node_) { + msg_mutex_->lock(); + work_node_ = top_node_; + top_node_ = nullptr; + bot_node_ = nullptr; + working_msgnode_size_ = msgnode_size_; + msg_mutex_->unlock(); + } + + f8::MsgHdr hdr; + while (work_node_) { + MsgNode *pdelnode = work_node_; + work_node_ = pdelnode->next; + hdr.msgid = pdelnode->msgid; + hdr.seqid = pdelnode->seqid; + hdr.socket_handle = pdelnode->sockhandle; + hdr.buf = pdelnode->buf; + hdr.buflen = pdelnode->buflen; + hdr.offset = 0; + hdr.ip_saddr = pdelnode->ip_saddr; + switch (pdelnode->sockfrom) { + case SF_IMServer: + { + ProcessIMServerMsg(hdr); + } + break; + } + if (pdelnode->buf) { + free(pdelnode->buf); + } + free(pdelnode); + working_msgnode_size_--; + if (a8::XGetTickCount() - starttick > 200) { + break; + } + }//end while + + if (!work_node_) { + working_msgnode_size_ = 0; + } +} + +void App::ProcessIMServerMsg(f8::MsgHdr& hdr) +{ + f8::NetMsgHandler* handler = f8::GetNetMsgHandler(&HandlerMgr::Instance()->immsghandler, + hdr.msgid); + if (handler) { + #ifdef DEBUG + f8::DumpMsgToLog(hdr, handler, ">>>>>>IMS "); + #endif + } +} + +void App::ProcessIMMsg() +{ + if (!im_work_node_ && im_top_node_) { + im_msg_mutex_->lock(); + im_work_node_ = im_top_node_; + im_top_node_ = nullptr; + im_bot_node_ = nullptr; + im_msg_mutex_->unlock(); + } + while (im_work_node_) { + IMMsgNode *pdelnode = im_work_node_; + switch (im_work_node_->msgid) { + case f8::IM_SysMsgQueue: + { + const a8::XParams* param = (const a8::XParams*)pdelnode->params.param1.GetUserData(); + f8::MsgQueue::Instance()->ProcessMsg(pdelnode->params.sender.GetInt(), + *param + ); + delete param; + } + break; + case IM_ClientSocketDisconnect: + { + #if 0 + PlayerMgr::Instance()->OnClientDisconnect(pdelnode->params); + #endif + } + break; + case IM_IMSSocketDisconnect: + { + } + break; + case IM_ExecGM: + { + HandlerMgr::Instance()->ProcGMMsg(pdelnode->params.param3, + pdelnode->params.sender, + pdelnode->params.param1.GetString(), + pdelnode->params.param2.GetString() + ); + } + break; + } + im_work_node_ = im_work_node_->next; + delete pdelnode; + } +} + +void App::InitLog() +{ + std::string filename_fmt = PROJ_LOG_FILENAME_FMT; + a8::ReplaceString(filename_fmt, "$pid", a8::XValue(getpid())); + + std::string proj_root_dir = a8::Format(PROJ_ROOT_FMT, {a8::Format(PROJ_NAME_FMT,{})}); + std::string proj_log_root_dir = a8::Format(PROJ_LOG_ROOT_FMT, {a8::Format(PROJ_NAME_FMT, {})}); + std::string log_file_name = a8::Format(PROJ_LOG_ROOT_FMT, + {a8::Format(PROJ_NAME_FMT, {})}) + "/" + filename_fmt; + + a8::MkDir(proj_root_dir); + a8::MkDir(proj_log_root_dir); + a8::UdpLog::Instance()->SetLogFileName(log_file_name); + a8::UdpLog::Instance()->Init(); + a8::UdpLog::Instance()->Info("proj_root_dir:%s", {proj_root_dir}); + a8::UdpLog::Instance()->Info("proj_log_root_dir:%s", {proj_log_root_dir}); + a8::UdpLog::Instance()->Info("log_file_name:%s", {log_file_name}); +} + +void App::UnInitLog() +{ + a8::UdpLog::Instance()->UnInit(); +} + +bool App::ParseOpt() +{ + int ch = 0; + while ((ch = getopt(argc, argv, "n:i:t:r:f:")) != -1) { + switch (ch) { + case 'i': + { + instance_id = a8::XValue(optarg); + } + break; + case 't': + { + is_test_mode = true; + test_param = a8::XValue(optarg); + } + break; + case 'f': + { + std::vector strings; + a8::Split(optarg, strings, ','); + for (auto& str : strings) { + flags.insert(a8::XValue(str).GetInt()); + } + } + break; + } + } + return instance_id > 0; +} + +long long App::NewUuid() +{ + return uuid.Generate(); +} + +a8::XParams* App::AddContext(long long context_id) +{ + context_hash_[context_id] = a8::XParams(); + return GetContext(context_id); +} + +void App::DelContext(long long context_id) +{ + context_hash_.erase(context_id); +} + +a8::XParams* App::GetContext(long long context_id) +{ + auto itr = context_hash_.find(context_id); + return itr != context_hash_.end() ? &(itr->second) : nullptr; +} diff --git a/server/groupserver/app.h b/server/groupserver/app.h new file mode 100644 index 0000000..26963ab --- /dev/null +++ b/server/groupserver/app.h @@ -0,0 +1,86 @@ +#pragma once + +#include + +struct MsgNode; +struct IMMsgNode; +class App : public a8::Singleton +{ +private: + App() {}; + friend class a8::Singleton; + +public: + + void Init(int argc, char* argv[]); + void UnInit(); + + int Run(); + + void AddSocketMsg(SocketFrom_e sockfrom, + int sockhandle, + long ip_saddr, + unsigned short msgid, + unsigned int seqid, + const char *msgbody, + int bodylen); + void AddIMMsg(unsigned short imcmd, a8::XParams params); + + void NotifyLoopCond(); + + long long NewUuid(); + a8::XParams* AddContext(long long context_id); + void DelContext(long long context_id); + a8::XParams* GetContext(long long context_id); + +private: + void QuickExecute(int delta_time); + void SlowerExecute(int delta_time); + void Schedule(); + bool HasTask(); + + void DispatchMsg(); + void ProcessIMMsg(); + + void ProcessIMServerMsg(f8::MsgHdr& hdr); + + void InitLog(); + void UnInitLog(); + + bool ParseOpt(); + +public: + int argc = 0; + char** argv = nullptr; + volatile bool terminated = false; + a8::uuid::SnowFlake uuid; + time_t nowtime = 0; + +public: + int instance_id = 0; + bool is_test_mode = false; + int test_param = 0; + std::set flags; + +private: + long long last_run_tick_ = 0; + std::mutex *loop_mutex_ = nullptr; + std::condition_variable *loop_cond_ = nullptr; + + std::mutex *msg_mutex_ = nullptr; + MsgNode* top_node_ = nullptr; + MsgNode* bot_node_ = nullptr; + MsgNode* work_node_ = nullptr; + + std::mutex* im_msg_mutex_ = nullptr; + IMMsgNode* im_top_node_ = nullptr; + IMMsgNode* im_bot_node_ = nullptr; + IMMsgNode* im_work_node_ = nullptr; + + std::map context_hash_; + +public: + int msgnode_size_ = 0 ; + int working_msgnode_size_ = 0; + +}; diff --git a/server/groupserver/constant.h b/server/groupserver/constant.h new file mode 100755 index 0000000..193ac75 --- /dev/null +++ b/server/groupserver/constant.h @@ -0,0 +1,27 @@ +#pragma once + +enum SocketFrom_e +{ + SF_IMServer, +}; + +enum InnerMesssage_e +{ + IM_ClientSocketDisconnect = 100, + IM_IMSSocketDisconnect, + IM_ExecGM, + IM_HttpResponse, +}; + +//网络处理对象 +enum NetHandler_e +{ + HID_IMSMgr, +}; + +const char* const PROJ_NAME_FMT = "friend_groupserver"; +const char* const PROJ_ROOT_FMT = "/data/logs/%s"; + +const float TEN_W = 10000 * 10; + +const int MAX_INSTANCE_ID = 1023; diff --git a/server/groupserver/handlermgr.cc b/server/groupserver/handlermgr.cc new file mode 100644 index 0000000..84fca45 --- /dev/null +++ b/server/groupserver/handlermgr.cc @@ -0,0 +1,81 @@ +#include "precompile.h" + +#include + +#include "handlermgr.h" + +#include "app.h" +#include "IMListener.h" +#include "perfmonitor.h" + +static void _GMOpsSelfChecking(f8::JsonHttpRequest* request) +{ + request->resp_xobj->SetVal("errcode", 0); + request->resp_xobj->SetVal("errmsg", ""); + request->resp_xobj->SetVal("healthy", 1); + request->resp_xobj->SetVal("max_rundelay", PerfMonitor::Instance()->max_run_delay_time); + request->resp_xobj->SetVal("max_timer_idle", PerfMonitor::Instance()->max_timer_idle); +} + +static void _GMOpsReload(f8::JsonHttpRequest* request) +{ + request->resp_xobj->SetVal("errcode", 0); + request->resp_xobj->SetVal("errmsg", ""); + a8::UdpLog::Instance()->Warning("reload config files", {}); +} + +void HandlerMgr::Init() +{ + RegisterNetMsgHandlers(); + RegisterGMMsgHandler("Ops@selfChecking", _GMOpsSelfChecking); + RegisterGMMsgHandler("Ops@reload", _GMOpsReload); +} + +void HandlerMgr::UnInit() +{ +} + +void HandlerMgr::RegisterNetMsgHandlers() +{ +} + +void HandlerMgr::ProcGMMsg(unsigned long saddr, int sockhandle, + const std::string& url, const std::string& querystr) +{ + if (url != "/webapp/index.php") { + IMListener::Instance()->SendText(sockhandle, a8::HttpResponse(404, "")); + return; + } + + a8::HTTPRequest request; + a8::ParserUrlQueryString(querystr.c_str(), request); + + std::string msgname = a8::Get(request, "c").GetString() + "@" + a8::Get(request, "a").GetString(); + auto itr = gmhandlers_.find(msgname); + if (itr != gmhandlers_.end()) { + f8::JsonHttpRequest* request = new f8::JsonHttpRequest; + request->saddr = saddr; + request->socket_handle = sockhandle; + request->query_str = querystr; + request->request.ReadFromUrlQueryString(querystr); + request->resp_xobj->SetVal("errcode", 0); + request->resp_xobj->SetVal("errmsg", ""); + itr->second(request); + + if (!request->pending){ + std::string response; + request->resp_xobj->ToJsonStr(response); + IMListener::Instance()->SendText(sockhandle, a8::HttpResponse(response)); + + delete request; + } + } else { + IMListener::Instance()->SendText(sockhandle, a8::HttpResponse("{}")); + } +} + +void HandlerMgr::RegisterGMMsgHandler(const std::string& msgname, + void (*handler)(f8::JsonHttpRequest*)) +{ + gmhandlers_[msgname] = handler; +} diff --git a/server/groupserver/handlermgr.h b/server/groupserver/handlermgr.h new file mode 100644 index 0000000..4b9fc01 --- /dev/null +++ b/server/groupserver/handlermgr.h @@ -0,0 +1,36 @@ +#pragma once + +#include + +#include "framework/cpp/netmsghandler.h" + +namespace a8 +{ + class MutableXObject; +} + +class HandlerMgr : public a8::Singleton +{ + + private: + HandlerMgr() {}; + friend class a8::Singleton; + + public: + + void Init(); + void UnInit(); + + f8::NetMsgHandlerObject wsmsghandler; + f8::NetMsgHandlerObject immsghandler; + + void ProcGMMsg(unsigned long saddr, int sockhandle, + const std::string& url, const std::string& quyerstr); + + private: + void RegisterNetMsgHandlers(); + void RegisterGMMsgHandler(const std::string& msgname, + void (*)(f8::JsonHttpRequest*)); + + std::map gmhandlers_; +}; diff --git a/server/groupserver/jsondatamgr.cc b/server/groupserver/jsondatamgr.cc new file mode 100644 index 0000000..bcbfe25 --- /dev/null +++ b/server/groupserver/jsondatamgr.cc @@ -0,0 +1,50 @@ +#include "precompile.h" + +#include "jsondatamgr.h" +#include "app.h" + +#include "framework/cpp/utils.h" + +void JsonDataMgr::Init() +{ + std::string masterserver_cluster_json_file; + if (!f8::IsOnlineEnv()) { + if (f8::IsTestEnv()) { + work_path_ = a8::Format("/root/pub/%d/%d/conf_test/game%d/masterserver.test", + { + GAME_ID, + App::Instance()->instance_id, + GAME_ID + }); + } else { + work_path_ = a8::Format("/root/pub/%d/%d/conf_test/game%d/masterserver.dev", + { + GAME_ID, + App::Instance()->instance_id, + GAME_ID + }); + } + } + masterserver_cluster_json_file = a8::Format("%s/node1/game9003.masterserver.cluster.json", + { + work_path_, + }); + masterserver_cluster_json_.ReadFromFile(masterserver_cluster_json_file); +} + +void JsonDataMgr::UnInit() +{ +} + +std::shared_ptr JsonDataMgr::GetConf() +{ + if (App::Instance()->instance_id < 1 || App::Instance()->instance_id > masterserver_cluster_json_.Size()) { + abort(); + } + return masterserver_cluster_json_[App::Instance()->instance_id - 1]; +} + +int JsonDataMgr::GetMasterSvrNum() +{ + return masterserver_cluster_json_.Size(); +} diff --git a/server/groupserver/jsondatamgr.h b/server/groupserver/jsondatamgr.h new file mode 100644 index 0000000..a7ae5e7 --- /dev/null +++ b/server/groupserver/jsondatamgr.h @@ -0,0 +1,22 @@ +#pragma once + +class JsonDataMgr : public a8::Singleton +{ + private: + JsonDataMgr() {}; + friend class a8::Singleton; + + public: + void Init(); + void UnInit(); + + std::shared_ptr GetConf(); + int GetMasterSvrNum(); + + std::string ip; + int listen_port = 0; + + private: + std::string work_path_ = "../config"; + a8::XObject masterserver_cluster_json_; +}; diff --git a/server/groupserver/main.cc b/server/groupserver/main.cc new file mode 100644 index 0000000..7dffbf1 --- /dev/null +++ b/server/groupserver/main.cc @@ -0,0 +1,11 @@ +#include "precompile.h" +#include "app.h" + +int main(int argc, char* argv[]) +{ + int exitcode = 0; + App::Instance()->Init(argc, argv); + exitcode = App::Instance()->Run(); + App::Instance()->UnInit(); + return exitcode; +} diff --git a/server/groupserver/perfmonitor.cc b/server/groupserver/perfmonitor.cc new file mode 100644 index 0000000..42123fa --- /dev/null +++ b/server/groupserver/perfmonitor.cc @@ -0,0 +1,64 @@ +#include "precompile.h" + +#include +#include + +#include "perfmonitor.h" +#include "app.h" + +static void SavePerfLog() +{ + a8::UdpLog::Instance()->Info + ("max_run_delay_time:%d max_timer_idle:%d " + "in_data_size:%d out_data_size:%d msgnode_size:%d " + "cache_friend_num:%d alloc_node_total_times:%d alloc_node_ok_times:%d " + "alloc_node_fail_times:%d " , + { + PerfMonitor::Instance()->max_run_delay_time, + PerfMonitor::Instance()->max_timer_idle, + PerfMonitor::Instance()->in_data_size, + PerfMonitor::Instance()->out_data_size, + App::Instance()->msgnode_size_, + PerfMonitor::Instance()->read_count, + PerfMonitor::Instance()->alloc_node_total_times, + PerfMonitor::Instance()->alloc_node_ok_times, + PerfMonitor::Instance()->alloc_node_fail_times + }); + a8::UdpLog::Instance()->Info + ("run_times:%d timer_times:%d event_times:%d free_times:%d " + "shutdown_times:%d connect_times:%d close_times:%d " + "send_times:%d recv_times:%d error_times:%d immsg_times:%d", + { + (long long)a8::IoLoop::Instance()->run_times, + (long long)a8::IoLoop::Instance()->timer_times, + (long long)a8::IoLoop::Instance()->event_times, + (long long)a8::IoLoop::Instance()->free_times, + (long long)a8::IoLoop::Instance()->shutdown_times, + (long long)a8::IoLoop::Instance()->connect_times, + (long long)a8::IoLoop::Instance()->close_times, + (long long)a8::IoLoop::Instance()->send_times, + (long long)a8::IoLoop::Instance()->recv_times, + (long long)a8::IoLoop::Instance()->error_times, + (long long)a8::IoLoop::Instance()->immsg_times + }); + PerfMonitor::Instance()->max_run_delay_time = 0; + PerfMonitor::Instance()->max_timer_idle = 0; +} + +void PerfMonitor::Init() +{ + { + int perf_log_time = 1000 * 60 * 5; + a8::Timer::Instance()->AddRepeatTimer(perf_log_time, + a8::XParams(), + [] (const a8::XParams& param) + { + SavePerfLog(); + }); + } +} + +void PerfMonitor::UnInit() +{ + +} diff --git a/server/groupserver/perfmonitor.h b/server/groupserver/perfmonitor.h new file mode 100644 index 0000000..8c537e5 --- /dev/null +++ b/server/groupserver/perfmonitor.h @@ -0,0 +1,22 @@ +#pragma once + +class PerfMonitor : public a8::Singleton +{ + private: + PerfMonitor() {}; + friend class a8::Singleton; + + public: + int max_run_delay_time = 0; + int max_timer_idle = 0; + int max_dispatchmsg_time = 0; + long long out_data_size = 0; + long long in_data_size = 0; + long long read_count = 0; + long long alloc_node_total_times = 0; + long long alloc_node_ok_times = 0; + long long alloc_node_fail_times = 0; + + void Init(); + void UnInit(); +}; diff --git a/server/groupserver/precompile.h b/server/groupserver/precompile.h new file mode 100644 index 0000000..7846db5 --- /dev/null +++ b/server/groupserver/precompile.h @@ -0,0 +1,19 @@ +#pragma once + +#include +#include + +#include "constant.h" +#include "types.h" + +namespace google +{ + namespace protobuf + { + class Message; + } +} + +#include "framework/cpp/types.h" +#include "framework/cpp/utils.h" +#include "framework/cpp/protoutils.h" diff --git a/server/groupserver/typeconvert.cc b/server/groupserver/typeconvert.cc new file mode 100644 index 0000000..625fbad --- /dev/null +++ b/server/groupserver/typeconvert.cc @@ -0,0 +1,53 @@ +#include "precompile.h" + +#include "typeconvert.h" +#include "cs_proto.pb.h" +#include "ss_proto.pb.h" + +void TypeConvert::Convert(const cs::MFBaseUserData& base_data_pb, BaseUserData& base_data) +{ + base_data.account_id = base_data_pb.account_id(); + base_data.nickname = base_data_pb.nickname(); + base_data.avatar_url = base_data_pb.avatar_url(); + base_data.sex = base_data_pb.sex(); + base_data.online = base_data_pb._online(); + #if 0 + base_data.group_id = base_data_pb.group_id(); + #endif + base_data.user_value1 = base_data_pb.user_value1(); + base_data.user_value2 = base_data_pb.user_value2(); + base_data.user_value3 = base_data_pb.user_value3(); + base_data.base_data_version = base_data_pb.base_data_version(); +} + +void TypeConvert::Convert(const BaseUserData& base_data, cs::MFBaseUserData& base_data_pb) +{ + base_data_pb.set_account_id(base_data.account_id); + base_data_pb.set_nickname(base_data.nickname); + base_data_pb.set_avatar_url(base_data.avatar_url); + base_data_pb.set_sex(base_data.sex); + base_data_pb.set__online(base_data.online); + #if 0 + base_data_pb.set_group_id(base_data.group_id); + #endif + base_data_pb.set_user_value1(base_data.user_value1); + base_data_pb.set_user_value2(base_data.user_value2); + base_data_pb.set_user_value3(base_data.user_value3); + base_data_pb.set_base_data_version(base_data.base_data_version); +} + +void TypeConvert::Convert(const cs::MFUserTempCustomData& temp_custom_data_pb, + UserTempCustomData& temp_custom_data) +{ + temp_custom_data.value1 = temp_custom_data_pb.value1(); + temp_custom_data.value2 = temp_custom_data_pb.value2(); + temp_custom_data.value3 = temp_custom_data_pb.value3(); +} + +void TypeConvert::Convert(const UserTempCustomData& temp_custom_data, + cs::MFUserTempCustomData& temp_custom_data_pb) +{ + temp_custom_data_pb.set_value1(temp_custom_data.value1); + temp_custom_data_pb.set_value2(temp_custom_data.value2); + temp_custom_data_pb.set_value3(temp_custom_data.value3); +} diff --git a/server/groupserver/typeconvert.h b/server/groupserver/typeconvert.h new file mode 100644 index 0000000..8d8a89d --- /dev/null +++ b/server/groupserver/typeconvert.h @@ -0,0 +1,23 @@ +#pragma once + +namespace cs +{ + class MFBaseUserData; + class MFUserTempCustomData; +} + +namespace ss +{ + class MFBaseUserDataDB; +} + +class TypeConvert +{ + public: + static void Convert(const cs::MFBaseUserData& base_data_pb, BaseUserData& base_data); + static void Convert(const BaseUserData& base_data, cs::MFBaseUserData& base_data_pb); + static void Convert(const cs::MFUserTempCustomData& temp_custom_data_pb, + UserTempCustomData& temp_custom_data); + static void Convert(const UserTempCustomData& temp_custom_data, + cs::MFUserTempCustomData& temp_custom_data_pb); +}; diff --git a/server/groupserver/types.cc b/server/groupserver/types.cc new file mode 100644 index 0000000..981bc36 --- /dev/null +++ b/server/groupserver/types.cc @@ -0,0 +1,3 @@ +#include "precompile.h" + + diff --git a/server/groupserver/types.h b/server/groupserver/types.h new file mode 100755 index 0000000..8d7f0fe --- /dev/null +++ b/server/groupserver/types.h @@ -0,0 +1,41 @@ +#pragma once + +struct BaseUserData +{ + std::string account_id; + std::string nickname; + std::string avatar_url; + int sex = 0; + int online = 0; + long long group_id = 0; + + long long user_value1 = 0; + long long user_value2 = 0; + long long user_value3 = 0; + + long long base_data_version = 0; +}; + +struct UserTempCustomData +{ + long long value1 = 0; + long long value2 = 0; + long long value3 = 0; +}; + +struct Friend +{ + BaseUserData base_data; + UserTempCustomData temp_custom_data; + + long long last_active_tick = 0; + list_head cache_entry; + list_head human_entry; + struct SvrNode* svr_node = nullptr; + + Friend() + { + INIT_LIST_HEAD(&human_entry); + INIT_LIST_HEAD(&cache_entry); + } +};