dl_net.h

浏览该文件的文档.

#pragma once
 
#include "io/dl_log.h"
#include "base/dl_string.h"
#include "system/dl_thread.h"
#include "base/dl_list_mt.h"
 
#include <magic_enum/magic_enum.hpp>
 
namespace dl
{
 
constexpr uint8_t NETWORK_MESSAGE_TAG = 0x1e;
constexpr bool NETWORK_LOG_CLIENT = true;
constexpr bool NETWORK_LOG_SERVER = true;
constexpr bool NETWORK_LOG_CLIENT_UDP = true;
constexpr bool NETWORK_LOG_SERVER_UDP = true;
 
#ifndef NDEBUG
constexpr bool NETWORK_LOG_LOW = true; // 更底层的上下行日志（write、read完成后）
#else
constexpr bool NETWORK_LOG_LOW = false;
#endif
 
 
struct MessageType
{
 
};

struct MsgHead
{
    uint32_t _id;        
    uint32_t _size;        
    uint32_t _check;  
    uint8_t _compress; 
    uint8_t _magic;       
    uint8_t _pad;
};

struct UdpMessage
{
    std::string _ip;
    uint16_t _port;
    Buffer _buf;
};

struct TcpMessage
{
    MsgHead _head;
    Buffer _buf;
 
    template<IsEnum E>
    E GetMsgId(uint32_t id)
    {
        auto msg_id_opt = magic_enum::enum_cast<E>(id);
        if (!msg_id_opt.has_value())
        {
            log_info("未知协议id：{}", id);
            return {};
        }
        return msg_id_opt.value();
    }
};
 
struct TcpMessageServer
{
    MsgHead _head;
    Buffer _buf;
    int _socketId;
 
    template<IsEnum E>
    E GetMsgId(uint32_t id)
    {
        auto msg_id_opt = magic_enum::enum_cast<E>(id);
        if (!msg_id_opt.has_value())
        {
            log_info("未知协议id：{}", id);
            return {};
        }
        return msg_id_opt.value();
    }
};
 
using BufferList = ListMultiThread<Buffer>;
using UdpMessageList = ListMultiThread<UdpMessage>;
using TcpMessageList = ListMultiThread<TcpMessage>;
 
class ClientImp;
class Client
{
public:
    bool Connent(std::string_view ip, uint16_t port);
 
    template<IsEnum E, IsPod T>
    void Send(E msg_id, const T& a)
    {
        BufferView buf = CreateBufferView(a);
        if (NETWORK_LOG_CLIENT)
        {
            // 检测消息枚举
            log_info(
                "Send->[{}]：\n"
                "消息id：{}\n"
                "数据大小：{}\n"
                "{}",
                GetRemoteAddressString(),
                magic_enum::enum_name(msg_id),
                buf.size(),
                to_string_auto(buf));
        }
        Send((uint32_t)msg_id, buf);
    }
    template<IsEnum E>
    TcpMessage* GetPopMsg()
    {
        TcpMessage* msg = GetPopMsg();
        if (!msg)
            return nullptr;
 
        if (NETWORK_LOG_CLIENT)
        {
            // 检测消息枚举
            auto msg_id_opt = magic_enum::enum_cast<E>(msg->_head._id);
            if (!msg_id_opt.has_value())
            {
                log_warn("未知协议：{}", msg->_head._id);
                return nullptr;
            }
            E msg_id = msg_id_opt.value();
 
            log_info(
                "GetPopMsg<-[{}]：\n"
                "消息id：{}\n"
                "数据大小：{}\n"
                "{}",
                GetRemoteAddressString(),
                magic_enum::enum_name(msg_id),
                msg->_head._size,
                to_string_auto(msg->_buf));
        }
        return msg;
    }

    std::string GetRemoteAddressString();
 
    Client();
    ~Client();
private:
    ClientImp* _imp;
    Thread* _tSend;
    Thread* _tRecv;
    std::atomic_bool _bEnd;
    std::atomic_bool _bValid;
    TcpMessageList _bufListSend;
    TcpMessageList _bufListRecv;
    TcpMessage _msgTemp;
 
    static void _thread_send(void*);// 发送线程
    static void _thread_recv(void*);// 接收线程
 
 
    void Send(uint32_t msg_id, BufferView buf);
    void Send(uint32_t msg_id, const Buffer& buf)
    {
        Send(msg_id, CreateBufferView(buf));
    }
 
 
    TcpMessage* GetPopMsg()
    {
        if (_bufListRecv.PopFront(_msgTemp))
            return &_msgTemp;
        else
            return nullptr;
    }
 
    bool _check_valid()
    {
        if (_bValid)
            return true;
        log_warn("未调用 Connent，或无网络权限，后续调用无效！");
        return false;
    }
};
 
class ServerImp;
class Server
{
public:
    using CbDisconnect = std::function<void(int)> ;
 
    bool Accept(uint16_t port);
    void Run();

    void SetCbDisconnect(CbDisconnect func);
 
 
    template<IsEnum E, IsPod T>
    void Send(int sokect_id, E msg_id, const T& a)
    {
        BufferView buf = CreateBufferView(a);
        if (NETWORK_LOG_SERVER)
        {
            log_info(
                "Send->[{}]：\n"
                "消息id：{}\n"
                "数据大小：{}\n"
                "{}",
                GetRemoteAddressString(sokect_id),
                magic_enum::enum_name(msg_id),
                buf.size(),
                to_string_auto(buf));
        }
        _send_imp(sokect_id, (uint32_t)msg_id, buf);
    }
 
    template<IsEnum E, IsNotPod T>
    void Send(int sokect_id, E msg_id, const T& a)
    {
        Buffer buf = a.ToBuffer();
        if (NETWORK_LOG_SERVER)
        {
            log_info(
                "Send->[{}]：\n"
                "消息id：{}\n"
                "数据大小：{}\n"
                "{}",
                GetRemoteAddressString(sokect_id),
                magic_enum::enum_name(msg_id),
                buf.size(),
                to_string_auto(buf));
        }
        _send_imp(sokect_id, (uint32_t)msg_id, buf);
    }
 
    std::string GetIp();
    uint16_t GetPort();
 
    template<IsEnum E>
    TcpMessageServer* GetPopMsg()
    {
        TcpMessageServer* msg = _get_pop_msg();
        if (!msg)
            return nullptr;
        if (NETWORK_LOG_SERVER)
        {
            // 检测消息枚举
            auto msg_id_opt = magic_enum::enum_cast<E>(msg->_head._id);
            if (!msg_id_opt.has_value())
            {
                log_warn("未知协议：{}", msg->_head._id);
                return nullptr;
            }
            E msg_id = msg_id_opt.value();
 
            log_info(
                "GetPopMsg<-[{}]：\n"
                "消息id：{}\n"
                "数据大小：{}\n"
                "{}",
                GetRemoteAddressString(msg->_socketId),
                magic_enum::enum_name(msg_id),
                msg->_head._size,
                to_string_auto(msg->_buf));
        }
        return msg;
    }
 
    std::string GetRemoteAddressString(int socket_id);
 
    Server();
    ~Server();
private:
    ServerImp* _imp;
    Thread* _t;
    TcpMessageServer _msgTemp;
 
    static void _thread_run(void*);
 
 
    void _send_imp(int sokect_id, uint32_t msg_id, BufferView buf);
 
    TcpMessageServer* _get_pop_msg();
};
 
class ClientUdpImp;
class ClientUdp
{
public:
    void SetAddress(std::string_view ip, uint16_t port, bool broadcast = false);
    void Send(BufferView buf);
    void Send(std::string_view str)
    {
        Send(CreateBufferView(str));
    }
 
    Buffer* GetPopMsg()
    {
        if (_bufListRecv.PopFront(_bufTemp))
            return &_bufTemp;
        else
            return nullptr;
    }
 
    ClientUdp();
    ~ClientUdp();
private:
    ClientUdpImp* _imp;
    std::atomic_bool _bValid;
    std::atomic_bool _bEnd;
    Thread* _tSend;
    Thread* _tRecv;
    BufferList _bufListSend;
    BufferList _bufListRecv;
    Buffer _bufTemp;
 
    static void _thread_send(void*);
    static void _thread_recv(void*);
 
    bool _check_valid()
    {
        if (_bValid)
            return true;
        log_warn("未调用 SetAddress，或无网络权限，后续调用无效！");
        return false;
    }
};
 
class ServerUdpImp;
class ServerUdp
{
    friend class ServerUdpImp;
public:
    bool Start(std::string_view ip, uint16_t port);
 
    UdpMessage* GetPopMsg() 
    { 
        if (_listMsg.PopFront(_msgTemp))
            return &_msgTemp;
        else
            return nullptr;
    }
 
    std::string GetIp();
    uint16_t GetPort();
 
    ServerUdp();
    ~ServerUdp();
private:
    ServerUdpImp* _imp;
    Thread* _t; 
    UdpMessageList _listMsg;
    UdpMessage _msgTemp;
 
    static void _thread_run(void*);
};

class Network
{
public:
    Network()
    {
        //Debug();
    }

    static std::string GetHostName();

    static std::vector<std::string> GetIpAddressLocal(bool ipv4 = true);
    static std::string GetIpAddressLocalFirst(bool ipv4 = true)
    {
        std::vector<std::string> vec = GetIpAddressLocal(ipv4);
        return vec.empty() ? "127.0.0.1" : vec[0];
    }
 
    void Debug()
    {
        log_msg("----------------网络信息-------------\n"
            "主机名：{}\n"
            "本地ip：{}\n",
            GetHostName(),
            String::Splicing(GetIpAddressLocal()));
    }
};
 
extern Network* g_net;
}