641 lines
18 KiB
C++
641 lines
18 KiB
C++
#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 "GCListener.h"
|
|
#include "jsondatamgr.h"
|
|
#include "handlermgr.h"
|
|
#include "gameclient.h"
|
|
#include "gameclientmgr.h"
|
|
#include "ss_msgid.pb.h"
|
|
#include "ss_proto.pb.h"
|
|
|
|
#include "target_conn.h"
|
|
#include "target_conn_mgr.h"
|
|
#if MASTER_MODE
|
|
#include "mastersvr.h"
|
|
#include "mastersvrmgr.h"
|
|
#endif
|
|
|
|
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_run_delay_time:%d max_timer_idle:%d "
|
|
"in_data_size:%d out_data_size:%d msgnode_size:%d read_count:%d",
|
|
{
|
|
App::Instance()->perf.max_run_delay_time,
|
|
App::Instance()->perf.max_timer_idle,
|
|
App::Instance()->perf.in_data_size,
|
|
App::Instance()->perf.out_data_size,
|
|
App::Instance()->msgnode_size_,
|
|
App::Instance()->perf.read_count,
|
|
});
|
|
if (App::Instance()->HasFlag(2)) {
|
|
a8::XPrintf("mainloop_time:%d netmsg_time:%d send_node_num:%d sent_bytes_num:%d\n",
|
|
{
|
|
App::Instance()->perf.max_run_delay_time,
|
|
App::Instance()->perf.max_dispatchmsg_time,
|
|
GCListener::Instance()->GetSendNodeNum(),
|
|
GCListener::Instance()->GetSentBytesNum()
|
|
});
|
|
}
|
|
#if 1
|
|
App::Instance()->perf.max_run_delay_time = 0;
|
|
App::Instance()->perf.max_timer_idle = 0;
|
|
#else
|
|
App::Instance()->perf = PerfMonitor();
|
|
#endif
|
|
}
|
|
|
|
bool App::Init(int argc, char* argv[])
|
|
{
|
|
signal(SIGPIPE, SIG_IGN);
|
|
this->argc = argc;
|
|
this->argv = argv;
|
|
|
|
if (!ParseOpt()) {
|
|
terminated = true;
|
|
#if MASTER_MODE
|
|
if (node_id <= 0) {
|
|
a8::XPrintf("gameserver启动失败,缺少-n参数\n", {});
|
|
} else if (node_id > MAX_NODE_ID) {
|
|
a8::XPrintf("gameserver启动失败,-n参数不能大于%d\n", {MAX_NODE_ID});
|
|
} else if (instance_id <= 0) {
|
|
a8::XPrintf("gameserver启动失败,缺少-i参数\n", {});
|
|
} else if (instance_id > MAX_INSTANCE_ID) {
|
|
a8::XPrintf("gameserver启动失败,-i参数不能大于%d\n", {MAX_INSTANCE_ID});
|
|
}
|
|
#else
|
|
a8::XPrintf("wsproxy启动失败,缺少-i参数\n", {});
|
|
#endif
|
|
return false;
|
|
}
|
|
a8::XPrintf("wsproxy starting node_id:%d instance_id:%d pid:%d master_mode:%d\n",
|
|
{
|
|
node_id,
|
|
instance_id,
|
|
getpid(),
|
|
MASTER_MODE
|
|
});
|
|
|
|
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();
|
|
JsonDataMgr::Instance()->Init();
|
|
#if MASTER_MODE
|
|
uuid.SetMachineId((node_id - 1) * MAX_NODE_ID + instance_id);
|
|
#else
|
|
uuid.SetMachineId(instance_id);
|
|
#endif
|
|
GameClientMgr::Instance()->Init();
|
|
#if MASTER_MODE
|
|
MasterSvrMgr::Instance()->Init();
|
|
#endif
|
|
TargetConnMgr::Instance()->Init();
|
|
GCListener::Instance()->Init();
|
|
|
|
a8::UdpLog::Instance()->Info("wsproxy 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();
|
|
});
|
|
}
|
|
if (HasFlag(1)) {
|
|
a8::Timer::Instance()->AddDeadLineTimer(
|
|
1000 * 60,
|
|
a8::XParams(),
|
|
[] (const a8::XParams& param)
|
|
{
|
|
App::Instance()->terminated = true;
|
|
App::Instance()->NotifyLoopCond();
|
|
}
|
|
);
|
|
}
|
|
if (HasFlag(4)) {
|
|
a8::Timer::Instance()->AddDeadLineTimer(
|
|
1000 * 30,
|
|
a8::XParams(),
|
|
[] (const a8::XParams& param)
|
|
{
|
|
App::Instance()->shutdowned = true;
|
|
a8::XPrintf("shutdowned\n", {});
|
|
}
|
|
);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void App::UnInit()
|
|
{
|
|
a8::XPrintf("wsproxy terminating instance_id:%d pid:%d\n", {instance_id, getpid()});
|
|
GCListener::Instance()->UnInit();
|
|
#if MASTER_MODE
|
|
MasterSvrMgr::Instance()->UnInit();
|
|
#endif
|
|
TargetConnMgr::Instance()->UnInit();
|
|
GameClientMgr::Instance()->UnInit();
|
|
JsonDataMgr::Instance()->UnInit();
|
|
a8::Timer::Instance()->UnInit();
|
|
HandlerMgr::Instance()->UnInit();
|
|
UnInitLog();
|
|
|
|
FreeSocketMsgQueue();
|
|
FreeIMMsgQueue();
|
|
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;
|
|
a8::XPrintf("wsproxy terminated instance_id:%d pid:%d\n", {instance_id, getpid()});
|
|
}
|
|
|
|
int App::Run()
|
|
{
|
|
int ret = 0;
|
|
a8::UdpLog::Instance()->Info("wsproxy running", {});
|
|
while (!terminated) {
|
|
a8::tick_t begin_tick = a8::XGetTickCount();
|
|
QuickExecute();
|
|
SlowerExecute();
|
|
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;
|
|
}
|
|
Schedule();
|
|
}
|
|
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()
|
|
{
|
|
ProcessIMMsg();
|
|
DispatchMsg();
|
|
a8::Timer::Instance()->Update();
|
|
}
|
|
|
|
void App::SlowerExecute()
|
|
{
|
|
}
|
|
|
|
void App::NotifyLoopCond()
|
|
{
|
|
std::unique_lock<std::mutex> lk(*loop_mutex_);
|
|
loop_cond_->notify_all();
|
|
}
|
|
|
|
void App::Schedule()
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
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_Client:
|
|
{
|
|
ProcessClientMsg(hdr);
|
|
}
|
|
break;
|
|
case SF_TargetServer:
|
|
{
|
|
ProcessTargetServerMsg(hdr);
|
|
}
|
|
break;
|
|
case SF_MasterServer:
|
|
{
|
|
ProcessMasterServerMsg(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::ProcessClientMsg(f8::MsgHdr& hdr)
|
|
{
|
|
if (hdr.msgid < 100) {
|
|
return;
|
|
}
|
|
#if MASTER_MODE
|
|
if (hdr.msgid == ss::_SS_CMLogin || hdr.msgid == ss::_SS_CMReConnect) {
|
|
ss::SS_CMLogin_CMReConnect_CommonHead2 msg;
|
|
bool ok = msg.ParseFromArray(hdr.buf + hdr.offset, hdr.buflen - hdr.offset);
|
|
if (ok) {
|
|
MasterSvrMgr::Instance()->RequestTargetServer(hdr, msg.team_uuid(), msg.account_id());
|
|
}
|
|
} else {
|
|
GameClient* client = GameClientMgr::Instance()->GetGameClientBySocket(hdr.socket_handle);
|
|
if (client && client->conn) {
|
|
if (client->conn) {
|
|
client->conn->ForwardClientMsg(hdr);
|
|
}
|
|
}
|
|
}
|
|
#else
|
|
TargetConn* conn = nullptr;
|
|
if (hdr.msgid == ss::_SS_CMLogin || hdr.msgid == ss::_SS_CMReConnect) {
|
|
ss::SS_CMLogin_CMReConnect_CommonHead msg;
|
|
bool ok = msg.ParseFromArray(hdr.buf + hdr.offset, hdr.buflen - hdr.offset);
|
|
if (ok) {
|
|
conn = TargetConnMgr::Instance()->GetConnById(msg.server_id());
|
|
if (!conn) {
|
|
ss::SS_SMRpcError respmsg;
|
|
respmsg.set_error_code(10);
|
|
GCListener::Instance()->SendMsg(hdr.socket_handle, respmsg);
|
|
}
|
|
} else {
|
|
return;
|
|
}
|
|
} else {
|
|
GameClient* client = GameClientMgr::Instance()->GetGameClientBySocket(hdr.socket_handle);
|
|
if (client) {
|
|
conn = client->conn;
|
|
}
|
|
}
|
|
if (conn) {
|
|
conn->ForwardClientMsg(hdr);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void App::ProcessMasterServerMsg(f8::MsgHdr& hdr)
|
|
{
|
|
#if MASTER_MODE
|
|
f8::NetMsgHandler* handler = f8::GetNetMsgHandler(&HandlerMgr::Instance()->msmsghandler,
|
|
hdr.msgid);
|
|
if (handler) {
|
|
switch (handler->handlerid) {
|
|
case HID_MasterSvrMgr:
|
|
ProcessNetMsg(handler, MasterSvrMgr::Instance(), hdr);
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void App::ProcessTargetServerMsg(f8::MsgHdr& hdr)
|
|
{
|
|
if (hdr.msgid == ss::_SS_ForceCloseSocket) {
|
|
GCListener::Instance()->ForceCloseClient(hdr.socket_handle);
|
|
return;
|
|
}
|
|
if (hdr.msgid < 100) {
|
|
return;
|
|
}
|
|
if (hdr.msgid == ss::_SS_CMLogin || hdr.msgid == ss::_SS_CMReConnect) {
|
|
GameClientMgr::Instance()->BindTargetConn(hdr.socket_handle, hdr.ip_saddr);
|
|
GCListener::Instance()->MarkClient(hdr.socket_handle, true);
|
|
}
|
|
GCListener::Instance()->ForwardTargetConnMsg(hdr);
|
|
}
|
|
|
|
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 IM_ClientSocketDisconnect:
|
|
{
|
|
GameClientMgr::Instance()->OnClientDisconnect(pdelnode->params);
|
|
#if MASTER_MODE
|
|
MasterSvrMgr::Instance()->RemoveRequest(pdelnode->params.param1, pdelnode->params.sender, true);
|
|
#endif
|
|
}
|
|
break;
|
|
case IM_TargetConnConnect:
|
|
{
|
|
GameClientMgr::Instance()->OnTargetServerConnect(pdelnode->params);
|
|
TargetConn* conn = TargetConnMgr::Instance()->GetConnById(pdelnode->params.sender);
|
|
if (conn && conn->Connected()) {
|
|
conn->SendStockMsg();
|
|
}
|
|
}
|
|
break;
|
|
case IM_TargetConnDisconnect:
|
|
{
|
|
GameClientMgr::Instance()->OnTargetServerDisconnect(pdelnode->params);
|
|
}
|
|
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:f:")) != -1) {
|
|
switch (ch) {
|
|
case 'n':
|
|
{
|
|
node_id = a8::XValue(optarg);
|
|
}
|
|
break;
|
|
case 'i':
|
|
{
|
|
instance_id = 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;
|
|
}
|
|
}
|
|
#if MASTER_MODE
|
|
return instance_id > 0 && node_id > 0;
|
|
#else
|
|
return instance_id > 0;
|
|
#endif
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
bool App::HasFlag(int flag)
|
|
{
|
|
return flags.find(flag) != flags.end();
|
|
}
|
|
|
|
void App::FreeSocketMsgQueue()
|
|
{
|
|
msg_mutex_->lock();
|
|
if (!work_node_) {
|
|
work_node_ = top_node_;
|
|
top_node_ = nullptr;
|
|
bot_node_ = nullptr;
|
|
}
|
|
while (work_node_) {
|
|
MsgNode* pdelnode = work_node_;
|
|
work_node_ = work_node_->next;
|
|
if (pdelnode->buf) {
|
|
free(pdelnode->buf);
|
|
}
|
|
free(pdelnode);
|
|
if (!work_node_) {
|
|
work_node_ = top_node_;
|
|
top_node_ = nullptr;
|
|
bot_node_ = nullptr;
|
|
}
|
|
}
|
|
msg_mutex_->unlock();
|
|
}
|
|
|
|
void App::FreeIMMsgQueue()
|
|
{
|
|
im_msg_mutex_->lock();
|
|
if (!im_work_node_) {
|
|
im_work_node_ = im_top_node_;
|
|
im_top_node_ = nullptr;
|
|
im_bot_node_ = nullptr;
|
|
}
|
|
while (im_work_node_) {
|
|
IMMsgNode* pdelnode = im_work_node_;
|
|
im_work_node_ = im_work_node_->next;
|
|
if (pdelnode->msgid == f8::IM_SysMsgQueue) {
|
|
a8::XParams* param = (a8::XParams*)pdelnode->params.param1.GetUserData();
|
|
delete param;
|
|
}
|
|
delete pdelnode;
|
|
if (!im_work_node_) {
|
|
im_work_node_ = im_top_node_;
|
|
im_top_node_ = nullptr;
|
|
im_bot_node_ = nullptr;
|
|
}
|
|
}
|
|
im_msg_mutex_->unlock();
|
|
}
|