server.hpp

#pragma once
 
#include <optional>
#include <random>
 
#include "impl/hash.h"
#include "raft/client.hpp"
#include "raft/persister.hpp"
 
namespace raft
{
    constexpr std::pair<uint64_t, uint64_t> DEFAULT_TIMEOUT_INTERVAL_RANGE = {500, 1000};
    constexpr uint64_t DEFAULT_HEARTBEAT_INTERVAL = 10;
 
    struct TimeoutInterval
    {
        uint64_t min = DEFAULT_TIMEOUT_INTERVAL_RANGE.first;
        uint64_t max = DEFAULT_TIMEOUT_INTERVAL_RANGE.second;
 
        [[nodiscard]] uint64_t sample(std::mt19937& rng) const
        {
            std::uniform_int_distribution dist(min, max);
            return dist(rng);
        }
    };
 
    struct EntryInfo
    {
        uint64_t index;  
        uint64_t term;  
 
        bool operator==(EntryInfo const& other) const = default;
    };
 
    using CommitCallback = std::function<void(EntryInfo, std::vector<std::byte>)>;
 
    struct Peer
    {
        std::string id;  
        std::string address;  
    };
 
    using LeaderChangedCallback =
        std::function<void(std::optional<Peer> leader, bool isLeader, bool lostLeadership)>;
 
    struct ServerCreateConfig
    {
        std::string id;  
        std::shared_ptr<ClientFactory> clientFactory;  
        std::vector<Peer> peers;  
        std::shared_ptr<Persister> persister;  
        std::optional<CommitCallback> commitCallback;  
        std::optional<LeaderChangedCallback>
            leaderChangedCallback;  
        TimeoutInterval timeoutInterval;  
        uint64_t heartbeatInterval = DEFAULT_HEARTBEAT_INTERVAL;  
        uint16_t threadCount = 1;  
    };
 
    class ServiceHandler
    {
      public:
        virtual ~ServiceHandler() = default;
 
        virtual void handleAppendEntries(
            const data::AppendEntriesRequest& request,
            std::function<void(tl::expected<data::AppendEntriesResponse, Error>)> callback) = 0;
 
        virtual void handleRequestVote(
            const data::RequestVoteRequest& request,
            std::function<void(tl::expected<data::RequestVoteResponse, Error>)> callback) = 0;
    };
 
    struct Status
    {
        bool isLeader;  
        std::optional<Peer>
            leader;  
        uint64_t term;  
        uint64_t commitIndex;  
        uint64_t logByteCount;  
    };
 
    class Server : public ServiceHandler
    {
      public:
        virtual tl::expected<void, Error> start() = 0;
        virtual void shutdown() = 0;
 
        [[nodiscard]] virtual tl::expected<Peer, Error> getLeader() const = 0;
 
        virtual tl::expected<EntryInfo, Error> append(std::vector<std::byte> data) = 0;
 
        virtual void setCommitCallback(CommitCallback callback) = 0;
 
        virtual void clearCommitCallback() = 0;
 
        virtual void setLeaderChangedCallback(LeaderChangedCallback callback) = 0;
 
        virtual void clearLeaderChangedCallback() = 0;
 
        [[nodiscard]] virtual tl::expected<uint64_t, Error> getTerm() const = 0;
 
        [[nodiscard]] virtual tl::expected<uint64_t, Error> getCommitIndex() const = 0;
 
        [[nodiscard]] virtual tl::expected<uint64_t, Error> getLogByteCount() const = 0;
 
        [[nodiscard]] virtual std::string getId() const = 0;
 
        [[nodiscard]] virtual tl::expected<Status, Error> getStatus() const = 0;
    };
 
    tl::expected<std::shared_ptr<Server>, Error> createServer(ServerCreateConfig& config);
}  // namespace raft
 
namespace std
{
    template<>
    struct hash<raft::EntryInfo>
    {
        std::size_t operator()(const raft::EntryInfo& e) const noexcept
        {
            std::size_t seed = std::hash<uint64_t> {}(e.index);
            raft::impl::hashCombine(seed, e.term);
 
            return seed;
        }
    };
}  // namespace std