server_common/wsproxy
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add SendStockMsg

Browse Source
This commit is contained in:
aozhiwei 2019-05-17 15:01:42 +08:00
parent 0442ea3ece
commit cacc618c2c
10 changed files with 106 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
server/wsproxy/app.cc
View File

@ -362,7 +362,7 @@ void App::ProcessClientMsg(f8::MsgHdr& hdr)
ss::SS_CMLogin_CMReConnect_CommonHead msg;
bool ok = msg.ParseFromArray(hdr.buf + hdr.offset, hdr.buflen - hdr.offset);
if (ok) {
conn = TargetConnMgr::Instance()->GetConnByInstanceId(msg.server_id());
conn = TargetConnMgr::Instance()->GetConnById(msg.server_id());
if (!conn) {
ss::SS_SMRpcError respmsg;
respmsg.set_error_code(10);
@ -420,6 +420,15 @@ void App::ProcessIMMsg()
MasterSvrMgr::Instance()->OnClientDisconnect(pdelnode->params);
}
break;
case IM_TargetConnConnect:
{
GameClientMgr::Instance()->OnTargetServerDisconnect(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);

3
server/wsproxy/constant.h
View File

@ -13,7 +13,8 @@ enum InnerMesssage_e
IM_PlayerOffline,
IM_ExecGM,
IM_TargetConnDisconnect,
IM_MasterSvrDisconnect
IM_MasterSvrDisconnect,
IM_TargetConnConnect,
};
//网络处理对象

7
server/wsproxy/gameclientmgr.cc
View File

@ -44,6 +44,11 @@ void GameClientMgr::OnTargetServerDisconnect(a8::XParams& param)
}
}
void GameClientMgr::OnTargetServerConnect(a8::XParams& param)
{
}
GameClient* GameClientMgr::GetGameClientBySocket(int sockhandle)
{
auto itr = socket_hash_.find(sockhandle);
@ -54,7 +59,7 @@ GameClient* GameClientMgr::GetGameClientBySocket(int sockhandle)
#else
void GameClientMgr::BindTargetConn(int socket_handle, int conn_instance_id)
{
TargetConn* conn = TargetConnMgr::Instance()->GetConnByInstanceId(conn_instance_id);
TargetConn* conn = TargetConnMgr::Instance()->GetConnById(conn_instance_id);
if (conn) {
GameClient* client = GetGameClientBySocket(socket_handle);
if (client) {

1
server/wsproxy/gameclientmgr.h
View File

@ -14,6 +14,7 @@ class GameClientMgr : public a8::Singleton<GameClientMgr>
void OnClientDisconnect(a8::XParams& param);
void OnTargetServerDisconnect(a8::XParams& param);
void OnTargetServerConnect(a8::XParams& param);
GameClient* GetGameClientBySocket(int sockhande);
#if MASTER_MODE
#else

10
server/wsproxy/mastersvrmgr.cc
View File

@ -6,6 +6,8 @@
#include "mastersvr.h"
#include "jsondatamgr.h"
#include "ss_proto.pb.h"
#include "target_conn.h"
#include "target_conn_mgr.h"
#include "framework/cpp/netmsghandler.h"
@ -37,8 +39,12 @@ void MasterSvrMgr::_SS_MS_ResponseTargetServer(f8::MsgHdr& hdr, const ss::SS_MS_
f8::MsgHdr* context_hdr = GetHdr(msg.context_id());
if (context_hdr) {
if (msg.error_code() == 0) {
std::string key = msg.host() + ":" + a8::XValue(msg.port()).GetString();
TargetConn* conn = TargetConnMgr::Instance()->GetConnByKey(key);
if (conn) {
}
}
pending_request_hash_.erase(msg.context_id());
pending_socket_hash_.erase(hdr.socket_handle);
@ -49,7 +55,7 @@ void MasterSvrMgr::_SS_MS_ResponseTargetServer(f8::MsgHdr& hdr, const ss::SS_MS_
}
}
MasterSvr* MasterSvrMgr::GetConnByInstanceId(int instance_id)
MasterSvr* MasterSvrMgr::GetConnById(int instance_id)
{
auto itr = mastersvr_hash_.find(instance_id);
return itr != mastersvr_hash_.end() ? itr->second : nullptr;
@ -61,7 +67,7 @@ void MasterSvrMgr::RequestTargetServer(f8::MsgHdr& hdr, const std::string& team_
return;
}
unsigned int code = a8::openssl::Crc32((unsigned char*)team_id.data(), team_id.size());
MasterSvr* svr = GetConnByInstanceId(code % mastersvr_hash_.size() + 1);
MasterSvr* svr = GetConnById(code % mastersvr_hash_.size() + 1);
if (svr) {
++curr_context_id_;
ss::SS_WSP_RequestTargetServer msg;

2
server/wsproxy/mastersvrmgr.h
View File

@ -32,7 +32,7 @@ class MasterSvrMgr : public a8::Singleton<MasterSvrMgr>
private:
long long GetConextId(int socket_handle);
f8::MsgHdr* GetHdr(long long conext_id);
MasterSvr* GetConnByInstanceId(int instance_id);
MasterSvr* GetConnById(int instance_id);
private:
long long curr_context_id_ = 0;

45
server/wsproxy/target_conn.cc
View File

@ -39,6 +39,17 @@ void TargetConn::Init(int instance_id, const std::string& remote_ip, int remote_
void TargetConn::UnInit()
{
TargetConnMsgNode* work_node;
work_node = top_node_;
top_node_ = nullptr;
bot_node_ = nullptr;
while (work_node) {
TargetConnMsgNode* pdelnode = work_node;
work_node = work_node->next_node;
delete pdelnode->msg;
delete pdelnode;
}
a8::Timer::Instance()->DeleteTimer(timer_);
timer_ = nullptr;
tcp_client_->Close();
@ -64,6 +75,22 @@ bool TargetConn::Connected()
return tcp_client_->Connected();
}
void TargetConn::SendStockMsg()
{
TargetConnMsgNode* work_node;
work_node = top_node_;
top_node_ = nullptr;
bot_node_ = nullptr;
while (work_node) {
TargetConnMsgNode* pdelnode = work_node;
work_node = work_node->next_node;
f8::Net_SendProxyCMsg(tcp_client_, pdelnode->msgid, *pdelnode->msg);
delete pdelnode->msg;
delete pdelnode;
}
}
void TargetConn::ForwardClientMsg(f8::MsgHdr& hdr)
{
char* buff = (char*)malloc(sizeof(f8::WSProxyPackHead_C) + hdr.buflen);
@ -95,6 +122,10 @@ void TargetConn::on_connect(a8::TcpClient* sender)
{
recv_bufflen_ = 0;
a8::UdpLog::Instance()->Info("target server connected", {});
App::Instance()->AddIMMsg(IM_TargetConnDisconnect,
a8::XParams()
.SetSender(instance_id)
);
}
void TargetConn::on_disconnect(a8::TcpClient* sender)
@ -170,3 +201,17 @@ void TargetConn::CheckAlive()
}
}
}
void TargetConn::AddStockMsg(int msgid, ::google::protobuf::Message* msg)
{
TargetConnMsgNode* node = new TargetConnMsgNode();
node->msgid = msgid;
node->msg = msg;
if (bot_node_) {
bot_node_->next_node = node;
bot_node_ = node;
} else {
top_node_ = node;
bot_node_ = node;
}
}

23
server/wsproxy/target_conn.h
View File

@ -7,6 +7,14 @@ namespace a8
class TcpClient;
}
struct TargetConnMsgNode
{
int msgid = 0;
::google::protobuf::Message* msg = nullptr;
TargetConnMsgNode* next_node = nullptr;
};
struct timer_list;
class TargetConn
{
@ -14,7 +22,6 @@ class TargetConn
int instance_id = 0;
std::string remote_ip;
int remote_port = 0;
int matching_player_num = 0;
a8::tick_t last_pong_tick = 0;
public:
@ -29,9 +36,19 @@ class TargetConn
void SendMsg(T& msg)
{
static int msgid = f8::Net_GetMessageId(msg);
if (Connected()) {
if (top_node_) {
SendStockMsg();
}
f8::Net_SendProxyCMsg(tcp_client_, msgid, msg);
} else {
T* new_msg = new T();
*new_msg = msg;
AddStockMsg(msgid, new_msg);
}
}
void SendStockMsg();
void ForwardClientMsg(f8::MsgHdr& hdr);
private:
@ -41,10 +58,14 @@ class TargetConn
void on_socketread(a8::TcpClient* sender, char* buf, unsigned int len);
void CheckAlive();
void AddStockMsg(int msgid, ::google::protobuf::Message* msg);
private:
char *recv_buff_ = nullptr;
unsigned int recv_bufflen_ = 0;
a8::TcpClient* tcp_client_ = nullptr;
timer_list* timer_ = nullptr;
TargetConnMsgNode* top_node_ = nullptr;
TargetConnMsgNode* bot_node_ = nullptr;
};

15
server/wsproxy/target_conn_mgr.cc
View File

@ -28,16 +28,15 @@ void TargetConnMgr::UnInit()
{
}
#if MASTER_MODE
TargetConn* TargetConnMgr::GetConnByKey(const std::string& key)
{
auto itr = target_conn_hash_.find(key);
return itr != target_conn_hash_.end() ? itr->second : nullptr;
auto itr = key_hash_.find(key);
return itr != key_hash_.end() ? itr->second : nullptr;
}
#else
TargetConn* TargetConnMgr::GetConnByInstanceId(int instance_id)
TargetConn* TargetConnMgr::GetConnById(int instance_id)
{
auto itr = target_conn_hash_.find(instance_id);
return itr != target_conn_hash_.end() ? itr->second : nullptr;
auto itr = id_hash_.find(instance_id);
return itr != id_hash_.end() ? itr->second : nullptr;
}
#endif

12
server/wsproxy/target_conn_mgr.h
View File

@ -12,17 +12,11 @@ class TargetConnMgr : public a8::Singleton<TargetConnMgr>
void Init();
void UnInit();
#if MASTER_MODE
TargetConn* GetConnByKey(const std::string& key);
#else
TargetConn* GetConnByInstanceId(int instance_id);
#endif
TargetConn* GetConnById(int instance_id);
private:
#if MASTER_MODE
std::map<std::string, TargetConn*> target_conn_hash_;
#else
std::map<int, TargetConn*> target_conn_hash_;
#endif
std::map<std::string, TargetConn*> key_hash_;
std::map<int, TargetConn*> id_hash_;
};