add SendStockMsg

server/wsproxy/app.cc

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

server/wsproxy/constant.h

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

server/wsproxy/gameclientmgr.cc

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

server/wsproxy/gameclientmgr.h

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

server/wsproxy/mastersvrmgr.cc

@@ -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,7 +39,11 @@ 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());
@@ -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;

server/wsproxy/mastersvrmgr.h

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

server/wsproxy/target_conn.cc

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

server/wsproxy/target_conn.h

@@ -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);
-        f8::Net_SendProxyCMsg(tcp_client_, msgid, 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;
 };

server/wsproxy/target_conn_mgr.cc

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

server/wsproxy/target_conn_mgr.h

@@ -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* GetConnById(int instance_id);
-    TargetConn* GetConnByInstanceId(int instance_id);
-#endif
 
  private:
 
-#if MASTER_MODE
+    std::map<std::string, TargetConn*> key_hash_;
-    std::map<std::string, TargetConn*> target_conn_hash_;
+    std::map<int, TargetConn*> id_hash_;
-#else
-    std::map<int, TargetConn*> target_conn_hash_;
-#endif
 };