server.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/frame.h"
#include "kcenon/network/detail/protocols/grpc/status.h"
#include "kcenon/network/detail/utils/result_types.h"
 
#include <chrono>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
namespace kcenon::network::protocols::grpc
{
    using grpc_metadata = std::vector<std::pair<std::string, std::string>>;
    struct grpc_server_config
    {
        size_t max_concurrent_streams = 100;
 
        size_t max_message_size = default_max_message_size;
 
        std::chrono::milliseconds keepalive_time{7200000};  // 2 hours
 
        std::chrono::milliseconds keepalive_timeout{20000};
 
        std::chrono::milliseconds max_connection_idle{0};  // 0 = unlimited
 
        std::chrono::milliseconds max_connection_age{0};  // 0 = unlimited
 
        size_t num_threads = 0;
    };
 
    class server_context
    {
    public:
        virtual auto client_metadata() const -> const grpc_metadata& = 0;
 
        virtual auto add_trailing_metadata(const std::string& key,
                                           const std::string& value) -> void = 0;
 
        virtual auto set_trailing_metadata(grpc_metadata metadata) -> void = 0;
 
        virtual auto is_cancelled() const -> bool = 0;
 
        virtual auto deadline() const
            -> std::optional<std::chrono::system_clock::time_point> = 0;
 
        virtual auto peer() const -> std::string = 0;
 
        virtual auto auth_context() const -> std::string = 0;
 
        virtual ~server_context() = default;
    };
 
    using unary_handler = std::function<
        std::pair<grpc_status, std::vector<uint8_t>>(
            server_context& ctx,
            const std::vector<uint8_t>& request)>;
 
    class server_writer
    {
    public:
        virtual auto write(const std::vector<uint8_t>& message) -> VoidResult = 0;
 
        virtual ~server_writer() = default;
    };
 
    using server_streaming_handler = std::function<
        grpc_status(
            server_context& ctx,
            const std::vector<uint8_t>& request,
            server_writer& writer)>;
 
    class server_reader
    {
    public:
        virtual auto read() -> Result<std::vector<uint8_t>> = 0;
 
        virtual auto has_more() const -> bool = 0;
 
        virtual ~server_reader() = default;
    };
 
    using client_streaming_handler = std::function<
        std::pair<grpc_status, std::vector<uint8_t>>(
            server_context& ctx,
            server_reader& reader)>;
 
    class server_reader_writer
    {
    public:
        virtual auto read() -> Result<std::vector<uint8_t>> = 0;
        virtual auto write(const std::vector<uint8_t>& message) -> VoidResult = 0;
        virtual auto has_more() const -> bool = 0;
 
        virtual ~server_reader_writer() = default;
    };
 
    using bidi_streaming_handler = std::function<
        grpc_status(
            server_context& ctx,
            server_reader_writer& stream)>;
 
    class grpc_service
    {
    public:
        virtual auto service_name() const -> std::string_view = 0;
 
        virtual ~grpc_service() = default;
    };
 
    class grpc_server
    {
    public:
        explicit grpc_server(const grpc_server_config& config = {});
 
        ~grpc_server();
 
        // Non-copyable
        grpc_server(const grpc_server&) = delete;
        grpc_server& operator=(const grpc_server&) = delete;
 
        // Movable
        grpc_server(grpc_server&&) noexcept;
        grpc_server& operator=(grpc_server&&) noexcept;
 
        auto start(uint16_t port) -> VoidResult;
 
        auto start_tls(uint16_t port,
                       const std::string& cert_path,
                       const std::string& key_path,
                       const std::string& ca_path = "") -> VoidResult;
 
        auto stop() -> void;
 
        auto wait() -> void;
 
        auto is_running() const -> bool;
 
        auto port() const -> uint16_t;
 
        auto register_service(grpc_service* service) -> VoidResult;
 
        auto register_unary_method(const std::string& full_method_name,
                                   unary_handler handler) -> VoidResult;
 
        auto register_server_streaming_method(const std::string& full_method_name,
                                              server_streaming_handler handler) -> VoidResult;
 
        auto register_client_streaming_method(const std::string& full_method_name,
                                              client_streaming_handler handler) -> VoidResult;
 
        auto register_bidi_streaming_method(const std::string& full_method_name,
                                            bidi_streaming_handler handler) -> VoidResult;
 
    private:
        class impl;
        std::unique_ptr<impl> impl_;
    };
 
} // namespace kcenon::network::protocols::grpc