Network.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Capability.h"
#include "common/Module.h"
#include "common/ServiceInterfaces.h"
#include "NetTypes.h"
 
#include <memory>
#include <mutex>
#include <atomic>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace eve::network {
 
class TcpSocket;
class UdpSocket;
class HttpRequest;
class Channel;
class Session;
class NetWorker;
class NetWriter;
class NetReader;
class UdpLink;
class NetHost;
class NetRpc;
 
class EVENGINE_API_PLATFORM Network : public Module, public eve::service::INetwork {
public:
    Module_REG(Network);
    Network();
    ~Network() override;
 
    std::unique_ptr<TcpSocket> makeTcp();
    std::unique_ptr<UdpSocket> makeUdp();
    std::unique_ptr<HttpRequest> makeHttp(std::string method, std::string url);
    std::unique_ptr<Channel> makeChannel(TcpSocket* socket);
    std::unique_ptr<Session> makeSession();
    std::unique_ptr<NetWriter> makeWriter();
    std::unique_ptr<NetReader> makeReader(std::string bytes);
    std::unique_ptr<UdpLink> makeUdpLink(UdpSocket* socket);
    std::unique_ptr<NetRpc> makeRpc(UdpLink* link);
    std::unique_ptr<NetHost> makeHost();
 
    TcpSocket*   newTcp();
    UdpSocket*   newUdp();
    HttpRequest* newHttp(std::string method, std::string url);
    Channel*     newChannel(TcpSocket* socket);
    Session*     newSession();
    NetWriter*   newWriter();
    NetReader*   newReader(std::string bytes);
    UdpLink*     newUdpLink(UdpSocket* socket);
    NetRpc*      newRpc(UdpLink* link);
    NetHost*     newHost();
 
    void setTimeout(int ms);
    int  getTimeout() const;
    void setVerifySsl(bool verify);
    bool getVerifySsl() const;
 
    NetTelemetrySnapshot telemetrySnapshot() const;
    void resetTelemetry();
 
    void pump();
 
    bool httpRequest(const std::string& method, const std::string& url,
                     const std::string& body, int timeoutMs, int& status,
                     std::string& responseBody) override;
 
private:
    friend class Channel;
    friend class HttpRequest;
    friend class NetHost;
    friend class NetWorker;
    friend class TcpSocket;
    friend class UdpSocket;
 
    void post(NetCompletion c);
    void recordSent(size_t bytes);
    void drainCompletions(std::vector<NetCompletion>& out);
    NetWorker* worker() const { return worker_.get(); }
 
    void watchTcp(TcpSocket* sock);
    void unwatchTcp(TcpSocket* sock);
    void watchUdp(UdpSocket* sock);
    void unwatchUdp(UdpSocket* sock);
    void pollSockets();
 
    void bindChannel(TcpSocket* sock, Channel* ch);
    void unbindChannel(TcpSocket* sock);
    Channel* channelFor(TcpSocket* sock) const;
 
    void bindUdpLink(UdpSocket* sock, UdpLink* link);
    void unbindUdpLink(UdpSocket* sock);
    void bindUdpHost(UdpSocket* sock, NetHost* host);
    void unbindUdpHost(UdpSocket* sock);
 
    void emitCompletion(const NetCompletion& c);
 
    int  timeoutMs_ = 10000;
    bool verifySsl_ = true;
    std::unique_ptr<NetWorker> worker_;
 
    mutable std::mutex watchMu_;
    std::vector<TcpSocket*> watchedTcp_;
    std::vector<UdpSocket*> watchedUdp_;
 
    mutable std::mutex channelMu_;
    std::unordered_map<TcpSocket*, Channel*> channels_;
 
    std::unordered_map<UdpSocket*, UdpLink*> udpLinks_;
    std::unordered_map<UdpSocket*, NetHost*> udpHosts_;
    std::atomic<uint64_t> telemetryRevision_{1};
    std::atomic<uint64_t> sentBytes_{0}, receivedBytes_{0}, completions_{0};
    std::atomic<uint64_t> errors_{0}, connections_{0};
};
 
}  // namespace eve::network