Add yum install libuuid-devel to amzn2

.github/workflows/package_memgraph.yaml

@@ -38,7 +38,7 @@ on:
 jobs:
   amzn-2:
     if: ${{ github.event.inputs.target_os == 'amzn-2' || github.event.inputs.target_os == 'all' }}
-    runs-on: [self-hosted, DockerMgBuild, X64]
+    runs-on: [self-hosted, mantis]
     timeout-minutes: 60
     steps:
       - name: "Set up repository"

environment/os/amzn-2.sh

@@ -45,7 +45,6 @@ MEMGRAPH_BUILD_DEPS=(
     readline-devel # for memgraph console
     python3-devel # for query modules
     openssl-devel
-    openssl
     libseccomp-devel
     python3 python3-pip nmap-ncat # for tests
     #

environment/os/centos-7.sh

@@ -43,7 +43,6 @@ MEMGRAPH_BUILD_DEPS=(
     readline-devel # for memgraph console
     python3-devel # for query modules
     openssl-devel
-    openssl
     libseccomp-devel
     python3 python-virtualenv python3-pip nmap-ncat # for qa, macro_benchmark and stress tests
     #

release/package/amzn-2/Dockerfile

@@ -12,4 +12,6 @@ RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERS
     && tar xzvf ${TOOLCHAIN_VERSION}-binaries-amzn-2-x86_64.tar.gz -C /opt \
     && rm ${TOOLCHAIN_VERSION}-binaries-amzn-2-x86_64.tar.gz
 
+RUN yum install libuuid-devel.x86_64 -y
+
 ENTRYPOINT ["sleep", "infinity"]

src/coordination/CMakeLists.txt

@@ -16,8 +16,6 @@ target_sources(mg-coordination
         include/coordination/raft_state.hpp
         include/coordination/rpc_errors.hpp
 
-        include/nuraft/raft_log_action.hpp
-        include/nuraft/coordinator_cluster_state.hpp
         include/nuraft/coordinator_log_store.hpp
         include/nuraft/coordinator_state_machine.hpp
         include/nuraft/coordinator_state_manager.hpp
@@ -35,7 +33,6 @@ target_sources(mg-coordination
         coordinator_log_store.cpp
         coordinator_state_machine.cpp
         coordinator_state_manager.cpp
-        coordinator_cluster_state.cpp
 )
 target_include_directories(mg-coordination PUBLIC include)
 

src/coordination/coordinator_client.cpp

@@ -41,9 +41,7 @@ CoordinatorClient::CoordinatorClient(CoordinatorInstance *coord_instance, Coordi
       fail_cb_{std::move(fail_cb)} {}
 
 auto CoordinatorClient::InstanceName() const -> std::string { return config_.instance_name; }
-
-auto CoordinatorClient::CoordinatorSocketAddress() const -> std::string { return config_.CoordinatorSocketAddress(); }
-auto CoordinatorClient::ReplicationSocketAddress() const -> std::string { return config_.ReplicationSocketAddress(); }
+auto CoordinatorClient::SocketAddress() const -> std::string { return rpc_client_.Endpoint().SocketAddress(); }
 
 auto CoordinatorClient::InstanceDownTimeoutSec() const -> std::chrono::seconds {
   return config_.instance_down_timeout_sec;
@@ -66,7 +64,7 @@ void CoordinatorClient::StartFrequentCheck() {
       [this, instance_name = config_.instance_name] {
         try {
           spdlog::trace("Sending frequent heartbeat to machine {} on {}", instance_name,
-                        config_.CoordinatorSocketAddress());
+                        rpc_client_.Endpoint().SocketAddress());
           {  // NOTE: This is intentionally scoped so that stream lock could get released.
             auto stream{rpc_client_.Stream<memgraph::replication_coordination_glue::FrequentHeartbeatRpc>()};
             stream.AwaitResponse();
@@ -119,7 +117,7 @@ auto CoordinatorClient::DemoteToReplica() const -> bool {
   return false;
 }
 
-auto CoordinatorClient::SendSwapMainUUIDRpc(utils::UUID const &uuid) const -> bool {
+auto CoordinatorClient::SendSwapMainUUIDRpc(const utils::UUID &uuid) const -> bool {
   try {
     auto stream{rpc_client_.Stream<replication_coordination_glue::SwapMainUUIDRpc>(uuid)};
     if (!stream.AwaitResponse().success) {
@@ -133,10 +131,9 @@ auto CoordinatorClient::SendSwapMainUUIDRpc(utils::UUID const &uuid) const -> bo
   return false;
 }
 
-auto CoordinatorClient::SendUnregisterReplicaRpc(std::string_view instance_name) const -> bool {
+auto CoordinatorClient::SendUnregisterReplicaRpc(std::string const &instance_name) const -> bool {
   try {
-    auto stream{rpc_client_.Stream<UnregisterReplicaRpc>(
-        std::string(instance_name))};  // TODO: (andi) Try to change to stream string_view and do just one copy later
+    auto stream{rpc_client_.Stream<UnregisterReplicaRpc>(instance_name)};
     if (!stream.AwaitResponse().success) {
       spdlog::error("Failed to receive successful RPC response for unregistering replica!");
       return false;
@@ -178,7 +175,9 @@ auto CoordinatorClient::SendGetInstanceTimestampsRpc() const
     -> utils::BasicResult<GetInstanceUUIDError, replication_coordination_glue::DatabaseHistories> {
   try {
     auto stream{rpc_client_.Stream<coordination::GetDatabaseHistoriesRpc>()};
-    return stream.AwaitResponse().database_histories;
+    auto res = stream.AwaitResponse();
+
+    return res.database_histories;
 
   } catch (const rpc::RpcFailedException &) {
     spdlog::error("RPC error occured while sending GetInstance UUID RPC");

src/coordination/coordinator_cluster_state.cpp

@@ -1,166 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#ifdef MG_ENTERPRISE
-
-#include "nuraft/coordinator_cluster_state.hpp"
-#include "utils/logging.hpp"
-
-#include <shared_mutex>
-
-namespace memgraph::coordination {
-
-using replication_coordination_glue::ReplicationRole;
-
-CoordinatorClusterState::CoordinatorClusterState(CoordinatorClusterState const &other)
-    : instance_roles_{other.instance_roles_} {}
-
-CoordinatorClusterState &CoordinatorClusterState::operator=(CoordinatorClusterState const &other) {
-  if (this == &other) {
-    return *this;
-  }
-  instance_roles_ = other.instance_roles_;
-  return *this;
-}
-
-CoordinatorClusterState::CoordinatorClusterState(CoordinatorClusterState &&other) noexcept
-    : instance_roles_{std::move(other.instance_roles_)} {}
-
-CoordinatorClusterState &CoordinatorClusterState::operator=(CoordinatorClusterState &&other) noexcept {
-  if (this == &other) {
-    return *this;
-  }
-  instance_roles_ = std::move(other.instance_roles_);
-  return *this;
-}
-
-auto CoordinatorClusterState::MainExists() const -> bool {
-  auto lock = std::shared_lock{log_lock_};
-  return std::ranges::any_of(instance_roles_,
-                             [](auto const &entry) { return entry.second.role == ReplicationRole::MAIN; });
-}
-
-auto CoordinatorClusterState::IsMain(std::string_view instance_name) const -> bool {
-  auto lock = std::shared_lock{log_lock_};
-  auto const it = instance_roles_.find(instance_name);
-  return it != instance_roles_.end() && it->second.role == ReplicationRole::MAIN;
-}
-
-auto CoordinatorClusterState::IsReplica(std::string_view instance_name) const -> bool {
-  auto lock = std::shared_lock{log_lock_};
-  auto const it = instance_roles_.find(instance_name);
-  return it != instance_roles_.end() && it->second.role == ReplicationRole::REPLICA;
-}
-
-auto CoordinatorClusterState::InsertInstance(std::string_view instance_name, ReplicationRole role) -> void {
-  auto lock = std::unique_lock{log_lock_};
-  instance_roles_[instance_name.data()].role = role;
-}
-
-auto CoordinatorClusterState::DoAction(TRaftLog log_entry, RaftLogAction log_action) -> void {
-  auto lock = std::unique_lock{log_lock_};
-  switch (log_action) {
-    case RaftLogAction::REGISTER_REPLICATION_INSTANCE: {
-      auto const &config = std::get<CoordinatorClientConfig>(log_entry);
-      instance_roles_[config.instance_name] = InstanceState{config, ReplicationRole::REPLICA};
-      break;
-    }
-    case RaftLogAction::UNREGISTER_REPLICATION_INSTANCE: {
-      auto const instance_name = std::get<std::string>(log_entry);
-      instance_roles_.erase(instance_name);
-      break;
-    }
-    case RaftLogAction::SET_INSTANCE_AS_MAIN: {
-      auto const instance_name = std::get<std::string>(log_entry);
-      auto it = instance_roles_.find(instance_name);
-      MG_ASSERT(it != instance_roles_.end(), "Instance does not exist as part of raft state!");
-      it->second.role = ReplicationRole::MAIN;
-      break;
-    }
-    case RaftLogAction::SET_INSTANCE_AS_REPLICA: {
-      auto const instance_name = std::get<std::string>(log_entry);
-      auto it = instance_roles_.find(instance_name);
-      MG_ASSERT(it != instance_roles_.end(), "Instance does not exist as part of raft state!");
-      it->second.role = ReplicationRole::REPLICA;
-      break;
-    }
-    case RaftLogAction::UPDATE_UUID: {
-      uuid_ = std::get<utils::UUID>(log_entry);
-      break;
-    }
-  }
-}
-
-// TODO: (andi) Improve based on Gareth's comments
-auto CoordinatorClusterState::Serialize(ptr<buffer> &data) -> void {
-  auto lock = std::shared_lock{log_lock_};
-  auto const role_to_string = [](auto const &role) -> std::string_view {
-    switch (role) {
-      case ReplicationRole::MAIN:
-        return "main";
-      case ReplicationRole::REPLICA:
-        return "replica";
-    }
-  };
-
-  auto const entry_to_string = [&role_to_string](auto const &entry) {
-    return fmt::format("{}_{}", entry.first, role_to_string(entry.second.role));
-  };
-
-  auto instances_str_view = instance_roles_ | ranges::views::transform(entry_to_string);
-  uint32_t size =
-      std::accumulate(instances_str_view.begin(), instances_str_view.end(), 0,
-                      [](uint32_t acc, auto const &entry) { return acc + sizeof(uint32_t) + entry.size(); });
-
-  data = buffer::alloc(size);
-  buffer_serializer bs(data);
-  std::for_each(instances_str_view.begin(), instances_str_view.end(), [&bs](auto const &entry) { bs.put_str(entry); });
-}
-
-auto CoordinatorClusterState::Deserialize(buffer &data) -> CoordinatorClusterState {
-  auto const str_to_role = [](auto const &str) -> ReplicationRole {
-    if (str == "main") {
-      return ReplicationRole::MAIN;
-    }
-    return ReplicationRole::REPLICA;
-  };
-
-  CoordinatorClusterState cluster_state;
-  buffer_serializer bs(data);
-  while (bs.size() > 0) {
-    auto const entry = bs.get_str();
-    auto const first_dash = entry.find('_');
-    auto const instance_name = entry.substr(0, first_dash);
-    auto const role_str = entry.substr(first_dash + 1);
-    cluster_state.InsertInstance(instance_name, str_to_role(role_str));
-  }
-  return cluster_state;
-}
-
-auto CoordinatorClusterState::GetInstances() const -> std::vector<InstanceState> {
-  auto lock = std::shared_lock{log_lock_};
-  return instance_roles_ | ranges::views::values | ranges::to<std::vector<InstanceState>>;
-}
-
-auto CoordinatorClusterState::GetUUID() const -> utils::UUID { return uuid_; }
-
-auto CoordinatorClusterState::FindCurrentMainInstanceName() const -> std::optional<std::string> {
-  auto lock = std::shared_lock{log_lock_};
-  auto const it = std::ranges::find_if(instance_roles_,
-                                       [](auto const &entry) { return entry.second.role == ReplicationRole::MAIN; });
-  if (it == instance_roles_.end()) {
-    return {};
-  }
-  return it->first;
-}
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/coordinator_handlers.cpp

@@ -140,7 +140,7 @@ void CoordinatorHandlers::PromoteReplicaToMainHandler(replication::ReplicationHa
         .port = repl_info_config.replication_port,
     };
   };
-  std::this_thread::sleep_for(std::chrono::milliseconds{1000});
+
   // registering replicas
   for (auto const &config : req.replication_clients_info | ranges::views::transform(converter)) {
     auto instance_client = replication_handler.RegisterReplica(config);

src/coordination/coordinator_instance.cpp

@@ -32,68 +32,16 @@ using nuraft::srv_config;
 
 CoordinatorInstance::CoordinatorInstance()
     : raft_state_(RaftState::MakeRaftState(
-          [this]() {
-            spdlog::info("Leader changed, starting all replication instances!");
-            auto const instances = raft_state_.GetInstances();
-            auto replicas = instances | ranges::views::filter([](auto const &instance) {
-                              return instance.role == ReplicationRole::REPLICA;
-                            });
-
-            std::ranges::for_each(replicas, [this](auto &replica) {
-              spdlog::info("Starting replication instance {}", replica.config.instance_name);
-              repl_instances_.emplace_back(this, replica.config, client_succ_cb_, client_fail_cb_,
-                                           &CoordinatorInstance::ReplicaSuccessCallback,
-                                           &CoordinatorInstance::ReplicaFailCallback);
-            });
-
-            auto main = instances | ranges::views::filter(
-                                        [](auto const &instance) { return instance.role == ReplicationRole::MAIN; });
-
-            // TODO: (andi) Add support for this
-            // MG_ASSERT(std::ranges::distance(main) == 1, "There should be exactly one main instance");
-
-            std::ranges::for_each(main, [this](auto &main_instance) {
-              spdlog::info("Starting main instance {}", main_instance.config.instance_name);
-              repl_instances_.emplace_back(this, main_instance.config, client_succ_cb_, client_fail_cb_,
-                                           &CoordinatorInstance::MainSuccessCallback,
-                                           &CoordinatorInstance::MainFailCallback);
-            });
-
-            std::ranges::for_each(repl_instances_, [this](auto &instance) {
-              instance.SetNewMainUUID(raft_state_.GetUUID());  // TODO: (andi) Rename
-              instance.ResumeFrequentCheck();
-            });
-            is_running_.store(true, std::memory_order::acquire);
-          },
-          [this]() {
-            spdlog::info("Leader changed, trying to stop all replication instances, thread id {}!",
-                         std::this_thread::get_id());
-            /// TODO Add to pool
-            // auto lock = std::lock_guard{coord_instance_lock_};  // RAII
-            // std::ranges::for_each(repl_instances_)
-            repl_instances_.clear();
-            spdlog::info("Leader changed, stopped all replication instances!");
-            return;
-            is_running_.store(false, std::memory_order::acquire);
-            pool_.AddTask([this]() {
-              auto lock = std::lock_guard{coord_instance_lock_};
-              std::ranges::for_each(repl_instances_, [](auto &instance) { instance.PauseFrequentCheck(); });
-            });
-          })) {
+          [this] { std::ranges::for_each(repl_instances_, &ReplicationInstance::StartFrequentCheck); },
+          [this] { std::ranges::for_each(repl_instances_, &ReplicationInstance::StopFrequentCheck); })) {
   client_succ_cb_ = [](CoordinatorInstance *self, std::string_view repl_instance_name) -> void {
-    if (!self->is_running_) {
-      return;
-    }
-    auto lock = std::lock_guard{self->coord_instance_lock_};  // RAII
+    auto lock = std::unique_lock{self->coord_instance_lock_};
     auto &repl_instance = self->FindReplicationInstance(repl_instance_name);
     std::invoke(repl_instance.GetSuccessCallback(), self, repl_instance_name);
   };
 
   client_fail_cb_ = [](CoordinatorInstance *self, std::string_view repl_instance_name) -> void {
-    if (!self->is_running_) {
-      return;
-    }
-    auto lock = std::lock_guard{self->coord_instance_lock_};
+    auto lock = std::unique_lock{self->coord_instance_lock_};
     auto &repl_instance = self->FindReplicationInstance(repl_instance_name);
     std::invoke(repl_instance.GetFailCallback(), self, repl_instance_name);
   };
@@ -111,101 +59,75 @@ auto CoordinatorInstance::FindReplicationInstance(std::string_view replication_i
 }
 
 auto CoordinatorInstance::ShowInstances() const -> std::vector<InstanceStatus> {
+  auto const coord_instances = raft_state_.GetAllCoordinators();
+
+  auto const stringify_repl_role = [](ReplicationInstance const &instance) -> std::string {
+    if (!instance.IsAlive()) return "unknown";
+    if (instance.IsMain()) return "main";
+    return "replica";
+  };
+
+  auto const repl_instance_to_status = [&stringify_repl_role](ReplicationInstance const &instance) -> InstanceStatus {
+    return {.instance_name = instance.InstanceName(),
+            .coord_socket_address = instance.SocketAddress(),
+            .cluster_role = stringify_repl_role(instance),
+            .is_alive = instance.IsAlive()};
+  };
+
   auto const coord_instance_to_status = [](ptr<srv_config> const &instance) -> InstanceStatus {
     return {.instance_name = "coordinator_" + std::to_string(instance->get_id()),
             .raft_socket_address = instance->get_endpoint(),
             .cluster_role = "coordinator",
-            .health = "unknown"};  // TODO: (andi) Get this info from RAFT and test it or when we will move
-                                   // CoordinatorState to every instance, we can be smarter about this using our RPC.
+            .is_alive = true};  // TODO: (andi) Get this info from RAFT and test it or when we will move
+                                // CoordinatorState to every instance, we can be smarter about this using our RPC.
   };
 
-  auto instances_status = utils::fmap(coord_instance_to_status, raft_state_.GetAllCoordinators());
-
-  if (raft_state_.IsLeader()) {
-    auto const stringify_repl_role = [this](ReplicationInstance const &instance) -> std::string {
-      if (!instance.IsAlive()) return "unknown";
-      if (raft_state_.IsMain(instance.InstanceName())) return "main";
-      return "replica";
-    };
-
-    auto const stringify_repl_health = [](ReplicationInstance const &instance) -> std::string {
-      return instance.IsAlive() ? "up" : "down";
-    };
-
-    auto process_repl_instance_as_leader =
-        [&stringify_repl_role, &stringify_repl_health](ReplicationInstance const &instance) -> InstanceStatus {
-      return {.instance_name = instance.InstanceName(),
-              .coord_socket_address = instance.CoordinatorSocketAddress(),
-              .cluster_role = stringify_repl_role(instance),
-              .health = stringify_repl_health(instance)};
-    };
-
-    {
-      auto lock = std::shared_lock{coord_instance_lock_};
-      std::ranges::transform(repl_instances_, std::back_inserter(instances_status), process_repl_instance_as_leader);
-    }
-  } else {
-    auto const stringify_repl_role = [](ReplicationRole role) -> std::string {
-      return role == ReplicationRole::MAIN ? "main" : "replica";
-    };
-
-    // TODO: (andi) Add capability that followers can also return socket addresses
-    auto process_repl_instance_as_follower = [&stringify_repl_role](auto const &instance) -> InstanceStatus {
-      return {.instance_name = instance.config.instance_name,
-              .cluster_role = stringify_repl_role(instance.role),
-              .health = "unknown"};
-    };
-
-    std::ranges::transform(raft_state_.GetInstances(), std::back_inserter(instances_status),
-                           process_repl_instance_as_follower);
+  auto instances_status = utils::fmap(coord_instance_to_status, coord_instances);
+  {
+    auto lock = std::shared_lock{coord_instance_lock_};
+    std::ranges::transform(repl_instances_, std::back_inserter(instances_status), repl_instance_to_status);
   }
 
   return instances_status;
 }
 
 auto CoordinatorInstance::TryFailover() -> void {
-  if (!is_running_) {
-    return;
-  }
-  auto const is_replica = [this](ReplicationInstance const &instance) { return IsReplica(instance.InstanceName()); };
-
-  auto alive_replicas =
-      repl_instances_ | ranges::views::filter(is_replica) | ranges::views::filter(&ReplicationInstance::IsAlive);
+  auto alive_replicas = repl_instances_ | ranges::views::filter(&ReplicationInstance::IsReplica) |
+                        ranges::views::filter(&ReplicationInstance::IsAlive);
 
   if (ranges::empty(alive_replicas)) {
     spdlog::warn("Failover failed since all replicas are down!");
     return;
   }
 
-  if (!raft_state_.RequestLeadership()) {
-    spdlog::error("Failover failed since the instance is not the leader!");
-    return;
-  }
+  // for each DB in instance we get one DatabaseHistory
+  using DatabaseHistories = replication_coordination_glue::DatabaseHistories;
+  std::vector<std::pair<std::string, DatabaseHistories>> instance_database_histories;
 
-  auto const get_ts = [](ReplicationInstance &replica) { return replica.GetClient().SendGetInstanceTimestampsRpc(); };
+  bool success{true};
+  std::ranges::for_each(alive_replicas, [&success, &instance_database_histories](ReplicationInstance &replica) {
+    if (!success) {
+      return;
+    }
+    auto res = replica.GetClient().SendGetInstanceTimestampsRpc();
+    if (res.HasError()) {
+      spdlog::error("Could get per db history data for instance {}", replica.InstanceName());
+      success = false;
+      return;
+    }
+    instance_database_histories.emplace_back(replica.InstanceName(), std::move(res.GetValue()));
+  });
 
-  auto maybe_instance_db_histories = alive_replicas | ranges::views::transform(get_ts) | ranges::to<std::vector>();
-
-  auto const ts_has_error = [](auto const &res) -> bool { return res.HasError(); };
-
-  if (std::ranges::any_of(maybe_instance_db_histories, ts_has_error)) {
+  if (!success) {
     spdlog::error("Aborting failover as at least one instance didn't provide per database history.");
     return;
   }
 
-  auto transform_to_pairs = ranges::views::transform([](auto const &zipped) {
-    auto &[replica, res] = zipped;
-    return std::make_pair(replica.InstanceName(), res.GetValue());
-  });
-
-  auto instance_db_histories =
-      ranges::views::zip(alive_replicas, maybe_instance_db_histories) | transform_to_pairs | ranges::to<std::vector>();
-
   auto [most_up_to_date_instance, latest_epoch, latest_commit_timestamp] =
-      ChooseMostUpToDateInstance(instance_db_histories);
+      ChooseMostUpToDateInstance(instance_database_histories);
 
   spdlog::trace("The most up to date instance is {} with epoch {} and {} latest commit timestamp",
-                most_up_to_date_instance, latest_epoch, latest_commit_timestamp);  // NOLINT
+                most_up_to_date_instance, *latest_epoch, *latest_commit_timestamp);
 
   auto *new_main = &FindReplicationInstance(most_up_to_date_instance);
 
@@ -217,17 +139,16 @@ auto CoordinatorInstance::TryFailover() -> void {
   };
 
   auto const new_main_uuid = utils::UUID{};
-
-  auto const failed_to_swap = [&new_main_uuid](ReplicationInstance &instance) {
-    return !instance.SendSwapAndUpdateUUID(new_main_uuid);
-  };
-
   // If for some replicas swap fails, for others on successful ping we will revert back on next change
   // or we will do failover first again and then it will be consistent again
-  if (std::ranges::any_of(alive_replicas | ranges::views::filter(is_not_new_main), failed_to_swap)) {
-    spdlog::error("Failed to swap uuid for all instances");
-    return;
+  for (auto &other_replica_instance : alive_replicas | ranges::views::filter(is_not_new_main)) {
+    if (!other_replica_instance.SendSwapAndUpdateUUID(new_main_uuid)) {
+      spdlog::error(fmt::format("Failed to swap uuid for instance {} which is alive, aborting failover",
+                                other_replica_instance.InstanceName()));
+      return;
+    }
   }
+
   auto repl_clients_info = repl_instances_ | ranges::views::filter(is_not_new_main) |
                            ranges::views::transform(&ReplicationInstance::ReplicationClientInfo) |
                            ranges::to<ReplicationClientsInfo>();
@@ -237,54 +158,23 @@ auto CoordinatorInstance::TryFailover() -> void {
     spdlog::warn("Failover failed since promoting replica to main failed!");
     return;
   }
-  spdlog::info("Promote to main done, trying to append update uuid, thread id {}, is leader {}",
-               std::this_thread::get_id(), raft_state_.IsLeader());
-  // TODO (antoniofilipovic) : This can fail and we don't know we change uuid
-  if (!raft_state_.AppendUpdateUUIDLog(new_main_uuid)) {
-    spdlog::trace("Append entry update uuid failed, thread id {}, is leader {}", std::this_thread::get_id(),
-                  raft_state_.IsLeader());
-    return;
-  }
-
-  auto const new_main_instance_name = new_main->InstanceName();
-  spdlog::info("Promote to main done, trying to set instance as main log");
-  // TODO (antoniofilipovic): This can fail and we don't know we have set up new MAIN
-  if (!raft_state_.AppendSetInstanceAsMainLog(new_main_instance_name)) {
-    spdlog::trace("Append set instance as main failed, thread id {}, is leader {}", std::this_thread::get_id(),
-                  raft_state_.IsLeader());
-    return;
-  }
-
-  // TODO:
-  // Set trying failover on instance (chosen instance)
-  // If all passes, all good
-  // if it fails, we need to check if main was promoted and we have correct new uuid
-  // PromoteToMain -> split on promote to main and enable writting -> solves issue that we have
-  // consistent state
-
+  // TODO: (andi) This should be replicated across all coordinator instances with Raft log
+  SetMainUUID(new_main_uuid);
   spdlog::info("Failover successful! Instance {} promoted to main.", new_main->InstanceName());
 }
 
-auto CoordinatorInstance::SetReplicationInstanceToMain(std::string_view instance_name)
+// TODO: (andi) Make sure you cannot put coordinator instance to the main
+auto CoordinatorInstance::SetReplicationInstanceToMain(std::string instance_name)
     -> SetInstanceToMainCoordinatorStatus {
-  if (!is_running_) {
-    return SetInstanceToMainCoordinatorStatus::NOT_LEADER;
-    ;
-  }
   auto lock = std::lock_guard{coord_instance_lock_};
 
-  if (raft_state_.MainExists()) {
+  if (std::ranges::any_of(repl_instances_, &ReplicationInstance::IsMain)) {
     return SetInstanceToMainCoordinatorStatus::MAIN_ALREADY_EXISTS;
   }
 
-  if (!raft_state_.RequestLeadership()) {
-    return SetInstanceToMainCoordinatorStatus::NOT_LEADER;
-  }
-
   auto const is_new_main = [&instance_name](ReplicationInstance const &instance) {
     return instance.InstanceName() == instance_name;
   };
-
   auto new_main = std::ranges::find_if(repl_instances_, is_new_main);
 
   if (new_main == repl_instances_.end()) {
@@ -302,163 +192,99 @@ auto CoordinatorInstance::SetReplicationInstanceToMain(std::string_view instance
 
   auto const new_main_uuid = utils::UUID{};
 
-  auto const failed_to_swap = [&new_main_uuid](ReplicationInstance &instance) {
-    return !instance.SendSwapAndUpdateUUID(new_main_uuid);
-  };
-
-  if (std::ranges::any_of(repl_instances_ | ranges::views::filter(is_not_new_main), failed_to_swap)) {
-    spdlog::error("Failed to swap uuid for all instances");
-    return SetInstanceToMainCoordinatorStatus::SWAP_UUID_FAILED;
+  for (auto &other_instance : repl_instances_ | ranges::views::filter(is_not_new_main)) {
+    if (!other_instance.SendSwapAndUpdateUUID(new_main_uuid)) {
+      spdlog::error(
+          fmt::format("Failed to swap uuid for instance {}, aborting failover", other_instance.InstanceName()));
+      return SetInstanceToMainCoordinatorStatus::SWAP_UUID_FAILED;
+    }
   }
 
-  auto repl_clients_info = repl_instances_ | ranges::views::filter(is_not_new_main) |
-                           ranges::views::transform(&ReplicationInstance::ReplicationClientInfo) |
-                           ranges::to<ReplicationClientsInfo>();
+  ReplicationClientsInfo repl_clients_info;
+  repl_clients_info.reserve(repl_instances_.size() - 1);
+  std::ranges::transform(repl_instances_ | ranges::views::filter(is_not_new_main),
+                         std::back_inserter(repl_clients_info), &ReplicationInstance::ReplicationClientInfo);
 
   if (!new_main->PromoteToMain(new_main_uuid, std::move(repl_clients_info), &CoordinatorInstance::MainSuccessCallback,
                                &CoordinatorInstance::MainFailCallback)) {
     return SetInstanceToMainCoordinatorStatus::COULD_NOT_PROMOTE_TO_MAIN;
   }
 
-  if (!raft_state_.AppendUpdateUUIDLog(new_main_uuid)) {
-    return SetInstanceToMainCoordinatorStatus::RAFT_LOG_ERROR;
-  }
-
-  if (!raft_state_.AppendSetInstanceAsMainLog(instance_name)) {
-    return SetInstanceToMainCoordinatorStatus::RAFT_LOG_ERROR;
-  }
-
-  spdlog::info("Instance {} promoted to main on leader", instance_name);
+  // TODO: (andi) This should be replicated across all coordinator instances with Raft log
+  SetMainUUID(new_main_uuid);
+  spdlog::info("Instance {} promoted to main", instance_name);
   return SetInstanceToMainCoordinatorStatus::SUCCESS;
 }
 
-auto CoordinatorInstance::RegisterReplicationInstance(CoordinatorClientConfig const &config)
+auto CoordinatorInstance::RegisterReplicationInstance(CoordinatorClientConfig config)
     -> RegisterInstanceCoordinatorStatus {
-  if (!is_running_) {
-    return RegisterInstanceCoordinatorStatus::NOT_LEADER;
-    ;
-  }
   auto lock = std::lock_guard{coord_instance_lock_};
 
-  if (std::ranges::any_of(repl_instances_, [instance_name = config.instance_name](ReplicationInstance const &instance) {
-        return instance.InstanceName() == instance_name;
-      })) {
-    return RegisterInstanceCoordinatorStatus::NAME_EXISTS;
-  }
-
-  if (std::ranges::any_of(repl_instances_, [&config](ReplicationInstance const &instance) {
-        return instance.CoordinatorSocketAddress() == config.CoordinatorSocketAddress();
-      })) {
-    return RegisterInstanceCoordinatorStatus::COORD_ENDPOINT_EXISTS;
-  }
-
-  if (std::ranges::any_of(repl_instances_, [&config](ReplicationInstance const &instance) {
-        return instance.ReplicationSocketAddress() == config.ReplicationSocketAddress();
-      })) {
-    return RegisterInstanceCoordinatorStatus::REPL_ENDPOINT_EXISTS;
-  }
-
-  if (!raft_state_.RequestLeadership()) {
-    return RegisterInstanceCoordinatorStatus::NOT_LEADER;
-  }
-
-  auto *new_instance = &repl_instances_.emplace_back(this, config, client_succ_cb_, client_fail_cb_,
-                                                     &CoordinatorInstance::ReplicaSuccessCallback,
-                                                     &CoordinatorInstance::ReplicaFailCallback);
-
-  if (!new_instance->SendDemoteToReplicaRpc()) {
-    spdlog::error("Failed to send demote to replica rpc for instance {}", config.instance_name);
-    repl_instances_.pop_back();
-    return RegisterInstanceCoordinatorStatus::RPC_FAILED;
-  }
-
-  if (!raft_state_.AppendRegisterReplicationInstanceLog(config)) {
-    return RegisterInstanceCoordinatorStatus::RAFT_LOG_ERROR;
-  }
-
-  new_instance->StartFrequentCheck();
-
-  spdlog::info("Instance {} registered", config.instance_name);
-  return RegisterInstanceCoordinatorStatus::SUCCESS;
-}
-
-auto CoordinatorInstance::UnregisterReplicationInstance(std::string_view instance_name)
-    -> UnregisterInstanceCoordinatorStatus {
-  if (!is_running_) {
-    return UnregisterInstanceCoordinatorStatus::NOT_LEADER;
-    ;
-  }
-  auto lock = std::lock_guard{coord_instance_lock_};
-
-  if (!raft_state_.RequestLeadership()) {
-    return UnregisterInstanceCoordinatorStatus::NOT_LEADER;
-  }
+  auto instance_name = config.instance_name;
 
   auto const name_matches = [&instance_name](ReplicationInstance const &instance) {
     return instance.InstanceName() == instance_name;
   };
 
-  auto inst_to_remove = std::ranges::find_if(repl_instances_, name_matches);
-  if (inst_to_remove == repl_instances_.end()) {
-    return UnregisterInstanceCoordinatorStatus::NO_INSTANCE_WITH_NAME;
+  if (std::ranges::any_of(repl_instances_, name_matches)) {
+    return RegisterInstanceCoordinatorStatus::NAME_EXISTS;
   }
 
-  // TODO: (andi) Change so that RaftLogState is the central place for asking who is main...
+  auto const socket_address_matches = [&config](ReplicationInstance const &instance) {
+    return instance.SocketAddress() == config.SocketAddress();
+  };
 
-  auto const is_main = [this](ReplicationInstance const &instance) { return IsMain(instance.InstanceName()); };
-
-  if (is_main(*inst_to_remove) && inst_to_remove->IsAlive()) {
-    return UnregisterInstanceCoordinatorStatus::IS_MAIN;
+  if (std::ranges::any_of(repl_instances_, socket_address_matches)) {
+    return RegisterInstanceCoordinatorStatus::ENDPOINT_EXISTS;
   }
 
-  inst_to_remove->StopFrequentCheck();
-
-  auto curr_main = std::ranges::find_if(repl_instances_, is_main);
-
-  if (curr_main != repl_instances_.end() && curr_main->IsAlive()) {
-    if (!curr_main->SendUnregisterReplicaRpc(instance_name)) {
-      inst_to_remove->StartFrequentCheck();
-      return UnregisterInstanceCoordinatorStatus::RPC_FAILED;
-    }
+  if (!raft_state_.RequestLeadership()) {
+    return RegisterInstanceCoordinatorStatus::NOT_LEADER;
   }
 
-  std::erase_if(repl_instances_, name_matches);
-
-  if (!raft_state_.AppendUnregisterReplicationInstanceLog(instance_name)) {
-    return UnregisterInstanceCoordinatorStatus::RAFT_LOG_ERROR;
+  auto const res = raft_state_.AppendRegisterReplicationInstance(instance_name);
+  if (!res->get_accepted()) {
+    spdlog::error(
+        "Failed to accept request for registering instance {}. Most likely the reason is that the instance is not "
+        "the "
+        "leader.",
+        config.instance_name);
+    return RegisterInstanceCoordinatorStatus::RAFT_COULD_NOT_ACCEPT;
   }
 
-  return UnregisterInstanceCoordinatorStatus::SUCCESS;
-}
+  spdlog::info("Request for registering instance {} accepted", instance_name);
+  try {
+    repl_instances_.emplace_back(this, std::move(config), client_succ_cb_, client_fail_cb_,
+                                 &CoordinatorInstance::ReplicaSuccessCallback,
+                                 &CoordinatorInstance::ReplicaFailCallback);
+  } catch (CoordinatorRegisterInstanceException const &) {
+    return RegisterInstanceCoordinatorStatus::RPC_FAILED;
+  }
 
-auto CoordinatorInstance::AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port,
-                                                 std::string_view raft_address) -> void {
-  raft_state_.AddCoordinatorInstance(raft_server_id, raft_port, raft_address);
+  if (res->get_result_code() != nuraft::cmd_result_code::OK) {
+    spdlog::error("Failed to register instance {} with error code {}", instance_name, res->get_result_code());
+    return RegisterInstanceCoordinatorStatus::RAFT_COULD_NOT_APPEND;
+  }
+
+  spdlog::info("Instance {} registered", instance_name);
+  return RegisterInstanceCoordinatorStatus::SUCCESS;
 }
 
 void CoordinatorInstance::MainFailCallback(std::string_view repl_instance_name) {
-  if (!is_running_) {
-    return;
-  }
-  spdlog::trace("Instance {} performing main fail callback", repl_instance_name);
   auto &repl_instance = FindReplicationInstance(repl_instance_name);
   repl_instance.OnFailPing();
   const auto &repl_instance_uuid = repl_instance.GetMainUUID();
-  MG_ASSERT(repl_instance_uuid.has_value(), "Replication instance must have uuid set");
+  MG_ASSERT(repl_instance_uuid.has_value(), "Instance must have uuid set");
 
-  // NOLINTNEXTLINE
-  if (!repl_instance.IsAlive() && raft_state_.GetUUID() == repl_instance_uuid.value()) {
+  if (!repl_instance.IsAlive() && GetMainUUID() == repl_instance_uuid.value()) {
     spdlog::info("Cluster without main instance, trying automatic failover");
     TryFailover();
   }
 }
 
 void CoordinatorInstance::MainSuccessCallback(std::string_view repl_instance_name) {
-  if (!is_running_) {
-    return;
-  }
-  spdlog::trace("Instance {} performing main successful callback", repl_instance_name);
   auto &repl_instance = FindReplicationInstance(repl_instance_name);
+  spdlog::trace("Instance {} performing main successful callback", repl_instance_name);
 
   if (repl_instance.IsAlive()) {
     repl_instance.OnSuccessPing();
@@ -468,8 +294,8 @@ void CoordinatorInstance::MainSuccessCallback(std::string_view repl_instance_nam
   const auto &repl_instance_uuid = repl_instance.GetMainUUID();
   MG_ASSERT(repl_instance_uuid.has_value(), "Instance must have uuid set.");
 
-  // NOLINTNEXTLINE
-  if (raft_state_.GetUUID() == repl_instance_uuid.value()) {
+  auto const curr_main_uuid = GetMainUUID();
+  if (curr_main_uuid == repl_instance_uuid.value()) {
     if (!repl_instance.EnableWritingOnMain()) {
       spdlog::error("Failed to enable writing on main instance {}", repl_instance_name);
       return;
@@ -479,12 +305,6 @@ void CoordinatorInstance::MainSuccessCallback(std::string_view repl_instance_nam
     return;
   }
 
-  if (!raft_state_.RequestLeadership()) {
-    spdlog::error("Demoting main instance {} to replica failed since the instance is not the leader!",
-                  repl_instance_name);
-    return;
-  }
-
   if (repl_instance.DemoteToReplica(&CoordinatorInstance::ReplicaSuccessCallback,
                                     &CoordinatorInstance::ReplicaFailCallback)) {
     repl_instance.OnSuccessPing();
@@ -494,32 +314,24 @@ void CoordinatorInstance::MainSuccessCallback(std::string_view repl_instance_nam
     return;
   }
 
-  if (!repl_instance.SendSwapAndUpdateUUID(raft_state_.GetUUID())) {
-    spdlog::error("Failed to swap uuid for demoted main instance {}", repl_instance_name);
-    return;
-  }
-
-  if (!raft_state_.AppendSetInstanceAsReplicaLog(repl_instance_name)) {
+  if (!repl_instance.SendSwapAndUpdateUUID(curr_main_uuid)) {
+    spdlog::error(fmt::format("Failed to swap uuid for demoted main instance {}", repl_instance.InstanceName()));
     return;
   }
 }
 
 void CoordinatorInstance::ReplicaSuccessCallback(std::string_view repl_instance_name) {
-  if (!is_running_) {
-    return;
-  }
-  spdlog::trace("Instance {} performing replica successful callback", repl_instance_name);
   auto &repl_instance = FindReplicationInstance(repl_instance_name);
-
-  if (!IsReplica(repl_instance_name)) {
+  if (!repl_instance.IsReplica()) {
     spdlog::error("Aborting replica callback since instance {} is not replica anymore", repl_instance_name);
     return;
   }
+  spdlog::trace("Instance {} performing replica successful callback", repl_instance_name);
   // We need to get replicas UUID from time to time to ensure replica is listening to correct main
   // and that it didn't go down for less time than we could notice
   // We need to get id of main replica is listening to
   // and swap if necessary
-  if (!repl_instance.EnsureReplicaHasCorrectMainUUID(raft_state_.GetUUID())) {
+  if (!repl_instance.EnsureReplicaHasCorrectMainUUID(GetMainUUID())) {
     spdlog::error("Failed to swap uuid for replica instance {} which is alive", repl_instance.InstanceName());
     return;
   }
@@ -528,23 +340,58 @@ void CoordinatorInstance::ReplicaSuccessCallback(std::string_view repl_instance_
 }
 
 void CoordinatorInstance::ReplicaFailCallback(std::string_view repl_instance_name) {
-  if (!is_running_) {
-    return;
-  }
-  spdlog::trace("Instance {} performing replica failure callback", repl_instance_name);
   auto &repl_instance = FindReplicationInstance(repl_instance_name);
-
-  if (!IsReplica(repl_instance_name)) {
+  if (!repl_instance.IsReplica()) {
     spdlog::error("Aborting replica fail callback since instance {} is not replica anymore", repl_instance_name);
     return;
   }
-
+  spdlog::trace("Instance {} performing replica failure callback", repl_instance_name);
   repl_instance.OnFailPing();
 }
 
-auto CoordinatorInstance::ChooseMostUpToDateInstance(std::span<InstanceNameDbHistories> instance_database_histories)
-    -> NewMainRes {
-  std::optional<NewMainRes> new_main_res;
+auto CoordinatorInstance::UnregisterReplicationInstance(std::string instance_name)
+    -> UnregisterInstanceCoordinatorStatus {
+  auto lock = std::lock_guard{coord_instance_lock_};
+
+  auto const name_matches = [&instance_name](ReplicationInstance const &instance) {
+    return instance.InstanceName() == instance_name;
+  };
+
+  auto inst_to_remove = std::ranges::find_if(repl_instances_, name_matches);
+  if (inst_to_remove == repl_instances_.end()) {
+    return UnregisterInstanceCoordinatorStatus::NO_INSTANCE_WITH_NAME;
+  }
+
+  if (inst_to_remove->IsMain() && inst_to_remove->IsAlive()) {
+    return UnregisterInstanceCoordinatorStatus::IS_MAIN;
+  }
+
+  inst_to_remove->StopFrequentCheck();
+  auto curr_main = std::ranges::find_if(repl_instances_, &ReplicationInstance::IsMain);
+  MG_ASSERT(curr_main != repl_instances_.end(), "There must be a main instance when unregistering a replica");
+  if (!curr_main->SendUnregisterReplicaRpc(instance_name)) {
+    inst_to_remove->StartFrequentCheck();
+    return UnregisterInstanceCoordinatorStatus::RPC_FAILED;
+  }
+  std::erase_if(repl_instances_, name_matches);
+
+  return UnregisterInstanceCoordinatorStatus::SUCCESS;
+}
+
+auto CoordinatorInstance::AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address)
+    -> void {
+  raft_state_.AddCoordinatorInstance(raft_server_id, raft_port, std::move(raft_address));
+}
+
+auto CoordinatorInstance::GetMainUUID() const -> utils::UUID { return main_uuid_; }
+
+// TODO: (andi) Add to the RAFT log.
+auto CoordinatorInstance::SetMainUUID(utils::UUID new_uuid) -> void { main_uuid_ = new_uuid; }
+
+auto CoordinatorInstance::ChooseMostUpToDateInstance(
+    const std::vector<std::pair<std::string, replication_coordination_glue::DatabaseHistories>>
+        &instance_database_histories) -> NewMainRes {
+  NewMainRes new_main_res;
   std::for_each(
       instance_database_histories.begin(), instance_database_histories.end(),
       [&new_main_res](const InstanceNameDbHistories &instance_res_pair) {
@@ -560,7 +407,7 @@ auto CoordinatorInstance::ChooseMostUpToDateInstance(std::span<InstanceNameDbHis
         std::ranges::for_each(
             instance_db_histories,
             [&instance_name = instance_name](const replication_coordination_glue::DatabaseHistory &db_history) {
-              spdlog::debug("Instance {}: name {}, default db {}", instance_name, db_history.name,
+              spdlog::trace("Instance {}: name {}, default db {}", instance_name, db_history.name,
                             memgraph::dbms::kDefaultDB);
             });
 
@@ -570,26 +417,35 @@ auto CoordinatorInstance::ChooseMostUpToDateInstance(std::span<InstanceNameDbHis
 
         std::ranges::for_each(instance_default_db_history | ranges::views::reverse,
                               [&instance_name = instance_name](const auto &epoch_history_it) {
-                                spdlog::debug("Instance {}: epoch {}, last_commit_timestamp: {}", instance_name,
+                                spdlog::trace("Instance {}: epoch {}, last_commit_timestamp: {}", instance_name,
                                               std::get<0>(epoch_history_it), std::get<1>(epoch_history_it));
                               });
 
         // get latest epoch
         // get latest timestamp
 
-        if (!new_main_res) {
+        if (!new_main_res.latest_epoch) {
           const auto &[epoch, timestamp] = *instance_default_db_history.crbegin();
-          new_main_res = std::make_optional<NewMainRes>({instance_name, epoch, timestamp});
-          spdlog::debug("Currently the most up to date instance is {} with epoch {} and {} latest commit timestamp",
+          new_main_res = NewMainRes{
+              .most_up_to_date_instance = instance_name,
+              .latest_epoch = epoch,
+              .latest_commit_timestamp = timestamp,
+          };
+          spdlog::trace("Currently the most up to date instance is {} with epoch {} and {} latest commit timestamp",
                         instance_name, epoch, timestamp);
           return;
         }
 
         bool found_same_point{false};
-        std::string last_most_up_to_date_epoch{new_main_res->latest_epoch};
+        std::string last_most_up_to_date_epoch{*new_main_res.latest_epoch};
         for (auto [epoch, timestamp] : ranges::reverse_view(instance_default_db_history)) {
-          if (new_main_res->latest_commit_timestamp < timestamp) {
-            new_main_res = std::make_optional<NewMainRes>({instance_name, epoch, timestamp});
+          if (*new_main_res.latest_commit_timestamp < timestamp) {
+            new_main_res = NewMainRes{
+                .most_up_to_date_instance = instance_name,
+                .latest_epoch = epoch,
+                .latest_commit_timestamp = timestamp,
+            };
+
             spdlog::trace("Found the new most up to date instance {} with epoch {} and {} latest commit timestamp",
                           instance_name, epoch, timestamp);
           }
@@ -603,20 +459,11 @@ auto CoordinatorInstance::ChooseMostUpToDateInstance(std::span<InstanceNameDbHis
 
         if (!found_same_point) {
           spdlog::error("Didn't find same history epoch {} for instance {} and instance {}", last_most_up_to_date_epoch,
-                        new_main_res->most_up_to_date_instance, instance_name);
+                        new_main_res.most_up_to_date_instance, instance_name);
         }
       });
 
-  return std::move(*new_main_res);
+  return new_main_res;
 }
-
-auto CoordinatorInstance::IsMain(std::string_view instance_name) const -> bool {
-  return raft_state_.IsMain(instance_name);
-}
-
-auto CoordinatorInstance::IsReplica(std::string_view instance_name) const -> bool {
-  return raft_state_.IsReplica(instance_name);
-}
-
 }  // namespace memgraph::coordination
 #endif

src/coordination/coordinator_state.cpp

@@ -41,7 +41,7 @@ CoordinatorState::CoordinatorState() {
   }
 }
 
-auto CoordinatorState::RegisterReplicationInstance(CoordinatorClientConfig const &config)
+auto CoordinatorState::RegisterReplicationInstance(CoordinatorClientConfig config)
     -> RegisterInstanceCoordinatorStatus {
   MG_ASSERT(std::holds_alternative<CoordinatorInstance>(data_),
             "Coordinator cannot register replica since variant holds wrong alternative");
@@ -56,8 +56,7 @@ auto CoordinatorState::RegisterReplicationInstance(CoordinatorClientConfig const
       data_);
 }
 
-auto CoordinatorState::UnregisterReplicationInstance(std::string_view instance_name)
-    -> UnregisterInstanceCoordinatorStatus {
+auto CoordinatorState::UnregisterReplicationInstance(std::string instance_name) -> UnregisterInstanceCoordinatorStatus {
   MG_ASSERT(std::holds_alternative<CoordinatorInstance>(data_),
             "Coordinator cannot unregister instance since variant holds wrong alternative");
 
@@ -71,8 +70,7 @@ auto CoordinatorState::UnregisterReplicationInstance(std::string_view instance_n
       data_);
 }
 
-auto CoordinatorState::SetReplicationInstanceToMain(std::string_view instance_name)
-    -> SetInstanceToMainCoordinatorStatus {
+auto CoordinatorState::SetReplicationInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus {
   MG_ASSERT(std::holds_alternative<CoordinatorInstance>(data_),
             "Coordinator cannot register replica since variant holds wrong alternative");
 
@@ -98,8 +96,8 @@ auto CoordinatorState::GetCoordinatorServer() const -> CoordinatorServer & {
   return *std::get<CoordinatorMainReplicaData>(data_).coordinator_server_;
 }
 
-auto CoordinatorState::AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port,
-                                              std::string_view raft_address) -> void {
+auto CoordinatorState::AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address)
+    -> void {
   MG_ASSERT(std::holds_alternative<CoordinatorInstance>(data_),
             "Coordinator cannot register replica since variant holds wrong alternative");
   return std::get<CoordinatorInstance>(data_).AddCoordinatorInstance(raft_server_id, raft_port, raft_address);

src/coordination/coordinator_state_machine.cpp

@@ -12,94 +12,37 @@
 #ifdef MG_ENTERPRISE
 
 #include "nuraft/coordinator_state_machine.hpp"
-#include "utils/logging.hpp"
 
 namespace memgraph::coordination {
 
-auto CoordinatorStateMachine::FindCurrentMainInstanceName() const -> std::optional<std::string> {
-  return cluster_state_.FindCurrentMainInstanceName();
+auto CoordinatorStateMachine::EncodeRegisterReplicationInstance(const std::string &name) -> ptr<buffer> {
+  std::string str_log = name + "_replica";
+  ptr<buffer> log = buffer::alloc(sizeof(uint32_t) + str_log.size());
+  buffer_serializer bs(log);
+  bs.put_str(str_log);
+  return log;
 }
 
-auto CoordinatorStateMachine::MainExists() const -> bool { return cluster_state_.MainExists(); }
-
-auto CoordinatorStateMachine::IsMain(std::string_view instance_name) const -> bool {
-  return cluster_state_.IsMain(instance_name);
-}
-
-auto CoordinatorStateMachine::IsReplica(std::string_view instance_name) const -> bool {
-  return cluster_state_.IsReplica(instance_name);
-}
-
-auto CoordinatorStateMachine::CreateLog(std::string_view log) -> ptr<buffer> {
-  ptr<buffer> log_buf = buffer::alloc(sizeof(uint32_t) + log.size());
-  buffer_serializer bs(log_buf);
-  bs.put_str(log.data());
-  return log_buf;
-}
-
-auto CoordinatorStateMachine::SerializeRegisterInstance(CoordinatorClientConfig const &config) -> ptr<buffer> {
-  auto const str_log = fmt::format("{}*register", config.ToString());
-  return CreateLog(str_log);
-}
-
-auto CoordinatorStateMachine::SerializeUnregisterInstance(std::string_view instance_name) -> ptr<buffer> {
-  auto const str_log = fmt::format("{}*unregister", instance_name);
-  return CreateLog(str_log);
-}
-
-auto CoordinatorStateMachine::SerializeSetInstanceAsMain(std::string_view instance_name) -> ptr<buffer> {
-  auto const str_log = fmt::format("{}*promote", instance_name);
-  return CreateLog(str_log);
-}
-
-auto CoordinatorStateMachine::SerializeSetInstanceAsReplica(std::string_view instance_name) -> ptr<buffer> {
-  auto const str_log = fmt::format("{}*demote", instance_name);
-  return CreateLog(str_log);
-}
-
-auto CoordinatorStateMachine::SerializeUpdateUUID(utils::UUID const &uuid) -> ptr<buffer> {
-  auto const str_log = fmt::format("{}*update_uuid", nlohmann::json{{"uuid", uuid}}.dump());
-  return CreateLog(str_log);
-}
-
-auto CoordinatorStateMachine::DecodeLog(buffer &data) -> std::pair<TRaftLog, RaftLogAction> {
+auto CoordinatorStateMachine::DecodeRegisterReplicationInstance(buffer &data) -> std::string {
   buffer_serializer bs(data);
-
-  auto const log_str = bs.get_str();
-  auto const sep = log_str.find('*');
-  auto const action = log_str.substr(sep + 1);
-  auto const info = log_str.substr(0, sep);
-
-  if (action == "register") {
-    return {CoordinatorClientConfig::FromString(info), RaftLogAction::REGISTER_REPLICATION_INSTANCE};
-  }
-  if (action == "unregister") {
-    return {info, RaftLogAction::UNREGISTER_REPLICATION_INSTANCE};
-  }
-  if (action == "promote") {
-    return {info, RaftLogAction::SET_INSTANCE_AS_MAIN};
-  }
-  if (action == "demote") {
-    return {info, RaftLogAction::SET_INSTANCE_AS_REPLICA};
-  }
-  if (action == "update_uuid") {
-    auto const json = nlohmann::json::parse(info);
-    return {json.at("uuid").get<utils::UUID>(), RaftLogAction::UPDATE_UUID};
-  }
-
-  throw std::runtime_error("Unknown action");
+  return bs.get_str();
 }
 
-auto CoordinatorStateMachine::pre_commit(ulong const /*log_idx*/, buffer & /*data*/) -> ptr<buffer> { return nullptr; }
+auto CoordinatorStateMachine::pre_commit(ulong const log_idx, buffer &data) -> ptr<buffer> {
+  buffer_serializer bs(data);
+  std::string str = bs.get_str();
+
+  spdlog::info("pre_commit {} : {}", log_idx, str);
+  return nullptr;
+}
 
 auto CoordinatorStateMachine::commit(ulong const log_idx, buffer &data) -> ptr<buffer> {
   buffer_serializer bs(data);
+  std::string str = bs.get_str();
 
-  auto const [parsed_data, log_action] = DecodeLog(data);
-  cluster_state_.DoAction(parsed_data, log_action);
+  spdlog::info("commit {} : {}", log_idx, str);
 
   last_committed_idx_ = log_idx;
-  // TODO: (andi) Don't return nullptr
   return nullptr;
 }
 
@@ -108,95 +51,61 @@ auto CoordinatorStateMachine::commit_config(ulong const log_idx, ptr<cluster_con
 }
 
 auto CoordinatorStateMachine::rollback(ulong const log_idx, buffer &data) -> void {
-  // NOTE: Nothing since we don't do anything in pre_commit
+  buffer_serializer bs(data);
+  std::string str = bs.get_str();
+
+  spdlog::info("rollback {} : {}", log_idx, str);
 }
 
-auto CoordinatorStateMachine::read_logical_snp_obj(snapshot &snapshot, void *& /*user_snp_ctx*/, ulong obj_id,
+auto CoordinatorStateMachine::read_logical_snp_obj(snapshot & /*snapshot*/, void *& /*user_snp_ctx*/, ulong /*obj_id*/,
                                                    ptr<buffer> &data_out, bool &is_last_obj) -> int {
-  spdlog::info("read logical snapshot object, obj_id: {}", obj_id);
+  // Put dummy data.
+  data_out = buffer::alloc(sizeof(int32));
+  buffer_serializer bs(data_out);
+  bs.put_i32(0);
 
-  ptr<SnapshotCtx> ctx = nullptr;
-  {
-    auto ll = std::lock_guard{snapshots_lock_};
-    auto entry = snapshots_.find(snapshot.get_last_log_idx());
-    if (entry == snapshots_.end()) {
-      data_out = nullptr;
-      is_last_obj = true;
-      return 0;
-    }
-    ctx = entry->second;
-  }
-  ctx->cluster_state_.Serialize(data_out);
   is_last_obj = true;
   return 0;
 }
 
-auto CoordinatorStateMachine::save_logical_snp_obj(snapshot &snapshot, ulong &obj_id, buffer &data, bool is_first_obj,
-                                                   bool is_last_obj) -> void {
-  spdlog::info("save logical snapshot object, obj_id: {}, is_first_obj: {}, is_last_obj: {}", obj_id, is_first_obj,
-               is_last_obj);
-
-  buffer_serializer bs(data);
-  auto cluster_state = CoordinatorClusterState::Deserialize(data);
-
-  {
-    auto ll = std::lock_guard{snapshots_lock_};
-    auto entry = snapshots_.find(snapshot.get_last_log_idx());
-    DMG_ASSERT(entry != snapshots_.end());
-    entry->second->cluster_state_ = cluster_state;
-  }
+auto CoordinatorStateMachine::save_logical_snp_obj(snapshot &s, ulong &obj_id, buffer & /*data*/, bool /*is_first_obj*/,
+                                                   bool /*is_last_obj*/) -> void {
+  spdlog::info("save snapshot {} term {} object ID", s.get_last_log_idx(), s.get_last_log_term(), obj_id);
+  // Request next object.
+  obj_id++;
 }
 
 auto CoordinatorStateMachine::apply_snapshot(snapshot &s) -> bool {
-  auto ll = std::lock_guard{snapshots_lock_};
-
-  auto entry = snapshots_.find(s.get_last_log_idx());
-  if (entry == snapshots_.end()) return false;
-
-  cluster_state_ = entry->second->cluster_state_;
+  spdlog::info("apply snapshot {} term {}", s.get_last_log_idx(), s.get_last_log_term());
+  {
+    auto lock = std::lock_guard{last_snapshot_lock_};
+    ptr<buffer> snp_buf = s.serialize();
+    last_snapshot_ = snapshot::deserialize(*snp_buf);
+  }
   return true;
 }
 
 auto CoordinatorStateMachine::free_user_snp_ctx(void *&user_snp_ctx) -> void {}
 
 auto CoordinatorStateMachine::last_snapshot() -> ptr<snapshot> {
-  auto ll = std::lock_guard{snapshots_lock_};
-  auto entry = snapshots_.rbegin();
-  if (entry == snapshots_.rend()) return nullptr;
-
-  ptr<SnapshotCtx> ctx = entry->second;
-  return ctx->snapshot_;
+  auto lock = std::lock_guard{last_snapshot_lock_};
+  return last_snapshot_;
 }
 
 auto CoordinatorStateMachine::last_commit_index() -> ulong { return last_committed_idx_; }
 
 auto CoordinatorStateMachine::create_snapshot(snapshot &s, async_result<bool>::handler_type &when_done) -> void {
-  ptr<buffer> snp_buf = s.serialize();
-  ptr<snapshot> ss = snapshot::deserialize(*snp_buf);
-  create_snapshot_internal(ss);
-
+  spdlog::info("create snapshot {} term {}", s.get_last_log_idx(), s.get_last_log_term());
+  // Clone snapshot from `s`.
+  {
+    auto lock = std::lock_guard{last_snapshot_lock_};
+    ptr<buffer> snp_buf = s.serialize();
+    last_snapshot_ = snapshot::deserialize(*snp_buf);
+  }
   ptr<std::exception> except(nullptr);
   bool ret = true;
   when_done(ret, except);
 }
 
-auto CoordinatorStateMachine::create_snapshot_internal(ptr<snapshot> snapshot) -> void {
-  auto ll = std::lock_guard{snapshots_lock_};
-
-  auto ctx = cs_new<SnapshotCtx>(snapshot, cluster_state_);
-  snapshots_[snapshot->get_last_log_idx()] = ctx;
-
-  constexpr int MAX_SNAPSHOTS = 3;
-  while (snapshots_.size() > MAX_SNAPSHOTS) {
-    snapshots_.erase(snapshots_.begin());
-  }
-}
-
-auto CoordinatorStateMachine::GetInstances() const -> std::vector<InstanceState> {
-  return cluster_state_.GetInstances();
-}
-
-auto CoordinatorStateMachine::GetUUID() const -> utils::UUID { return cluster_state_.GetUUID(); }
-
 }  // namespace memgraph::coordination
 #endif

src/coordination/include/coordination/coordinator_client.hpp

@@ -46,17 +46,16 @@ class CoordinatorClient {
   void ResumeFrequentCheck();
 
   auto InstanceName() const -> std::string;
-  auto CoordinatorSocketAddress() const -> std::string;
-  auto ReplicationSocketAddress() const -> std::string;
+  auto SocketAddress() const -> std::string;
 
   [[nodiscard]] auto DemoteToReplica() const -> bool;
 
-  auto SendPromoteReplicaToMainRpc(utils::UUID const &uuid, ReplicationClientsInfo replication_clients_info) const
+  auto SendPromoteReplicaToMainRpc(const utils::UUID &uuid, ReplicationClientsInfo replication_clients_info) const
       -> bool;
 
-  auto SendSwapMainUUIDRpc(utils::UUID const &uuid) const -> bool;
+  auto SendSwapMainUUIDRpc(const utils::UUID &uuid) const -> bool;
 
-  auto SendUnregisterReplicaRpc(std::string_view instance_name) const -> bool;
+  auto SendUnregisterReplicaRpc(std::string const &instance_name) const -> bool;
 
   auto SendEnableWritingOnMainRpc() const -> bool;
 

src/coordination/include/coordination/coordinator_config.hpp

@@ -14,20 +14,16 @@
 #ifdef MG_ENTERPRISE
 
 #include "replication_coordination_glue/mode.hpp"
-#include "utils/string.hpp"
 
 #include <chrono>
 #include <cstdint>
 #include <optional>
 #include <string>
 
-#include <fmt/format.h>
-
 namespace memgraph::coordination {
 
 inline constexpr auto *kDefaultReplicationServerIp = "0.0.0.0";
 
-// TODO: (andi) JSON serialization for RAFT log.
 struct CoordinatorClientConfig {
   std::string instance_name;
   std::string ip_address;
@@ -36,35 +32,14 @@ struct CoordinatorClientConfig {
   std::chrono::seconds instance_down_timeout_sec{5};
   std::chrono::seconds instance_get_uuid_frequency_sec{10};
 
-  auto CoordinatorSocketAddress() const -> std::string { return fmt::format("{}:{}", ip_address, port); }
-  auto ReplicationSocketAddress() const -> std::string {
-    return fmt::format("{}:{}", replication_client_info.replication_ip_address,
-                       replication_client_info.replication_port);
-  }
+  auto SocketAddress() const -> std::string { return ip_address + ":" + std::to_string(port); }
 
   struct ReplicationClientInfo {
-    // TODO: (andi) Do we even need here instance_name for this struct?
     std::string instance_name;
     replication_coordination_glue::ReplicationMode replication_mode{};
     std::string replication_ip_address;
     uint16_t replication_port{};
 
-    auto ToString() const -> std::string {
-      return fmt::format("{}#{}#{}#{}", instance_name, replication_ip_address, replication_port,
-                         replication_coordination_glue::ReplicationModeToString(replication_mode));
-    }
-
-    // TODO: (andi) How can I make use of monadic parsers here?
-    static auto FromString(std::string_view log) -> ReplicationClientInfo {
-      ReplicationClientInfo replication_client_info;
-      auto splitted = utils::Split(log, "#");
-      replication_client_info.instance_name = splitted[0];
-      replication_client_info.replication_ip_address = splitted[1];
-      replication_client_info.replication_port = std::stoi(splitted[2]);
-      replication_client_info.replication_mode = replication_coordination_glue::ReplicationModeFromString(splitted[3]);
-      return replication_client_info;
-    }
-
     friend bool operator==(ReplicationClientInfo const &, ReplicationClientInfo const &) = default;
   };
 
@@ -79,25 +54,6 @@ struct CoordinatorClientConfig {
 
   std::optional<SSL> ssl;
 
-  auto ToString() const -> std::string {
-    return fmt::format("{}|{}|{}|{}|{}|{}|{}", instance_name, ip_address, port,
-                       instance_health_check_frequency_sec.count(), instance_down_timeout_sec.count(),
-                       instance_get_uuid_frequency_sec.count(), replication_client_info.ToString());
-  }
-
-  static auto FromString(std::string_view log) -> CoordinatorClientConfig {
-    CoordinatorClientConfig config;
-    auto splitted = utils::Split(log, "|");
-    config.instance_name = splitted[0];
-    config.ip_address = splitted[1];
-    config.port = std::stoi(splitted[2]);
-    config.instance_health_check_frequency_sec = std::chrono::seconds(std::stoi(splitted[3]));
-    config.instance_down_timeout_sec = std::chrono::seconds(std::stoi(splitted[4]));
-    config.instance_get_uuid_frequency_sec = std::chrono::seconds(std::stoi(splitted[5]));
-    config.replication_client_info = ReplicationClientInfo::FromString(splitted[6]);
-    return config;
-  }
-
   friend bool operator==(CoordinatorClientConfig const &, CoordinatorClientConfig const &) = default;
 };
 

src/coordination/include/coordination/coordinator_exceptions.hpp

@@ -83,16 +83,5 @@ class RaftCouldNotParseFlagsException final : public utils::BasicException {
   SPECIALIZE_GET_EXCEPTION_NAME(RaftCouldNotParseFlagsException)
 };
 
-class InvalidRaftLogActionException final : public utils::BasicException {
- public:
-  explicit InvalidRaftLogActionException(std::string_view what) noexcept : BasicException(what) {}
-
-  template <class... Args>
-  explicit InvalidRaftLogActionException(fmt::format_string<Args...> fmt, Args &&...args) noexcept
-      : InvalidRaftLogActionException(fmt::format(fmt, std::forward<Args>(args)...)) {}
-
-  SPECIALIZE_GET_EXCEPTION_NAME(InvalidRaftLogActionException)
-};
-
 }  // namespace memgraph::coordination
 #endif

src/coordination/include/coordination/coordinator_instance.hpp

@@ -28,8 +28,8 @@ namespace memgraph::coordination {
 
 struct NewMainRes {
   std::string most_up_to_date_instance;
-  std::string latest_epoch;
-  uint64_t latest_commit_timestamp;
+  std::optional<std::string> latest_epoch;
+  std::optional<uint64_t> latest_commit_timestamp;
 };
 using InstanceNameDbHistories = std::pair<std::string, replication_coordination_glue::DatabaseHistories>;
 
@@ -37,25 +37,20 @@ class CoordinatorInstance {
  public:
   CoordinatorInstance();
 
-  [[nodiscard]] auto RegisterReplicationInstance(CoordinatorClientConfig const &config)
-      -> RegisterInstanceCoordinatorStatus;
-  [[nodiscard]] auto UnregisterReplicationInstance(std::string_view instance_name)
-      -> UnregisterInstanceCoordinatorStatus;
+  [[nodiscard]] auto RegisterReplicationInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus;
+  [[nodiscard]] auto UnregisterReplicationInstance(std::string instance_name) -> UnregisterInstanceCoordinatorStatus;
 
-  [[nodiscard]] auto SetReplicationInstanceToMain(std::string_view instance_name) -> SetInstanceToMainCoordinatorStatus;
+  [[nodiscard]] auto SetReplicationInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus;
 
   auto ShowInstances() const -> std::vector<InstanceStatus>;
 
   auto TryFailover() -> void;
 
-  auto AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string_view raft_address) -> void;
+  auto AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address) -> void;
 
-  static auto ChooseMostUpToDateInstance(std::span<InstanceNameDbHistories> histories) -> NewMainRes;
+  auto GetMainUUID() const -> utils::UUID;
 
- private:
-  HealthCheckClientCallback client_succ_cb_, client_fail_cb_;
-
-  auto OnRaftCommitCallback(TRaftLog const &log_entry, RaftLogAction log_action) -> void;
+  auto SetMainUUID(utils::UUID new_uuid) -> void;
 
   auto FindReplicationInstance(std::string_view replication_instance_name) -> ReplicationInstance &;
 
@@ -67,14 +62,17 @@ class CoordinatorInstance {
 
   void ReplicaFailCallback(std::string_view);
 
-  auto IsMain(std::string_view instance_name) const -> bool;
-  auto IsReplica(std::string_view instance_name) const -> bool;
+  static auto ChooseMostUpToDateInstance(const std::vector<InstanceNameDbHistories> &) -> NewMainRes;
 
-  // NOTE: Must be std::list because we rely on pointer stability.
-  // Leader and followers should both have same view on repl_instances_
+ private:
+  HealthCheckClientCallback client_succ_cb_, client_fail_cb_;
+
+  // NOTE: Must be std::list because we rely on pointer stability
   std::list<ReplicationInstance> repl_instances_;
   mutable utils::ResourceLock coord_instance_lock_{};
 
+  utils::UUID main_uuid_;
+
   RaftState raft_state_;
 };
 

src/coordination/include/coordination/coordinator_state.hpp

@@ -33,16 +33,14 @@ class CoordinatorState {
   CoordinatorState(CoordinatorState &&) noexcept = delete;
   CoordinatorState &operator=(CoordinatorState &&) noexcept = delete;
 
-  [[nodiscard]] auto RegisterReplicationInstance(CoordinatorClientConfig const &config)
-      -> RegisterInstanceCoordinatorStatus;
-  [[nodiscard]] auto UnregisterReplicationInstance(std::string_view instance_name)
-      -> UnregisterInstanceCoordinatorStatus;
+  [[nodiscard]] auto RegisterReplicationInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus;
+  [[nodiscard]] auto UnregisterReplicationInstance(std::string instance_name) -> UnregisterInstanceCoordinatorStatus;
 
-  [[nodiscard]] auto SetReplicationInstanceToMain(std::string_view instance_name) -> SetInstanceToMainCoordinatorStatus;
+  [[nodiscard]] auto SetReplicationInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus;
 
   auto ShowInstances() const -> std::vector<InstanceStatus>;
 
-  auto AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string_view raft_address) -> void;
+  auto AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address) -> void;
 
   // NOTE: The client code must check that the server exists before calling this method.
   auto GetCoordinatorServer() const -> CoordinatorServer &;

src/coordination/include/coordination/instance_status.hpp

@@ -26,7 +26,7 @@ struct InstanceStatus {
   std::string raft_socket_address;
   std::string coord_socket_address;
   std::string cluster_role;
-  std::string health;
+  bool is_alive;
 };
 
 }  // namespace memgraph::coordination

src/coordination/include/coordination/raft_state.hpp

@@ -14,16 +14,11 @@
 #ifdef MG_ENTERPRISE
 
 #include <flags/replication.hpp>
-#include "nuraft/coordinator_state_machine.hpp"
-#include "nuraft/coordinator_state_manager.hpp"
 
 #include <libnuraft/nuraft.hxx>
 
 namespace memgraph::coordination {
 
-class CoordinatorInstance;
-struct CoordinatorClientConfig;
-
 using BecomeLeaderCb = std::function<void()>;
 using BecomeFollowerCb = std::function<void()>;
 
@@ -52,39 +47,26 @@ class RaftState {
   RaftState &operator=(RaftState &&other) noexcept = default;
   ~RaftState();
 
-  static auto MakeRaftState(BecomeLeaderCb &&become_leader_cb, BecomeFollowerCb &&become_follower_cb) -> RaftState;
+  static auto MakeRaftState(BecomeLeaderCb become_leader_cb, BecomeFollowerCb become_follower_cb) -> RaftState;
 
   auto InstanceName() const -> std::string;
   auto RaftSocketAddress() const -> std::string;
 
-  auto AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string_view raft_address) -> void;
+  auto AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address) -> void;
   auto GetAllCoordinators() const -> std::vector<ptr<srv_config>>;
 
   auto RequestLeadership() -> bool;
   auto IsLeader() const -> bool;
 
-  auto FindCurrentMainInstanceName() const -> std::optional<std::string>;
-  auto MainExists() const -> bool;
-  auto IsMain(std::string_view instance_name) const -> bool;
-  auto IsReplica(std::string_view instance_name) const -> bool;
+  auto AppendRegisterReplicationInstance(std::string const &instance) -> ptr<raft_result>;
 
-  auto AppendRegisterReplicationInstanceLog(CoordinatorClientConfig const &config) -> bool;
-  auto AppendUnregisterReplicationInstanceLog(std::string_view instance_name) -> bool;
-  auto AppendSetInstanceAsMainLog(std::string_view instance_name) -> bool;
-  auto AppendSetInstanceAsReplicaLog(std::string_view instance_name) -> bool;
-  auto AppendUpdateUUIDLog(utils::UUID const &uuid) -> bool;
-
-  auto GetInstances() const -> std::vector<InstanceState>;
-  auto GetUUID() const -> utils::UUID;
-
- private:
-  // TODO: (andi) I think variables below can be abstracted/clean them.
+  // TODO: (andi) I think variables below can be abstracted
   uint32_t raft_server_id_;
   uint32_t raft_port_;
   std::string raft_address_;
 
-  ptr<CoordinatorStateMachine> state_machine_;
-  ptr<CoordinatorStateManager> state_manager_;
+  ptr<state_machine> state_machine_;
+  ptr<state_mgr> state_manager_;
   ptr<raft_server> raft_server_;
   ptr<logger> logger_;
   raft_launcher launcher_;

src/coordination/include/coordination/register_main_replica_coordinator_status.hpp

@@ -19,12 +19,12 @@ namespace memgraph::coordination {
 
 enum class RegisterInstanceCoordinatorStatus : uint8_t {
   NAME_EXISTS,
-  COORD_ENDPOINT_EXISTS,
-  REPL_ENDPOINT_EXISTS,
+  ENDPOINT_EXISTS,
   NOT_COORDINATOR,
-  NOT_LEADER,
   RPC_FAILED,
-  RAFT_LOG_ERROR,
+  NOT_LEADER,
+  RAFT_COULD_NOT_ACCEPT,
+  RAFT_COULD_NOT_APPEND,
   SUCCESS
 };
 
@@ -32,9 +32,8 @@ enum class UnregisterInstanceCoordinatorStatus : uint8_t {
   NO_INSTANCE_WITH_NAME,
   IS_MAIN,
   NOT_COORDINATOR,
-  RPC_FAILED,
   NOT_LEADER,
-  RAFT_LOG_ERROR,
+  RPC_FAILED,
   SUCCESS,
 };
 
@@ -42,11 +41,9 @@ enum class SetInstanceToMainCoordinatorStatus : uint8_t {
   NO_INSTANCE_WITH_NAME,
   MAIN_ALREADY_EXISTS,
   NOT_COORDINATOR,
-  NOT_LEADER,
-  RAFT_LOG_ERROR,
-  COULD_NOT_PROMOTE_TO_MAIN,
-  SWAP_UUID_FAILED,
   SUCCESS,
+  COULD_NOT_PROMOTE_TO_MAIN,
+  SWAP_UUID_FAILED
 };
 
 }  // namespace memgraph::coordination

src/coordination/include/coordination/replication_instance.hpp

@@ -17,12 +17,11 @@
 #include "coordination/coordinator_exceptions.hpp"
 #include "replication_coordination_glue/role.hpp"
 
+#include <libnuraft/nuraft.hxx>
 #include "utils/resource_lock.hpp"
 #include "utils/result.hpp"
 #include "utils/uuid.hpp"
 
-#include <libnuraft/nuraft.hxx>
-
 namespace memgraph::coordination {
 
 class CoordinatorInstance;
@@ -51,14 +50,13 @@ class ReplicationInstance {
   auto IsAlive() const -> bool;
 
   auto InstanceName() const -> std::string;
-  auto CoordinatorSocketAddress() const -> std::string;
-  auto ReplicationSocketAddress() const -> std::string;
+  auto SocketAddress() const -> std::string;
 
-  auto PromoteToMain(utils::UUID const &uuid, ReplicationClientsInfo repl_clients_info,
+  auto IsReplica() const -> bool;
+  auto IsMain() const -> bool;
+
+  auto PromoteToMain(utils::UUID uuid, ReplicationClientsInfo repl_clients_info,
                      HealthCheckInstanceCallback main_succ_cb, HealthCheckInstanceCallback main_fail_cb) -> bool;
-
-  auto SendDemoteToReplicaRpc() -> bool;
-
   auto DemoteToReplica(HealthCheckInstanceCallback replica_succ_cb, HealthCheckInstanceCallback replica_fail_cb)
       -> bool;
 
@@ -71,8 +69,8 @@ class ReplicationInstance {
 
   auto EnsureReplicaHasCorrectMainUUID(utils::UUID const &curr_main_uuid) -> bool;
 
-  auto SendSwapAndUpdateUUID(utils::UUID const &new_main_uuid) -> bool;
-  auto SendUnregisterReplicaRpc(std::string_view instance_name) -> bool;
+  auto SendSwapAndUpdateUUID(const utils::UUID &new_main_uuid) -> bool;
+  auto SendUnregisterReplicaRpc(std::string const &instance_name) -> bool;
 
   auto SendGetInstanceUUID() -> utils::BasicResult<coordination::GetInstanceUUIDError, std::optional<utils::UUID>>;
   auto GetClient() -> CoordinatorClient &;
@@ -80,14 +78,14 @@ class ReplicationInstance {
   auto EnableWritingOnMain() -> bool;
 
   auto SetNewMainUUID(utils::UUID const &main_uuid) -> void;
-  auto ResetMainUUID() -> void;
-  auto GetMainUUID() const -> std::optional<utils::UUID> const &;
+  auto GetMainUUID() const -> const std::optional<utils::UUID> &;
 
   auto GetSuccessCallback() -> HealthCheckInstanceCallback &;
   auto GetFailCallback() -> HealthCheckInstanceCallback &;
 
  private:
   CoordinatorClient client_;
+  replication_coordination_glue::ReplicationRole replication_role_;
   std::chrono::system_clock::time_point last_response_time_{};
   bool is_alive_{false};
   std::chrono::system_clock::time_point last_check_of_uuid_{};
@@ -103,8 +101,7 @@ class ReplicationInstance {
   HealthCheckInstanceCallback fail_cb_;
 
   friend bool operator==(ReplicationInstance const &first, ReplicationInstance const &second) {
-    return first.client_ == second.client_ && first.last_response_time_ == second.last_response_time_ &&
-           first.is_alive_ == second.is_alive_ && first.main_uuid_ == second.main_uuid_;
+    return first.client_ == second.client_ && first.replication_role_ == second.replication_role_;
   }
 };
 

src/coordination/include/nuraft/coordinator_cluster_state.hpp

@@ -1,82 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include "coordination/coordinator_config.hpp"
-#include "nuraft/raft_log_action.hpp"
-#include "replication_coordination_glue/role.hpp"
-#include "utils/resource_lock.hpp"
-#include "utils/uuid.hpp"
-
-#include <libnuraft/nuraft.hxx>
-#include <range/v3/view.hpp>
-
-#include <map>
-#include <numeric>
-#include <string>
-#include <variant>
-
-namespace memgraph::coordination {
-
-using replication_coordination_glue::ReplicationRole;
-
-struct InstanceState {
-  CoordinatorClientConfig config;
-  ReplicationRole role;
-};
-
-using TRaftLog = std::variant<CoordinatorClientConfig, std::string, utils::UUID>;
-
-using nuraft::buffer;
-using nuraft::buffer_serializer;
-using nuraft::ptr;
-
-class CoordinatorClusterState {
- public:
-  CoordinatorClusterState() = default;
-  CoordinatorClusterState(CoordinatorClusterState const &);
-  CoordinatorClusterState &operator=(CoordinatorClusterState const &);
-
-  CoordinatorClusterState(CoordinatorClusterState &&other) noexcept;
-  CoordinatorClusterState &operator=(CoordinatorClusterState &&other) noexcept;
-  ~CoordinatorClusterState() = default;
-
-  auto FindCurrentMainInstanceName() const -> std::optional<std::string>;
-
-  auto MainExists() const -> bool;
-
-  auto IsMain(std::string_view instance_name) const -> bool;
-
-  auto IsReplica(std::string_view instance_name) const -> bool;
-
-  auto InsertInstance(std::string_view instance_name, ReplicationRole role) -> void;
-
-  auto DoAction(TRaftLog log_entry, RaftLogAction log_action) -> void;
-
-  auto Serialize(ptr<buffer> &data) -> void;
-
-  static auto Deserialize(buffer &data) -> CoordinatorClusterState;
-
-  auto GetInstances() const -> std::vector<InstanceState>;
-
-  auto GetUUID() const -> utils::UUID;
-
- private:
-  std::map<std::string, InstanceState, std::less<>> instance_roles_;
-  utils::UUID uuid_{};
-  mutable utils::ResourceLock log_lock_{};
-};
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/include/nuraft/coordinator_state_machine.hpp

@@ -13,15 +13,9 @@
 
 #ifdef MG_ENTERPRISE
 
-#include "coordination/coordinator_config.hpp"
-#include "nuraft/coordinator_cluster_state.hpp"
-#include "nuraft/raft_log_action.hpp"
-
 #include <spdlog/spdlog.h>
 #include <libnuraft/nuraft.hxx>
 
-#include <variant>
-
 namespace memgraph::coordination {
 
 using nuraft::async_result;
@@ -42,19 +36,9 @@ class CoordinatorStateMachine : public state_machine {
   CoordinatorStateMachine &operator=(CoordinatorStateMachine &&) = delete;
   ~CoordinatorStateMachine() override {}
 
-  auto FindCurrentMainInstanceName() const -> std::optional<std::string>;
-  auto MainExists() const -> bool;
-  auto IsMain(std::string_view instance_name) const -> bool;
-  auto IsReplica(std::string_view instance_name) const -> bool;
+  static auto EncodeRegisterReplicationInstance(const std::string &name) -> ptr<buffer>;
 
-  static auto CreateLog(std::string_view log) -> ptr<buffer>;
-  static auto SerializeRegisterInstance(CoordinatorClientConfig const &config) -> ptr<buffer>;
-  static auto SerializeUnregisterInstance(std::string_view instance_name) -> ptr<buffer>;
-  static auto SerializeSetInstanceAsMain(std::string_view instance_name) -> ptr<buffer>;
-  static auto SerializeSetInstanceAsReplica(std::string_view instance_name) -> ptr<buffer>;
-  static auto SerializeUpdateUUID(utils::UUID const &uuid) -> ptr<buffer>;
-
-  static auto DecodeLog(buffer &data) -> std::pair<TRaftLog, RaftLogAction>;
+  static auto DecodeRegisterReplicationInstance(buffer &data) -> std::string;
 
   auto pre_commit(ulong log_idx, buffer &data) -> ptr<buffer> override;
 
@@ -80,31 +64,11 @@ class CoordinatorStateMachine : public state_machine {
 
   auto create_snapshot(snapshot &s, async_result<bool>::handler_type &when_done) -> void override;
 
-  auto GetInstances() const -> std::vector<InstanceState>;
-  auto GetUUID() const -> utils::UUID;
-
  private:
-  struct SnapshotCtx {
-    SnapshotCtx(ptr<snapshot> &snapshot, CoordinatorClusterState const &cluster_state)
-        : snapshot_(snapshot), cluster_state_(cluster_state) {}
-
-    ptr<snapshot> snapshot_;
-    CoordinatorClusterState cluster_state_;
-  };
-
-  auto create_snapshot_internal(ptr<snapshot> snapshot) -> void;
-
-  CoordinatorClusterState cluster_state_;
-
-  // mutable utils::RWLock lock{utils::RWLock::Priority::READ};
-
   std::atomic<uint64_t> last_committed_idx_{0};
 
-  // TODO: (andi) Maybe not needed, remove it
-  std::map<uint64_t, ptr<SnapshotCtx>> snapshots_;
-  std::mutex snapshots_lock_;
-
   ptr<snapshot> last_snapshot_;
+
   std::mutex last_snapshot_lock_;
 };
 

src/coordination/include/nuraft/raft_log_action.hpp

@@ -1,53 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include "coordination/coordinator_exceptions.hpp"
-
-#include <cstdint>
-#include <string>
-
-namespace memgraph::coordination {
-
-enum class RaftLogAction : uint8_t {
-  REGISTER_REPLICATION_INSTANCE,
-  UNREGISTER_REPLICATION_INSTANCE,
-  SET_INSTANCE_AS_MAIN,
-  SET_INSTANCE_AS_REPLICA,
-  UPDATE_UUID
-};
-
-inline auto ParseRaftLogAction(std::string_view action) -> RaftLogAction {
-  if (action == "register") {
-    return RaftLogAction::REGISTER_REPLICATION_INSTANCE;
-  }
-  if (action == "unregister") {
-    return RaftLogAction::UNREGISTER_REPLICATION_INSTANCE;
-  }
-  if (action == "promote") {
-    return RaftLogAction::SET_INSTANCE_AS_MAIN;
-  }
-  if (action == "demote") {
-    return RaftLogAction::SET_INSTANCE_AS_REPLICA;
-  }
-
-  if (action == "update_uuid") {
-    return RaftLogAction::UPDATE_UUID;
-  }
-
-  throw InvalidRaftLogActionException("Invalid Raft log action: {}.", action);
-}
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/raft_state.cpp

@@ -13,8 +13,9 @@
 
 #include "coordination/raft_state.hpp"
 
-#include "coordination/coordinator_config.hpp"
 #include "coordination/coordinator_exceptions.hpp"
+#include "nuraft/coordinator_state_machine.hpp"
+#include "nuraft/coordinator_state_manager.hpp"
 #include "utils/counter.hpp"
 
 namespace memgraph::coordination {
@@ -59,8 +60,6 @@ auto RaftState::InitRaftServer() -> void {
 
   raft_server::init_options init_opts;
   init_opts.raft_callback_ = [this](cb_func::Type event_type, cb_func::Param *param) -> nuraft::CbReturnCode {
-    spdlog::info("Received some message, my id {}, leader id {}, event_type {}, thread_id {}", param->myId,
-                 param->leaderId, event_type, std::this_thread::get_id());
     if (event_type == cb_func::BecomeLeader) {
       spdlog::info("Node {} became leader", param->leaderId);
       become_leader_cb_();
@@ -91,13 +90,18 @@ auto RaftState::InitRaftServer() -> void {
   throw RaftServerStartException("Failed to initialize raft server on {}:{}", raft_address_, raft_port_);
 }
 
-auto RaftState::MakeRaftState(BecomeLeaderCb &&become_leader_cb, BecomeFollowerCb &&become_follower_cb) -> RaftState {
-  uint32_t raft_server_id = FLAGS_raft_server_id;
-  uint32_t raft_port = FLAGS_raft_server_port;
+auto RaftState::MakeRaftState(BecomeLeaderCb become_leader_cb, BecomeFollowerCb become_follower_cb) -> RaftState {
+  uint32_t raft_server_id{0};
+  uint32_t raft_port{0};
+  try {
+    raft_server_id = FLAGS_raft_server_id;
+    raft_port = FLAGS_raft_server_port;
+  } catch (std::exception const &e) {
+    throw RaftCouldNotParseFlagsException("Failed to parse flags: {}", e.what());
+  }
 
   auto raft_state =
       RaftState(std::move(become_leader_cb), std::move(become_follower_cb), raft_server_id, raft_port, "127.0.0.1");
-
   raft_state.InitRaftServer();
   return raft_state;
 }
@@ -108,9 +112,8 @@ auto RaftState::InstanceName() const -> std::string { return "coordinator_" + st
 
 auto RaftState::RaftSocketAddress() const -> std::string { return raft_address_ + ":" + std::to_string(raft_port_); }
 
-auto RaftState::AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string_view raft_address)
-    -> void {
-  auto const endpoint = fmt::format("{}:{}", raft_address, raft_port);
+auto RaftState::AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address) -> void {
+  auto const endpoint = raft_address + ":" + std::to_string(raft_port);
   srv_config const srv_config_to_add(static_cast<int>(raft_server_id), endpoint);
   if (!raft_server_->add_srv(srv_config_to_add)->get_accepted()) {
     throw RaftAddServerException("Failed to add server {} to the cluster", endpoint);
@@ -128,123 +131,10 @@ auto RaftState::IsLeader() const -> bool { return raft_server_->is_leader(); }
 
 auto RaftState::RequestLeadership() -> bool { return raft_server_->is_leader() || raft_server_->request_leadership(); }
 
-auto RaftState::AppendRegisterReplicationInstanceLog(CoordinatorClientConfig const &config) -> bool {
-  auto new_log = CoordinatorStateMachine::SerializeRegisterInstance(config);
-  auto const res = raft_server_->append_entries({new_log});
-
-  if (!res->get_accepted()) {
-    spdlog::error(
-        "Failed to accept request for registering instance {}. Most likely the reason is that the instance is not "
-        "the "
-        "leader.",
-        config.instance_name);
-    return false;
-  }
-
-  spdlog::info("Request for registering instance {} accepted", config.instance_name);
-
-  if (res->get_result_code() != nuraft::cmd_result_code::OK) {
-    spdlog::error("Failed to register instance {} with error code {}", config.instance_name, res->get_result_code());
-    return false;
-  }
-
-  return true;
+auto RaftState::AppendRegisterReplicationInstance(std::string const &instance) -> ptr<raft_result> {
+  auto new_log = CoordinatorStateMachine::EncodeRegisterReplicationInstance(instance);
+  return raft_server_->append_entries({new_log});
 }
 
-auto RaftState::AppendUnregisterReplicationInstanceLog(std::string_view instance_name) -> bool {
-  auto new_log = CoordinatorStateMachine::SerializeUnregisterInstance(instance_name);
-  auto const res = raft_server_->append_entries({new_log});
-  if (!res->get_accepted()) {
-    spdlog::error(
-        "Failed to accept request for unregistering instance {}. Most likely the reason is that the instance is not "
-        "the leader.",
-        instance_name);
-    return false;
-  }
-
-  spdlog::info("Request for unregistering instance {} accepted", instance_name);
-
-  if (res->get_result_code() != nuraft::cmd_result_code::OK) {
-    spdlog::error("Failed to unregister instance {} with error code {}", instance_name, res->get_result_code());
-    return false;
-  }
-  return true;
-}
-
-auto RaftState::AppendSetInstanceAsMainLog(std::string_view instance_name) -> bool {
-  auto new_log = CoordinatorStateMachine::SerializeSetInstanceAsMain(instance_name);
-  auto const res = raft_server_->append_entries({new_log});
-  if (!res->get_accepted()) {
-    spdlog::error(
-        "Failed to accept request for promoting instance {}. Most likely the reason is that the instance is not "
-        "the leader.",
-        instance_name);
-    return false;
-  }
-
-  spdlog::info("Request for promoting instance {} accepted", instance_name);
-
-  if (res->get_result_code() != nuraft::cmd_result_code::OK) {
-    spdlog::error("Failed to promote instance {} with error code {}", instance_name, res->get_result_code());
-    return false;
-  }
-  return true;
-}
-
-auto RaftState::AppendSetInstanceAsReplicaLog(std::string_view instance_name) -> bool {
-  auto new_log = CoordinatorStateMachine::SerializeSetInstanceAsReplica(instance_name);
-  auto const res = raft_server_->append_entries({new_log});
-  if (!res->get_accepted()) {
-    spdlog::error(
-        "Failed to accept request for demoting instance {}. Most likely the reason is that the instance is not "
-        "the leader.",
-        instance_name);
-    return false;
-  }
-  spdlog::info("Request for demoting instance {} accepted", instance_name);
-
-  if (res->get_result_code() != nuraft::cmd_result_code::OK) {
-    spdlog::error("Failed to promote instance {} with error code {}", instance_name, res->get_result_code());
-    return false;
-  }
-
-  return true;
-}
-
-auto RaftState::AppendUpdateUUIDLog(utils::UUID const &uuid) -> bool {
-  auto new_log = CoordinatorStateMachine::SerializeUpdateUUID(uuid);
-  auto const res = raft_server_->append_entries({new_log});
-  if (!res->get_accepted()) {
-    spdlog::error(
-        "Failed to accept request for updating UUID. Most likely the reason is that the instance is not "
-        "the leader.");
-    return false;
-  }
-  spdlog::info("Request for updating UUID accepted");
-
-  if (res->get_result_code() != nuraft::cmd_result_code::OK) {
-    spdlog::error("Failed to update UUID with error code {}", res->get_result_code());
-    return false;
-  }
-
-  return true;
-}
-
-auto RaftState::FindCurrentMainInstanceName() const -> std::optional<std::string> {
-  return state_machine_->FindCurrentMainInstanceName();
-}
-
-auto RaftState::MainExists() const -> bool { return state_machine_->MainExists(); }
-
-auto RaftState::IsMain(std::string_view instance_name) const -> bool { return state_machine_->IsMain(instance_name); }
-
-auto RaftState::IsReplica(std::string_view instance_name) const -> bool {
-  return state_machine_->IsReplica(instance_name);
-}
-
-auto RaftState::GetInstances() const -> std::vector<InstanceState> { return state_machine_->GetInstances(); }
-
-auto RaftState::GetUUID() const -> utils::UUID { return state_machine_->GetUUID(); }
-
 }  // namespace memgraph::coordination
 #endif

src/coordination/replication_instance.cpp

@@ -25,8 +25,15 @@ ReplicationInstance::ReplicationInstance(CoordinatorInstance *peer, CoordinatorC
                                          HealthCheckInstanceCallback succ_instance_cb,
                                          HealthCheckInstanceCallback fail_instance_cb)
     : client_(peer, std::move(config), std::move(succ_cb), std::move(fail_cb)),
+      replication_role_(replication_coordination_glue::ReplicationRole::REPLICA),
       succ_cb_(succ_instance_cb),
-      fail_cb_(fail_instance_cb) {}
+      fail_cb_(fail_instance_cb) {
+  if (!client_.DemoteToReplica()) {
+    throw CoordinatorRegisterInstanceException("Failed to demote instance {} to replica", client_.InstanceName());
+  }
+
+  client_.StartFrequentCheck();
+}
 
 auto ReplicationInstance::OnSuccessPing() -> void {
   last_response_time_ = std::chrono::system_clock::now();
@@ -45,17 +52,24 @@ auto ReplicationInstance::IsReadyForUUIDPing() -> bool {
 }
 
 auto ReplicationInstance::InstanceName() const -> std::string { return client_.InstanceName(); }
-auto ReplicationInstance::CoordinatorSocketAddress() const -> std::string { return client_.CoordinatorSocketAddress(); }
-auto ReplicationInstance::ReplicationSocketAddress() const -> std::string { return client_.ReplicationSocketAddress(); }
+auto ReplicationInstance::SocketAddress() const -> std::string { return client_.SocketAddress(); }
 auto ReplicationInstance::IsAlive() const -> bool { return is_alive_; }
 
-auto ReplicationInstance::PromoteToMain(utils::UUID const &new_uuid, ReplicationClientsInfo repl_clients_info,
+auto ReplicationInstance::IsReplica() const -> bool {
+  return replication_role_ == replication_coordination_glue::ReplicationRole::REPLICA;
+}
+auto ReplicationInstance::IsMain() const -> bool {
+  return replication_role_ == replication_coordination_glue::ReplicationRole::MAIN;
+}
+
+auto ReplicationInstance::PromoteToMain(utils::UUID new_uuid, ReplicationClientsInfo repl_clients_info,
                                         HealthCheckInstanceCallback main_succ_cb,
                                         HealthCheckInstanceCallback main_fail_cb) -> bool {
   if (!client_.SendPromoteReplicaToMainRpc(new_uuid, std::move(repl_clients_info))) {
     return false;
   }
 
+  replication_role_ = replication_coordination_glue::ReplicationRole::MAIN;
   main_uuid_ = new_uuid;
   succ_cb_ = main_succ_cb;
   fail_cb_ = main_fail_cb;
@@ -63,14 +77,13 @@ auto ReplicationInstance::PromoteToMain(utils::UUID const &new_uuid, Replication
   return true;
 }
 
-auto ReplicationInstance::SendDemoteToReplicaRpc() -> bool { return client_.DemoteToReplica(); }
-
 auto ReplicationInstance::DemoteToReplica(HealthCheckInstanceCallback replica_succ_cb,
                                           HealthCheckInstanceCallback replica_fail_cb) -> bool {
   if (!client_.DemoteToReplica()) {
     return false;
   }
 
+  replication_role_ = replication_coordination_glue::ReplicationRole::REPLICA;
   succ_cb_ = replica_succ_cb;
   fail_cb_ = replica_fail_cb;
 
@@ -104,7 +117,6 @@ auto ReplicationInstance::EnsureReplicaHasCorrectMainUUID(utils::UUID const &cur
   }
   UpdateReplicaLastResponseUUID();
 
-  // NOLINTNEXTLINE
   if (res.GetValue().has_value() && res.GetValue().value() == curr_main_uuid) {
     return true;
   }
@@ -112,7 +124,7 @@ auto ReplicationInstance::EnsureReplicaHasCorrectMainUUID(utils::UUID const &cur
   return SendSwapAndUpdateUUID(curr_main_uuid);
 }
 
-auto ReplicationInstance::SendSwapAndUpdateUUID(utils::UUID const &new_main_uuid) -> bool {
+auto ReplicationInstance::SendSwapAndUpdateUUID(const utils::UUID &new_main_uuid) -> bool {
   if (!replication_coordination_glue::SendSwapMainUUIDRpc(client_.RpcClient(), new_main_uuid)) {
     return false;
   }
@@ -120,7 +132,7 @@ auto ReplicationInstance::SendSwapAndUpdateUUID(utils::UUID const &new_main_uuid
   return true;
 }
 
-auto ReplicationInstance::SendUnregisterReplicaRpc(std::string_view instance_name) -> bool {
+auto ReplicationInstance::SendUnregisterReplicaRpc(std::string const &instance_name) -> bool {
   return client_.SendUnregisterReplicaRpc(instance_name);
 }
 

src/dbms/coordinator_handler.cpp

@@ -20,28 +20,28 @@ namespace memgraph::dbms {
 CoordinatorHandler::CoordinatorHandler(coordination::CoordinatorState &coordinator_state)
     : coordinator_state_(coordinator_state) {}
 
-auto CoordinatorHandler::RegisterReplicationInstance(coordination::CoordinatorClientConfig const &config)
+auto CoordinatorHandler::RegisterReplicationInstance(memgraph::coordination::CoordinatorClientConfig config)
     -> coordination::RegisterInstanceCoordinatorStatus {
   return coordinator_state_.RegisterReplicationInstance(config);
 }
 
-auto CoordinatorHandler::UnregisterReplicationInstance(std::string_view instance_name)
+auto CoordinatorHandler::UnregisterReplicationInstance(std::string instance_name)
     -> coordination::UnregisterInstanceCoordinatorStatus {
-  return coordinator_state_.UnregisterReplicationInstance(instance_name);
+  return coordinator_state_.UnregisterReplicationInstance(std::move(instance_name));
 }
 
-auto CoordinatorHandler::SetReplicationInstanceToMain(std::string_view instance_name)
+auto CoordinatorHandler::SetReplicationInstanceToMain(std::string instance_name)
     -> coordination::SetInstanceToMainCoordinatorStatus {
-  return coordinator_state_.SetReplicationInstanceToMain(instance_name);
+  return coordinator_state_.SetReplicationInstanceToMain(std::move(instance_name));
 }
 
 auto CoordinatorHandler::ShowInstances() const -> std::vector<coordination::InstanceStatus> {
   return coordinator_state_.ShowInstances();
 }
 
-auto CoordinatorHandler::AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port,
-                                                std::string_view raft_address) -> void {
-  coordinator_state_.AddCoordinatorInstance(raft_server_id, raft_port, raft_address);
+auto CoordinatorHandler::AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address)
+    -> void {
+  coordinator_state_.AddCoordinatorInstance(raft_server_id, raft_port, std::move(raft_address));
 }
 
 }  // namespace memgraph::dbms

src/dbms/coordinator_handler.hpp

@@ -30,17 +30,16 @@ class CoordinatorHandler {
 
   // TODO: (andi) When moving coordinator state on same instances, rename from RegisterReplicationInstance to
   // RegisterInstance
-  auto RegisterReplicationInstance(coordination::CoordinatorClientConfig const &config)
+  auto RegisterReplicationInstance(coordination::CoordinatorClientConfig config)
       -> coordination::RegisterInstanceCoordinatorStatus;
 
-  auto UnregisterReplicationInstance(std::string_view instance_name)
-      -> coordination::UnregisterInstanceCoordinatorStatus;
+  auto UnregisterReplicationInstance(std::string instance_name) -> coordination::UnregisterInstanceCoordinatorStatus;
 
-  auto SetReplicationInstanceToMain(std::string_view instance_name) -> coordination::SetInstanceToMainCoordinatorStatus;
+  auto SetReplicationInstanceToMain(std::string instance_name) -> coordination::SetInstanceToMainCoordinatorStatus;
 
   auto ShowInstances() const -> std::vector<coordination::InstanceStatus>;
 
-  auto AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string_view raft_address) -> void;
+  auto AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address) -> void;
 
  private:
   coordination::CoordinatorState &coordinator_state_;

src/dbms/dbms_handler.cpp

@@ -185,16 +185,6 @@ DbmsHandler::DbmsHandler(storage::Config config, replication::ReplicationState &
   auto directories = std::set{std::string{kDefaultDB}};
 
   // Recover previous databases
-  if (flags::AreExperimentsEnabled(flags::Experiments::SYSTEM_REPLICATION) && !recovery_on_startup) {
-    // This will result in dropping databases on SystemRecoveryHandler
-    // for MT case, and for single DB case we might not even set replication as commit timestamp is checked
-    spdlog::warn(
-        "Data recovery on startup not set, this will result in dropping database in case of multi-tenancy enabled.");
-  }
-
-  // TODO: Problem is if user doesn't set this up "database" name won't be recovered
-  // but if storage-recover-on-startup is true storage will be recovered which is an issue
-  spdlog::info("Data recovery on startup set to {}", recovery_on_startup);
   if (recovery_on_startup) {
     auto it = durability_->begin(std::string(kDBPrefix));
     auto end = durability_->end(std::string(kDBPrefix));
@@ -420,10 +410,9 @@ void DbmsHandler::UpdateDurability(const storage::Config &config, std::optional<
   if (!durability_) return;
   // Save database in a list of active databases
   const auto &key = Durability::GenKey(config.salient.name);
-  if (rel_dir == std::nullopt) {
+  if (rel_dir == std::nullopt)
     rel_dir =
         std::filesystem::relative(config.durability.storage_directory, default_config_.durability.storage_directory);
-  }
   const auto &val = Durability::GenVal(config.salient.uuid, *rel_dir);
   durability_->Put(key, val);
 }

src/dbms/dbms_handler.hpp

@@ -155,8 +155,6 @@ class DbmsHandler {
     spdlog::debug("Trying to create db '{}' on replica which already exists.", config.name);
 
     auto db = Get_(config.name);
-    spdlog::debug("Aligning database with name {} which has UUID {}, where config UUID is {}", config.name,
-                  std::string(db->uuid()), std::string(config.uuid));
     if (db->uuid() == config.uuid) {  // Same db
       return db;
     }
@@ -165,22 +163,18 @@ class DbmsHandler {
 
     // TODO: Fix this hack
     if (config.name == kDefaultDB) {
-      spdlog::debug("Last commit timestamp for DB {} is {}", kDefaultDB,
-                    db->storage()->repl_storage_state_.last_commit_timestamp_);
-      // This seems correct, if database made progress
       if (db->storage()->repl_storage_state_.last_commit_timestamp_ != storage::kTimestampInitialId) {
         spdlog::debug("Default storage is not clean, cannot update UUID...");
         return NewError::GENERIC;  // Update error
       }
-      spdlog::debug("Updated default db's UUID");
+      spdlog::debug("Update default db's UUID");
       // Default db cannot be deleted and remade, have to just update the UUID
       db->storage()->config_.salient.uuid = config.uuid;
       UpdateDurability(db->storage()->config_, ".");
       return db;
     }
 
-    spdlog::debug("Dropping database {} with UUID: {} and recreating with the correct UUID: {}", config.name,
-                  std::string(db->uuid()), std::string(config.uuid));
+    spdlog::debug("Drop database and recreate with the correct UUID");
     // Defer drop
     (void)Delete_(db->name());
     // Second attempt

src/dbms/inmemory/replication_handlers.cpp

@@ -19,6 +19,7 @@
 #include "storage/v2/durability/durability.hpp"
 #include "storage/v2/durability/snapshot.hpp"
 #include "storage/v2/durability/version.hpp"
+#include "storage/v2/fmt.hpp"
 #include "storage/v2/indices/label_index_stats.hpp"
 #include "storage/v2/inmemory/storage.hpp"
 #include "storage/v2/inmemory/unique_constraints.hpp"
@@ -134,7 +135,7 @@ void InMemoryReplicationHandlers::SwapMainUUIDHandler(dbms::DbmsHandler *dbms_ha
 
   replication_coordination_glue::SwapMainUUIDReq req;
   slk::Load(&req, req_reader);
-  spdlog::info("Set replica data UUID  to main uuid {}", std::string(req.uuid));
+  spdlog::info(fmt::format("Set replica data UUID  to main uuid {}", std::string(req.uuid)));
   dbms_handler->ReplicationState().TryPersistRoleReplica(role_replica_data.config, req.uuid);
   role_replica_data.uuid_ = req.uuid;
 

src/io/network/endpoint.cpp

@@ -24,22 +24,22 @@
 
 namespace memgraph::io::network {
 
-Endpoint::IpFamily Endpoint::GetIpFamily(std::string_view address) {
+Endpoint::IpFamily Endpoint::GetIpFamily(const std::string &address) {
   in_addr addr4;
   in6_addr addr6;
-  int ipv4_result = inet_pton(AF_INET, address.data(), &addr4);
-  int ipv6_result = inet_pton(AF_INET6, address.data(), &addr6);
+  int ipv4_result = inet_pton(AF_INET, address.c_str(), &addr4);
+  int ipv6_result = inet_pton(AF_INET6, address.c_str(), &addr6);
   if (ipv4_result == 1) {
     return IpFamily::IP4;
-  }
-  if (ipv6_result == 1) {
+  } else if (ipv6_result == 1) {
     return IpFamily::IP6;
+  } else {
+    return IpFamily::NONE;
   }
-  return IpFamily::NONE;
 }
 
 std::optional<std::pair<std::string, uint16_t>> Endpoint::ParseSocketOrIpAddress(
-    std::string_view address, const std::optional<uint16_t> default_port) {
+    const std::string &address, const std::optional<uint16_t> default_port) {
   /// expected address format:
   ///   - "ip_address:port_number"
   ///   - "ip_address"
@@ -56,7 +56,7 @@ std::optional<std::pair<std::string, uint16_t>> Endpoint::ParseSocketOrIpAddress
       if (GetIpFamily(address) == IpFamily::NONE) {
         return std::nullopt;
       }
-      return std::pair{std::string(address), *default_port};  // TODO: (andi) Optimize throughout the code
+      return std::pair{address, *default_port};
     }
   } else if (parts.size() == 2) {
     ip_address = std::move(parts[0]);
@@ -88,7 +88,7 @@ std::optional<std::pair<std::string, uint16_t>> Endpoint::ParseSocketOrIpAddress
 }
 
 std::optional<std::pair<std::string, uint16_t>> Endpoint::ParseHostname(
-    std::string_view address, const std::optional<uint16_t> default_port = {}) {
+    const std::string &address, const std::optional<uint16_t> default_port = {}) {
   const std::string delimiter = ":";
   std::string ip_address;
   std::vector<std::string> parts = utils::Split(address, delimiter);
@@ -97,7 +97,7 @@ std::optional<std::pair<std::string, uint16_t>> Endpoint::ParseHostname(
       if (!IsResolvableAddress(address, *default_port)) {
         return std::nullopt;
       }
-      return std::pair{std::string(address), *default_port};  // TODO: (andi) Optimize throughout the code
+      return std::pair{address, *default_port};
     }
   } else if (parts.size() == 2) {
     int64_t int_port{0};
@@ -153,20 +153,20 @@ std::ostream &operator<<(std::ostream &os, const Endpoint &endpoint) {
   return os << endpoint.address << ":" << endpoint.port;
 }
 
-bool Endpoint::IsResolvableAddress(std::string_view address, uint16_t port) {
+bool Endpoint::IsResolvableAddress(const std::string &address, uint16_t port) {
   addrinfo hints{
       .ai_flags = AI_PASSIVE,
       .ai_family = AF_UNSPEC,     // IPv4 and IPv6
       .ai_socktype = SOCK_STREAM  // TCP socket
   };
   addrinfo *info = nullptr;
-  auto status = getaddrinfo(address.data(), std::to_string(port).c_str(), &hints, &info);
+  auto status = getaddrinfo(address.c_str(), std::to_string(port).c_str(), &hints, &info);
   if (info) freeaddrinfo(info);
   return status == 0;
 }
 
 std::optional<std::pair<std::string, uint16_t>> Endpoint::ParseSocketOrAddress(
-    std::string_view address, const std::optional<uint16_t> default_port) {
+    const std::string &address, const std::optional<uint16_t> default_port) {
   const std::string delimiter = ":";
   std::vector<std::string> parts = utils::Split(address, delimiter);
   if (parts.size() == 1) {

src/io/network/endpoint.hpp

@@ -48,8 +48,8 @@ struct Endpoint {
   uint16_t port{0};
   IpFamily family{IpFamily::NONE};
 
-  static std::optional<std::pair<std::string, uint16_t>> ParseSocketOrAddress(
-      std::string_view address, std::optional<uint16_t> default_port = {});
+  static std::optional<std::pair<std::string, uint16_t>> ParseSocketOrAddress(const std::string &address,
+                                                                              std::optional<uint16_t> default_port);
 
   /**
    * Tries to parse the given string as either a socket address or ip address.
@@ -62,7 +62,7 @@ struct Endpoint {
    * it won't be used, as we expect that it is given in the address string.
    */
   static std::optional<std::pair<std::string, uint16_t>> ParseSocketOrIpAddress(
-      std::string_view address, std::optional<uint16_t> default_port = {});
+      const std::string &address, std::optional<uint16_t> default_port = {});
 
   /**
    * Tries to parse given string as either socket address or hostname.
@@ -71,12 +71,12 @@ struct Endpoint {
    *    - "hostname"
    * After we parse hostname and port we try to resolve the hostname into an ip_address.
    */
-  static std::optional<std::pair<std::string, uint16_t>> ParseHostname(std::string_view address,
+  static std::optional<std::pair<std::string, uint16_t>> ParseHostname(const std::string &address,
                                                                        std::optional<uint16_t> default_port);
 
-  static IpFamily GetIpFamily(std::string_view address);
+  static IpFamily GetIpFamily(const std::string &address);
 
-  static bool IsResolvableAddress(std::string_view address, uint16_t port);
+  static bool IsResolvableAddress(const std::string &address, uint16_t port);
 
   /**
    * Tries to resolve hostname to its corresponding IP address.

src/memgraph.cpp

@@ -334,8 +334,7 @@ int main(int argc, char **argv) {
       .salient.items = {.properties_on_edges = FLAGS_storage_properties_on_edges,
                         .enable_schema_metadata = FLAGS_storage_enable_schema_metadata},
       .salient.storage_mode = memgraph::flags::ParseStorageMode()};
-  spdlog::info("config recover on startup {}, flags {} {}", db_config.durability.recover_on_startup,
-               FLAGS_storage_recover_on_startup, FLAGS_data_recovery_on_startup);
+
   memgraph::utils::Scheduler jemalloc_purge_scheduler;
   jemalloc_purge_scheduler.Run("Jemalloc purge", std::chrono::seconds(FLAGS_storage_gc_cycle_sec),
                                [] { memgraph::memory::PurgeUnusedMemory(); });

src/query/interpreter.cpp

@@ -410,7 +410,7 @@ class CoordQueryHandler final : public query::CoordinatorQueryHandler {
 
       : coordinator_handler_(coordinator_state) {}
 
-  void UnregisterInstance(std::string_view instance_name) override {
+  void UnregisterInstance(std::string const &instance_name) override {
     auto status = coordinator_handler_.UnregisterReplicationInstance(instance_name);
     switch (status) {
       using enum memgraph::coordination::UnregisterInstanceCoordinatorStatus;
@@ -423,8 +423,6 @@ class CoordQueryHandler final : public query::CoordinatorQueryHandler {
         throw QueryRuntimeException("UNREGISTER INSTANCE query can only be run on a coordinator!");
       case NOT_LEADER:
         throw QueryRuntimeException("Couldn't unregister replica instance since coordinator is not a leader!");
-      case RAFT_LOG_ERROR:
-        throw QueryRuntimeException("Couldn't unregister replica instance since raft server couldn't append the log!");
       case RPC_FAILED:
         throw QueryRuntimeException(
             "Couldn't unregister replica instance because current main instance couldn't unregister replica!");
@@ -433,18 +431,20 @@ class CoordQueryHandler final : public query::CoordinatorQueryHandler {
     }
   }
 
-  void RegisterReplicationInstance(std::string_view coordinator_socket_address,
-                                   std::string_view replication_socket_address,
+  void RegisterReplicationInstance(std::string const &coordinator_socket_address,
+                                   std::string const &replication_socket_address,
                                    std::chrono::seconds const &instance_check_frequency,
                                    std::chrono::seconds const &instance_down_timeout,
                                    std::chrono::seconds const &instance_get_uuid_frequency,
-                                   std::string_view instance_name, CoordinatorQuery::SyncMode sync_mode) override {
-    const auto maybe_replication_ip_port = io::network::Endpoint::ParseSocketOrAddress(replication_socket_address);
+                                   std::string const &instance_name, CoordinatorQuery::SyncMode sync_mode) override {
+    const auto maybe_replication_ip_port =
+        io::network::Endpoint::ParseSocketOrAddress(replication_socket_address, std::nullopt);
     if (!maybe_replication_ip_port) {
       throw QueryRuntimeException("Invalid replication socket address!");
     }
 
-    const auto maybe_coordinator_ip_port = io::network::Endpoint::ParseSocketOrAddress(coordinator_socket_address);
+    const auto maybe_coordinator_ip_port =
+        io::network::Endpoint::ParseSocketOrAddress(coordinator_socket_address, std::nullopt);
     if (!maybe_replication_ip_port) {
       throw QueryRuntimeException("Invalid replication socket address!");
     }
@@ -452,13 +452,13 @@ class CoordQueryHandler final : public query::CoordinatorQueryHandler {
     const auto [replication_ip, replication_port] = *maybe_replication_ip_port;
     const auto [coordinator_server_ip, coordinator_server_port] = *maybe_coordinator_ip_port;
     const auto repl_config = coordination::CoordinatorClientConfig::ReplicationClientInfo{
-        .instance_name = std::string(instance_name),
+        .instance_name = instance_name,
         .replication_mode = convertFromCoordinatorToReplicationMode(sync_mode),
         .replication_ip_address = replication_ip,
         .replication_port = replication_port};
 
     auto coordinator_client_config =
-        coordination::CoordinatorClientConfig{.instance_name = std::string(instance_name),
+        coordination::CoordinatorClientConfig{.instance_name = instance_name,
                                               .ip_address = coordinator_server_ip,
                                               .port = coordinator_server_port,
                                               .instance_health_check_frequency_sec = instance_check_frequency,
@@ -472,17 +472,18 @@ class CoordQueryHandler final : public query::CoordinatorQueryHandler {
       using enum memgraph::coordination::RegisterInstanceCoordinatorStatus;
       case NAME_EXISTS:
         throw QueryRuntimeException("Couldn't register replica instance since instance with such name already exists!");
-      case COORD_ENDPOINT_EXISTS:
+      case ENDPOINT_EXISTS:
         throw QueryRuntimeException(
-            "Couldn't register replica instance since instance with such coordinator endpoint already exists!");
-      case REPL_ENDPOINT_EXISTS:
-        throw QueryRuntimeException(
-            "Couldn't register replica instance since instance with such replication endpoint already exists!");
+            "Couldn't register replica instance since instance with such endpoint already exists!");
       case NOT_COORDINATOR:
         throw QueryRuntimeException("REGISTER INSTANCE query can only be run on a coordinator!");
       case NOT_LEADER:
         throw QueryRuntimeException("Couldn't register replica instance since coordinator is not a leader!");
-      case RAFT_LOG_ERROR:
+      case RAFT_COULD_NOT_ACCEPT:
+        throw QueryRuntimeException(
+            "Couldn't register replica instance since raft server couldn't accept the log! Most likely the raft "
+            "instance is not a leader!");
+      case RAFT_COULD_NOT_APPEND:
         throw QueryRuntimeException("Couldn't register replica instance since raft server couldn't append the log!");
       case RPC_FAILED:
         throw QueryRuntimeException(
@@ -493,8 +494,8 @@ class CoordQueryHandler final : public query::CoordinatorQueryHandler {
     }
   }
 
-  auto AddCoordinatorInstance(uint32_t raft_server_id, std::string_view raft_socket_address) -> void override {
-    auto const maybe_ip_and_port = io::network::Endpoint::ParseSocketOrAddress(raft_socket_address);
+  auto AddCoordinatorInstance(uint32_t raft_server_id, std::string const &raft_socket_address) -> void override {
+    auto const maybe_ip_and_port = io::network::Endpoint::ParseSocketOrIpAddress(raft_socket_address);
     if (maybe_ip_and_port) {
       auto const [ip, port] = *maybe_ip_and_port;
       spdlog::info("Adding instance {} with raft socket address {}:{}.", raft_server_id, port, ip);
@@ -504,8 +505,8 @@ class CoordQueryHandler final : public query::CoordinatorQueryHandler {
     }
   }
 
-  void SetReplicationInstanceToMain(std::string_view instance_name) override {
-    auto const status = coordinator_handler_.SetReplicationInstanceToMain(instance_name);
+  void SetReplicationInstanceToMain(const std::string &instance_name) override {
+    auto status = coordinator_handler_.SetReplicationInstanceToMain(instance_name);
     switch (status) {
       using enum memgraph::coordination::SetInstanceToMainCoordinatorStatus;
       case NO_INSTANCE_WITH_NAME:
@@ -514,10 +515,6 @@ class CoordQueryHandler final : public query::CoordinatorQueryHandler {
         throw QueryRuntimeException("Couldn't set instance to main since there is already a main instance in cluster!");
       case NOT_COORDINATOR:
         throw QueryRuntimeException("SET INSTANCE TO MAIN query can only be run on a coordinator!");
-      case NOT_LEADER:
-        throw QueryRuntimeException("Couldn't set instance to main since coordinator is not a leader!");
-      case RAFT_LOG_ERROR:
-        throw QueryRuntimeException("Couldn't promote instance since raft server couldn't append the log!");
       case COULD_NOT_PROMOTE_TO_MAIN:
         throw QueryRuntimeException(
             "Couldn't set replica instance to main! Check coordinator and replica for more logs");
@@ -1254,13 +1251,14 @@ Callback HandleCoordinatorQuery(CoordinatorQuery *coordinator_query, const Param
         throw QueryRuntimeException("Only coordinator can run SHOW INSTANCES.");
       }
 
-      callback.header = {"name", "raft_socket_address", "coordinator_socket_address", "health", "role"};
+      callback.header = {"name", "raft_socket_address", "coordinator_socket_address", "alive", "role"};
       callback.fn = [handler = CoordQueryHandler{*coordinator_state},
                      replica_nfields = callback.header.size()]() mutable {
         auto const instances = handler.ShowInstances();
         auto const converter = [](const auto &status) -> std::vector<TypedValue> {
           return {TypedValue{status.instance_name}, TypedValue{status.raft_socket_address},
-                  TypedValue{status.coord_socket_address}, TypedValue{status.health}, TypedValue{status.cluster_role}};
+                  TypedValue{status.coord_socket_address}, TypedValue{status.is_alive},
+                  TypedValue{status.cluster_role}};
         };
 
         return utils::fmap(converter, instances);

src/query/interpreter.hpp

@@ -95,24 +95,25 @@ class CoordinatorQueryHandler {
   };
 
   /// @throw QueryRuntimeException if an error ocurred.
-  virtual void RegisterReplicationInstance(std::string_view coordinator_socket_address,
-                                           std::string_view replication_socket_address,
+  virtual void RegisterReplicationInstance(std::string const &coordinator_socket_address,
+                                           std::string const &replication_socket_address,
                                            std::chrono::seconds const &instance_health_check_frequency,
                                            std::chrono::seconds const &instance_down_timeout,
                                            std::chrono::seconds const &instance_get_uuid_frequency,
-                                           std::string_view instance_name, CoordinatorQuery::SyncMode sync_mode) = 0;
+                                           std::string const &instance_name, CoordinatorQuery::SyncMode sync_mode) = 0;
 
   /// @throw QueryRuntimeException if an error ocurred.
-  virtual void UnregisterInstance(std::string_view instance_name) = 0;
+  virtual void UnregisterInstance(std::string const &instance_name) = 0;
 
   /// @throw QueryRuntimeException if an error ocurred.
-  virtual void SetReplicationInstanceToMain(std::string_view instance_name) = 0;
+  virtual void SetReplicationInstanceToMain(const std::string &instance_name) = 0;
 
   /// @throw QueryRuntimeException if an error ocurred.
   virtual std::vector<coordination::InstanceStatus> ShowInstances() const = 0;
 
   /// @throw QueryRuntimeException if an error ocurred.
-  virtual auto AddCoordinatorInstance(uint32_t raft_server_id, std::string_view coordinator_socket_address) -> void = 0;
+  virtual auto AddCoordinatorInstance(uint32_t raft_server_id, std::string const &coordinator_socket_address)
+      -> void = 0;
 };
 #endif
 

src/replication_coordination_glue/mode.hpp

@@ -12,32 +12,7 @@
 #pragma once
 
 #include <cstdint>
-#include <map>
-#include <stdexcept>
-#include <string>
 
 namespace memgraph::replication_coordination_glue {
-
 enum class ReplicationMode : std::uint8_t { SYNC, ASYNC };
-
-inline auto ReplicationModeToString(ReplicationMode mode) -> std::string {
-  switch (mode) {
-    case ReplicationMode::SYNC:
-      return "SYNC";
-    case ReplicationMode::ASYNC:
-      return "ASYNC";
-  }
-  throw std::invalid_argument("Invalid replication mode");
-}
-
-inline auto ReplicationModeFromString(std::string_view mode) -> ReplicationMode {
-  if (mode == "SYNC") {
-    return ReplicationMode::SYNC;
-  }
-  if (mode == "ASYNC") {
-    return ReplicationMode::ASYNC;
-  }
-  throw std::invalid_argument("Invalid replication mode");
-}
-
 }  // namespace memgraph::replication_coordination_glue

src/replication_handler/replication_handler.cpp

@@ -271,8 +271,9 @@ auto ReplicationHandler::GetDatabasesHistories() -> replication_coordination_glu
   dbms_handler_.ForEach([&results](memgraph::dbms::DatabaseAccess db_acc) {
     auto &repl_storage_state = db_acc->storage()->repl_storage_state_;
 
-    std::vector<std::pair<std::string, uint64_t>> history = utils::fmap(
-        [](const auto &elem) { return std::make_pair(elem.first, elem.second); }, repl_storage_state.history);
+    std::vector<std::pair<std::string, uint64_t>> history =
+        utils::fmap([](const auto &elem) { return std::pair<std::string, uint64_t>(elem.first, elem.second); },
+                    repl_storage_state.history);
 
     history.emplace_back(std::string(repl_storage_state.epoch_.id()), repl_storage_state.last_commit_timestamp_.load());
     replication_coordination_glue::DatabaseHistory repl{

src/storage/v2/durability/durability.cpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -118,8 +118,6 @@ std::optional<std::vector<WalDurabilityInfo>> GetWalFiles(const std::filesystem:
     if (!item.is_regular_file()) continue;
     try {
       auto info = ReadWalInfo(item.path());
-      spdlog::trace("Getting wal file with following info: uuid: {}, epoch id: {}, from timestamp {}, to_timestamp {} ",
-                    info.uuid, info.epoch_id, info.from_timestamp, info.to_timestamp);
       if ((uuid.empty() || info.uuid == uuid) && (!current_seq_num || info.seq_num < *current_seq_num)) {
         wal_files.emplace_back(info.seq_num, info.from_timestamp, info.to_timestamp, std::move(info.uuid),
                                std::move(info.epoch_id), item.path());
@@ -358,7 +356,6 @@ std::optional<RecoveryInfo> Recovery::RecoverData(std::string *uuid, Replication
       spdlog::warn(utils::MessageWithLink("No snapshot or WAL file found.", "https://memgr.ph/durability"));
       return std::nullopt;
     }
-    // TODO(antoniofilipovic) What is the logic here?
     std::sort(wal_files.begin(), wal_files.end());
     // UUID used for durability is the UUID of the last WAL file.
     // Same for the epoch id.
@@ -413,17 +410,22 @@ std::optional<RecoveryInfo> Recovery::RecoverData(std::string *uuid, Replication
     std::optional<uint64_t> previous_seq_num;
     auto last_loaded_timestamp = snapshot_timestamp;
     spdlog::info("Trying to load WAL files.");
-
-    if (last_loaded_timestamp) {
-      epoch_history->emplace_back(repl_storage_state.epoch_.id(), *last_loaded_timestamp);
-    }
-
     for (auto &wal_file : wal_files) {
       if (previous_seq_num && (wal_file.seq_num - *previous_seq_num) > 1) {
         LOG_FATAL("You are missing a WAL file with the sequence number {}!", *previous_seq_num + 1);
       }
       previous_seq_num = wal_file.seq_num;
 
+      if (wal_file.epoch_id != repl_storage_state.epoch_.id()) {
+        // This way we skip WALs finalized only because of role change.
+        // We can also set the last timestamp to 0 if last loaded timestamp
+        // is nullopt as this can only happen if the WAL file with seq = 0
+        // does not contain any deltas and we didn't find any snapshots.
+        if (last_loaded_timestamp) {
+          epoch_history->emplace_back(wal_file.epoch_id, *last_loaded_timestamp);
+        }
+        repl_storage_state.epoch_.SetEpoch(std::move(wal_file.epoch_id));
+      }
       try {
         auto info = LoadWal(wal_file.path, &indices_constraints, last_loaded_timestamp, vertices, edges, name_id_mapper,
                             edge_count, config.salient.items);
@@ -432,28 +434,13 @@ std::optional<RecoveryInfo> Recovery::RecoverData(std::string *uuid, Replication
         recovery_info.next_timestamp = std::max(recovery_info.next_timestamp, info.next_timestamp);
 
         recovery_info.last_commit_timestamp = info.last_commit_timestamp;
-
-        if (recovery_info.next_timestamp != 0) {
-          last_loaded_timestamp.emplace(recovery_info.next_timestamp - 1);
-        }
-
-        bool epoch_history_empty = epoch_history->empty();
-        bool epoch_not_recorded = !epoch_history_empty && epoch_history->back().first != wal_file.epoch_id;
-        auto last_loaded_timestamp_value = last_loaded_timestamp.value_or(0);
-
-        if (epoch_history_empty || epoch_not_recorded) {
-          epoch_history->emplace_back(std::string(wal_file.epoch_id), last_loaded_timestamp_value);
-        }
-
-        auto last_epoch_updated = !epoch_history_empty && epoch_history->back().first == wal_file.epoch_id &&
-                                  epoch_history->back().second < last_loaded_timestamp_value;
-        if (last_epoch_updated) {
-          epoch_history->back().second = last_loaded_timestamp_value;
-        }
-
       } catch (const RecoveryFailure &e) {
         LOG_FATAL("Couldn't recover WAL deltas from {} because of: {}", wal_file.path, e.what());
       }
+
+      if (recovery_info.next_timestamp != 0) {
+        last_loaded_timestamp.emplace(recovery_info.next_timestamp - 1);
+      }
     }
     // The sequence number needs to be recovered even though `LoadWal` didn't
     // load any deltas from that file.
@@ -469,12 +456,7 @@ std::optional<RecoveryInfo> Recovery::RecoverData(std::string *uuid, Replication
 
   memgraph::metrics::Measure(memgraph::metrics::SnapshotRecoveryLatency_us,
                              std::chrono::duration_cast<std::chrono::microseconds>(timer.Elapsed()).count());
-  spdlog::info("Set epoch id: {}  with commit timestamp {}", std::string(repl_storage_state.epoch_.id()),
-               repl_storage_state.last_commit_timestamp_);
 
-  std::for_each(repl_storage_state.history.begin(), repl_storage_state.history.end(), [](auto &history) {
-    spdlog::info("epoch id: {}  with commit timestamp {}", std::string(history.first), history.second);
-  });
   return recovery_info;
 }
 

src/storage/v2/inmemory/replication/recovery.cpp

@@ -233,7 +233,7 @@ std::vector<RecoveryStep> GetRecoverySteps(uint64_t replica_commit, utils::FileR
     }
   }
 
-  // In all cases, if we have a current wal file we need to use it
+  // In all cases, if we have a current wal file we need to use itW
   if (current_wal_seq_num) {
     // NOTE: File not handled directly, so no need to lock it
     recovery_steps.emplace_back(RecoveryCurrentWal{*current_wal_seq_num});

src/storage/v2/inmemory/storage.cpp

@@ -109,7 +109,6 @@ InMemoryStorage::InMemoryStorage(Config config)
       timestamp_ = std::max(timestamp_, info->next_timestamp);
       if (info->last_commit_timestamp) {
         repl_storage_state_.last_commit_timestamp_ = *info->last_commit_timestamp;
-        spdlog::info("Recovering last commit timestamp {}", *info->last_commit_timestamp);
       }
     }
   } else if (config_.durability.snapshot_wal_mode != Config::Durability::SnapshotWalMode::DISABLED ||

src/storage/v2/replication/replication_client.cpp

@@ -54,24 +54,15 @@ void ReplicationStorageClient::UpdateReplicaState(Storage *storage, DatabaseAcce
 
   std::optional<uint64_t> branching_point;
   // different epoch id, replica was main
-  // In case there is no epoch transfer, and MAIN doesn't hold all the epochs as it could have been down and miss it
-  // we need then just to check commit timestamp
   if (replica.epoch_id != replStorageState.epoch_.id() && replica.current_commit_timestamp != kTimestampInitialId) {
-    spdlog::trace(
-        "REPLICA: epoch UUID: {} and last_commit_timestamp: {}; MAIN: epoch UUID {} and last_commit_timestamp {}",
-        std::string(replica.epoch_id), replica.current_commit_timestamp, std::string(replStorageState.epoch_.id()),
-        replStorageState.last_commit_timestamp_);
     auto const &history = replStorageState.history;
     const auto epoch_info_iter = std::find_if(history.crbegin(), history.crend(), [&](const auto &main_epoch_info) {
       return main_epoch_info.first == replica.epoch_id;
     });
     // main didn't have that epoch, but why is here branching point
     if (epoch_info_iter == history.crend()) {
-      spdlog::info("Couldn't find epoch {} in MAIN, setting branching point", std::string(replica.epoch_id));
       branching_point = 0;
-    } else if (epoch_info_iter->second < replica.current_commit_timestamp) {
-      spdlog::info("Found epoch {} on MAIN with last_commit_timestamp {}, REPLICA's last_commit_timestamp {}",
-                   std::string(epoch_info_iter->first), epoch_info_iter->second, replica.current_commit_timestamp);
+    } else if (epoch_info_iter->second != replica.current_commit_timestamp) {
       branching_point = epoch_info_iter->second;
     }
   }
@@ -201,6 +192,9 @@ void ReplicationStorageClient::StartTransactionReplication(const uint64_t curren
   }
 }
 
+//////// AF: you can't finialize transaction replication if you are not replicating
+/////// AF: if there is no stream or it is Defunct than we need to set replica in MAYBE_BEHIND -> is that even used
+/////// AF:
 bool ReplicationStorageClient::FinalizeTransactionReplication(Storage *storage, DatabaseAccessProtector db_acc) {
   // We can only check the state because it guarantees to be only
   // valid during a single transaction replication (if the assumption

src/utils/CMakeLists.txt

@@ -25,8 +25,12 @@ find_package(Threads REQUIRED)
 add_library(mg-utils STATIC ${utils_src_files})
 add_library(mg::utils ALIAS mg-utils)
 
+find_path(LIBUUID_INCLUDE_DIR uuid.h PATH_SUFFIXES uuid)
+find_library(LIBUUID_LIBRARY libuuid.a)
+include_directories(${LIBUUID_INCLUDE_DIR})
+target_link_libraries(testuuid PUBLIC ${LIBUUID_LIBRARY})
 target_link_libraries(mg-utils PUBLIC Boost::headers fmt::fmt spdlog::spdlog json)
-target_link_libraries(mg-utils PRIVATE librdtsc stdc++fs Threads::Threads gflags uuid rt)
+target_link_libraries(mg-utils PRIVATE librdtsc stdc++fs Threads::Threads gflags ${LIBUUID_LIBRARY} rt)
 
 set(settings_src_files
     settings.cpp)

src/utils/string.hpp

@@ -229,13 +229,6 @@ inline std::vector<std::string> Split(const std::string_view src, const std::str
   return res;
 }
 
-inline std::vector<std::string_view> SplitView(const std::string_view src, const std::string_view delimiter,
-                                               int splits = -1) {
-  std::vector<std::string_view> res;
-  Split(&res, src, delimiter, splits);
-  return res;
-}
-
 /**
  * Split a string by whitespace into a vector.
  * Runs of consecutive whitespace are regarded as a single delimiter.

src/utils/uuid.cpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -10,7 +10,7 @@
 // licenses/APL.txt.
 
 #include "utils/uuid.hpp"
-
+#include <uuid/uuid.h>
 #include "slk/serialization.hpp"
 
 namespace memgraph::utils {

src/utils/uuid.hpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -12,7 +12,6 @@
 #pragma once
 
 #include <uuid/uuid.h>
-
 #include <array>
 #include <json/json.hpp>
 #include <string>
@@ -40,10 +39,9 @@ struct UUID {
 
   UUID() { uuid_generate(uuid.data()); }
   explicit operator std::string() const {
-    // Note not using UUID_STR_LEN so we can build with older libuuid
-    auto decoded = std::array<char, 37 /*UUID_STR_LEN*/>{};
+    auto decoded = std::array<char, UUID_STR_LEN>{};
     uuid_unparse(uuid.data(), decoded.data());
-    return std::string{decoded.data(), 37 /*UUID_STR_LEN*/ - 1};
+    return std::string{decoded.data(), UUID_STR_LEN - 1};
   }
 
   explicit operator arr_t() const { return uuid; }

tests/e2e/high_availability/coord_cluster_registration.py

@@ -133,12 +133,12 @@ def test_register_repl_instances_then_coordinators():
         return sorted(list(execute_and_fetch_all(coordinator3_cursor, "SHOW INSTANCES")))
 
     expected_cluster_coord3 = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_1", "", "127.0.0.1:10011", "up", "replica"),
-        ("instance_2", "", "127.0.0.1:10012", "up", "replica"),
-        ("instance_3", "", "127.0.0.1:10013", "up", "main"),
+        ("coordinator_1", "127.0.0.1:10111", "", True, "coordinator"),
+        ("coordinator_2", "127.0.0.1:10112", "", True, "coordinator"),
+        ("coordinator_3", "127.0.0.1:10113", "", True, "coordinator"),
+        ("instance_1", "", "127.0.0.1:10011", True, "replica"),
+        ("instance_2", "", "127.0.0.1:10012", True, "replica"),
+        ("instance_3", "", "127.0.0.1:10013", True, "main"),
     ]
     mg_sleep_and_assert(expected_cluster_coord3, check_coordinator3)
 
@@ -147,23 +147,21 @@ def test_register_repl_instances_then_coordinators():
     def check_coordinator1():
         return sorted(list(execute_and_fetch_all(coordinator1_cursor, "SHOW INSTANCES")))
 
-    expected_cluster_shared = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_1", "", "", "unknown", "replica"),
-        ("instance_2", "", "", "unknown", "replica"),
-        ("instance_3", "", "", "unknown", "main"),
+    # TODO: (andi) This should be solved eventually
+    expected_cluster_not_shared = [
+        ("coordinator_1", "127.0.0.1:10111", "", True, "coordinator"),
+        ("coordinator_2", "127.0.0.1:10112", "", True, "coordinator"),
+        ("coordinator_3", "127.0.0.1:10113", "", True, "coordinator"),
     ]
 
-    mg_sleep_and_assert(expected_cluster_shared, check_coordinator1)
+    mg_sleep_and_assert(expected_cluster_not_shared, check_coordinator1)
 
     coordinator2_cursor = connect(host="localhost", port=7691).cursor()
 
     def check_coordinator2():
         return sorted(list(execute_and_fetch_all(coordinator2_cursor, "SHOW INSTANCES")))
 
-    mg_sleep_and_assert(expected_cluster_shared, check_coordinator2)
+    mg_sleep_and_assert(expected_cluster_not_shared, check_coordinator2)
 
 
 def test_register_coordinator_then_repl_instances():
@@ -189,12 +187,12 @@ def test_register_coordinator_then_repl_instances():
         return sorted(list(execute_and_fetch_all(coordinator3_cursor, "SHOW INSTANCES")))
 
     expected_cluster_coord3 = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_1", "", "127.0.0.1:10011", "up", "replica"),
-        ("instance_2", "", "127.0.0.1:10012", "up", "replica"),
-        ("instance_3", "", "127.0.0.1:10013", "up", "main"),
+        ("coordinator_1", "127.0.0.1:10111", "", True, "coordinator"),
+        ("coordinator_2", "127.0.0.1:10112", "", True, "coordinator"),
+        ("coordinator_3", "127.0.0.1:10113", "", True, "coordinator"),
+        ("instance_1", "", "127.0.0.1:10011", True, "replica"),
+        ("instance_2", "", "127.0.0.1:10012", True, "replica"),
+        ("instance_3", "", "127.0.0.1:10013", True, "main"),
     ]
     mg_sleep_and_assert(expected_cluster_coord3, check_coordinator3)
 
@@ -203,23 +201,21 @@ def test_register_coordinator_then_repl_instances():
     def check_coordinator1():
         return sorted(list(execute_and_fetch_all(coordinator1_cursor, "SHOW INSTANCES")))
 
-    expected_cluster_shared = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_1", "", "", "unknown", "replica"),
-        ("instance_2", "", "", "unknown", "replica"),
-        ("instance_3", "", "", "unknown", "main"),
+    # TODO: (andi) This should be solved eventually
+    expected_cluster_not_shared = [
+        ("coordinator_1", "127.0.0.1:10111", "", True, "coordinator"),
+        ("coordinator_2", "127.0.0.1:10112", "", True, "coordinator"),
+        ("coordinator_3", "127.0.0.1:10113", "", True, "coordinator"),
     ]
 
-    mg_sleep_and_assert(expected_cluster_shared, check_coordinator1)
+    mg_sleep_and_assert(expected_cluster_not_shared, check_coordinator1)
 
     coordinator2_cursor = connect(host="localhost", port=7691).cursor()
 
     def check_coordinator2():
         return sorted(list(execute_and_fetch_all(coordinator2_cursor, "SHOW INSTANCES")))
 
-    mg_sleep_and_assert(expected_cluster_shared, check_coordinator2)
+    mg_sleep_and_assert(expected_cluster_not_shared, check_coordinator2)
 
 
 def test_coordinators_communication_with_restarts():
@@ -241,13 +237,10 @@ def test_coordinators_communication_with_restarts():
     )
     execute_and_fetch_all(coordinator3_cursor, "SET INSTANCE instance_3 TO MAIN")
 
-    expected_cluster_shared = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_1", "", "", "unknown", "replica"),
-        ("instance_2", "", "", "unknown", "replica"),
-        ("instance_3", "", "", "unknown", "main"),
+    expected_cluster_not_shared = [
+        ("coordinator_1", "127.0.0.1:10111", "", True, "coordinator"),
+        ("coordinator_2", "127.0.0.1:10112", "", True, "coordinator"),
+        ("coordinator_3", "127.0.0.1:10113", "", True, "coordinator"),
     ]
 
     coordinator1_cursor = connect(host="localhost", port=7690).cursor()
@@ -255,20 +248,20 @@ def test_coordinators_communication_with_restarts():
     def check_coordinator1():
         return sorted(list(execute_and_fetch_all(coordinator1_cursor, "SHOW INSTANCES")))
 
-    mg_sleep_and_assert(expected_cluster_shared, check_coordinator1)
+    mg_sleep_and_assert(expected_cluster_not_shared, check_coordinator1)
 
     coordinator2_cursor = connect(host="localhost", port=7691).cursor()
 
     def check_coordinator2():
         return sorted(list(execute_and_fetch_all(coordinator2_cursor, "SHOW INSTANCES")))
 
-    mg_sleep_and_assert(expected_cluster_shared, check_coordinator2)
+    mg_sleep_and_assert(expected_cluster_not_shared, check_coordinator2)
 
     interactive_mg_runner.kill(MEMGRAPH_INSTANCES_DESCRIPTION, "coordinator_1")
     interactive_mg_runner.start(MEMGRAPH_INSTANCES_DESCRIPTION, "coordinator_1")
     coordinator1_cursor = connect(host="localhost", port=7690).cursor()
 
-    mg_sleep_and_assert(expected_cluster_shared, check_coordinator1)
+    mg_sleep_and_assert(expected_cluster_not_shared, check_coordinator1)
 
     interactive_mg_runner.kill(MEMGRAPH_INSTANCES_DESCRIPTION, "coordinator_1")
     interactive_mg_runner.kill(MEMGRAPH_INSTANCES_DESCRIPTION, "coordinator_2")
@@ -278,11 +271,11 @@ def test_coordinators_communication_with_restarts():
     coordinator1_cursor = connect(host="localhost", port=7690).cursor()
     coordinator2_cursor = connect(host="localhost", port=7691).cursor()
 
-    mg_sleep_and_assert(expected_cluster_shared, check_coordinator1)
-    mg_sleep_and_assert(expected_cluster_shared, check_coordinator2)
+    mg_sleep_and_assert(expected_cluster_not_shared, check_coordinator1)
+    mg_sleep_and_assert(expected_cluster_not_shared, check_coordinator2)
 
 
-# # TODO: (andi) Test when dealing with distributed coordinators that you can register on one coordinator and unregister from any other coordinator
+# TODO: (andi) Test when dealing with distributed coordinators that you can register on one coordinator and unregister from any other coordinator
 @pytest.mark.parametrize(
     "kill_instance",
     [True, False],
@@ -291,12 +284,7 @@ def test_unregister_replicas(kill_instance):
     safe_execute(shutil.rmtree, TEMP_DIR)
     interactive_mg_runner.start_all(MEMGRAPH_INSTANCES_DESCRIPTION)
 
-    coordinator1_cursor = connect(host="localhost", port=7690).cursor()
-    coordinator2_cursor = connect(host="localhost", port=7691).cursor()
     coordinator3_cursor = connect(host="localhost", port=7692).cursor()
-
-    assert add_coordinator(coordinator3_cursor, "ADD COORDINATOR 1 ON '127.0.0.1:10111'")
-    assert add_coordinator(coordinator3_cursor, "ADD COORDINATOR 2 ON '127.0.0.1:10112'")
     execute_and_fetch_all(
         coordinator3_cursor, "REGISTER INSTANCE instance_1 ON '127.0.0.1:10011' WITH '127.0.0.1:10001'"
     )
@@ -308,12 +296,6 @@ def test_unregister_replicas(kill_instance):
     )
     execute_and_fetch_all(coordinator3_cursor, "SET INSTANCE instance_3 TO MAIN")
 
-    def check_coordinator1():
-        return sorted(list(execute_and_fetch_all(coordinator1_cursor, "SHOW INSTANCES")))
-
-    def check_coordinator2():
-        return sorted(list(execute_and_fetch_all(coordinator2_cursor, "SHOW INSTANCES")))
-
     def check_coordinator3():
         return sorted(list(execute_and_fetch_all(coordinator3_cursor, "SHOW INSTANCES")))
 
@@ -323,21 +305,10 @@ def test_unregister_replicas(kill_instance):
         return sorted(list(execute_and_fetch_all(main_cursor, "SHOW REPLICAS")))
 
     expected_cluster = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_1", "", "127.0.0.1:10011", "up", "replica"),
-        ("instance_2", "", "127.0.0.1:10012", "up", "replica"),
-        ("instance_3", "", "127.0.0.1:10013", "up", "main"),
-    ]
-
-    expected_cluster_shared = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_1", "", "", "unknown", "replica"),
-        ("instance_2", "", "", "unknown", "replica"),
-        ("instance_3", "", "", "unknown", "main"),
+        ("coordinator_3", "127.0.0.1:10113", "", True, "coordinator"),
+        ("instance_1", "", "127.0.0.1:10011", True, "replica"),
+        ("instance_2", "", "127.0.0.1:10012", True, "replica"),
+        ("instance_3", "", "127.0.0.1:10013", True, "main"),
     ]
 
     expected_replicas = [
@@ -357,8 +328,6 @@ def test_unregister_replicas(kill_instance):
         ),
     ]
 
-    mg_sleep_and_assert(expected_cluster_shared, check_coordinator1)
-    mg_sleep_and_assert(expected_cluster_shared, check_coordinator2)
     mg_sleep_and_assert(expected_cluster, check_coordinator3)
     mg_sleep_and_assert(expected_replicas, check_main)
 
@@ -367,19 +336,9 @@ def test_unregister_replicas(kill_instance):
     execute_and_fetch_all(coordinator3_cursor, "UNREGISTER INSTANCE instance_1")
 
     expected_cluster = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_2", "", "127.0.0.1:10012", "up", "replica"),
-        ("instance_3", "", "127.0.0.1:10013", "up", "main"),
-    ]
-
-    expected_cluster_shared = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_2", "", "", "unknown", "replica"),
-        ("instance_3", "", "", "unknown", "main"),
+        ("coordinator_3", "127.0.0.1:10113", "", True, "coordinator"),
+        ("instance_2", "", "127.0.0.1:10012", True, "replica"),
+        ("instance_3", "", "127.0.0.1:10013", True, "main"),
     ]
 
     expected_replicas = [
@@ -392,8 +351,6 @@ def test_unregister_replicas(kill_instance):
         ),
     ]
 
-    mg_sleep_and_assert(expected_cluster_shared, check_coordinator1)
-    mg_sleep_and_assert(expected_cluster_shared, check_coordinator2)
     mg_sleep_and_assert(expected_cluster, check_coordinator3)
     mg_sleep_and_assert(expected_replicas, check_main)
 
@@ -402,22 +359,11 @@ def test_unregister_replicas(kill_instance):
     execute_and_fetch_all(coordinator3_cursor, "UNREGISTER INSTANCE instance_2")
 
     expected_cluster = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_3", "", "127.0.0.1:10013", "up", "main"),
-    ]
-
-    expected_cluster_shared = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_3", "", "", "unknown", "main"),
+        ("coordinator_3", "127.0.0.1:10113", "", True, "coordinator"),
+        ("instance_3", "", "127.0.0.1:10013", True, "main"),
     ]
     expected_replicas = []
 
-    mg_sleep_and_assert(expected_cluster_shared, check_coordinator1)
-    mg_sleep_and_assert(expected_cluster_shared, check_coordinator2)
     mg_sleep_and_assert(expected_cluster, check_coordinator3)
     mg_sleep_and_assert(expected_replicas, check_main)
 
@@ -426,11 +372,7 @@ def test_unregister_main():
     safe_execute(shutil.rmtree, TEMP_DIR)
     interactive_mg_runner.start_all(MEMGRAPH_INSTANCES_DESCRIPTION)
 
-    coordinator1_cursor = connect(host="localhost", port=7690).cursor()
-    coordinator2_cursor = connect(host="localhost", port=7691).cursor()
     coordinator3_cursor = connect(host="localhost", port=7692).cursor()
-    assert add_coordinator(coordinator3_cursor, "ADD COORDINATOR 1 ON '127.0.0.1:10111'")
-    assert add_coordinator(coordinator3_cursor, "ADD COORDINATOR 2 ON '127.0.0.1:10112'")
     execute_and_fetch_all(
         coordinator3_cursor, "REGISTER INSTANCE instance_1 ON '127.0.0.1:10011' WITH '127.0.0.1:10001'"
     )
@@ -442,35 +384,16 @@ def test_unregister_main():
     )
     execute_and_fetch_all(coordinator3_cursor, "SET INSTANCE instance_3 TO MAIN")
 
-    def check_coordinator1():
-        return sorted(list(execute_and_fetch_all(coordinator1_cursor, "SHOW INSTANCES")))
-
-    def check_coordinator2():
-        return sorted(list(execute_and_fetch_all(coordinator2_cursor, "SHOW INSTANCES")))
-
     def check_coordinator3():
         return sorted(list(execute_and_fetch_all(coordinator3_cursor, "SHOW INSTANCES")))
 
     expected_cluster = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_1", "", "127.0.0.1:10011", "up", "replica"),
-        ("instance_2", "", "127.0.0.1:10012", "up", "replica"),
-        ("instance_3", "", "127.0.0.1:10013", "up", "main"),
+        ("coordinator_3", "127.0.0.1:10113", "", True, "coordinator"),
+        ("instance_1", "", "127.0.0.1:10011", True, "replica"),
+        ("instance_2", "", "127.0.0.1:10012", True, "replica"),
+        ("instance_3", "", "127.0.0.1:10013", True, "main"),
     ]
 
-    expected_cluster_shared = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_1", "", "", "unknown", "replica"),
-        ("instance_2", "", "", "unknown", "replica"),
-        ("instance_3", "", "", "unknown", "main"),
-    ]
-
-    mg_sleep_and_assert(expected_cluster_shared, check_coordinator1)
-    mg_sleep_and_assert(expected_cluster_shared, check_coordinator2)
     mg_sleep_and_assert(expected_cluster, check_coordinator3)
 
     try:
@@ -484,43 +407,20 @@ def test_unregister_main():
     interactive_mg_runner.kill(MEMGRAPH_INSTANCES_DESCRIPTION, "instance_3")
 
     expected_cluster = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_1", "", "127.0.0.1:10011", "up", "main"),
-        ("instance_2", "", "127.0.0.1:10012", "up", "replica"),
-        ("instance_3", "", "127.0.0.1:10013", "down", "unknown"),
+        ("coordinator_3", "127.0.0.1:10113", "", True, "coordinator"),
+        ("instance_1", "", "127.0.0.1:10011", True, "main"),
+        ("instance_2", "", "127.0.0.1:10012", True, "replica"),
+        ("instance_3", "", "127.0.0.1:10013", False, "unknown"),
     ]
 
-    expected_cluster_shared = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_1", "", "", "unknown", "main"),
-        ("instance_2", "", "", "unknown", "replica"),
-        ("instance_3", "", "", "unknown", "main"),
-    ]
-
-    mg_sleep_and_assert(expected_cluster_shared, check_coordinator1)
-    mg_sleep_and_assert(expected_cluster_shared, check_coordinator2)
     mg_sleep_and_assert(expected_cluster, check_coordinator3)
 
     execute_and_fetch_all(coordinator3_cursor, "UNREGISTER INSTANCE instance_3")
 
     expected_cluster = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_1", "", "127.0.0.1:10011", "up", "main"),
-        ("instance_2", "", "127.0.0.1:10012", "up", "replica"),
-    ]
-
-    expected_cluster_shared = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_1", "", "", "unknown", "main"),
-        ("instance_2", "", "", "unknown", "replica"),
+        ("coordinator_3", "127.0.0.1:10113", "", True, "coordinator"),
+        ("instance_1", "", "127.0.0.1:10011", True, "main"),
+        ("instance_2", "", "127.0.0.1:10012", True, "replica"),
     ]
 
     expected_replicas = [
@@ -538,8 +438,6 @@ def test_unregister_main():
     def check_main():
         return sorted(list(execute_and_fetch_all(main_cursor, "SHOW REPLICAS")))
 
-    mg_sleep_and_assert(expected_cluster_shared, check_coordinator1)
-    mg_sleep_and_assert(expected_cluster_shared, check_coordinator2)
     mg_sleep_and_assert(expected_cluster, check_coordinator3)
     mg_sleep_and_assert(expected_replicas, check_main)
 

tests/e2e/high_availability/coordinator.py

@@ -44,10 +44,10 @@ def test_coordinator_show_instances():
         return sorted(list(execute_and_fetch_all(cursor, "SHOW INSTANCES;")))
 
     expected_data = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("instance_1", "", "127.0.0.1:10011", "up", "replica"),
-        ("instance_2", "", "127.0.0.1:10012", "up", "replica"),
-        ("instance_3", "", "127.0.0.1:10013", "up", "main"),
+        ("coordinator_1", "127.0.0.1:10111", "", True, "coordinator"),
+        ("instance_1", "", "127.0.0.1:10011", True, "replica"),
+        ("instance_2", "", "127.0.0.1:10012", True, "replica"),
+        ("instance_3", "", "127.0.0.1:10013", True, "main"),
     ]
     mg_sleep_and_assert(expected_data, retrieve_data)
 

tests/e2e/high_availability/disable_writing_on_main_after_restart.py

@@ -143,20 +143,20 @@ def test_writing_disabled_on_main_restart():
         return sorted(list(execute_and_fetch_all(coordinator3_cursor, "SHOW INSTANCES")))
 
     expected_cluster_coord3 = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_3", "", "127.0.0.1:10013", "up", "main"),
+        ("coordinator_1", "127.0.0.1:10111", "", True, "coordinator"),
+        ("coordinator_2", "127.0.0.1:10112", "", True, "coordinator"),
+        ("coordinator_3", "127.0.0.1:10113", "", True, "coordinator"),
+        ("instance_3", "", "127.0.0.1:10013", True, "main"),
     ]
     mg_sleep_and_assert(expected_cluster_coord3, check_coordinator3)
 
     interactive_mg_runner.kill(MEMGRAPH_INSTANCES_DESCRIPTION, "instance_3")
 
     expected_cluster_coord3 = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_3", "", "127.0.0.1:10013", "down", "unknown"),
+        ("coordinator_1", "127.0.0.1:10111", "", True, "coordinator"),
+        ("coordinator_2", "127.0.0.1:10112", "", True, "coordinator"),
+        ("coordinator_3", "127.0.0.1:10113", "", True, "coordinator"),
+        ("instance_3", "", "127.0.0.1:10013", False, "unknown"),
     ]
 
     mg_sleep_and_assert(expected_cluster_coord3, check_coordinator3)
@@ -173,10 +173,10 @@ def test_writing_disabled_on_main_restart():
         )
 
     expected_cluster_coord3 = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_3", "", "127.0.0.1:10013", "up", "main"),
+        ("coordinator_1", "127.0.0.1:10111", "", True, "coordinator"),
+        ("coordinator_2", "127.0.0.1:10112", "", True, "coordinator"),
+        ("coordinator_3", "127.0.0.1:10113", "", True, "coordinator"),
+        ("instance_3", "", "127.0.0.1:10013", True, "main"),
     ]
 
     mg_sleep_and_assert(expected_cluster_coord3, check_coordinator3)

tests/e2e/high_availability/distributed_coords.py

@@ -13,16 +13,11 @@ import os
 import shutil
 import sys
 import tempfile
-from time import sleep
 
 import interactive_mg_runner
 import pytest
 from common import connect, execute_and_fetch_all, safe_execute
-from mg_utils import (
-    mg_sleep_and_assert,
-    mg_sleep_and_assert_any_function,
-    mg_sleep_and_assert_collection,
-)
+from mg_utils import mg_sleep_and_assert, mg_sleep_and_assert_collection
 
 interactive_mg_runner.SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))
 interactive_mg_runner.PROJECT_DIR = os.path.normpath(
@@ -123,19 +118,9 @@ MEMGRAPH_INSTANCES_DESCRIPTION = {
 
 
 def test_distributed_automatic_failover():
-    # Goal of this test is to check that coordination works if one instance fails
-    # with multiple coordinators
-
-    # 1. Start all manually
-    # 2. Everything is set up on main
-    # 3. MAIN dies
-    # 4. New main elected
-
-    # 1
     safe_execute(shutil.rmtree, TEMP_DIR)
     interactive_mg_runner.start_all(MEMGRAPH_INSTANCES_DESCRIPTION)
 
-    # 2
     main_cursor = connect(host="localhost", port=7689).cursor()
     expected_data_on_main = [
         (
@@ -153,28 +138,23 @@ def test_distributed_automatic_failover():
             {"memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
         ),
     ]
+    actual_data_on_main = sorted(list(execute_and_fetch_all(main_cursor, "SHOW REPLICAS;")))
+    assert actual_data_on_main == sorted(expected_data_on_main)
 
-    def retrieve_data_show_replicas():
-        return sorted(list(execute_and_fetch_all(main_cursor, "SHOW REPLICAS;")))
-
-    mg_sleep_and_assert_collection(expected_data_on_main, retrieve_data_show_replicas)
-
-    # 3
     interactive_mg_runner.kill(MEMGRAPH_INSTANCES_DESCRIPTION, "instance_3")
 
-    # 4
     coord_cursor = connect(host="localhost", port=7692).cursor()
 
     def retrieve_data_show_repl_cluster():
         return sorted(list(execute_and_fetch_all(coord_cursor, "SHOW INSTANCES;")))
 
     expected_data_on_coord = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_1", "", "127.0.0.1:10011", "up", "main"),
-        ("instance_2", "", "127.0.0.1:10012", "up", "replica"),
-        ("instance_3", "", "127.0.0.1:10013", "down", "unknown"),
+        ("coordinator_1", "127.0.0.1:10111", "", True, "coordinator"),
+        ("coordinator_2", "127.0.0.1:10112", "", True, "coordinator"),
+        ("coordinator_3", "127.0.0.1:10113", "", True, "coordinator"),
+        ("instance_1", "", "127.0.0.1:10011", True, "main"),
+        ("instance_2", "", "127.0.0.1:10012", True, "replica"),
+        ("instance_3", "", "127.0.0.1:10013", False, "unknown"),
     ]
     mg_sleep_and_assert(expected_data_on_coord, retrieve_data_show_repl_cluster)
 
@@ -222,425 +202,5 @@ def test_distributed_automatic_failover():
     mg_sleep_and_assert_collection(expected_data_on_new_main_old_alive, retrieve_data_show_replicas)
 
 
-def test_distributed_automatic_failover_after_coord_dies():
-    # Goal of this test is to check if main and coordinator die at same time in the beginning that
-    # everything works fine
-    # 1. Start all manually
-    # 2. Coordinator dies
-    # 3. MAIN dies
-    # 4.
-    safe_execute(shutil.rmtree, TEMP_DIR)
-
-    # 1
-    interactive_mg_runner.start_all(MEMGRAPH_INSTANCES_DESCRIPTION)
-
-    # 2
-    interactive_mg_runner.kill(MEMGRAPH_INSTANCES_DESCRIPTION, "coordinator_3")
-
-    # 3
-    interactive_mg_runner.kill(MEMGRAPH_INSTANCES_DESCRIPTION, "instance_3")
-
-    coord_cursor_1 = connect(host="localhost", port=7690).cursor()
-
-    def show_instances_coord1():
-        return sorted(list(execute_and_fetch_all(coord_cursor_1, "SHOW INSTANCES;")))
-
-    coord_cursor_2 = connect(host="localhost", port=7691).cursor()
-
-    def show_instances_coord2():
-        return sorted(list(execute_and_fetch_all(coord_cursor_2, "SHOW INSTANCES;")))
-
-    leader_data = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_1", "", "127.0.0.1:10011", "up", "main"),
-        ("instance_2", "", "127.0.0.1:10012", "up", "replica"),
-        ("instance_3", "", "127.0.0.1:10013", "down", "unknown"),
-    ]
-    mg_sleep_and_assert_any_function(leader_data, [show_instances_coord1, show_instances_coord2])
-
-    follower_data = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("instance_1", "", "", "unknown", "main"),
-        ("instance_2", "", "", "unknown", "replica"),
-        ("instance_3", "", "", "unknown", "main"),
-    ]
-    mg_sleep_and_assert_any_function(leader_data, [show_instances_coord1, show_instances_coord2])
-    mg_sleep_and_assert_any_function(follower_data, [show_instances_coord1, show_instances_coord2])
-
-    new_main_cursor = connect(host="localhost", port=7687).cursor()
-
-    def retrieve_data_show_replicas():
-        return sorted(list(execute_and_fetch_all(new_main_cursor, "SHOW REPLICAS;")))
-
-    expected_data_on_new_main = [
-        (
-            "instance_2",
-            "127.0.0.1:10002",
-            "sync",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-        (
-            "instance_3",
-            "127.0.0.1:10003",
-            "sync",
-            {"ts": 0, "behind": None, "status": "invalid"},
-            {"memgraph": {"ts": 0, "behind": 0, "status": "invalid"}},
-        ),
-    ]
-    mg_sleep_and_assert_collection(expected_data_on_new_main, retrieve_data_show_replicas)
-
-    interactive_mg_runner.start(MEMGRAPH_INSTANCES_DESCRIPTION, "instance_3")
-    expected_data_on_new_main_old_alive = [
-        (
-            "instance_2",
-            "127.0.0.1:10002",
-            "sync",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-        (
-            "instance_3",
-            "127.0.0.1:10003",
-            "sync",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-    ]
-
-    mg_sleep_and_assert_collection(expected_data_on_new_main_old_alive, retrieve_data_show_replicas)
-
-
-@pytest.mark.parametrize("data_recovery", ["false"])
-def test_distributed_coordinators_work_partial_failover(data_recovery):
-    # Goal of this test is to check that correct MAIN instance is chosen
-    # if coordinator dies while failover is being done
-    # 1. We start all replicas, main and 4 coordinators manually
-    # 2. We check that main has correct state
-    # 3. Create initial data on MAIN
-    # 4. Expect data to be copied on all replicas
-    # 5. Kill MAIN: instance 3
-
-    # 6. Failover should succeed to instance 1 -> SHOW ROLE -> MAIN
-    # 7. Kill 2 coordinators (1 and 2) as soon as instance becomes MAIN
-    # 8. coord 4 become follower (2 coords dead, no leader)
-    # 8. instance_1 writes (MAIN, successfully)
-    # 9. Kill coordinator 4
-    # 10. Connect to coordinator 3
-    # 11. Start coordinator_1 and coordinator_2 (coord 3 probably leader)
-    # 12. Failover again
-    # 13. Main can't write to replicas anymore, coordinator can't progress
-
-    temp_dir = tempfile.TemporaryDirectory().name
-
-    MEMGRAPH_INNER_INSTANCES_DESCRIPTION = {
-        "instance_1": {
-            "args": [
-                "--experimental-enabled=high-availability",
-                "--bolt-port",
-                "7688",
-                "--log-level",
-                "TRACE",
-                "--coordinator-server-port",
-                "10011",
-                "--replication-restore-state-on-startup",
-                "true",
-                f"--data-recovery-on-startup={data_recovery}",
-                "--storage-recover-on-startup=false",
-            ],
-            "log_file": "instance_1.log",
-            "data_directory": f"{temp_dir}/instance_1",
-            "setup_queries": [],
-        },
-        "instance_2": {
-            "args": [
-                "--experimental-enabled=high-availability",
-                "--bolt-port",
-                "7689",
-                "--log-level",
-                "TRACE",
-                "--coordinator-server-port",
-                "10012",
-                "--replication-restore-state-on-startup",
-                "true",
-                f"--data-recovery-on-startup={data_recovery}",
-                "--storage-recover-on-startup=false",
-            ],
-            "log_file": "instance_2.log",
-            "data_directory": f"{temp_dir}/instance_2",
-            "setup_queries": [],
-        },
-        "instance_3": {
-            "args": [
-                "--experimental-enabled=high-availability",
-                "--bolt-port",
-                "7687",
-                "--log-level",
-                "TRACE",
-                "--coordinator-server-port",
-                "10013",
-                "--replication-restore-state-on-startup",
-                "true",
-                "--data-recovery-on-startup",
-                f"{data_recovery}",
-                "--storage-recover-on-startup=false",
-            ],
-            "log_file": "instance_3.log",
-            "data_directory": f"{temp_dir}/instance_3",
-            "setup_queries": [],
-        },
-        "coordinator_1": {
-            "args": [
-                "--experimental-enabled=high-availability",
-                "--bolt-port",
-                "7690",
-                "--log-level=TRACE",
-                "--raft-server-id=1",
-                "--raft-server-port=10111",
-            ],
-            "log_file": "coordinator1.log",
-            "data_directory": f"{temp_dir}/coordinator_1",
-            "setup_queries": [],
-        },
-        "coordinator_2": {
-            "args": [
-                "--experimental-enabled=high-availability",
-                "--bolt-port",
-                "7691",
-                "--log-level=TRACE",
-                "--raft-server-id=2",
-                "--raft-server-port=10112",
-            ],
-            "log_file": "coordinator2.log",
-            "data_directory": f"{temp_dir}/coordinator_2",
-            "setup_queries": [],
-        },
-        "coordinator_3": {
-            "args": [
-                "--experimental-enabled=high-availability",
-                "--bolt-port",
-                "7692",
-                "--log-level=TRACE",
-                "--raft-server-id=3",
-                "--raft-server-port=10113",
-            ],
-            "log_file": "coordinator3.log",
-            "data_directory": f"{temp_dir}/coordinator_3",
-            "setup_queries": [],
-        },
-        "coordinator_4": {
-            "args": [
-                "--experimental-enabled=high-availability",
-                "--bolt-port",
-                "7693",
-                "--log-level=TRACE",
-                "--raft-server-id=4",
-                "--raft-server-port=10114",
-            ],
-            "log_file": "coordinator4.log",
-            "data_directory": f"{temp_dir}/coordinator_4",
-            "setup_queries": [],
-        },
-    }
-
-    # 1
-
-    interactive_mg_runner.start_all_except(MEMGRAPH_INNER_INSTANCES_DESCRIPTION, {"coordinator_4"})
-
-    interactive_mg_runner.start(MEMGRAPH_INNER_INSTANCES_DESCRIPTION, "coordinator_4")
-
-    coord_cursor = connect(host="localhost", port=7693).cursor()
-
-    for query in [
-        "ADD COORDINATOR 1 ON '127.0.0.1:10111';",
-        "ADD COORDINATOR 2 ON '127.0.0.1:10112';",
-        "ADD COORDINATOR 3 ON '127.0.0.1:10113';",
-    ]:
-        sleep(1)
-        execute_and_fetch_all(coord_cursor, query)
-
-    for query in [
-        "REGISTER INSTANCE instance_3 ON '127.0.0.1:10013' WITH '127.0.0.1:10003';",
-        "REGISTER INSTANCE instance_1 ON '127.0.0.1:10011' WITH '127.0.0.1:10001';",
-        "REGISTER INSTANCE instance_2 ON '127.0.0.1:10012' WITH '127.0.0.1:10002';",
-        "SET INSTANCE instance_3 TO MAIN;",
-    ]:
-        execute_and_fetch_all(coord_cursor, query)
-
-    # 2
-
-    main_cursor = connect(host="localhost", port=7687).cursor()
-    expected_data_on_main = [
-        (
-            "instance_1",
-            "127.0.0.1:10001",
-            "sync",
-            {"behind": None, "status": "ready", "ts": 0},
-            {"memgraph": {"behind": 0, "status": "ready", "ts": 0}},
-        ),
-        (
-            "instance_2",
-            "127.0.0.1:10002",
-            "sync",
-            {"behind": None, "status": "ready", "ts": 0},
-            {"memgraph": {"behind": 0, "status": "ready", "ts": 0}},
-        ),
-    ]
-
-    main_cursor = connect(host="localhost", port=7687).cursor()
-
-    def retrieve_data_show_replicas():
-        return sorted(list(execute_and_fetch_all(main_cursor, "SHOW REPLICAS;")))
-
-    mg_sleep_and_assert_collection(expected_data_on_main, retrieve_data_show_replicas)
-
-    coord_cursor = connect(host="localhost", port=7693).cursor()
-
-    def retrieve_data_show_instances_main_coord():
-        return sorted(list(execute_and_fetch_all(coord_cursor, "SHOW INSTANCES;")))
-
-    expected_data_on_coord = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("coordinator_4", "127.0.0.1:10114", "", "unknown", "coordinator"),
-        ("instance_1", "", "127.0.0.1:10011", "up", "replica"),
-        ("instance_2", "", "127.0.0.1:10012", "up", "replica"),
-        ("instance_3", "", "127.0.0.1:10013", "up", "main"),
-    ]
-    mg_sleep_and_assert(expected_data_on_coord, retrieve_data_show_instances_main_coord)
-
-    # 3
-
-    execute_and_fetch_all(main_cursor, "CREATE (:Epoch1Vertex {prop:1});")
-    execute_and_fetch_all(main_cursor, "CREATE (:Epoch1Vertex {prop:2});")
-
-    # 4
-    instance_1_cursor = connect(host="localhost", port=7688).cursor()
-    instance_2_cursor = connect(host="localhost", port=7689).cursor()
-
-    assert execute_and_fetch_all(instance_1_cursor, "MATCH (n) RETURN count(n);")[0][0] == 2
-    assert execute_and_fetch_all(instance_2_cursor, "MATCH (n) RETURN count(n);")[0][0] == 2
-
-    # 5
-
-    interactive_mg_runner.kill(MEMGRAPH_INNER_INSTANCES_DESCRIPTION, "instance_3")
-    # 6
-
-    sleep(4.5)
-    max_tries = 100
-    last_role = "replica"
-    while max_tries:
-        max_tries -= 1
-        last_role = execute_and_fetch_all(instance_1_cursor, "SHOW REPLICATION ROLE;")[0][0]
-        if "main" == last_role:
-            interactive_mg_runner.kill(MEMGRAPH_INNER_INSTANCES_DESCRIPTION, "coordinator_1")
-            interactive_mg_runner.kill(MEMGRAPH_INNER_INSTANCES_DESCRIPTION, "coordinator_2")
-            break
-        sleep(0.1)
-    assert max_tries > 0 or last_role == "main"
-
-    expected_data_on_coord = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("coordinator_4", "127.0.0.1:10114", "", "unknown", "coordinator"),
-        ("instance_1", "", "127.0.0.1:10011", "unknown", "main"),  # TODO although above we see it is MAIN
-        ("instance_2", "", "127.0.0.1:10012", "unknown", "replica"),
-        ("instance_3", "", "127.0.0.1:10013", "unknown", "main"),
-    ]
-
-    def retrieve_data_show_instances():
-        return sorted(list(execute_and_fetch_all(coord_cursor, "SHOW INSTANCES;")))
-
-    mg_sleep_and_assert(expected_data_on_coord, retrieve_data_show_instances)
-
-    # 7
-    def retrieve_role():
-        return execute_and_fetch_all(instance_1_cursor, "SHOW REPLICATION ROLE;")[0]
-
-    mg_sleep_and_assert("MAIN", retrieve_role)
-
-    # 8
-
-    with pytest.raises(Exception) as e:
-        execute_and_fetch_all(instance_1_cursor, "CREATE (:Epoch2Vertex {prop:1});")
-    assert "At least one SYNC replica has not confirmed committing last transaction." in str(e.value)
-
-    def get_vertex_count_instance_2():
-        return execute_and_fetch_all(instance_2_cursor, "MATCH (n) RETURN count(n)")[0][0]
-
-    mg_sleep_and_assert(3, get_vertex_count_instance_2)
-
-    assert execute_and_fetch_all(instance_1_cursor, "MATCH (n) RETURN count(n);")[0][0] == 3
-
-    # 9
-
-    interactive_mg_runner.kill(MEMGRAPH_INNER_INSTANCES_DESCRIPTION, "coordinator_4")
-
-    # 10
-
-    coord_3_cursor = connect(port=7692, host="localhost").cursor()
-
-    expected_data_on_coord = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("coordinator_4", "127.0.0.1:10114", "", "unknown", "coordinator"),
-        ("instance_1", "", "127.0.0.1:10011", "unknown", "replica"),  # TODO: bug this is main
-        ("instance_2", "", "127.0.0.1:10012", "unknown", "replica"),
-        ("instance_3", "", "127.0.0.1:10013", "unknown", "replica"),
-    ]
-
-    def retrieve_data_show_instances_new_leader():
-        return sorted(list(execute_and_fetch_all(coord_3_cursor, "SHOW INSTANCES;")))
-
-    mg_sleep_and_assert(expected_data_on_coord, retrieve_data_show_instances_new_leader)
-
-    # 11
-
-    interactive_mg_runner.start(MEMGRAPH_INNER_INSTANCES_DESCRIPTION, "coordinator_1")
-    interactive_mg_runner.start(MEMGRAPH_INNER_INSTANCES_DESCRIPTION, "coordinator_2")
-
-    # 12
-
-    expected_data_on_coord = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("coordinator_2", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("coordinator_3", "127.0.0.1:10113", "", "unknown", "coordinator"),
-        ("coordinator_4", "127.0.0.1:10114", "", "unknown", "coordinator"),
-        (
-            "instance_1",
-            "",
-            "127.0.0.1:10011",
-            "up",
-            "replica",
-        ),  # TODO: bug this is main, this might crash instance, because we will maybe execute replica callback on MAIN, which won't work
-        ("instance_2", "", "127.0.0.1:10012", "up", "replica"),
-        ("instance_3", "", "127.0.0.1:10013", "down", "unknown"),
-    ]
-    mg_sleep_and_assert(expected_data_on_coord, retrieve_data_show_instances_new_leader)
-
-    import time
-
-    time.sleep(5)  # failover
-
-    with pytest.raises(Exception) as e:
-        execute_and_fetch_all(instance_1_cursor, "CREATE (:Epoch2Vertex {prop:2});")
-    assert "At least one SYNC replica has not confirmed committing last transaction." in str(e.value)
-
-    def get_vertex_count_instance_2():
-        return execute_and_fetch_all(instance_2_cursor, "MATCH (n) RETURN count(n)")[0][0]
-
-    mg_sleep_and_assert(4, get_vertex_count_instance_2)  # MAIN will not be able to write to it anymore
-
-    # 13
-
-
 if __name__ == "__main__":
-    sys.exit(pytest.main([__file__, "-k", "test_distributed_coordinators_work_partial_failover", "-vv"]))
     sys.exit(pytest.main([__file__, "-rA"]))

tests/e2e/high_availability/not_replicate_from_old_main.py

@@ -75,11 +75,8 @@ def test_replication_works_on_failover():
             {"memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
         ),
     ]
-
-    def retrieve_data_show_replicas():
-        return sorted(list(execute_and_fetch_all(main_cursor, "SHOW REPLICAS;")))
-
-    mg_sleep_and_assert(expected_data_on_main, retrieve_data_show_replicas)
+    actual_data_on_main = sorted(list(execute_and_fetch_all(main_cursor, "SHOW REPLICAS;")))
+    assert actual_data_on_main == expected_data_on_main
 
     # 3
     interactive_mg_runner.start_all_keep_others(MEMGRAPH_SECOND_CLUSTER_DESCRIPTION)
@@ -203,9 +200,9 @@ def test_not_replicate_old_main_register_new_cluster():
         return sorted(list(execute_and_fetch_all(first_cluster_coord_cursor, "SHOW INSTANCES;")))
 
     expected_data_up_first_cluster = [
-        ("coordinator_1", "127.0.0.1:10111", "", "unknown", "coordinator"),
-        ("instance_2", "", "127.0.0.1:10012", "up", "main"),
-        ("shared_instance", "", "127.0.0.1:10011", "up", "replica"),
+        ("coordinator_1", "127.0.0.1:10111", "", True, "coordinator"),
+        ("instance_2", "", "127.0.0.1:10012", True, "main"),
+        ("shared_instance", "", "127.0.0.1:10011", True, "replica"),
     ]
 
     mg_sleep_and_assert(expected_data_up_first_cluster, show_repl_cluster)
@@ -257,9 +254,9 @@ def test_not_replicate_old_main_register_new_cluster():
         return sorted(list(execute_and_fetch_all(second_cluster_coord_cursor, "SHOW INSTANCES;")))
 
     expected_data_up_second_cluster = [
-        ("coordinator_1", "127.0.0.1:10112", "", "unknown", "coordinator"),
-        ("instance_3", "", "127.0.0.1:10013", "up", "main"),
-        ("shared_instance", "", "127.0.0.1:10011", "up", "replica"),
+        ("coordinator_1", "127.0.0.1:10112", "", True, "coordinator"),
+        ("instance_3", "", "127.0.0.1:10013", True, "main"),
+        ("shared_instance", "", "127.0.0.1:10011", True, "replica"),
     ]
 
     mg_sleep_and_assert(expected_data_up_second_cluster, show_repl_cluster)

tests/e2e/interactive_mg_runner.py

@@ -39,7 +39,6 @@ import tempfile
 import time
 from argparse import ArgumentParser
 from inspect import signature
-from typing import List, Set
 
 import yaml
 
@@ -215,14 +214,6 @@ def start_all(context, procdir="", keep_directories=True):
         start_instance(context, key, procdir)
 
 
-def start_all_except(context, exceptions: Set[str], procdir="", keep_directories=True):
-    stop_all(keep_directories)
-    for key, _ in context.items():
-        if key in exceptions:
-            continue
-        start_instance(context, key, procdir)
-
-
 def start_all_keep_others(context, procdir="", keep_directories=True):
     for key, _ in context.items():
         start_instance(context, key, procdir)

tests/e2e/mg_utils.py

@@ -17,28 +17,6 @@ def mg_sleep_and_assert(expected_value, function_to_retrieve_data, max_duration=
     return result
 
 
-def mg_sleep_and_assert_any_function(
-    expected_value, functions_to_retrieve_data, max_duration=20, time_between_attempt=0.2
-):
-    result = [f() for f in functions_to_retrieve_data]
-    if any((x == expected_value for x in result)):
-        return result
-    start_time = time.time()
-    while result != expected_value:
-        duration = time.time() - start_time
-        if duration > max_duration:
-            assert (
-                False
-            ), f" mg_sleep_and_assert has tried for too long and did not get the expected result! Last result was: {result}"
-
-        time.sleep(time_between_attempt)
-        result = [f() for f in functions_to_retrieve_data]
-        if any((x == expected_value for x in result)):
-            return result
-
-    return result
-
-
 def mg_sleep_and_assert_collection(
     expected_value, function_to_retrieve_data, max_duration=20, time_between_attempt=0.2
 ):

tests/e2e/replication/show_while_creating_invalid_state.py

@@ -923,7 +923,7 @@ def test_replication_role_recovery(connection):
                 "--log-level=TRACE",
                 "--replication-restore-state-on-startup",
                 "true",
-                "--data-recovery-on-startup",
+                "--storage-recover-on-startup",
                 "false",
             ],
             "log_file": "replica.log",
@@ -934,7 +934,7 @@ def test_replication_role_recovery(connection):
                 "--bolt-port",
                 "7687",
                 "--log-level=TRACE",
-                "--data-recovery-on-startup=true",
+                "--storage-recover-on-startup=true",
                 "--replication-restore-state-on-startup=true",
             ],
             "log_file": "main.log",
@@ -1105,7 +1105,7 @@ def test_basic_recovery_when_replica_is_kill_when_main_is_down():
                 "--bolt-port",
                 "7687",
                 "--log-level=TRACE",
-                "--data-recovery-on-startup=true",
+                "--storage-recover-on-startup=true",
                 "--replication-restore-state-on-startup=true",
             ],
             "log_file": "main.log",
@@ -1201,7 +1201,7 @@ def test_async_replication_when_main_is_killed():
                 "data_directory": f"{data_directory_replica.name}",
             },
             "main": {
-                "args": ["--bolt-port", "7687", "--log-level=TRACE", "--data-recovery-on-startup=true"],
+                "args": ["--bolt-port", "7687", "--log-level=TRACE", "--storage-recover-on-startup=true"],
                 "log_file": "main.log",
                 "setup_queries": [],
                 "data_directory": f"{data_directory_main.name}",
@@ -1284,7 +1284,7 @@ def test_sync_replication_when_main_is_killed():
                 "data_directory": f"{data_directory_replica.name}",
             },
             "main": {
-                "args": ["--bolt-port", "7687", "--log-level=TRACE", "--data-recovery-on-startup=true"],
+                "args": ["--bolt-port", "7687", "--log-level=TRACE", "--storage-recover-on-startup=true"],
                 "log_file": "main.log",
                 "setup_queries": [],
                 "data_directory": f"{data_directory_main.name}",
@@ -1340,7 +1340,7 @@ def test_attempt_to_write_data_on_main_when_async_replica_is_down():
             "setup_queries": ["SET REPLICATION ROLE TO REPLICA WITH PORT 10002;"],
         },
         "main": {
-            "args": ["--bolt-port", "7687", "--log-level=TRACE", "--data-recovery-on-startup=true"],
+            "args": ["--bolt-port", "7687", "--log-level=TRACE", "--storage-recover-on-startup=true"],
             "log_file": "main.log",
             "setup_queries": [
                 "REGISTER REPLICA async_replica1 ASYNC TO '127.0.0.1:10001';",
@@ -1443,7 +1443,7 @@ def test_attempt_to_write_data_on_main_when_sync_replica_is_down(connection):
             "setup_queries": ["SET REPLICATION ROLE TO REPLICA WITH PORT 10002;"],
         },
         "main": {
-            "args": ["--bolt-port", "7687", "--log-level=TRACE", "--data-recovery-on-startup", "true"],
+            "args": ["--bolt-port", "7687", "--log-level=TRACE", "--storage-recover-on-startup", "true"],
             "log_file": "main.log",
             # need to do it manually
             "setup_queries": [],
@@ -1572,7 +1572,7 @@ def test_attempt_to_create_indexes_on_main_when_async_replica_is_down():
             "setup_queries": ["SET REPLICATION ROLE TO REPLICA WITH PORT 10002;"],
         },
         "main": {
-            "args": ["--bolt-port", "7687", "--log-level=TRACE", "--data-recovery-on-startup=true"],
+            "args": ["--bolt-port", "7687", "--log-level=TRACE", "--storage-recover-on-startup=true"],
             "log_file": "main.log",
             "setup_queries": [
                 "REGISTER REPLICA async_replica1 ASYNC TO '127.0.0.1:10001';",
@@ -1673,7 +1673,7 @@ def test_attempt_to_create_indexes_on_main_when_sync_replica_is_down(connection)
             "setup_queries": ["SET REPLICATION ROLE TO REPLICA WITH PORT 10002;"],
         },
         "main": {
-            "args": ["--bolt-port", "7687", "--log-level=TRACE", "--data-recovery-on-startup=true"],
+            "args": ["--bolt-port", "7687", "--log-level=TRACE", "--storage-recover-on-startup=true"],
             "log_file": "main.log",
             # Need to do it manually
             "setup_queries": [],
@@ -1818,7 +1818,7 @@ def test_trigger_on_create_before_commit_with_offline_sync_replica(connection):
             "setup_queries": ["SET REPLICATION ROLE TO REPLICA WITH PORT 10002;"],
         },
         "main": {
-            "args": ["--bolt-port", "7687", "--log-level=TRACE", "--data-recovery-on-startup=true"],
+            "args": ["--bolt-port", "7687", "--log-level=TRACE", "--storage-recover-on-startup=true"],
             "log_file": "main.log",
             # Need to do it manually since we kill replica
             "setup_queries": [],
@@ -1937,7 +1937,7 @@ def test_trigger_on_update_before_commit_with_offline_sync_replica(connection):
             "setup_queries": ["SET REPLICATION ROLE TO REPLICA WITH PORT 10002;"],
         },
         "main": {
-            "args": ["--bolt-port", "7687", "--log-level=TRACE", "--data-recovery-on-startup=true"],
+            "args": ["--bolt-port", "7687", "--log-level=TRACE", "--storage-recover-on-startup=true"],
             "log_file": "main.log",
             "setup_queries": [],
         },
@@ -2060,7 +2060,7 @@ def test_trigger_on_delete_before_commit_with_offline_sync_replica(connection):
             "setup_queries": ["SET REPLICATION ROLE TO REPLICA WITH PORT 10002;"],
         },
         "main": {
-            "args": ["--bolt-port", "7687", "--log-level=TRACE", "--data-recovery-on-startup=true"],
+            "args": ["--bolt-port", "7687", "--log-level=TRACE", "--storage-recover-on-startup=true"],
             "log_file": "main.log",
             "setup_queries": [],
         },
@@ -2187,7 +2187,7 @@ def test_trigger_on_create_before_and_after_commit_with_offline_sync_replica(con
             "setup_queries": ["SET REPLICATION ROLE TO REPLICA WITH PORT 10002;"],
         },
         "main": {
-            "args": ["--bolt-port", "7687", "--log-level=TRACE", "--data-recovery-on-startup=true"],
+            "args": ["--bolt-port", "7687", "--log-level=TRACE", "--storage-recover-on-startup=true"],
             "log_file": "main.log",
             "setup_queries": [],
         },
@@ -2310,7 +2310,7 @@ def test_triggers_on_create_before_commit_with_offline_sync_replica(connection):
             "setup_queries": ["SET REPLICATION ROLE TO REPLICA WITH PORT 10002;"],
         },
         "main": {
-            "args": ["--bolt-port", "7687", "--log-level=TRACE", "--data-recovery-on-startup=true"],
+            "args": ["--bolt-port", "7687", "--log-level=TRACE", "--storage-recover-on-startup=true"],
             "log_file": "main.log",
             "setup_queries": [],
         },

tests/unit/coordination_utils.cpp

@@ -67,8 +67,8 @@ TEST_F(CoordinationUtils, MemgraphDbHistorySimple) {
   auto [instance_name, latest_epoch, latest_commit_timestamp] =
       instance.ChooseMostUpToDateInstance(instance_database_histories);
   ASSERT_TRUE(instance_name == "instance_1" || instance_name == "instance_2" || instance_name == "instance_3");
-  ASSERT_TRUE(latest_epoch == db_histories.back().first);
-  ASSERT_TRUE(latest_commit_timestamp == db_histories.back().second);
+  ASSERT_TRUE(*latest_epoch == db_histories.back().first);
+  ASSERT_TRUE(*latest_commit_timestamp == db_histories.back().second);
 }
 
 TEST_F(CoordinationUtils, MemgraphDbHistoryLastEpochDifferent) {
@@ -121,8 +121,8 @@ TEST_F(CoordinationUtils, MemgraphDbHistoryLastEpochDifferent) {
       instance.ChooseMostUpToDateInstance(instance_database_histories);
 
   ASSERT_TRUE(instance_name == "instance_3");
-  ASSERT_TRUE(latest_epoch == db_histories.back().first);
-  ASSERT_TRUE(latest_commit_timestamp == db_histories.back().second);
+  ASSERT_TRUE(*latest_epoch == db_histories.back().first);
+  ASSERT_TRUE(*latest_commit_timestamp == db_histories.back().second);
 }
 
 TEST_F(CoordinationUtils, MemgraphDbHistoryOneInstanceAheadFewEpochs) {
@@ -179,8 +179,8 @@ TEST_F(CoordinationUtils, MemgraphDbHistoryOneInstanceAheadFewEpochs) {
       instance.ChooseMostUpToDateInstance(instance_database_histories);
 
   ASSERT_TRUE(instance_name == "instance_3");
-  ASSERT_TRUE(latest_epoch == db_histories_longest.back().first);
-  ASSERT_TRUE(latest_commit_timestamp == db_histories_longest.back().second);
+  ASSERT_TRUE(*latest_epoch == db_histories_longest.back().first);
+  ASSERT_TRUE(*latest_commit_timestamp == db_histories_longest.back().second);
 }
 
 TEST_F(CoordinationUtils, MemgraphDbHistoryInstancesHistoryDiverged) {
@@ -241,6 +241,6 @@ TEST_F(CoordinationUtils, MemgraphDbHistoryInstancesHistoryDiverged) {
       instance.ChooseMostUpToDateInstance(instance_database_histories);
 
   ASSERT_TRUE(instance_name == "instance_3");
-  ASSERT_TRUE(latest_epoch == std::string(newest_different_epoch));
-  ASSERT_TRUE(latest_commit_timestamp == oldest_commit_timestamp);
+  ASSERT_TRUE(*latest_epoch == std::string(newest_different_epoch));
+  ASSERT_TRUE(*latest_commit_timestamp == oldest_commit_timestamp);
 }