service_registry.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "kcenon/network/detail/protocols/grpc/server.h"
#include "kcenon/network/detail/protocols/grpc/status.h"
#include "kcenon/network/detail/utils/result_types.h"
 
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
// Forward declarations for gRPC types
#if NETWORK_GRPC_OFFICIAL
namespace grpc {
class Service;
class Server;
class ServerBuilder;
class ServerContext;
class ByteBuffer;
namespace reflection {
namespace v1alpha {
class ServerReflectionRequest;
class ServerReflectionResponse;
}
}
}
#endif
 
namespace kcenon::network::protocols::grpc
{
 
// ============================================================================
// Method Types and Descriptors
// ============================================================================
 
enum class method_type
{
    unary,              
    server_streaming,   
    client_streaming,   
    bidi_streaming      
};
 
struct method_descriptor
{
    std::string name;
 
    std::string full_name;
 
    method_type type = method_type::unary;
 
    std::string input_type;
 
    std::string output_type;
 
    auto is_client_streaming() const -> bool
    {
        return type == method_type::client_streaming ||
               type == method_type::bidi_streaming;
    }
 
    auto is_server_streaming() const -> bool
    {
        return type == method_type::server_streaming ||
               type == method_type::bidi_streaming;
    }
};
 
struct service_descriptor
{
    std::string name;
 
    std::string package;
 
    std::vector<method_descriptor> methods;
 
    auto find_method(std::string_view method_name) const
        -> const method_descriptor*
    {
        for (const auto& method : methods)
        {
            if (method.name == method_name)
            {
                return &method;
            }
        }
        return nullptr;
    }
 
    auto full_name() const -> std::string
    {
        if (package.empty())
        {
            return name;
        }
        return package + "." + name;
    }
};
 
// ============================================================================
// Service Interface
// ============================================================================
 
class service_base
{
public:
    virtual ~service_base() = default;
 
    virtual auto descriptor() const -> const service_descriptor& = 0;
 
    virtual auto is_ready() const -> bool { return true; }
 
#if NETWORK_GRPC_OFFICIAL
    virtual auto grpc_service() -> ::grpc::Service* { return nullptr; }
#endif
};
 
// ============================================================================
// Generic Service (Dynamic Registration)
// ============================================================================
 
class generic_service : public service_base
{
public:
    explicit generic_service(std::string service_name);
 
    ~generic_service() override;
 
    // Non-copyable
    generic_service(const generic_service&) = delete;
    generic_service& operator=(const generic_service&) = delete;
 
    // Movable
    generic_service(generic_service&&) noexcept;
    generic_service& operator=(generic_service&&) noexcept;
 
    auto descriptor() const -> const service_descriptor& override;
 
    auto register_unary_method(
        const std::string& method_name,
        unary_handler handler,
        const std::string& input_type = "",
        const std::string& output_type = "") -> VoidResult;
 
    auto register_server_streaming_method(
        const std::string& method_name,
        server_streaming_handler handler,
        const std::string& input_type = "",
        const std::string& output_type = "") -> VoidResult;
 
    auto register_client_streaming_method(
        const std::string& method_name,
        client_streaming_handler handler,
        const std::string& input_type = "",
        const std::string& output_type = "") -> VoidResult;
 
    auto register_bidi_streaming_method(
        const std::string& method_name,
        bidi_streaming_handler handler,
        const std::string& input_type = "",
        const std::string& output_type = "") -> VoidResult;
 
    auto get_unary_handler(const std::string& method_name) const
        -> const unary_handler*;
 
    auto get_server_streaming_handler(const std::string& method_name) const
        -> const server_streaming_handler*;
 
    auto get_client_streaming_handler(const std::string& method_name) const
        -> const client_streaming_handler*;
 
    auto get_bidi_streaming_handler(const std::string& method_name) const
        -> const bidi_streaming_handler*;
 
#if NETWORK_GRPC_OFFICIAL
    auto grpc_service() -> ::grpc::Service* override;
#endif
 
private:
    class impl;
    std::unique_ptr<impl> impl_;
};
 
// ============================================================================
// Protoc Service Adapter
// ============================================================================
 
#if NETWORK_GRPC_OFFICIAL
 
class protoc_service_adapter : public service_base
{
public:
    protoc_service_adapter(std::unique_ptr<::grpc::Service> service,
                           std::string service_name);
 
    protoc_service_adapter(::grpc::Service* service,
                           std::string service_name);
 
    ~protoc_service_adapter() override;
 
    // Non-copyable
    protoc_service_adapter(const protoc_service_adapter&) = delete;
    protoc_service_adapter& operator=(const protoc_service_adapter&) = delete;
 
    // Movable
    protoc_service_adapter(protoc_service_adapter&&) noexcept;
    protoc_service_adapter& operator=(protoc_service_adapter&&) noexcept;
 
    auto descriptor() const -> const service_descriptor& override;
 
    auto grpc_service() -> ::grpc::Service* override;
 
private:
    class impl;
    std::unique_ptr<impl> impl_;
};
 
#endif // NETWORK_GRPC_OFFICIAL
 
// ============================================================================
// Service Registry
// ============================================================================
 
struct registry_config
{
    bool enable_reflection = false;
 
    bool enable_health_check = false;
 
    std::string health_service_name = "grpc.health.v1.Health";
};
 
class service_registry
{
public:
    explicit service_registry(const registry_config& config = {});
 
    ~service_registry();
 
    // Non-copyable
    service_registry(const service_registry&) = delete;
    service_registry& operator=(const service_registry&) = delete;
 
    // Movable
    service_registry(service_registry&&) noexcept;
    service_registry& operator=(service_registry&&) noexcept;
 
    auto register_service(service_base* service) -> VoidResult;
 
    auto unregister_service(const std::string& service_name) -> VoidResult;
 
    auto find_service(const std::string& service_name) const -> service_base*;
 
    auto services() const -> std::vector<service_base*>;
 
    auto service_names() const -> std::vector<std::string>;
 
    auto find_method(const std::string& full_method_path) const
        -> std::optional<std::pair<service_base*, const method_descriptor*>>;
 
    auto is_reflection_enabled() const -> bool;
 
    auto configure_server(grpc_server& server) -> VoidResult;
 
#if NETWORK_GRPC_OFFICIAL
    auto configure_server_builder(::grpc::ServerBuilder& builder) -> VoidResult;
 
    auto enable_reflection(::grpc::ServerBuilder& builder) -> VoidResult;
#endif
 
    auto set_service_health(const std::string& service_name, bool serving)
        -> VoidResult;
 
    auto get_service_health(const std::string& service_name) const -> bool;
 
private:
    class impl;
    std::unique_ptr<impl> impl_;
};
 
// ============================================================================
// Health Checking Support
// ============================================================================
 
enum class health_status
{
    unknown,        
    serving,        
    not_serving,    
    service_unknown 
};
 
class health_service : public service_base
{
public:
    health_service();
    ~health_service() override;
 
    // Non-copyable
    health_service(const health_service&) = delete;
    health_service& operator=(const health_service&) = delete;
 
    // Movable
    health_service(health_service&&) noexcept;
    health_service& operator=(health_service&&) noexcept;
 
    auto descriptor() const -> const service_descriptor& override;
 
    auto set_status(const std::string& service_name, health_status status) -> void;
 
    auto get_status(const std::string& service_name) const -> health_status;
 
    auto clear() -> void;
 
#if NETWORK_GRPC_OFFICIAL
    auto grpc_service() -> ::grpc::Service* override;
#endif
 
private:
    class impl;
    std::unique_ptr<impl> impl_;
};
 
// ============================================================================
// Utility Functions
// ============================================================================
 
auto parse_method_path(std::string_view full_path)
    -> std::optional<std::pair<std::string, std::string>>;
 
auto build_method_path(std::string_view service_name,
                       std::string_view method_name) -> std::string;
 
} // namespace kcenon::network::protocols::grpc