client.hpp

#pragma once
 
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <variant>
#include <vector>
 
#include <tl/expected.hpp>
 
#include "raft/errors.hpp"
 
namespace raft
{
    constexpr uint64_t DEFAULT_TIMEOUT_MS = 1000;
 
    namespace data
    {
        struct NoOp
        {
            bool operator==(NoOp const& other) const = default;
        };
 
        struct LogEntry
        {
            uint64_t term;  
            std::variant<std::vector<std::byte>, NoOp> entry;  
 
            bool operator==(LogEntry const& other) const = default;
        };
 
        struct AppendEntriesRequest
        {
            uint64_t term;  
            std::string leaderID;  
            uint64_t
                prevLogIndex;  
            uint64_t prevLogTerm;  
            std::vector<LogEntry>
                entries;  
            uint64_t leaderCommit;  
 
            bool operator==(AppendEntriesRequest const& other) const = default;
        };
 
        struct AppendEntriesResponse
        {
            uint64_t term;  
            bool success;  
 
            bool operator==(AppendEntriesResponse const& other) const = default;
        };
 
        struct RequestVoteRequest
        {
            uint64_t term;  
            std::string candidateID;  
            uint64_t lastLogIndex;  
            uint64_t lastLogTerm;  
 
            bool operator==(RequestVoteRequest const& other) const = default;
        };
 
        struct RequestVoteResponse
        {
            uint64_t term;  
            bool voteGranted;  
 
            bool operator==(RequestVoteResponse const& other) const = default;
        };
    }  // namespace data
 
    struct RequestConfig
    {
        uint64_t timeout = DEFAULT_TIMEOUT_MS;  
    };
 
    class Client
    {
      public:
        virtual ~Client() = default;
 
        virtual void appendEntries(
            data::AppendEntriesRequest request,
            RequestConfig config,
            std::function<void(tl::expected<data::AppendEntriesResponse, Error>)> callback) = 0;
 
        virtual void requestVote(
            data::RequestVoteRequest request,
            RequestConfig config,
            std::function<void(tl::expected<data::RequestVoteResponse, Error>)> callback) = 0;
    };
 
    tl::expected<std::unique_ptr<Client>, Error> createClient(std::string const& address);
 
    class ClientFactory
    {
      public:
        virtual ~ClientFactory() = default;
 
        virtual tl::expected<std::unique_ptr<Client>, Error> createClient(
            std::string const& address) = 0;
    };
 
    std::shared_ptr<ClientFactory> createClientFactory();
}  // namespace raft