resilient_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 <atomic>
#include <chrono>
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
#include "internal/core/messaging_client.h"
 
#ifdef WITH_COMMON_SYSTEM
#include "kcenon/common/resilience/circuit_breaker.h"
#include "kcenon/common/resilience/circuit_state.h"
#endif
 
#include "kcenon/network/detail/utils/result_types.h"
 
namespace kcenon::network::utils
{
 
    class resilient_client
    {
    public:
        resilient_client(const std::string& client_id,
                         const std::string& host,
                         unsigned short port,
                         size_t max_retries = 3,
                         std::chrono::milliseconds initial_backoff = std::chrono::seconds(1)
#ifdef WITH_COMMON_SYSTEM
                         , common::resilience::circuit_breaker_config cb_config = {}
#endif
                         );
 
        ~resilient_client() noexcept;
 
        auto connect() -> VoidResult;
 
        auto disconnect() -> VoidResult;
 
        auto send_with_retry(std::vector<uint8_t>&& data) -> VoidResult;
 
        [[nodiscard]] auto is_connected() const noexcept -> bool;
 
        auto set_reconnect_callback(std::function<void(size_t attempt)> callback) -> void;
 
        auto set_disconnect_callback(std::function<void()> callback) -> void;
 
        [[nodiscard]] auto get_client() const -> std::shared_ptr<core::messaging_client>;
 
#ifdef WITH_COMMON_SYSTEM
        [[nodiscard]] auto circuit_state() const -> common::resilience::circuit_state;
#endif
 
    private:
        auto reconnect() -> VoidResult;
 
        auto calculate_backoff(size_t attempt) const -> std::chrono::milliseconds;
 
        std::shared_ptr<core::messaging_client> client_; 
        std::string host_;        
        unsigned short port_;     
        size_t max_retries_;      
        std::chrono::milliseconds initial_backoff_; 
        std::atomic<bool> is_connected_{false}; 
        std::function<void(size_t)> reconnect_callback_; 
        std::function<void()> disconnect_callback_;      
#ifdef WITH_COMMON_SYSTEM
        std::unique_ptr<common::resilience::circuit_breaker> circuit_breaker_; 
#endif
    };
 
} // namespace kcenon::network::utils