utils.hpp

Go to the documentation of this file.

#pragma once
#ifndef _KURLYK_HTTP_UTILS_HPP_INCLUDED
#define _KURLYK_HTTP_UTILS_HPP_INCLUDED

 
namespace kurlyk {

    inline HttpRateLimitHandlePtr create_rate_limit(long requests_per_period, long period_ms, bool sequential = false) {
        return HttpRequestManager::get_instance().create_rate_limit(requests_per_period, period_ms, sequential);
    }

    inline HttpRateLimitHandlePtr create_rate_limit_rpm(long requests_per_minute, bool sequential = false) {
        long period_ms = 60000; // 1 minute in milliseconds
        return HttpRequestManager::get_instance().create_rate_limit(requests_per_minute, period_ms, sequential);
    }

    inline HttpRateLimitHandlePtr create_rate_limit_rps(long requests_per_second, bool sequential = false) {
        long period_ms = 1000; // 1 second in milliseconds
        return HttpRequestManager::get_instance().create_rate_limit(requests_per_second, period_ms, sequential);
    }

    inline HttpRateLimitHandlePtr get_rate_limit(long limit_id) {
        return HttpRequestManager::get_instance().get_rate_limit(limit_id);
    }

    inline bool remove_limit(long limit_id) {
        return HttpRequestManager::get_instance().remove_limit(limit_id);
    }

    inline bool remove_limit(const HttpRateLimitHandlePtr& limit) {
        return HttpRequestManager::get_instance().remove_limit(limit);
    }

    inline uint64_t generate_request_id() {
        return HttpRequestManager::get_instance().generate_request_id();
    }

    inline uint64_t generate_group_id() {
        return HttpRequestManager::get_instance().generate_group_id();
    }

    inline void set_max_pending_requests(std::size_t max_pending_requests) {
        HttpRequestManager::get_instance().set_max_pending_requests(max_pending_requests);
    }

    inline std::size_t max_pending_requests() {
        return HttpRequestManager::get_instance().max_pending_requests();
    }

    inline void cancel_request_by_id(uint64_t request_id, std::function<void()> callback) {
        HttpRequestManager::get_instance().cancel_request_by_id(request_id, std::move(callback));
        ::kurlyk::core::NetworkWorker::get_instance().notify();
    }

    inline std::future<void> cancel_request_by_id(uint64_t request_id) {
        auto promise = std::make_shared<std::promise<void>>();
        auto future = promise->get_future();
        HttpRequestManager::get_instance().cancel_request_by_id(request_id, [promise](){
            try {
                promise->set_value();
            } catch (const std::future_error& e) {
                if (e.code() == std::make_error_condition(std::future_errc::promise_already_satisfied)) {
                    KURLYK_HANDLE_ERROR(e, "Promise already satisfied in HttpClient::request callback");
                } else {
                    KURLYK_HANDLE_ERROR(e, "Future error in HttpClient::request callback");
                }
            } catch (const std::exception& e) {
                KURLYK_HANDLE_ERROR(e, "Unhandled exception in HttpClient::request callback");
            } catch (...) {
                // Unknown fatal error in request callback
            }
        });
        ::kurlyk::core::NetworkWorker::get_instance().notify();
        return future;
    }

    inline void cancel_requests_by_group_id(uint64_t group_id, std::function<void()> callback) {
        HttpRequestManager::get_instance().cancel_requests_by_group_id(group_id, std::move(callback));
        ::kurlyk::core::NetworkWorker::get_instance().notify();
    }

    inline std::future<void> cancel_requests_by_group_id(uint64_t group_id) {
        auto promise = std::make_shared<std::promise<void>>();
        auto future = promise->get_future();
        HttpRequestManager::get_instance().cancel_requests_by_group_id(group_id, [promise](){
            try {
                promise->set_value();
            } catch (const std::future_error& e) {
                if (e.code() == std::make_error_condition(std::future_errc::promise_already_satisfied)) {
                    KURLYK_HANDLE_ERROR(e, "Promise already satisfied in HttpClient::request callback");
                } else {
                    KURLYK_HANDLE_ERROR(e, "Future error in HttpClient::request callback");
                }
            } catch (const std::exception& e) {
                KURLYK_HANDLE_ERROR(e, "Unhandled exception in HttpClient::request callback");
            } catch (...) {
                // Unknown fatal error in request callback
            }
        });
        ::kurlyk::core::NetworkWorker::get_instance().notify();
        return future;
    }

    inline HttpResponsePtr make_submit_error_response(const SubmitResult& submit_result) {
#       if __cplusplus >= 201402L
        auto response = std::make_unique<HttpResponse>();
#       else
        auto response = std::unique_ptr<HttpResponse>(new HttpResponse());
#       endif
        response->ready = true;
        response->status_code = 0;
        response->error_code = submit_result.error_code;
        response->error_message = submit_result.error_code.message();
        return response;
    }

    inline void safe_set_response(
            std::shared_ptr<std::promise<HttpResponsePtr>> promise,
            HttpResponsePtr response) {
        if (!response || !response->ready) return;
        try {
            promise->set_value(std::move(response));
        } catch (const std::future_error& e) {
            if (e.code() == std::make_error_condition(std::future_errc::promise_already_satisfied)) {
                KURLYK_HANDLE_ERROR(e, "Promise already satisfied in HttpClient::request callback");
            } else {
                KURLYK_HANDLE_ERROR(e, "Future error in HttpClient::request callback");
            }
        } catch (const std::exception& e) {
            KURLYK_HANDLE_ERROR(e, "Unhandled exception in HttpClient::request callback");
        } catch (...) {
            // Unknown fatal error in request callback
        }
    }

    inline SubmitResult submit_http_request(
            std::unique_ptr<HttpRequest> request_ptr,
            HttpResponseCallback callback) {
        SubmitResult submit_result = HttpRequestManager::get_instance().submit_request(
            std::move(request_ptr), std::move(callback));
        if (submit_result) {
            ::kurlyk::core::NetworkWorker::get_instance().notify();
        }
        return submit_result;
    }

    inline bool http_request(
            std::unique_ptr<HttpRequest> request_ptr,
            HttpResponseCallback callback) {
        return submit_http_request(std::move(request_ptr), std::move(callback)).accepted;
    }

    inline std::future<HttpResponsePtr> http_request(
            std::unique_ptr<HttpRequest> request_ptr) {
 
        auto promise = std::make_shared<std::promise<HttpResponsePtr>>();
        auto future = promise->get_future();
 
        HttpResponseCallback callback = [promise](HttpResponsePtr response) {
            safe_set_response(promise, std::move(response));
        };
 
        const SubmitResult submit_result = submit_http_request(std::move(request_ptr), std::move(callback));
        if (!submit_result) {
            safe_set_response(promise, make_submit_error_response(submit_result));
        }
 
        return future;
    }

    inline uint64_t http_request(
            const std::string &method,
            const std::string &url,
            const QueryParams &query,
            const Headers &headers,
            const std::string &content,
            HttpResponseCallback callback) {
#       if __cplusplus >= 201402L
        auto request_ptr = std::make_unique<HttpRequest>();
#       else
        auto request_ptr = std::unique_ptr<HttpRequest>(new HttpRequest());
#       endif
 
        const uint64_t request_id = HttpRequestManager::get_instance().generate_request_id();
        request_ptr->request_id = request_id;
        request_ptr->set_url(url, query);
        request_ptr->method  = method;
        request_ptr->headers = headers;
        request_ptr->content = content;
        if (http_request(std::move(request_ptr), std::move(callback))) return request_id;
        return 0;
    }

    inline uint64_t http_request(
            const std::string &method,
            const std::string &url,
            const QueryParams &query,
            const Headers &headers,
            const std::string &content,
            bool streaming,
            HttpResponseCallback callback) {
#       if __cplusplus >= 201402L
        auto request_ptr = std::make_unique<HttpRequest>();
#       else
        auto request_ptr = std::unique_ptr<HttpRequest>(new HttpRequest());
#       endif
 
        const uint64_t request_id = HttpRequestManager::get_instance().generate_request_id();
        request_ptr->request_id = request_id;
        request_ptr->set_url(url, query);
        request_ptr->method  = method;
        request_ptr->headers = headers;
        request_ptr->content = content;
        request_ptr->streaming = streaming;
        if (http_request(std::move(request_ptr), std::move(callback))) return request_id;
        return 0;
    }

    inline std::pair<uint64_t, std::future<HttpResponsePtr>> http_request(
            const std::string &method,
            const std::string &url,
            const QueryParams &query,
            const Headers &headers,
            const std::string &content) {
 
#       if __cplusplus >= 201402L
        auto request_ptr = std::make_unique<HttpRequest>();
#       else
        auto request_ptr = std::unique_ptr<HttpRequest>(new HttpRequest());
#       endif
 
        const uint64_t request_id = HttpRequestManager::get_instance().generate_request_id();
        request_ptr->request_id = request_id;
        request_ptr->set_url(url, query);
        request_ptr->method = method;
        request_ptr->headers = headers;
        request_ptr->content = content;
 
        auto promise = std::make_shared<std::promise<HttpResponsePtr>>();
        auto future = promise->get_future();
 
        HttpResponseCallback callback = [promise](HttpResponsePtr response) {
            safe_set_response(promise, std::move(response));
        };
 
        const SubmitResult submit_result = submit_http_request(std::move(request_ptr), std::move(callback));
        if (!submit_result) {
            safe_set_response(promise, make_submit_error_response(submit_result));
        }
 
        return {request_id, std::move(future)};
    }

    inline uint64_t http_request(
            const std::string &method,
            const std::string &host,
            const std::string &path,
            const QueryParams &query,
            const Headers &headers,
            const std::string &content,
            HttpResponseCallback callback) {
 
#       if __cplusplus >= 201402L
        auto request_ptr = std::make_unique<HttpRequest>();
#       else
        auto request_ptr = std::unique_ptr<HttpRequest>(new HttpRequest());
#       endif
 
        const uint64_t request_id = HttpRequestManager::get_instance().generate_request_id();
        request_ptr->request_id = request_id;
        request_ptr->set_url(host, path, query);
        request_ptr->method  = method;
        request_ptr->headers = headers;
        request_ptr->content = content;
        if (http_request(std::move(request_ptr), std::move(callback))) return request_id;
        return 0;
    }

    inline uint64_t http_request(
            const std::string &method,
            const std::string &host,
            const std::string &path,
            const QueryParams &query,
            const Headers &headers,
            const std::string &content,
            bool streaming,
            HttpResponseCallback callback) {
 
#       if __cplusplus >= 201402L
        auto request_ptr = std::make_unique<HttpRequest>();
#       else
        auto request_ptr = std::unique_ptr<HttpRequest>(new HttpRequest());
#       endif
 
        const uint64_t request_id = HttpRequestManager::get_instance().generate_request_id();
        request_ptr->request_id = request_id;
        request_ptr->set_url(host, path, query);
        request_ptr->method  = method;
        request_ptr->headers = headers;
        request_ptr->content = content;
        request_ptr->streaming = streaming;
        if (http_request(std::move(request_ptr), std::move(callback))) return request_id;
        return 0;
    }

    inline uint64_t http_get(
            const std::string &url,
            const QueryParams& query,
            const Headers& headers,
            HttpResponseCallback callback) {
        return http_request("GET", url, query, headers, std::string(), std::move(callback));
    }

    inline uint64_t http_get(
            const std::string &url,
            const QueryParams& query,
            const Headers& headers,
            bool streaming,
            HttpResponseCallback callback) {
        return http_request("GET", url, query, headers, std::string(), streaming, std::move(callback));
    }

    inline std::pair<uint64_t, std::future<HttpResponsePtr>> http_get(
            const std::string& url,
            const QueryParams& query,
            const Headers& headers) {
 
#       if __cplusplus >= 201402L
        auto request_ptr = std::make_unique<HttpRequest>();
#       else
        auto request_ptr = std::unique_ptr<HttpRequest>(new HttpRequest());
#       endif
 
        const uint64_t request_id = HttpRequestManager::get_instance().generate_request_id();
        request_ptr->request_id = request_id;
        request_ptr->set_url(url, query);
        request_ptr->method = "GET";
        request_ptr->headers = headers;
 
        auto promise = std::make_shared<std::promise<HttpResponsePtr>>();
        auto future = promise->get_future();
 
        HttpResponseCallback callback = [promise](HttpResponsePtr response) {
            safe_set_response(promise, std::move(response));
        };
 
        const SubmitResult submit_result = submit_http_request(std::move(request_ptr), std::move(callback));
        if (!submit_result) {
            safe_set_response(promise, make_submit_error_response(submit_result));
        }
 
        return {request_id, std::move(future)};
    }

    inline uint64_t http_post(
            const std::string &url,
            const QueryParams& query,
            const Headers& headers,
            const std::string& content,
            HttpResponseCallback callback) {
        return http_request("POST", url, query, headers, content, std::move(callback));
    }

    inline uint64_t http_post(
            const std::string &url,
            const QueryParams& query,
            const Headers& headers,
            const std::string& content,
            bool streaming,
            HttpResponseCallback callback) {
        return http_request("POST", url, query, headers, content, streaming, std::move(callback));
    }

    inline std::pair<uint64_t, std::future<HttpResponsePtr>> http_post(
            const std::string& url,
            const QueryParams& query,
            const Headers& headers,
            const std::string& content) {
 
#       if __cplusplus >= 201402L
        auto request_ptr = std::make_unique<HttpRequest>();
#       else
        auto request_ptr = std::unique_ptr<HttpRequest>(new HttpRequest());
#       endif
 
        const uint64_t request_id = HttpRequestManager::get_instance().generate_request_id();
        request_ptr->request_id = request_id;
        request_ptr->set_url(url, query);
        request_ptr->method = "POST";
        request_ptr->headers = headers;
        request_ptr->content = content;
 
        auto promise = std::make_shared<std::promise<HttpResponsePtr>>();
        auto future = promise->get_future();
 
        HttpResponseCallback callback = [promise](HttpResponsePtr response) {
            safe_set_response(promise, std::move(response));
        };
 
        const SubmitResult submit_result = submit_http_request(std::move(request_ptr), std::move(callback));
        if (!submit_result) {
            safe_set_response(promise, make_submit_error_response(submit_result));
        }
 
        return {request_id, std::move(future)};
    }
 
} // namespace kurlyk
 
#endif // _KURLYK_HTTP_UTILS_HPP_INCLUDED