ai_service_connector.cpp File Reference

Implementation of AI service connector. More...

#include <kcenon/pacs/ai/ai_service_connector.h>
#include <kcenon/pacs/integration/logger_adapter.h>
#include <kcenon/pacs/integration/monitoring_adapter.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <iomanip>
#include <mutex>
#include <queue>
#include <shared_mutex>
#include <sstream>
#include <thread>
#include <unordered_map>

Include dependency graph for ai_service_connector.cpp:

Go to the source code of this file.

Classes
struct	http_response
	Simple HTTP response structure. More...
class	socket_handle
	RAII wrapper for platform socket handle. More...
struct	parsed_url
	Parse URL into host, port, and path components. More...
class	http_client
	HTTP client for AI service communication. More...
class	job_tracker
	Tracks active inference jobs. More...
class	ai_service_connector::impl

Namespaces
namespace	kcenon
namespace	kcenon::pacs
namespace	kcenon::pacs::ai
namespace	kcenon::pacs::ai::metrics
namespace	kcenon::pacs::ai::json_util

Functions
std::string	kcenon::pacs::ai::json_util::escape_string (std::string_view str)
	Escape special characters in JSON string.
std::string	kcenon::pacs::ai::json_util::to_iso8601 (std::chrono::system_clock::time_point tp)
	Convert time_point to ISO 8601 string.
std::optional< std::chrono::system_clock::time_point >	kcenon::pacs::ai::json_util::from_iso8601 (const std::string &str)
	Parse ISO 8601 string to time_point.
std::optional< std::string >	kcenon::pacs::ai::json_util::extract_string (const std::string &json, const std::string &key)
	Simple JSON value extractor (for basic parsing)
std::optional< int >	kcenon::pacs::ai::json_util::extract_int (const std::string &json, const std::string &key)
	Simple JSON integer extractor.
std::string	kcenon::pacs::ai::json_util::build_request_json (const inference_request &request)
	Build inference request JSON.
	kcenon::pacs::ai::if (!request.parameters.empty())
	kcenon::pacs::ai::if (!request.metadata.empty())
std::optional< inference_status >	parse_status_json (const std::string &json)
	Parse inference status from JSON response.
std::optional< model_info >	parse_model_json (const std::string &json)
	Parse model info from JSON.
std::string	base64_encode (std::string_view input)
	Encode data to Base64.
std::vector< std::string >	extract_json_array_objects (const std::string &json)
	Extract JSON objects from a JSON array string.

Variables
constexpr const char *	kcenon::pacs::ai::metrics::inference_requests_total = "pacs_ai_inference_requests_total"
constexpr const char *	kcenon::pacs::ai::metrics::inference_requests_success = "pacs_ai_inference_requests_success"
constexpr const char *	kcenon::pacs::ai::metrics::inference_requests_failed = "pacs_ai_inference_requests_failed"
constexpr const char *	kcenon::pacs::ai::metrics::inference_duration = "pacs_ai_inference_duration_seconds"
constexpr const char *	kcenon::pacs::ai::metrics::active_jobs = "pacs_ai_active_jobs"

Detailed Description

Implementation of AI service connector.

Definition in file ai_service_connector.cpp.

Function Documentation

base64_encode()

std::string base64_encode ( std::string_view input )

inlinenodiscard

Encode data to Base64.

Definition at line 364 of file ai_service_connector.cpp.

                                                                   {
    static constexpr char table[] =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
    std::string result;
    result.reserve(((input.size() + 2) / 3) * 4);
 
    auto ptr = reinterpret_cast<const unsigned char*>(input.data());
    auto len = input.size();
 
    for (std::size_t i = 0; i < len; i += 3) {
        uint32_t octet_a = ptr[i];
        uint32_t octet_b = (i + 1 < len) ? ptr[i + 1] : 0;
        uint32_t octet_c = (i + 2 < len) ? ptr[i + 2] : 0;
 
        uint32_t triple = (octet_a << 16) | (octet_b << 8) | octet_c;
 
        result += table[(triple >> 18) & 0x3F];
        result += table[(triple >> 12) & 0x3F];
        result += (i + 1 < len) ? table[(triple >> 6) & 0x3F] : '=';
        result += (i + 2 < len) ? table[triple & 0x3F] : '=';
    }
 
    return result;
}

extract_json_array_objects()

std::vector< std::string > extract_json_array_objects ( const std::string & json )

inlinenodiscard

Extract JSON objects from a JSON array string.

Definition at line 393 of file ai_service_connector.cpp.

                           {
    std::vector<std::string> objects;
 
    // Find array start
    auto arr_start = json.find('[');
    if (arr_start == std::string::npos) {
        return objects;
    }
 
    int depth = 0;
    std::size_t obj_start = std::string::npos;
 
    for (std::size_t i = arr_start + 1; i < json.size(); ++i) {
        char c = json[i];
 
        if (c == '"') {
            // Skip string content
            ++i;
            while (i < json.size() && json[i] != '"') {
                if (json[i] == '\\') ++i;  // Skip escaped character
                ++i;
            }
            continue;
        }
 
        if (c == '{') {
            if (depth == 0) {
                obj_start = i;
            }
            ++depth;
        } else if (c == '}') {
            --depth;
            if (depth == 0 && obj_start != std::string::npos) {
                objects.push_back(json.substr(obj_start, i - obj_start + 1));
                obj_start = std::string::npos;
            }
        } else if (c == ']' && depth == 0) {
            break;
        }
    }
 
    return objects;
}

parse_model_json()

std::optional< model_info > parse_model_json ( const std::string & json )

inlinenodiscard

Parse model info from JSON.

Definition at line 333 of file ai_service_connector.cpp.

                           {
    model_info info;
 
    auto model_id = extract_string(json, "model_id");
    if (!model_id) {
        return std::nullopt;
    }
    info.model_id = *model_id;
 
    auto name = extract_string(json, "name");
    if (name) {
        info.name = *name;
    }
 
    auto description = extract_string(json, "description");
    if (description) {
        info.description = *description;
    }
 
    auto version = extract_string(json, "version");
    if (version) {
        info.version = *version;
    }
 
    return info;
}

References kcenon::pacs::ai::json_util::extract_string(), and name.

Here is the call graph for this function:

parse_status_json()

std::optional< inference_status > parse_status_json ( const std::string & json )

inlinenodiscard

Parse inference status from JSON response.

Definition at line 261 of file ai_service_connector.cpp.

                           {
    inference_status status;
 
    auto job_id = extract_string(json, "job_id");
    if (!job_id) {
        return std::nullopt;
    }
    status.job_id = *job_id;
 
    auto status_str = extract_string(json, "status");
    if (status_str) {
        if (*status_str == "pending") {
            status.status = inference_status_code::pending;
        } else if (*status_str == "running") {
            status.status = inference_status_code::running;
        } else if (*status_str == "completed") {
            status.status = inference_status_code::completed;
        } else if (*status_str == "failed") {
            status.status = inference_status_code::failed;
        } else if (*status_str == "cancelled") {
            status.status = inference_status_code::cancelled;
        } else if (*status_str == "timeout") {
            status.status = inference_status_code::timeout;
        }
    }
 
    auto progress = extract_int(json, "progress");
    if (progress) {
        status.progress = *progress;
    }
 
    auto message = extract_string(json, "message");
    if (message) {
        status.message = *message;
    }
 
    auto error = extract_string(json, "error_message");
    if (error) {
        status.error_message = *error;
    }
 
    auto created_at = extract_string(json, "created_at");
    if (created_at) {
        auto tp = from_iso8601(*created_at);
        if (tp) {
            status.created_at = *tp;
        }
    }
 
    auto started_at = extract_string(json, "started_at");
    if (started_at) {
        auto tp = from_iso8601(*started_at);
        if (tp) {
            status.started_at = *tp;
        }
    }
 
    auto completed_at = extract_string(json, "completed_at");
    if (completed_at) {
        auto tp = from_iso8601(*completed_at);
        if (tp) {
            status.completed_at = *tp;
        }
    }
 
    return status;
}

References kcenon::pacs::ai::cancelled, kcenon::pacs::ai::completed, kcenon::pacs::ai::json_util::extract_int(), kcenon::pacs::ai::json_util::extract_string(), kcenon::pacs::ai::failed, kcenon::pacs::ai::json_util::from_iso8601(), kcenon::pacs::ai::pending, kcenon::pacs::ai::running, and kcenon::pacs::ai::timeout.

Here is the call graph for this function: