From cc568e71384fbc637dc2670a12841575d849c406 Mon Sep 17 00:00:00 2001 From: aozhiwei Date: Sat, 7 Sep 2019 22:54:01 +0800 Subject: [PATCH] add gameserver --- server/gameserver/CMakeLists.txt | 10 +- server/gameserver/GCListener.cc | 112 +++++++ server/gameserver/GCListener.h | 33 ++ server/gameserver/app.cc | 436 +++++++++++++++++++++++++ server/gameserver/app.h | 85 +++++ server/gameserver/constant.h | 22 ++ server/gameserver/error_code.h | 13 + server/gameserver/global.cc | 16 + server/gameserver/global.h | 15 + server/gameserver/handlermgr.cc | 80 +++++ server/gameserver/handlermgr.h | 35 ++ server/gameserver/jsondatamgr.cc | 51 +++ server/gameserver/jsondatamgr.h | 19 ++ server/gameserver/main.cc | 11 + server/gameserver/precompile.h | 21 ++ server/gameserver/types.cc | 3 + server/gameserver/types.h | 10 + server/tools/protobuild/cs_msgid.proto | 14 + server/tools/protobuild/cs_proto.proto | 35 ++ 19 files changed, 1013 insertions(+), 8 deletions(-) create mode 100644 server/gameserver/GCListener.cc create mode 100644 server/gameserver/GCListener.h create mode 100755 server/gameserver/app.cc create mode 100644 server/gameserver/app.h create mode 100755 server/gameserver/constant.h create mode 100755 server/gameserver/error_code.h create mode 100755 server/gameserver/global.cc create mode 100755 server/gameserver/global.h create mode 100644 server/gameserver/handlermgr.cc create mode 100644 server/gameserver/handlermgr.h create mode 100644 server/gameserver/jsondatamgr.cc create mode 100644 server/gameserver/jsondatamgr.h create mode 100644 server/gameserver/main.cc create mode 100644 server/gameserver/precompile.h create mode 100644 server/gameserver/types.cc create mode 100755 server/gameserver/types.h create mode 100644 server/tools/protobuild/cs_msgid.proto create mode 100755 server/tools/protobuild/cs_proto.proto diff --git a/server/gameserver/CMakeLists.txt b/server/gameserver/CMakeLists.txt index a04d277..a3842c6 100644 --- a/server/gameserver/CMakeLists.txt +++ b/server/gameserver/CMakeLists.txt @@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 2.8) set(GAME_ID 9502) set(CMAKE_BUILD_TYPE "Debug") -set(CMAKE_BUILD_TYPE "Release") +#set(CMAKE_BUILD_TYPE "Release") set(CMAKE_CXX_FLAGS_RELEASE "-O3 -g -std=gnu++11 -DGAME_ID=${GAME_ID}") set(CMAKE_CXX_FLAGS_DEBUG "-Wall -g -std=gnu++11 -DGAME_ID=${GAME_ID}") @@ -38,12 +38,6 @@ execute_process( COMMAND touch -a cs_proto.pb.cc COMMAND touch -a cs_msgid.pb.h COMMAND touch -a cs_msgid.pb.cc - 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 metatable.pb.h - COMMAND touch -a metatable.pb.cc ) aux_source_directory(. SRC_LIST @@ -60,7 +54,7 @@ add_executable( 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=cs_proto,cs_msgid,ss_proto,ss_msgid,metatable --python_out=../tools/robot/virtualclient + COMMAND python ../../third_party/tools/scripts/construct/build_pb.py --cpp_out=. --pb_files=cs_proto,cs_msgid ) add_dependencies(gameserver script_pb_protocol) diff --git a/server/gameserver/GCListener.cc b/server/gameserver/GCListener.cc new file mode 100644 index 0000000..08a5664 --- /dev/null +++ b/server/gameserver/GCListener.cc @@ -0,0 +1,112 @@ +#include "precompile.h" + +#include +#include +#include + +#include "framework/cpp/netmsghandler.h" + +#include "app.h" +#include "GCListener.h" +#include "jsondatamgr.h" +#include "handlermgr.h" + +class GGClientSession: 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_GameClient, + 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("收到client非法数据包", {}); + } + } + + 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_ClientSocketDisconnect, + a8::XParams() + .SetSender(socket_handle) + .SetParam1(1)); + } + +}; + +static void CreateGameClientSocket(a8::TcpSession **p) +{ + *p = new GGClientSession(); +} + +static void GSListeneron_error(a8::TcpListener*, int type, int errorid) +{ + a8::UdpLog::Instance()->Debug("GCListeneron_error %d %d", {type, errorid}); +} + +void GCListener::Init() +{ + tcp_listener_ = new a8::TcpListener(); + tcp_listener_->on_create_client_socket = CreateGameClientSocket; + tcp_listener_->on_error = GSListeneron_error; + + tcp_listener_->bind_address = "0.0.0.0"; + tcp_listener_->bind_port = JsonDataMgr::Instance()->GetConf()->At("listen_port")->AsXValue(); + tcp_listener_->Open(); +} + +void GCListener::UnInit() +{ + delete tcp_listener_; + tcp_listener_ = nullptr; +} + +void GCListener::SendText(int sockhandle, const std::string& text) +{ + tcp_listener_->SendClientMsg(sockhandle, text.data(), text.size()); +} + +void GCListener::ForceCloseClient(int sockhandle) +{ + tcp_listener_->ForceCloseClient(sockhandle); +} + +void GCListener::MarkClient(int sockhandle, bool is_active) +{ + tcp_listener_->MarkClient(sockhandle, is_active); +} diff --git a/server/gameserver/GCListener.h b/server/gameserver/GCListener.h new file mode 100644 index 0000000..2cab5b6 --- /dev/null +++ b/server/gameserver/GCListener.h @@ -0,0 +1,33 @@ +#pragma once + +//game client listener +namespace a8 +{ + class TcpListener; +} + +class GCListener : public a8::Singleton +{ + private: + GCListener() {}; + 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); + } + + void SendText(int sockhandle, const std::string& text); + + void ForceCloseClient(int sockhandle); + void MarkClient(int sockhandle, bool is_active); + + private: + a8::TcpListener *tcp_listener_ = nullptr; +}; diff --git a/server/gameserver/app.cc b/server/gameserver/app.cc new file mode 100755 index 0000000..4b5a5dd --- /dev/null +++ b/server/gameserver/app.cc @@ -0,0 +1,436 @@ +#include "precompile.h" + +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "framework/cpp/netmsghandler.h" + +#include "app.h" +#include "jsondatamgr.h" +#include "handlermgr.h" +#include "GCListener.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"; + +static void SavePerfLog() +{ + a8::UdpLog::Instance()->Info("max_mainloop_rundelay:%d", + { + App::Instance()->perf.max_run_delay_time, + }); + App::Instance()->perf.max_run_delay_time = 0; + App::Instance()->perf.max_timer_idle = 0; +} + +void App::Init(int argc, char* argv[]) +{ + #if 0 + { + Vector2D dir; + dir.Normalize(); + } + #endif + signal(SIGPIPE, SIG_IGN); + this->argc = argc; + this->argv = argv; + + if (!ParseOpt()) { + terminated = true; + if (instance_id <= 0) { + a8::XPrintf("gameserver启动失败,缺少-i参数\n", {}); + } + return; + } + a8::XPrintf("masterserver starting instance_id:%d pid:%d game_id:%d\n", {instance_id, getpid(), GAME_ID}); + + 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(); + f8::MsgQueue::Instance()->Init(); + f8::TGLog::Instance()->Init(a8::Format(PROJ_NAME_FMT, {GAME_ID}), false); + JsonDataMgr::Instance()->Init(); + uuid.SetMachineId(instance_id); + GCListener::Instance()->Init(); + + a8::UdpLog::Instance()->Info("masterserver starting instance_id:%d pid:%d", {instance_id, getpid()}); + { + int perf_log_time = 1000 * 60 * 5; + if (getenv("is_dev_env")) { + perf_log_time = 1000 * 10; + } + a8::Timer::Instance()->AddRepeatTimer(perf_log_time, + a8::XParams(), + [] (const a8::XParams& param) + { + SavePerfLog(); + }); + } +} + +void App::UnInit() +{ + if (terminated) { + return; + } + GCListener::Instance()->UnInit(); + JsonDataMgr::Instance()->UnInit(); + f8::MsgQueue::Instance()->UnInit(); + a8::Timer::Instance()->UnInit(); + HandlerMgr::Instance()->UnInit(); + f8::TGLog::Instance()->UnInit(); + UnInitLog(); + + delete im_msg_mutex_; + im_msg_mutex_ = nullptr; + delete msg_mutex_; + msg_mutex_ = nullptr; + delete loop_cond_; + loop_cond_ = nullptr; + delete loop_mutex_; + loop_mutex_ = nullptr; +} + +int App::Run() +{ + if (terminated) { + return 0; + } + int ret = 0; + a8::UdpLog::Instance()->Info("masterserver running", {}); + last_run_tick_ = a8::XGetTickCount(); + int delta_time = 0; + while (!terminated) { + a8::tick_t begin_tick = a8::XGetTickCount(); + Global::g_nowtime = time(nullptr); + QuickExecute(delta_time); + SlowerExecute(delta_time); + Schedule(); + a8::tick_t end_tick = a8::XGetTickCount(); + if (end_tick - begin_tick > perf.max_run_delay_time) { + perf.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_GameClient: + { + } + 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::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_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,{GAME_ID})}); + std::string proj_log_root_dir = a8::Format(PROJ_LOG_ROOT_FMT, {a8::Format(PROJ_NAME_FMT, {GAME_ID})}); + std::string log_file_name = a8::Format(PROJ_LOG_ROOT_FMT, + {a8::Format(PROJ_NAME_FMT, {GAME_ID})}) + "/" + 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 && node_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/gameserver/app.h b/server/gameserver/app.h new file mode 100644 index 0000000..1ea9ed1 --- /dev/null +++ b/server/gameserver/app.h @@ -0,0 +1,85 @@ +#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 InitLog(); + void UnInitLog(); + + bool ParseOpt(); + +public: + int argc = 0; + char** argv = nullptr; + volatile bool terminated = false; + PerfMonitor perf; + a8::uuid::SnowFlake uuid; + +public: + int node_id = 0; + 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/gameserver/constant.h b/server/gameserver/constant.h new file mode 100755 index 0000000..439cd4a --- /dev/null +++ b/server/gameserver/constant.h @@ -0,0 +1,22 @@ +#pragma once + +enum SocketFrom_e +{ + SF_GameClient, +}; + +enum InnerMesssage_e +{ + IM_ClientSocketDisconnect = 100, + IM_ExecGM, + IM_HttpResponse, +}; + +//网络处理对象 +enum NetHandler_e +{ + HID_GSMgr, +}; + +const char* const PROJ_NAME_FMT = "game%d_gameserver"; +const char* const PROJ_ROOT_FMT = "/data/logs/%s"; diff --git a/server/gameserver/error_code.h b/server/gameserver/error_code.h new file mode 100755 index 0000000..35ec63e --- /dev/null +++ b/server/gameserver/error_code.h @@ -0,0 +1,13 @@ +#pragma once + +/* + 类似http的错误码设计 + 0：成功 + <400: 客户端的错 + >500: 服务器的错 +*/ +enum ErrorCode_e +{ + ERRNO_OK = 0, + +}; diff --git a/server/gameserver/global.cc b/server/gameserver/global.cc new file mode 100755 index 0000000..0e96f26 --- /dev/null +++ b/server/gameserver/global.cc @@ -0,0 +1,16 @@ +#include "precompile.h" +#include "global.h" + +time_t Global::BetweenDays(time_t time1, time_t time2) +{ + return (time1 + g_time_zone*3600)/3600/24 - (time2 + g_time_zone*3600)/3600/24; +} + +time_t Global::GetDaySeconds(time_t time, int incdays) +{ + return time_t((time + g_time_zone * 3600)/3600/24 + incdays) * 3600 * 24 - 3600 * g_time_zone; +} + +int Global::g_nowtime = time(nullptr); +int Global::g_time_zone = 8; +bool Global::g_shutdown = false; diff --git a/server/gameserver/global.h b/server/gameserver/global.h new file mode 100755 index 0000000..e82bf2c --- /dev/null +++ b/server/gameserver/global.h @@ -0,0 +1,15 @@ +#pragma once + +class Global : public a8::Singleton +{ + private: + Global() {}; + friend class a8::Singleton; + public: + static time_t BetweenDays(time_t time1, time_t time2); + static time_t GetDaySeconds(time_t time, int incdays = 0); + + static int g_nowtime; + static int g_time_zone; // 默认东八区 + static bool g_shutdown; +}; diff --git a/server/gameserver/handlermgr.cc b/server/gameserver/handlermgr.cc new file mode 100644 index 0000000..f63aa13 --- /dev/null +++ b/server/gameserver/handlermgr.cc @@ -0,0 +1,80 @@ +#include "precompile.h" + +#include + +#include "handlermgr.h" + +#include "GCListener.h" +#include "app.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", App::Instance()->perf.max_run_delay_time); + request->resp_xobj->SetVal("max_timer_idle", App::Instance()->perf.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") { + GCListener::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); + GCListener::Instance()->SendText(sockhandle, a8::HttpResponse(response)); + + delete request; + } + } else { + GCListener::Instance()->SendText(sockhandle, a8::HttpResponse("{}")); + } +} + +void HandlerMgr::RegisterGMMsgHandler(const std::string& msgname, + void (*handler)(f8::JsonHttpRequest*)) +{ + gmhandlers_[msgname] = handler; +} diff --git a/server/gameserver/handlermgr.h b/server/gameserver/handlermgr.h new file mode 100644 index 0000000..2bf21b8 --- /dev/null +++ b/server/gameserver/handlermgr.h @@ -0,0 +1,35 @@ +#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 ggmsghandler; + + 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/gameserver/jsondatamgr.cc b/server/gameserver/jsondatamgr.cc new file mode 100644 index 0000000..55deb8d --- /dev/null +++ b/server/gameserver/jsondatamgr.cc @@ -0,0 +1,51 @@ +#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 (App::Instance()->flags.find(2) != App::Instance()->flags.end()) { + masterserver_cluster_json_file = a8::Format("/root/pub/%d/%d/conf_test/game%d/masterserver/node%d/" + "game%d.masterserver.cluster.json", + { + GAME_ID, + App::Instance()->instance_id, + GAME_ID, + App::Instance()->node_id, + GAME_ID + }); + } else { + masterserver_cluster_json_file = a8::Format("/var/data/conf_test/game%d/masterserver/node%d/" + "game%d.masterserver.cluster.json", + { + GAME_ID, + App::Instance()->node_id, + GAME_ID + }); + } + } else { + masterserver_cluster_json_file = a8::Format("../config/node%d/game%d.masterserver.cluster.json", + { + App::Instance()->node_id, + GAME_ID + }); + } + 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]; +} diff --git a/server/gameserver/jsondatamgr.h b/server/gameserver/jsondatamgr.h new file mode 100644 index 0000000..ce10f2e --- /dev/null +++ b/server/gameserver/jsondatamgr.h @@ -0,0 +1,19 @@ +#pragma once + +class JsonDataMgr : public a8::Singleton +{ + private: + JsonDataMgr() {}; + friend class a8::Singleton; + + public: + void Init(); + void UnInit(); + + std::shared_ptr GetConf(); + + std::string ip; + int listen_port = 0; + private: + a8::XObject masterserver_cluster_json_; +}; diff --git a/server/gameserver/main.cc b/server/gameserver/main.cc new file mode 100644 index 0000000..7dffbf1 --- /dev/null +++ b/server/gameserver/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/gameserver/precompile.h b/server/gameserver/precompile.h new file mode 100644 index 0000000..49c2658 --- /dev/null +++ b/server/gameserver/precompile.h @@ -0,0 +1,21 @@ +#pragma once + +#include +#include + +#include "constant.h" +#include "types.h" +#include "error_code.h" +#include "global.h" + +namespace google +{ + namespace protobuf + { + class Message; + } +} + +#include "framework/cpp/types.h" +#include "framework/cpp/protoutils.h" + diff --git a/server/gameserver/types.cc b/server/gameserver/types.cc new file mode 100644 index 0000000..981bc36 --- /dev/null +++ b/server/gameserver/types.cc @@ -0,0 +1,3 @@ +#include "precompile.h" + + diff --git a/server/gameserver/types.h b/server/gameserver/types.h new file mode 100755 index 0000000..1467ba7 --- /dev/null +++ b/server/gameserver/types.h @@ -0,0 +1,10 @@ +#pragma once + +struct PerfMonitor +{ + int max_run_delay_time = 0; + int max_timer_idle = 0; + long long out_data_size = 0; + long long in_data_size = 0; + long long read_count = 0; +}; diff --git a/server/tools/protobuild/cs_msgid.proto b/server/tools/protobuild/cs_msgid.proto new file mode 100644 index 0000000..0595eb5 --- /dev/null +++ b/server/tools/protobuild/cs_msgid.proto @@ -0,0 +1,14 @@ +package ss; + +//消息id定义 +enum SSMessageId_e +{ + _SS_Ping = 8; + _SS_Pong = 9; + + _SS_WSP_SocketDisconnect = 10; + _SS_WSP_RequestTargetServer = 11; + _SS_MS_ResponseTargetServer = 12; + _SS_ForceCloseSocket = 13; + +} diff --git a/server/tools/protobuild/cs_proto.proto b/server/tools/protobuild/cs_proto.proto new file mode 100755 index 0000000..be04905 --- /dev/null +++ b/server/tools/protobuild/cs_proto.proto @@ -0,0 +1,35 @@ +package ss; + +message SS_Ping +{ + +} + +message SS_Pong +{ + +} + +message SS_WSP_SocketDisconnect +{ +} + +message SS_WSP_RequestTargetServer +{ + optional int64 context_id = 1; + optional string account_id = 2; + optional string team_id = 3; +} + +message SS_MS_ResponseTargetServer +{ + optional int32 error_code = 1; + optional string error_msg = 2; + optional int64 context_id = 3; + optional string host = 4; + optional int32 port = 5; +} + +message SS_ForceCloseSocket +{ +}