server.hpp

#pragma once
 
#include <chrono>
#include <memory>
 
#include "raft/errors.hpp"
#include "raft/network.hpp"
#include "raft/server.hpp"
 
namespace raft::enhanced
{
    struct RequestInfo
    {
        std::string clientID;  
        uint64_t requestID;  
    };
 
    using GlobalCommitCallback =
        std::function<void(std::vector<std::byte> data, bool local, bool duplicate)>;
 
    struct LocalCommitInfo
    {
        std::vector<std::byte> data;  
        bool duplicate = false;  
    };
 
    using LocalCommitCallback = std::function<void(tl::expected<LocalCommitInfo, Error> result)>;
 
    using EndSessionCallback = std::function<void(tl::expected<void, Error> result)>;
 
    struct ServerCreateConfig
    {
        std::shared_ptr<raft::Network> network;  
        std::shared_ptr<raft::Server> server;  
        std::chrono::nanoseconds commitTimeout = std::chrono::seconds(5);  
        uint64_t threadCount = 1;  
        std::optional<GlobalCommitCallback> commitCallback;  
    };
 
    class ServerImpl;
 
    class Server
    {
      public:
        explicit Server(ServerCreateConfig config);
        ~Server();
 
        Server(Server const&) = delete;
        Server& operator=(Server const&) = delete;
        Server(Server&&) noexcept;
        Server& operator=(Server&&) noexcept;
 
        void commit(RequestInfo const& info,
                    const std::vector<std::byte>& value,
                    LocalCommitCallback callback);
 
        void endSession(std::string const& clientID, EndSessionCallback callback);
 
        void setCommitCallback(GlobalCommitCallback callback);
        void clearCommitCallback();
 
      private:
        std::shared_ptr<ServerImpl> pImpl_;
    };
}  // namespace raft::enhanced