http_client Class Reference

HTTP client for AI service communication. More...

Collaboration diagram for http_client:

Public Member Functions
	http_client (const ai_service_config &config)
auto	post (const std::string &path, const std::string &body, const std::string &content_type="application/json") -> Result< http_response >
auto	get (const std::string &path) -> Result< http_response >
auto	del (const std::string &path) -> Result< http_response >
auto	check_connectivity () -> bool
auto	measure_latency () -> std::optional< std::chrono::milliseconds >

Private Member Functions
auto	send_request (const std::string &method, const std::string &path, const std::map< std::string, std::string > &headers, const std::string &body) -> Result< http_response >
std::map< std::string, std::string >	build_headers () const

Static Private Member Functions
static auto	parse_http_response (const std::string &raw) -> Result< http_response >

Private Attributes
ai_service_config	config_

Detailed Description

HTTP client for AI service communication.

Uses synchronous POSIX/Winsock sockets for HTTP/1.1 operations. No dependency on network_system internals (messaging_client, thread_manager).

Definition at line 554 of file ai_service_connector.cpp.

Constructor & Destructor Documentation

http_client()

http_client::http_client ( const ai_service_config & config )

inlineexplicit

Definition at line 556 of file ai_service_connector.cpp.

        : config_(config) {}

Member Function Documentation

build_headers()

std::map< std::string, std::string > http_client::build_headers ( ) const

inlinenodiscardprivate

Definition at line 777 of file ai_service_connector.cpp.

                                                                     {
        std::map<std::string, std::string> headers;
        headers["Content-Type"] = "application/json";
 
        switch (config_.auth_type) {
            case authentication_type::api_key:
                headers["X-API-Key"] = config_.api_key;
                break;
            case authentication_type::bearer_token:
                headers["Authorization"] = "Bearer " + config_.bearer_token;
                break;
            case authentication_type::basic: {
                std::string credentials = config_.username + ":" + config_.password;
                headers["Authorization"] = "Basic " + json_util::base64_encode(credentials);
                break;
            }
            case authentication_type::none:
            default:
                break;
        }
 
        return headers;
    }

check_connectivity()

auto http_client::check_connectivity ( ) -> bool

inlinenodiscard

Definition at line 590 of file ai_service_connector.cpp.

                                                    {
        auto result = get("/health");
        return result.is_ok() && result.value().is_success();
    }

del()

auto http_client::del ( const std::string & path ) -> Result<http_response>

inlinenodiscard

Definition at line 581 of file ai_service_connector.cpp.

                                 {
        kcenon::pacs::integration::logger_adapter::debug(
            "AI service DELETE request: {}", config_.base_url + path);
 
        auto headers = build_headers();
        return send_request("DELETE", path, headers, "");
    }

References kcenon::pacs::integration::logger_adapter::debug().

Here is the call graph for this function:

get()

auto http_client::get ( const std::string & path ) -> Result<http_response>

inlinenodiscard

Definition at line 572 of file ai_service_connector.cpp.

                                 {
        kcenon::pacs::integration::logger_adapter::debug(
            "AI service GET request: {}", config_.base_url + path);
 
        auto headers = build_headers();
        return send_request("GET", path, headers, "");
    }

References kcenon::pacs::integration::logger_adapter::debug().

Here is the call graph for this function:

measure_latency()

auto http_client::measure_latency ( ) -> std::optional<std::chrono::milliseconds>

inlinenodiscard

Definition at line 595 of file ai_service_connector.cpp.

                                                                               {
        auto start = std::chrono::steady_clock::now();
        auto result = get("/health");
        auto end = std::chrono::steady_clock::now();
 
        if (!result.is_ok()) {
            return std::nullopt;
        }
 
        return std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    }

parse_http_response()

static auto http_client::parse_http_response ( const std::string & raw ) -> Result<http_response>

inlinestaticnodiscardprivate

Definition at line 726 of file ai_service_connector.cpp.

                                 {
        http_response response;
 
        auto header_end = raw.find("\r\n\r\n");
        if (header_end == std::string::npos) {
            return error_info(-1, "Malformed HTTP response", "ai_service_connector");
        }
 
        // Parse status line
        auto first_line_end = raw.find("\r\n");
        std::string status_line = raw.substr(0, first_line_end);
 
        // Parse "HTTP/1.x STATUS_CODE REASON"
        auto first_space = status_line.find(' ');
        if (first_space == std::string::npos) {
            return error_info(-1, "Invalid HTTP status line", "ai_service_connector");
        }
        auto code_start = first_space + 1;
        try {
            response.status_code = std::stoi(status_line.substr(code_start));
        } catch (...) {
            return error_info(-1, "Invalid HTTP status code", "ai_service_connector");
        }
 
        // Parse headers
        auto headers_str = raw.substr(first_line_end + 2,
                                      header_end - first_line_end - 2);
        std::istringstream header_stream(headers_str);
        std::string line;
        while (std::getline(header_stream, line)) {
            if (!line.empty() && line.back() == '\r') line.pop_back();
            auto colon = line.find(':');
            if (colon != std::string::npos) {
                auto name = line.substr(0, colon);
                auto value = line.substr(colon + 1);
                // Trim leading whitespace from value
                auto val_start = value.find_first_not_of(' ');
                if (val_start != std::string::npos) {
                    value = value.substr(val_start);
                }
                response.headers[name] = value;
            }
        }
 
        // Extract body
        response.body = raw.substr(header_end + 4);
 
        return response;
    }

References http_response::body, http_response::headers, name, and http_response::status_code.

post()

auto http_client::post ( const std::string & path, const std::string & body, const std::string & content_type = "application/json" ) -> Result<http_response>

inlinenodiscard

Definition at line 559 of file ai_service_connector.cpp.

                                 {
        kcenon::pacs::integration::logger_adapter::debug(
            "AI service POST request: {} (body size: {} bytes)",
            config_.base_url + path, body.size());
 
        auto headers = build_headers();
        headers["Content-Type"] = content_type;
        return send_request("POST", path, headers, body);
    }

References kcenon::pacs::integration::logger_adapter::debug().

Here is the call graph for this function:

send_request()

auto http_client::send_request ( const std::string & method, const std::string & path, const std::map< std::string, std::string > & headers, const std::string & body ) -> Result<http_response>

inlinenodiscardprivate

Definition at line 610 of file ai_service_connector.cpp.

                                                        {
 
        std::string full_url = config_.base_url + path;
        auto url = parsed_url::parse(full_url);
        if (!url) {
            return error_info(-1, "Invalid URL: " + full_url, "ai_service_connector");
        }
 
        // Resolve hostname
        struct addrinfo hints{};
        hints.ai_family = AF_UNSPEC;
        hints.ai_socktype = SOCK_STREAM;
        hints.ai_protocol = IPPROTO_TCP;
 
        struct addrinfo* addr_result = nullptr;
        int gai_err = getaddrinfo(url->host.c_str(), url->port.c_str(),
                                  &hints, &addr_result);
        if (gai_err != 0) {
            return error_info(-1,
                "DNS resolution failed for " + url->host + ": " +
                    gai_strerror(gai_err),
                "ai_service_connector");
        }
 
        // RAII cleanup for addrinfo
        auto addr_cleanup = [](struct addrinfo* p) { freeaddrinfo(p); };
        std::unique_ptr<struct addrinfo, decltype(addr_cleanup)>
            addr_guard(addr_result, addr_cleanup);
 
        // Create and connect socket
        socket_handle sock(
            ::socket(addr_result->ai_family, addr_result->ai_socktype,
                     addr_result->ai_protocol));
        if (!sock.valid()) {
            return error_info(-1, "Failed to create socket", "ai_service_connector");
        }
 
        // Set socket timeout
        auto timeout_sec = std::chrono::duration_cast<std::chrono::seconds>(
            config_.connection_timeout).count();
        if (timeout_sec <= 0) timeout_sec = 30;
 
#ifdef _WIN32
        DWORD tv = static_cast<DWORD>(timeout_sec * 1000);
        setsockopt(sock.get(), SOL_SOCKET, SO_RCVTIMEO,
                   reinterpret_cast<const char*>(&tv), sizeof(tv));
        setsockopt(sock.get(), SOL_SOCKET, SO_SNDTIMEO,
                   reinterpret_cast<const char*>(&tv), sizeof(tv));
#else
        struct timeval tv{};
        tv.tv_sec = timeout_sec;
        setsockopt(sock.get(), SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
        setsockopt(sock.get(), SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
#endif
 
        // Connect
        if (::connect(sock.get(), addr_result->ai_addr,
                      static_cast<int>(addr_result->ai_addrlen)) != 0) {
            return error_info(-1,
                "Connection failed to " + url->host + ":" + url->port,
                "ai_service_connector");
        }
 
        // Build HTTP request
        std::ostringstream request_stream;
        request_stream << method << " " << url->path << " HTTP/1.1\r\n";
        request_stream << "Host: " << url->host << "\r\n";
        request_stream << "Connection: close\r\n";
 
        for (const auto& [name, value] : headers) {
            request_stream << name << ": " << value << "\r\n";
        }
 
        if (!body.empty()) {
            request_stream << "Content-Length: " << body.size() << "\r\n";
        }
        request_stream << "\r\n";
        request_stream << body;
 
        std::string request_data = request_stream.str();
 
        // Send request
        auto total_sent = std::size_t{0};
        while (total_sent < request_data.size()) {
            auto sent = ::send(sock.get(),
                               request_data.data() + total_sent,
                               static_cast<int>(request_data.size() - total_sent),
                               0);
            if (sent <= 0) {
                return error_info(-1, "Failed to send HTTP request",
                                  "ai_service_connector");
            }
            total_sent += static_cast<std::size_t>(sent);
        }
 
        // Receive response
        std::string response_data;
        char buffer[4096];
        while (true) {
            auto received = ::recv(sock.get(), buffer, sizeof(buffer), 0);
            if (received < 0) {
                return error_info(-1, "Failed to receive HTTP response",
                                  "ai_service_connector");
            }
            if (received == 0) break;  // Connection closed
            response_data.append(buffer, static_cast<std::size_t>(received));
        }
 
        // Parse HTTP response
        return parse_http_response(response_data);
    }

References name, and parsed_url::parse().

Here is the call graph for this function:

Member Data Documentation

config_

ai_service_config http_client::config_

private

Definition at line 608 of file ai_service_connector.cpp.

---

The documentation for this class was generated from the following file:

• src/ai/ai_service_connector.cpp