reconnection.h

Go to the documentation of this file.

#pragma once
 
#include "util/rats_export.h"
#include "node/peer_network.h"
#include "peer/peer.h"
#include "core/address.h"
#include "peer/peer_id.h"
#include "peer/peer_book.h"
 
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
#include <unordered_map>
 
namespace librats {
 
class RATS_API ReconnectionService final : public Subsystem {
public:
    struct Config {
        std::string               store_path = "";          
        bool                      persist_discovered = true; 
        size_t                    max_targets = 1024;        
        size_t                    max_attempts = 0;          
        size_t                    startup_targets = 32;      
        size_t                    archive_max = 4096;        
        std::chrono::seconds      archive_max_age{std::chrono::hours(24 * 30)};  
        std::chrono::milliseconds base_backoff{1000};
        std::chrono::milliseconds max_backoff{60000};
        std::chrono::milliseconds tick{1000};
        std::chrono::milliseconds dial_timeout{15000};  
    };
 
    ReconnectionService();
    explicit ReconnectionService(Config config);
    ~ReconnectionService() override;
 
    void add(const Address& address);
 
    void remove(const Address& address);
 
    size_t target_count() const;
 
    std::vector<Address> known_peers(size_t n) const;
 
    void attach(NodeContext& ctx) override;
    void start() override;
    void stop() override;
 
private:
    struct Target {
        Address                               address;
        bool                                  dialing = false;  
        int                                   attempts = 0;     
        std::chrono::steady_clock::time_point next_attempt;     
        std::chrono::steady_clock::time_point dial_deadline;    
 
        void mark_connected(std::chrono::steady_clock::time_point now) {
            dialing      = false;
            attempts     = 0;
            next_attempt = now;
        }
    };
 
    void on_connected(const Peer& peer);
    void on_disconnected(const PeerId& id);
    void on_dial_failed(const Address& address);
    void loop();
    std::chrono::milliseconds backoff_for(int attempts) const;
 
    Config                      config_;
    PeerNetwork*                network_ = nullptr;
    // Built once in the constructor (when store_path is set) and never reassigned,
    // so the pointer is safe to read from any thread; PeerBook is itself internally
    // synchronized. (Creating it in start() raced reads from on_connected, which can
    // fire on a reactor thread before this subsystem's start() returns.)
    std::unique_ptr<PeerBook>   book_;
 
    std::thread             thread_;
    std::atomic<bool>       running_{false};
    std::mutex              wait_mutex_;
    std::condition_variable wake_;
 
    mutable std::mutex                       mutex_;
    std::unordered_map<Address, Target>      targets_;  
};
 
} // namespace librats