RADNet.h

Go to the documentation of this file.

#ifndef RADNET_H
#define RADNET_H
 
#pragma once
 
#include <RADCore/RADCore.h>
 
#include <cstdint>
#include <map>
#include <memory>
#include <string>
#include <vector>
 
namespace RADNet {
 
    struct Datagram {
        std::vector<uint8_t> payload;
        std::string address;
        uint16_t port = 0;
    };
 
    enum class SocketState {
        Unconnected,
        Connecting,
        Connected,
        Listening,
        Closed
    };
 
    class RADSocketReactor {
    public:
        static RADSocketReactor& instance();
 
        RADSocketReactor(const RADSocketReactor&) = delete;
        RADSocketReactor& operator=(const RADSocketReactor&) = delete;
 
    private:
        RADSocketReactor();
        ~RADSocketReactor();
    };
 
    class RADUdpSocket : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(datagramReceived, (RADNet::Datagram));
            RAD_EVENT(errorOccurred, (std::string));
 
        explicit RADUdpSocket(RADCore::EventLoop& loop);
        ~RADUdpSocket();
 
        bool bind(uint16_t port, const std::string& address = "0.0.0.0");
        bool sendTo(const std::string& address, uint16_t port, const std::vector<uint8_t>& payload);
        void close();
        bool isOpen() const;
        uint16_t localPort() const;
 
    private:
        struct Impl;
        std::shared_ptr<Impl> pImpl_;
    };
 
    class RADUdpServer : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(datagramReceived, (RADNet::Datagram));
            RAD_EVENT(errorOccurred, (std::string));
 
        explicit RADUdpServer(RADCore::EventLoop& loop);
        ~RADUdpServer();
 
        bool listen(uint16_t port, const std::string& address = "0.0.0.0");
        bool sendTo(const std::string& address, uint16_t port, const std::vector<uint8_t>& payload);
        void close();
        uint16_t localPort() const;
 
    RADHandlers:
        void handleDatagram(RADNet::Datagram datagram);
        void handleError(std::string message);
 
    private:
        RADUdpSocket socket_;
        RADCore::Connection datagramConnection_;
        RADCore::Connection errorConnection_;
    };
 
    class RADTcpSocket : public RADCore::RADIODevice {
    public:
        RADEvents:
            RAD_EVENT(connected, ());
            RAD_EVENT(disconnected, ());
 
        explicit RADTcpSocket(RADCore::EventLoop& loop);
        ~RADTcpSocket();
 
        bool open(RADCore::OpenMode mode) override;
        bool connectToHost(const std::string& address, uint16_t port);
        void close() override;
        bool isOpen() const override;
        ssize_t readData(void* buffer, size_t maxBytes) override;
        ssize_t writeData(const void* data, size_t size) override;
        SocketState state() const;
 
    private:
        friend class RADTcpServer;
        RADTcpSocket(RADCore::EventLoop& loop, int acceptedFd, std::string peerAddress, uint16_t peerPort);
 
        struct Impl;
        std::shared_ptr<Impl> pImpl_;
    };
 
    class RADTcpServer : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(newConnection, (std::shared_ptr<RADNet::RADTcpSocket>));
            RAD_EVENT(errorOccurred, (std::string));
 
        explicit RADTcpServer(RADCore::EventLoop& loop);
        ~RADTcpServer();
 
        bool listen(uint16_t port, const std::string& address = "0.0.0.0", int backlog = 128);
        void close();
        bool isListening() const;
        uint16_t localPort() const;
 
    private:
        struct Impl;
        std::shared_ptr<Impl> pImpl_;
    };
 
    struct RADHttpResponse {
        int statusCode = 0;
        std::string reasonPhrase;
        std::map<std::string, std::string> headers;
        std::string body;
    };
 
    struct RADHttpRequest {
        std::string method = "GET";
        std::string url;
        std::map<std::string, std::string> headers;
        std::string body;
        long timeoutMs = 30000;
        long connectTimeoutMs = 10000;
        bool followRedirects = true;
        long maxRedirects = 8;
        bool verifyTls = true;
    };
 
    struct RADDnsResult {
        std::vector<std::string> addresses;
        std::string error;
    };
 
    class RADHttpClient : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(finished, (RADNet::RADHttpResponse));
            RAD_EVENT(errorOccurred, (std::string));
 
        explicit RADHttpClient(RADCore::EventLoop& loop);
 
        static std::optional<RADHttpResponse> request(const RADHttpRequest& request, std::string* error = nullptr);
        static std::optional<RADHttpResponse> get(const RADCore::RADUrl& url, std::string* error = nullptr);
        static std::optional<RADHttpResponse> get(const std::string& url, std::string* error = nullptr);
        static std::optional<RADHttpResponse> post(const std::string& url, const std::string& body,
            const std::map<std::string, std::string>& headers = {}, std::string* error = nullptr);
        static RADDnsResult resolve(const std::string& host);
 
        void requestAsync(const RADHttpRequest& request);
        void getAsync(const RADCore::RADUrl& url);
        void getAsync(const std::string& url);
 
    private:
        RADCore::EventLoop& loop_;
    };
 
    struct RADTcpFrame {
        uint32_t messageId = 0;
        std::vector<uint8_t> payload;
    };
 
    struct RADProtocolEndpointConfig {
        std::string address = "127.0.0.1";
        uint16_t port = 0;
        int backlog = 128;
        int connectTimeoutMs = 5000;
        uint32_t maxPayloadBytes = 16 * 1024 * 1024;
    };
 
    std::vector<uint8_t> encodeFrame(const RADTcpFrame& frame);
    bool decodeFrames(std::vector<uint8_t>& buffer, std::vector<RADTcpFrame>& frames,
        uint32_t maxPayloadBytes = 16 * 1024 * 1024, std::string* error = nullptr);
    RADProtocolEndpointConfig endpointConfigFromJson(const RADCore::RADJsonValue& value,
        const RADProtocolEndpointConfig& defaults = {});
 
    class RADProtocolSocket : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(frameReceived, (RADNet::RADTcpFrame));
            RAD_EVENT(errorOccurred, (std::string));
            RAD_EVENT(connected, ());
            RAD_EVENT(disconnected, ());
 
        explicit RADProtocolSocket(RADCore::EventLoop& loop);
        RADProtocolSocket(RADCore::EventLoop& loop, std::shared_ptr<RADTcpSocket> socket);
        ~RADProtocolSocket() override;
 
        bool connectToHost(const std::string& host, uint16_t port);
        bool sendFrame(uint32_t messageId, const std::vector<uint8_t>& payload);
        bool sendFrame(const RADTcpFrame& frame);
        void close();
        bool isOpen() const;
        void setMaxPayloadBytes(uint32_t maxPayloadBytes);
 
    RADHandlers:
        void handleReadyRead();
        void handleError(std::string message);
        void handleConnected();
        void handleDisconnected();
 
    private:
        void attach(std::shared_ptr<RADTcpSocket> socket);
 
        RADCore::EventLoop& loop_;
        std::shared_ptr<RADTcpSocket> socket_;
        RADCore::Connection readyReadConnection_;
        RADCore::Connection errorConnection_;
        RADCore::Connection connectedConnection_;
        RADCore::Connection disconnectedConnection_;
        std::vector<uint8_t> buffer_;
        uint32_t maxPayloadBytes_ = 16 * 1024 * 1024;
    };
 
    class RADProtocolClient : public RADProtocolSocket {
    public:
        explicit RADProtocolClient(RADCore::EventLoop& loop);
        bool connectUsingConfig(const RADProtocolEndpointConfig& config);
    };
 
    class RADProtocolServer : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(newConnection, (std::shared_ptr<RADNet::RADProtocolSocket>));
            RAD_EVENT(errorOccurred, (std::string));
 
        explicit RADProtocolServer(RADCore::EventLoop& loop);
        bool listenUsingConfig(const RADProtocolEndpointConfig& config);
        void close();
        uint16_t localPort() const;
 
    RADHandlers:
        void handleNewConnection(std::shared_ptr<RADNet::RADTcpSocket> socket);
        void handleError(std::string message);
 
    private:
        RADCore::EventLoop& loop_;
        RADTcpServer server_;
        RADCore::Connection newConnection_;
        RADCore::Connection errorConnection_;
        uint32_t maxPayloadBytes_ = 16 * 1024 * 1024;
    };
 
} // namespace RADNet
 
#endif