server/relation
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1

Browse Source
This commit is contained in:
aozhiwei 2020-09-18 15:04:08 +08:00
parent 454949d110
commit c7095d6ea8
18 changed files with 1241 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

125
server/groupserver/CMakeLists.txt Normal file
View File

@ -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()

112
server/groupserver/IMListener.cc Normal file
View File

@ -0,0 +1,112 @@
#include "precompile.h"
#include <google/protobuf/message.h>
#include <a8/mixedsession.h>
#include <a8/tcplistener.h>
#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);
}

38
server/groupserver/IMListener.h Normal file
View File

@ -0,0 +1,38 @@
#pragma once
#include "framework/cpp/netmsghandler.h"
//imserver listener
namespace a8
{
class TcpListener;
}
class IMListener : public a8::Singleton<IMListener>
{
private:
IMListener() {};
friend class a8::Singleton<IMListener>;
public:
void Init();
void UnInit();
template <typename T>
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, "<<<<<<<IML ");
#endif
}
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;
};

428
server/groupserver/app.cc Executable file
View File

@ -0,0 +1,428 @@
#include "precompile.h"
#include <signal.h>
#include <string.h>
#include <unistd.h>
#include <mutex>
#include <condition_variable>
#include <a8/redis.h>
#include <a8/timer.h>
#include <a8/uuid.h>
#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<std::mutex> lk(*loop_mutex_);
loop_cond_->notify_all();
}
void App::Schedule()
{
#if 1
{
std::unique_lock<std::mutex> lk(*loop_mutex_);
loop_cond_->wait_for(lk, std::chrono::milliseconds(1));
}
#else
std::unique_lock<std::mutex> 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<std::string> 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;
}

86
server/groupserver/app.h Normal file
View File

@ -0,0 +1,86 @@
#pragma once
#include <a8/uuid.h>
struct MsgNode;
struct IMMsgNode;
class App : public a8::Singleton<App>
{
private:
App() {};
friend class a8::Singleton<App>;
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<int> 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<long long, a8::XParams> context_hash_;
public:
int msgnode_size_ = 0 ;
int working_msgnode_size_ = 0;
};

27
server/groupserver/constant.h Executable file
View File

@ -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;

81
server/groupserver/handlermgr.cc Normal file
View File

@ -0,0 +1,81 @@
#include "precompile.h"
#include <a8/mutable_xobject.h>
#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;
}

36
server/groupserver/handlermgr.h Normal file
View File

@ -0,0 +1,36 @@
#pragma once
#include <a8/basehttpsession.h>
#include "framework/cpp/netmsghandler.h"
namespace a8
{
class MutableXObject;
}
class HandlerMgr : public a8::Singleton<HandlerMgr>
{
private:
HandlerMgr() {};
friend class a8::Singleton<HandlerMgr>;
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<std::string, void (*)(f8::JsonHttpRequest*)> gmhandlers_;
};

50
server/groupserver/jsondatamgr.cc Normal file
View File

@ -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<a8::XObject> 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();
}

22
server/groupserver/jsondatamgr.h Normal file
View File

@ -0,0 +1,22 @@
#pragma once
class JsonDataMgr : public a8::Singleton<JsonDataMgr>
{
private:
JsonDataMgr() {};
friend class a8::Singleton<JsonDataMgr>;
public:
void Init();
void UnInit();
std::shared_ptr<a8::XObject> GetConf();
int GetMasterSvrNum();
std::string ip;
int listen_port = 0;
private:
std::string work_path_ = "../config";
a8::XObject masterserver_cluster_json_;
};

11
server/groupserver/main.cc Normal file
View File

@ -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;
}

64
server/groupserver/perfmonitor.cc Normal file
View File

@ -0,0 +1,64 @@
#include "precompile.h"
#include <a8/timer.h>
#include <a8/ioloop.h>
#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()
{
}

22
server/groupserver/perfmonitor.h Normal file
View File

@ -0,0 +1,22 @@
#pragma once
class PerfMonitor : public a8::Singleton<PerfMonitor>
{
private:
PerfMonitor() {};
friend class a8::Singleton<PerfMonitor>;
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();
};

19
server/groupserver/precompile.h Normal file
View File

@ -0,0 +1,19 @@
#pragma once
#include <a8/a8.h>
#include <a8/udplog.h>
#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"

53
server/groupserver/typeconvert.cc Normal file
View File

@ -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);
}

23
server/groupserver/typeconvert.h Normal file
View File

@ -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);
};

3
server/groupserver/types.cc Normal file
View File

@ -0,0 +1,3 @@
#include "precompile.h"

41
server/groupserver/types.h Executable file
View File

@ -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);
}
};