Bugfix: Using reference in a callback

.github/workflows/release_build_test.yaml

@@ -56,15 +56,6 @@ jobs:
       - name: "Build package"
         run: |
           ./release/package/run.sh package debian-10 $BUILD_TYPE
-      - name: Upload to S3
-        uses: jakejarvis/s3-sync-action@v0.5.1
-        env:
-          AWS_S3_BUCKET: "deps.memgraph.io"
-          AWS_ACCESS_KEY_ID: ${{ secrets.S3_AWS_ACCESS_KEY_ID }}
-          AWS_SECRET_ACCESS_KEY: ${{ secrets.S3_AWS_SECRET_ACCESS_KEY }}
-          AWS_REGION: "eu-west-1"
-          SOURCE_DIR: "build/output"
-          DEST_DIR: "memgraph-unofficial/${{ github.ref_name }}/"
       - name: "Upload package"
         uses: actions/upload-artifact@v4
         with:
@@ -84,15 +75,6 @@ jobs:
       - name: "Build package"
         run: |
           ./release/package/run.sh package ubuntu-22.04 $BUILD_TYPE
-      - name: Upload to S3
-        uses: jakejarvis/s3-sync-action@v0.5.1
-        env:
-          AWS_S3_BUCKET: "deps.memgraph.io"
-          AWS_ACCESS_KEY_ID: ${{ secrets.S3_AWS_ACCESS_KEY_ID }}
-          AWS_SECRET_ACCESS_KEY: ${{ secrets.S3_AWS_SECRET_ACCESS_KEY }}
-          AWS_REGION: "eu-west-1"
-          SOURCE_DIR: "build/output"
-          DEST_DIR: "memgraph-unofficial/${{ github.ref_name }}/"
       - name: "Upload package"
         uses: actions/upload-artifact@v4
         with:
@@ -104,7 +86,7 @@ jobs:
     needs: [Ubuntu20_04]
     runs-on: [self-hosted, DockerMgBuild, ARM64]
     # M1 Mac mini is sometimes slower
-    timeout-minutes: 150
+    timeout-minutes: 90
     steps:
       - name: "Set up repository"
         uses: actions/checkout@v4
@@ -119,26 +101,6 @@ jobs:
           name: ubuntu-22.04-aarch64
           path: build/output/ubuntu-22.04-arm/memgraph*.deb
 
-  PushToS3Ubuntu20_04_ARM:
-    if: github.ref_type == 'tag'
-    needs: [PackageUbuntu20_04_ARM]
-    runs-on: ubuntu-latest
-    steps:
-      - name: Download package
-        uses: actions/download-artifact@v4
-        with:
-          name: ubuntu-22.04-aarch64
-          path: build/output/release
-      - name: Upload to S3
-        uses: jakejarvis/s3-sync-action@v0.5.1
-        env:
-          AWS_S3_BUCKET: "deps.memgraph.io"
-          AWS_ACCESS_KEY_ID: ${{ secrets.S3_AWS_ACCESS_KEY_ID }}
-          AWS_SECRET_ACCESS_KEY: ${{ secrets.S3_AWS_SECRET_ACCESS_KEY }}
-          AWS_REGION: "eu-west-1"
-          SOURCE_DIR: "build/output/release"
-          DEST_DIR: "memgraph-unofficial/${{ github.ref_name }}/"
-
   PackageDebian11:
     if: github.ref_type == 'tag'
     needs: [Debian10, Ubuntu20_04]
@@ -152,15 +114,6 @@ jobs:
       - name: "Build package"
         run: |
           ./release/package/run.sh package debian-11 $BUILD_TYPE
-      - name: Upload to S3
-        uses: jakejarvis/s3-sync-action@v0.5.1
-        env:
-          AWS_S3_BUCKET: "deps.memgraph.io"
-          AWS_ACCESS_KEY_ID: ${{ secrets.S3_AWS_ACCESS_KEY_ID }}
-          AWS_SECRET_ACCESS_KEY: ${{ secrets.S3_AWS_SECRET_ACCESS_KEY }}
-          AWS_REGION: "eu-west-1"
-          SOURCE_DIR: "build/output"
-          DEST_DIR: "memgraph-unofficial/${{ github.ref_name }}/"
       - name: "Upload package"
         uses: actions/upload-artifact@v4
         with:
@@ -172,7 +125,7 @@ jobs:
     needs: [Debian10, Ubuntu20_04]
     runs-on: [self-hosted, DockerMgBuild, ARM64]
     # M1 Mac mini is sometimes slower
-    timeout-minutes: 150
+    timeout-minutes: 90
     steps:
       - name: "Set up repository"
         uses: actions/checkout@v4
@@ -187,15 +140,16 @@ jobs:
           name: debian-11-aarch64
           path: build/output/debian-11-arm/memgraph*.deb
 
-  PushToS3Debian11_ARM:
+  PushToS3:
     if: github.ref_type == 'tag'
-    needs: [PackageDebian11_ARM]
+    needs: [PackageDebian10, PackageDebian11, PackageDebian11_ARM, PackageUbuntu20_04, PackageUbuntu20_04_ARM]
     runs-on: ubuntu-latest
     steps:
-      - name: Download package
+      - name: Download artifacts
         uses: actions/download-artifact@v4
         with:
-          name: debian-11-aarch64
+          # name: # if name input parameter is not provided, all artifacts are downloaded
+                  # and put in directories named after each one.
           path: build/output/release
       - name: Upload to S3
         uses: jakejarvis/s3-sync-action@v0.5.1

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
     #

query_modules/schema.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
@@ -9,11 +9,10 @@
 // by the Apache License, Version 2.0, included in the file
 // licenses/APL.txt.
 
-#include <boost/functional/hash.hpp>
 #include <mgp.hpp>
 #include "utils/string.hpp"
 
-#include <unordered_set>
+#include <optional>
 
 namespace Schema {
 
@@ -38,7 +37,6 @@ constexpr std::string_view kParameterIndices = "indices";
 constexpr std::string_view kParameterUniqueConstraints = "unique_constraints";
 constexpr std::string_view kParameterExistenceConstraints = "existence_constraints";
 constexpr std::string_view kParameterDropExisting = "drop_existing";
-constexpr int kInitialNumberOfPropertyOccurances = 1;
 
 std::string TypeOf(const mgp::Type &type);
 
@@ -110,79 +108,83 @@ void Schema::ProcessPropertiesRel(mgp::Record &record, const std::string_view &t
   record.Insert(std::string(kReturnMandatory).c_str(), mandatory);
 }
 
-struct PropertyInfo {
-  std::unordered_set<std::string> property_types;  // property types
-  int64_t number_of_property_occurrences = 0;
+struct Property {
+  std::string name;
+  mgp::Value value;
 
-  PropertyInfo() = default;
-  explicit PropertyInfo(std::string &&property_type)
-      : property_types({std::move(property_type)}),
-        number_of_property_occurrences(Schema::kInitialNumberOfPropertyOccurances) {}
-};
-
-struct LabelsInfo {
-  std::unordered_map<std::string, PropertyInfo> properties;  // key is a property name
-  int64_t number_of_label_occurrences = 0;
+  Property(const std::string &name, mgp::Value &&value) : name(name), value(std::move(value)) {}
 };
 
 struct LabelsHash {
-  std::size_t operator()(const std::set<std::string> &s) const { return boost::hash_range(s.begin(), s.end()); }
+  std::size_t operator()(const std::set<std::string> &set) const {
+    std::size_t seed = set.size();
+    for (const auto &i : set) {
+      seed ^= std::hash<std::string>{}(i) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+    }
+    return seed;
+  }
 };
 
 struct LabelsComparator {
   bool operator()(const std::set<std::string> &lhs, const std::set<std::string> &rhs) const { return lhs == rhs; }
 };
 
+struct PropertyComparator {
+  bool operator()(const Property &lhs, const Property &rhs) const { return lhs.name < rhs.name; }
+};
+
+struct PropertyInfo {
+  std::set<Property, PropertyComparator> properties;
+  bool mandatory;
+};
+
 void Schema::NodeTypeProperties(mgp_list * /*args*/, mgp_graph *memgraph_graph, mgp_result *result,
                                 mgp_memory *memory) {
   mgp::MemoryDispatcherGuard guard{memory};
   const auto record_factory = mgp::RecordFactory(result);
   try {
-    std::unordered_map<std::set<std::string>, LabelsInfo, LabelsHash, LabelsComparator> node_types_properties;
+    std::unordered_map<std::set<std::string>, PropertyInfo, LabelsHash, LabelsComparator> node_types_properties;
 
-    for (const auto node : mgp::Graph(memgraph_graph).Nodes()) {
+    for (auto node : mgp::Graph(memgraph_graph).Nodes()) {
       std::set<std::string> labels_set = {};
-      for (const auto label : node.Labels()) {
+      for (auto label : node.Labels()) {
         labels_set.emplace(label);
       }
 
-      node_types_properties[labels_set].number_of_label_occurrences++;
+      if (node_types_properties.find(labels_set) == node_types_properties.end()) {
+        node_types_properties[labels_set] = PropertyInfo{std::set<Property, PropertyComparator>(), true};
+      }
 
       if (node.Properties().empty()) {
+        node_types_properties[labels_set].mandatory = false;  // if there is node with no property, it is not mandatory
         continue;
       }
 
-      auto &labels_info = node_types_properties.at(labels_set);
-      for (const auto &[key, prop] : node.Properties()) {
-        auto prop_type = TypeOf(prop.Type());
-        if (labels_info.properties.find(key) == labels_info.properties.end()) {
-          labels_info.properties[key] = PropertyInfo{std::move(prop_type)};
-        } else {
-          labels_info.properties[key].property_types.emplace(prop_type);
-          labels_info.properties[key].number_of_property_occurrences++;
+      auto &property_info = node_types_properties.at(labels_set);
+      for (auto &[key, prop] : node.Properties()) {
+        property_info.properties.emplace(key, std::move(prop));
+        if (property_info.mandatory) {
+          property_info.mandatory =
+              property_info.properties.size() == 1;  // if there is only one property, it is mandatory
         }
       }
     }
 
-    for (auto &[node_type, labels_info] : node_types_properties) {  // node type is a set of labels
+    for (auto &[labels, property_info] : node_types_properties) {
       std::string label_type;
-      auto labels_list = mgp::List();
-      for (const auto &label : node_type) {
+      mgp::List labels_list = mgp::List();
+      for (auto const &label : labels) {
         label_type += ":`" + std::string(label) + "`";
         labels_list.AppendExtend(mgp::Value(label));
       }
-      for (const auto &prop : labels_info.properties) {
-        auto prop_types = mgp::List();
-        for (const auto &prop_type : prop.second.property_types) {
-          prop_types.AppendExtend(mgp::Value(prop_type));
-        }
-        bool mandatory = prop.second.number_of_property_occurrences == labels_info.number_of_label_occurrences;
+      for (auto const &prop : property_info.properties) {
         auto record = record_factory.NewRecord();
-        ProcessPropertiesNode(record, label_type, labels_list, prop.first, prop_types, mandatory);
+        ProcessPropertiesNode(record, label_type, labels_list, prop.name, TypeOf(prop.value.Type()),
+                              property_info.mandatory);
       }
-      if (labels_info.properties.empty()) {
+      if (property_info.properties.empty()) {
         auto record = record_factory.NewRecord();
-        ProcessPropertiesNode<mgp::List>(record, label_type, labels_list, "", mgp::List(), false);
+        ProcessPropertiesNode<std::string>(record, label_type, labels_list, "", "", false);
       }
     }
 
@@ -195,45 +197,40 @@ void Schema::NodeTypeProperties(mgp_list * /*args*/, mgp_graph *memgraph_graph,
 void Schema::RelTypeProperties(mgp_list * /*args*/, mgp_graph *memgraph_graph, mgp_result *result, mgp_memory *memory) {
   mgp::MemoryDispatcherGuard guard{memory};
 
-  std::unordered_map<std::string, LabelsInfo> rel_types_properties;
+  std::unordered_map<std::string, PropertyInfo> rel_types_properties;
   const auto record_factory = mgp::RecordFactory(result);
   try {
-    const auto graph = mgp::Graph(memgraph_graph);
-    for (const auto rel : graph.Relationships()) {
+    const mgp::Graph graph = mgp::Graph(memgraph_graph);
+    for (auto rel : graph.Relationships()) {
       std::string rel_type = std::string(rel.Type());
-
-      rel_types_properties[rel_type].number_of_label_occurrences++;
+      if (rel_types_properties.find(rel_type) == rel_types_properties.end()) {
+        rel_types_properties[rel_type] = PropertyInfo{std::set<Property, PropertyComparator>(), true};
+      }
 
       if (rel.Properties().empty()) {
+        rel_types_properties[rel_type].mandatory = false;  // if there is rel with no property, it is not mandatory
         continue;
       }
 
-      auto &labels_info = rel_types_properties.at(rel_type);
+      auto &property_info = rel_types_properties.at(rel_type);
       for (auto &[key, prop] : rel.Properties()) {
-        auto prop_type = TypeOf(prop.Type());
-        if (labels_info.properties.find(key) == labels_info.properties.end()) {
-          labels_info.properties[key] = PropertyInfo{std::move(prop_type)};
-        } else {
-          labels_info.properties[key].property_types.emplace(prop_type);
-          labels_info.properties[key].number_of_property_occurrences++;
+        property_info.properties.emplace(key, std::move(prop));
+        if (property_info.mandatory) {
+          property_info.mandatory =
+              property_info.properties.size() == 1;  // if there is only one property, it is mandatory
         }
       }
     }
 
-    for (auto &[rel_type, labels_info] : rel_types_properties) {
-      std::string type_str = ":`" + std::string(rel_type) + "`";
-      for (const auto &prop : labels_info.properties) {
-        auto prop_types = mgp::List();
-        for (const auto &prop_type : prop.second.property_types) {
-          prop_types.AppendExtend(mgp::Value(prop_type));
-        }
-        bool mandatory = prop.second.number_of_property_occurrences == labels_info.number_of_label_occurrences;
+    for (auto &[type, property_info] : rel_types_properties) {
+      std::string type_str = ":`" + std::string(type) + "`";
+      for (auto const &prop : property_info.properties) {
         auto record = record_factory.NewRecord();
-        ProcessPropertiesRel(record, type_str, prop.first, prop_types, mandatory);
+        ProcessPropertiesRel(record, type_str, prop.name, TypeOf(prop.value.Type()), property_info.mandatory);
       }
-      if (labels_info.properties.empty()) {
+      if (property_info.properties.empty()) {
         auto record = record_factory.NewRecord();
-        ProcessPropertiesRel<mgp::List>(record, type_str, "", mgp::List(), false);
+        ProcessPropertiesRel<std::string>(record, type_str, "", "", false);
       }
     }
 

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

@@ -16,7 +16,6 @@
 
 #include "coordination/coordinator_config.hpp"
 #include "coordination/coordinator_rpc.hpp"
-#include "replication_coordination_glue/common.hpp"
 #include "replication_coordination_glue/messages.hpp"
 #include "utils/result.hpp"
 
@@ -31,7 +30,7 @@ auto CreateClientContext(memgraph::coordination::CoordinatorClientConfig const &
 }  // namespace
 
 CoordinatorClient::CoordinatorClient(CoordinatorInstance *coord_instance, CoordinatorClientConfig config,
-                                     HealthCheckClientCallback succ_cb, HealthCheckClientCallback fail_cb)
+                                     HealthCheckCallback succ_cb, HealthCheckCallback fail_cb)
     : rpc_context_{CreateClientContext(config)},
       rpc_client_{io::network::Endpoint(io::network::Endpoint::needs_resolving, config.ip_address, config.port),
                   &rpc_context_},
@@ -41,9 +40,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,15 +63,11 @@ 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();
           }
-          // Subtle race condition:
-          // acquiring of lock needs to happen before function call, as function callback can be changed
-          // for instance after lock is already acquired
-          // (failover case when instance is promoted to MAIN)
           succ_cb_(coord_instance_, instance_name);
         } catch (rpc::RpcFailedException const &) {
           fail_cb_(coord_instance_, instance_name);
@@ -86,6 +79,11 @@ void CoordinatorClient::StopFrequentCheck() { instance_checker_.Stop(); }
 void CoordinatorClient::PauseFrequentCheck() { instance_checker_.Pause(); }
 void CoordinatorClient::ResumeFrequentCheck() { instance_checker_.Resume(); }
 
+auto CoordinatorClient::SetCallbacks(HealthCheckCallback succ_cb, HealthCheckCallback fail_cb) -> void {
+  succ_cb_ = std::move(succ_cb);
+  fail_cb_ = std::move(fail_cb);
+}
+
 auto CoordinatorClient::ReplicationClientInfo() const -> ReplClientInfo { return config_.replication_client_info; }
 
 auto CoordinatorClient::SendPromoteReplicaToMainRpc(const utils::UUID &uuid,
@@ -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;
@@ -174,17 +171,5 @@ auto CoordinatorClient::SendEnableWritingOnMainRpc() const -> bool {
   return false;
 }
 
-auto CoordinatorClient::SendGetInstanceTimestampsRpc() const
-    -> utils::BasicResult<GetInstanceUUIDError, replication_coordination_glue::DatabaseHistories> {
-  try {
-    auto stream{rpc_client_.Stream<coordination::GetDatabaseHistoriesRpc>()};
-    return stream.AwaitResponse().database_histories;
-
-  } catch (const rpc::RpcFailedException &) {
-    spdlog::error("RPC error occured while sending GetInstance UUID RPC");
-    return GetInstanceUUIDError::RPC_EXCEPTION;
-  }
-}
-
 }  // namespace memgraph::coordination
 #endif

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

@@ -57,17 +57,6 @@ void CoordinatorHandlers::Register(memgraph::coordination::CoordinatorServer &se
         spdlog::info("Received GetInstanceUUIDRpc on coordinator server");
         CoordinatorHandlers::GetInstanceUUIDHandler(replication_handler, req_reader, res_builder);
       });
-
-  server.Register<coordination::GetDatabaseHistoriesRpc>(
-      [&replication_handler](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
-        spdlog::info("Received GetDatabasesHistoryRpc on coordinator server");
-        CoordinatorHandlers::GetDatabaseHistoriesHandler(replication_handler, req_reader, res_builder);
-      });
-}
-
-void CoordinatorHandlers::GetDatabaseHistoriesHandler(replication::ReplicationHandler &replication_handler,
-                                                      slk::Reader * /*req_reader*/, slk::Builder *res_builder) {
-  slk::Save(coordination::GetDatabaseHistoriesRes{replication_handler.GetDatabasesHistories()}, res_builder);
 }
 
 void CoordinatorHandlers::SwapMainUUIDHandler(replication::ReplicationHandler &replication_handler,
@@ -140,7 +129,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

@@ -15,12 +15,10 @@
 
 #include "coordination/coordinator_exceptions.hpp"
 #include "coordination/fmt.hpp"
-#include "dbms/constants.hpp"
 #include "nuraft/coordinator_state_machine.hpp"
 #include "nuraft/coordinator_state_manager.hpp"
 #include "utils/counter.hpp"
 #include "utils/functional.hpp"
-#include "utils/resource_lock.hpp"
 
 #include <range/v3/view.hpp>
 #include <shared_mutex>
@@ -32,182 +30,144 @@ 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;
-                            });
+          [this] { std::ranges::for_each(repl_instances_, &ReplicationInstance::StartFrequentCheck); },
+          [this] { std::ranges::for_each(repl_instances_, &ReplicationInstance::StopFrequentCheck); })) {
+  auto find_repl_instance = [](CoordinatorInstance *self,
+                               std::string_view repl_instance_name) -> ReplicationInstance & {
+    auto repl_instance =
+        std::ranges::find_if(self->repl_instances_, [repl_instance_name](ReplicationInstance const &instance) {
+          return instance.InstanceName() == repl_instance_name;
+        });
 
-            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(); });
-            });
-          })) {
-  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 &repl_instance = self->FindReplicationInstance(repl_instance_name);
-    std::invoke(repl_instance.GetSuccessCallback(), self, repl_instance_name);
+    MG_ASSERT(repl_instance != self->repl_instances_.end(), "Instance {} not found during callback!",
+              repl_instance_name);
+    return *repl_instance;
   };
 
-  client_fail_cb_ = [](CoordinatorInstance *self, std::string_view repl_instance_name) -> void {
-    if (!self->is_running_) {
-      return;
-    }
+  replica_succ_cb_ = [find_repl_instance](CoordinatorInstance *self, std::string_view repl_instance_name) -> void {
     auto lock = std::lock_guard{self->coord_instance_lock_};
-    auto &repl_instance = self->FindReplicationInstance(repl_instance_name);
-    std::invoke(repl_instance.GetFailCallback(), self, repl_instance_name);
+    spdlog::trace("Instance {} performing replica successful callback", repl_instance_name);
+    auto &repl_instance = find_repl_instance(self, 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(self->GetMainUUID())) {
+      spdlog::error("Failed to swap uuid for replica instance {} which is alive", repl_instance.InstanceName());
+      return;
+    }
+
+    repl_instance.OnSuccessPing();
   };
-}
 
-auto CoordinatorInstance::FindReplicationInstance(std::string_view replication_instance_name) -> ReplicationInstance & {
-  auto repl_instance =
-      std::ranges::find_if(repl_instances_, [replication_instance_name](ReplicationInstance const &instance) {
-        return instance.InstanceName() == replication_instance_name;
-      });
+  replica_fail_cb_ = [find_repl_instance](CoordinatorInstance *self, std::string_view repl_instance_name) -> void {
+    auto lock = std::lock_guard{self->coord_instance_lock_};
+    spdlog::trace("Instance {} performing replica failure callback", repl_instance_name);
+    auto &repl_instance = find_repl_instance(self, repl_instance_name);
+    repl_instance.OnFailPing();
+  };
 
-  MG_ASSERT(repl_instance != repl_instances_.end(), "Instance {} not found during callback!",
-            replication_instance_name);
-  return *repl_instance;
+  main_succ_cb_ = [find_repl_instance](CoordinatorInstance *self, std::string_view repl_instance_name) -> void {
+    auto lock = std::lock_guard{self->coord_instance_lock_};
+    spdlog::trace("Instance {} performing main successful callback", repl_instance_name);
+
+    auto &repl_instance = find_repl_instance(self, repl_instance_name);
+
+    if (repl_instance.IsAlive()) {
+      repl_instance.OnSuccessPing();
+      return;
+    }
+
+    const auto &repl_instance_uuid = repl_instance.GetMainUUID();
+    MG_ASSERT(repl_instance_uuid.has_value(), "Instance must have uuid set.");
+
+    auto const curr_main_uuid = self->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;
+      }
+
+      repl_instance.OnSuccessPing();
+      return;
+    }
+
+    // TODO(antoniof) make demoteToReplica idempotent since main can be demoted to replica but
+    // swapUUID can fail
+    if (repl_instance.DemoteToReplica(self->replica_succ_cb_, self->replica_fail_cb_)) {
+      repl_instance.OnSuccessPing();
+      spdlog::info("Instance {} demoted to replica", repl_instance_name);
+    } else {
+      spdlog::error("Instance {} failed to become replica", repl_instance_name);
+      return;
+    }
+
+    if (!repl_instance.SendSwapAndUpdateUUID(curr_main_uuid)) {
+      spdlog::error(fmt::format("Failed to swap uuid for demoted main instance {}", repl_instance.InstanceName()));
+      return;
+    }
+  };
+
+  main_fail_cb_ = [find_repl_instance](CoordinatorInstance *self, std::string_view repl_instance_name) -> void {
+    auto lock = std::lock_guard{self->coord_instance_lock_};
+    spdlog::trace("Instance {} performing main failure callback", repl_instance_name);
+    auto &repl_instance = find_repl_instance(self, repl_instance_name);
+    repl_instance.OnFailPing();
+    const auto &repl_instance_uuid = repl_instance.GetMainUUID();
+    MG_ASSERT(repl_instance_uuid.has_value(), "Instance must have uuid set");
+
+    if (!repl_instance.IsAlive() && self->GetMainUUID() == repl_instance_uuid.value()) {
+      spdlog::info("Cluster without main instance, trying automatic failover");
+      self->TryFailover();  // TODO: (andi) Initiate failover
+    }
+  };
 }
 
 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;
-  }
-
-  auto const get_ts = [](ReplicationInstance &replica) { return replica.GetClient().SendGetInstanceTimestampsRpc(); };
-
-  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)) {
-    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);
-
-  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
-
-  auto *new_main = &FindReplicationInstance(most_up_to_date_instance);
+  // TODO: Smarter choice
+  auto new_main = ranges::begin(alive_replicas);
 
   new_main->PauseFrequentCheck();
   utils::OnScopeExit scope_exit{[&new_main] { new_main->ResumeFrequentCheck(); }};
@@ -217,74 +177,41 @@ 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>();
 
-  if (!new_main->PromoteToMain(new_main_uuid, std::move(repl_clients_info), &CoordinatorInstance::MainSuccessCallback,
-                               &CoordinatorInstance::MainFailCallback)) {
+  if (!new_main->PromoteToMain(new_main_uuid, std::move(repl_clients_info), main_succ_cb_, main_fail_cb_)) {
     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,98 +229,85 @@ 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)) {
+  if (!new_main->PromoteToMain(new_main_uuid, std::move(repl_clients_info), main_succ_cb_, main_fail_cb_)) {
     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;
-      })) {
+  auto instance_name = config.instance_name;
+
+  auto const name_matches = [&instance_name](ReplicationInstance const &instance) {
+    return instance.InstanceName() == instance_name;
+  };
+
+  if (std::ranges::any_of(repl_instances_, name_matches)) {
     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;
-  }
+  auto const socket_address_matches = [&config](ReplicationInstance const &instance) {
+    return instance.SocketAddress() == config.SocketAddress();
+  };
 
-  if (std::ranges::any_of(repl_instances_, [&config](ReplicationInstance const &instance) {
-        return instance.ReplicationSocketAddress() == config.ReplicationSocketAddress();
-      })) {
-    return RegisterInstanceCoordinatorStatus::REPL_ENDPOINT_EXISTS;
+  if (std::ranges::any_of(repl_instances_, socket_address_matches)) {
+    return RegisterInstanceCoordinatorStatus::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);
+  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;
+  }
 
-  if (!new_instance->SendDemoteToReplicaRpc()) {
-    spdlog::error("Failed to send demote to replica rpc for instance {}", config.instance_name);
-    repl_instances_.pop_back();
+  spdlog::info("Request for registering instance {} accepted", instance_name);
+  try {
+    repl_instances_.emplace_back(this, std::move(config), replica_succ_cb_, replica_fail_cb_);
+  } catch (CoordinatorRegisterInstanceException const &) {
     return RegisterInstanceCoordinatorStatus::RPC_FAILED;
   }
 
-  if (!raft_state_.AppendRegisterReplicationInstanceLog(config)) {
-    return RegisterInstanceCoordinatorStatus::RAFT_LOG_ERROR;
+  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;
   }
 
-  new_instance->StartFrequentCheck();
-
-  spdlog::info("Instance {} registered", config.instance_name);
+  spdlog::info("Instance {} registered", instance_name);
   return RegisterInstanceCoordinatorStatus::SUCCESS;
 }
 
-auto CoordinatorInstance::UnregisterReplicationInstance(std::string_view instance_name)
+auto CoordinatorInstance::UnregisterReplicationInstance(std::string 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 const name_matches = [&instance_name](ReplicationInstance const &instance) {
     return instance.InstanceName() == instance_name;
   };
@@ -403,220 +317,31 @@ auto CoordinatorInstance::UnregisterReplicationInstance(std::string_view instanc
     return UnregisterInstanceCoordinatorStatus::NO_INSTANCE_WITH_NAME;
   }
 
-  // TODO: (andi) Change so that RaftLogState is the central place for asking who is main...
-
-  auto const is_main = [this](ReplicationInstance const &instance) { return IsMain(instance.InstanceName()); };
-
-  if (is_main(*inst_to_remove) && inst_to_remove->IsAlive()) {
+  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_, 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;
-    }
+  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);
 
-  if (!raft_state_.AppendUnregisterReplicationInstanceLog(instance_name)) {
-    return UnregisterInstanceCoordinatorStatus::RAFT_LOG_ERROR;
-  }
-
   return UnregisterInstanceCoordinatorStatus::SUCCESS;
 }
 
-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);
+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));
 }
 
-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");
+auto CoordinatorInstance::GetMainUUID() const -> utils::UUID { return main_uuid_; }
 
-  // NOLINTNEXTLINE
-  if (!repl_instance.IsAlive() && raft_state_.GetUUID() == 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);
-
-  if (repl_instance.IsAlive()) {
-    repl_instance.OnSuccessPing();
-    return;
-  }
-
-  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()) {
-    if (!repl_instance.EnableWritingOnMain()) {
-      spdlog::error("Failed to enable writing on main instance {}", repl_instance_name);
-      return;
-    }
-
-    repl_instance.OnSuccessPing();
-    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();
-    spdlog::info("Instance {} demoted to replica", repl_instance_name);
-  } else {
-    spdlog::error("Instance {} failed to become replica", repl_instance_name);
-    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)) {
-    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)) {
-    spdlog::error("Aborting replica callback since instance {} is not replica anymore", repl_instance_name);
-    return;
-  }
-  // 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())) {
-    spdlog::error("Failed to swap uuid for replica instance {} which is alive", repl_instance.InstanceName());
-    return;
-  }
-
-  repl_instance.OnSuccessPing();
-}
-
-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)) {
-    spdlog::error("Aborting replica fail callback since instance {} is not replica anymore", repl_instance_name);
-    return;
-  }
-
-  repl_instance.OnFailPing();
-}
-
-auto CoordinatorInstance::ChooseMostUpToDateInstance(std::span<InstanceNameDbHistories> instance_database_histories)
-    -> NewMainRes {
-  std::optional<NewMainRes> new_main_res;
-  std::for_each(
-      instance_database_histories.begin(), instance_database_histories.end(),
-      [&new_main_res](const InstanceNameDbHistories &instance_res_pair) {
-        const auto &[instance_name, instance_db_histories] = instance_res_pair;
-
-        // Find default db for instance and its history
-        auto default_db_history_data = std::ranges::find_if(
-            instance_db_histories, [default_db = memgraph::dbms::kDefaultDB](
-                                       const replication_coordination_glue::DatabaseHistory &db_timestamps) {
-              return db_timestamps.name == default_db;
-            });
-
-        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,
-                            memgraph::dbms::kDefaultDB);
-            });
-
-        MG_ASSERT(default_db_history_data != instance_db_histories.end(), "No history for instance");
-
-        const auto &instance_default_db_history = default_db_history_data->history;
-
-        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,
-                                              std::get<0>(epoch_history_it), std::get<1>(epoch_history_it));
-                              });
-
-        // get latest epoch
-        // get latest timestamp
-
-        if (!new_main_res) {
-          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",
-                        instance_name, epoch, timestamp);
-          return;
-        }
-
-        bool found_same_point{false};
-        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});
-            spdlog::trace("Found the new most up to date instance {} with epoch {} and {} latest commit timestamp",
-                          instance_name, epoch, timestamp);
-          }
-
-          // we found point at which they were same
-          if (epoch == last_most_up_to_date_epoch) {
-            found_same_point = true;
-            break;
-          }
-        }
-
-        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);
-        }
-      });
-
-  return std::move(*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);
-}
+// TODO: (andi) Add to the RAFT log.
+auto CoordinatorInstance::SetMainUUID(utils::UUID new_uuid) -> void { main_uuid_ = new_uuid; }
 
 }  // namespace memgraph::coordination
 #endif

src/coordination/coordinator_rpc.cpp

@@ -76,9 +76,9 @@ void EnableWritingOnMainRes::Load(EnableWritingOnMainRes *self, memgraph::slk::R
   memgraph::slk::Load(self, reader);
 }
 
-void EnableWritingOnMainReq::Save(EnableWritingOnMainReq const & /*self*/, memgraph::slk::Builder * /*builder*/) {}
+void EnableWritingOnMainReq::Save(EnableWritingOnMainReq const &self, memgraph::slk::Builder *builder) {}
 
-void EnableWritingOnMainReq::Load(EnableWritingOnMainReq * /*self*/, memgraph::slk::Reader * /*reader*/) {}
+void EnableWritingOnMainReq::Load(EnableWritingOnMainReq *self, memgraph::slk::Reader *reader) {}
 
 // GetInstanceUUID
 void GetInstanceUUIDReq::Save(const GetInstanceUUIDReq &self, memgraph::slk::Builder *builder) {
@@ -97,24 +97,6 @@ void GetInstanceUUIDRes::Load(GetInstanceUUIDRes *self, memgraph::slk::Reader *r
   memgraph::slk::Load(self, reader);
 }
 
-// GetDatabaseHistoriesRpc
-
-void GetDatabaseHistoriesReq::Save(const GetDatabaseHistoriesReq & /*self*/, memgraph::slk::Builder * /*builder*/) {
-  /* nothing to serialize */
-}
-
-void GetDatabaseHistoriesReq::Load(GetDatabaseHistoriesReq * /*self*/, memgraph::slk::Reader * /*reader*/) {
-  /* nothing to serialize */
-}
-
-void GetDatabaseHistoriesRes::Save(const GetDatabaseHistoriesRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-
-void GetDatabaseHistoriesRes::Load(GetDatabaseHistoriesRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-
 }  // namespace coordination
 
 constexpr utils::TypeInfo coordination::PromoteReplicaToMainReq::kType{utils::TypeId::COORD_FAILOVER_REQ,
@@ -148,12 +130,6 @@ constexpr utils::TypeInfo coordination::GetInstanceUUIDReq::kType{utils::TypeId:
 constexpr utils::TypeInfo coordination::GetInstanceUUIDRes::kType{utils::TypeId::COORD_GET_UUID_RES, "CoordGetUUIDRes",
                                                                   nullptr};
 
-constexpr utils::TypeInfo coordination::GetDatabaseHistoriesReq::kType{utils::TypeId::COORD_GET_INSTANCE_DATABASES_REQ,
-                                                                       "GetInstanceDatabasesReq", nullptr};
-
-constexpr utils::TypeInfo coordination::GetDatabaseHistoriesRes::kType{utils::TypeId::COORD_GET_INSTANCE_DATABASES_RES,
-                                                                       "GetInstanceDatabasesRes", nullptr};
-
 namespace slk {
 
 // PromoteReplicaToMainRpc
@@ -237,16 +213,6 @@ void Load(memgraph::coordination::GetInstanceUUIDRes *self, memgraph::slk::Reade
   memgraph::slk::Load(&self->uuid, reader);
 }
 
-// GetInstanceTimestampsReq
-
-void Save(const memgraph::coordination::GetDatabaseHistoriesRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.database_histories, builder);
-}
-
-void Load(memgraph::coordination::GetDatabaseHistoriesRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->database_histories, reader);
-}
-
 }  // namespace slk
 
 }  // namespace memgraph

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

@@ -14,7 +14,6 @@
 #ifdef MG_ENTERPRISE
 
 #include "coordination/coordinator_config.hpp"
-#include "replication_coordination_glue/common.hpp"
 #include "rpc/client.hpp"
 #include "rpc_errors.hpp"
 #include "utils/result.hpp"
@@ -24,13 +23,13 @@
 namespace memgraph::coordination {
 
 class CoordinatorInstance;
-using HealthCheckClientCallback = std::function<void(CoordinatorInstance *, std::string_view)>;
+using HealthCheckCallback = std::function<void(CoordinatorInstance *, std::string_view)>;
 using ReplicationClientsInfo = std::vector<ReplClientInfo>;
 
 class CoordinatorClient {
  public:
   explicit CoordinatorClient(CoordinatorInstance *coord_instance, CoordinatorClientConfig config,
-                             HealthCheckClientCallback succ_cb, HealthCheckClientCallback fail_cb);
+                             HealthCheckCallback succ_cb, HealthCheckCallback fail_cb);
 
   ~CoordinatorClient() = default;
 
@@ -46,17 +45,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;
 
@@ -64,8 +62,7 @@ class CoordinatorClient {
 
   auto ReplicationClientInfo() const -> ReplClientInfo;
 
-  auto SendGetInstanceTimestampsRpc() const
-      -> utils::BasicResult<GetInstanceUUIDError, replication_coordination_glue::DatabaseHistories>;
+  auto SetCallbacks(HealthCheckCallback succ_cb, HealthCheckCallback fail_cb) -> void;
 
   auto RpcClient() -> rpc::Client & { return rpc_client_; }
 
@@ -85,8 +82,8 @@ class CoordinatorClient {
 
   CoordinatorClientConfig config_;
   CoordinatorInstance *coord_instance_;
-  HealthCheckClientCallback succ_cb_;
-  HealthCheckClientCallback fail_cb_;
+  HealthCheckCallback succ_cb_;
+  HealthCheckCallback fail_cb_;
 };
 
 }  // namespace memgraph::coordination

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_handlers.hpp

@@ -41,9 +41,6 @@ class CoordinatorHandlers {
 
   static void GetInstanceUUIDHandler(replication::ReplicationHandler &replication_handler, slk::Reader *req_reader,
                                      slk::Builder *res_builder);
-
-  static void GetDatabaseHistoriesHandler(replication::ReplicationHandler &replication_handler, slk::Reader *req_reader,
-                                          slk::Builder *res_builder);
 };
 
 }  // namespace memgraph::dbms

src/coordination/include/coordination/coordinator_instance.hpp

@@ -18,7 +18,6 @@
 #include "coordination/raft_state.hpp"
 #include "coordination/register_main_replica_coordinator_status.hpp"
 #include "coordination/replication_instance.hpp"
-#include "utils/resource_lock.hpp"
 #include "utils/rw_lock.hpp"
 #include "utils/thread_pool.hpp"
 
@@ -26,54 +25,33 @@
 
 namespace memgraph::coordination {
 
-struct NewMainRes {
-  std::string most_up_to_date_instance;
-  std::string latest_epoch;
-  uint64_t latest_commit_timestamp;
-};
-using InstanceNameDbHistories = std::pair<std::string, replication_coordination_glue::DatabaseHistories>;
-
 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;
+
+  auto SetMainUUID(utils::UUID new_uuid) -> void;
 
  private:
-  HealthCheckClientCallback client_succ_cb_, client_fail_cb_;
+  HealthCheckCallback main_succ_cb_, main_fail_cb_, replica_succ_cb_, replica_fail_cb_;
 
-  auto OnRaftCommitCallback(TRaftLog const &log_entry, RaftLogAction log_action) -> void;
-
-  auto FindReplicationInstance(std::string_view replication_instance_name) -> ReplicationInstance &;
-
-  void MainFailCallback(std::string_view);
-
-  void MainSuccessCallback(std::string_view);
-
-  void ReplicaSuccessCallback(std::string_view);
-
-  void ReplicaFailCallback(std::string_view);
-
-  auto IsMain(std::string_view instance_name) const -> bool;
-  auto IsReplica(std::string_view instance_name) const -> bool;
-
-  // NOTE: Must be std::list because we rely on pointer stability.
-  // Leader and followers should both have same view on repl_instances_
+  // NOTE: Must be std::list because we rely on pointer stability
   std::list<ReplicationInstance> repl_instances_;
-  mutable utils::ResourceLock coord_instance_lock_{};
+  mutable utils::RWLock coord_instance_lock_{utils::RWLock::Priority::READ};
+
+  utils::UUID main_uuid_;
 
   RaftState raft_state_;
 };

src/coordination/include/coordination/coordinator_rpc.hpp

@@ -15,7 +15,6 @@
 #ifdef MG_ENTERPRISE
 
 #include "coordination/coordinator_config.hpp"
-#include "replication_coordination_glue/common.hpp"
 #include "rpc/messages.hpp"
 #include "slk/serialization.hpp"
 
@@ -162,32 +161,6 @@ struct GetInstanceUUIDRes {
 
 using GetInstanceUUIDRpc = rpc::RequestResponse<GetInstanceUUIDReq, GetInstanceUUIDRes>;
 
-struct GetDatabaseHistoriesReq {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(GetDatabaseHistoriesReq *self, memgraph::slk::Reader *reader);
-  static void Save(const GetDatabaseHistoriesReq &self, memgraph::slk::Builder *builder);
-
-  GetDatabaseHistoriesReq() = default;
-};
-
-struct GetDatabaseHistoriesRes {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(GetDatabaseHistoriesRes *self, memgraph::slk::Reader *reader);
-  static void Save(const GetDatabaseHistoriesRes &self, memgraph::slk::Builder *builder);
-
-  explicit GetDatabaseHistoriesRes(const replication_coordination_glue::DatabaseHistories &database_histories)
-      : database_histories(database_histories) {}
-  GetDatabaseHistoriesRes() = default;
-
-  replication_coordination_glue::DatabaseHistories database_histories;
-};
-
-using GetDatabaseHistoriesRpc = rpc::RequestResponse<GetDatabaseHistoriesReq, GetDatabaseHistoriesRes>;
-
 }  // namespace memgraph::coordination
 
 // SLK serialization declarations
@@ -210,21 +183,15 @@ void Save(const memgraph::coordination::GetInstanceUUIDReq &self, memgraph::slk:
 void Load(memgraph::coordination::GetInstanceUUIDReq *self, memgraph::slk::Reader *reader);
 void Save(const memgraph::coordination::GetInstanceUUIDRes &self, memgraph::slk::Builder *builder);
 void Load(memgraph::coordination::GetInstanceUUIDRes *self, memgraph::slk::Reader *reader);
-
 // UnregisterReplicaRpc
 void Save(memgraph::coordination::UnregisterReplicaRes const &self, memgraph::slk::Builder *builder);
 void Load(memgraph::coordination::UnregisterReplicaRes *self, memgraph::slk::Reader *reader);
 void Save(memgraph::coordination::UnregisterReplicaReq const &self, memgraph::slk::Builder *builder);
 void Load(memgraph::coordination::UnregisterReplicaReq *self, memgraph::slk::Reader *reader);
 
-// EnableWritingOnMainRpc
 void Save(memgraph::coordination::EnableWritingOnMainRes const &self, memgraph::slk::Builder *builder);
 void Load(memgraph::coordination::EnableWritingOnMainRes *self, memgraph::slk::Reader *reader);
 
-// GetDatabaseHistoriesRpc
-void Save(const memgraph::coordination::GetDatabaseHistoriesRes &self, memgraph::slk::Builder *builder);
-void Load(memgraph::coordination::GetDatabaseHistoriesRes *self, memgraph::slk::Reader *reader);
-
 }  // namespace memgraph::slk
 
 #endif

src/coordination/include/coordination/coordinator_slk.hpp

@@ -14,7 +14,6 @@
 #ifdef MG_ENTERPRISE
 
 #include "coordination/coordinator_config.hpp"
-#include "replication_coordination_glue/common.hpp"
 #include "slk/serialization.hpp"
 #include "slk/streams.hpp"
 
@@ -35,18 +34,5 @@ inline void Load(ReplicationClientInfo *obj, Reader *reader) {
   Load(&obj->replication_ip_address, reader);
   Load(&obj->replication_port, reader);
 }
-
-inline void Save(const replication_coordination_glue::DatabaseHistory &obj, Builder *builder) {
-  Save(obj.db_uuid, builder);
-  Save(obj.history, builder);
-  Save(obj.name, builder);
-}
-
-inline void Load(replication_coordination_glue::DatabaseHistory *obj, Reader *reader) {
-  Load(&obj->db_uuid, reader);
-  Load(&obj->history, reader);
-  Load(&obj->name, reader);
-}
-
 }  // namespace memgraph::slk
 #endif

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,24 +17,18 @@
 #include "coordination/coordinator_exceptions.hpp"
 #include "replication_coordination_glue/role.hpp"
 
-#include "utils/resource_lock.hpp"
+#include <libnuraft/nuraft.hxx>
 #include "utils/result.hpp"
 #include "utils/uuid.hpp"
 
-#include <libnuraft/nuraft.hxx>
-
 namespace memgraph::coordination {
 
 class CoordinatorInstance;
-class ReplicationInstance;
-
-using HealthCheckInstanceCallback = void (CoordinatorInstance::*)(std::string_view);
 
 class ReplicationInstance {
  public:
-  ReplicationInstance(CoordinatorInstance *peer, CoordinatorClientConfig config, HealthCheckClientCallback succ_cb,
-                      HealthCheckClientCallback fail_cb, HealthCheckInstanceCallback succ_instance_cb,
-                      HealthCheckInstanceCallback fail_instance_cb);
+  ReplicationInstance(CoordinatorInstance *peer, CoordinatorClientConfig config, HealthCheckCallback succ_cb,
+                      HealthCheckCallback fail_cb);
 
   ReplicationInstance(ReplicationInstance const &other) = delete;
   ReplicationInstance &operator=(ReplicationInstance const &other) = delete;
@@ -51,16 +45,14 @@ 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,
-                     HealthCheckInstanceCallback main_succ_cb, HealthCheckInstanceCallback main_fail_cb) -> bool;
+  auto IsReplica() const -> bool;
+  auto IsMain() const -> bool;
 
-  auto SendDemoteToReplicaRpc() -> bool;
-
-  auto DemoteToReplica(HealthCheckInstanceCallback replica_succ_cb, HealthCheckInstanceCallback replica_fail_cb)
-      -> bool;
+  auto PromoteToMain(utils::UUID uuid, ReplicationClientsInfo repl_clients_info, HealthCheckCallback main_succ_cb,
+                     HealthCheckCallback main_fail_cb) -> bool;
+  auto DemoteToReplica(HealthCheckCallback replica_succ_cb, HealthCheckCallback replica_fail_cb) -> bool;
 
   auto StartFrequentCheck() -> void;
   auto StopFrequentCheck() -> void;
@@ -71,8 +63,9 @@ 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 &;
@@ -81,13 +74,11 @@ class ReplicationInstance {
 
   auto SetNewMainUUID(utils::UUID const &main_uuid) -> void;
   auto ResetMainUUID() -> void;
-  auto GetMainUUID() const -> std::optional<utils::UUID> const &;
-
-  auto GetSuccessCallback() -> HealthCheckInstanceCallback &;
-  auto GetFailCallback() -> HealthCheckInstanceCallback &;
+  auto GetMainUUID() const -> const std::optional<utils::UUID> &;
 
  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_{};
@@ -99,12 +90,8 @@ class ReplicationInstance {
   // so we need to send swap uuid again
   std::optional<utils::UUID> main_uuid_;
 
-  HealthCheckInstanceCallback succ_cb_;
-  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/coordination/rpc_errors.hpp

@@ -11,5 +11,4 @@
 
 namespace memgraph::coordination {
 enum class GetInstanceUUIDError { NO_RESPONSE, RPC_EXCEPTION };
-enum class GetInstanceTimestampsError { NO_RESPONSE, RPC_EXCEPTION };
 }  // namespace memgraph::coordination

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

@@ -13,20 +13,21 @@
 
 #include "coordination/replication_instance.hpp"
 
-#include <utility>
-
 #include "replication_coordination_glue/handler.hpp"
 #include "utils/result.hpp"
 
 namespace memgraph::coordination {
 
 ReplicationInstance::ReplicationInstance(CoordinatorInstance *peer, CoordinatorClientConfig config,
-                                         HealthCheckClientCallback succ_cb, HealthCheckClientCallback fail_cb,
-                                         HealthCheckInstanceCallback succ_instance_cb,
-                                         HealthCheckInstanceCallback fail_instance_cb)
+                                         HealthCheckCallback succ_cb, HealthCheckCallback fail_cb)
     : client_(peer, std::move(config), std::move(succ_cb), std::move(fail_cb)),
-      succ_cb_(succ_instance_cb),
-      fail_cb_(fail_instance_cb) {}
+      replication_role_(replication_coordination_glue::ReplicationRole::REPLICA) {
+  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,34 +46,37 @@ 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,
-                                        HealthCheckInstanceCallback main_succ_cb,
-                                        HealthCheckInstanceCallback main_fail_cb) -> bool {
+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,
+                                        HealthCheckCallback main_succ_cb, HealthCheckCallback 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;
+  client_.SetCallbacks(std::move(main_succ_cb), std::move(main_fail_cb));
 
   return true;
 }
 
-auto ReplicationInstance::SendDemoteToReplicaRpc() -> bool { return client_.DemoteToReplica(); }
-
-auto ReplicationInstance::DemoteToReplica(HealthCheckInstanceCallback replica_succ_cb,
-                                          HealthCheckInstanceCallback replica_fail_cb) -> bool {
+auto ReplicationInstance::DemoteToReplica(HealthCheckCallback replica_succ_cb, HealthCheckCallback replica_fail_cb)
+    -> bool {
   if (!client_.DemoteToReplica()) {
     return false;
   }
 
-  succ_cb_ = replica_succ_cb;
-  fail_cb_ = replica_fail_cb;
+  replication_role_ = replication_coordination_glue::ReplicationRole::REPLICA;
+  client_.SetCallbacks(std::move(replica_succ_cb), std::move(replica_fail_cb));
 
   return true;
 }
@@ -86,12 +90,10 @@ auto ReplicationInstance::ReplicationClientInfo() const -> CoordinatorClientConf
   return client_.ReplicationClientInfo();
 }
 
-auto ReplicationInstance::GetSuccessCallback() -> HealthCheckInstanceCallback & { return succ_cb_; }
-auto ReplicationInstance::GetFailCallback() -> HealthCheckInstanceCallback & { return fail_cb_; }
-
 auto ReplicationInstance::GetClient() -> CoordinatorClient & { return client_; }
 
 auto ReplicationInstance::SetNewMainUUID(utils::UUID const &main_uuid) -> void { main_uuid_ = main_uuid; }
+auto ReplicationInstance::ResetMainUUID() -> void { main_uuid_ = std::nullopt; }
 auto ReplicationInstance::GetMainUUID() const -> std::optional<utils::UUID> const & { return main_uuid_; }
 
 auto ReplicationInstance::EnsureReplicaHasCorrectMainUUID(utils::UUID const &curr_main_uuid) -> bool {
@@ -104,7 +106,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 +113,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 +121,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
@@ -272,6 +266,10 @@ class DbmsHandler {
   bool IsMain() const { return repl_state_.IsMain(); }
   bool IsReplica() const { return repl_state_.IsReplica(); }
 
+#ifdef MG_ENTERPRISE
+  // coordination::CoordinatorState &CoordinatorState() { return coordinator_state_; }
+#endif
+
   /**
    * @brief Return all active databases.
    *

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/memory/global_memory_control.cpp

@@ -122,11 +122,11 @@ static bool my_commit(extent_hooks_t *extent_hooks, void *addr, size_t size, siz
 
   [[maybe_unused]] auto blocker = memgraph::utils::MemoryTracker::OutOfMemoryExceptionBlocker{};
   if (GetQueriesMemoryControl().IsThreadTracked()) [[unlikely]] {
-    [[maybe_unused]] bool ok = GetQueriesMemoryControl().TrackAllocOnCurrentThread(length);
+    bool ok = GetQueriesMemoryControl().TrackAllocOnCurrentThread(length);
     DMG_ASSERT(ok);
   }
 
-  [[maybe_unused]] auto ok = memgraph::utils::total_memory_tracker.Alloc(static_cast<int64_t>(length));
+  auto ok = memgraph::utils::total_memory_tracker.Alloc(static_cast<int64_t>(length));
   DMG_ASSERT(ok);
 
   return false;

src/mg_import_csv.cpp

@@ -416,7 +416,7 @@ memgraph::storage::PropertyValue StringToValue(const std::string &str, const std
 std::string GetIdSpace(const std::string &type) {
   // The format of this field is as follows:
   // [START_|END_]ID[(<id_space>)]
-  static std::regex format(R"(^(START_|END_)?ID(\(([^\(\)]+)\))?$)", std::regex::extended);
+  std::regex format(R"(^(START_|END_)?ID(\(([^\(\)]+)\))?$)", std::regex::extended);
   std::smatch res;
   if (!std::regex_match(type, res, format))
     throw LoadException(

src/query/frontend/ast/ast.hpp

@@ -3035,6 +3035,8 @@ class ReplicationQuery : public memgraph::query::Query {
 
   enum class SyncMode { SYNC, ASYNC };
 
+  enum class ReplicaState { READY, REPLICATING, RECOVERY, MAYBE_BEHIND, DIVERGED_FROM_MAIN };
+
   ReplicationQuery() = default;
 
   DEFVISITABLE(QueryVisitor<void>);

src/query/interpreter.cpp

@@ -297,6 +297,16 @@ inline auto convertToReplicationMode(const ReplicationQuery::SyncMode &sync_mode
 
 class ReplQueryHandler {
  public:
+  struct ReplicaInfo {
+    std::string name;
+    std::string socket_address;
+    ReplicationQuery::SyncMode sync_mode;
+    std::optional<double> timeout;
+    uint64_t current_timestamp_of_replica;
+    uint64_t current_number_of_timestamp_behind_master;
+    ReplicationQuery::ReplicaState state;
+  };
+
   explicit ReplQueryHandler(query::ReplicationQueryHandler &replication_query_handler)
       : handler_{&replication_query_handler} {}
 
@@ -387,16 +397,58 @@ class ReplQueryHandler {
     }
   }
 
-  std::vector<ReplicasInfo> ShowReplicas() const {
-    auto info = handler_->ShowReplicas();
-    if (info.HasError()) {
-      switch (info.GetError()) {
-        case ShowReplicaError::NOT_MAIN:
-          throw QueryRuntimeException("Replica can't show registered replicas (it shouldn't have any)!");
-      }
+  std::vector<ReplicaInfo> ShowReplicas(const dbms::Database &db) const {
+    if (handler_->IsReplica()) {
+      // replica can't show registered replicas (it shouldn't have any)
+      throw QueryRuntimeException("Replica can't show registered replicas (it shouldn't have any)!");
     }
 
-    return info.GetValue().entries_;
+    // TODO: Combine results? Have a single place with clients???
+    //       Also authentication checks (replica + database visibility)
+    const auto repl_infos = db.storage()->ReplicasInfo();
+    std::vector<ReplicaInfo> replicas;
+    replicas.reserve(repl_infos.size());
+
+    const auto from_info = [](const auto &repl_info) -> ReplicaInfo {
+      ReplicaInfo replica;
+      replica.name = repl_info.name;
+      replica.socket_address = repl_info.endpoint.SocketAddress();
+      switch (repl_info.mode) {
+        case replication_coordination_glue::ReplicationMode::SYNC:
+          replica.sync_mode = ReplicationQuery::SyncMode::SYNC;
+          break;
+        case replication_coordination_glue::ReplicationMode::ASYNC:
+          replica.sync_mode = ReplicationQuery::SyncMode::ASYNC;
+          break;
+      }
+
+      replica.current_timestamp_of_replica = repl_info.timestamp_info.current_timestamp_of_replica;
+      replica.current_number_of_timestamp_behind_master =
+          repl_info.timestamp_info.current_number_of_timestamp_behind_master;
+
+      switch (repl_info.state) {
+        case storage::replication::ReplicaState::READY:
+          replica.state = ReplicationQuery::ReplicaState::READY;
+          break;
+        case storage::replication::ReplicaState::REPLICATING:
+          replica.state = ReplicationQuery::ReplicaState::REPLICATING;
+          break;
+        case storage::replication::ReplicaState::RECOVERY:
+          replica.state = ReplicationQuery::ReplicaState::RECOVERY;
+          break;
+        case storage::replication::ReplicaState::MAYBE_BEHIND:
+          replica.state = ReplicationQuery::ReplicaState::MAYBE_BEHIND;
+          break;
+        case storage::replication::ReplicaState::DIVERGED_FROM_MAIN:
+          replica.state = ReplicationQuery::ReplicaState::DIVERGED_FROM_MAIN;
+          break;
+      }
+
+      return replica;
+    };
+
+    std::transform(repl_infos.begin(), repl_infos.end(), std::back_inserter(replicas), from_info);
+    return replicas;
   }
 
  private:
@@ -410,7 +462,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 +475,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 +483,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 +504,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 +524,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 +546,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 +557,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 +567,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");
@@ -1043,98 +1092,50 @@ Callback HandleReplicationQuery(ReplicationQuery *repl_query, const Parameters &
       }
 #endif
 
-      bool full_info = false;
-#ifdef MG_ENTERPRISE
-      full_info = license::global_license_checker.IsEnterpriseValidFast();
-#endif
-
-      callback.header = {"name", "socket_address", "sync_mode", "system_info", "data_info"};
-
+      callback.header = {
+          "name", "socket_address", "sync_mode", "current_timestamp_of_replica", "number_of_timestamp_behind_master",
+          "state"};
       callback.fn = [handler = ReplQueryHandler{replication_query_handler}, replica_nfields = callback.header.size(),
-                     full_info] {
-        auto const sync_mode_to_tv = [](memgraph::replication_coordination_glue::ReplicationMode sync_mode) {
-          using namespace std::string_view_literals;
-          switch (sync_mode) {
-            using enum memgraph::replication_coordination_glue::ReplicationMode;
-            case SYNC:
-              return TypedValue{"sync"sv};
-            case ASYNC:
-              return TypedValue{"async"sv};
-          }
-        };
-
-        auto const replica_sys_state_to_tv = [](memgraph::replication::ReplicationClient::State state) {
-          using namespace std::string_view_literals;
-          switch (state) {
-            using enum memgraph::replication::ReplicationClient::State;
-            case BEHIND:
-              return TypedValue{"invalid"sv};
-            case READY:
-              return TypedValue{"ready"sv};
-            case RECOVERY:
-              return TypedValue{"recovery"sv};
-          }
-        };
-
-        auto const sys_info_to_tv = [&](ReplicaSystemInfoState orig) {
-          auto info = std::map<std::string, TypedValue>{};
-          info.emplace("ts", TypedValue{static_cast<int64_t>(orig.ts_)});
-          // TODO: behind not implemented
-          info.emplace("behind", TypedValue{/* static_cast<int64_t>(orig.behind_) */});
-          info.emplace("status", replica_sys_state_to_tv(orig.state_));
-          return TypedValue{std::move(info)};
-        };
-
-        auto const replica_state_to_tv = [](memgraph::storage::replication::ReplicaState state) {
-          using namespace std::string_view_literals;
-          switch (state) {
-            using enum memgraph::storage::replication::ReplicaState;
-            case READY:
-              return TypedValue{"ready"sv};
-            case REPLICATING:
-              return TypedValue{"replicating"sv};
-            case RECOVERY:
-              return TypedValue{"recovery"sv};
-            case MAYBE_BEHIND:
-              return TypedValue{"invalid"sv};
-            case DIVERGED_FROM_MAIN:
-              return TypedValue{"diverged"sv};
-          }
-        };
-
-        auto const info_to_tv = [&](ReplicaInfoState orig) {
-          auto info = std::map<std::string, TypedValue>{};
-          info.emplace("ts", TypedValue{static_cast<int64_t>(orig.ts_)});
-          info.emplace("behind", TypedValue{static_cast<int64_t>(orig.behind_)});
-          info.emplace("status", replica_state_to_tv(orig.state_));
-          return TypedValue{std::move(info)};
-        };
-
-        auto const data_info_to_tv = [&](std::map<std::string, ReplicaInfoState> orig) {
-          auto data_info = std::map<std::string, TypedValue>{};
-          for (auto &[name, info] : orig) {
-            data_info.emplace(name, info_to_tv(info));
-          }
-          return TypedValue{std::move(data_info)};
-        };
-
-        auto replicas = handler.ShowReplicas();
+                     db_acc = current_db.db_acc_] {
+        const auto &replicas = handler.ShowReplicas(*db_acc->get());
         auto typed_replicas = std::vector<std::vector<TypedValue>>{};
         typed_replicas.reserve(replicas.size());
-        for (auto &replica : replicas) {
+        for (const auto &replica : replicas) {
           std::vector<TypedValue> typed_replica;
           typed_replica.reserve(replica_nfields);
 
-          typed_replica.emplace_back(replica.name_);
-          typed_replica.emplace_back(replica.socket_address_);
-          typed_replica.emplace_back(sync_mode_to_tv(replica.sync_mode_));
-          if (full_info) {
-            typed_replica.emplace_back(sys_info_to_tv(replica.system_info_));
-          } else {
-            // Set to NULL
-            typed_replica.emplace_back(TypedValue{});
+          typed_replica.emplace_back(replica.name);
+          typed_replica.emplace_back(replica.socket_address);
+
+          switch (replica.sync_mode) {
+            case ReplicationQuery::SyncMode::SYNC:
+              typed_replica.emplace_back("sync");
+              break;
+            case ReplicationQuery::SyncMode::ASYNC:
+              typed_replica.emplace_back("async");
+              break;
+          }
+
+          typed_replica.emplace_back(static_cast<int64_t>(replica.current_timestamp_of_replica));
+          typed_replica.emplace_back(static_cast<int64_t>(replica.current_number_of_timestamp_behind_master));
+
+          switch (replica.state) {
+            case ReplicationQuery::ReplicaState::READY:
+              typed_replica.emplace_back("ready");
+              break;
+            case ReplicationQuery::ReplicaState::REPLICATING:
+              typed_replica.emplace_back("replicating");
+              break;
+            case ReplicationQuery::ReplicaState::RECOVERY:
+              typed_replica.emplace_back("recovery");
+              break;
+            case ReplicationQuery::ReplicaState::MAYBE_BEHIND:
+              typed_replica.emplace_back("invalid");
+              break;
+            case ReplicationQuery::ReplicaState::DIVERGED_FROM_MAIN:
+              typed_replica.emplace_back("diverged");
+              break;
           }
-          typed_replica.emplace_back(data_info_to_tv(replica.data_info_));
 
           typed_replicas.emplace_back(std::move(typed_replica));
         }
@@ -1254,13 +1255,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

@@ -84,6 +84,16 @@ class CoordinatorQueryHandler {
   CoordinatorQueryHandler(CoordinatorQueryHandler &&) = default;
   CoordinatorQueryHandler &operator=(CoordinatorQueryHandler &&) = default;
 
+  struct Replica {
+    std::string name;
+    std::string socket_address;
+    ReplicationQuery::SyncMode sync_mode;
+    std::optional<double> timeout;
+    uint64_t current_timestamp_of_replica;
+    uint64_t current_number_of_timestamp_behind_master;
+    ReplicationQuery::ReplicaState state;
+  };
+
   struct MainReplicaStatus {
     std::string_view name;
     std::string_view socket_address;
@@ -95,24 +105,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/query/procedure/mg_procedure_impl.cpp

@@ -3798,7 +3798,7 @@ void PrintFuncSignature(const mgp_func &func, std::ostream &stream) {
 
 bool IsValidIdentifierName(const char *name) {
   if (!name) return false;
-  static std::regex regex("[_[:alpha:]][_[:alnum:]]*");
+  std::regex regex("[_[:alpha:]][_[:alnum:]]*");
   return std::regex_match(name, regex);
 }
 

src/query/replication_query_handler.hpp

@@ -11,8 +11,6 @@
 
 #pragma once
 
-#include "replication/replication_client.hpp"
-#include "replication_coordination_glue/mode.hpp"
 #include "replication_coordination_glue/role.hpp"
 #include "utils/result.hpp"
 #include "utils/uuid.hpp"
@@ -33,7 +31,6 @@ enum class RegisterReplicaError : uint8_t {
   COULD_NOT_BE_PERSISTED,
   ERROR_ACCEPTING_MAIN
 };
-
 enum class UnregisterReplicaResult : uint8_t {
   NOT_MAIN,
   COULD_NOT_BE_PERSISTED,
@@ -41,47 +38,6 @@ enum class UnregisterReplicaResult : uint8_t {
   SUCCESS,
 };
 
-enum class ShowReplicaError : uint8_t {
-  NOT_MAIN,
-};
-
-struct ReplicaSystemInfoState {
-  uint64_t ts_;
-  uint64_t behind_;
-  replication::ReplicationClient::State state_;
-};
-
-struct ReplicaInfoState {
-  ReplicaInfoState(uint64_t ts, uint64_t behind, storage::replication::ReplicaState state)
-      : ts_(ts), behind_(behind), state_(state) {}
-
-  uint64_t ts_;
-  uint64_t behind_;
-  storage::replication::ReplicaState state_;
-};
-
-struct ReplicasInfo {
-  ReplicasInfo(std::string name, std::string socket_address, replication_coordination_glue::ReplicationMode sync_mode,
-               ReplicaSystemInfoState system_info, std::map<std::string, ReplicaInfoState> data_info)
-      : name_(std::move(name)),
-        socket_address_(std::move(socket_address)),
-        sync_mode_(sync_mode),
-        system_info_(std::move(system_info)),
-        data_info_(std::move(data_info)) {}
-
-  std::string name_;
-  std::string socket_address_;
-  memgraph::replication_coordination_glue::ReplicationMode sync_mode_;
-  ReplicaSystemInfoState system_info_;
-  std::map<std::string, ReplicaInfoState> data_info_;
-};
-
-struct ReplicasInfos {
-  explicit ReplicasInfos(std::vector<ReplicasInfo> entries) : entries_(std::move(entries)) {}
-
-  std::vector<ReplicasInfo> entries_;
-};
-
 /// A handler type that keep in sync current ReplicationState and the MAIN/REPLICA-ness of Storage
 struct ReplicationQueryHandler {
   virtual ~ReplicationQueryHandler() = default;
@@ -110,8 +66,6 @@ struct ReplicationQueryHandler {
   virtual auto GetRole() const -> memgraph::replication_coordination_glue::ReplicationRole = 0;
   virtual bool IsMain() const = 0;
   virtual bool IsReplica() const = 0;
-
-  virtual auto ShowReplicas() const -> utils::BasicResult<ShowReplicaError, ReplicasInfos> = 0;
 };
 
 }  // namespace memgraph::query

src/replication/include/replication/replication_client.hpp

@@ -14,9 +14,7 @@
 #include "replication/config.hpp"
 #include "replication_coordination_glue/messages.hpp"
 #include "rpc/client.hpp"
-#include "utils/rw_lock.hpp"
 #include "utils/scheduler.hpp"
-#include "utils/spin_lock.hpp"
 #include "utils/synchronized.hpp"
 #include "utils/thread_pool.hpp"
 
@@ -116,9 +114,8 @@ struct ReplicationClient {
   enum class State {
     BEHIND,
     READY,
-    RECOVERY,
   };
-  utils::Synchronized<State, utils::WritePrioritizedRWLock> state_{State::BEHIND};
+  utils::Synchronized<State> state_{State::BEHIND};
 
   replication_coordination_glue::ReplicationMode mode_{replication_coordination_glue::ReplicationMode::SYNC};
   // This thread pool is used for background tasks so we don't

src/replication_coordination_glue/CMakeLists.txt

@@ -7,7 +7,6 @@ target_sources(mg-repl_coord_glue
         mode.hpp
         role.hpp
         handler.hpp
-        common.hpp
 
         PRIVATE
         messages.cpp

src/replication_coordination_glue/common.hpp

@@ -1,32 +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
-
-#include "rpc/client.hpp"
-#include "utils/uuid.hpp"
-
-#include <deque>
-#include "messages.hpp"
-#include "rpc/messages.hpp"
-#include "utils/uuid.hpp"
-
-namespace memgraph::replication_coordination_glue {
-
-struct DatabaseHistory {
-  memgraph::utils::UUID db_uuid;
-  std::vector<std::pair<std::string, uint64_t>> history;
-  std::string name;
-};
-
-using DatabaseHistories = std::vector<DatabaseHistory>;
-
-}  // namespace memgraph::replication_coordination_glue

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/include/replication_handler/replication_handler.hpp

@@ -14,7 +14,6 @@
 #include "dbms/dbms_handler.hpp"
 #include "flags/experimental.hpp"
 #include "replication/include/replication/state.hpp"
-#include "replication_coordination_glue/common.hpp"
 #include "replication_handler/system_replication.hpp"
 #include "replication_handler/system_rpc.hpp"
 #include "utils/result.hpp"
@@ -40,12 +39,10 @@ void SystemRestore(replication::ReplicationClient &client, system::System &syste
                    const utils::UUID &main_uuid, auth::SynchedAuth &auth) {
   // Check if system is up to date
   if (client.state_.WithLock(
-          [](auto &state) { return state != memgraph::replication::ReplicationClient::State::BEHIND; }))
+          [](auto &state) { return state == memgraph::replication::ReplicationClient::State::READY; }))
     return;
 
   // Try to recover...
-  client.state_.WithLock(
-      [](auto &state) { return state != memgraph::replication::ReplicationClient::State::RECOVERY; });
   {
     using enum memgraph::flags::Experiments;
     bool full_system_replication =
@@ -142,16 +139,11 @@ struct ReplicationHandler : public memgraph::query::ReplicationQueryHandler {
   bool IsMain() const override;
   bool IsReplica() const override;
 
-  auto ShowReplicas() const
-      -> utils::BasicResult<memgraph::query::ShowReplicaError, memgraph::query::ReplicasInfos> override;
-
   auto GetReplState() const -> const memgraph::replication::ReplicationState &;
   auto GetReplState() -> memgraph::replication::ReplicationState &;
 
   auto GetReplicaUUID() -> std::optional<utils::UUID>;
 
-  auto GetDatabasesHistories() -> replication_coordination_glue::DatabaseHistories;
-
  private:
   template <bool SendSwapUUID>
   auto RegisterReplica_(const memgraph::replication::ReplicationClientConfig &config)

src/replication_handler/replication_handler.cpp

@@ -10,29 +10,26 @@
 // licenses/APL.txt.
 
 #include "replication_handler/replication_handler.hpp"
-#include "dbms/constants.hpp"
 #include "dbms/dbms_handler.hpp"
-#include "replication/replication_client.hpp"
 #include "replication_handler/system_replication.hpp"
-#include "utils/functional.hpp"
 
 namespace memgraph::replication {
 
 namespace {
 #ifdef MG_ENTERPRISE
-void RecoverReplication(replication::ReplicationState &repl_state, system::System &system,
-                        dbms::DbmsHandler &dbms_handler, auth::SynchedAuth &auth) {
+void RecoverReplication(memgraph::replication::ReplicationState &repl_state, memgraph::system::System &system,
+                        memgraph::dbms::DbmsHandler &dbms_handler, memgraph::auth::SynchedAuth &auth) {
   /*
    * REPLICATION RECOVERY AND STARTUP
    */
 
   // Startup replication state (if recovered at startup)
-  auto replica = [&dbms_handler, &auth, &system](replication::RoleReplicaData &data) {
-    return replication::StartRpcServer(dbms_handler, data, auth, system);
+  auto replica = [&dbms_handler, &auth, &system](memgraph::replication::RoleReplicaData &data) {
+    return memgraph::replication::StartRpcServer(dbms_handler, data, auth, system);
   };
 
   // Replication recovery and frequent check start
-  auto main = [&system, &dbms_handler, &auth](replication::RoleMainData &mainData) {
+  auto main = [&system, &dbms_handler, &auth](memgraph::replication::RoleMainData &mainData) {
     for (auto &client : mainData.registered_replicas_) {
       if (client.try_set_uuid &&
           replication_coordination_glue::SendSwapMainUUIDRpc(client.rpc_client_, mainData.uuid_)) {
@@ -41,7 +38,7 @@ void RecoverReplication(replication::ReplicationState &repl_state, system::Syste
       SystemRestore(client, system, dbms_handler, mainData.uuid_, auth);
     }
     // DBMS here
-    dbms_handler.ForEach([&mainData](dbms::DatabaseAccess db_acc) {
+    dbms_handler.ForEach([&mainData](memgraph::dbms::DatabaseAccess db_acc) {
       dbms::DbmsHandler::RecoverStorageReplication(std::move(db_acc), mainData);
     });
 
@@ -51,7 +48,7 @@ void RecoverReplication(replication::ReplicationState &repl_state, system::Syste
 
     // Warning
     if (dbms_handler.default_config().durability.snapshot_wal_mode ==
-        storage::Config::Durability::SnapshotWalMode::DISABLED) {
+        memgraph::storage::Config::Durability::SnapshotWalMode::DISABLED) {
       spdlog::warn(
           "The instance has the MAIN replication role, but durability logs and snapshots are disabled. Please "
           "consider "
@@ -62,18 +59,19 @@ void RecoverReplication(replication::ReplicationState &repl_state, system::Syste
     return true;
   };
 
-  auto result = std::visit(utils::Overloaded{replica, main}, repl_state.ReplicationData());
+  auto result = std::visit(memgraph::utils::Overloaded{replica, main}, repl_state.ReplicationData());
   MG_ASSERT(result, "Replica recovery failure!");
 }
 #else
-void RecoverReplication(replication::ReplicationState &repl_state, dbms::DbmsHandler &dbms_handler) {
+void RecoverReplication(memgraph::replication::ReplicationState &repl_state,
+                        memgraph::dbms::DbmsHandler &dbms_handler) {
   // Startup replication state (if recovered at startup)
-  auto replica = [&dbms_handler](replication::RoleReplicaData &data) {
-    return replication::StartRpcServer(dbms_handler, data);
+  auto replica = [&dbms_handler](memgraph::replication::RoleReplicaData &data) {
+    return memgraph::replication::StartRpcServer(dbms_handler, data);
   };
 
   // Replication recovery and frequent check start
-  auto main = [&dbms_handler](replication::RoleMainData &mainData) {
+  auto main = [&dbms_handler](memgraph::replication::RoleMainData &mainData) {
     dbms::DbmsHandler::RecoverStorageReplication(dbms_handler.Get(), mainData);
 
     for (auto &client : mainData.registered_replicas_) {
@@ -81,12 +79,12 @@ void RecoverReplication(replication::ReplicationState &repl_state, dbms::DbmsHan
           replication_coordination_glue::SendSwapMainUUIDRpc(client.rpc_client_, mainData.uuid_)) {
         client.try_set_uuid = false;
       }
-      replication::StartReplicaClient(client, dbms_handler, mainData.uuid_);
+      memgraph::replication::StartReplicaClient(client, dbms_handler, mainData.uuid_);
     }
 
     // Warning
     if (dbms_handler.default_config().durability.snapshot_wal_mode ==
-        storage::Config::Durability::SnapshotWalMode::DISABLED) {
+        memgraph::storage::Config::Durability::SnapshotWalMode::DISABLED) {
       spdlog::warn(
           "The instance has the MAIN replication role, but durability logs and snapshots are disabled. Please "
           "consider "
@@ -97,7 +95,7 @@ void RecoverReplication(replication::ReplicationState &repl_state, dbms::DbmsHan
     return true;
   };
 
-  auto result = std::visit(utils::Overloaded{replica, main}, repl_state.ReplicationData());
+  auto result = std::visit(memgraph::utils::Overloaded{replica, main}, repl_state.ReplicationData());
   MG_ASSERT(result, "Replica recovery failure!");
 }
 #endif
@@ -135,19 +133,20 @@ void StartReplicaClient(replication::ReplicationClient &client, dbms::DbmsHandle
   spdlog::trace("Replication client started at: {}:{}", endpoint.address, endpoint.port);
   client.StartFrequentCheck([&, license = license::global_license_checker.IsEnterpriseValidFast(), main_uuid](
                                 bool reconnect, replication::ReplicationClient &client) mutable {
-    if (client.try_set_uuid && replication_coordination_glue::SendSwapMainUUIDRpc(client.rpc_client_, main_uuid)) {
+    if (client.try_set_uuid &&
+        memgraph::replication_coordination_glue::SendSwapMainUUIDRpc(client.rpc_client_, main_uuid)) {
       client.try_set_uuid = false;
     }
     // Working connection
     // Check if system needs restoration
     if (reconnect) {
-      client.state_.WithLock([](auto &state) { state = replication::ReplicationClient::State::BEHIND; });
+      client.state_.WithLock([](auto &state) { state = memgraph::replication::ReplicationClient::State::BEHIND; });
     }
     // Check if license has changed
     const auto new_license = license::global_license_checker.IsEnterpriseValidFast();
     if (new_license != license) {
       license = new_license;
-      client.state_.WithLock([](auto &state) { state = replication::ReplicationClient::State::BEHIND; });
+      client.state_.WithLock([](auto &state) { state = memgraph::replication::ReplicationClient::State::BEHIND; });
     }
 #ifdef MG_ENTERPRISE
     SystemRestore<true>(client, system, dbms_handler, main_uuid, auth);
@@ -155,10 +154,10 @@ void StartReplicaClient(replication::ReplicationClient &client, dbms::DbmsHandle
     // Check if any database has been left behind
     dbms_handler.ForEach([&name = client.name_, reconnect](dbms::DatabaseAccess db_acc) {
       // Specific database <-> replica client
-      db_acc->storage()->repl_storage_state_.WithClient(name, [&](storage::ReplicationStorageClient &client) {
-        if (reconnect || client.State() == storage::replication::ReplicaState::MAYBE_BEHIND) {
+      db_acc->storage()->repl_storage_state_.WithClient(name, [&](storage::ReplicationStorageClient *client) {
+        if (reconnect || client->State() == storage::replication::ReplicaState::MAYBE_BEHIND) {
           // Database <-> replica might be behind, check and recover
-          client.TryCheckReplicaStateAsync(db_acc->storage(), db_acc);
+          client->TryCheckReplicaStateAsync(db_acc->storage(), db_acc);
         }
       });
     });
@@ -166,8 +165,9 @@ void StartReplicaClient(replication::ReplicationClient &client, dbms::DbmsHandle
 }
 
 #ifdef MG_ENTERPRISE
-ReplicationHandler::ReplicationHandler(replication::ReplicationState &repl_state, dbms::DbmsHandler &dbms_handler,
-                                       system::System &system, auth::SynchedAuth &auth)
+ReplicationHandler::ReplicationHandler(memgraph::replication::ReplicationState &repl_state,
+                                       memgraph::dbms::DbmsHandler &dbms_handler, memgraph::system::System &system,
+                                       memgraph::auth::SynchedAuth &auth)
     : repl_state_{repl_state}, dbms_handler_{dbms_handler}, system_{system}, auth_{auth} {
   RecoverReplication(repl_state_, system_, dbms_handler_, auth_);
 }
@@ -179,20 +179,20 @@ ReplicationHandler::ReplicationHandler(replication::ReplicationState &repl_state
 #endif
 
 bool ReplicationHandler::SetReplicationRoleMain() {
-  auto const main_handler = [](replication::RoleMainData &) {
+  auto const main_handler = [](memgraph::replication::RoleMainData &) {
     // If we are already MAIN, we don't want to change anything
     return false;
   };
 
-  auto const replica_handler = [this](replication::RoleReplicaData const &) {
+  auto const replica_handler = [this](memgraph::replication::RoleReplicaData const &) {
     return DoReplicaToMainPromotion(utils::UUID{});
   };
 
   // TODO: under lock
-  return std::visit(utils::Overloaded{main_handler, replica_handler}, repl_state_.ReplicationData());
+  return std::visit(memgraph::utils::Overloaded{main_handler, replica_handler}, repl_state_.ReplicationData());
 }
 
-bool ReplicationHandler::SetReplicationRoleReplica(const replication::ReplicationServerConfig &config,
+bool ReplicationHandler::SetReplicationRoleReplica(const memgraph::replication::ReplicationServerConfig &config,
                                                    const std::optional<utils::UUID> &main_uuid) {
   return SetReplicationRoleReplica_<true>(config, main_uuid);
 }
@@ -238,16 +238,18 @@ auto ReplicationHandler::RegisterReplica(const memgraph::replication::Replicatio
   return RegisterReplica_<false>(config);
 }
 
-auto ReplicationHandler::UnregisterReplica(std::string_view name) -> query::UnregisterReplicaResult {
-  auto const replica_handler = [](replication::RoleReplicaData const &) -> query::UnregisterReplicaResult {
-    return query::UnregisterReplicaResult::NOT_MAIN;
+auto ReplicationHandler::UnregisterReplica(std::string_view name) -> memgraph::query::UnregisterReplicaResult {
+  auto const replica_handler =
+      [](memgraph::replication::RoleReplicaData const &) -> memgraph::query::UnregisterReplicaResult {
+    return memgraph::query::UnregisterReplicaResult::NOT_MAIN;
   };
-  auto const main_handler = [this, name](replication::RoleMainData &mainData) -> query::UnregisterReplicaResult {
+  auto const main_handler =
+      [this, name](memgraph::replication::RoleMainData &mainData) -> memgraph::query::UnregisterReplicaResult {
     if (!repl_state_.TryPersistUnregisterReplica(name)) {
-      return query::UnregisterReplicaResult::COULD_NOT_BE_PERSISTED;
+      return memgraph::query::UnregisterReplicaResult::COULD_NOT_BE_PERSISTED;
     }
     // Remove database specific clients
-    dbms_handler_.ForEach([name](dbms::DatabaseAccess db_acc) {
+    dbms_handler_.ForEach([name](memgraph::dbms::DatabaseAccess db_acc) {
       db_acc->storage()->repl_storage_state_.replication_clients_.WithLock([&name](auto &clients) {
         std::erase_if(clients, [name](const auto &client) { return client->Name() == name; });
       });
@@ -255,92 +257,28 @@ auto ReplicationHandler::UnregisterReplica(std::string_view name) -> query::Unre
     // Remove instance level clients
     auto const n_unregistered =
         std::erase_if(mainData.registered_replicas_, [name](auto const &client) { return client.name_ == name; });
-    return n_unregistered != 0 ? query::UnregisterReplicaResult::SUCCESS
-                               : query::UnregisterReplicaResult::CAN_NOT_UNREGISTER;
+    return n_unregistered != 0 ? memgraph::query::UnregisterReplicaResult::SUCCESS
+                               : memgraph::query::UnregisterReplicaResult::CAN_NOT_UNREGISTER;
   };
 
-  return std::visit(utils::Overloaded{main_handler, replica_handler}, repl_state_.ReplicationData());
+  return std::visit(memgraph::utils::Overloaded{main_handler, replica_handler}, repl_state_.ReplicationData());
 }
 
-auto ReplicationHandler::GetRole() const -> replication_coordination_glue::ReplicationRole {
+auto ReplicationHandler::GetRole() const -> memgraph::replication_coordination_glue::ReplicationRole {
   return repl_state_.GetRole();
 }
 
-auto ReplicationHandler::GetDatabasesHistories() -> replication_coordination_glue::DatabaseHistories {
-  replication_coordination_glue::DatabaseHistories results;
-  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);
-
-    history.emplace_back(std::string(repl_storage_state.epoch_.id()), repl_storage_state.last_commit_timestamp_.load());
-    replication_coordination_glue::DatabaseHistory repl{
-        .db_uuid = utils::UUID{db_acc->storage()->uuid()}, .history = history, .name = std::string(db_acc->name())};
-    results.emplace_back(repl);
-  });
-
-  return results;
-}
-
 auto ReplicationHandler::GetReplicaUUID() -> std::optional<utils::UUID> {
-  MG_ASSERT(repl_state_.IsReplica(), "Instance is not replica");
+  MG_ASSERT(repl_state_.IsReplica());
   return std::get<RoleReplicaData>(repl_state_.ReplicationData()).uuid_;
 }
 
 auto ReplicationHandler::GetReplState() const -> const memgraph::replication::ReplicationState & { return repl_state_; }
 
-auto ReplicationHandler::GetReplState() -> replication::ReplicationState & { return repl_state_; }
+auto ReplicationHandler::GetReplState() -> memgraph::replication::ReplicationState & { return repl_state_; }
 
 bool ReplicationHandler::IsMain() const { return repl_state_.IsMain(); }
 
 bool ReplicationHandler::IsReplica() const { return repl_state_.IsReplica(); }
-auto ReplicationHandler::ShowReplicas() const -> utils::BasicResult<query::ShowReplicaError, query::ReplicasInfos> {
-  using res_t = utils::BasicResult<query::ShowReplicaError, query::ReplicasInfos>;
-  auto main = [this](RoleMainData const &main) -> res_t {
-    auto entries = std::vector<query::ReplicasInfo>{};
-    entries.reserve(main.registered_replicas_.size());
-
-    const bool full_info = license::global_license_checker.IsEnterpriseValidFast();
-
-    for (auto const &replica : main.registered_replicas_) {
-      // STEP 1: data_info
-      auto data_info = std::map<std::string, query::ReplicaInfoState>{};
-      this->dbms_handler_.ForEach([&](dbms::DatabaseAccess db_acc) {
-        auto *storage = db_acc->storage();
-        // ATM we only support IN_MEMORY_TRANSACTIONAL
-        if (storage->storage_mode_ != storage::StorageMode::IN_MEMORY_TRANSACTIONAL) return;
-        if (!full_info && storage->name() == dbms::kDefaultDB) return;
-        auto ok =
-            storage->repl_storage_state_.WithClient(replica.name_, [&](storage::ReplicationStorageClient &client) {
-              auto ts_info = client.GetTimestampInfo(storage);
-              auto state = client.State();
-
-              data_info.emplace(storage->name(),
-                                query::ReplicaInfoState{ts_info.current_timestamp_of_replica,
-                                                        ts_info.current_number_of_timestamp_behind_main, state});
-            });
-        DMG_ASSERT(ok);
-      });
-
-// STEP 2: system_info
-#ifdef MG_ENTERPRISE
-      // Already locked on system transaction via the interpreter
-      const auto ts = system_.LastCommittedSystemTimestamp();
-      // NOTE: no system behind at the moment
-      query::ReplicaSystemInfoState system_info{ts, 0 /* behind ts not implemented */, *replica.state_.ReadLock()};
-#else
-      query::ReplicaSystemInfoState system_info{};
-#endif
-      // STEP 3: add entry
-      entries.emplace_back(replica.name_, replica.rpc_client_.Endpoint().SocketAddress(), replica.mode_, system_info,
-                           std::move(data_info));
-    }
-    return query::ReplicasInfos{std::move(entries)};
-  };
-  auto replica = [](RoleReplicaData const &) -> res_t { return query::ShowReplicaError::NOT_MAIN; };
-
-  return std::visit(utils::Overloaded{main, replica}, repl_state_.ReplicationData());
-}
 
 }  // namespace memgraph::replication

src/storage/v2/delta.hpp

@@ -123,26 +123,6 @@ inline bool operator==(const PreviousPtr::Pointer &a, const PreviousPtr::Pointer
 
 inline bool operator!=(const PreviousPtr::Pointer &a, const PreviousPtr::Pointer &b) { return !(a == b); }
 
-struct opt_str {
-  opt_str(std::optional<std::string> const &other) : str_{other ? new_cstr(*other) : nullptr} {}
-
-  ~opt_str() { delete[] str_; }
-
-  auto as_opt_str() const -> std::optional<std::string> {
-    if (!str_) return std::nullopt;
-    return std::optional<std::string>{std::in_place, str_};
-  }
-
- private:
-  static auto new_cstr(std::string const &str) -> char const * {
-    auto *mem = new char[str.length() + 1];
-    strcpy(mem, str.c_str());
-    return mem;
-  }
-
-  char const *str_ = nullptr;
-};
-
 struct Delta {
   enum class Action : std::uint8_t {
     /// Use for Vertex and Edge
@@ -180,7 +160,7 @@ struct Delta {
   // Because of this object was created in past txs, we create timestamp by ourselves inside instead of having it from
   // current tx. This timestamp we got from RocksDB timestamp stored in key.
   Delta(DeleteDeserializedObjectTag /*tag*/, uint64_t ts, std::optional<std::string> old_disk_key)
-      : timestamp(new std::atomic<uint64_t>(ts)), command_id(0), old_disk_key{.value = old_disk_key} {}
+      : timestamp(new std::atomic<uint64_t>(ts)), command_id(0), old_disk_key{.value = std::move(old_disk_key)} {}
 
   Delta(DeleteObjectTag /*tag*/, std::atomic<uint64_t> *timestamp, uint64_t command_id)
       : timestamp(timestamp), command_id(command_id), action(Action::DELETE_OBJECT) {}
@@ -242,7 +222,7 @@ struct Delta {
       case Action::REMOVE_OUT_EDGE:
         break;
       case Action::DELETE_DESERIALIZED_OBJECT:
-        std::destroy_at(&old_disk_key.value);
+        old_disk_key.value.reset();
         delete timestamp;
         timestamp = nullptr;
         break;
@@ -262,7 +242,7 @@ struct Delta {
     Action action;
     struct {
       Action action = Action::DELETE_DESERIALIZED_OBJECT;
-      opt_str value;
+      std::optional<std::string> value;
     } old_disk_key;
     struct {
       Action action;

src/storage/v2/disk/storage.hpp

@@ -310,7 +310,7 @@ class DiskStorage final : public Storage {
   StorageInfo GetBaseInfo() override;
   StorageInfo GetInfo(memgraph::replication_coordination_glue::ReplicationRole replication_role) override;
 
-  void FreeMemory(std::unique_lock<utils::ResourceLock> /*lock*/, bool /*periodic*/) override {}
+  void FreeMemory(std::unique_lock<utils::ResourceLock> /*lock*/) override {}
 
   void PrepareForNewEpoch() override { throw utils::BasicException("Disk storage mode does not support replication."); }
 

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/label_property_index.cpp

@@ -144,30 +144,27 @@ void InMemoryLabelPropertyIndex::RemoveObsoleteEntries(uint64_t oldest_active_st
   auto maybe_stop = utils::ResettableCounter<2048>();
 
   for (auto &[label_property, index] : index_) {
-    auto [label_id, prop_id] = label_property;
     // before starting index, check if stop_requested
     if (token.stop_requested()) return;
 
     auto index_acc = index.access();
-    auto it = index_acc.begin();
-    auto end_it = index_acc.end();
-    if (it == end_it) continue;
-    while (true) {
+    for (auto it = index_acc.begin(); it != index_acc.end();) {
       // Hot loop, don't check stop_requested every time
       if (maybe_stop() && token.stop_requested()) return;
 
       auto next_it = it;
       ++next_it;
 
-      bool has_next = next_it != end_it;
-      if (it->timestamp < oldest_active_start_timestamp) {
-        bool redundant_duplicate = has_next && it->vertex == next_it->vertex && it->value == next_it->value;
-        if (redundant_duplicate ||
-            !AnyVersionHasLabelProperty(*it->vertex, label_id, prop_id, it->value, oldest_active_start_timestamp)) {
-          index_acc.remove(*it);
-        }
+      if (it->timestamp >= oldest_active_start_timestamp) {
+        it = next_it;
+        continue;
+      }
+
+      if ((next_it != index_acc.end() && it->vertex == next_it->vertex && it->value == next_it->value) ||
+          !AnyVersionHasLabelProperty(*it->vertex, label_property.first, label_property.second, it->value,
+                                      oldest_active_start_timestamp)) {
+        index_acc.remove(*it);
       }
-      if (!has_next) break;
       it = next_it;
     }
   }

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

@@ -106,8 +106,8 @@ uint64_t ReplicateCurrentWal(const utils::UUID &main_uuid, const InMemoryStorage
   return response.current_commit_timestamp;
 }
 
-/// This method tries to find the optimal path for recovering a single replica.
-/// Based on the last commit transferred to replica it tries to update the
+/// This method tries to find the optimal path for recoverying a single replica.
+/// Based on the last commit transfered to replica it tries to update the
 /// replica using durability files - WALs and Snapshots. WAL files are much
 /// smaller in size as they contain only the Deltas (changes) made during the
 /// transactions while Snapshots contain all the data. For that reason we prefer
@@ -175,7 +175,7 @@ std::vector<RecoveryStep> GetRecoverySteps(uint64_t replica_commit, utils::FileR
   auto add_snapshot = [&]() {
     if (!latest_snapshot) return;
     const auto lock_success = locker_acc.AddPath(latest_snapshot->path);
-    MG_ASSERT(!lock_success.HasError(), "Tried to lock a non-existent snapshot path.");
+    MG_ASSERT(!lock_success.HasError(), "Tried to lock a nonexistant snapshot path.");
     recovery_steps.emplace_back(std::in_place_type_t<RecoverySnapshot>{}, std::move(latest_snapshot->path));
   };
 
@@ -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 ||
@@ -144,7 +143,9 @@ InMemoryStorage::InMemoryStorage(Config config)
 
   if (config_.gc.type == Config::Gc::Type::PERIODIC) {
     // TODO: move out of storage have one global gc_runner_
-    gc_runner_.Run("Storage GC", config_.gc.interval, [this] { this->FreeMemory({}, true); });
+    gc_runner_.Run("Storage GC", config_.gc.interval, [this] {
+      this->FreeMemory(std::unique_lock<utils::ResourceLock>{main_lock_, std::defer_lock});
+    });
   }
   if (timestamp_ == kTimestampInitialId) {
     commit_log_.emplace();
@@ -1424,27 +1425,28 @@ void InMemoryStorage::SetStorageMode(StorageMode new_storage_mode) {
     }
 
     storage_mode_ = new_storage_mode;
-    FreeMemory(std::move(main_guard), false);
+    FreeMemory(std::move(main_guard));
   }
 }
 
-template <bool aggressive = true>
-void InMemoryStorage::CollectGarbage(std::unique_lock<utils::ResourceLock> main_guard, bool periodic) {
+template <bool force>
+void InMemoryStorage::CollectGarbage(std::unique_lock<utils::ResourceLock> main_guard) {
   // NOTE: You do not need to consider cleanup of deleted object that occurred in
   // different storage modes within the same CollectGarbage call. This is because
   // SetStorageMode will ensure CollectGarbage is called before any new transactions
   // with the new storage mode can start.
 
   // SetStorageMode will pass its unique_lock of main_lock_. We will use that lock,
-  // as reacquiring the lock would cause deadlock. Otherwise, we need to get our own
+  // as reacquiring the lock would cause  deadlock. Otherwise, we need to get our own
   // lock.
   if (!main_guard.owns_lock()) {
-    if constexpr (aggressive) {
-      // We tried to be aggressive but we do not already have main lock continue as not aggressive
-      // Perf note: Do not try to get unique lock if it was not already passed in. GC maybe expensive,
-      // do not assume it is fast, unique lock will blocks all new storage transactions.
-      CollectGarbage<false>({}, periodic);
-      return;
+    if constexpr (force) {
+      // We take the unique lock on the main storage lock, so we can forcefully clean
+      // everything we can
+      if (!main_lock_.try_lock()) {
+        CollectGarbage<false>();
+        return;
+      }
     } else {
       // Because the garbage collector iterates through the indices and constraints
       // to clean them up, it must take the main lock for reading to make sure that
@@ -1456,24 +1458,17 @@ void InMemoryStorage::CollectGarbage(std::unique_lock<utils::ResourceLock> main_
   }
 
   utils::OnScopeExit lock_releaser{[&] {
-    if (main_guard.owns_lock()) {
-      main_guard.unlock();
+    if (!main_guard.owns_lock()) {
+      if constexpr (force) {
+        main_lock_.unlock();
+      } else {
+        main_lock_.unlock_shared();
+      }
     } else {
-      main_lock_.unlock_shared();
+      main_guard.unlock();
     }
   }};
 
-  // Only one gc run at a time
-  std::unique_lock<std::mutex> gc_guard(gc_lock_, std::try_to_lock);
-  if (!gc_guard.owns_lock()) {
-    return;
-  }
-
-  // Diagnostic trace
-  spdlog::trace("Storage GC on '{}' started [{}]", name(), periodic ? "periodic" : "forced");
-  auto trace_on_exit = utils::OnScopeExit{
-      [&] { spdlog::trace("Storage GC on '{}' finished [{}]", name(), periodic ? "periodic" : "forced"); }};
-
   // Garbage collection must be performed in two phases. In the first phase,
   // deltas that won't be applied by any transaction anymore are unlinked from
   // the version chains. They cannot be deleted immediately, because there
@@ -1481,29 +1476,27 @@ void InMemoryStorage::CollectGarbage(std::unique_lock<utils::ResourceLock> main_
   // chain traversal. They are instead marked for deletion and will be deleted
   // in the second GC phase in this GC iteration or some of the following
   // ones.
+  std::unique_lock<std::mutex> gc_guard(gc_lock_, std::try_to_lock);
+  if (!gc_guard.owns_lock()) {
+    return;
+  }
 
   uint64_t oldest_active_start_timestamp = commit_log_->OldestActive();
 
-  {
-    std::unique_lock<utils::SpinLock> guard(engine_lock_);
-    uint64_t mark_timestamp = timestamp_;  // a timestamp no active transaction can currently have
-
-    // Deltas from previous GC runs or from aborts can be cleaned up here
-    garbage_undo_buffers_.WithLock([&](auto &garbage_undo_buffers) {
-      guard.unlock();
-      if (aggressive or mark_timestamp == oldest_active_start_timestamp) {
-        // We know no transaction is active, it is safe to simply delete all the garbage undos
-        // Nothing can be reading them
-        garbage_undo_buffers.clear();
-      } else {
-        // garbage_undo_buffers is ordered, pop until we can't
-        while (!garbage_undo_buffers.empty() &&
-               garbage_undo_buffers.front().mark_timestamp_ <= oldest_active_start_timestamp) {
-          garbage_undo_buffers.pop_front();
-        }
+  // Deltas from previous GC runs or from aborts can be cleaned up here
+  garbage_undo_buffers_.WithLock([&](auto &garbage_undo_buffers) {
+    if constexpr (force) {
+      // if force is set to true we can simply delete all the leftover undos because
+      // no transaction is active
+      garbage_undo_buffers.clear();
+    } else {
+      // garbage_undo_buffers is ordered, pop until we can't
+      while (!garbage_undo_buffers.empty() &&
+             garbage_undo_buffers.front().mark_timestamp_ <= oldest_active_start_timestamp) {
+        garbage_undo_buffers.pop_front();
       }
-    });
-  }
+    }
+  });
 
   // We don't move undo buffers of unlinked transactions to garbage_undo_buffers
   // list immediately, because we would have to repeatedly take
@@ -1701,8 +1694,7 @@ void InMemoryStorage::CollectGarbage(std::unique_lock<utils::ResourceLock> main_
     std::unique_lock<utils::SpinLock> guard(engine_lock_);
     uint64_t mark_timestamp = timestamp_;  // a timestamp no active transaction can currently have
 
-    if (aggressive or mark_timestamp == oldest_active_start_timestamp) {
-      guard.unlock();
+    if (force or mark_timestamp == oldest_active_start_timestamp) {
       // if lucky, there are no active transactions, hence nothing looking at the deltas
       // remove them now
       unlinked_undo_buffers.clear();
@@ -1764,8 +1756,8 @@ void InMemoryStorage::CollectGarbage(std::unique_lock<utils::ResourceLock> main_
 }
 
 // tell the linker he can find the CollectGarbage definitions here
-template void InMemoryStorage::CollectGarbage<true>(std::unique_lock<utils::ResourceLock> main_guard, bool periodic);
-template void InMemoryStorage::CollectGarbage<false>(std::unique_lock<utils::ResourceLock> main_guard, bool periodic);
+template void InMemoryStorage::CollectGarbage<true>(std::unique_lock<utils::ResourceLock>);
+template void InMemoryStorage::CollectGarbage<false>(std::unique_lock<utils::ResourceLock>);
 
 StorageInfo InMemoryStorage::GetBaseInfo() {
   StorageInfo info{};
@@ -2116,35 +2108,50 @@ void InMemoryStorage::AppendToWalDataDefinition(durability::StorageMetadataOpera
 
 utils::BasicResult<InMemoryStorage::CreateSnapshotError> InMemoryStorage::CreateSnapshot(
     memgraph::replication_coordination_glue::ReplicationRole replication_role) {
-  using memgraph::replication_coordination_glue::ReplicationRole;
-  if (replication_role == ReplicationRole::REPLICA) {
+  if (replication_role == memgraph::replication_coordination_glue::ReplicationRole::REPLICA) {
     return InMemoryStorage::CreateSnapshotError::DisabledForReplica;
   }
+  auto const &epoch = repl_storage_state_.epoch_;
+  auto snapshot_creator = [this, &epoch]() {
+    utils::Timer timer;
+    auto transaction = CreateTransaction(IsolationLevel::SNAPSHOT_ISOLATION, storage_mode_,
+                                         memgraph::replication_coordination_glue::ReplicationRole::MAIN);
+    durability::CreateSnapshot(this, &transaction, recovery_.snapshot_directory_, recovery_.wal_directory_, &vertices_,
+                               &edges_, uuid_, epoch, repl_storage_state_.history, &file_retainer_);
+    // Finalize snapshot transaction.
+    commit_log_->MarkFinished(transaction.start_timestamp);
+
+    memgraph::metrics::Measure(memgraph::metrics::SnapshotCreationLatency_us,
+                               std::chrono::duration_cast<std::chrono::microseconds>(timer.Elapsed()).count());
+  };
 
   std::lock_guard snapshot_guard(snapshot_lock_);
 
-  auto accessor = std::invoke([&]() {
-    if (storage_mode_ == StorageMode::IN_MEMORY_ANALYTICAL) {
-      // For analytical no other txn can be in play
-      return UniqueAccess(ReplicationRole::MAIN, IsolationLevel::SNAPSHOT_ISOLATION);
+  auto should_try_shared{true};
+  auto max_num_tries{10};
+  while (max_num_tries) {
+    if (should_try_shared) {
+      std::shared_lock storage_guard(main_lock_);
+      if (storage_mode_ == memgraph::storage::StorageMode::IN_MEMORY_TRANSACTIONAL) {
+        snapshot_creator();
+        return {};
+      }
     } else {
-      return Access(ReplicationRole::MAIN, IsolationLevel::SNAPSHOT_ISOLATION);
+      std::unique_lock main_guard{main_lock_};
+      if (storage_mode_ == memgraph::storage::StorageMode::IN_MEMORY_ANALYTICAL) {
+        snapshot_creator();
+        return {};
+      }
     }
-  });
+    should_try_shared = !should_try_shared;
+    max_num_tries--;
+  }
 
-  utils::Timer timer;
-  Transaction *transaction = accessor->GetTransaction();
-  auto const &epoch = repl_storage_state_.epoch_;
-  durability::CreateSnapshot(this, transaction, recovery_.snapshot_directory_, recovery_.wal_directory_, &vertices_,
-                             &edges_, uuid_, epoch, repl_storage_state_.history, &file_retainer_);
-
-  memgraph::metrics::Measure(memgraph::metrics::SnapshotCreationLatency_us,
-                             std::chrono::duration_cast<std::chrono::microseconds>(timer.Elapsed()).count());
-  return {};
+  return CreateSnapshotError::ReachedMaxNumTries;
 }
 
-void InMemoryStorage::FreeMemory(std::unique_lock<utils::ResourceLock> main_guard, bool periodic) {
-  CollectGarbage(std::move(main_guard), periodic);
+void InMemoryStorage::FreeMemory(std::unique_lock<utils::ResourceLock> main_guard) {
+  CollectGarbage<true>(std::move(main_guard));
 
   static_cast<InMemoryLabelIndex *>(indices_.label_index_.get())->RunGC();
   static_cast<InMemoryLabelPropertyIndex *>(indices_.label_property_index_.get())->RunGC();

src/storage/v2/inmemory/storage.hpp

@@ -332,7 +332,7 @@ class InMemoryStorage final : public Storage {
   std::unique_ptr<Accessor> UniqueAccess(memgraph::replication_coordination_glue::ReplicationRole replication_role,
                                          std::optional<IsolationLevel> override_isolation_level) override;
 
-  void FreeMemory(std::unique_lock<utils::ResourceLock> main_guard, bool periodic) override;
+  void FreeMemory(std::unique_lock<utils::ResourceLock> main_guard) override;
 
   utils::FileRetainer::FileLockerAccessor::ret_type IsPathLocked();
   utils::FileRetainer::FileLockerAccessor::ret_type LockPath();
@@ -363,7 +363,7 @@ class InMemoryStorage final : public Storage {
   /// @throw std::system_error
   /// @throw std::bad_alloc
   template <bool force>
-  void CollectGarbage(std::unique_lock<utils::ResourceLock> main_guard, bool periodic);
+  void CollectGarbage(std::unique_lock<utils::ResourceLock> main_guard = {});
 
   bool InitializeWalFile(memgraph::replication::ReplicationEpoch &epoch);
   void FinalizeWalFile();

src/storage/v2/property_store.cpp

@@ -1051,14 +1051,6 @@ struct SpecificPropertyAndBufferInfo {
   uint64_t all_size;
 };
 
-// Struct used to return info about the property position
-struct SpecificPropertyAndBufferInfoMinimal {
-  uint64_t property_begin;
-  uint64_t property_end;
-
-  auto property_size() const { return property_end - property_begin; }
-};
-
 // Function used to find the position where the property should be in the data
 // buffer. It keeps the properties in the buffer sorted by `PropertyId` and
 // returns the positions in the buffer where the seeked property starts and
@@ -1091,27 +1083,6 @@ SpecificPropertyAndBufferInfo FindSpecificPropertyAndBufferInfo(Reader *reader,
   return {property_begin, property_end, property_end - property_begin, all_begin, all_end, all_end - all_begin};
 }
 
-// Like FindSpecificPropertyAndBufferInfo, but will early exit. No need to find the "all" information
-SpecificPropertyAndBufferInfoMinimal FindSpecificPropertyAndBufferInfoMinimal(Reader *reader, PropertyId property) {
-  uint64_t property_begin = reader->GetPosition();
-  while (true) {
-    switch (HasExpectedProperty(reader, property)) {
-      case ExpectedPropertyStatus::MISSING_DATA:
-        [[fallthrough]];
-      case ExpectedPropertyStatus::GREATER: {
-        return {0, 0};
-      }
-      case ExpectedPropertyStatus::EQUAL: {
-        return {property_begin, reader->GetPosition()};
-      }
-      case ExpectedPropertyStatus::SMALLER: {
-        property_begin = reader->GetPosition();
-        break;
-      }
-    }
-  }
-}
-
 // All data buffers will be allocated to a power of 8 size.
 uint64_t ToPowerOf8(uint64_t size) {
   uint64_t mod = size % 8;
@@ -1283,12 +1254,11 @@ bool PropertyStore::IsPropertyEqual(PropertyId property, const PropertyValue &va
   BufferInfo buffer_info = GetBufferInfo(buffer_);
   Reader reader(buffer_info.data, buffer_info.size);
 
-  auto info = FindSpecificPropertyAndBufferInfoMinimal(&reader, property);
-  auto property_size = info.property_size();
-  if (property_size == 0) return value.IsNull();
-  Reader prop_reader(buffer_info.data + info.property_begin, property_size);
+  auto info = FindSpecificPropertyAndBufferInfo(&reader, property);
+  if (info.property_size == 0) return value.IsNull();
+  Reader prop_reader(buffer_info.data + info.property_begin, info.property_size);
   if (!CompareExpectedProperty(&prop_reader, property, value)) return false;
-  return prop_reader.GetPosition() == property_size;
+  return prop_reader.GetPosition() == info.property_size;
 }
 
 std::map<PropertyId, PropertyValue> PropertyStore::Properties() const {

src/storage/v2/replication/global.hpp

@@ -26,7 +26,7 @@ namespace memgraph::storage {
 
 struct TimestampInfo {
   uint64_t current_timestamp_of_replica;
-  uint64_t current_number_of_timestamp_behind_main;
+  uint64_t current_number_of_timestamp_behind_master;
 };
 
 struct ReplicaInfo {

src/storage/v2/replication/replication_client.cpp

@@ -53,25 +53,14 @@ void ReplicationStorageClient::UpdateReplicaState(Storage *storage, DatabaseAcce
 #endif
 
   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;
     }
   }
@@ -106,7 +95,7 @@ void ReplicationStorageClient::UpdateReplicaState(Storage *storage, DatabaseAcce
 TimestampInfo ReplicationStorageClient::GetTimestampInfo(Storage const *storage) {
   TimestampInfo info;
   info.current_timestamp_of_replica = 0;
-  info.current_number_of_timestamp_behind_main = 0;
+  info.current_number_of_timestamp_behind_master = 0;
 
   try {
     auto stream{client_.rpc_client_.Stream<replication::TimestampRpc>(main_uuid_, storage->uuid())};
@@ -115,9 +104,9 @@ TimestampInfo ReplicationStorageClient::GetTimestampInfo(Storage const *storage)
 
     auto main_time_stamp = storage->repl_storage_state_.last_commit_timestamp_.load();
     info.current_timestamp_of_replica = response.current_commit_timestamp;
-    info.current_number_of_timestamp_behind_main = response.current_commit_timestamp - main_time_stamp;
+    info.current_number_of_timestamp_behind_master = response.current_commit_timestamp - main_time_stamp;
 
-    if (!is_success || info.current_number_of_timestamp_behind_main != 0) {
+    if (!is_success || info.current_number_of_timestamp_behind_master != 0) {
       replica_state_.WithLock([](auto &val) { val = replication::ReplicaState::MAYBE_BEHIND; });
       LogRpcFailure();
     }
@@ -201,6 +190,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
@@ -223,11 +215,11 @@ bool ReplicationStorageClient::FinalizeTransactionReplication(Storage *storage,
     MG_ASSERT(replica_stream_, "Missing stream for transaction deltas");
     try {
       auto response = replica_stream_->Finalize();
-      return replica_state_.WithLock([storage, &response, db_acc = std::move(db_acc), this](auto &state) mutable {
+      return replica_state_.WithLock([storage, response, db_acc = std::move(db_acc), this](auto &state) mutable {
         replica_stream_.reset();
         if (!response.success || state == replication::ReplicaState::RECOVERY) {
           state = replication::ReplicaState::RECOVERY;
-          client_.thread_pool_.AddTask([storage, &response, db_acc = std::move(db_acc), this] {
+          client_.thread_pool_.AddTask([storage, response, db_acc = std::move(db_acc), this] {
             this->RecoverReplica(response.current_commit_timestamp, storage);
           });
           return false;

src/storage/v2/replication/replication_storage_state.hpp

@@ -63,7 +63,7 @@ struct ReplicationStorageState {
     return replication_clients_.WithLock([replica_name, cb = std::forward<F>(callback)](auto &clients) {
       for (const auto &client : clients) {
         if (client->Name() == replica_name) {
-          cb(*client);
+          cb(client.get());
           return true;
         }
       }

src/storage/v2/storage.hpp

@@ -284,8 +284,6 @@ class Storage {
     virtual UniqueConstraints::DeletionStatus DropUniqueConstraint(LabelId label,
                                                                    const std::set<PropertyId> &properties) = 0;
 
-    auto GetTransaction() -> Transaction * { return std::addressof(transaction_); }
-
    protected:
     Storage *storage_;
     std::shared_lock<utils::ResourceLock> storage_guard_;
@@ -338,15 +336,9 @@ class Storage {
 
   StorageMode GetStorageMode() const noexcept;
 
-  virtual void FreeMemory(std::unique_lock<utils::ResourceLock> main_guard, bool periodic) = 0;
+  virtual void FreeMemory(std::unique_lock<utils::ResourceLock> main_guard) = 0;
 
-  void FreeMemory() {
-    if (storage_mode_ == StorageMode::IN_MEMORY_ANALYTICAL) {
-      FreeMemory(std::unique_lock{main_lock_}, false);
-    } else {
-      FreeMemory({}, false);
-    }
-  }
+  void FreeMemory() { FreeMemory({}); }
 
   virtual std::unique_ptr<Accessor> Access(memgraph::replication_coordination_glue::ReplicationRole replication_role,
                                            std::optional<IsolationLevel> override_isolation_level) = 0;

src/system/include/system/system.hpp

@@ -34,7 +34,7 @@ struct System {
     if (!system_unique.try_lock_for(try_time)) {
       return std::nullopt;
     }
-    return Transaction{state_, std::move(system_unique), ++timestamp_};
+    return Transaction{state_, std::move(system_unique), timestamp_++};
   }
 
   // TODO: this and LastCommittedSystemTimestamp maybe not needed
@@ -46,7 +46,7 @@ struct System {
  private:
   State state_;
   std::timed_mutex mtx_{};
-  std::uint64_t timestamp_{0};
+  std::uint64_t timestamp_{};
 };
 
 }  // namespace memgraph::system

src/utils/CMakeLists.txt

@@ -24,7 +24,6 @@ find_package(Threads REQUIRED)
 
 add_library(mg-utils STATIC ${utils_src_files})
 add_library(mg::utils ALIAS mg-utils)
-
 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)
 

src/utils/disk_utils.hpp

@@ -21,7 +21,7 @@ inline std::optional<std::string> GetOldDiskKeyOrNull(storage::Delta *head) {
     head = head->next;
   }
   if (head->action == storage::Delta::Action::DELETE_DESERIALIZED_OBJECT) {
-    return head->old_disk_key.value.as_opt_str();
+    return head->old_disk_key.value;
   }
   return std::nullopt;
 }

src/utils/functional.hpp

@@ -18,11 +18,8 @@
 
 namespace memgraph::utils {
 
-template <template <typename, typename...> class Container, typename T, typename Allocator = std::allocator<T>,
-          typename F, typename R = std::invoke_result_t<F, T>>
-requires ranges::range<Container<T, Allocator>> &&
-    (!std::same_as<Container<T, Allocator>, std::string>)auto fmap(F &&f, const Container<T, Allocator> &v)
-        -> std::vector<R> {
+template <class F, class T, class R = typename std::invoke_result<F, T>::type>
+auto fmap(F &&f, std::vector<T> const &v) -> std::vector<R> {
   return v | ranges::views::transform(std::forward<F>(f)) | ranges::to<std::vector<R>>();
 }
 

src/utils/resource_lock.hpp

@@ -66,17 +66,6 @@ struct ResourceLock {
     }
     return false;
   }
-
-  template <typename Rep, typename Period>
-  bool try_lock_shared_for(std::chrono::duration<Rep, Period> const &time) {
-    auto lock = std::unique_lock{mtx};
-    // block until available
-    if (!cv.wait_for(lock, time, [this] { return state != UNIQUE; })) return false;
-    state = SHARED;
-    ++count;
-    return true;
-  }
-
   void unlock() {
     auto lock = std::unique_lock{mtx};
     state = UNLOCKED;

src/utils/scheduler.hpp

@@ -57,7 +57,7 @@ class Scheduler {
         // program and there is probably no work to do in scheduled function at
         // the start of the program. Since Server will log some messages on
         // the program start we let him log first and we make sure by first
-        // waiting that function f will not log before it.
+        // waiting that funcion f will not log before it.
         // Check for pause also.
         std::unique_lock<std::mutex> lk(mutex_);
         auto now = std::chrono::system_clock::now();

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.
@@ -249,7 +242,7 @@ std::vector<TString, TAllocator> *Split(std::vector<TString, TAllocator> *out, c
   if (src.empty()) return out;
   // TODO: Investigate how much regex allocate and perhaps replace with custom
   // solution doing no allocations.
-  static std::regex not_whitespace("[^\\s]+");
+  std::regex not_whitespace("[^\\s]+");
   auto matches_begin = std::cregex_iterator(src.data(), src.data() + src.size(), not_whitespace);
   auto matches_end = std::cregex_iterator();
   out->reserve(std::distance(matches_begin, matches_end));

src/utils/typeinfo.hpp

@@ -114,8 +114,6 @@ enum class TypeId : uint64_t {
 
   COORD_GET_UUID_REQ,
   COORD_GET_UUID_RES,
-  COORD_GET_INSTANCE_DATABASES_REQ,
-  COORD_GET_INSTANCE_DATABASES_RES,
 
   // AST
   AST_LABELIX = 3000,

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,42 +305,17 @@ 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 = [
-        (
-            "instance_1",
-            "127.0.0.1:10001",
-            "sync",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-        (
-            "instance_2",
-            "127.0.0.1:10002",
-            "sync",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
+        ("instance_1", "127.0.0.1:10001", "sync", 0, 0, "ready"),
+        ("instance_2", "127.0.0.1:10002", "sync", 0, 0, "ready"),
     ]
 
-    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,33 +324,15 @@ 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 = [
-        (
-            "instance_2",
-            "127.0.0.1:10002",
-            "sync",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
+        ("instance_2", "127.0.0.1:10002", "sync", 0, 0, "ready"),
     ]
 
-    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 +341,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 +354,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 +366,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,53 +389,24 @@ 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 = [
-        (
-            "instance_2",
-            "127.0.0.1:10002",
-            "sync",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
+        ("instance_2", "127.0.0.1:10002", "sync", 0, 0, "ready"),
     ]
 
     main_cursor = connect(host="localhost", port=7687).cursor()
@@ -538,8 +414,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
 
 interactive_mg_runner.SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))
 interactive_mg_runner.PROJECT_DIR = os.path.normpath(
@@ -123,58 +118,31 @@ 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 = [
-        (
-            "instance_1",
-            "127.0.0.1:10001",
-            "sync",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-        (
-            "instance_2",
-            "127.0.0.1:10002",
-            "sync",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
+        ("instance_1", "127.0.0.1:10001", "sync", 0, 0, "ready"),
+        ("instance_2", "127.0.0.1:10002", "sync", 0, 0, "ready"),
     ]
+    actual_data_on_main = sorted(list(execute_and_fetch_all(main_cursor, "SHOW REPLICAS;")))
+    assert actual_data_on_main == 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)
 
@@ -184,463 +152,19 @@ def test_distributed_automatic_failover():
         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"}},
-        ),
+        ("instance_2", "127.0.0.1:10002", "sync", 0, 0, "ready"),
+        ("instance_3", "127.0.0.1:10003", "sync", 0, 0, "invalid"),
     ]
-    mg_sleep_and_assert_collection(expected_data_on_new_main, retrieve_data_show_replicas)
+    mg_sleep_and_assert(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"}},
-        ),
+        ("instance_2", "127.0.0.1:10002", "sync", 0, 0, "ready"),
+        ("instance_3", "127.0.0.1:10003", "sync", 0, 0, "ready"),
     ]
 
-    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
+    mg_sleep_and_assert(expected_data_on_new_main_old_alive, retrieve_data_show_replicas)
 
 
 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

@@ -67,19 +67,10 @@ def test_replication_works_on_failover():
     # 2
     main_cursor = connect(host="localhost", port=7687).cursor()
     expected_data_on_main = [
-        (
-            "shared_replica",
-            "127.0.0.1:10001",
-            "sync",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
+        ("shared_replica", "127.0.0.1:10001", "sync", 0, 0, "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)
@@ -91,20 +82,8 @@ def test_replication_works_on_failover():
         return sorted(list(execute_and_fetch_all(new_main_cursor, "SHOW REPLICAS;")))
 
     expected_data_on_new_main = [
-        (
-            "replica",
-            "127.0.0.1:10002",
-            "sync",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-        (
-            "shared_replica",
-            "127.0.0.1:10001",
-            "sync",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
+        ("replica", "127.0.0.1:10002", "sync", 0, 0, "ready"),
+        ("shared_replica", "127.0.0.1:10001", "sync", 0, 0, "ready"),
     ]
     mg_sleep_and_assert(expected_data_on_new_main, retrieve_data_show_replicas)
 
@@ -203,9 +182,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 +236,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

@@ -15,43 +15,3 @@ def mg_sleep_and_assert(expected_value, function_to_retrieve_data, max_duration=
         result = function_to_retrieve_data()
 
     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
-):
-    result = function_to_retrieve_data()
-    start_time = time.time()
-    while len(result) != len(expected_value) or any((x not in result for x in 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 = function_to_retrieve_data()
-
-    return result

tests/e2e/query_modules/schema_test.py

@@ -431,7 +431,7 @@ def test_node_type_properties1():
             f"CALL libschema.node_type_properties() YIELD nodeType, nodeLabels, propertyName, propertyTypes , mandatory RETURN nodeType, nodeLabels, propertyName, propertyTypes , mandatory ORDER BY propertyName, nodeLabels[0];",
         )[0]
     )
-    assert (result) == [":`Activity`", ["Activity"], "location", ["String"], True]
+    assert (result) == [":`Activity`", ["Activity"], "location", "String", False]
 
     result = list(
         execute_and_fetch_all(
@@ -439,7 +439,7 @@ def test_node_type_properties1():
             f"CALL libschema.node_type_properties() YIELD nodeType, nodeLabels, propertyName, propertyTypes , mandatory RETURN nodeType, nodeLabels, propertyName, propertyTypes , mandatory ORDER BY propertyName, nodeLabels[0];",
         )[1]
     )
-    assert (result) == [":`Activity`", ["Activity"], "name", ["String"], True]
+    assert (result) == [":`Activity`", ["Activity"], "name", "String", False]
 
     result = list(
         execute_and_fetch_all(
@@ -447,7 +447,7 @@ def test_node_type_properties1():
             f"CALL libschema.node_type_properties() YIELD nodeType, nodeLabels, propertyName, propertyTypes , mandatory RETURN nodeType, nodeLabels, propertyName, propertyTypes , mandatory ORDER BY propertyName, nodeLabels[0];",
         )[2]
     )
-    assert (result) == [":`Dog`", ["Dog"], "name", ["String"], True]
+    assert (result) == [":`Dog`", ["Dog"], "name", "String", False]
 
     result = list(
         execute_and_fetch_all(
@@ -455,7 +455,7 @@ def test_node_type_properties1():
             f"CALL libschema.node_type_properties() YIELD nodeType, nodeLabels, propertyName, propertyTypes , mandatory RETURN nodeType, nodeLabels, propertyName, propertyTypes , mandatory ORDER BY propertyName, nodeLabels[0];",
         )[3]
     )
-    assert (result) == [":`Dog`", ["Dog"], "owner", ["String"], True]
+    assert (result) == [":`Dog`", ["Dog"], "owner", "String", False]
 
 
 def test_node_type_properties2():
@@ -471,8 +471,7 @@ def test_node_type_properties2():
         cursor,
         f"CALL libschema.node_type_properties() YIELD nodeType, nodeLabels, propertyName, propertyTypes , mandatory RETURN nodeType, nodeLabels, propertyName, propertyTypes , mandatory ORDER BY propertyName, nodeLabels[0];",
     )
-
-    assert (list(result[0])) == [":`MyNode`", ["MyNode"], "", [], False]
+    assert (list(result[0])) == [":`MyNode`", ["MyNode"], "", "", False]
     assert (result.__len__()) == 1
 
 
@@ -490,8 +489,8 @@ def test_node_type_properties3():
         f"CALL libschema.node_type_properties() YIELD nodeType, nodeLabels, propertyName, propertyTypes , mandatory RETURN nodeType, nodeLabels, propertyName, propertyTypes , mandatory ORDER BY propertyName, nodeLabels[0];",
     )
 
-    assert (list(result[0])) == [":`Dog`", ["Dog"], "name", ["String"], False]
-    assert (list(result[1])) == [":`Dog`", ["Dog"], "owner", ["String"], False]
+    assert (list(result[0])) == [":`Dog`", ["Dog"], "name", "String", False]
+    assert (list(result[1])) == [":`Dog`", ["Dog"], "owner", "String", False]
     assert (result.__len__()) == 2
 
 
@@ -510,9 +509,9 @@ def test_node_type_properties4():
             f"CALL libschema.node_type_properties() YIELD nodeType, nodeLabels, propertyName, propertyTypes , mandatory RETURN nodeType, nodeLabels, propertyName, propertyTypes , mandatory ORDER BY propertyName, nodeLabels[0];",
         )
     )
-    assert (list(result[0])) == [":`Label1`:`Label2`", ["Label1", "Label2"], "property1", ["String"], False]
-    assert (list(result[1])) == [":`Label1`:`Label2`", ["Label1", "Label2"], "property2", ["String"], False]
-    assert (list(result[2])) == [":`Label1`:`Label2`", ["Label1", "Label2"], "property3", ["String"], False]
+    assert (list(result[0])) == [":`Label1`:`Label2`", ["Label1", "Label2"], "property1", "String", False]
+    assert (list(result[1])) == [":`Label1`:`Label2`", ["Label1", "Label2"], "property2", "String", False]
+    assert (list(result[2])) == [":`Label1`:`Label2`", ["Label1", "Label2"], "property3", "String", False]
     assert (result.__len__()) == 3
 
 
@@ -529,49 +528,7 @@ def test_node_type_properties5():
         f"CALL libschema.node_type_properties() YIELD nodeType, nodeLabels, propertyName, propertyTypes , mandatory RETURN nodeType, nodeLabels, propertyName, propertyTypes , mandatory ORDER BY propertyName, nodeLabels[0];",
     )
 
-    assert (list(result[0])) == [":`Dog`", ["Dog"], "name", ["String"], True]
-    assert (result.__len__()) == 1
-
-
-def test_node_type_properties6():
-    cursor = connect().cursor()
-    execute_and_fetch_all(
-        cursor,
-        """
-        CREATE (d:Dog {name: 'Rex'})
-        CREATE (n:Dog {name: 'Simba', owner: 'Lucy'})
-        """,
-    )
-    result = execute_and_fetch_all(
-        cursor,
-        f"CALL libschema.node_type_properties() YIELD nodeType, nodeLabels, propertyName, propertyTypes , mandatory RETURN nodeType, nodeLabels, propertyName, propertyTypes , mandatory ORDER BY propertyName, nodeLabels[0];",
-    )
-
-    assert (list(result[0])) == [":`Dog`", ["Dog"], "name", ["String"], True]
-    assert (list(result[1])) == [":`Dog`", ["Dog"], "owner", ["String"], False]
-    assert (result.__len__()) == 2
-
-
-def test_node_type_properties_multiple_property_types():
-    cursor = connect().cursor()
-    execute_and_fetch_all(
-        cursor,
-        """
-        CREATE (n:Node {prop1: 1})
-        CREATE (m:Node {prop1: '1'})
-        """,
-    )
-    result = execute_and_fetch_all(
-        cursor,
-        f"CALL libschema.node_type_properties() YIELD nodeType, nodeLabels, propertyName, propertyTypes , mandatory RETURN nodeType, nodeLabels, propertyName, propertyTypes , mandatory ORDER BY propertyName, nodeLabels[0];",
-    )
-    assert (list(result[0])) == [":`Node`", ["Node"], "prop1", ["Int", "String"], True] or (list(result[0])) == [
-        ":`Node`",
-        ["Node"],
-        "prop1",
-        ["String", "Int"],
-        True,
-    ]
+    assert (list(result[0])) == [":`Dog`", ["Dog"], "name", "String", True]
     assert (result.__len__()) == 1
 
 
@@ -587,7 +544,7 @@ def test_rel_type_properties1():
             f"CALL libschema.rel_type_properties() YIELD relType,propertyName, propertyTypes , mandatory RETURN relType, propertyName, propertyTypes , mandatory;",
         )[0]
     )
-    assert (result) == [":`LOVES`", "", [], False]
+    assert (result) == [":`LOVES`", "", "", False]
 
 
 def test_rel_type_properties2():
@@ -603,7 +560,7 @@ def test_rel_type_properties2():
         cursor,
         f"CALL libschema.rel_type_properties() YIELD relType,propertyName, propertyTypes , mandatory RETURN relType, propertyName, propertyTypes , mandatory;",
     )
-    assert (list(result[0])) == [":`LOVES`", "duration", ["Int"], False]
+    assert (list(result[0])) == [":`LOVES`", "duration", "Int", False]
     assert (result.__len__()) == 1
 
 
@@ -619,47 +576,7 @@ def test_rel_type_properties3():
         cursor,
         f"CALL libschema.rel_type_properties() YIELD relType,propertyName, propertyTypes , mandatory RETURN relType, propertyName, propertyTypes , mandatory;",
     )
-    assert (list(result[0])) == [":`LOVES`", "duration", ["Int"], True]
-    assert (result.__len__()) == 1
-
-
-def test_rel_type_properties4():
-    cursor = connect().cursor()
-    execute_and_fetch_all(
-        cursor,
-        """
-        CREATE (n:Dog {name: 'Simba', owner: 'Lucy'})-[j:LOVES {duration: 30}]->(a:Activity {name: 'Running', location: 'Zadar'})
-        CREATE (m:Dog {name: 'Rex', owner: 'Lucy'})-[r:LOVES {duration: 30, weather: 'sunny'}]->(b:Activity {name: 'Running', location: 'Zadar'})
-        """,
-    )
-    result = execute_and_fetch_all(
-        cursor,
-        f"CALL libschema.rel_type_properties() YIELD relType,propertyName, propertyTypes , mandatory RETURN relType, propertyName, propertyTypes , mandatory;",
-    )
-    assert (list(result[0])) == [":`LOVES`", "weather", ["String"], False]
-    assert (list(result[1])) == [":`LOVES`", "duration", ["Int"], True]
-    assert (result.__len__()) == 2
-
-
-def test_rel_type_properties_multiple_property_types():
-    cursor = connect().cursor()
-    execute_and_fetch_all(
-        cursor,
-        """
-        CREATE (n:Dog {name: 'Simba', owner: 'Lucy'})-[j:LOVES {duration: 30}]->(a:Activity {name: 'Running', location: 'Zadar'})
-        CREATE (m:Dog {name: 'Rex', owner: 'Lucy'})-[r:LOVES {duration: "30"}]->(b:Activity {name: 'Running', location: 'Zadar'})
-        """,
-    )
-    result = execute_and_fetch_all(
-        cursor,
-        f"CALL libschema.rel_type_properties() YIELD relType,propertyName, propertyTypes , mandatory RETURN relType, propertyName, propertyTypes , mandatory;",
-    )
-    assert (list(result[0])) == [":`LOVES`", "duration", ["Int", "String"], True] or (list(result[0])) == [
-        ":`LOVES`",
-        "duration",
-        ["String", "Int"],
-        True,
-    ]
+    assert (list(result[0])) == [":`LOVES`", "duration", "Int", True]
     assert (result.__len__()) == 1
 
 

tests/e2e/replication/edge_delete.py

@@ -14,7 +14,7 @@ import time
 
 import pytest
 from common import execute_and_fetch_all
-from mg_utils import mg_sleep_and_assert_collection
+from mg_utils import mg_sleep_and_assert
 
 
 # BUGFIX: for issue https://github.com/memgraph/memgraph/issues/1515
@@ -28,52 +28,28 @@ def test_replication_handles_delete_when_multiple_edges_of_same_type(connection)
     conn = connection(7687, "main")
     conn.autocommit = True
     cursor = conn.cursor()
-    actual_data = execute_and_fetch_all(cursor, "SHOW REPLICAS;")
+    actual_data = set(execute_and_fetch_all(cursor, "SHOW REPLICAS;"))
 
-    expected_data = [
-        (
-            "replica_1",
-            "127.0.0.1:10001",
-            "sync",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-        (
-            "replica_2",
-            "127.0.0.1:10002",
-            "async",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-    ]
-    assert all([x in actual_data for x in expected_data])
+    expected_data = {
+        ("replica_1", "127.0.0.1:10001", "sync", 0, 0, "ready"),
+        ("replica_2", "127.0.0.1:10002", "async", 0, 0, "ready"),
+    }
+    assert actual_data == expected_data
 
     # 1/
     execute_and_fetch_all(cursor, "CREATE (a)-[r:X]->(b) CREATE (a)-[:X]->(b) DELETE r;")
 
     # 2/
-    expected_data = [
-        (
-            "replica_1",
-            "127.0.0.1:10001",
-            "sync",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 2, "behind": 0, "status": "ready"}},
-        ),
-        (
-            "replica_2",
-            "127.0.0.1:10002",
-            "async",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 2, "behind": 0, "status": "ready"}},
-        ),
-    ]
+    expected_data = {
+        ("replica_1", "127.0.0.1:10001", "sync", 2, 0, "ready"),
+        ("replica_2", "127.0.0.1:10002", "async", 2, 0, "ready"),
+    }
 
     def retrieve_data():
-        return execute_and_fetch_all(cursor, "SHOW REPLICAS;")
+        return set(execute_and_fetch_all(cursor, "SHOW REPLICAS;"))
 
-    actual_data = mg_sleep_and_assert_collection(expected_data, retrieve_data)
-    assert all([x in actual_data for x in expected_data])
+    actual_data = mg_sleep_and_assert(expected_data, retrieve_data)
+    assert actual_data == expected_data
 
 
 if __name__ == "__main__":

tests/e2e/replication/show.py

@@ -10,11 +10,12 @@
 # licenses/APL.txt.
 
 import sys
-import time
 
 import pytest
+import time
+
 from common import execute_and_fetch_all
-from mg_utils import mg_sleep_and_assert_collection
+from mg_utils import mg_sleep_and_assert
 
 
 @pytest.mark.parametrize(
@@ -30,42 +31,25 @@ def test_show_replication_role(port, role, connection):
 
 def test_show_replicas(connection):
     cursor = connection(7687, "main").cursor()
-    actual_data = execute_and_fetch_all(cursor, "SHOW REPLICAS;")
+    actual_data = set(execute_and_fetch_all(cursor, "SHOW REPLICAS;"))
 
     expected_column_names = {
         "name",
         "socket_address",
         "sync_mode",
-        "system_info",
-        "data_info",
+        "current_timestamp_of_replica",
+        "number_of_timestamp_behind_master",
+        "state",
     }
     actual_column_names = {x.name for x in cursor.description}
     assert actual_column_names == expected_column_names
 
-    expected_data = [
-        (
-            "replica_1",
-            "127.0.0.1:10001",
-            "sync",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-        (
-            "replica_2",
-            "127.0.0.1:10002",
-            "sync",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-        (
-            "replica_3",
-            "127.0.0.1:10003",
-            "async",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-    ]
-    assert all([x in actual_data for x in expected_data])
+    expected_data = {
+        ("replica_1", "127.0.0.1:10001", "sync", 0, 0, "ready"),
+        ("replica_2", "127.0.0.1:10002", "sync", 0, 0, "ready"),
+        ("replica_3", "127.0.0.1:10003", "async", 0, 0, "ready"),
+    }
+    assert actual_data == expected_data
 
 
 def test_show_replicas_while_inserting_data(connection):
@@ -78,108 +62,49 @@ def test_show_replicas_while_inserting_data(connection):
 
     # 0/
     cursor = connection(7687, "main").cursor()
-    actual_data = execute_and_fetch_all(cursor, "SHOW REPLICAS;")
+    actual_data = set(execute_and_fetch_all(cursor, "SHOW REPLICAS;"))
 
     expected_column_names = {
         "name",
         "socket_address",
         "sync_mode",
-        "system_info",
-        "data_info",
+        "current_timestamp_of_replica",
+        "number_of_timestamp_behind_master",
+        "state",
     }
     actual_column_names = {x.name for x in cursor.description}
     assert actual_column_names == expected_column_names
 
-    expected_data = [
-        (
-            "replica_1",
-            "127.0.0.1:10001",
-            "sync",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-        (
-            "replica_2",
-            "127.0.0.1:10002",
-            "sync",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-        (
-            "replica_3",
-            "127.0.0.1:10003",
-            "async",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-    ]
-    assert all([x in actual_data for x in expected_data])
+    expected_data = {
+        ("replica_1", "127.0.0.1:10001", "sync", 0, 0, "ready"),
+        ("replica_2", "127.0.0.1:10002", "sync", 0, 0, "ready"),
+        ("replica_3", "127.0.0.1:10003", "async", 0, 0, "ready"),
+    }
+    assert actual_data == expected_data
 
     # 1/
     execute_and_fetch_all(cursor, "CREATE (n1:Number {name: 'forty_two', value:42});")
 
     # 2/
-    expected_data = [
-        (
-            "replica_1",
-            "127.0.0.1:10001",
-            "sync",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 4, "behind": 0, "status": "ready"}},
-        ),
-        (
-            "replica_2",
-            "127.0.0.1:10002",
-            "sync",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 4, "behind": 0, "status": "ready"}},
-        ),
-        (
-            "replica_3",
-            "127.0.0.1:10003",
-            "async",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 4, "behind": 0, "status": "ready"}},
-        ),
-    ]
+    expected_data = {
+        ("replica_1", "127.0.0.1:10001", "sync", 4, 0, "ready"),
+        ("replica_2", "127.0.0.1:10002", "sync", 4, 0, "ready"),
+        ("replica_3", "127.0.0.1:10003", "async", 4, 0, "ready"),
+    }
 
     def retrieve_data():
-        return execute_and_fetch_all(cursor, "SHOW REPLICAS;")
+        return set(execute_and_fetch_all(cursor, "SHOW REPLICAS;"))
 
-    actual_data = mg_sleep_and_assert_collection(expected_data, retrieve_data)
-    assert all([x in actual_data for x in expected_data])
+    actual_data = mg_sleep_and_assert(expected_data, retrieve_data)
+    assert actual_data == expected_data
 
     # 3/
     res = execute_and_fetch_all(cursor, "MATCH (node) return node;")
     assert len(res) == 1
 
     # 4/
-    expected_data = [
-        (
-            "replica_1",
-            "127.0.0.1:10001",
-            "sync",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 4, "behind": 0, "status": "ready"}},
-        ),
-        (
-            "replica_2",
-            "127.0.0.1:10002",
-            "sync",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 4, "behind": 0, "status": "ready"}},
-        ),
-        (
-            "replica_3",
-            "127.0.0.1:10003",
-            "async",
-            {"ts": 0, "behind": None, "status": "ready"},
-            {"memgraph": {"ts": 4, "behind": 0, "status": "ready"}},
-        ),
-    ]
-
-    actual_data = execute_and_fetch_all(cursor, "SHOW REPLICAS;")
-    assert all([x in actual_data for x in expected_data])
+    actual_data = set(execute_and_fetch_all(cursor, "SHOW REPLICAS;"))
+    assert actual_data == expected_data
 
 
 if __name__ == "__main__":

tests/e2e/replication_experimental/multitenancy.py

@@ -22,7 +22,7 @@ import interactive_mg_runner
 import mgclient
 import pytest
 from common import execute_and_fetch_all
-from mg_utils import mg_sleep_and_assert, mg_sleep_and_assert_collection
+from mg_utils import mg_sleep_and_assert
 
 interactive_mg_runner.SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))
 interactive_mg_runner.PROJECT_DIR = os.path.normpath(
@@ -35,10 +35,6 @@ BOLT_PORTS = {"main": 7687, "replica_1": 7688, "replica_2": 7689}
 REPLICATION_PORTS = {"replica_1": 10001, "replica_2": 10002}
 
 
-def set_eq(actual, expected):
-    return len(actual) == len(expected) and all([x in actual for x in expected])
-
-
 def create_memgraph_instances_with_role_recovery(data_directory: Any) -> Dict[str, Any]:
     return {
         "replica_1": {
@@ -178,9 +174,10 @@ def setup_main(main_cursor):
     execute_and_fetch_all(main_cursor, "CREATE (:Node{on:'B'});")
 
 
-def show_replicas_func(cursor):
+def show_replicas_func(cursor, db_name):
     def func():
-        return execute_and_fetch_all(cursor, "SHOW REPLICAS;")
+        execute_and_fetch_all(cursor, f"USE DATABASE {db_name};")
+        return set(execute_and_fetch_all(cursor, "SHOW REPLICAS;"))
 
     return func
 
@@ -274,31 +271,17 @@ def test_manual_databases_create_multitenancy_replication(connection):
     execute_and_fetch_all(cursor, "CREATE ()-[:EDGE]->();")
 
     # 2/
-    expected_data = [
-        (
-            "replica_1",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_1']}",
-            "sync",
-            {"ts": 2, "behind": None, "status": "ready"},
-            {
-                "A": {"ts": 1, "behind": 0, "status": "ready"},
-                "B": {"ts": 1, "behind": 0, "status": "ready"},
-                "memgraph": {"ts": 0, "behind": 0, "status": "ready"},
-            },
-        ),
-        (
-            "replica_2",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_2']}",
-            "async",
-            {"ts": 2, "behind": None, "status": "ready"},
-            {
-                "A": {"ts": 1, "behind": 0, "status": "ready"},
-                "B": {"ts": 1, "behind": 0, "status": "ready"},
-                "memgraph": {"ts": 0, "behind": 0, "status": "ready"},
-            },
-        ),
-    ]
-    mg_sleep_and_assert_collection(expected_data, show_replicas_func(cursor))
+    expected_data = {
+        ("replica_1", f"127.0.0.1:{REPLICATION_PORTS['replica_1']}", "sync", 1, 0, "ready"),
+        ("replica_2", f"127.0.0.1:{REPLICATION_PORTS['replica_2']}", "async", 1, 0, "ready"),
+    }
+    mg_sleep_and_assert(expected_data, show_replicas_func(cursor, "A"))
+
+    expected_data = {
+        ("replica_1", f"127.0.0.1:{REPLICATION_PORTS['replica_1']}", "sync", 1, 0, "ready"),
+        ("replica_2", f"127.0.0.1:{REPLICATION_PORTS['replica_2']}", "async", 1, 0, "ready"),
+    }
+    mg_sleep_and_assert(expected_data, show_replicas_func(cursor, "B"))
 
     cursor_replica = connection(BOLT_PORTS["replica_1"], "replica").cursor()
     assert get_number_of_nodes_func(cursor_replica, "A")() == 1
@@ -540,23 +523,11 @@ def test_manual_databases_create_multitenancy_replication_main_behind(connection
     execute_and_fetch_all(main_cursor, "CREATE DATABASE A;")
 
     # 2/
-    expected_data = [
-        (
-            "replica_1",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_1']}",
-            "sync",
-            {"ts": 3, "behind": None, "status": "ready"},
-            {"A": {"ts": 0, "behind": 0, "status": "ready"}, "memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-        (
-            "replica_2",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_2']}",
-            "async",
-            {"ts": 3, "behind": None, "status": "ready"},
-            {"A": {"ts": 0, "behind": 0, "status": "ready"}, "memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-    ]
-    mg_sleep_and_assert_collection(expected_data, show_replicas_func(main_cursor))
+    expected_data = {
+        ("replica_1", f"127.0.0.1:{REPLICATION_PORTS['replica_1']}", "sync", 0, 0, "ready"),
+        ("replica_2", f"127.0.0.1:{REPLICATION_PORTS['replica_2']}", "async", 0, 0, "ready"),
+    }
+    mg_sleep_and_assert(expected_data, show_replicas_func(main_cursor, "A"))
 
     databases_on_main = show_databases_func(main_cursor)()
 
@@ -596,31 +567,17 @@ def test_automatic_databases_create_multitenancy_replication(connection):
     execute_and_fetch_all(main_cursor, "CREATE (:Node)-[:EDGE]->(:Node)")
 
     # 3/
-    expected_data = [
-        (
-            "replica_1",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_1']}",
-            "sync",
-            {"ts": 4, "behind": None, "status": "ready"},
-            {
-                "A": {"ts": 7, "behind": 0, "status": "ready"},
-                "B": {"ts": 0, "behind": 0, "status": "ready"},
-                "memgraph": {"ts": 0, "behind": 0, "status": "ready"},
-            },
-        ),
-        (
-            "replica_2",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_2']}",
-            "async",
-            {"ts": 4, "behind": None, "status": "ready"},
-            {
-                "A": {"ts": 7, "behind": 0, "status": "ready"},
-                "B": {"ts": 0, "behind": 0, "status": "ready"},
-                "memgraph": {"ts": 0, "behind": 0, "status": "ready"},
-            },
-        ),
-    ]
-    mg_sleep_and_assert_collection(expected_data, show_replicas_func(main_cursor))
+    expected_data = {
+        ("replica_1", f"127.0.0.1:{REPLICATION_PORTS['replica_1']}", "sync", 7, 0, "ready"),
+        ("replica_2", f"127.0.0.1:{REPLICATION_PORTS['replica_2']}", "async", 7, 0, "ready"),
+    }
+    mg_sleep_and_assert(expected_data, show_replicas_func(main_cursor, "A"))
+
+    expected_data = {
+        ("replica_1", f"127.0.0.1:{REPLICATION_PORTS['replica_1']}", "sync", 0, 0, "ready"),
+        ("replica_2", f"127.0.0.1:{REPLICATION_PORTS['replica_2']}", "async", 0, 0, "ready"),
+    }
+    mg_sleep_and_assert(expected_data, show_replicas_func(main_cursor, "B"))
 
     cursor_replica = connection(BOLT_PORTS["replica_1"], "replica").cursor()
     assert get_number_of_nodes_func(cursor_replica, "A")() == 7
@@ -683,26 +640,19 @@ def test_automatic_databases_multitenancy_replication_predefined(connection):
     execute_and_fetch_all(cursor, "CREATE ()-[:EDGE]->();")
 
     # 2/
-    expected_data = [
-        (
-            "replica_1",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_1']}",
-            "sync",
-            {"ts": 2, "behind": None, "status": "ready"},
-            {
-                "A": {"ts": 1, "behind": 0, "status": "ready"},
-                "B": {"ts": 1, "behind": 0, "status": "ready"},
-                "memgraph": {"ts": 0, "behind": 0, "status": "ready"},
-            },
-        ),
-    ]
-    mg_sleep_and_assert_collection(expected_data, show_replicas_func(cursor))
+    expected_data = {
+        ("replica_1", f"127.0.0.1:{REPLICATION_PORTS['replica_1']}", "sync", 1, 0, "ready"),
+    }
+    mg_sleep_and_assert(expected_data, show_replicas_func(cursor, "A"))
+
+    expected_data = {
+        ("replica_1", f"127.0.0.1:{REPLICATION_PORTS['replica_1']}", "sync", 1, 0, "ready"),
+    }
+    mg_sleep_and_assert(expected_data, show_replicas_func(cursor, "B"))
 
     cursor_replica = connection(BOLT_PORTS["replica_1"], "replica").cursor()
     assert get_number_of_nodes_func(cursor_replica, "A")() == 1
     assert get_number_of_edges_func(cursor_replica, "A")() == 0
-    assert get_number_of_nodes_func(cursor_replica, "B")() == 2
-    assert get_number_of_edges_func(cursor_replica, "B")() == 1
 
 
 def test_automatic_databases_create_multitenancy_replication_dirty_main(connection):
@@ -748,16 +698,10 @@ def test_automatic_databases_create_multitenancy_replication_dirty_main(connecti
     cursor = connection(BOLT_PORTS["main"], "main").cursor()
 
     # 1/
-    expected_data = [
-        (
-            "replica_1",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_1']}",
-            "sync",
-            {"ts": 1, "behind": None, "status": "ready"},
-            {"A": {"ts": 1, "behind": 0, "status": "ready"}, "memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-    ]
-    mg_sleep_and_assert_collection(expected_data, show_replicas_func(cursor))
+    expected_data = {
+        ("replica_1", f"127.0.0.1:{REPLICATION_PORTS['replica_1']}", "sync", 1, 0, "ready"),
+    }
+    mg_sleep_and_assert(expected_data, show_replicas_func(cursor, "A"))
 
     cursor_replica = connection(BOLT_PORTS["replica_1"], "replica").cursor()
     execute_and_fetch_all(cursor_replica, "USE DATABASE A;")
@@ -796,85 +740,31 @@ def test_multitenancy_replication_restart_replica_w_fc(connection, replica_name)
     time.sleep(3)  # In order for the frequent check to run
     # Check that the FC did invalidate
     expected_data = {
-        "replica_1": [
-            (
-                "replica_1",
-                f"127.0.0.1:{REPLICATION_PORTS['replica_1']}",
-                "sync",
-                {"ts": 4, "behind": None, "status": "ready"},
-                {
-                    "A": {"ts": 0, "behind": 0, "status": "invalid"},
-                    "B": {"ts": 0, "behind": 0, "status": "invalid"},
-                    "memgraph": {"ts": 0, "behind": 0, "status": "invalid"},
-                },
-            ),
-            (
-                "replica_2",
-                f"127.0.0.1:{REPLICATION_PORTS['replica_2']}",
-                "async",
-                {"ts": 4, "behind": None, "status": "ready"},
-                {
-                    "A": {"ts": 7, "behind": 0, "status": "ready"},
-                    "B": {"ts": 3, "behind": 0, "status": "ready"},
-                    "memgraph": {"ts": 0, "behind": 0, "status": "ready"},
-                },
-            ),
-        ],
-        "replica_2": [
-            (
-                "replica_1",
-                f"127.0.0.1:{REPLICATION_PORTS['replica_1']}",
-                "sync",
-                {"ts": 4, "behind": None, "status": "ready"},
-                {
-                    "A": {"ts": 7, "behind": 0, "status": "ready"},
-                    "B": {"ts": 3, "behind": 0, "status": "ready"},
-                    "memgraph": {"ts": 0, "behind": 0, "status": "ready"},
-                },
-            ),
-            (
-                "replica_2",
-                f"127.0.0.1:{REPLICATION_PORTS['replica_2']}",
-                "async",
-                {"ts": 4, "behind": None, "status": "ready"},
-                {
-                    "A": {"ts": 0, "behind": 0, "status": "invalid"},
-                    "B": {"ts": 0, "behind": 0, "status": "invalid"},
-                    "memgraph": {"ts": 0, "behind": 0, "status": "invalid"},
-                },
-            ),
-        ],
+        "replica_1": {
+            ("replica_1", f"127.0.0.1:{REPLICATION_PORTS['replica_1']}", "sync", 0, 0, "invalid"),
+            ("replica_2", f"127.0.0.1:{REPLICATION_PORTS['replica_2']}", "async", 7, 0, "ready"),
+        },
+        "replica_2": {
+            ("replica_1", f"127.0.0.1:{REPLICATION_PORTS['replica_1']}", "sync", 7, 0, "ready"),
+            ("replica_2", f"127.0.0.1:{REPLICATION_PORTS['replica_2']}", "async", 0, 0, "invalid"),
+        },
     }
-    assert set_eq(expected_data[replica_name], show_replicas_func(main_cursor)())
+    assert expected_data[replica_name] == show_replicas_func(main_cursor, "A")()
     # Restart
     interactive_mg_runner.start(MEMGRAPH_INSTANCES_DESCRIPTION, replica_name)
 
     # 4/
-    expected_data = [
-        (
-            "replica_1",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_1']}",
-            "sync",
-            {"ts": 4, "behind": None, "status": "ready"},
-            {
-                "A": {"ts": 7, "behind": 0, "status": "ready"},
-                "B": {"ts": 3, "behind": 0, "status": "ready"},
-                "memgraph": {"ts": 0, "behind": 0, "status": "ready"},
-            },
-        ),
-        (
-            "replica_2",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_2']}",
-            "async",
-            {"ts": 4, "behind": None, "status": "ready"},
-            {
-                "A": {"ts": 7, "behind": 0, "status": "ready"},
-                "B": {"ts": 3, "behind": 0, "status": "ready"},
-                "memgraph": {"ts": 0, "behind": 0, "status": "ready"},
-            },
-        ),
-    ]
-    mg_sleep_and_assert_collection(expected_data, show_replicas_func(main_cursor))
+    expected_data = {
+        ("replica_1", f"127.0.0.1:{REPLICATION_PORTS['replica_1']}", "sync", 7, 0, "ready"),
+        ("replica_2", f"127.0.0.1:{REPLICATION_PORTS['replica_2']}", "async", 7, 0, "ready"),
+    }
+    mg_sleep_and_assert(expected_data, show_replicas_func(main_cursor, "A"))
+
+    expected_data = {
+        ("replica_1", f"127.0.0.1:{REPLICATION_PORTS['replica_1']}", "sync", 3, 0, "ready"),
+        ("replica_2", f"127.0.0.1:{REPLICATION_PORTS['replica_2']}", "async", 3, 0, "ready"),
+    }
+    mg_sleep_and_assert(expected_data, show_replicas_func(main_cursor, "B"))
 
     cursor_replica = connection(BOLT_PORTS[replica_name], "replica").cursor()
 
@@ -915,33 +805,19 @@ def test_multitenancy_replication_restart_replica_wo_fc(connection, replica_name
     interactive_mg_runner.start(MEMGRAPH_INSTANCES_DESCRIPTION, replica_name)
 
     # 4/
-    expected_data = [
-        (
-            "replica_1",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_1']}",
-            "sync",
-            {"ts": 4, "behind": None, "status": "ready"},
-            {
-                "A": {"ts": 7, "behind": 0, "status": "ready"},
-                "B": {"ts": 3, "behind": 0, "status": "ready"},
-                "memgraph": {"ts": 0, "behind": 0, "status": "ready"},
-            },
-        ),
-        (
-            "replica_2",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_2']}",
-            "async",
-            {"ts": 4, "behind": None, "status": "ready"},
-            {
-                "A": {"ts": 7, "behind": 0, "status": "ready"},
-                "B": {"ts": 3, "behind": 0, "status": "ready"},
-                "memgraph": {"ts": 0, "behind": 0, "status": "ready"},
-            },
-        ),
-    ]
-    mg_sleep_and_assert_collection(expected_data, show_replicas_func(main_cursor))
+    expected_data = {
+        ("replica_1", f"127.0.0.1:{REPLICATION_PORTS['replica_1']}", "sync", 7, 0, "ready"),
+        ("replica_2", f"127.0.0.1:{REPLICATION_PORTS['replica_2']}", "async", 7, 0, "ready"),
+    }
+    mg_sleep_and_assert(expected_data, show_replicas_func(main_cursor, "A"))
 
-    cursor_replica = connection(BOLT_PORTS[replica_name], replica_name).cursor()
+    expected_data = {
+        ("replica_1", f"127.0.0.1:{REPLICATION_PORTS['replica_1']}", "sync", 3, 0, "ready"),
+        ("replica_2", f"127.0.0.1:{REPLICATION_PORTS['replica_2']}", "async", 3, 0, "ready"),
+    }
+    mg_sleep_and_assert(expected_data, show_replicas_func(main_cursor, "B"))
+
+    cursor_replica = connection(BOLT_PORTS[replica_name], "replica").cursor()
     assert get_number_of_nodes_func(cursor_replica, "A")() == 7
     assert get_number_of_edges_func(cursor_replica, "A")() == 3
     assert get_number_of_nodes_func(cursor_replica, "B")() == 2
@@ -1023,28 +899,17 @@ def test_multitenancy_replication_drop_replica(connection, replica_name):
     )
 
     # 4/
-    expected_data = [
-        (
-            "replica_1",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_1']}",
-            "sync",
-            {
-                "A": {"ts": 7, "behind": 0, "status": "ready"},
-                "B": {"ts": 3, "behind": 0, "status": "ready"},
-                "memgraph": {"ts": 0, "behind": 0, "status": "ready"},
-            },
-        ),
-        (
-            "replica_2",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_2']}",
-            "async",
-            {
-                "A": {"ts": 7, "behind": 0, "status": "ready"},
-                "B": {"ts": 3, "behind": 0, "status": "ready"},
-                "memgraph": {"ts": 0, "behind": 0, "status": "ready"},
-            },
-        ),
-    ]
+    expected_data = {
+        ("replica_1", f"127.0.0.1:{REPLICATION_PORTS['replica_1']}", "sync", 7, 0, "ready"),
+        ("replica_2", f"127.0.0.1:{REPLICATION_PORTS['replica_2']}", "async", 7, 0, "ready"),
+    }
+    mg_sleep_and_assert(expected_data, show_replicas_func(main_cursor, "A"))
+
+    expected_data = {
+        ("replica_1", f"127.0.0.1:{REPLICATION_PORTS['replica_1']}", "sync", 3, 0, "ready"),
+        ("replica_2", f"127.0.0.1:{REPLICATION_PORTS['replica_2']}", "async", 3, 0, "ready"),
+    }
+    mg_sleep_and_assert(expected_data, show_replicas_func(main_cursor, "B"))
 
     cursor_replica = connection(BOLT_PORTS[replica_name], "replica").cursor()
     assert get_number_of_nodes_func(cursor_replica, "A")() == 7
@@ -1128,31 +993,17 @@ def test_automatic_databases_drop_multitenancy_replication(connection):
     execute_and_fetch_all(main_cursor, "CREATE (:Node{on:'A'});")
 
     # 3/
-    expected_data = [
-        (
-            "replica_1",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_1']}",
-            "sync",
-            {"ts": 4, "behind": None, "status": "ready"},
-            {
-                "A": {"ts": 1, "behind": 0, "status": "ready"},
-                "B": {"ts": 0, "behind": 0, "status": "ready"},
-                "memgraph": {"ts": 0, "behind": 0, "status": "ready"},
-            },
-        ),
-        (
-            "replica_2",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_2']}",
-            "async",
-            {"ts": 4, "behind": None, "status": "ready"},
-            {
-                "A": {"ts": 1, "behind": 0, "status": "ready"},
-                "B": {"ts": 0, "behind": 0, "status": "ready"},
-                "memgraph": {"ts": 0, "behind": 0, "status": "ready"},
-            },
-        ),
-    ]
-    mg_sleep_and_assert(expected_data, show_replicas_func(main_cursor))
+    expected_data = {
+        ("replica_1", f"127.0.0.1:{REPLICATION_PORTS['replica_1']}", "sync", 1, 0, "ready"),
+        ("replica_2", f"127.0.0.1:{REPLICATION_PORTS['replica_2']}", "async", 1, 0, "ready"),
+    }
+    mg_sleep_and_assert(expected_data, show_replicas_func(main_cursor, "A"))
+
+    expected_data = {
+        ("replica_1", f"127.0.0.1:{REPLICATION_PORTS['replica_1']}", "sync", 0, 0, "ready"),
+        ("replica_2", f"127.0.0.1:{REPLICATION_PORTS['replica_2']}", "async", 0, 0, "ready"),
+    }
+    mg_sleep_and_assert(expected_data, show_replicas_func(main_cursor, "B"))
 
     # 4/
     execute_and_fetch_all(main_cursor, "USE DATABASE memgraph;")
@@ -1237,23 +1088,11 @@ def test_multitenancy_drop_while_replica_using(connection):
     execute_and_fetch_all(main_cursor, "CREATE (:Node{on:'A'});")
 
     # 3/
-    expected_data = [
-        (
-            "replica_1",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_1']}",
-            "sync",
-            {"ts": 3, "behind": None, "status": "ready"},
-            {"A": {"ts": 1, "behind": 0, "status": "ready"}, "memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-        (
-            "replica_2",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_2']}",
-            "async",
-            {"ts": 3, "behind": None, "status": "ready"},
-            {"A": {"ts": 1, "behind": 0, "status": "ready"}, "memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-    ]
-    mg_sleep_and_assert_collection(expected_data, show_replicas_func(main_cursor))
+    expected_data = {
+        ("replica_1", f"127.0.0.1:{REPLICATION_PORTS['replica_1']}", "sync", 1, 0, "ready"),
+        ("replica_2", f"127.0.0.1:{REPLICATION_PORTS['replica_2']}", "async", 1, 0, "ready"),
+    }
+    mg_sleep_and_assert(expected_data, show_replicas_func(main_cursor, "A"))
 
     # 4/
     replica1_cursor = connection(BOLT_PORTS["replica_1"], "replica").cursor()
@@ -1271,23 +1110,11 @@ def test_multitenancy_drop_while_replica_using(connection):
     execute_and_fetch_all(main_cursor, "CREATE DATABASE B;")
     execute_and_fetch_all(main_cursor, "USE DATABASE B;")
 
-    expected_data = [
-        (
-            "replica_1",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_1']}",
-            "sync",
-            {"ts": 8, "behind": None, "status": "ready"},
-            {"B": {"ts": 0, "behind": 0, "status": "ready"}, "memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-        (
-            "replica_2",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_2']}",
-            "async",
-            {"ts": 8, "behind": None, "status": "ready"},
-            {"B": {"ts": 0, "behind": 0, "status": "ready"}, "memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-    ]
-    mg_sleep_and_assert(expected_data, show_replicas_func(main_cursor))
+    expected_data = {
+        ("replica_1", f"127.0.0.1:{REPLICATION_PORTS['replica_1']}", "sync", 0, 0, "ready"),
+        ("replica_2", f"127.0.0.1:{REPLICATION_PORTS['replica_2']}", "async", 0, 0, "ready"),
+    }
+    mg_sleep_and_assert(expected_data, show_replicas_func(main_cursor, "B"))
 
     # 6/
     assert execute_and_fetch_all(replica1_cursor, "MATCH(n) RETURN count(*);")[0][0] == 1
@@ -1336,23 +1163,11 @@ def test_multitenancy_drop_and_recreate_while_replica_using(connection):
     execute_and_fetch_all(main_cursor, "CREATE (:Node{on:'A'});")
 
     # 3/
-    expected_data = [
-        (
-            "replica_1",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_1']}",
-            "sync",
-            {"ts": 3, "behind": None, "status": "ready"},
-            {"A": {"ts": 1, "behind": 0, "status": "ready"}, "memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-        (
-            "replica_2",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_2']}",
-            "async",
-            {"ts": 3, "behind": None, "status": "ready"},
-            {"A": {"ts": 1, "behind": 0, "status": "ready"}, "memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-    ]
-    mg_sleep_and_assert_collection(expected_data, show_replicas_func(main_cursor))
+    expected_data = {
+        ("replica_1", f"127.0.0.1:{REPLICATION_PORTS['replica_1']}", "sync", 1, 0, "ready"),
+        ("replica_2", f"127.0.0.1:{REPLICATION_PORTS['replica_2']}", "async", 1, 0, "ready"),
+    }
+    mg_sleep_and_assert(expected_data, show_replicas_func(main_cursor, "A"))
 
     # 4/
     replica1_cursor = connection(BOLT_PORTS["replica_1"], "replica").cursor()
@@ -1369,23 +1184,11 @@ def test_multitenancy_drop_and_recreate_while_replica_using(connection):
     execute_and_fetch_all(main_cursor, "CREATE DATABASE A;")
     execute_and_fetch_all(main_cursor, "USE DATABASE A;")
 
-    expected_data = [
-        (
-            "replica_1",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_1']}",
-            "sync",
-            {"ts": 8, "behind": None, "status": "ready"},
-            {"A": {"ts": 0, "behind": 0, "status": "ready"}, "memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-        (
-            "replica_2",
-            f"127.0.0.1:{REPLICATION_PORTS['replica_2']}",
-            "async",
-            {"ts": 8, "behind": None, "status": "ready"},
-            {"A": {"ts": 0, "behind": 0, "status": "ready"}, "memgraph": {"ts": 0, "behind": 0, "status": "ready"}},
-        ),
-    ]
-    mg_sleep_and_assert(expected_data, show_replicas_func(main_cursor))
+    expected_data = {
+        ("replica_1", f"127.0.0.1:{REPLICATION_PORTS['replica_1']}", "sync", 0, 0, "ready"),
+        ("replica_2", f"127.0.0.1:{REPLICATION_PORTS['replica_2']}", "async", 0, 0, "ready"),
+    }
+    mg_sleep_and_assert(expected_data, show_replicas_func(main_cursor, "A"))
 
     # 6/
     assert execute_and_fetch_all(replica1_cursor, "MATCH(n) RETURN count(*);")[0][0] == 1

tests/unit/CMakeLists.txt

@@ -430,11 +430,3 @@ target_include_directories(${test_prefix}distributed_lamport_clock PRIVATE ${CMA
 
 add_unit_test(query_hint_provider.cpp)
 target_link_libraries(${test_prefix}query_hint_provider mg-query mg-glue)
-
-
-# Test coordination
-if(MG_ENTERPRISE)
-add_unit_test(coordination_utils.cpp)
-target_link_libraries(${test_prefix}coordination_utils gflags mg-coordination mg-repl_coord_glue)
-target_include_directories(${test_prefix}coordination_utils PRIVATE ${CMAKE_SOURCE_DIR}/include)
-endif()

tests/unit/coordination_utils.cpp

@@ -1,246 +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.
-
-#include <gflags/gflags.h>
-#include <gtest/gtest.h>
-#include "coordination/coordinator_instance.hpp"
-#include "dbms/constants.hpp"
-#include "replication_coordination_glue/common.hpp"
-#include "utils/functional.hpp"
-
-class CoordinationUtils : public ::testing::Test {
- protected:
-  void SetUp() override {}
-
-  void TearDown() override {}
-
-  std::filesystem::path test_folder_{std::filesystem::temp_directory_path() / "MG_tests_unit_coordination"};
-};
-
-TEST_F(CoordinationUtils, MemgraphDbHistorySimple) {
-  // Choose any if everything is same
-  // X = dead
-  // Main      : A(24)  B(36)  C(48) D(50) E(51) X
-  // replica  1: A(24)  B(36)  C(48) D(50) E(51)
-  // replica  2: A(24)  B(36)  C(48) D(50) E(51)
-  // replica  3: A(24)  B(36)  C(48) D(50) E(51)
-  std::vector<std::pair<std::string, memgraph::replication_coordination_glue::DatabaseHistories>>
-      instance_database_histories;
-
-  std::vector<std::pair<memgraph::utils::UUID, uint64_t>> histories;
-  histories.emplace_back(memgraph::utils::UUID{}, 24);
-  histories.emplace_back(memgraph::utils::UUID{}, 36);
-  histories.emplace_back(memgraph::utils::UUID{}, 48);
-  histories.emplace_back(memgraph::utils::UUID{}, 50);
-  histories.emplace_back(memgraph::utils::UUID{}, 51);
-
-  memgraph::utils::UUID db_uuid;
-  std::string default_name = std::string(memgraph::dbms::kDefaultDB);
-
-  auto db_histories = memgraph::utils::fmap(
-      [](const std::pair<memgraph::utils::UUID, uint64_t> &pair) {
-        return std::make_pair(std::string(pair.first), pair.second);
-      },
-      histories);
-
-  memgraph::replication_coordination_glue::DatabaseHistory history{
-      .db_uuid = db_uuid, .history = db_histories, .name = default_name};
-
-  memgraph::replication_coordination_glue::DatabaseHistories instance_1_db_histories_{history};
-  instance_database_histories.emplace_back("instance_1", instance_1_db_histories_);
-
-  memgraph::replication_coordination_glue::DatabaseHistories instance_2_db_histories_{history};
-  instance_database_histories.emplace_back("instance_2", instance_2_db_histories_);
-
-  memgraph::replication_coordination_glue::DatabaseHistories instance_3_db_histories_{history};
-  instance_database_histories.emplace_back("instance_3", instance_3_db_histories_);
-  memgraph::coordination::CoordinatorInstance instance;
-
-  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);
-}
-
-TEST_F(CoordinationUtils, MemgraphDbHistoryLastEpochDifferent) {
-  // Prioritize one with the biggest last commit timestamp on last epoch
-  // X = dead
-  // Main      : A(24)  B(36)  C(48) D(50) E(59) X
-  // replica  1: A(24)  B(12)  C(15) D(17) E(51)
-  // replica  2: A(24)  B(12)  C(15) D(17) E(57)
-  // replica  3: A(24)  B(12)  C(15) D(17) E(59)
-  std::vector<std::pair<std::string, memgraph::replication_coordination_glue::DatabaseHistories>>
-      instance_database_histories;
-
-  std::vector<std::pair<memgraph::utils::UUID, uint64_t>> histories;
-  histories.emplace_back(memgraph::utils::UUID{}, 24);
-  histories.emplace_back(memgraph::utils::UUID{}, 36);
-  histories.emplace_back(memgraph::utils::UUID{}, 48);
-  histories.emplace_back(memgraph::utils::UUID{}, 50);
-  histories.emplace_back(memgraph::utils::UUID{}, 59);
-
-  memgraph::utils::UUID db_uuid;
-  std::string default_name = std::string(memgraph::dbms::kDefaultDB);
-
-  auto db_histories = memgraph::utils::fmap(
-      [](const std::pair<memgraph::utils::UUID, uint64_t> &pair) {
-        return std::make_pair(std::string(pair.first), pair.second);
-      },
-      histories);
-
-  db_histories.back().second = 51;
-  memgraph::replication_coordination_glue::DatabaseHistory history1{
-      .db_uuid = db_uuid, .history = db_histories, .name = default_name};
-
-  memgraph::replication_coordination_glue::DatabaseHistories instance_1_db_histories_{history1};
-  instance_database_histories.emplace_back("instance_1", instance_1_db_histories_);
-
-  db_histories.back().second = 57;
-  memgraph::replication_coordination_glue::DatabaseHistory history2{
-      .db_uuid = db_uuid, .history = db_histories, .name = default_name};
-  memgraph::replication_coordination_glue::DatabaseHistories instance_2_db_histories_{history2};
-  instance_database_histories.emplace_back("instance_2", instance_2_db_histories_);
-
-  db_histories.back().second = 59;
-  memgraph::replication_coordination_glue::DatabaseHistory history3{
-      .db_uuid = db_uuid, .history = db_histories, .name = default_name};
-  memgraph::replication_coordination_glue::DatabaseHistories instance_3_db_histories_{history3};
-  instance_database_histories.emplace_back("instance_3", instance_3_db_histories_);
-
-  memgraph::coordination::CoordinatorInstance instance;
-  auto [instance_name, latest_epoch, latest_commit_timestamp] =
-      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);
-}
-
-TEST_F(CoordinationUtils, MemgraphDbHistoryOneInstanceAheadFewEpochs) {
-  // Prioritize one biggest commit timestamp
-  // X = dead
-  // Main      : A(24)  B(36)  C(48) D(50) E(51)   X    X     X  X
-  // replica  1: A(24)  B(36)  C(48) D(50) E(51) F(60) G(65)  X  up
-  // replica  2: A(24)  B(36)  C(48) D(50) E(51)  X     X     X  up
-  // replica  3: A(24)  B(36)  C(48) D(50) E(51)  X     X     X  up
-  std::vector<std::pair<std::string, memgraph::replication_coordination_glue::DatabaseHistories>>
-      instance_database_histories;
-
-  std::vector<std::pair<memgraph::utils::UUID, uint64_t>> histories;
-  histories.emplace_back(memgraph::utils::UUID{}, 24);
-  histories.emplace_back(memgraph::utils::UUID{}, 36);
-  histories.emplace_back(memgraph::utils::UUID{}, 48);
-  histories.emplace_back(memgraph::utils::UUID{}, 50);
-  histories.emplace_back(memgraph::utils::UUID{}, 51);
-
-  memgraph::utils::UUID db_uuid;
-  std::string default_name = std::string(memgraph::dbms::kDefaultDB);
-
-  auto db_histories = memgraph::utils::fmap(
-      [](const std::pair<memgraph::utils::UUID, uint64_t> &pair) {
-        return std::make_pair(std::string(pair.first), pair.second);
-      },
-      histories);
-
-  memgraph::replication_coordination_glue::DatabaseHistory history{
-      .db_uuid = db_uuid, .history = db_histories, .name = default_name};
-
-  memgraph::replication_coordination_glue::DatabaseHistories instance_1_db_histories_{history};
-  instance_database_histories.emplace_back("instance_1", instance_1_db_histories_);
-
-  memgraph::replication_coordination_glue::DatabaseHistories instance_2_db_histories_{history};
-  instance_database_histories.emplace_back("instance_2", instance_2_db_histories_);
-
-  histories.emplace_back(memgraph::utils::UUID{}, 60);
-  histories.emplace_back(memgraph::utils::UUID{}, 65);
-  auto db_histories_longest = memgraph::utils::fmap(
-      [](const std::pair<memgraph::utils::UUID, uint64_t> &pair) {
-        return std::make_pair(std::string(pair.first), pair.second);
-      },
-      histories);
-
-  memgraph::replication_coordination_glue::DatabaseHistory history_longest{
-      .db_uuid = db_uuid, .history = db_histories_longest, .name = default_name};
-
-  memgraph::replication_coordination_glue::DatabaseHistories instance_3_db_histories_{history_longest};
-  instance_database_histories.emplace_back("instance_3", instance_3_db_histories_);
-
-  memgraph::coordination::CoordinatorInstance instance;
-  auto [instance_name, latest_epoch, latest_commit_timestamp] =
-      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);
-}
-
-TEST_F(CoordinationUtils, MemgraphDbHistoryInstancesHistoryDiverged) {
-  // When history diverged, also prioritize one with biggest last commit timestamp
-  // Main      : A(1)  B(2)   C(3)    X
-  // replica  1: A(1)  B(2)   C(3)    X     X up
-  // replica  2: A(1)  B(2)    X     D(5)   X up
-  // replica  3: A(1)  B(2)    X     D(4)   X up
-  std::vector<std::pair<std::string, memgraph::replication_coordination_glue::DatabaseHistories>>
-      instance_database_histories;
-
-  std::vector<std::pair<memgraph::utils::UUID, uint64_t>> histories;
-  histories.emplace_back(memgraph::utils::UUID{}, 1);
-  histories.emplace_back(memgraph::utils::UUID{}, 2);
-  histories.emplace_back(memgraph::utils::UUID{}, 3);
-
-  memgraph::utils::UUID db_uuid;
-  std::string default_name = std::string(memgraph::dbms::kDefaultDB);
-
-  auto db_histories = memgraph::utils::fmap(
-      [](const std::pair<memgraph::utils::UUID, uint64_t> &pair) {
-        return std::make_pair(std::string(pair.first), pair.second);
-      },
-      histories);
-
-  memgraph::replication_coordination_glue::DatabaseHistory history{
-      .db_uuid = db_uuid, .history = db_histories, .name = default_name};
-
-  memgraph::replication_coordination_glue::DatabaseHistories instance_1_db_histories_{history};
-  instance_database_histories.emplace_back("instance_1", instance_1_db_histories_);
-
-  db_histories.pop_back();
-
-  auto oldest_commit_timestamp{5};
-  auto newest_different_epoch = memgraph::utils::UUID{};
-  histories.emplace_back(newest_different_epoch, oldest_commit_timestamp);
-  auto db_histories_different = memgraph::utils::fmap(
-      [](const std::pair<memgraph::utils::UUID, uint64_t> &pair) {
-        return std::make_pair(std::string(pair.first), pair.second);
-      },
-      histories);
-
-  memgraph::replication_coordination_glue::DatabaseHistory history_3{
-      .db_uuid = db_uuid, .history = db_histories_different, .name = default_name};
-
-  memgraph::replication_coordination_glue::DatabaseHistories instance_3_db_histories_{history_3};
-  instance_database_histories.emplace_back("instance_3", instance_3_db_histories_);
-
-  db_histories_different.back().second = 4;
-  memgraph::replication_coordination_glue::DatabaseHistory history_2{
-      .db_uuid = db_uuid, .history = db_histories_different, .name = default_name};
-
-  memgraph::replication_coordination_glue::DatabaseHistories instance_2_db_histories_{history_2};
-  instance_database_histories.emplace_back("instance_2", instance_2_db_histories_);
-
-  memgraph::coordination::CoordinatorInstance instance;
-  auto [instance_name, latest_epoch, latest_commit_timestamp] =
-      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);
-}