HttpRequest.hpp

Go to the documentation of this file.

#pragma once
#ifndef _KURLYK_HTTP_REQUEST_HPP_INCLUDED
#define _KURLYK_HTTP_REQUEST_HPP_INCLUDED

 
namespace kurlyk {

    class HttpRequest {
    public:
        uint64_t request_id = 0;         
        uint64_t group_id = 0;           
        Headers headers;                 
        std::string url;                 
        std::string method = "GET";      
        std::string content;             
        std::string user_agent;          
        std::string accept_encoding;     
        std::string cookie_file;         
        std::string cookie;              
        std::string cert_file;           
        std::string key_file;            
        std::string ca_file;             
        std::string ca_path;             
        std::string proxy_server;        
        std::string proxy_auth;          
        ProxyType proxy_type = ProxyType::PROXY_HTTP; 
        bool proxy_tunnel  = true;       
        std::string interface_name;      
        bool use_interface = false;      
 
        bool follow_location = true;     
        long max_redirects   = 10;       
        bool auto_referer    = false;    
        bool head_only       = false;    
        bool streaming       = false;    
 
        long timeout         = 30;       
        long connect_timeout = 10;       
        HttpRateLimitHandlePtr general_rate_limit;  
        HttpRateLimitHandlePtr specific_rate_limit; 
        std::string general_rate_limit_key;         
        std::string specific_rate_limit_key;        
        std::set<long> valid_statuses = {200}; 
        long retry_attempts = 0;         
        long retry_delay_ms = 0;         
 
        bool clear_cookie_file = false;  
 
        // Debug parameters
        bool verbose = false;            
        bool debug_header = false;       

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

        void set_url(
                const std::string& host,
                const std::string& path,
                const QueryParams& query) {
            const std::string query_str = utils::to_query_string(query, "?");
            set_url(host, path, query_str);
        }

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

        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_accept_language(const std::string& value) {
            headers.emplace("Accept-Language", value);
        }

        void set_content_type(const std::string& value) {
            headers.emplace("Content-Type", value);
        }

        void set_origin(const std::string& value) {
            headers.emplace("Origin", value);
        }

        void set_referer(const std::string& value) {
            headers.emplace("Referer", value);
        }

        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(
                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_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_auth(
                const std::string& username,
                const std::string& password) {
            proxy_auth = username + ":" + password;
        }

        void set_retry_attempts(long retry_attempts, long retry_delay_ms) {
            this->retry_attempts = retry_attempts;
            this->retry_delay_ms = retry_delay_ms;
        }
        
        void add_valid_status(long status) {
            valid_statuses.insert(status);
        }

        void set_valid_statuses(const std::set<long>& statuses) {
            valid_statuses = statuses;
        }

        void clear_valid_statuses() {
            valid_statuses.clear();
        }

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

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

        void set_cert_file(const std::string& cert_file) {
            this->cert_file = cert_file;
        }

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

        void set_timeout(long timeout) {
            this->timeout = timeout;
        }

        void set_connect_timeout(long connect_timeout) {
            this->connect_timeout = connect_timeout;
        }

        void set_streaming(bool streaming) {
            this->streaming = streaming;
        }

        void set_verbose(bool verbose) {
            this->verbose = verbose;
        }

        void set_debug_header(bool debug_header) {
            this->debug_header = debug_header;
        }
 
    }; // HttpRequest
    
    using HttpRequestPtr = std::unique_ptr<HttpRequest>;
 
}; // namespace kurlyk
 
#endif // _KURLYK_HTTP_REQUEST_HPP_INCLUDED