HttpRequestContext.hpp

Go to the documentation of this file.

#pragma once
#ifndef KURLYK_HEADER_KURLYK_HTTP_HTTP_REQUEST_MANAGER_HTTP_REQUEST_CONTEXT_HPP_INCLUDED
#define KURLYK_HEADER_KURLYK_HTTP_HTTP_REQUEST_MANAGER_HTTP_REQUEST_CONTEXT_HPP_INCLUDED

 
namespace kurlyk {

    class HttpRequestContext {
    public:
        using time_point_t = std::chrono::steady_clock::time_point;
 
        std::unique_ptr<HttpRequest> request;       
        HttpResponseCallback         callback;      
        long                         retry_attempt; 
        time_point_t                 start_time;    
        uint64_t                     in_flight_token = 0; 
        std::function<void()>        on_complete;   
        std::function<void()>        on_group_complete; 
        std::atomic<bool>            complete_called{false};  

        HttpRequestContext(
            std::unique_ptr<HttpRequest> request_ptr,
            HttpResponseCallback callback)
            : request(std::move(request_ptr)),
              callback(std::move(callback)),
              retry_attempt(0),
              in_flight_token(0),
              complete_called(false) {
        }
 
        HttpRequestContext() = default;

        void invoke_callback(HttpResponsePtr response) noexcept {
            if (!callback) return;
 
            try {
                callback(std::move(response));
            } catch (...) {
                report_callback_exception(
                    std::current_exception(),
                    "Unhandled exception in HttpRequestContext response callback");
            }
        }

        void invoke_final_callback(HttpResponsePtr response) noexcept {
            invoke_callback(std::move(response));
            complete();
        }

        void complete() noexcept {
            bool expected = false;
            if (!complete_called.compare_exchange_strong(expected, true)) {
                return;
            }
 
            try {
                if (on_complete) {
                    on_complete();
                }
            } catch (...) {
                report_callback_exception(
                    std::current_exception(),
                    "Exception in HttpRequestContext completion callback");
            }
 
            try {
                if (on_group_complete) {
                    on_group_complete();
                }
            } catch (...) {
                report_callback_exception(
                    std::current_exception(),
                    "Exception in HttpRequestContext group completion callback");
            }
        }
 
    private:
        static void report_callback_exception(
                std::exception_ptr exception,
                const char* message) noexcept {
            try {
                KURLYK_HANDLE_ERROR(exception, message);
            } catch (...) {
                // Error reporting must not interrupt request cleanup.
            }
        }
    }; // HttpRequestContext
 
} // namespace kurlyk
 
#endif // KURLYK_HEADER_KURLYK_HTTP_HTTP_REQUEST_MANAGER_HTTP_REQUEST_CONTEXT_HPP_INCLUDED