AutoClusterFailover.h

#ifndef PULSAR_AUTO_CLUSTER_FAILOVER_H_
#define PULSAR_AUTO_CLUSTER_FAILOVER_H_
 
#include <pulsar/ServiceInfoProvider.h>
 
#include <chrono>
#include <cstdint>
#include <functional>
#include <memory>
#include <vector>
 
namespace pulsar {
 
class Client;
class AutoClusterFailoverImpl;
 
class PULSAR_PUBLIC AutoClusterFailover final : public ServiceInfoProvider {
   public:
    struct Config {
        const ServiceInfo primary;
        const std::vector<ServiceInfo> secondary;
        std::chrono::milliseconds checkInterval{5000};  // 5 seconds
        uint32_t failoverThreshold{1};
        uint32_t switchBackThreshold{1};
 
        Config(ServiceInfo primary, std::vector<ServiceInfo> secondary)
            : primary(std::move(primary)), secondary(std::move(secondary)) {}
    };

    class Builder {
       public:
        Builder(ServiceInfo primary, std::vector<ServiceInfo> secondary)
            : config_(std::move(primary), std::move(secondary)) {}
 
        // Set how frequently probes run against the active cluster(s). Default: 5 seconds.
        Builder& withCheckInterval(std::chrono::milliseconds interval) {
            config_.checkInterval = interval;
            return *this;
        }
 
        // Set the number of consecutive failed probes required before attempting failover. Default: 1.
        Builder& withFailoverThreshold(uint32_t threshold) {
            config_.failoverThreshold = threshold;
            return *this;
        }
 
        // Set the number of consecutive successful primary probes required before switching back from a
        // healthy secondary. If the active secondary becomes unavailable and the primary is available,
        // the implementation may switch back immediately regardless of this threshold. Default: 1.
        Builder& withSwitchBackThreshold(uint32_t threshold) {
            config_.switchBackThreshold = threshold;
            return *this;
        }
 
        AutoClusterFailover build() { return AutoClusterFailover(std::move(config_)); }
 
       private:
        Config config_;
    };
 
    explicit AutoClusterFailover(Config&& config);
 
    ~AutoClusterFailover() final;
 
    ServiceInfo initialServiceInfo() final;
 
    void initialize(std::function<void(ServiceInfo)> onServiceInfoUpdate) final;
 
   private:
    std::shared_ptr<AutoClusterFailoverImpl> impl_;
};
 
}  // namespace pulsar
 
#endif