diff --git a/server/masterserver/CMakeLists.txt b/server/masterserver/CMakeLists.txt
new file mode 100644
index 0000000..a0d0637
--- /dev/null
+++ b/server/masterserver/CMakeLists.txt
@@ -0,0 +1,75 @@
+project(masterserver)
+cmake_minimum_required(VERSION 2.8)
+
+if (${GAME_ID})
+  message(GAME_ID: ${GAME_ID})
+else()
+  set(GAME_ID 2001)
+  message(GAME_ID: ${GAME_ID})
+endif()
+
+set(CMAKE_BUILD_TYPE "Debug")
+set(CMAKE_CXX_FLAGS_RELEASE "-std=gnu++11 -fsanitize=address -fno-omit-frame-pointer")
+set(CMAKE_CXX_FLAGS_DEBUG "-Wall -g -std=gnu++11 -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
+  .
+)
+
+link_directories(
+  /usr/lib64/mysql
+  /usr/local/lib
+)
+
+aux_source_directory(../../third_party/a8engine/a8
+  SRC_LIST
+)
+
+aux_source_directory(../../third_party/framework/cpp
+  SRC_LIST
+)
+
+aux_source_directory(.
+  SRC_LIST
+)
+
+set(EXECUTABLE_OUTPUT_PATH
+  ${PROJECT_BINARY_DIR}/../bin
+)
+
+set_directory_properties(PROPERTIES COMPILE_DEFINITIONS_DEBUG "_DEBUG")
+
+add_executable(
+  masterserver ${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=cs_proto,cs_msgid,ss_proto,ss_msgid,metatable --python_out=../tools/robot/virtualclient
+)
+add_dependencies(masterserver script_pb_protocol)
+
+target_link_libraries(
+  masterserver
+  pthread
+  mysqlclient
+  protobuf
+  rt
+  dl
+  util
+  crypto
+  ssl
+  jsoncpp
+  curl
+  hiredis
+  tinyxml2
+)
diff --git a/server/masterserver/GGListener.cc b/server/masterserver/GGListener.cc
new file mode 100644
index 0000000..49d8920
--- /dev/null
+++ b/server/masterserver/GGListener.cc
@@ -0,0 +1,132 @@
+#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 "GGListener.h"
+#include "jsondatamgr.h"
+#include "cs_proto.pb.h"
+#include "cs_msgid.pb.h"
+#include "handlermgr.h"
+
+class GCClientSession: 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::WSProxyPackHead_C)) {
+            f8::WSProxyPackHead_C* p = (f8::WSProxyPackHead_C*)&buf[offset];
+            if (p->magic_code == f8::MAGIC_CODE) {
+                if (buflen - offset < sizeof(f8::WSProxyPackHead_C) + p->packlen) {
+                    break;
+                }
+                App::Instance()->AddSocketMsg(SF_GameGate,
+                                              (socket_handle << 16) + p->socket_handle,
+                                              saddr,
+                                              p->msgid,
+                                              p->seqid,
+                                              &buf[offset + sizeof(f8::WSProxyPackHead_C)],
+                                              p->packlen);
+                offset += sizeof(f8::WSProxyPackHead_C) + p->packlen;
+            } else {
+                warning = true;
+                offset++;
+                continue;
+            }
+        }
+
+        if (warning) {
+            a8::UdpLog::Instance()->Warning("收到client非法数据包", {});
+        }
+    }
+
+    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_ClientSocketDisconnect,
+                                  a8::XParams()
+                                  .SetSender(socket_handle)
+                                  .SetParam1(1));
+    }
+
+};
+
+static void CreateGameClientSocket(a8::TcpSession **p)
+{
+    *p = new GCClientSession();
+}
+
+static void GSListeneron_error(a8::TcpListener*, int type, int errorid)
+{
+    a8::UdpLog::Instance()->Debug("GGListeneron_error %d %d", {type, errorid});
+}
+
+void GGListener::Init()
+{
+    tcp_listener_ = new a8::TcpListener();
+    tcp_listener_->on_create_client_socket = CreateGameClientSocket;
+    tcp_listener_->on_error = GSListeneron_error;
+
+    tcp_listener_->bind_address = "0.0.0.0";
+    tcp_listener_->bind_port = JsonDataMgr::Instance()->GetConf()->At("listen_port")->AsXValue();
+    tcp_listener_->Open();
+}
+
+void GGListener::UnInit()
+{
+    delete tcp_listener_;
+    tcp_listener_ = nullptr;
+}
+
+void GGListener::SendText(int sockhandle, const std::string& text)
+{
+    tcp_listener_->SendClientMsg(sockhandle, text.data(), text.size());
+}
+
+void GGListener::SendError(int sockhandle, unsigned int seqid,
+                           int error_code, const std::string& error_msg,
+                           const char* file, int lineno, int error_param)
+{
+    cs::SMRpcError msg;
+    msg.set_error_code(error_code);
+    msg.set_error_msg(error_msg);
+    msg.set_debug_msg("");
+    if (file) {
+        msg.set_file(file);
+    } else {
+        msg.set_file("");
+    }
+    msg.set_lineno(lineno);
+    msg.set_error_param(error_param);
+    f8::Net_SendProxyMsg(tcp_listener_, sockhandle, seqid, error_code, cs::_SMRpcError, msg);
+}
+
+void GGListener::ForceCloseClient(int sockhandle)
+{
+    tcp_listener_->ForceCloseClient(sockhandle);
+}
+
+void GGListener::MarkClient(int sockhandle, bool is_active)
+{
+    tcp_listener_->MarkClient(sockhandle, is_active);
+}
diff --git a/server/masterserver/GGListener.h b/server/masterserver/GGListener.h
new file mode 100644
index 0000000..0819887
--- /dev/null
+++ b/server/masterserver/GGListener.h
@@ -0,0 +1,46 @@
+#pragma once
+
+//game client listener
+namespace a8
+{
+    class TcpListener;
+}
+
+class GGListener : public a8::Singleton<GGListener>
+{
+ private:
+    GGListener() {};
+    friend class a8::Singleton<GGListener>;
+
+ public:
+    enum { HID = HID_GGListener };
+
+ public:
+    void Init();
+    void UnInit();
+
+    template <typename T>
+    void SendProxyMsg(int sockhandle, T& msg)
+    {
+        static int msgid = f8::Net_GetMessageId(msg);
+        f8::Net_SendProxyMsg(tcp_listener_, sockhandle, 0, 0, msgid, msg);
+    }
+
+    template <typename T>
+    void SendToClient(int sockhandle, unsigned int seqid, T& msg)
+    {
+        static int msgid = f8::Net_GetMessageId(msg);
+        f8::Net_SendProxyMsg(tcp_listener_, sockhandle, seqid, 0, msgid, msg);
+    }
+    void SendText(int sockhandle, const std::string& text);
+
+    void SendError(int sockhandle, unsigned int seqid,
+                   int error_code, const std::string& error_msg,
+                   const char* file = nullptr, int lineno = 0, int error_param = 0);
+
+    void ForceCloseClient(int sockhandle);
+    void MarkClient(int sockhandle, bool is_active);
+
+ private:
+    a8::TcpListener *tcp_listener_ = nullptr;
+};
diff --git a/server/masterserver/app.cc b/server/masterserver/app.cc
new file mode 100755
index 0000000..bbc6052
--- /dev/null
+++ b/server/masterserver/app.cc
@@ -0,0 +1,467 @@
+#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 "ss_msgid.pb.h"
+#include "ss_proto.pb.h"
+
+#include "framework/cpp/msgqueue.h"
+#include "framework/cpp/tglog.h"
+#include "framework/cpp/httpclientpool.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";
+
+static void SavePerfLog()
+{
+    a8::UdpLog::Instance()->Info("max_mainloop_rundelay:%d room_num:%d",
+                                 {
+                                  App::Instance()->perf.max_run_delay_time,
+                                 });
+    App::Instance()->perf.max_run_delay_time = 0;
+    App::Instance()->perf.max_timer_idle = 0;
+    f8::HttpClientPool::Instance()->max_request_delay = 0;
+}
+
+void App::Init(int argc, char* argv[])
+{
+    #if 0
+    {
+        Vector2D dir;
+        dir.Normalize();
+    }
+    #endif
+    signal(SIGPIPE, SIG_IGN);
+    this->argc = argc;
+    this->argv = argv;
+
+    if (!ParseOpt()) {
+        terminated = true;
+        a8::XPrintf("masterserver启动失败,缺少-i参数\n", {});
+        return;
+    }
+    a8::XPrintf("masterserver starting instance_id:%d pid:%d game_id:%d\n", {instance_id, getpid(), GAME_ID});
+
+    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();
+    f8::MsgQueue::Instance()->Init();
+    f8::TGLog::Instance()->Init(a8::Format(PROJ_NAME_FMT, {GAME_ID}), false);
+    f8::HttpClientPool::Instance()->Init(10);
+    JsonDataMgr::Instance()->Init();
+    uuid.SetMachineId(instance_id);
+    #if 0
+    GGListener::Instance()->Init();
+    #endif
+
+    a8::UdpLog::Instance()->Info("masterserver 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();
+                                              });
+    }
+}
+
+void App::UnInit()
+{
+    if (terminated) {
+        return;
+    }
+    #if 0
+    GGListener::Instance()->Init();
+    #endif
+    JsonDataMgr::Instance()->UnInit();
+    f8::HttpClientPool::Instance()->UnInit();
+    f8::MsgQueue::Instance()->UnInit();
+    a8::Timer::Instance()->UnInit();
+    HandlerMgr::Instance()->UnInit();
+    f8::TGLog::Instance()->UnInit();
+    UnInitLog();
+
+    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;
+}
+
+int App::Run()
+{
+    if (terminated) {
+        return 0;
+    }
+    int ret = 0;
+    a8::UdpLog::Instance()->Info("masterserver running", {});
+    last_run_tick_ = a8::XGetTickCount();
+    int delta_time = 0;
+    while (!terminated) {
+        a8::tick_t begin_tick = a8::XGetTickCount();
+        Global::g_nowtime = time(nullptr);
+        QuickExecute(delta_time);
+        SlowerExecute(delta_time);
+        Schedule();
+        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;
+        }
+        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_GameGate:
+            {
+                ProcessGameGateMsg(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::ProcessGameGateMsg(f8::MsgHdr& hdr)
+{
+    if (hdr.msgid == ss::_SS_Ping) {
+        #if 0
+        ss::SS_Pong pongmsg;
+        GGListener::Instance()->SendProxyMsg(hdr.socket_handle, pongmsg);
+        #endif
+        return;
+    }
+    f8::NetMsgHandler* handler = f8::GetNetMsgHandler(&HandlerMgr::Instance()->ggmsghandler,
+                                                      hdr.msgid);
+    if (handler) {
+        switch (handler->handlerid) {
+        case HID_GGListener:
+            #if 0
+            ProcessNetMsg(handler, GGListener::Instance(), hdr);
+            #endif
+            break;
+        }
+    }
+}
+
+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_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, "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;
+}
diff --git a/server/masterserver/app.h b/server/masterserver/app.h
new file mode 100644
index 0000000..815c1d3
--- /dev/null
+++ b/server/masterserver/app.h
@@ -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 ProcessGameGateMsg(f8::MsgHdr& hdr);
+
+    void InitLog();
+    void UnInitLog();
+
+    bool ParseOpt();
+
+public:
+    int argc = 0;
+    char** argv = nullptr;
+    volatile bool terminated = false;
+    PerfMonitor perf;
+    a8::uuid::SnowFlake uuid;
+
+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;
+
+};
diff --git a/server/masterserver/constant.h b/server/masterserver/constant.h
new file mode 100755
index 0000000..cca524d
--- /dev/null
+++ b/server/masterserver/constant.h
@@ -0,0 +1,150 @@
+#pragma once
+
+enum SocketFrom_e
+{
+    SF_GameGate,
+};
+
+enum InnerMesssage_e
+{
+    IM_ClientSocketDisconnect  = 100,
+    IM_PlayerOffline,
+    IM_ExecGM,
+    IM_DBSConnDisconnect,
+    IM_BSConnDisconnect,
+    IM_LoadConfig,
+    IM_HttpResponse,
+};
+
+//网络处理对象
+enum NetHandler_e
+{
+    HID_Player,
+    HID_PlayerMgr,
+    HID_Room,
+    HID_RoomMgr,
+    HID_GGListener,
+};
+
+enum PlayerState_e
+{
+    PS_None
+};
+
+enum VirtualItemId_e
+{
+    VID_Item_Gold = 50001,
+    VID_Item_Exp = 50002,
+    VID_Soul_Stone = 50018,
+    VID_Pickaxe = 50019
+};
+
+enum SyncData_e
+{
+    SYNC_Data_Exp = 0,
+};
+
+enum DoorState_e
+{
+    DoorStateClose = 0,
+    DoorStateOpen = 1
+};
+
+enum GasMode_e
+{
+    GasInactive = 0,
+    GasWaiting = 1,
+    GasMoving = 2,
+    GasJump = 3
+};
+
+enum ActionType_e
+{
+    AT_None = 0,
+    AT_Reload = 1,
+    AT_UseItem = 2,
+    AT_Relive = 3,
+    AT_Rescue = 4
+};
+
+enum InventorySlot_e
+{
+    IS_9MM  = 0,
+    IS_556MM  = 1,
+    IS_762MM  = 2,
+    IS_12GAUGE  = 3,
+    IS_RPG  = 4,
+    IS_FRAG  = 5,
+    IS_SMOKE  = 6,
+    IS_HEALTHKIT  = 7,
+    IS_PAIN_KILLER  = 8,
+
+    IS_1XSCOPE  = 12,
+    IS_2XSCOPE  = 13,
+    IS_4XSCOPE  = 14,
+    IS_8XSCOPE  = 15,
+    IS_15XSCOPE = 16,
+
+    IS_END
+};
+
+enum SkillType_e
+{
+    ST_Hide = 1,
+    ST_SummonHero = 2,
+    ST_Accelerate = 3,
+    ST_DamageAdd = 4,
+    ST_DefAdd = 5,
+    ST_RecoverHP = 6,
+    ST_ReflectDamage = 7,
+    ST_SelfDetonate = 8
+};
+
+enum SkillCond_e
+{
+    SC_Active = 1,
+    SC_Passive = 2
+};
+
+enum VirtualWeapon_e
+{
+    VW_SafeArea = 9000000,
+    VW_Spectate = 9000001,
+    VW_SelfDetonate = 9000002,
+    VW_Mine = 9000003,
+};
+
+enum VirtualPlayer_e
+{
+    VP_SafeArea = 9000000,
+    VP_Spectate = 9000001,
+    VP_SelfDetonate = 9000002,
+    VP_Mine = 9000003,
+};
+
+const char* const PROJ_NAME_FMT = "game%d_gameserver";
+const char* const PROJ_ROOT_FMT = "/data/logs/%s";
+
+const float TEN_W = 10000 * 10;
+
+const int SYS_RESET_TIME = 2*60; //每日两点重置
+
+const int DEF_WEAPON_ID = 12103;
+
+const int SERVER_FRAME_RATE = 20;
+const int SYNC_FRAME_RATE = 10;
+const float FRAME_RATE_MS = 1000.0f / SERVER_FRAME_RATE;
+
+const int MAX_WEAPON_NUM = 5;
+
+const int GUN_SLOT1 = 1;
+const int GUN_SLOT2 = 2;
+
+const int FRAG_SLOT = 3;
+const int SMOKE_SLOT = 4;
+
+const int MAP_HEIGHT = 8192;
+const int MAP_WIDTH = 8192;
+const int MAP_CELL_WIDTH = 64 * 8;
+
+const int DOOR_THING_ID = 61701;
diff --git a/server/masterserver/error_code.h b/server/masterserver/error_code.h
new file mode 100755
index 0000000..35ec63e
--- /dev/null
+++ b/server/masterserver/error_code.h
@@ -0,0 +1,13 @@
+#pragma once
+
+/*
+  类似http的错误码设计
+  0：成功
+  <400: 客户端的错
+  >500: 服务器的错
+*/
+enum ErrorCode_e
+{
+    ERRNO_OK = 0,
+
+};
diff --git a/server/masterserver/global.cc b/server/masterserver/global.cc
new file mode 100755
index 0000000..14f96c9
--- /dev/null
+++ b/server/masterserver/global.cc
@@ -0,0 +1,37 @@
+#include "precompile.h"
+#include "global.h"
+
+int g_hint_flags = 0;
+
+bool Global::IsVirtualItem(int itemid)
+{
+    return (itemid == VID_Item_Exp ||
+            itemid == VID_Item_Gold ||
+            itemid == VID_Soul_Stone ||
+            itemid == VID_Pickaxe);
+}
+
+time_t Global::BetweenDays(time_t time1, time_t time2)
+{
+    return (time1 + g_time_zone*3600)/3600/24 - (time2 + g_time_zone*3600)/3600/24;
+}
+
+time_t Global::GetDaySeconds(time_t time, int incdays)
+{
+    return time_t((time + g_time_zone * 3600)/3600/24 + incdays) * 3600 * 24 - 3600 * g_time_zone;
+}
+
+bool Global::IsTimeToReset(int time)
+{
+    return BetweenDays(g_nowtime - 60 * SYS_RESET_TIME, time - 60 * SYS_RESET_TIME) > 0;
+}
+
+
+int Global::g_nowtime = time(nullptr);
+int Global::g_time_zone = 8;
+bool Global::g_shutdown = false;
+
+bool IsValidSlotId(int slot_id)
+{
+    return slot_id >= 0 && slot_id < IS_END;
+}
diff --git a/server/masterserver/global.h b/server/masterserver/global.h
new file mode 100755
index 0000000..9d9df3c
--- /dev/null
+++ b/server/masterserver/global.h
@@ -0,0 +1,22 @@
+#pragma once
+
+extern int g_hint_flags;
+
+class Global : public a8::Singleton<Global>
+{
+ private:
+    Global() {};
+    friend class a8::Singleton<Global>;
+ public:
+
+    static bool IsVirtualItem(int itemid);
+    static bool IsTimeToReset(int time);
+    static time_t BetweenDays(time_t time1, time_t time2);
+    static time_t GetDaySeconds(time_t time, int incdays = 0);
+
+    static int g_nowtime;
+    static int g_time_zone; // 默认东八区
+    static bool g_shutdown;
+};
+
+bool IsValidSlotId(int slot_id);
diff --git a/server/masterserver/handlermgr.cc b/server/masterserver/handlermgr.cc
new file mode 100644
index 0000000..76a5593
--- /dev/null
+++ b/server/masterserver/handlermgr.cc
@@ -0,0 +1,82 @@
+#include "precompile.h"
+
+#include <a8/mutable_xobject.h>
+
+#include "handlermgr.h"
+
+#include "GGListener.h"
+#include "app.h"
+#include "cs_proto.pb.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", App::Instance()->perf.max_run_delay_time);
+    request->resp_xobj->SetVal("max_timer_idle", App::Instance()->perf.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);
+    //    RegisterGMMsgHandler("Ops@shutdown", _GMOpsShutdown);
+}
+
+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") {
+        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()) {
+        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);
+            GGListener::Instance()->SendText(sockhandle, a8::HttpResponse(response));
+
+            delete request;
+        }
+    } else {
+        GGListener::Instance()->SendText(sockhandle, a8::HttpResponse("{}"));
+    }
+}
+
+void HandlerMgr::RegisterGMMsgHandler(const std::string& msgname,
+                                      void (*handler)(f8::JsonHttpRequest*))
+{
+    gmhandlers_[msgname] = handler;
+}
diff --git a/server/masterserver/handlermgr.h b/server/masterserver/handlermgr.h
new file mode 100644
index 0000000..bcbbdd8
--- /dev/null
+++ b/server/masterserver/handlermgr.h
@@ -0,0 +1,38 @@
+#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 ggmsghandler;
+    f8::NetMsgHandlerObject dbmsghandler;
+    f8::NetMsgHandlerObject dpmsghandler;
+    f8::NetMsgHandlerObject bsmsghandler;
+
+    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_;
+};
diff --git a/server/masterserver/jsondatamgr.cc b/server/masterserver/jsondatamgr.cc
new file mode 100644
index 0000000..6451fd5
--- /dev/null
+++ b/server/masterserver/jsondatamgr.cc
@@ -0,0 +1,42 @@
+#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 (App::Instance()->flags.find(2) != App::Instance()->flags.end()) {
+            masterserver_cluster_json_file = a8::Format("/root/pub/%d/%d/conf_test/game%d/masterserver/"
+                                                      "game%d.masterserver.cluster.json",
+                                                      {
+                                                       GAME_ID,
+                                                       App::Instance()->instance_id,
+                                                       GAME_ID,
+                                                       GAME_ID
+                                                      });
+        } else {
+            masterserver_cluster_json_file = a8::Format("/var/data/conf_test/game%d/masterserver/"
+                                                      "game%d.masterserver.cluster.json",
+                                                      {GAME_ID, GAME_ID});
+        }
+    } else {
+        masterserver_cluster_json_file = a8::Format("../config/game%d.masterserver.cluster.json", {GAME_ID});
+    }
+    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];
+}
diff --git a/server/masterserver/jsondatamgr.h b/server/masterserver/jsondatamgr.h
new file mode 100644
index 0000000..10a3f34
--- /dev/null
+++ b/server/masterserver/jsondatamgr.h
@@ -0,0 +1,17 @@
+#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();
+
+ private:
+    a8::XObject masterserver_cluster_json_;
+};
diff --git a/server/masterserver/main.cc b/server/masterserver/main.cc
new file mode 100644
index 0000000..7dffbf1
--- /dev/null
+++ b/server/masterserver/main.cc
@@ -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;
+}
diff --git a/server/masterserver/precompile.h b/server/masterserver/precompile.h
new file mode 100644
index 0000000..49c2658
--- /dev/null
+++ b/server/masterserver/precompile.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <a8/a8.h>
+#include <a8/udplog.h>
+
+#include "constant.h"
+#include "types.h"
+#include "error_code.h"
+#include "global.h"
+
+namespace google
+{
+    namespace protobuf
+    {
+        class Message;
+    }
+}
+
+#include "framework/cpp/types.h"
+#include "framework/cpp/protoutils.h"
+
diff --git a/server/masterserver/types.cc b/server/masterserver/types.cc
new file mode 100644
index 0000000..015e742
--- /dev/null
+++ b/server/masterserver/types.cc
@@ -0,0 +1,4 @@
+#include "precompile.h"
+
+#include "cs_proto.pb.h"
+
diff --git a/server/masterserver/types.h b/server/masterserver/types.h
new file mode 100755
index 0000000..1467ba7
--- /dev/null
+++ b/server/masterserver/types.h
@@ -0,0 +1,10 @@
+#pragma once
+
+struct PerfMonitor
+{
+    int max_run_delay_time = 0;
+    int max_timer_idle = 0;
+    long long out_data_size = 0;
+    long long in_data_size = 0;
+    long long read_count = 0;
+};