WebSocketConfig.hpp

Go to the documentation of this file.

#pragma once
#ifndef _KURLYK_WEBSOCKET_CONFIG_HPP_INCLUDED
#define _KURLYK_WEBSOCKET_CONFIG_HPP_INCLUDED

 
namespace kurlyk {

    class WebSocketConfig {
    public:
        Headers headers;                
        std::string url;                
        std::string user_agent;         
        std::string accept_encoding;    
        std::string cookie;             
        std::vector<std::string> protocols; 
        std::string cert_file;          
        std::string key_file;           
        std::string ca_file;            
        std::string proxy_server;       
        std::string proxy_auth;         
        ProxyType proxy_type    = ProxyType::PROXY_HTTP; 
        long request_timeout    = 20;   
        long idle_timeout       = 0;    
        long reconnect_delay    = 5;    
        long reconnect_attempts = 0;    
        std::size_t max_send_queue_size = 0; 
        bool reconnect      = true;     
        bool verify_cert    = true;     

        struct RateLimitData {
            long requests_per_period; 
            long period_ms; 
 
            RateLimitData(long requests_per_period = 0, long period_ms = 0)
                : requests_per_period(requests_per_period), period_ms(period_ms) {}
        };
 
        std::vector<RateLimitData> rate_limits; 

        void set_url(const std::string& host, const std::string& path, const std::string& query = "") {
            url = host;
            if (!path.empty() && path[0] != '/') {
                url += "/";
            }
            url += path;
            if (!query.empty()) {
                url += (query[0] == '?' ? "" : "?") + query;
            }
        }

        void set_url(const std::string& url, const QueryParams& query) {
            this->url = url + (query.empty() ? "" : utils::to_query_string(query, "?"));
        }

        void set_accept_encoding(bool identity = false, bool deflate = false, bool gzip = false, bool brotli = false) {
            std::string encodings;
            if (identity) encodings += "identity";
            if (deflate) encodings += (encodings.empty() ? "" : ",") + std::string("deflate");
            if (gzip) encodings += (encodings.empty() ? "" : ",") + std::string("gzip");
            if (brotli) encodings += (encodings.empty() ? "" : ",") + std::string("br");
            accept_encoding = std::move(encodings);
        }

        void set_proxy(const std::string& ip, int port) {
            proxy_server = ip + ":" + std::to_string(port);
        }

        void set_proxy(const std::string& ip, int port, ProxyType type) {
            proxy_server = ip + ":" + std::to_string(port);
            proxy_type = type;
        }

        void set_proxy_server(const std::string& server) {
            proxy_server = server;
        }

        void set_proxy_auth(const std::string& auth) {
            proxy_auth = auth;
        }

        void set_proxy_type(ProxyType type) {
            proxy_type = type;
        }

        void set_proxy(
                const std::string& ip,
                int port,
                const std::string& username,
                const std::string& password,
                ProxyType type = ProxyType::PROXY_HTTP) {
            set_proxy(ip, port);
            set_proxy_auth(username, password);
            proxy_type = type;
        }

        void set_proxy_auth(const std::string& username, const std::string& password) {
            proxy_auth = username + ":" + password;
        }

        void set_reconnect(bool reconnect, long reconnect_attempts = 0, long reconnect_delay = 0) {
            this->reconnect = reconnect;
            this->reconnect_attempts = reconnect_attempts;
            this->reconnect_delay = reconnect_delay;
        }

        void set_user_agent(const std::string& user_agent) {
            this->user_agent = user_agent;
        }

        void set_accept_language(const std::string& accept_language) {
            this->headers.emplace("Accept-Language", accept_language);
        }

        void set_cookie(const std::string& cookie) {
            this->cookie = cookie;
        }

        void set_idle_timeout(long idle_timeout) {
            this->idle_timeout = idle_timeout;
        }

        void set_request_timeout(long request_timeout) {
            this->request_timeout = request_timeout;
        }

        void set_max_send_queue_size(std::size_t max_send_queue_size) {
            this->max_send_queue_size = max_send_queue_size;
        }

        void set_ca_file(const std::string& ca_file) {
            this->ca_file = ca_file;
        }

        void set_ca_file(bool verify_cert, const std::string& ca_file) {
            this->verify_cert = verify_cert;
            this->ca_file = ca_file;
        }

        void set_verify_cert(bool verify_cert) {
            this->verify_cert = verify_cert;
        }

        long add_rate_limit(long requests_per_period, long period_ms) {
            rate_limits.emplace_back(requests_per_period, period_ms);
            return rate_limits.size() - 1;
        }

        long add_rate_limit_rpm(long requests_per_minute) {
            long period_ms = 60000; // 1 minute in milliseconds
            return add_rate_limit(requests_per_minute, period_ms);
        }

        long add_rate_limit_rps(long requests_per_second) {
            long period_ms = 1000; // 1 second in milliseconds
            return add_rate_limit(requests_per_second, period_ms);
        }
    };
 
} // namespace kurlyk
 
#endif // _KURLYK_WEBSOCKET_CONFIG_HPP_INCLUDED