game2006/server/gameserver/handlermgr.cc

#include "precompile.h"

#include <a8/mutable_xobject.h>

#include <f8/udplog.h>
#include <f8/msgqueue.h>
#include <f8/jsonhttprequest.h>

#include "handlermgr.h"

#include "GGListener.h"
#include "app.h"
#include "player.h"
#include "playermgr.h"
#include "roommgr.h"
#include "cs_proto.pb.h"
#include "ss_proto.pb.h"
#include "jsondatamgr.h"
#include "perfmonitor.h"

static void _GMOpsSelfChecking(std::shared_ptr<f8::JsonHttpRequest> request)
{
    request->GetResp()->SetVal("errcode", 0);
    request->GetResp()->SetVal("errmsg", "");
    request->GetResp()->SetVal("healthy", 1);
    request->GetResp()->SetVal("servicing", App::Instance()->IsServicing() ? 1 : 0);
    request->GetResp()->SetVal("max_rundelay", PerfMonitor::Instance()->max_run_delay_time);
    request->GetResp()->SetVal("max_timer_idle", PerfMonitor::Instance()->max_timer_idle);
}

static void _GMOpsStopService(std::shared_ptr<f8::JsonHttpRequest> request)
{
    request->GetResp()->SetVal("errcode", 0);
    request->GetResp()->SetVal("errmsg", "");
    App::Instance()->SetServicing(false);
}

static void _GMOpsStartService(std::shared_ptr<f8::JsonHttpRequest> request)
{
    request->GetResp()->SetVal("errcode", 0);
    request->GetResp()->SetVal("errmsg", "");
    App::Instance()->SetServicing(true);
}

static void _GMOpsServerInfo(std::shared_ptr<f8::JsonHttpRequest> request)
{
    request->GetResp()->SetVal("errcode", 0);
    request->GetResp()->SetVal("errmsg", "");
    request->GetResp()->SetVal("node_id", f8::App::Instance()->GetNodeId());
    request->GetResp()->SetVal("instance_id", f8::App::Instance()->GetInstanceId());
}

static void _GMOpsTerminate(std::shared_ptr<f8::JsonHttpRequest> request)
{
    request->GetResp()->SetVal("errcode", 0);
    request->GetResp()->SetVal("errmsg", "");
    f8::App::Instance()->Terminate();
}

static void _GMStatGetRealTimeOnline(std::shared_ptr<f8::JsonHttpRequest> request)
{
    request->GetResp()->SetVal("errcode", 0);
    request->GetResp()->SetVal("errmsg", "");
    request->GetResp()->SetVal("num", PerfMonitor::Instance()->entity_num[ET_Player]);
    request->GetResp()->SetVal("room_num", RoomMgr::Instance()->RoomNum());
}

void HandlerMgr::Init()
{
    RegisterNetMsgHandlers();
    RegisterGMMsgHandler("Ops@selfChecking", _GMOpsSelfChecking);
    RegisterGMMsgHandler("Ops@stopService", _GMOpsStopService);
    RegisterGMMsgHandler("Ops@startService", _GMOpsStartService);
    RegisterGMMsgHandler("Ops@serverInfo", _GMOpsServerInfo);
    RegisterGMMsgHandler("Ops@terminate", _GMOpsTerminate);
    RegisterGMMsgHandler("Stat@getRealTimeOnline", _GMStatGetRealTimeOnline);
    f8::MsgQueue::Instance()->RegisterCallBack
        (
         IM_ExecGM,
         [] (const a8::Args& args)
         {
             int socket_handle = args.Get<int>(0);
             std::string url = args.Get<std::string>(1);
             std::string query_str = args.Get<std::string>(2);
             unsigned long saddr = args.Get<unsigned long>(3);

             HandlerMgr::Instance()->ProcGMMsg
                 (
                  saddr,
                  socket_handle,
                  url,
                  query_str
                  );
         });
}

void HandlerMgr::UnInit()
{
}

void HandlerMgr::RegisterNetMsgHandlers()
{
    RegisterNetMsgHandler(&ggmsghandler, &PlayerMgr::_SS_WSP_SocketDisconnect);
    RegisterNetMsgHandler(&ggmsghandler, &PlayerMgr::_SS_Ping);
    RegisterNetMsgHandler(&ggmsghandler, &RoomMgr::_CMJoin);
    RegisterNetMsgHandler(&ggmsghandler, &RoomMgr::_CMReconnect);
    RegisterNetMsgHandler(&ggmsghandler, &RoomMgr::_CMPing);

    #if 0
    RegisterNetMsgHandler(&ggmsghandler, &MatchTeam::_CMMatchCancel);
    RegisterNetMsgHandler(&ggmsghandler, &MatchTeam::_CMMatchChoose);
    RegisterNetMsgHandler(&ggmsghandler, &MatchTeam::_CMMatchStartGame);
    RegisterNetMsgHandler(&ggmsghandler, &MatchTeam::_CMMatchCancelStartGame);
    RegisterNetMsgHandler(&ggmsghandler, &MatchTeam::_CMMatchSendMsg);
    RegisterNetMsgHandler(&ggmsghandler, &MatchTeam::_CMMatchBroadcastMsg);
    #endif

    RegisterNetMsgHandler(&ggmsghandler, &Player::_CMMove);
    RegisterNetMsgHandler(&ggmsghandler, &Player::_CMImmediateMsg);
    RegisterNetMsgHandler(&ggmsghandler, &Player::_CMExecCommand);
    RegisterNetMsgHandler(&ggmsghandler, &Player::_CMEmote);
    RegisterNetMsgHandler(&ggmsghandler, &Player::_CMVoice);
    RegisterNetMsgHandler(&ggmsghandler, &Player::_CMGameOver);
    RegisterNetMsgHandler(&ggmsghandler, &Player::_CMWatchWar);
    RegisterNetMsgHandler(&ggmsghandler, &Player::_CMLeave);
    RegisterNetMsgHandler(&ggmsghandler, &Player::_CMRevive);
    RegisterNetMsgHandler(&ggmsghandler, &Player::_CMCancelRevive);
    RegisterNetMsgHandler(&ggmsghandler, &Player::_CMRequestBulletDmg);
    RegisterNetMsgHandler(&ggmsghandler, &Player::_CMRequestThrowDmg);
    RegisterNetMsgHandler(&ggmsghandler, &Player::_CMStowShield);
    RegisterNetMsgHandler(&ggmsghandler, &Player::_CMTeamMarkTargetPos);
    RegisterNetMsgHandler(&ggmsghandler, &Player::_CMSetRevivePosition);
    RegisterNetMsgHandler(&ggmsghandler, &Player::_CMGetSettlementTeamList);
    RegisterNetMsgHandler(&ggmsghandler, &Player::_CMReportHookHitPos);
    RegisterNetMsgHandler(&ggmsghandler, &Player::_CMReportSpecShotHitPos);
    RegisterNetMsgHandler(&ggmsghandler, &Player::_CMWatchTarget);
    RegisterNetMsgHandler(&ggmsghandler, &Player::_CMTeamCommand);
}

void HandlerMgr::ProcGMMsg(unsigned long saddr, int sockhandle,
                           const std::string& url, const std::string& querystr)
{
    if (url != "/webapp/index.php") {
        GGListener::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()) {
        auto request = std::make_shared<f8::JsonHttpRequest>
            (
             saddr,
             url,
             querystr,
             [sockhandle] (const a8::Args& args)
             {
                 std::string data = args.Get<std::string>(0);
                 GGListener::Instance()->SendText(sockhandle, data);
             });
        itr->second(request);
    } else {
        GGListener::Instance()->SendText(sockhandle, a8::HttpResponse("{}"));
    }
}

void HandlerMgr::RegisterGMMsgHandler(const std::string& msgname,
                                      void (*handler)(std::shared_ptr<f8::JsonHttpRequest>))
{
    gmhandlers_[msgname] = handler;
}