http_errors.h

Go to the documentation of this file.

 
#pragma once
 
#include <asio/error.hpp>
#include <asio/ssl/error.hpp>
 
#include <openssl/err.h>
#include <openssl/ssl.h>
 
#include <cerrno>
#include <exception>
#include <stdexcept>
#include <string>
#include <system_error>
 
namespace neograph::async {
 
enum class HttpErrorKind {
    // ── Retryable ─────────────────────────────────────────────────
    ConnectRefused,       
    ConnectTimeout,       
    DnsTemporary,         
    ReadTimeout,          
    WriteTimeout,         
    PeerReset,            
    PeerEofEarly,         
    TlsHandshakeReset,    
    ServerError,          
    TooManyRequests,      
 
    // ── Not retryable ─────────────────────────────────────────────
    DnsPermanent,         
    TlsVerifyFailed,      
    ProtocolError,        
    RequestTooLarge,      
    PayloadInvalid,       
 
    // ── Catch-all ─────────────────────────────────────────────────
    Unknown,              
};
 
constexpr bool is_retryable(HttpErrorKind k) noexcept {
    switch (k) {
        case HttpErrorKind::ConnectRefused:
        case HttpErrorKind::ConnectTimeout:
        case HttpErrorKind::DnsTemporary:
        case HttpErrorKind::ReadTimeout:
        case HttpErrorKind::WriteTimeout:
        case HttpErrorKind::PeerReset:
        case HttpErrorKind::PeerEofEarly:
        case HttpErrorKind::TlsHandshakeReset:
        case HttpErrorKind::ServerError:
        case HttpErrorKind::TooManyRequests:
            return true;
        case HttpErrorKind::DnsPermanent:
        case HttpErrorKind::TlsVerifyFailed:
        case HttpErrorKind::ProtocolError:
        case HttpErrorKind::RequestTooLarge:
        case HttpErrorKind::PayloadInvalid:
        case HttpErrorKind::Unknown:
            return false;
    }
    return false;
}
 
inline HttpErrorKind classify_asio_error(const asio::error_code& ec) noexcept {
    if (!ec) return HttpErrorKind::Unknown;
 
    const auto& cat = ec.category();
 
    // asio::error::get_ssl_category() — OpenSSL error_codes.
    // Short-read (peer closed the TLS stream without close_notify)
    // is shaped differently in OpenSSL 1.x vs 3.x; asio normalizes
    // it as asio::ssl::error::stream_truncated, so compare against
    // the enum instead of a raw SSL_R_* reason.
    if (ec == asio::ssl::error::stream_truncated) {
        return HttpErrorKind::PeerEofEarly;
    }
    if (cat == asio::error::get_ssl_category()) {
        const int reason = ERR_GET_REASON(ec.value());
        if (reason == SSL_R_CERTIFICATE_VERIFY_FAILED) {
            return HttpErrorKind::TlsVerifyFailed;
        }
        return HttpErrorKind::TlsHandshakeReset;
    }
 
    // Match known asio enumerators directly. Doing this BEFORE any
    // category-based dispatch is important on Windows, where
    // asio::error::get_netdb_category() and get_misc_category() both
    // alias to system_category() — so a system errno like
    // WSAECONNREFUSED would hit the netdb branch first and fall out
    // as DnsPermanent. The ec==enum comparison matches by numeric
    // value within the enum's native category and is stable across
    // POSIX (errno) and Windows (WSA*).
    if (ec == asio::error::connection_refused) return HttpErrorKind::ConnectRefused;
    if (ec == asio::error::timed_out)          return HttpErrorKind::ConnectTimeout;
    if (ec == asio::error::connection_reset)   return HttpErrorKind::PeerReset;
    if (ec == asio::error::broken_pipe)        return HttpErrorKind::PeerReset;
    if (ec == asio::error::not_connected)      return HttpErrorKind::PeerReset;
    if (ec == asio::error::eof)                return HttpErrorKind::PeerEofEarly;
    if (ec == asio::error::host_not_found)     return HttpErrorKind::DnsPermanent;
    if (ec == asio::error::host_not_found_try_again)
        return HttpErrorKind::DnsTemporary;
 
    // Linux-only: netdb and misc categories are distinct from the
    // system category, so unknown values there are still best
    // classified as DNS / misc rather than fully Unknown. On Windows
    // these checks are no-ops because the specific-enum block above
    // already handled the real cases and the remaining system errors
    // deserve Unknown (retry = false) rather than being misrouted.
#if !defined(ASIO_WINDOWS) && !defined(_WIN32)
    if (cat == asio::error::get_netdb_category()) {
        return HttpErrorKind::DnsPermanent;
    }
    if (cat == asio::error::get_misc_category()) {
        return HttpErrorKind::Unknown;
    }
#else
    (void)cat;
#endif
    return HttpErrorKind::Unknown;
}
 
constexpr HttpErrorKind classify_http_status(int status) noexcept {
    if (status >= 500 && status < 600) return HttpErrorKind::ServerError;
    if (status == 429)                 return HttpErrorKind::TooManyRequests;
    if (status == 413)                 return HttpErrorKind::RequestTooLarge;
    if (status >= 400 && status < 500) return HttpErrorKind::PayloadInvalid;
    return HttpErrorKind::Unknown;
}
 
struct HttpError : std::runtime_error {
    HttpErrorKind kind        = HttpErrorKind::Unknown;
    int           http_status = 0;           
    std::string   retry_after;               
 
    HttpError(HttpErrorKind k, std::string msg)
        : std::runtime_error(std::move(msg)), kind(k) {}
};
 
}  // namespace neograph::async