grpc_official_wrapper.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 <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
// Forward declarations for gRPC types
#if NETWORK_GRPC_OFFICIAL
namespace grpc {
class Status;
class ServerContext;
class ClientContext;
class Channel;
}
#endif
 
namespace kcenon::network::protocols::grpc
{
 
// ============================================================================
// Channel Credentials Configuration
// ============================================================================
 
struct channel_credentials_config
{
    bool insecure = false;
 
    std::string root_certificates;
 
    std::optional<std::string> client_certificate;
 
    std::optional<std::string> client_key;
};
 
// ============================================================================
// Status Conversion Utilities
// ============================================================================
 
#if NETWORK_GRPC_OFFICIAL
 
auto from_grpc_status(const ::grpc::Status& status) -> grpc_status;
 
auto to_grpc_status(const grpc_status& status) -> ::grpc::Status;
 
template<typename T>
auto result_to_grpc_status(const Result<T>& result) -> ::grpc::Status;
 
auto void_result_to_grpc_status(const VoidResult& result) -> ::grpc::Status;
 
template<typename T>
auto grpc_status_to_result(const ::grpc::Status& status, T&& value) -> Result<T>;
 
auto grpc_status_to_void_result(const ::grpc::Status& status) -> VoidResult;
 
// ============================================================================
// Error Code Mapping
// ============================================================================
 
namespace detail
{
 
auto map_grpc_code_to_error(int code) -> int;
 
auto map_status_to_grpc_code(status_code code) -> int;
 
} // namespace detail
 
// ============================================================================
// Deadline Utilities
// ============================================================================
 
auto set_deadline(::grpc::ClientContext* ctx,
                  std::chrono::system_clock::time_point deadline) -> void;
 
template<typename Rep, typename Period>
auto set_timeout(::grpc::ClientContext* ctx,
                 std::chrono::duration<Rep, Period> timeout) -> void
{
    set_deadline(ctx, std::chrono::system_clock::now() + timeout);
}
 
auto get_remaining_time(const ::grpc::ServerContext* ctx)
    -> std::optional<std::chrono::milliseconds>;
 
// ============================================================================
// Channel Management
// ============================================================================
 
auto create_channel(const std::string& target,
                    const channel_credentials_config& config)
    -> std::shared_ptr<::grpc::Channel>;
 
auto create_insecure_channel(const std::string& target)
    -> std::shared_ptr<::grpc::Channel>;
 
auto wait_for_channel_ready(const std::shared_ptr<::grpc::Channel>& channel,
                            std::chrono::milliseconds timeout) -> bool;
 
// ============================================================================
// Server Streaming Adapters
// ============================================================================
 
class official_server_writer;
 
class official_server_reader;
 
class official_server_reader_writer;
 
// ============================================================================
// Client Streaming Adapters
// ============================================================================
 
class official_client_reader;
 
class official_client_writer;
 
class official_client_reader_writer;
 
#endif // NETWORK_GRPC_OFFICIAL
 
} // namespace kcenon::network::protocols::grpc