ws_client.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
 
#include <asio/any_io_executor.hpp>
#include <asio/awaitable.hpp>
 
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
namespace neograph::async {
 
enum class WsOpcode : std::uint8_t {
    Continuation = 0x0,
    Text         = 0x1,
    Binary       = 0x2,
    Close        = 0x8,
    Ping         = 0x9,
    Pong         = 0xA,
};
 
struct WsClientOptions {
    std::size_t max_handshake_bytes = 64u * 1024u;
 
    std::size_t max_frame_payload_bytes = 16u * 1024u * 1024u;
 
    std::size_t max_message_payload_bytes = 16u * 1024u * 1024u;
 
    std::chrono::milliseconds handshake_timeout{30000};
 
    std::chrono::milliseconds read_timeout{0};
};
 
struct WsMessage {
    WsOpcode    op;
    std::string payload;
};
 
class NEOGRAPH_API WsClient {
public:
    ~WsClient();
    WsClient(const WsClient&)            = delete;
    WsClient& operator=(const WsClient&) = delete;
    WsClient(WsClient&&) noexcept;
    WsClient& operator=(WsClient&&) noexcept;
 
    asio::awaitable<void> send_text(std::string_view payload);
 
    asio::awaitable<void> send_binary(std::string_view payload);
 
    asio::awaitable<void> send_close(std::uint16_t code = 1000, std::string_view reason = "");
 
    asio::awaitable<WsMessage> recv();
 
private:
    // Friend forward-declaration; the trailing standalone declaration
    // (further down) also carries NEOGRAPH_API. MSVC C2375 fires if
    // the two declarations disagree on linkage, so the macro must
    // appear here too even though it's redundant on POSIX.
    friend NEOGRAPH_API asio::awaitable<std::unique_ptr<WsClient>> ws_connect(
        asio::any_io_executor,
        std::string_view,
        std::string_view,
        std::string_view,
        std::vector<std::pair<std::string, std::string>>,
        bool);
    friend NEOGRAPH_API asio::awaitable<std::unique_ptr<WsClient>> ws_connect(
        asio::any_io_executor,
        std::string_view,
        std::string_view,
        std::string_view,
        std::vector<std::pair<std::string, std::string>>,
        bool,
        WsClientOptions);
 
    struct Impl;
    std::unique_ptr<Impl> impl_;
 
    explicit WsClient(std::unique_ptr<Impl>);
 
    asio::awaitable<WsMessage> recv_message();
    asio::awaitable<void> send_frame_owned(WsOpcode opcode, std::string payload);
    asio::awaitable<void> send_close_owned(std::uint16_t code, std::string reason);
    static asio::awaitable<std::unique_ptr<WsClient>> connect_owned(
        asio::any_io_executor                            ex,
        std::string                                      host,
        std::string                                      port,
        std::string                                      path,
        std::vector<std::pair<std::string, std::string>> headers,
        bool                                             tls,
        WsClientOptions                                  options);
    static asio::awaitable<std::unique_ptr<WsClient>> handshake_owned(
        asio::any_io_executor                            ex,
        std::string                                      host,
        std::string                                      port,
        std::string                                      path,
        std::vector<std::pair<std::string, std::string>> headers,
        bool                                             tls,
        WsClientOptions                                  options);
};
 
NEOGRAPH_API asio::awaitable<std::unique_ptr<WsClient>> ws_connect(
    asio::any_io_executor                            ex,
    std::string_view                                 host,
    std::string_view                                 port,
    std::string_view                                 path,
    std::vector<std::pair<std::string, std::string>> headers = {},
    bool                                             tls     = true);
 
NEOGRAPH_API asio::awaitable<std::unique_ptr<WsClient>> ws_connect(
    asio::any_io_executor                            ex,
    std::string_view                                 host,
    std::string_view                                 port,
    std::string_view                                 path,
    std::vector<std::pair<std::string, std::string>> headers,
    bool                                             tls,
    WsClientOptions                                  options);
 
namespace detail {
 
struct WsFrameHeader {
    WsOpcode      opcode;
    bool          fin;
    bool          masked;
    std::uint64_t payload_len;
    std::uint8_t  mask_key[4];
    std::size_t header_size;
};
 
NEOGRAPH_API std::optional<WsFrameHeader> parse_frame_header(std::string_view buf);
 
NEOGRAPH_API void encode_frame_header(std::string&       out,
                                      WsOpcode           opcode,
                                      bool               fin,
                                      bool               masked,
                                      std::uint64_t      payload_len,
                                      const std::uint8_t mask_key[4] = nullptr);
 
NEOGRAPH_API void apply_mask(char* data, std::size_t len, const std::uint8_t mask_key[4]) noexcept;
 
NEOGRAPH_API std::string generate_sec_websocket_key();
 
NEOGRAPH_API std::string compute_sec_websocket_accept(std::string_view client_key);
 
}  // namespace detail
 
}  // namespace neograph::async