client.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 <vector>
 
namespace kcenon::network::protocols::grpc
{
    using grpc_metadata = std::vector<std::pair<std::string, std::string>>;
 
    struct grpc_channel_config
    {
        std::chrono::milliseconds default_timeout{30000};
 
        bool use_tls = true;
 
        std::string root_certificates;
 
        std::optional<std::string> client_certificate;
 
        std::optional<std::string> client_key;
 
        size_t max_message_size = default_max_message_size;
 
        std::chrono::milliseconds keepalive_time{0};
 
        std::chrono::milliseconds keepalive_timeout{20000};
 
        uint32_t max_retry_attempts = 3;
    };
 
    struct call_options
    {
        std::optional<std::chrono::system_clock::time_point> deadline;
 
        grpc_metadata metadata;
 
        bool wait_for_ready = false;
 
        std::string compression_algorithm;
 
        template<typename Duration>
        void set_timeout(Duration timeout)
        {
            deadline = std::chrono::system_clock::now() +
                       std::chrono::duration_cast<std::chrono::system_clock::duration>(timeout);
        }
    };
 
    class grpc_client
    {
    public:
        explicit grpc_client(const std::string& target,
                             const grpc_channel_config& config = {});
 
        ~grpc_client();
 
        // Non-copyable
        grpc_client(const grpc_client&) = delete;
        grpc_client& operator=(const grpc_client&) = delete;
 
        // Movable
        grpc_client(grpc_client&&) noexcept;
        grpc_client& operator=(grpc_client&&) noexcept;
 
        auto connect() -> VoidResult;
 
        auto disconnect() -> void;
 
        auto is_connected() const -> bool;
 
        auto wait_for_connected(std::chrono::milliseconds timeout) -> bool;
 
        auto target() const -> const std::string&;
 
        auto call_raw(const std::string& method,
                      const std::vector<uint8_t>& request,
                      const call_options& options = {}) -> Result<grpc_message>;
 
        auto call_raw_async(const std::string& method,
                            const std::vector<uint8_t>& request,
                            std::function<void(Result<grpc_message>)> callback,
                            const call_options& options = {}) -> void;
 
        class server_stream_reader
        {
        public:
            virtual auto read() -> Result<grpc_message> = 0;
 
            virtual auto has_more() const -> bool = 0;
 
            virtual auto finish() -> grpc_status = 0;
 
            virtual ~server_stream_reader() = default;
        };
 
        auto server_stream_raw(const std::string& method,
                               const std::vector<uint8_t>& request,
                               const call_options& options = {})
            -> Result<std::unique_ptr<server_stream_reader>>;
 
        class client_stream_writer
        {
        public:
            virtual auto write(const std::vector<uint8_t>& message) -> VoidResult = 0;
 
            virtual auto writes_done() -> VoidResult = 0;
 
            virtual auto finish() -> Result<grpc_message> = 0;
 
            virtual ~client_stream_writer() = default;
        };
 
        auto client_stream_raw(const std::string& method,
                               const call_options& options = {})
            -> Result<std::unique_ptr<client_stream_writer>>;
 
        class bidi_stream
        {
        public:
            virtual auto write(const std::vector<uint8_t>& message) -> VoidResult = 0;
 
            virtual auto read() -> Result<grpc_message> = 0;
 
            virtual auto writes_done() -> VoidResult = 0;
 
            virtual auto finish() -> grpc_status = 0;
 
            virtual ~bidi_stream() = default;
        };
 
        auto bidi_stream_raw(const std::string& method,
                             const call_options& options = {})
            -> Result<std::unique_ptr<bidi_stream>>;
 
    private:
        class impl;
        std::unique_ptr<impl> impl_;
    };
 
} // namespace kcenon::network::protocols::grpc