MsgRpc.hpp

//
// Created by xiong on 2020/10/23.
//
 
#ifndef EMX_MSGRPC_HPP
#define EMX_MSGRPC_HPP
 
#include "core/EmxUV.hpp"
 
namespace Emx {
    class MsgRpc {
    public:
        enum class ClientTypeE : uint8_t {
            Req = 0,
            Resp    
        };
 
        struct Header {
            uint32_t sync;
            uint32_t reqClientId;
            uint32_t respClientId;
            uint32_t sessionId;
            uint32_t module;
            uint32_t method;
            int32_t chn;
            ErrCodeE code;
            uint32_t size;
        };
    };
 
    class MsgRpcReqSync {
    public:
        static ErrCodeE Request(uint32_t dstClientId, uint32_t module, uint32_t method, int32_t chn,
                const char *req = nullptr, int32_t size = 0, std::string *resp = nullptr, int32_t timeoutMs = 10000);
    };
 
    class MsgRpcReqAsync : public EuvPipeClientBase {
    public:
        using Callback = std::function<void()>;
 
        using RecvRespCallback = std::function<void(Emx::ErrCodeE e, uint32_t clientId, uint32_t module,
                uint32_t method, int32_t chn, const char *data, int32_t size)>;
 
        struct Config {
            EuvLoop *loop;
            char *buffer; 
            int32_t size; 
            Callback OnConnected;
            Callback OnDisConnected;    
            RecvRespCallback OnRecvResp;
        };
 
        MsgRpcReqAsync() : EuvPipeClientBase(), m_header({}) {
            m_waitSize = sizeof(MsgRpc::Header);
            m_waitHeader = true;
        }
 
        ErrCodeE CreateMsgRpcReqAsync(Config &cfg);
 
        void DestroyMsgRpcReqAsync() { Destroy(); }
 
        ErrCodeE Request(uint32_t dstClientId, uint32_t module, uint32_t method, int32_t chn, const char *req = nullptr,
                int32_t size = 0);
 
    protected:
        void OnConnect() override {
            if (m_cbOnConnected) m_cbOnConnected();
        }
 
        void OnDisConnect() override {
            if (m_cbOnDisConnected) m_cbOnDisConnected();
        }
 
        void OnRecv(const char *data, int32_t size) override;
 
    private:
        bool m_waitHeader;
        uint32_t m_waitSize;
        MsgRpc::Header m_header;
        std::string m_data;
        Callback m_cbOnConnected;
        Callback m_cbOnDisConnected;
        RecvRespCallback m_cbOnRecvResp;
    };
 
    class MsgRpcRep : public EuvPipeClientBase {
    public:
        using Callback = std::function<void()>;
        using RecvReqCallback = std::function<ErrCodeE(uint32_t module, uint32_t method, int32_t chn, const char *data,
                int32_t size, std::string &out)>;
        struct Config {
            EuvLoop *loop;            
            uint32_t clientId;        
            char *buffer;             
            int32_t size;             
            Callback OnConnected;     
            Callback OnDisConnected;  
            RecvReqCallback OnRecvReq;
        };
 
        MsgRpcRep() : EuvPipeClientBase() {
            m_waitSize = sizeof(MsgRpc::Header);
            m_waitHeader = true;
            m_clientId = 0;
        }
 
        ErrCodeE CreateMsgRpcRep(Config &cfg);
 
        void DestroyMsgRpcRep() { Destroy(); }
 
    protected:
        void OnConnect() override {
            if (m_cbConnected) m_cbConnected();
        }
 
        void OnDisConnect() override {
            if (m_cbDisConnected) m_cbDisConnected();
        }
 
        void OnRecv(const char *data, int32_t size) override;
 
    private:
        bool m_waitHeader;
        uint32_t m_waitSize;
        MsgRpc::Header m_header;
        std::string m_data;
        Callback m_cbConnected;
        Callback m_cbDisConnected;
        RecvReqCallback m_cbRecvReq;
        uint32_t m_clientId;
    };
}// namespace Emx
#endif//EMX_MSGRPC_HPP