const std::optional<utils::UUID> &current_main_uuid, dbms::DbmsHandler &dbms_handler,

auth::SynchedAuth &auth, uint64_t const request_version, slk::Reader *req_reader,

slk::Builder *res_builder) {

using memgraph::replication::SystemRecoveryRes;

SystemRecoveryRes res(SystemRecoveryRes::Result::FAILURE);

utils::OnScopeExit const send_on_exit([&]() { rpc::SendFinalResponse(res, request_version, res_builder); });

memgraph::replication::SystemRecoveryReq req;

rpc::LoadWithUpgrade(req, request_version, req_reader);

// validate

if (current_main_uuid != req.main_uuid) [[unlikely]] {

LogWrongMain(current_main_uuid, req.main_uuid, SystemRecoveryReq::kType.name);

return;

}

/*

if (!dbms::SystemRecoveryHandler(dbms_handler, req.database_configs)) return; // Failure sent on exit

/*

if (!auth::SystemRecoveryHandler(auth, req.auth_config, req.users, req.roles, req.profiles))

return; // Failure sent on exit

/*

system_state_access.SetLastCommitedTS(req.forced_group_timestamp);

spdlog::debug("SystemRecoveryHandler: SUCCESS updated LCTS to {}", req.forced_group_timestamp);

res = SystemRecoveryRes(SystemRecoveryRes::Result::SUCCESS);

const std::optional<utils::UUID> &current_main_uuid, uint64_t const request_version,

slk::Reader *req_reader, slk::Builder *res_builder) {

using memgraph::replication::FinalizeSystemTxRes;

FinalizeSystemTxRes res(false);

utils::OnScopeExit const send_on_exit([&]() { rpc::SendFinalResponse(res, request_version, res_builder); });

memgraph::replication::FinalizeSystemTxReq req;

memgraph::slk::Load(&req, req_reader);

// validate MAIN

if (current_main_uuid != req.main_uuid) [[unlikely]] {

LogWrongMain(current_main_uuid, req.main_uuid, SystemRecoveryReq::kType.name);

return;

}

// validate delta

// Note: No need to check epoch, recovery mechanism is done by a full uptodate snapshot

// of the set of databases. Hence no history exists to maintain regarding epoch change.

// If MAIN has changed we need to check this new group_timestamp is consistent with

// what we have so far.

if (req.expected_group_timestamp != system_state_access.LastCommitedTS()) {

spdlog::error("Received system delta with expected ts: {} != last commited ts: {}",

req.expected_group_timestamp,

system_state_access.LastCommitedTS());

return;

}

system_state_access.SetLastCommitedTS(req.new_group_timestamp);

spdlog::debug("FinalizeSystemTxHandler: SUCCESS updated LCTS to {}", req.new_group_timestamp);

res = FinalizeSystemTxRes(true);

auth::SynchedAuth &auth) {

// NOTE: Register even without license as the user could add a license at run-time

auto system_state_access = system.CreateSystemStateAccess();

// need to tell REPLICA the uuid to use for "memgraph" default database

data.server->rpc_server_.Register<replication::SystemRecoveryRpc>(

[&data, system_state_access, &dbms_handler, &auth](

std::optional<rpc::FileReplicationHandler> const & /*file_replication_handler*/,

uint64_t const request_version,

auto *req_reader,

auto *res_builder) mutable {

SystemRecoveryHandler(

system_state_access, data.uuid_, dbms_handler, auth, request_version, req_reader, res_builder);

});

// Generic finalize message

data.server->rpc_server_.Register<replication::FinalizeSystemTxRpc>(

[&data, system_state_access](std::optional<rpc::FileReplicationHandler> const & /*file_replication_handler*/,

uint64_t const request_version,

auto *req_reader,

auto *res_builder) mutable {

FinalizeSystemTxHandler(system_state_access, data.uuid_, request_version, req_reader, res_builder);

});

// DBMS

dbms::Register(data, system_state_access, dbms_handler);

// Auth

auth::Register(data, system_state_access, auth);

system::System &system) {

#else

bool StartRpcServer(dbms::DbmsHandler &dbms_handler, replication::RoleReplicaData &data) {

#endif

// Register storage handlers

dbms::InMemoryReplicationHandlers::Register(&dbms_handler, data);

#ifdef MG_ENTERPRISE

// Register system handlers

Register(data, system, dbms_handler, auth);

#endif

// Start server

if (!data.server->Start()) {

spdlog::error("Unable to start the replication server.");

return false;

}

return true;

}