Add tests for flags

.clang-format

@@ -2,7 +2,7 @@
 BasedOnStyle: Google
 ---
 Language:     Cpp
-Standard:     c++20
+Standard:     "c++20"
 UseTab:       Never
 DerivePointerAlignment: false
 PointerAlignment: Right

.clang-tidy

@@ -6,7 +6,6 @@ Checks: '*,
          -altera-unroll-loops,
          -android-*,
          -cert-err58-cpp,
-         -cppcoreguidelines-avoid-do-while,
          -cppcoreguidelines-avoid-c-arrays,
          -cppcoreguidelines-avoid-goto,
          -cppcoreguidelines-avoid-magic-numbers,
@@ -61,7 +60,6 @@ Checks: '*,
          -readability-implicit-bool-conversion,
          -readability-magic-numbers,
          -readability-named-parameter,
-         -readability-identifier-length,
          -misc-no-recursion,
          -concurrency-mt-unsafe,
          -bugprone-easily-swappable-parameters'

.github/ISSUE_TEMPLATE/bug_report.md

@@ -3,6 +3,7 @@ name: Bug report
 about: Create a report to help us improve
 title: ""
 labels: bug
+assignees: gitbuda
 ---
 
 **Memgraph version**

.github/workflows/diff.yaml

@@ -268,6 +268,7 @@ jobs:
           ctest -R memgraph__unit --output-on-failure -j$THREADS
 
       - name: Ensure Kafka and Pulsar are up
+        if: false
         run: |
           cd tests/e2e/streams/kafka
           docker-compose up -d
@@ -275,6 +276,7 @@ jobs:
           docker-compose up -d
 
       - name: Run e2e tests
+        if: false
         run: |
           cd tests
           ./setup.sh /opt/toolchain-v4/activate
@@ -283,6 +285,7 @@ jobs:
           ./run.sh
 
       - name: Ensure Kafka and Pulsar are down
+        if: false
         run: |
           cd tests/e2e/streams/kafka
           docker-compose down
@@ -383,6 +386,71 @@ jobs:
             # multiple paths could be defined
             build/logs
 
+  experimental_build_mt:
+    name: "MultiTenancy replication build"
+    runs-on: [self-hosted, Linux, X64, Diff]
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+
+    steps:
+      - name: Set up repository
+        uses: actions/checkout@v4
+        with:
+          # Number of commits to fetch. `0` indicates all history for all
+          # branches and tags. (default: 1)
+          fetch-depth: 0
+
+
+      - name: Build release binaries
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v4/activate
+
+          # Initialize dependencies.
+          ./init
+
+          # Build MT replication experimental binaries.
+          cd build
+          cmake -DCMAKE_BUILD_TYPE=Release -D MG_EXPERIMENTAL_REPLICATION_MULTITENANCY=ON ..
+          make -j$THREADS
+
+      - name: Run unit tests
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v4/activate
+
+          # Run unit tests.
+          cd build
+          ctest -R memgraph__unit --output-on-failure -j$THREADS
+
+      - name: Run e2e tests
+        if: false
+        run: |
+          cd tests
+          ./setup.sh /opt/toolchain-v4/activate
+          source ve3/bin/activate_e2e
+          cd e2e
+
+          # Just the replication based e2e tests
+          ./run.sh "Replicate multitenancy"
+          ./run.sh "Show"
+          ./run.sh "Show while creating invalid state"
+          ./run.sh "Delete edge replication"
+          ./run.sh "Read-write benchmark"
+          ./run.sh "Index replication"
+          ./run.sh "Constraints"
+
+      - name: Save test data
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: "Test data(MultiTenancy replication build)"
+          path: |
+            # multiple paths could be defined
+            build/logs
+
   release_jepsen_test:
     name: "Release Jepsen Test"
     runs-on: [self-hosted, Linux, X64, Debian10, JepsenControl]

.github/workflows/release_debian10.yaml

@@ -1,7 +1,4 @@
 name: Release Debian 10
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref_name }}
-  cancel-in-progress: true
 
 on:
   workflow_dispatch:
@@ -13,12 +10,7 @@ on:
         options:
           - Release
           - RelWithDebInfo
-  push:
-    branches:
-      - "release/**"
-    tags:
-      - "v*.*.*-rc*"
-      - "v*.*-rc*"
+
   schedule:
     - cron: "0 22 * * *"
 
@@ -329,6 +321,7 @@ jobs:
             --no-strict
 
   release_e2e_test:
+    if: false
     name: "Release End-to-end Test"
     runs-on: [self-hosted, Linux, X64, Debian10]
     timeout-minutes: 60

.github/workflows/release_ubuntu2004.yaml

@@ -1,7 +1,4 @@
 name: Release Ubuntu 20.04
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref_name }}
-  cancel-in-progress: true
 
 on:
   workflow_dispatch:
@@ -13,12 +10,7 @@ on:
         options:
           - Release
           - RelWithDebInfo
-  push:
-    branches:
-      - "release/**"
-    tags:
-      - "v*.*.*-rc*"
-      - "v*.*-rc*"
+
   schedule:
     - cron: "0 22 * * *"
 
@@ -325,6 +317,7 @@ jobs:
             --no-strict
 
   release_e2e_test:
+    if: false
     name: "Release End-to-end Test"
     runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
     timeout-minutes: 60

.github/workflows/stress_test_large.yaml

@@ -1,7 +1,4 @@
 name: Stress test large
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref_name }}
-  cancel-in-progress: true
 
 on:
   workflow_dispatch:
@@ -13,10 +10,7 @@ on:
         options:
           - Release
           - RelWithDebInfo
-  push:
-    tags:
-      - "v*.*.*-rc*"
-      - "v*.*-rc*"
+
   schedule:
     - cron: "0 22 * * *"
 

.pre-commit-config.yaml

@@ -17,10 +17,9 @@ repos:
         name: isort (python)
         args: ["--profile", "black"]
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v17.0.6
+    rev: v13.0.0
     hooks:
       - id: clang-format
-        types_or: [c++, c]
 #  - repo: local
 #    hooks:
 #      - id: clang-tidy

CMakeLists.txt

@@ -189,7 +189,7 @@ add_custom_target(clean_all
 # is easier debugging of compilation and linker flags.
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
-set(CMAKE_CXX_STANDARD 23)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 # c99-designator is disabled because of required mixture of designated and
 # non-designated initializers in Python Query Module code (`py_module.cpp`).
@@ -275,7 +275,7 @@ option(MG_EXPERIMENTAL_HIGH_AVAILABILITY "Feature flag for experimental high ava
 
 if (NOT MG_ENTERPRISE AND MG_EXPERIMENTAL_HIGH_AVAILABILITY)
     set(MG_EXPERIMENTAL_HIGH_AVAILABILITY OFF)
-    message(FATAL_ERROR "MG_EXPERIMENTAL_HIGH_AVAILABILITY can only be used with enterpise version of the code.")
+    message(FATAL_ERROR "MG_EXPERIMENTAL_HIGH_AVAILABILITY must be used with enterpise version of the code.")
 endif ()
 
 if (MG_EXPERIMENTAL_HIGH_AVAILABILITY)
@@ -291,6 +291,16 @@ option(TSAN "Build with Thread Sanitizer. To get a reasonable performance option
 option(UBSAN "Build with Undefined Behaviour Sanitizer" OFF)
 
 # Build feature flags
+option(MG_EXPERIMENTAL_REPLICATION_MULTITENANCY "Feature flag for experimental replicaition of multitenacy" OFF)
+
+if (NOT MG_ENTERPRISE AND MG_EXPERIMENTAL_REPLICATION_MULTITENANCY)
+    set(MG_EXPERIMENTAL_REPLICATION_MULTITENANCY OFF)
+    message(FATAL_ERROR "MG_EXPERIMENTAL_REPLICATION_MULTITENANCY with community edition build isn't possible")
+endif ()
+
+if (MG_EXPERIMENTAL_REPLICATION_MULTITENANCY)
+    add_compile_definitions(MG_EXPERIMENTAL_REPLICATION_MULTITENANCY)
+endif ()
 
 if (TEST_COVERAGE)
   string(TOLOWER ${CMAKE_BUILD_TYPE} lower_build_type)

init

@@ -120,7 +120,7 @@ fi
 # develop on them -> pre-commit hook not required -> we can use latest
 # packages.
 if [ "${DISTRO}" != "centos-7" ] && [ "$DISTRO" != "debian-10" ] && [ "${DISTRO}" != "ubuntu-18.04" ] && [ "${DISTRO}" != "amzn-2" ]; then
-  python3 -m pip install pre-commit==3.5.*
+  python3 -m pip install pre-commit
   python3 -m pre_commit install
   # Install py format tools for usage during the development.
   echo "Install black formatter"

libs/setup.sh

@@ -123,10 +123,10 @@ declare -A primary_urls=(
   ["pulsar"]="http://$local_cache_host/git/pulsar.git"
   ["librdtsc"]="http://$local_cache_host/git/librdtsc.git"
   ["ctre"]="http://$local_cache_host/file/hanickadot/compile-time-regular-expressions/v3.7.2/single-header/ctre.hpp"
-  ["absl"]="http://$local_cache_host/git/abseil-cpp.git"
-  ["jemalloc"]="http://$local_cache_host/git/jemalloc.git"
-  ["range-v3"]="http://$local_cache_host/git/range-v3.git"
-  ["nuraft"]="http://$local_cache_host/git/NuRaft.git"
+  ["absl"]="https://$local_cache_host/git/abseil-cpp.git"
+  ["jemalloc"]="https://$local_cache_host/git/jemalloc.git"
+  ["range-v3"]="https://$local_cache_host/git/ericniebler/range-v3.git"
+  ["nuraft"]="https://$local_cache_host/git/eBay/NuRaft.git"
 )
 
 # The goal of secondary urls is to have links to the "source of truth" of
@@ -270,8 +270,6 @@ pushd jemalloc
 MALLOC_CONF="retain:false,percpu_arena:percpu,oversize_threshold:0,muzzy_decay_ms:5000,dirty_decay_ms:5000" \
 ./configure \
   --disable-cxx \
-  --with-lg-page=12 \
-  --with-lg-hugepage=21 \
   --enable-shared=no --prefix=$working_dir \
   --with-malloc-conf="retain:false,percpu_arena:percpu,oversize_threshold:0,muzzy_decay_ms:5000,dirty_decay_ms:5000"
 

src/auth/auth.cpp

@@ -57,19 +57,16 @@ struct UpdateAuthData : memgraph::system::ISystemAction {
   void DoDurability() override { /* Done during Auth execution */
   }
 
-  bool DoReplication(replication::ReplicationClient &client, const utils::UUID &main_uuid,
-                     replication::ReplicationEpoch const &epoch,
+  bool DoReplication(replication::ReplicationClient &client, replication::ReplicationEpoch const &epoch,
                      memgraph::system::Transaction const &txn) const override {
     auto check_response = [](const replication::UpdateAuthDataRes &response) { return response.success; };
     if (user_) {
       return client.SteamAndFinalizeDelta<replication::UpdateAuthDataRpc>(
-          check_response, main_uuid, std::string{epoch.id()}, txn.last_committed_system_timestamp(), txn.timestamp(),
-          *user_);
+          check_response, std::string{epoch.id()}, txn.last_committed_system_timestamp(), txn.timestamp(), *user_);
     }
     if (role_) {
       return client.SteamAndFinalizeDelta<replication::UpdateAuthDataRpc>(
-          check_response, main_uuid, std::string{epoch.id()}, txn.last_committed_system_timestamp(), txn.timestamp(),
-          *role_);
+          check_response, std::string{epoch.id()}, txn.last_committed_system_timestamp(), txn.timestamp(), *role_);
     }
     // Should never get here
     MG_ASSERT(false, "Trying to update auth data that is not a user nor a role");
@@ -91,8 +88,7 @@ struct DropAuthData : memgraph::system::ISystemAction {
   void DoDurability() override { /* Done during Auth execution */
   }
 
-  bool DoReplication(replication::ReplicationClient &client, const utils::UUID &main_uuid,
-                     replication::ReplicationEpoch const &epoch,
+  bool DoReplication(replication::ReplicationClient &client, replication::ReplicationEpoch const &epoch,
                      memgraph::system::Transaction const &txn) const override {
     auto check_response = [](const replication::DropAuthDataRes &response) { return response.success; };
 
@@ -106,8 +102,7 @@ struct DropAuthData : memgraph::system::ISystemAction {
         break;
     }
     return client.SteamAndFinalizeDelta<replication::DropAuthDataRpc>(
-        check_response, main_uuid, std::string{epoch.id()}, txn.last_committed_system_timestamp(), txn.timestamp(),
-        type, name_);
+        check_response, std::string{epoch.id()}, txn.last_committed_system_timestamp(), txn.timestamp(), type, name_);
   }
   void PostReplication(replication::RoleMainData &mainData) const override {}
 

src/auth/replication_handlers.cpp

@@ -17,15 +17,8 @@
 
 namespace memgraph::auth {
 
-void LogWrongMain(const std::optional<utils::UUID> &current_main_uuid, const utils::UUID &main_req_id,
-                  std::string_view rpc_req) {
-  spdlog::error(fmt::format("Received {} with main_id: {} != current_main_uuid: {}", rpc_req, std::string(main_req_id),
-                            current_main_uuid.has_value() ? std::string(current_main_uuid.value()) : ""));
-}
-
 #ifdef MG_ENTERPRISE
-void UpdateAuthDataHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access,
-                           const std::optional<utils::UUID> &current_main_uuid, auth::SynchedAuth &auth,
+void UpdateAuthDataHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access, auth::SynchedAuth &auth,
                            slk::Reader *req_reader, slk::Builder *res_builder) {
   replication::UpdateAuthDataReq req;
   memgraph::slk::Load(&req, req_reader);
@@ -33,12 +26,6 @@ void UpdateAuthDataHandler(memgraph::system::ReplicaHandlerAccessToState &system
   using memgraph::replication::UpdateAuthDataRes;
   UpdateAuthDataRes res(false);
 
-  if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, replication::UpdateAuthDataReq::kType.name);
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
   // Note: No need to check epoch, recovery mechanism is done by a full uptodate snapshot
   //       of the set of databases. Hence no history exists to maintain regarding epoch change.
   //       If MAIN has changed we need to check this new group_timestamp is consistent with
@@ -66,8 +53,7 @@ void UpdateAuthDataHandler(memgraph::system::ReplicaHandlerAccessToState &system
   memgraph::slk::Save(res, res_builder);
 }
 
-void DropAuthDataHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access,
-                         const std::optional<utils::UUID> &current_main_uuid, auth::SynchedAuth &auth,
+void DropAuthDataHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access, auth::SynchedAuth &auth,
                          slk::Reader *req_reader, slk::Builder *res_builder) {
   replication::DropAuthDataReq req;
   memgraph::slk::Load(&req, req_reader);
@@ -75,12 +61,6 @@ void DropAuthDataHandler(memgraph::system::ReplicaHandlerAccessToState &system_s
   using memgraph::replication::DropAuthDataRes;
   DropAuthDataRes res(false);
 
-  if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, replication::DropAuthDataRes::kType.name);
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
   // Note: No need to check epoch, recovery mechanism is done by a full uptodate snapshot
   //       of the set of databases. Hence no history exists to maintain regarding epoch change.
   //       If MAIN has changed we need to check this new group_timestamp is consistent with
@@ -175,14 +155,14 @@ void Register(replication::RoleReplicaData const &data, system::ReplicaHandlerAc
               auth::SynchedAuth &auth) {
   // NOTE: Register even without license as the user could add a license at run-time
   data.server->rpc_server_.Register<replication::UpdateAuthDataRpc>(
-      [&data, system_state_access, &auth](auto *req_reader, auto *res_builder) mutable {
+      [system_state_access, &auth](auto *req_reader, auto *res_builder) mutable {
         spdlog::debug("Received UpdateAuthDataRpc");
-        UpdateAuthDataHandler(system_state_access, data.uuid_, auth, req_reader, res_builder);
+        UpdateAuthDataHandler(system_state_access, auth, req_reader, res_builder);
       });
   data.server->rpc_server_.Register<replication::DropAuthDataRpc>(
-      [&data, system_state_access, &auth](auto *req_reader, auto *res_builder) mutable {
+      [system_state_access, &auth](auto *req_reader, auto *res_builder) mutable {
         spdlog::debug("Received DropAuthDataRpc");
-        DropAuthDataHandler(system_state_access, data.uuid_, auth, req_reader, res_builder);
+        DropAuthDataHandler(system_state_access, auth, req_reader, res_builder);
       });
 }
 #endif

src/auth/replication_handlers.hpp

@@ -17,16 +17,10 @@
 #include "system/state.hpp"
 
 namespace memgraph::auth {
-
-void LogWrongMain(const std::optional<utils::UUID> &current_main_uuid, const utils::UUID &main_req_id,
-                  std::string_view rpc_req);
-
 #ifdef MG_ENTERPRISE
-void UpdateAuthDataHandler(system::ReplicaHandlerAccessToState &system_state_access,
-                           const std::optional<utils::UUID> &current_main_uuid, auth::SynchedAuth &auth,
+void UpdateAuthDataHandler(system::ReplicaHandlerAccessToState &system_state_access, auth::SynchedAuth &auth,
                            slk::Reader *req_reader, slk::Builder *res_builder);
-void DropAuthDataHandler(system::ReplicaHandlerAccessToState &system_state_access,
-                         const std::optional<utils::UUID> &current_main_uuid, auth::SynchedAuth &auth,
+void DropAuthDataHandler(system::ReplicaHandlerAccessToState &system_state_access, auth::SynchedAuth &auth,
                          slk::Reader *req_reader, slk::Builder *res_builder);
 
 bool SystemRecoveryHandler(auth::SynchedAuth &auth, auth::Auth::Config auth_config,

src/auth/rpc.cpp

@@ -89,7 +89,6 @@ void Load(auth::Auth::Config *self, memgraph::slk::Reader *reader) {
 
 // Serialize code for UpdateAuthDataReq
 void Save(const memgraph::replication::UpdateAuthDataReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.main_uuid, builder);
   memgraph::slk::Save(self.epoch_id, builder);
   memgraph::slk::Save(self.expected_group_timestamp, builder);
   memgraph::slk::Save(self.new_group_timestamp, builder);
@@ -97,7 +96,6 @@ void Save(const memgraph::replication::UpdateAuthDataReq &self, memgraph::slk::B
   memgraph::slk::Save(self.role, builder);
 }
 void Load(memgraph::replication::UpdateAuthDataReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->main_uuid, reader);
   memgraph::slk::Load(&self->epoch_id, reader);
   memgraph::slk::Load(&self->expected_group_timestamp, reader);
   memgraph::slk::Load(&self->new_group_timestamp, reader);
@@ -115,7 +113,6 @@ void Load(memgraph::replication::UpdateAuthDataRes *self, memgraph::slk::Reader
 
 // Serialize code for DropAuthDataReq
 void Save(const memgraph::replication::DropAuthDataReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.main_uuid, builder);
   memgraph::slk::Save(self.epoch_id, builder);
   memgraph::slk::Save(self.expected_group_timestamp, builder);
   memgraph::slk::Save(self.new_group_timestamp, builder);
@@ -123,7 +120,6 @@ void Save(const memgraph::replication::DropAuthDataReq &self, memgraph::slk::Bui
   memgraph::slk::Save(self.name, builder);
 }
 void Load(memgraph::replication::DropAuthDataReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->main_uuid, reader);
   memgraph::slk::Load(&self->epoch_id, reader);
   memgraph::slk::Load(&self->expected_group_timestamp, reader);
   memgraph::slk::Load(&self->new_group_timestamp, reader);

src/auth/rpc.hpp

@@ -27,22 +27,17 @@ struct UpdateAuthDataReq {
   static void Load(UpdateAuthDataReq *self, memgraph::slk::Reader *reader);
   static void Save(const UpdateAuthDataReq &self, memgraph::slk::Builder *builder);
   UpdateAuthDataReq() = default;
-  UpdateAuthDataReq(const utils::UUID &main_uuid, std::string epoch_id, uint64_t expected_ts, uint64_t new_ts,
-                    auth::User user)
-      : main_uuid(main_uuid),
-        epoch_id{std::move(epoch_id)},
+  UpdateAuthDataReq(std::string epoch_id, uint64_t expected_ts, uint64_t new_ts, auth::User user)
+      : epoch_id{std::move(epoch_id)},
         expected_group_timestamp{expected_ts},
         new_group_timestamp{new_ts},
         user{std::move(user)} {}
-  UpdateAuthDataReq(const utils::UUID &main_uuid, std::string epoch_id, uint64_t expected_ts, uint64_t new_ts,
-                    auth::Role role)
-      : main_uuid(main_uuid),
-        epoch_id{std::move(epoch_id)},
+  UpdateAuthDataReq(std::string epoch_id, uint64_t expected_ts, uint64_t new_ts, auth::Role role)
+      : epoch_id{std::move(epoch_id)},
         expected_group_timestamp{expected_ts},
         new_group_timestamp{new_ts},
         role{std::move(role)} {}
 
-  utils::UUID main_uuid;
   std::string epoch_id;
   uint64_t expected_group_timestamp;
   uint64_t new_group_timestamp;
@@ -74,16 +69,13 @@ struct DropAuthDataReq {
 
   enum class DataType { USER, ROLE };
 
-  DropAuthDataReq(const utils::UUID &main_uuid, std::string epoch_id, uint64_t expected_ts, uint64_t new_ts,
-                  DataType type, std::string_view name)
-      : main_uuid(main_uuid),
-        epoch_id{std::move(epoch_id)},
+  DropAuthDataReq(std::string epoch_id, uint64_t expected_ts, uint64_t new_ts, DataType type, std::string_view name)
+      : epoch_id{std::move(epoch_id)},
         expected_group_timestamp{expected_ts},
         new_group_timestamp{new_ts},
         type{type},
         name{name} {}
 
-  utils::UUID main_uuid;
   std::string epoch_id;
   uint64_t expected_group_timestamp;
   uint64_t new_group_timestamp;

src/coordination/CMakeLists.txt

@@ -8,32 +8,21 @@ target_sources(mg-coordination
         include/coordination/coordinator_server.hpp
         include/coordination/coordinator_config.hpp
         include/coordination/coordinator_exceptions.hpp
-        include/coordination/coordinator_slk.hpp
         include/coordination/coordinator_instance.hpp
-        include/coordination/coordinator_handlers.hpp
+        include/coordination/coordinator_slk.hpp
+        include/coordination/coordinator_data.hpp
         include/coordination/constants.hpp
-        include/coordination/instance_status.hpp
-        include/coordination/replication_instance.hpp
-        include/coordination/raft_state.hpp
-        include/coordination/rpc_errors.hpp
-
-        include/nuraft/coordinator_log_store.hpp
-        include/nuraft/coordinator_state_machine.hpp
-        include/nuraft/coordinator_state_manager.hpp
+        include/coordination/coordinator_cluster_config.hpp
+        include/coordination/coordinator_handlers.hpp
 
         PRIVATE
         coordinator_client.cpp
         coordinator_state.cpp
         coordinator_rpc.cpp
         coordinator_server.cpp
-        coordinator_handlers.cpp
+        coordinator_data.cpp
         coordinator_instance.cpp
-        replication_instance.cpp
-        raft_state.cpp
-
-        coordinator_log_store.cpp
-        coordinator_state_machine.cpp
-        coordinator_state_manager.cpp
+        coordinator_handlers.cpp
 )
 target_include_directories(mg-coordination PUBLIC include)
 

src/coordination/coordinator_client.cpp

@@ -9,7 +9,6 @@
 // by the Apache License, Version 2.0, included in the file
 // licenses/APL.txt.
 
-#include "utils/uuid.hpp"
 #ifdef MG_ENTERPRISE
 
 #include "coordination/coordinator_client.hpp"
@@ -17,7 +16,6 @@
 #include "coordination/coordinator_config.hpp"
 #include "coordination/coordinator_rpc.hpp"
 #include "replication_coordination_glue/messages.hpp"
-#include "utils/result.hpp"
 
 namespace memgraph::coordination {
 
@@ -29,38 +27,25 @@ auto CreateClientContext(memgraph::coordination::CoordinatorClientConfig const &
 }
 }  // namespace
 
-CoordinatorClient::CoordinatorClient(CoordinatorInstance *coord_instance, CoordinatorClientConfig config,
+CoordinatorClient::CoordinatorClient(CoordinatorData *coord_data, CoordinatorClientConfig config,
                                      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_},
       config_{std::move(config)},
-      coord_instance_{coord_instance},
+      coord_data_{coord_data},
       succ_cb_{std::move(succ_cb)},
       fail_cb_{std::move(fail_cb)} {}
 
 auto CoordinatorClient::InstanceName() const -> std::string { return config_.instance_name; }
 auto CoordinatorClient::SocketAddress() const -> std::string { return rpc_client_.Endpoint().SocketAddress(); }
 
-auto CoordinatorClient::InstanceDownTimeoutSec() const -> std::chrono::seconds {
-  return config_.instance_down_timeout_sec;
-}
-
-auto CoordinatorClient::InstanceGetUUIDFrequencySec() const -> std::chrono::seconds {
-  return config_.instance_get_uuid_frequency_sec;
-}
-
 void CoordinatorClient::StartFrequentCheck() {
-  if (instance_checker_.IsRunning()) {
-    return;
-  }
-
-  MG_ASSERT(config_.instance_health_check_frequency_sec > std::chrono::seconds(0),
+  MG_ASSERT(config_.health_check_frequency_sec > std::chrono::seconds(0),
             "Health check frequency must be greater than 0");
 
   instance_checker_.Run(
-      config_.instance_name, config_.instance_health_check_frequency_sec,
-      [this, instance_name = config_.instance_name] {
+      config_.instance_name, config_.health_check_frequency_sec, [this, instance_name = config_.instance_name] {
         try {
           spdlog::trace("Sending frequent heartbeat to machine {} on {}", instance_name,
                         rpc_client_.Endpoint().SocketAddress());
@@ -68,9 +53,9 @@ void CoordinatorClient::StartFrequentCheck() {
             auto stream{rpc_client_.Stream<memgraph::replication_coordination_glue::FrequentHeartbeatRpc>()};
             stream.AwaitResponse();
           }
-          succ_cb_(coord_instance_, instance_name);
+          succ_cb_(coord_data_, instance_name);
         } catch (rpc::RpcFailedException const &) {
-          fail_cb_(coord_instance_, instance_name);
+          fail_cb_(coord_data_, instance_name);
         }
       });
 }
@@ -86,17 +71,16 @@ auto CoordinatorClient::SetCallbacks(HealthCheckCallback succ_cb, HealthCheckCal
 
 auto CoordinatorClient::ReplicationClientInfo() const -> ReplClientInfo { return config_.replication_client_info; }
 
-auto CoordinatorClient::SendPromoteReplicaToMainRpc(const utils::UUID &uuid,
-                                                    ReplicationClientsInfo replication_clients_info) const -> bool {
+auto CoordinatorClient::SendPromoteReplicaToMainRpc(ReplicationClientsInfo replication_clients_info) const -> bool {
   try {
-    auto stream{rpc_client_.Stream<PromoteReplicaToMainRpc>(uuid, std::move(replication_clients_info))};
+    auto stream{rpc_client_.Stream<PromoteReplicaToMainRpc>(std::move(replication_clients_info))};
     if (!stream.AwaitResponse().success) {
-      spdlog::error("Failed to receive successful PromoteReplicaToMainRpc response!");
+      spdlog::error("Failed to receive successful RPC failover response!");
       return false;
     }
     return true;
   } catch (rpc::RpcFailedException const &) {
-    spdlog::error("RPC error occurred while sending PromoteReplicaToMainRpc!");
+    spdlog::error("RPC error occurred while sending failover RPC!");
   }
   return false;
 }
@@ -117,59 +101,5 @@ auto CoordinatorClient::DemoteToReplica() const -> bool {
   return false;
 }
 
-auto CoordinatorClient::SendSwapMainUUIDRpc(const utils::UUID &uuid) const -> bool {
-  try {
-    auto stream{rpc_client_.Stream<replication_coordination_glue::SwapMainUUIDRpc>(uuid)};
-    if (!stream.AwaitResponse().success) {
-      spdlog::error("Failed to receive successful RPC swapping of uuid response!");
-      return false;
-    }
-    return true;
-  } catch (const rpc::RpcFailedException &) {
-    spdlog::error("RPC error occurred while sending swapping uuid RPC!");
-  }
-  return false;
-}
-
-auto CoordinatorClient::SendUnregisterReplicaRpc(std::string const &instance_name) const -> bool {
-  try {
-    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;
-    }
-    return true;
-  } catch (rpc::RpcFailedException const &) {
-    spdlog::error("Failed to unregister replica!");
-  }
-  return false;
-}
-
-auto CoordinatorClient::SendGetInstanceUUIDRpc() const
-    -> utils::BasicResult<GetInstanceUUIDError, std::optional<utils::UUID>> {
-  try {
-    auto stream{rpc_client_.Stream<GetInstanceUUIDRpc>()};
-    auto res = stream.AwaitResponse();
-    return res.uuid;
-  } catch (const rpc::RpcFailedException &) {
-    spdlog::error("RPC error occured while sending GetInstance UUID RPC");
-    return GetInstanceUUIDError::RPC_EXCEPTION;
-  }
-}
-
-auto CoordinatorClient::SendEnableWritingOnMainRpc() const -> bool {
-  try {
-    auto stream{rpc_client_.Stream<EnableWritingOnMainRpc>()};
-    if (!stream.AwaitResponse().success) {
-      spdlog::error("Failed to receive successful RPC response for enabling writing on main!");
-      return false;
-    }
-    return true;
-  } catch (rpc::RpcFailedException const &) {
-    spdlog::error("Failed to enable writing on main!");
-  }
-  return false;
-}
-
 }  // namespace memgraph::coordination
 #endif

src/coordination/coordinator_data.cpp

@@ -0,0 +1,199 @@
+// 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 "coordination/coordinator_instance.hpp"
+#include "coordination/register_main_replica_coordinator_status.hpp"
+#ifdef MG_ENTERPRISE
+
+#include "coordination/coordinator_data.hpp"
+
+#include <range/v3/view.hpp>
+#include <shared_mutex>
+#include "libnuraft/nuraft.hxx"
+
+namespace memgraph::coordination {
+
+CoordinatorData::CoordinatorData() {
+  auto find_instance = [](CoordinatorData *coord_data, std::string_view instance_name) -> CoordinatorInstance & {
+    auto instance = std::ranges::find_if(
+        coord_data->registered_instances_,
+        [instance_name](CoordinatorInstance const &instance) { return instance.InstanceName() == instance_name; });
+
+    MG_ASSERT(instance != coord_data->registered_instances_.end(), "Instance {} not found during callback!",
+              instance_name);
+    return *instance;
+  };
+
+  replica_succ_cb_ = [find_instance](CoordinatorData *coord_data, std::string_view instance_name) -> void {
+    auto lock = std::lock_guard{coord_data->coord_data_lock_};
+    spdlog::trace("Instance {} performing replica successful callback", instance_name);
+    find_instance(coord_data, instance_name).OnSuccessPing();
+  };
+
+  replica_fail_cb_ = [find_instance](CoordinatorData *coord_data, std::string_view instance_name) -> void {
+    auto lock = std::lock_guard{coord_data->coord_data_lock_};
+    spdlog::trace("Instance {} performing replica failure callback", instance_name);
+    find_instance(coord_data, instance_name).OnFailPing();
+  };
+
+  main_succ_cb_ = [find_instance](CoordinatorData *coord_data, std::string_view instance_name) -> void {
+    auto lock = std::lock_guard{coord_data->coord_data_lock_};
+    spdlog::trace("Instance {} performing main successful callback", instance_name);
+
+    auto &instance = find_instance(coord_data, instance_name);
+
+    if (instance.IsAlive() || !coord_data->ClusterHasAliveMain_()) {
+      instance.OnSuccessPing();
+      return;
+    }
+
+    bool const demoted = instance.DemoteToReplica(coord_data->replica_succ_cb_, coord_data->replica_fail_cb_);
+    if (demoted) {
+      instance.OnSuccessPing();
+      spdlog::info("Instance {} demoted to replica", instance_name);
+    } else {
+      spdlog::error("Instance {} failed to become replica", instance_name);
+    }
+  };
+
+  main_fail_cb_ = [find_instance](CoordinatorData *coord_data, std::string_view instance_name) -> void {
+    auto lock = std::lock_guard{coord_data->coord_data_lock_};
+    spdlog::trace("Instance {} performing main failure callback", instance_name);
+    find_instance(coord_data, instance_name).OnFailPing();
+
+    if (!coord_data->ClusterHasAliveMain_()) {
+      spdlog::info("Cluster without main instance, trying automatic failover");
+      coord_data->TryFailover();
+    }
+  };
+}
+
+auto CoordinatorData::ClusterHasAliveMain_() const -> bool {
+  auto const alive_main = [](CoordinatorInstance const &instance) { return instance.IsMain() && instance.IsAlive(); };
+  return std::ranges::any_of(registered_instances_, alive_main);
+}
+
+auto CoordinatorData::TryFailover() -> void {
+  auto replica_instances = registered_instances_ | ranges::views::filter(&CoordinatorInstance::IsReplica);
+
+  auto chosen_replica_instance = std::ranges::find_if(replica_instances, &CoordinatorInstance::IsAlive);
+  if (chosen_replica_instance == replica_instances.end()) {
+    spdlog::warn("Failover failed since all replicas are down!");
+    return;
+  }
+
+  chosen_replica_instance->PauseFrequentCheck();
+  utils::OnScopeExit scope_exit{[&chosen_replica_instance] { chosen_replica_instance->ResumeFrequentCheck(); }};
+
+  std::vector<ReplClientInfo> repl_clients_info;
+  repl_clients_info.reserve(std::ranges::distance(replica_instances));
+
+  auto const not_chosen_replica_instance = [&chosen_replica_instance](CoordinatorInstance const &instance) {
+    return instance != *chosen_replica_instance;
+  };
+
+  std::ranges::transform(registered_instances_ | ranges::views::filter(not_chosen_replica_instance),
+                         std::back_inserter(repl_clients_info),
+                         [](const CoordinatorInstance &instance) { return instance.ReplicationClientInfo(); });
+
+  if (!chosen_replica_instance->PromoteToMain(std::move(repl_clients_info), main_succ_cb_, main_fail_cb_)) {
+    spdlog::warn("Failover failed since promoting replica to main failed!");
+    return;
+  }
+  spdlog::info("Failover successful! Instance {} promoted to main.", chosen_replica_instance->InstanceName());
+}
+
+auto CoordinatorData::ShowInstances() const -> std::vector<CoordinatorInstanceStatus> {
+  std::vector<CoordinatorInstanceStatus> instances_status;
+  instances_status.reserve(registered_instances_.size());
+
+  auto const stringify_repl_role = [](CoordinatorInstance const &instance) -> std::string {
+    if (!instance.IsAlive()) return "unknown";
+    if (instance.IsMain()) return "main";
+    return "replica";
+  };
+
+  auto const instance_to_status =
+      [&stringify_repl_role](CoordinatorInstance const &instance) -> CoordinatorInstanceStatus {
+    return {.instance_name = instance.InstanceName(),
+            .socket_address = instance.SocketAddress(),
+            .replication_role = stringify_repl_role(instance),
+            .is_alive = instance.IsAlive()};
+  };
+
+  {
+    auto lock = std::shared_lock{coord_data_lock_};
+    std::ranges::transform(registered_instances_, std::back_inserter(instances_status), instance_to_status);
+  }
+
+  return instances_status;
+}
+
+auto CoordinatorData::SetInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus {
+  auto lock = std::lock_guard{coord_data_lock_};
+
+  auto const is_new_main = [&instance_name](CoordinatorInstance const &instance) {
+    return instance.InstanceName() == instance_name;
+  };
+  auto new_main = std::ranges::find_if(registered_instances_, is_new_main);
+
+  if (new_main == registered_instances_.end()) {
+    spdlog::error("Instance {} not registered. Please register it using REGISTER INSTANCE {}", instance_name,
+                  instance_name);
+    return SetInstanceToMainCoordinatorStatus::NO_INSTANCE_WITH_NAME;
+  }
+
+  new_main->PauseFrequentCheck();
+  utils::OnScopeExit scope_exit{[&new_main] { new_main->ResumeFrequentCheck(); }};
+
+  ReplicationClientsInfo repl_clients_info;
+  repl_clients_info.reserve(registered_instances_.size() - 1);
+
+  auto const is_not_new_main = [&instance_name](CoordinatorInstance const &instance) {
+    return instance.InstanceName() != instance_name;
+  };
+  std::ranges::transform(registered_instances_ | ranges::views::filter(is_not_new_main),
+                         std::back_inserter(repl_clients_info),
+                         [](const CoordinatorInstance &instance) { return instance.ReplicationClientInfo(); });
+
+  if (!new_main->PromoteToMain(std::move(repl_clients_info), main_succ_cb_, main_fail_cb_)) {
+    return SetInstanceToMainCoordinatorStatus::COULD_NOT_PROMOTE_TO_MAIN;
+  }
+
+  spdlog::info("Instance {} promoted to main", instance_name);
+  return SetInstanceToMainCoordinatorStatus::SUCCESS;
+}
+
+auto CoordinatorData::RegisterInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus {
+  auto lock = std::lock_guard{coord_data_lock_};
+  if (std::ranges::any_of(registered_instances_, [&config](CoordinatorInstance const &instance) {
+        return instance.InstanceName() == config.instance_name;
+      })) {
+    return RegisterInstanceCoordinatorStatus::NAME_EXISTS;
+  }
+
+  if (std::ranges::any_of(registered_instances_, [&config](CoordinatorInstance const &instance) {
+        return instance.SocketAddress() == config.SocketAddress();
+      })) {
+    return RegisterInstanceCoordinatorStatus::ENDPOINT_EXISTS;
+  }
+
+  try {
+    registered_instances_.emplace_back(this, std::move(config), replica_succ_cb_, replica_fail_cb_);
+    return RegisterInstanceCoordinatorStatus::SUCCESS;
+
+  } catch (CoordinatorRegisterInstanceException const &) {
+    return RegisterInstanceCoordinatorStatus::RPC_FAILED;
+  }
+}
+
+}  // namespace memgraph::coordination
+#endif

src/coordination/coordinator_handlers.cpp

@@ -16,7 +16,6 @@
 
 #include "coordination/coordinator_rpc.hpp"
 #include "coordination/include/coordination/coordinator_server.hpp"
-#include "replication/state.hpp"
 
 namespace memgraph::dbms {
 
@@ -33,53 +32,18 @@ void CoordinatorHandlers::Register(memgraph::coordination::CoordinatorServer &se
         spdlog::info("Received DemoteMainToReplicaRpc from coordinator server");
         CoordinatorHandlers::DemoteMainToReplicaHandler(replication_handler, req_reader, res_builder);
       });
-
-  server.Register<replication_coordination_glue::SwapMainUUIDRpc>(
-      [&replication_handler](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
-        spdlog::info("Received SwapMainUUIDRPC on coordinator server");
-        CoordinatorHandlers::SwapMainUUIDHandler(replication_handler, req_reader, res_builder);
-      });
-
-  server.Register<coordination::UnregisterReplicaRpc>(
-      [&replication_handler](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
-        spdlog::info("Received UnregisterReplicaRpc on coordinator server");
-        CoordinatorHandlers::UnregisterReplicaHandler(replication_handler, req_reader, res_builder);
-      });
-
-  server.Register<coordination::EnableWritingOnMainRpc>(
-      [&replication_handler](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
-        spdlog::info("Received EnableWritingOnMainRpc on coordinator server");
-        CoordinatorHandlers::EnableWritingOnMainHandler(replication_handler, req_reader, res_builder);
-      });
-
-  server.Register<coordination::GetInstanceUUIDRpc>(
-      [&replication_handler](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
-        spdlog::info("Received GetInstanceUUIDRpc on coordinator server");
-        CoordinatorHandlers::GetInstanceUUIDHandler(replication_handler, req_reader, res_builder);
-      });
-}
-
-void CoordinatorHandlers::SwapMainUUIDHandler(replication::ReplicationHandler &replication_handler,
-                                              slk::Reader *req_reader, slk::Builder *res_builder) {
-  if (!replication_handler.IsReplica()) {
-    spdlog::error("Setting main uuid must be performed on replica.");
-    slk::Save(replication_coordination_glue::SwapMainUUIDRes{false}, res_builder);
-    return;
-  }
-
-  replication_coordination_glue::SwapMainUUIDReq req;
-  slk::Load(&req, req_reader);
-  spdlog::info(fmt::format("Set replica data UUID  to main uuid {}", std::string(req.uuid)));
-  std::get<memgraph::replication::RoleReplicaData>(replication_handler.GetReplState().ReplicationData()).uuid_ =
-      req.uuid;
-
-  slk::Save(replication_coordination_glue::SwapMainUUIDRes{true}, res_builder);
 }
 
 void CoordinatorHandlers::DemoteMainToReplicaHandler(replication::ReplicationHandler &replication_handler,
                                                      slk::Reader *req_reader, slk::Builder *res_builder) {
   spdlog::info("Executing DemoteMainToReplicaHandler");
 
+  if (!replication_handler.IsMain()) {
+    spdlog::error("Setting to replica must be performed on main.");
+    slk::Save(coordination::DemoteMainToReplicaRes{false}, res_builder);
+    return;
+  }
+
   coordination::DemoteMainToReplicaReq req;
   slk::Load(&req, req_reader);
 
@@ -87,20 +51,13 @@ void CoordinatorHandlers::DemoteMainToReplicaHandler(replication::ReplicationHan
       .ip_address = req.replication_client_info.replication_ip_address,
       .port = req.replication_client_info.replication_port};
 
-  if (!replication_handler.SetReplicationRoleReplica(clients_config, std::nullopt)) {
+  if (!replication_handler.SetReplicationRoleReplica(clients_config)) {
     spdlog::error("Demoting main to replica failed!");
-    slk::Save(coordination::DemoteMainToReplicaRes{false}, res_builder);
+    slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
     return;
   }
 
-  slk::Save(coordination::DemoteMainToReplicaRes{true}, res_builder);
-}
-
-void CoordinatorHandlers::GetInstanceUUIDHandler(replication::ReplicationHandler &replication_handler,
-                                                 slk::Reader * /*req_reader*/, slk::Builder *res_builder) {
-  spdlog::info("Executing GetInstanceUUIDHandler");
-
-  slk::Save(coordination::GetInstanceUUIDRes{replication_handler.GetReplicaUUID()}, res_builder);
+  slk::Save(coordination::PromoteReplicaToMainRes{true}, res_builder);
 }
 
 void CoordinatorHandlers::PromoteReplicaToMainHandler(replication::ReplicationHandler &replication_handler,
@@ -110,17 +67,18 @@ void CoordinatorHandlers::PromoteReplicaToMainHandler(replication::ReplicationHa
     slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
     return;
   }
-  coordination::PromoteReplicaToMainReq req;
-  slk::Load(&req, req_reader);
 
   // This can fail because of disk. If it does, the cluster state could get inconsistent.
   // We don't handle disk issues.
-  if (const bool success = replication_handler.DoReplicaToMainPromotion(req.main_uuid_); !success) {
+  if (!replication_handler.DoReplicaToMainPromotion()) {
     spdlog::error("Promoting replica to main failed!");
     slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
     return;
   }
 
+  coordination::PromoteReplicaToMainReq req;
+  slk::Load(&req, req_reader);
+
   auto const converter = [](const auto &repl_info_config) {
     return replication::ReplicationClientConfig{
         .name = repl_info_config.instance_name,
@@ -132,7 +90,7 @@ void CoordinatorHandlers::PromoteReplicaToMainHandler(replication::ReplicationHa
 
   // registering replicas
   for (auto const &config : req.replication_clients_info | ranges::views::transform(converter)) {
-    auto instance_client = replication_handler.RegisterReplica(config, false);
+    auto instance_client = replication_handler.RegisterReplica(config);
     if (instance_client.HasError()) {
       using enum memgraph::replication::RegisterReplicaError;
       switch (instance_client.GetError()) {
@@ -151,68 +109,15 @@ void CoordinatorHandlers::PromoteReplicaToMainHandler(replication::ReplicationHa
           spdlog::error("Registered replica could not be persisted!");
           slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
           return;
-        case memgraph::query::RegisterReplicaError::ERROR_ACCEPTING_MAIN:
-          spdlog::error("Replica didn't accept change of main!");
-          slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
-          return;
         case memgraph::query::RegisterReplicaError::CONNECTION_FAILED:
           // Connection failure is not a fatal error
           break;
       }
     }
   }
-  spdlog::info("Promote replica to main was success {}", std::string(req.main_uuid_));
+
   slk::Save(coordination::PromoteReplicaToMainRes{true}, res_builder);
 }
 
-void CoordinatorHandlers::UnregisterReplicaHandler(replication::ReplicationHandler &replication_handler,
-                                                   slk::Reader *req_reader, slk::Builder *res_builder) {
-  if (!replication_handler.IsMain()) {
-    spdlog::error("Unregistering replica must be performed on main.");
-    slk::Save(coordination::UnregisterReplicaRes{false}, res_builder);
-    return;
-  }
-
-  coordination::UnregisterReplicaReq req;
-  slk::Load(&req, req_reader);
-
-  auto res = replication_handler.UnregisterReplica(req.instance_name);
-  switch (res) {
-    using enum memgraph::query::UnregisterReplicaResult;
-    case SUCCESS:
-      slk::Save(coordination::UnregisterReplicaRes{true}, res_builder);
-      break;
-    case NOT_MAIN:
-      spdlog::error("Unregistering replica must be performed on main.");
-      slk::Save(coordination::UnregisterReplicaRes{false}, res_builder);
-      break;
-    case CAN_NOT_UNREGISTER:
-      spdlog::error("Could not unregister replica.");
-      slk::Save(coordination::UnregisterReplicaRes{false}, res_builder);
-      break;
-    case COULD_NOT_BE_PERSISTED:
-      spdlog::error("Could not persist replica unregistration.");
-      slk::Save(coordination::UnregisterReplicaRes{false}, res_builder);
-      break;
-  }
-}
-
-void CoordinatorHandlers::EnableWritingOnMainHandler(replication::ReplicationHandler &replication_handler,
-                                                     slk::Reader * /*req_reader*/, slk::Builder *res_builder) {
-  if (!replication_handler.IsMain()) {
-    spdlog::error("Enable writing on main must be performed on main!");
-    slk::Save(coordination::EnableWritingOnMainRes{false}, res_builder);
-    return;
-  }
-
-  if (!replication_handler.GetReplState().EnableWritingOnMain()) {
-    spdlog::error("Enabling writing on main failed!");
-    slk::Save(coordination::EnableWritingOnMainRes{false}, res_builder);
-    return;
-  }
-
-  slk::Save(coordination::EnableWritingOnMainRes{true}, res_builder);
-}
-
 }  // namespace memgraph::dbms
 #endif

src/coordination/coordinator_instance.cpp

@@ -13,336 +13,72 @@
 
 #include "coordination/coordinator_instance.hpp"
 
-#include "coordination/coordinator_exceptions.hpp"
-#include "nuraft/coordinator_state_machine.hpp"
-#include "nuraft/coordinator_state_manager.hpp"
-#include "utils/counter.hpp"
-#include "utils/functional.hpp"
-
-#include <range/v3/view.hpp>
-#include <shared_mutex>
-
 namespace memgraph::coordination {
 
-using nuraft::ptr;
-using nuraft::srv_config;
-
-CoordinatorInstance::CoordinatorInstance()
-    : raft_state_(RaftState::MakeRaftState(
-          [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;
-        });
-
-    MG_ASSERT(repl_instance != self->repl_instances_.end(), "Instance {} not found during callback!",
-              repl_instance_name);
-    return *repl_instance;
-  };
-
-  replica_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 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();
-  };
-
-  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();
-  };
-
-  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
-    }
-  };
+CoordinatorInstance::CoordinatorInstance(CoordinatorData *data, CoordinatorClientConfig config,
+                                         HealthCheckCallback succ_cb, HealthCheckCallback fail_cb)
+    : client_(data, std::move(config), std::move(succ_cb), std::move(fail_cb)),
+      replication_role_(replication_coordination_glue::ReplicationRole::REPLICA),
+      is_alive_(true) {
+  if (!client_.DemoteToReplica()) {
+    throw CoordinatorRegisterInstanceException("Failed to demote instance {} to replica", client_.InstanceName());
+  }
+  client_.StartFrequentCheck();
 }
 
-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",
-            .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, 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::OnSuccessPing() -> void {
+  last_response_time_ = std::chrono::system_clock::now();
+  is_alive_ = true;
 }
 
-auto CoordinatorInstance::TryFailover() -> void {
-  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;
-  }
-
-  // TODO: Smarter choice
-  auto new_main = ranges::begin(alive_replicas);
-
-  new_main->PauseFrequentCheck();
-  utils::OnScopeExit scope_exit{[&new_main] { new_main->ResumeFrequentCheck(); }};
-
-  auto const is_not_new_main = [&new_main](ReplicationInstance &instance) {
-    return instance.InstanceName() != new_main->InstanceName();
-  };
-
-  auto const new_main_uuid = utils::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
-  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;
-    }
-  }
-
-  // TODO: (andi) fmap compliant
-  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), main_succ_cb_, main_fail_cb_)) {
-    spdlog::warn("Failover failed since promoting replica to main failed!");
-    return;
-  }
-  // 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::OnFailPing() -> bool {
+  is_alive_ =
+      std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - last_response_time_).count() <
+      CoordinatorClusterConfig::alive_response_time_difference_sec_;
+  return is_alive_;
 }
 
-// TODO: (andi) Make sure you cannot put coordinator instance to the main
-auto CoordinatorInstance::SetReplicationInstanceToMain(std::string instance_name)
-    -> SetInstanceToMainCoordinatorStatus {
-  auto lock = std::lock_guard{coord_instance_lock_};
+auto CoordinatorInstance::InstanceName() const -> std::string { return client_.InstanceName(); }
+auto CoordinatorInstance::SocketAddress() const -> std::string { return client_.SocketAddress(); }
+auto CoordinatorInstance::IsAlive() const -> bool { return is_alive_; }
 
-  if (std::ranges::any_of(repl_instances_, &ReplicationInstance::IsMain)) {
-    return SetInstanceToMainCoordinatorStatus::MAIN_ALREADY_EXISTS;
-  }
-
-  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()) {
-    spdlog::error("Instance {} not registered. Please register it using REGISTER INSTANCE {}", instance_name,
-                  instance_name);
-    return SetInstanceToMainCoordinatorStatus::NO_INSTANCE_WITH_NAME;
-  }
-
-  new_main->PauseFrequentCheck();
-  utils::OnScopeExit scope_exit{[&new_main] { new_main->ResumeFrequentCheck(); }};
-
-  auto const is_not_new_main = [&instance_name](ReplicationInstance const &instance) {
-    return instance.InstanceName() != instance_name;
-  };
-
-  auto const new_main_uuid = utils::UUID{};
-
-  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;
-    }
-  }
-
-  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), main_succ_cb_, main_fail_cb_)) {
-    return SetInstanceToMainCoordinatorStatus::COULD_NOT_PROMOTE_TO_MAIN;
-  }
-
-  // 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::IsReplica() const -> bool {
+  return replication_role_ == replication_coordination_glue::ReplicationRole::REPLICA;
+}
+auto CoordinatorInstance::IsMain() const -> bool {
+  return replication_role_ == replication_coordination_glue::ReplicationRole::MAIN;
 }
 
-auto CoordinatorInstance::RegisterReplicationInstance(CoordinatorClientConfig config)
-    -> RegisterInstanceCoordinatorStatus {
-  auto lock = std::lock_guard{coord_instance_lock_};
-
-  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;
+auto CoordinatorInstance::PromoteToMain(ReplicationClientsInfo repl_clients_info, HealthCheckCallback main_succ_cb,
+                                        HealthCheckCallback main_fail_cb) -> bool {
+  if (!client_.SendPromoteReplicaToMainRpc(std::move(repl_clients_info))) {
+    return false;
   }
 
-  auto const socket_address_matches = [&config](ReplicationInstance const &instance) {
-    return instance.SocketAddress() == config.SocketAddress();
-  };
+  replication_role_ = replication_coordination_glue::ReplicationRole::MAIN;
+  client_.SetCallbacks(std::move(main_succ_cb), std::move(main_fail_cb));
 
-  if (std::ranges::any_of(repl_instances_, socket_address_matches)) {
-    return RegisterInstanceCoordinatorStatus::ENDPOINT_EXISTS;
-  }
-
-  if (!raft_state_.RequestLeadership()) {
-    return RegisterInstanceCoordinatorStatus::NOT_LEADER;
-  }
-
-  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;
-  }
-
-  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 (res->get_result_code() != nuraft::cmd_result_code::OK) {
-    spdlog::error("Failed to register instance {} with error code {}", instance_name, res->get_result_code());
-    return RegisterInstanceCoordinatorStatus::RAFT_COULD_NOT_APPEND;
-  }
-
-  spdlog::info("Instance {} registered", instance_name);
-  return RegisterInstanceCoordinatorStatus::SUCCESS;
+  return true;
 }
 
-auto CoordinatorInstance::UnregisterReplicationInstance(std::string instance_name)
-    -> UnregisterInstanceCoordinatorStatus {
-  auto lock = std::lock_guard{coord_instance_lock_};
-
-  auto const name_matches = [&instance_name](ReplicationInstance const &instance) {
-    return instance.InstanceName() == instance_name;
-  };
-
-  auto inst_to_remove = std::ranges::find_if(repl_instances_, name_matches);
-  if (inst_to_remove == repl_instances_.end()) {
-    return UnregisterInstanceCoordinatorStatus::NO_INSTANCE_WITH_NAME;
+auto CoordinatorInstance::DemoteToReplica(HealthCheckCallback replica_succ_cb, HealthCheckCallback replica_fail_cb)
+    -> bool {
+  if (!client_.DemoteToReplica()) {
+    return false;
   }
 
-  if (inst_to_remove->IsMain() && inst_to_remove->IsAlive()) {
-    return UnregisterInstanceCoordinatorStatus::IS_MAIN;
-  }
+  replication_role_ = replication_coordination_glue::ReplicationRole::REPLICA;
+  client_.SetCallbacks(std::move(replica_succ_cb), std::move(replica_fail_cb));
 
-  inst_to_remove->StopFrequentCheck();
-  auto curr_main = std::ranges::find_if(repl_instances_, &ReplicationInstance::IsMain);
-  MG_ASSERT(curr_main != repl_instances_.end(), "There must be a main instance when unregistering a replica");
-  if (!curr_main->SendUnregisterReplicaRpc(instance_name)) {
-    inst_to_remove->StartFrequentCheck();
-    return UnregisterInstanceCoordinatorStatus::RPC_FAILED;
-  }
-  std::erase_if(repl_instances_, name_matches);
-
-  return UnregisterInstanceCoordinatorStatus::SUCCESS;
+  return true;
 }
 
-auto CoordinatorInstance::AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address)
-    -> void {
-  raft_state_.AddCoordinatorInstance(raft_server_id, raft_port, std::move(raft_address));
+auto CoordinatorInstance::PauseFrequentCheck() -> void { client_.PauseFrequentCheck(); }
+auto CoordinatorInstance::ResumeFrequentCheck() -> void { client_.ResumeFrequentCheck(); }
+
+auto CoordinatorInstance::ReplicationClientInfo() const -> CoordinatorClientConfig::ReplicationClientInfo {
+  return client_.ReplicationClientInfo();
 }
 
-auto CoordinatorInstance::GetMainUUID() const -> utils::UUID { return main_uuid_; }
-
-// TODO: (andi) Add to the RAFT log.
-auto CoordinatorInstance::SetMainUUID(utils::UUID new_uuid) -> void { main_uuid_ = new_uuid; }
-
 }  // namespace memgraph::coordination
 #endif

src/coordination/coordinator_log_store.cpp

@@ -1,201 +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_log_store.hpp"
-
-#include "coordination/coordinator_exceptions.hpp"
-#include "utils/logging.hpp"
-
-namespace memgraph::coordination {
-
-using nuraft::cs_new;
-
-namespace {
-
-ptr<log_entry> MakeClone(const ptr<log_entry> &entry) {
-  return cs_new<log_entry>(entry->get_term(), buffer::clone(entry->get_buf()), entry->get_val_type(),
-                           entry->get_timestamp());
-}
-
-}  // namespace
-
-CoordinatorLogStore::CoordinatorLogStore() : start_idx_(1) {
-  ptr<buffer> buf = buffer::alloc(sizeof(uint64_t));
-  logs_[0] = cs_new<log_entry>(0, buf);
-}
-
-CoordinatorLogStore::~CoordinatorLogStore() {}
-
-auto CoordinatorLogStore::FindOrDefault_(uint64_t index) const -> ptr<log_entry> {
-  auto entry = logs_.find(index);
-  if (entry == logs_.end()) {
-    entry = logs_.find(0);
-  }
-  return entry->second;
-}
-
-uint64_t CoordinatorLogStore::next_slot() const {
-  auto lock = std::lock_guard{logs_lock_};
-  return start_idx_ + logs_.size() - 1;
-}
-
-uint64_t CoordinatorLogStore::start_index() const { return start_idx_; }
-
-ptr<log_entry> CoordinatorLogStore::last_entry() const {
-  auto lock = std::lock_guard{logs_lock_};
-
-  uint64_t const last_idx = start_idx_ + logs_.size() - 1;
-  auto const last_src = FindOrDefault_(last_idx - 1);
-
-  return MakeClone(last_src);
-}
-
-uint64_t CoordinatorLogStore::append(ptr<log_entry> &entry) {
-  ptr<log_entry> clone = MakeClone(entry);
-  uint64_t next_slot{0};
-  {
-    auto lock = std::lock_guard{logs_lock_};
-    next_slot = start_idx_ + logs_.size() - 1;
-    logs_[next_slot] = clone;
-  }
-  return next_slot;
-}
-
-void CoordinatorLogStore::write_at(uint64_t index, ptr<log_entry> &entry) {
-  ptr<log_entry> clone = MakeClone(entry);
-
-  // Discard all logs equal to or greater than `index.
-  {
-    auto lock = std::lock_guard{logs_lock_};
-    auto itr = logs_.lower_bound(index);
-    while (itr != logs_.end()) {
-      itr = logs_.erase(itr);
-    }
-    logs_[index] = clone;
-  }
-}
-
-ptr<std::vector<ptr<log_entry>>> CoordinatorLogStore::log_entries(uint64_t start, uint64_t end) {
-  auto ret = cs_new<std::vector<ptr<log_entry>>>();
-  ret->resize(end - start);
-
-  for (uint64_t i = start, curr_index = 0; i < end; ++i, ++curr_index) {
-    ptr<log_entry> src = nullptr;
-    {
-      auto lock = std::lock_guard{logs_lock_};
-      if (auto const entry = logs_.find(i); entry != logs_.end()) {
-        src = entry->second;
-      } else {
-        throw RaftCouldNotFindEntryException("Could not find entry at index {}", i);
-      }
-    }
-    (*ret)[curr_index] = MakeClone(src);
-  }
-  return ret;
-}
-
-ptr<log_entry> CoordinatorLogStore::entry_at(uint64_t index) {
-  ptr<log_entry> src = nullptr;
-  {
-    auto lock = std::lock_guard{logs_lock_};
-    src = FindOrDefault_(index);
-  }
-  return MakeClone(src);
-}
-
-uint64_t CoordinatorLogStore::term_at(uint64_t index) {
-  uint64_t term = 0;
-  {
-    auto lock = std::lock_guard{logs_lock_};
-    term = FindOrDefault_(index)->get_term();
-  }
-  return term;
-}
-
-ptr<buffer> CoordinatorLogStore::pack(uint64_t index, int32 cnt) {
-  std::vector<ptr<buffer>> logs;
-
-  size_t size_total = 0;
-  uint64_t const end_index = index + cnt;
-  for (uint64_t i = index; i < end_index; ++i) {
-    ptr<log_entry> le = nullptr;
-    {
-      auto lock = std::lock_guard{logs_lock_};
-      le = logs_[i];
-    }
-    MG_ASSERT(le.get(), "Could not find log entry at index {}", i);
-    auto buf = le->serialize();
-    size_total += buf->size();
-    logs.push_back(buf);
-  }
-
-  auto buf_out = buffer::alloc(sizeof(int32) + cnt * sizeof(int32) + size_total);
-  buf_out->pos(0);
-  buf_out->put((int32)cnt);
-
-  for (auto &entry : logs) {
-    buf_out->put(static_cast<int32>(entry->size()));
-    buf_out->put(*entry);
-  }
-  return buf_out;
-}
-
-void CoordinatorLogStore::apply_pack(uint64_t index, buffer &pack) {
-  pack.pos(0);
-  int32 const num_logs = pack.get_int();
-
-  for (int32 i = 0; i < num_logs; ++i) {
-    uint64_t cur_idx = index + i;
-    int32 buf_size = pack.get_int();
-
-    ptr<buffer> buf_local = buffer::alloc(buf_size);
-    pack.get(buf_local);
-
-    ptr<log_entry> le = log_entry::deserialize(*buf_local);
-    {
-      auto lock = std::lock_guard{logs_lock_};
-      logs_[cur_idx] = le;
-    }
-  }
-
-  {
-    auto lock = std::lock_guard{logs_lock_};
-    auto const entry = logs_.upper_bound(0);
-    if (entry != logs_.end()) {
-      start_idx_ = entry->first;
-    } else {
-      start_idx_ = 1;
-    }
-  }
-}
-
-// NOTE: Remove all logs up to given 'last_log_index' (inclusive).
-bool CoordinatorLogStore::compact(uint64_t last_log_index) {
-  auto lock = std::lock_guard{logs_lock_};
-  for (uint64_t ii = start_idx_; ii <= last_log_index; ++ii) {
-    auto const entry = logs_.find(ii);
-    if (entry != logs_.end()) {
-      logs_.erase(entry);
-    }
-  }
-
-  if (start_idx_ <= last_log_index) {
-    start_idx_ = last_log_index + 1;
-  }
-  return true;
-}
-
-bool CoordinatorLogStore::flush() { return true; }
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/coordinator_rpc.cpp

@@ -52,51 +52,6 @@ void DemoteMainToReplicaRes::Load(DemoteMainToReplicaRes *self, memgraph::slk::R
   memgraph::slk::Load(self, reader);
 }
 
-void UnregisterReplicaReq::Save(UnregisterReplicaReq const &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-
-void UnregisterReplicaReq::Load(UnregisterReplicaReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-
-void UnregisterReplicaRes::Save(UnregisterReplicaRes const &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-
-void UnregisterReplicaRes::Load(UnregisterReplicaRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-
-void EnableWritingOnMainRes::Save(EnableWritingOnMainRes const &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-
-void EnableWritingOnMainRes::Load(EnableWritingOnMainRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-
-void EnableWritingOnMainReq::Save(EnableWritingOnMainReq const &self, memgraph::slk::Builder *builder) {}
-
-void EnableWritingOnMainReq::Load(EnableWritingOnMainReq *self, memgraph::slk::Reader *reader) {}
-
-// GetInstanceUUID
-void GetInstanceUUIDReq::Save(const GetInstanceUUIDReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-
-void GetInstanceUUIDReq::Load(GetInstanceUUIDReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-
-void GetInstanceUUIDRes::Save(const GetInstanceUUIDRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-
-void GetInstanceUUIDRes::Load(GetInstanceUUIDRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-
 }  // namespace coordination
 
 constexpr utils::TypeInfo coordination::PromoteReplicaToMainReq::kType{utils::TypeId::COORD_FAILOVER_REQ,
@@ -109,31 +64,10 @@ constexpr utils::TypeInfo coordination::DemoteMainToReplicaReq::kType{utils::Typ
                                                                       "CoordDemoteToReplicaReq", nullptr};
 
 constexpr utils::TypeInfo coordination::DemoteMainToReplicaRes::kType{utils::TypeId::COORD_SET_REPL_MAIN_RES,
-
                                                                       "CoordDemoteToReplicaRes", nullptr};
 
-constexpr utils::TypeInfo coordination::UnregisterReplicaReq::kType{utils::TypeId::COORD_UNREGISTER_REPLICA_REQ,
-                                                                    "UnregisterReplicaReq", nullptr};
-
-constexpr utils::TypeInfo coordination::UnregisterReplicaRes::kType{utils::TypeId::COORD_UNREGISTER_REPLICA_RES,
-                                                                    "UnregisterReplicaRes", nullptr};
-
-constexpr utils::TypeInfo coordination::EnableWritingOnMainReq::kType{utils::TypeId::COORD_ENABLE_WRITING_ON_MAIN_REQ,
-                                                                      "CoordEnableWritingOnMainReq", nullptr};
-
-constexpr utils::TypeInfo coordination::EnableWritingOnMainRes::kType{utils::TypeId::COORD_ENABLE_WRITING_ON_MAIN_RES,
-                                                                      "CoordEnableWritingOnMainRes", nullptr};
-
-constexpr utils::TypeInfo coordination::GetInstanceUUIDReq::kType{utils::TypeId::COORD_GET_UUID_REQ, "CoordGetUUIDReq",
-                                                                  nullptr};
-
-constexpr utils::TypeInfo coordination::GetInstanceUUIDRes::kType{utils::TypeId::COORD_GET_UUID_RES, "CoordGetUUIDRes",
-                                                                  nullptr};
-
 namespace slk {
 
-// PromoteReplicaToMainRpc
-
 void Save(const memgraph::coordination::PromoteReplicaToMainRes &self, memgraph::slk::Builder *builder) {
   memgraph::slk::Save(self.success, builder);
 }
@@ -143,16 +77,13 @@ void Load(memgraph::coordination::PromoteReplicaToMainRes *self, memgraph::slk::
 }
 
 void Save(const memgraph::coordination::PromoteReplicaToMainReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.main_uuid_, builder);
   memgraph::slk::Save(self.replication_clients_info, builder);
 }
 
 void Load(memgraph::coordination::PromoteReplicaToMainReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->main_uuid_, reader);
   memgraph::slk::Load(&self->replication_clients_info, reader);
 }
 
-// DemoteMainToReplicaRpc
 void Save(const memgraph::coordination::DemoteMainToReplicaReq &self, memgraph::slk::Builder *builder) {
   memgraph::slk::Save(self.replication_client_info, builder);
 }
@@ -169,50 +100,6 @@ void Load(memgraph::coordination::DemoteMainToReplicaRes *self, memgraph::slk::R
   memgraph::slk::Load(&self->success, reader);
 }
 
-// UnregisterReplicaRpc
-
-void Save(memgraph::coordination::UnregisterReplicaReq const &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.instance_name, builder);
-}
-
-void Load(memgraph::coordination::UnregisterReplicaReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->instance_name, reader);
-}
-
-void Save(memgraph::coordination::UnregisterReplicaRes const &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.success, builder);
-}
-
-void Load(memgraph::coordination::UnregisterReplicaRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->success, reader);
-}
-
-void Save(memgraph::coordination::EnableWritingOnMainRes const &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.success, builder);
-}
-
-void Load(memgraph::coordination::EnableWritingOnMainRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->success, reader);
-}
-
-// GetInstanceUUIDRpc
-
-void Save(const memgraph::coordination::GetInstanceUUIDReq & /*self*/, memgraph::slk::Builder * /*builder*/) {
-  /* nothing to serialize*/
-}
-
-void Load(memgraph::coordination::GetInstanceUUIDReq * /*self*/, memgraph::slk::Reader * /*reader*/) {
-  /* nothing to serialize*/
-}
-
-void Save(const memgraph::coordination::GetInstanceUUIDRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.uuid, builder);
-}
-
-void Load(memgraph::coordination::GetInstanceUUIDRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->uuid, reader);
-}
-
 }  // namespace slk
 
 }  // namespace memgraph

src/coordination/coordinator_server.cpp

@@ -12,7 +12,7 @@
 #ifdef MG_ENTERPRISE
 
 #include "coordination/coordinator_server.hpp"
-#include "replication_coordination_glue/handler.hpp"
+#include "replication_coordination_glue/messages.hpp"
 
 namespace memgraph::coordination {
 

src/coordination/coordinator_state.cpp

@@ -25,7 +25,7 @@
 namespace memgraph::coordination {
 
 CoordinatorState::CoordinatorState() {
-  MG_ASSERT(!(FLAGS_raft_server_id && FLAGS_coordinator_server_port),
+  MG_ASSERT(!(FLAGS_coordinator && FLAGS_coordinator_server_port),
             "Instance cannot be a coordinator and have registered coordinator server.");
 
   spdlog::info("Executing coordinator constructor");
@@ -41,53 +41,37 @@ CoordinatorState::CoordinatorState() {
   }
 }
 
-auto CoordinatorState::RegisterReplicationInstance(CoordinatorClientConfig config)
-    -> RegisterInstanceCoordinatorStatus {
-  MG_ASSERT(std::holds_alternative<CoordinatorInstance>(data_),
+auto CoordinatorState::RegisterInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus {
+  MG_ASSERT(std::holds_alternative<CoordinatorData>(data_),
             "Coordinator cannot register replica since variant holds wrong alternative");
 
   return std::visit(
-      memgraph::utils::Overloaded{[](const CoordinatorMainReplicaData & /*coordinator_main_replica_data*/) {
-                                    return RegisterInstanceCoordinatorStatus::NOT_COORDINATOR;
-                                  },
-                                  [config](CoordinatorInstance &coordinator_instance) {
-                                    return coordinator_instance.RegisterReplicationInstance(config);
-                                  }},
+      memgraph::utils::Overloaded{
+          [](const CoordinatorMainReplicaData & /*coordinator_main_replica_data*/) {
+            return RegisterInstanceCoordinatorStatus::NOT_COORDINATOR;
+          },
+          [config](CoordinatorData &coordinator_data) { return coordinator_data.RegisterInstance(config); }},
       data_);
 }
 
-auto CoordinatorState::UnregisterReplicationInstance(std::string instance_name) -> UnregisterInstanceCoordinatorStatus {
-  MG_ASSERT(std::holds_alternative<CoordinatorInstance>(data_),
-            "Coordinator cannot unregister instance since variant holds wrong alternative");
-
-  return std::visit(
-      memgraph::utils::Overloaded{[](const CoordinatorMainReplicaData & /*coordinator_main_replica_data*/) {
-                                    return UnregisterInstanceCoordinatorStatus::NOT_COORDINATOR;
-                                  },
-                                  [&instance_name](CoordinatorInstance &coordinator_instance) {
-                                    return coordinator_instance.UnregisterReplicationInstance(instance_name);
-                                  }},
-      data_);
-}
-
-auto CoordinatorState::SetReplicationInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus {
-  MG_ASSERT(std::holds_alternative<CoordinatorInstance>(data_),
+auto CoordinatorState::SetInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus {
+  MG_ASSERT(std::holds_alternative<CoordinatorData>(data_),
             "Coordinator cannot register replica since variant holds wrong alternative");
 
   return std::visit(
       memgraph::utils::Overloaded{[](const CoordinatorMainReplicaData & /*coordinator_main_replica_data*/) {
                                     return SetInstanceToMainCoordinatorStatus::NOT_COORDINATOR;
                                   },
-                                  [&instance_name](CoordinatorInstance &coordinator_instance) {
-                                    return coordinator_instance.SetReplicationInstanceToMain(instance_name);
+                                  [&instance_name](CoordinatorData &coordinator_data) {
+                                    return coordinator_data.SetInstanceToMain(instance_name);
                                   }},
       data_);
 }
 
-auto CoordinatorState::ShowInstances() const -> std::vector<InstanceStatus> {
-  MG_ASSERT(std::holds_alternative<CoordinatorInstance>(data_),
+auto CoordinatorState::ShowInstances() const -> std::vector<CoordinatorInstanceStatus> {
+  MG_ASSERT(std::holds_alternative<CoordinatorData>(data_),
             "Can't call show instances on data_, as variant holds wrong alternative");
-  return std::get<CoordinatorInstance>(data_).ShowInstances();
+  return std::get<CoordinatorData>(data_).ShowInstances();
 }
 
 auto CoordinatorState::GetCoordinatorServer() const -> CoordinatorServer & {
@@ -95,13 +79,5 @@ auto CoordinatorState::GetCoordinatorServer() const -> CoordinatorServer & {
             "Cannot get coordinator server since variant holds wrong alternative");
   return *std::get<CoordinatorMainReplicaData>(data_).coordinator_server_;
 }
-
-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);
-}
-
 }  // namespace memgraph::coordination
 #endif

src/coordination/coordinator_state_machine.cpp

@@ -1,111 +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_state_machine.hpp"
-
-namespace memgraph::coordination {
-
-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::DecodeRegisterReplicationInstance(buffer &data) -> std::string {
-  buffer_serializer bs(data);
-  return bs.get_str();
-}
-
-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();
-
-  spdlog::info("commit {} : {}", log_idx, str);
-
-  last_committed_idx_ = log_idx;
-  return nullptr;
-}
-
-auto CoordinatorStateMachine::commit_config(ulong const log_idx, ptr<cluster_config> & /*new_conf*/) -> void {
-  last_committed_idx_ = log_idx;
-}
-
-auto CoordinatorStateMachine::rollback(ulong const log_idx, buffer &data) -> void {
-  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*/,
-                                                   ptr<buffer> &data_out, bool &is_last_obj) -> int {
-  // Put dummy data.
-  data_out = buffer::alloc(sizeof(int32));
-  buffer_serializer bs(data_out);
-  bs.put_i32(0);
-
-  is_last_obj = true;
-  return 0;
-}
-
-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 {
-  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 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 {
-  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);
-}
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/coordinator_state_manager.cpp

@@ -1,68 +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_state_manager.hpp"
-
-namespace memgraph::coordination {
-
-using nuraft::cluster_config;
-using nuraft::cs_new;
-using nuraft::srv_config;
-using nuraft::srv_state;
-using nuraft::state_mgr;
-
-CoordinatorStateManager::CoordinatorStateManager(int srv_id, std::string const &endpoint)
-    : my_id_(srv_id), my_endpoint_(endpoint), cur_log_store_(cs_new<CoordinatorLogStore>()) {
-  my_srv_config_ = cs_new<srv_config>(srv_id, endpoint);
-
-  // Initial cluster config: contains only one server (myself).
-  cluster_config_ = cs_new<cluster_config>();
-  cluster_config_->get_servers().push_back(my_srv_config_);
-}
-
-auto CoordinatorStateManager::load_config() -> ptr<cluster_config> {
-  // Just return in-memory data in this example.
-  // May require reading from disk here, if it has been written to disk.
-  return cluster_config_;
-}
-
-auto CoordinatorStateManager::save_config(cluster_config const &config) -> void {
-  // Just keep in memory in this example.
-  // Need to write to disk here, if want to make it durable.
-  ptr<buffer> buf = config.serialize();
-  cluster_config_ = cluster_config::deserialize(*buf);
-}
-
-auto CoordinatorStateManager::save_state(srv_state const &state) -> void {
-  // Just keep in memory in this example.
-  // Need to write to disk here, if want to make it durable.
-  ptr<buffer> buf = state.serialize();
-  saved_state_ = srv_state::deserialize(*buf);
-}
-
-auto CoordinatorStateManager::read_state() -> ptr<srv_state> {
-  // Just return in-memory data in this example.
-  // May require reading from disk here, if it has been written to disk.
-  return saved_state_;
-}
-
-auto CoordinatorStateManager::load_log_store() -> ptr<log_store> { return cur_log_store_; }
-
-auto CoordinatorStateManager::server_id() -> int32 { return my_id_; }
-
-auto CoordinatorStateManager::system_exit(int const exit_code) -> void {}
-
-auto CoordinatorStateManager::GetSrvConfig() const -> ptr<srv_config> { return my_srv_config_; }
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/include/coordination/coordinator_client.hpp

@@ -15,21 +15,18 @@
 
 #include "coordination/coordinator_config.hpp"
 #include "rpc/client.hpp"
-#include "rpc_errors.hpp"
-#include "utils/result.hpp"
 #include "utils/scheduler.hpp"
-#include "utils/uuid.hpp"
 
 namespace memgraph::coordination {
 
-class CoordinatorInstance;
-using HealthCheckCallback = std::function<void(CoordinatorInstance *, std::string_view)>;
+class CoordinatorData;
+using HealthCheckCallback = std::function<void(CoordinatorData *, std::string_view)>;
 using ReplicationClientsInfo = std::vector<ReplClientInfo>;
 
 class CoordinatorClient {
  public:
-  explicit CoordinatorClient(CoordinatorInstance *coord_instance, CoordinatorClientConfig config,
-                             HealthCheckCallback succ_cb, HealthCheckCallback fail_cb);
+  explicit CoordinatorClient(CoordinatorData *coord_data_, CoordinatorClientConfig config, HealthCheckCallback succ_cb,
+                             HealthCheckCallback fail_cb);
 
   ~CoordinatorClient() = default;
 
@@ -47,29 +44,13 @@ class CoordinatorClient {
   auto InstanceName() const -> std::string;
   auto SocketAddress() const -> std::string;
 
+  [[nodiscard]] auto SendPromoteReplicaToMainRpc(ReplicationClientsInfo replication_clients_info) const -> bool;
   [[nodiscard]] auto DemoteToReplica() const -> bool;
 
-  auto SendPromoteReplicaToMainRpc(const utils::UUID &uuid, ReplicationClientsInfo replication_clients_info) const
-      -> bool;
-
-  auto SendSwapMainUUIDRpc(const utils::UUID &uuid) const -> bool;
-
-  auto SendUnregisterReplicaRpc(std::string const &instance_name) const -> bool;
-
-  auto SendEnableWritingOnMainRpc() const -> bool;
-
-  auto SendGetInstanceUUIDRpc() const -> memgraph::utils::BasicResult<GetInstanceUUIDError, std::optional<utils::UUID>>;
-
   auto ReplicationClientInfo() const -> ReplClientInfo;
 
   auto SetCallbacks(HealthCheckCallback succ_cb, HealthCheckCallback fail_cb) -> void;
 
-  auto RpcClient() -> rpc::Client & { return rpc_client_; }
-
-  auto InstanceDownTimeoutSec() const -> std::chrono::seconds;
-
-  auto InstanceGetUUIDFrequencySec() const -> std::chrono::seconds;
-
   friend bool operator==(CoordinatorClient const &first, CoordinatorClient const &second) {
     return first.config_ == second.config_;
   }
@@ -77,11 +58,12 @@ class CoordinatorClient {
  private:
   utils::Scheduler instance_checker_;
 
+  // TODO: (andi) Pimpl?
   communication::ClientContext rpc_context_;
   mutable rpc::Client rpc_client_;
 
   CoordinatorClientConfig config_;
-  CoordinatorInstance *coord_instance_;
+  CoordinatorData *coord_data_;
   HealthCheckCallback succ_cb_;
   HealthCheckCallback fail_cb_;
 };

src/coordination/include/coordination/coordinator_cluster_config.hpp

@@ -9,6 +9,14 @@
 // by the Apache License, Version 2.0, included in the file
 // licenses/APL.txt.
 
+#pragma once
+
+#ifdef MG_ENTERPRISE
 namespace memgraph::coordination {
-enum class GetInstanceUUIDError { NO_RESPONSE, RPC_EXCEPTION };
+
+struct CoordinatorClusterConfig {
+  static constexpr int alive_response_time_difference_sec_{5};
+};
+
 }  // namespace memgraph::coordination
+#endif

src/coordination/include/coordination/coordinator_config.hpp

@@ -28,9 +28,7 @@ struct CoordinatorClientConfig {
   std::string instance_name;
   std::string ip_address;
   uint16_t port{};
-  std::chrono::seconds instance_health_check_frequency_sec{1};
-  std::chrono::seconds instance_down_timeout_sec{5};
-  std::chrono::seconds instance_get_uuid_frequency_sec{10};
+  std::chrono::seconds health_check_frequency_sec{1};
 
   auto SocketAddress() const -> std::string { return ip_address + ":" + std::to_string(port); }
 

src/coordination/include/coordination/coordinator_data.hpp

@@ -0,0 +1,52 @@
+// 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_instance.hpp"
+#include "coordination/coordinator_instance_status.hpp"
+#include "coordination/coordinator_server.hpp"
+#include "coordination/register_main_replica_coordinator_status.hpp"
+#include "utils/rw_lock.hpp"
+#include "utils/thread_pool.hpp"
+
+#include <list>
+
+namespace memgraph::coordination {
+class CoordinatorData {
+ public:
+  CoordinatorData();
+
+  [[nodiscard]] auto RegisterInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus;
+
+  [[nodiscard]] auto SetInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus;
+
+  auto TryFailover() -> void;
+
+  auto ShowInstances() const -> std::vector<CoordinatorInstanceStatus>;
+
+ private:
+  auto ClusterHasAliveMain_() const -> bool;
+
+  mutable utils::RWLock coord_data_lock_{utils::RWLock::Priority::READ};
+  HealthCheckCallback main_succ_cb_, main_fail_cb_, replica_succ_cb_, replica_fail_cb_;
+  // NOTE: Must be std::list because we rely on pointer stability
+  std::list<CoordinatorInstance> registered_instances_;
+};
+
+struct CoordinatorMainReplicaData {
+  std::unique_ptr<CoordinatorServer> coordinator_server_;
+};
+
+}  // namespace memgraph::coordination
+#endif

src/coordination/include/coordination/coordinator_exceptions.hpp

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

src/coordination/include/coordination/coordinator_handlers.hpp

@@ -31,16 +31,6 @@ class CoordinatorHandlers {
                                           slk::Builder *res_builder);
   static void DemoteMainToReplicaHandler(replication::ReplicationHandler &replication_handler, slk::Reader *req_reader,
                                          slk::Builder *res_builder);
-  static void SwapMainUUIDHandler(replication::ReplicationHandler &replication_handler, slk::Reader *req_reader,
-                                  slk::Builder *res_builder);
-
-  static void UnregisterReplicaHandler(replication::ReplicationHandler &replication_handler, slk::Reader *req_reader,
-                                       slk::Builder *res_builder);
-  static void EnableWritingOnMainHandler(replication::ReplicationHandler &replication_handler, slk::Reader *req_reader,
-                                         slk::Builder *res_builder);
-
-  static void GetInstanceUUIDHandler(replication::ReplicationHandler &replication_handler, slk::Reader *req_reader,
-                                     slk::Builder *res_builder);
 };
 
 }  // namespace memgraph::dbms

src/coordination/include/coordination/coordinator_instance.hpp

@@ -13,47 +13,55 @@
 
 #ifdef MG_ENTERPRISE
 
-#include "coordination/coordinator_server.hpp"
-#include "coordination/instance_status.hpp"
-#include "coordination/raft_state.hpp"
-#include "coordination/register_main_replica_coordinator_status.hpp"
-#include "coordination/replication_instance.hpp"
-#include "utils/rw_lock.hpp"
-#include "utils/thread_pool.hpp"
-
-#include <list>
+#include "coordination/coordinator_client.hpp"
+#include "coordination/coordinator_cluster_config.hpp"
+#include "coordination/coordinator_exceptions.hpp"
+#include "replication_coordination_glue/role.hpp"
 
 namespace memgraph::coordination {
 
+class CoordinatorData;
+
 class CoordinatorInstance {
  public:
-  CoordinatorInstance();
+  CoordinatorInstance(CoordinatorData *data, CoordinatorClientConfig config, HealthCheckCallback succ_cb,
+                      HealthCheckCallback fail_cb);
 
-  [[nodiscard]] auto RegisterReplicationInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus;
-  [[nodiscard]] auto UnregisterReplicationInstance(std::string instance_name) -> UnregisterInstanceCoordinatorStatus;
+  CoordinatorInstance(CoordinatorInstance const &other) = delete;
+  CoordinatorInstance &operator=(CoordinatorInstance const &other) = delete;
+  CoordinatorInstance(CoordinatorInstance &&other) noexcept = delete;
+  CoordinatorInstance &operator=(CoordinatorInstance &&other) noexcept = delete;
+  ~CoordinatorInstance() = default;
 
-  [[nodiscard]] auto SetReplicationInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus;
+  auto OnSuccessPing() -> void;
+  auto OnFailPing() -> bool;
 
-  auto ShowInstances() const -> std::vector<InstanceStatus>;
+  auto IsAlive() const -> bool;
 
-  auto TryFailover() -> void;
+  auto InstanceName() const -> std::string;
+  auto SocketAddress() const -> std::string;
 
-  auto AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address) -> void;
+  auto IsReplica() const -> bool;
+  auto IsMain() const -> bool;
 
-  auto GetMainUUID() const -> utils::UUID;
+  auto PromoteToMain(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 SetMainUUID(utils::UUID new_uuid) -> void;
+  auto PauseFrequentCheck() -> void;
+  auto ResumeFrequentCheck() -> void;
+
+  auto ReplicationClientInfo() const -> ReplClientInfo;
 
  private:
-  HealthCheckCallback main_succ_cb_, main_fail_cb_, replica_succ_cb_, replica_fail_cb_;
+  CoordinatorClient client_;
+  replication_coordination_glue::ReplicationRole replication_role_;
+  std::chrono::system_clock::time_point last_response_time_{};
+  bool is_alive_{false};
 
-  // NOTE: Must be std::list because we rely on pointer stability
-  std::list<ReplicationInstance> repl_instances_;
-  mutable utils::RWLock coord_instance_lock_{utils::RWLock::Priority::READ};
-
-  utils::UUID main_uuid_;
-
-  RaftState raft_state_;
+  friend bool operator==(CoordinatorInstance const &first, CoordinatorInstance const &second) {
+    return first.client_ == second.client_ && first.replication_role_ == second.replication_role_;
+  }
 };
 
 }  // namespace memgraph::coordination

src/coordination/include/coordination/coordinator_instance_status.hpp

@@ -19,13 +19,10 @@
 
 namespace memgraph::coordination {
 
-// TODO: (andi) For phase IV. Some instances won't have raft_socket_address, coord_socket_address, replication_role and
-// cluster role... At the end, all instances will have everything.
-struct InstanceStatus {
+struct CoordinatorInstanceStatus {
   std::string instance_name;
-  std::string raft_socket_address;
-  std::string coord_socket_address;
-  std::string cluster_role;
+  std::string socket_address;
+  std::string replication_role;
   bool is_alive;
 };
 

src/coordination/include/coordination/coordinator_rpc.hpp

@@ -11,7 +11,6 @@
 
 #pragma once
 
-#include "utils/uuid.hpp"
 #ifdef MG_ENTERPRISE
 
 #include "coordination/coordinator_config.hpp"
@@ -27,13 +26,10 @@ struct PromoteReplicaToMainReq {
   static void Load(PromoteReplicaToMainReq *self, memgraph::slk::Reader *reader);
   static void Save(const PromoteReplicaToMainReq &self, memgraph::slk::Builder *builder);
 
-  explicit PromoteReplicaToMainReq(const utils::UUID &uuid,
-                                   std::vector<CoordinatorClientConfig::ReplicationClientInfo> replication_clients_info)
-      : main_uuid_(uuid), replication_clients_info(std::move(replication_clients_info)) {}
+  explicit PromoteReplicaToMainReq(std::vector<CoordinatorClientConfig::ReplicationClientInfo> replication_clients_info)
+      : replication_clients_info(std::move(replication_clients_info)) {}
   PromoteReplicaToMainReq() = default;
 
-  // get uuid here
-  utils::UUID main_uuid_;
   std::vector<CoordinatorClientConfig::ReplicationClientInfo> replication_clients_info;
 };
 
@@ -82,116 +78,27 @@ struct DemoteMainToReplicaRes {
 
 using DemoteMainToReplicaRpc = rpc::RequestResponse<DemoteMainToReplicaReq, DemoteMainToReplicaRes>;
 
-struct UnregisterReplicaReq {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(UnregisterReplicaReq *self, memgraph::slk::Reader *reader);
-  static void Save(UnregisterReplicaReq const &self, memgraph::slk::Builder *builder);
-
-  explicit UnregisterReplicaReq(std::string instance_name) : instance_name(std::move(instance_name)) {}
-
-  UnregisterReplicaReq() = default;
-
-  std::string instance_name;
-};
-
-struct UnregisterReplicaRes {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(UnregisterReplicaRes *self, memgraph::slk::Reader *reader);
-  static void Save(const UnregisterReplicaRes &self, memgraph::slk::Builder *builder);
-
-  explicit UnregisterReplicaRes(bool success) : success(success) {}
-  UnregisterReplicaRes() = default;
-
-  bool success;
-};
-
-using UnregisterReplicaRpc = rpc::RequestResponse<UnregisterReplicaReq, UnregisterReplicaRes>;
-
-struct EnableWritingOnMainReq {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(EnableWritingOnMainReq *self, memgraph::slk::Reader *reader);
-  static void Save(EnableWritingOnMainReq const &self, memgraph::slk::Builder *builder);
-
-  EnableWritingOnMainReq() = default;
-};
-
-struct EnableWritingOnMainRes {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(EnableWritingOnMainRes *self, memgraph::slk::Reader *reader);
-  static void Save(EnableWritingOnMainRes const &self, memgraph::slk::Builder *builder);
-
-  explicit EnableWritingOnMainRes(bool success) : success(success) {}
-  EnableWritingOnMainRes() = default;
-
-  bool success;
-};
-
-using EnableWritingOnMainRpc = rpc::RequestResponse<EnableWritingOnMainReq, EnableWritingOnMainRes>;
-
-struct GetInstanceUUIDReq {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(GetInstanceUUIDReq *self, memgraph::slk::Reader *reader);
-  static void Save(const GetInstanceUUIDReq &self, memgraph::slk::Builder *builder);
-
-  GetInstanceUUIDReq() = default;
-};
-
-struct GetInstanceUUIDRes {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(GetInstanceUUIDRes *self, memgraph::slk::Reader *reader);
-  static void Save(const GetInstanceUUIDRes &self, memgraph::slk::Builder *builder);
-
-  explicit GetInstanceUUIDRes(std::optional<utils::UUID> uuid) : uuid(uuid) {}
-  GetInstanceUUIDRes() = default;
-
-  std::optional<utils::UUID> uuid;
-};
-
-using GetInstanceUUIDRpc = rpc::RequestResponse<GetInstanceUUIDReq, GetInstanceUUIDRes>;
-
 }  // namespace memgraph::coordination
 
 // SLK serialization declarations
 namespace memgraph::slk {
 
-// PromoteReplicaToMainRpc
 void Save(const memgraph::coordination::PromoteReplicaToMainRes &self, memgraph::slk::Builder *builder);
+
 void Load(memgraph::coordination::PromoteReplicaToMainRes *self, memgraph::slk::Reader *reader);
+
 void Save(const memgraph::coordination::PromoteReplicaToMainReq &self, memgraph::slk::Builder *builder);
+
 void Load(memgraph::coordination::PromoteReplicaToMainReq *self, memgraph::slk::Reader *reader);
 
-// DemoteMainToReplicaRpc
 void Save(const memgraph::coordination::DemoteMainToReplicaRes &self, memgraph::slk::Builder *builder);
+
 void Load(memgraph::coordination::DemoteMainToReplicaRes *self, memgraph::slk::Reader *reader);
+
 void Save(const memgraph::coordination::DemoteMainToReplicaReq &self, memgraph::slk::Builder *builder);
+
 void Load(memgraph::coordination::DemoteMainToReplicaReq *self, memgraph::slk::Reader *reader);
 
-// GetInstanceUUIDRpc
-void Save(const memgraph::coordination::GetInstanceUUIDReq &self, memgraph::slk::Builder *builder);
-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);
-
-void Save(memgraph::coordination::EnableWritingOnMainRes const &self, memgraph::slk::Builder *builder);
-void Load(memgraph::coordination::EnableWritingOnMainRes *self, memgraph::slk::Reader *reader);
-
 }  // namespace memgraph::slk
 
 #endif

src/coordination/include/coordination/coordinator_state.hpp

@@ -13,9 +13,9 @@
 
 #ifdef MG_ENTERPRISE
 
-#include "coordination/coordinator_instance.hpp"
+#include "coordination/coordinator_data.hpp"
+#include "coordination/coordinator_instance_status.hpp"
 #include "coordination/coordinator_server.hpp"
-#include "coordination/instance_status.hpp"
 #include "coordination/register_main_replica_coordinator_status.hpp"
 
 #include <variant>
@@ -33,24 +33,17 @@ class CoordinatorState {
   CoordinatorState(CoordinatorState &&) noexcept = delete;
   CoordinatorState &operator=(CoordinatorState &&) noexcept = delete;
 
-  [[nodiscard]] auto RegisterReplicationInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus;
-  [[nodiscard]] auto UnregisterReplicationInstance(std::string instance_name) -> UnregisterInstanceCoordinatorStatus;
+  [[nodiscard]] auto RegisterInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus;
 
-  [[nodiscard]] auto SetReplicationInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus;
+  [[nodiscard]] auto SetInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus;
 
-  auto ShowInstances() const -> std::vector<InstanceStatus>;
+  auto ShowInstances() const -> std::vector<CoordinatorInstanceStatus>;
 
-  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.
+  // The client code must check that the server exists before calling this method.
   auto GetCoordinatorServer() const -> CoordinatorServer &;
 
  private:
-  struct CoordinatorMainReplicaData {
-    std::unique_ptr<CoordinatorServer> coordinator_server_;
-  };
-
-  std::variant<CoordinatorInstance, CoordinatorMainReplicaData> data_;
+  std::variant<CoordinatorData, CoordinatorMainReplicaData> data_;
 };
 
 }  // namespace memgraph::coordination

src/coordination/include/coordination/raft_state.hpp

@@ -1,79 +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 <flags/replication.hpp>
-
-#include <libnuraft/nuraft.hxx>
-
-namespace memgraph::coordination {
-
-using BecomeLeaderCb = std::function<void()>;
-using BecomeFollowerCb = std::function<void()>;
-
-using nuraft::buffer;
-using nuraft::logger;
-using nuraft::ptr;
-using nuraft::raft_launcher;
-using nuraft::raft_server;
-using nuraft::srv_config;
-using nuraft::state_machine;
-using nuraft::state_mgr;
-using raft_result = nuraft::cmd_result<ptr<buffer>>;
-
-class RaftState {
- private:
-  explicit RaftState(BecomeLeaderCb become_leader_cb, BecomeFollowerCb become_follower_cb, uint32_t raft_server_id,
-                     uint32_t raft_port, std::string raft_address);
-
-  auto InitRaftServer() -> void;
-
- public:
-  RaftState() = delete;
-  RaftState(RaftState const &other) = default;
-  RaftState &operator=(RaftState const &other) = default;
-  RaftState(RaftState &&other) noexcept = default;
-  RaftState &operator=(RaftState &&other) noexcept = default;
-  ~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 raft_address) -> void;
-  auto GetAllCoordinators() const -> std::vector<ptr<srv_config>>;
-
-  auto RequestLeadership() -> bool;
-  auto IsLeader() const -> bool;
-
-  auto AppendRegisterReplicationInstance(std::string const &instance) -> ptr<raft_result>;
-
-  // TODO: (andi) I think variables below can be abstracted
-  uint32_t raft_server_id_;
-  uint32_t raft_port_;
-  std::string raft_address_;
-
-  ptr<state_machine> state_machine_;
-  ptr<state_mgr> state_manager_;
-  ptr<raft_server> raft_server_;
-  ptr<logger> logger_;
-  raft_launcher launcher_;
-
-  BecomeLeaderCb become_leader_cb_;
-  BecomeFollowerCb become_follower_cb_;
-};
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/include/coordination/register_main_replica_coordinator_status.hpp

@@ -22,28 +22,14 @@ enum class RegisterInstanceCoordinatorStatus : uint8_t {
   ENDPOINT_EXISTS,
   NOT_COORDINATOR,
   RPC_FAILED,
-  NOT_LEADER,
-  RAFT_COULD_NOT_ACCEPT,
-  RAFT_COULD_NOT_APPEND,
   SUCCESS
 };
 
-enum class UnregisterInstanceCoordinatorStatus : uint8_t {
-  NO_INSTANCE_WITH_NAME,
-  IS_MAIN,
-  NOT_COORDINATOR,
-  NOT_LEADER,
-  RPC_FAILED,
-  SUCCESS,
-};
-
 enum class SetInstanceToMainCoordinatorStatus : uint8_t {
   NO_INSTANCE_WITH_NAME,
-  MAIN_ALREADY_EXISTS,
   NOT_COORDINATOR,
   SUCCESS,
   COULD_NOT_PROMOTE_TO_MAIN,
-  SWAP_UUID_FAILED
 };
 
 }  // namespace memgraph::coordination

src/coordination/include/coordination/replication_instance.hpp

@@ -1,99 +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_client.hpp"
-#include "coordination/coordinator_exceptions.hpp"
-#include "replication_coordination_glue/role.hpp"
-
-#include <libnuraft/nuraft.hxx>
-#include "utils/result.hpp"
-#include "utils/uuid.hpp"
-
-namespace memgraph::coordination {
-
-class CoordinatorInstance;
-
-class ReplicationInstance {
- public:
-  ReplicationInstance(CoordinatorInstance *peer, CoordinatorClientConfig config, HealthCheckCallback succ_cb,
-                      HealthCheckCallback fail_cb);
-
-  ReplicationInstance(ReplicationInstance const &other) = delete;
-  ReplicationInstance &operator=(ReplicationInstance const &other) = delete;
-  ReplicationInstance(ReplicationInstance &&other) noexcept = delete;
-  ReplicationInstance &operator=(ReplicationInstance &&other) noexcept = delete;
-  ~ReplicationInstance() = default;
-
-  auto OnSuccessPing() -> void;
-  auto OnFailPing() -> bool;
-  auto IsReadyForUUIDPing() -> bool;
-
-  void UpdateReplicaLastResponseUUID();
-
-  auto IsAlive() const -> bool;
-
-  auto InstanceName() const -> std::string;
-  auto SocketAddress() const -> std::string;
-
-  auto IsReplica() const -> bool;
-  auto IsMain() const -> 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;
-  auto PauseFrequentCheck() -> void;
-  auto ResumeFrequentCheck() -> void;
-
-  auto ReplicationClientInfo() const -> ReplClientInfo;
-
-  auto EnsureReplicaHasCorrectMainUUID(utils::UUID const &curr_main_uuid) -> 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 &;
-
-  auto EnableWritingOnMain() -> bool;
-
-  auto SetNewMainUUID(utils::UUID const &main_uuid) -> void;
-  auto ResetMainUUID() -> void;
-  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_{};
-
-  // for replica this is main uuid of current main
-  // for "main" main this same as in CoordinatorData
-  // it is set to nullopt when replica is down
-  // TLDR; when replica is down and comes back up we reset uuid of main replica is listening to
-  // so we need to send swap uuid again
-  std::optional<utils::UUID> main_uuid_;
-
-  friend bool operator==(ReplicationInstance const &first, ReplicationInstance const &second) {
-    return first.client_ == second.client_ && first.replication_role_ == second.replication_role_;
-  }
-};
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/include/nuraft/coordinator_log_store.hpp

@@ -1,70 +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 <libnuraft/nuraft.hxx>
-
-namespace memgraph::coordination {
-
-using nuraft::buffer;
-using nuraft::int32;
-using nuraft::int64;
-using nuraft::log_entry;
-using nuraft::log_store;
-using nuraft::ptr;
-using nuraft::raft_server;
-
-class CoordinatorLogStore : public log_store {
- public:
-  CoordinatorLogStore();
-  CoordinatorLogStore(CoordinatorLogStore const &) = delete;
-  CoordinatorLogStore &operator=(CoordinatorLogStore const &) = delete;
-  CoordinatorLogStore(CoordinatorLogStore &&) = delete;
-  CoordinatorLogStore &operator=(CoordinatorLogStore &&) = delete;
-  ~CoordinatorLogStore() override;
-
-  ulong next_slot() const override;
-
-  ulong start_index() const override;
-
-  ptr<log_entry> last_entry() const override;
-
-  ulong append(ptr<log_entry> &entry) override;
-
-  void write_at(ulong index, ptr<log_entry> &entry) override;
-
-  ptr<std::vector<ptr<log_entry>>> log_entries(ulong start, ulong end) override;
-
-  ptr<log_entry> entry_at(ulong index) override;
-
-  ulong term_at(ulong index) override;
-
-  ptr<buffer> pack(ulong index, int32 cnt) override;
-
-  void apply_pack(ulong index, buffer &pack) override;
-
-  bool compact(ulong last_log_index) override;
-
-  bool flush() override;
-
- private:
-  auto FindOrDefault_(ulong index) const -> ptr<log_entry>;
-
-  std::map<ulong, ptr<log_entry>> logs_;
-  mutable std::mutex logs_lock_;
-  std::atomic<ulong> start_idx_;
-};
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/include/nuraft/coordinator_state_machine.hpp

@@ -1,76 +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 <spdlog/spdlog.h>
-#include <libnuraft/nuraft.hxx>
-
-namespace memgraph::coordination {
-
-using nuraft::async_result;
-using nuraft::buffer;
-using nuraft::buffer_serializer;
-using nuraft::cluster_config;
-using nuraft::int32;
-using nuraft::ptr;
-using nuraft::snapshot;
-using nuraft::state_machine;
-
-class CoordinatorStateMachine : public state_machine {
- public:
-  CoordinatorStateMachine() = default;
-  CoordinatorStateMachine(CoordinatorStateMachine const &) = delete;
-  CoordinatorStateMachine &operator=(CoordinatorStateMachine const &) = delete;
-  CoordinatorStateMachine(CoordinatorStateMachine &&) = delete;
-  CoordinatorStateMachine &operator=(CoordinatorStateMachine &&) = delete;
-  ~CoordinatorStateMachine() override {}
-
-  static auto EncodeRegisterReplicationInstance(const std::string &name) -> ptr<buffer>;
-
-  static auto DecodeRegisterReplicationInstance(buffer &data) -> std::string;
-
-  auto pre_commit(ulong log_idx, buffer &data) -> ptr<buffer> override;
-
-  auto commit(ulong log_idx, buffer &data) -> ptr<buffer> override;
-
-  auto commit_config(ulong log_idx, ptr<cluster_config> & /*new_conf*/) -> void override;
-
-  auto rollback(ulong log_idx, buffer &data) -> void override;
-
-  auto read_logical_snp_obj(snapshot & /*snapshot*/, void *& /*user_snp_ctx*/, ulong /*obj_id*/, ptr<buffer> &data_out,
-                            bool &is_last_obj) -> int override;
-
-  auto save_logical_snp_obj(snapshot &s, ulong &obj_id, buffer & /*data*/, bool /*is_first_obj*/, bool /*is_last_obj*/)
-      -> void override;
-
-  auto apply_snapshot(snapshot &s) -> bool override;
-
-  auto free_user_snp_ctx(void *&user_snp_ctx) -> void override;
-
-  auto last_snapshot() -> ptr<snapshot> override;
-
-  auto last_commit_index() -> ulong override;
-
-  auto create_snapshot(snapshot &s, async_result<bool>::handler_type &when_done) -> void override;
-
- private:
-  std::atomic<uint64_t> last_committed_idx_{0};
-
-  ptr<snapshot> last_snapshot_;
-
-  std::mutex last_snapshot_lock_;
-};
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/include/nuraft/coordinator_state_manager.hpp

@@ -1,66 +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 "nuraft/coordinator_log_store.hpp"
-
-#include <spdlog/spdlog.h>
-#include <libnuraft/nuraft.hxx>
-
-namespace memgraph::coordination {
-
-using nuraft::cluster_config;
-using nuraft::cs_new;
-using nuraft::srv_config;
-using nuraft::srv_state;
-using nuraft::state_mgr;
-
-class CoordinatorStateManager : public state_mgr {
- public:
-  explicit CoordinatorStateManager(int srv_id, std::string const &endpoint);
-
-  CoordinatorStateManager(CoordinatorStateManager const &) = delete;
-  CoordinatorStateManager &operator=(CoordinatorStateManager const &) = delete;
-  CoordinatorStateManager(CoordinatorStateManager &&) = delete;
-  CoordinatorStateManager &operator=(CoordinatorStateManager &&) = delete;
-
-  ~CoordinatorStateManager() override = default;
-
-  auto load_config() -> ptr<cluster_config> override;
-
-  auto save_config(cluster_config const &config) -> void override;
-
-  auto save_state(srv_state const &state) -> void override;
-
-  auto read_state() -> ptr<srv_state> override;
-
-  auto load_log_store() -> ptr<log_store> override;
-
-  auto server_id() -> int32 override;
-
-  auto system_exit(int exit_code) -> void override;
-
-  auto GetSrvConfig() const -> ptr<srv_config>;
-
- private:
-  int my_id_;
-  std::string my_endpoint_;
-  ptr<CoordinatorLogStore> cur_log_store_;
-  ptr<srv_config> my_srv_config_;
-  ptr<cluster_config> cluster_config_;
-  ptr<srv_state> saved_state_;
-};
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/raft_state.cpp

@@ -1,140 +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 "coordination/raft_state.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 {
-
-using nuraft::asio_service;
-using nuraft::cb_func;
-using nuraft::CbReturnCode;
-using nuraft::cmd_result;
-using nuraft::cs_new;
-using nuraft::ptr;
-using nuraft::raft_params;
-using nuraft::raft_server;
-using nuraft::srv_config;
-using raft_result = cmd_result<ptr<buffer>>;
-
-RaftState::RaftState(BecomeLeaderCb become_leader_cb, BecomeFollowerCb become_follower_cb, uint32_t raft_server_id,
-                     uint32_t raft_port, std::string raft_address)
-    : raft_server_id_(raft_server_id),
-      raft_port_(raft_port),
-      raft_address_(std::move(raft_address)),
-      state_machine_(cs_new<CoordinatorStateMachine>()),
-      state_manager_(
-          cs_new<CoordinatorStateManager>(raft_server_id_, raft_address_ + ":" + std::to_string(raft_port_))),
-      logger_(nullptr),
-      become_leader_cb_(std::move(become_leader_cb)),
-      become_follower_cb_(std::move(become_follower_cb)) {}
-
-auto RaftState::InitRaftServer() -> void {
-  asio_service::options asio_opts;
-  asio_opts.thread_pool_size_ = 1;  // TODO: (andi) Improve this
-
-  raft_params params;
-  params.heart_beat_interval_ = 100;
-  params.election_timeout_lower_bound_ = 200;
-  params.election_timeout_upper_bound_ = 400;
-  // 5 logs are preserved before the last snapshot
-  params.reserved_log_items_ = 5;
-  // Create snapshot for every 5 log appends
-  params.snapshot_distance_ = 5;
-  params.client_req_timeout_ = 3000;
-  params.return_method_ = raft_params::blocking;
-
-  raft_server::init_options init_opts;
-  init_opts.raft_callback_ = [this](cb_func::Type event_type, cb_func::Param *param) -> nuraft::CbReturnCode {
-    if (event_type == cb_func::BecomeLeader) {
-      spdlog::info("Node {} became leader", param->leaderId);
-      become_leader_cb_();
-    } else if (event_type == cb_func::BecomeFollower) {
-      spdlog::info("Node {} became follower", param->myId);
-      become_follower_cb_();
-    }
-    return CbReturnCode::Ok;
-  };
-
-  raft_launcher launcher;
-
-  raft_server_ = launcher.init(state_machine_, state_manager_, logger_, static_cast<int>(raft_port_), asio_opts, params,
-                               init_opts);
-
-  if (!raft_server_) {
-    throw RaftServerStartException("Failed to launch raft server on {}:{}", raft_address_, raft_port_);
-  }
-
-  auto maybe_stop = utils::ResettableCounter<20>();
-  do {
-    if (raft_server_->is_initialized()) {
-      return;
-    }
-    std::this_thread::sleep_for(std::chrono::milliseconds(250));
-  } while (!maybe_stop());
-
-  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{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;
-}
-
-RaftState::~RaftState() { launcher_.shutdown(); }
-
-auto RaftState::InstanceName() const -> std::string { return "coordinator_" + std::to_string(raft_server_id_); }
-
-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 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);
-  }
-  spdlog::info("Request to add server {} to the cluster accepted", endpoint);
-}
-
-auto RaftState::GetAllCoordinators() const -> std::vector<ptr<srv_config>> {
-  std::vector<ptr<srv_config>> all_srv_configs;
-  raft_server_->get_srv_config_all(all_srv_configs);
-  return all_srv_configs;
-}
-
-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::AppendRegisterReplicationInstance(std::string const &instance) -> ptr<raft_result> {
-  auto new_log = CoordinatorStateMachine::EncodeRegisterReplicationInstance(instance);
-  return raft_server_->append_entries({new_log});
-}
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/replication_instance.cpp

@@ -1,138 +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 "coordination/replication_instance.hpp"
-
-#include "replication_coordination_glue/handler.hpp"
-#include "utils/result.hpp"
-
-namespace memgraph::coordination {
-
-ReplicationInstance::ReplicationInstance(CoordinatorInstance *peer, CoordinatorClientConfig config,
-                                         HealthCheckCallback succ_cb, HealthCheckCallback fail_cb)
-    : client_(peer, std::move(config), std::move(succ_cb), std::move(fail_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();
-  is_alive_ = true;
-}
-
-auto ReplicationInstance::OnFailPing() -> bool {
-  auto elapsed_time = std::chrono::system_clock::now() - last_response_time_;
-  is_alive_ = elapsed_time < client_.InstanceDownTimeoutSec();
-  return is_alive_;
-}
-
-auto ReplicationInstance::IsReadyForUUIDPing() -> bool {
-  return std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - last_check_of_uuid_) >
-         client_.InstanceGetUUIDFrequencySec();
-}
-
-auto ReplicationInstance::InstanceName() const -> std::string { return client_.InstanceName(); }
-auto ReplicationInstance::SocketAddress() const -> std::string { return client_.SocketAddress(); }
-auto ReplicationInstance::IsAlive() const -> bool { return is_alive_; }
-
-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;
-  client_.SetCallbacks(std::move(main_succ_cb), std::move(main_fail_cb));
-
-  return true;
-}
-
-auto ReplicationInstance::DemoteToReplica(HealthCheckCallback replica_succ_cb, HealthCheckCallback replica_fail_cb)
-    -> bool {
-  if (!client_.DemoteToReplica()) {
-    return false;
-  }
-
-  replication_role_ = replication_coordination_glue::ReplicationRole::REPLICA;
-  client_.SetCallbacks(std::move(replica_succ_cb), std::move(replica_fail_cb));
-
-  return true;
-}
-
-auto ReplicationInstance::StartFrequentCheck() -> void { client_.StartFrequentCheck(); }
-auto ReplicationInstance::StopFrequentCheck() -> void { client_.StopFrequentCheck(); }
-auto ReplicationInstance::PauseFrequentCheck() -> void { client_.PauseFrequentCheck(); }
-auto ReplicationInstance::ResumeFrequentCheck() -> void { client_.ResumeFrequentCheck(); }
-
-auto ReplicationInstance::ReplicationClientInfo() const -> CoordinatorClientConfig::ReplicationClientInfo {
-  return client_.ReplicationClientInfo();
-}
-
-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 {
-  if (!IsReadyForUUIDPing()) {
-    return true;
-  }
-  auto res = SendGetInstanceUUID();
-  if (res.HasError()) {
-    return false;
-  }
-  UpdateReplicaLastResponseUUID();
-
-  if (res.GetValue().has_value() && res.GetValue().value() == curr_main_uuid) {
-    return true;
-  }
-
-  return SendSwapAndUpdateUUID(curr_main_uuid);
-}
-
-auto ReplicationInstance::SendSwapAndUpdateUUID(const utils::UUID &new_main_uuid) -> bool {
-  if (!replication_coordination_glue::SendSwapMainUUIDRpc(client_.RpcClient(), new_main_uuid)) {
-    return false;
-  }
-  SetNewMainUUID(new_main_uuid);
-  return true;
-}
-
-auto ReplicationInstance::SendUnregisterReplicaRpc(std::string const &instance_name) -> bool {
-  return client_.SendUnregisterReplicaRpc(instance_name);
-}
-
-auto ReplicationInstance::EnableWritingOnMain() -> bool { return client_.SendEnableWritingOnMainRpc(); }
-
-auto ReplicationInstance::SendGetInstanceUUID()
-    -> utils::BasicResult<coordination::GetInstanceUUIDError, std::optional<utils::UUID>> {
-  return client_.SendGetInstanceUUIDRpc();
-}
-
-void ReplicationInstance::UpdateReplicaLastResponseUUID() { last_check_of_uuid_ = std::chrono::system_clock::now(); }
-
-}  // namespace memgraph::coordination
-#endif

src/dbms/constants.hpp

@@ -16,4 +16,10 @@ namespace memgraph::dbms {
 constexpr std::string_view kDefaultDB = "memgraph";        //!< Name of the default database
 constexpr std::string_view kMultiTenantDir = "databases";  //!< Name of the multi-tenant directory
 
+#ifdef MG_EXPERIMENTAL_REPLICATION_MULTITENANCY
+constexpr bool allow_mt_repl = true;
+#else
+constexpr bool allow_mt_repl = false;
+#endif
+
 }  // namespace memgraph::dbms

src/dbms/coordinator_handler.cpp

@@ -9,41 +9,31 @@
 // by the Apache License, Version 2.0, included in the file
 // licenses/APL.txt.
 
+#include "coordination/register_main_replica_coordinator_status.hpp"
 #ifdef MG_ENTERPRISE
 
 #include "dbms/coordinator_handler.hpp"
 
-#include "coordination/register_main_replica_coordinator_status.hpp"
+#include "dbms/dbms_handler.hpp"
 
 namespace memgraph::dbms {
 
 CoordinatorHandler::CoordinatorHandler(coordination::CoordinatorState &coordinator_state)
     : coordinator_state_(coordinator_state) {}
 
-auto CoordinatorHandler::RegisterReplicationInstance(memgraph::coordination::CoordinatorClientConfig config)
+auto CoordinatorHandler::RegisterInstance(memgraph::coordination::CoordinatorClientConfig config)
     -> coordination::RegisterInstanceCoordinatorStatus {
-  return coordinator_state_.RegisterReplicationInstance(config);
+  return coordinator_state_.RegisterInstance(config);
 }
 
-auto CoordinatorHandler::UnregisterReplicationInstance(std::string instance_name)
-    -> coordination::UnregisterInstanceCoordinatorStatus {
-  return coordinator_state_.UnregisterReplicationInstance(std::move(instance_name));
-}
-
-auto CoordinatorHandler::SetReplicationInstanceToMain(std::string instance_name)
+auto CoordinatorHandler::SetInstanceToMain(std::string instance_name)
     -> coordination::SetInstanceToMainCoordinatorStatus {
-  return coordinator_state_.SetReplicationInstanceToMain(std::move(instance_name));
+  return coordinator_state_.SetInstanceToMain(std::move(instance_name));
 }
 
-auto CoordinatorHandler::ShowInstances() const -> std::vector<coordination::InstanceStatus> {
+auto CoordinatorHandler::ShowInstances() const -> std::vector<coordination::CoordinatorInstanceStatus> {
   return coordinator_state_.ShowInstances();
 }
-
-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
 
 #endif

src/dbms/coordinator_handler.hpp

@@ -14,8 +14,8 @@
 #ifdef MG_ENTERPRISE
 
 #include "coordination/coordinator_config.hpp"
+#include "coordination/coordinator_instance_status.hpp"
 #include "coordination/coordinator_state.hpp"
-#include "coordination/instance_status.hpp"
 #include "coordination/register_main_replica_coordinator_status.hpp"
 
 #include <vector>
@@ -28,18 +28,12 @@ class CoordinatorHandler {
  public:
   explicit CoordinatorHandler(coordination::CoordinatorState &coordinator_state);
 
-  // TODO: (andi) When moving coordinator state on same instances, rename from RegisterReplicationInstance to
-  // RegisterInstance
-  auto RegisterReplicationInstance(coordination::CoordinatorClientConfig config)
+  auto RegisterInstance(coordination::CoordinatorClientConfig config)
       -> coordination::RegisterInstanceCoordinatorStatus;
 
-  auto UnregisterReplicationInstance(std::string instance_name) -> coordination::UnregisterInstanceCoordinatorStatus;
+  auto SetInstanceToMain(std::string 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 raft_address) -> void;
+  auto ShowInstances() const -> std::vector<coordination::CoordinatorInstanceStatus>;
 
  private:
   coordination::CoordinatorState &coordinator_state_;

src/dbms/dbms_handler.cpp

@@ -16,7 +16,6 @@
 
 #include "dbms/constants.hpp"
 #include "dbms/global.hpp"
-#include "flags/experimental.hpp"
 #include "spdlog/spdlog.h"
 #include "system/include/system/system.hpp"
 #include "utils/exceptions.hpp"
@@ -39,8 +38,6 @@ std::string RegisterReplicaErrorToString(query::RegisterReplicaError error) {
       return "CONNECTION_FAILED";
     case COULD_NOT_BE_PERSISTED:
       return "COULD_NOT_BE_PERSISTED";
-    case ERROR_ACCEPTING_MAIN:
-      return "ERROR_ACCEPTING_MAIN";
   }
 }
 
@@ -55,7 +52,7 @@ void RestoreReplication(replication::RoleMainData &mainData, DatabaseAccess db_a
     spdlog::info("Replica {} restoration started for {}.", instance_client.name_, db_acc->name());
     const auto &ret = db_acc->storage()->repl_storage_state_.replication_clients_.WithLock(
         [&, db_acc](auto &storage_clients) mutable -> utils::BasicResult<query::RegisterReplicaError> {
-          auto client = std::make_unique<storage::ReplicationStorageClient>(instance_client, mainData.uuid_);
+          auto client = std::make_unique<storage::ReplicationStorageClient>(instance_client);
           auto *storage = db_acc->storage();
           client->Start(storage, std::move(db_acc));
           // After start the storage <-> replica state should be READY or RECOVERING (if correctly started)
@@ -159,9 +156,9 @@ struct Durability {
   }
 };
 
-DbmsHandler::DbmsHandler(storage::Config config, replication::ReplicationState &repl_state, auth::SynchedAuth &auth,
-                         bool recovery_on_startup)
-    : default_config_{std::move(config)}, auth_{auth}, repl_state_{repl_state} {
+DbmsHandler::DbmsHandler(storage::Config config, memgraph::system::System &system,
+                         replication::ReplicationState &repl_state, auth::SynchedAuth &auth, bool recovery_on_startup)
+    : default_config_{std::move(config)}, auth_{auth}, repl_state_{repl_state}, system_{&system} {
   // TODO: Decouple storage config from dbms config
   // TODO: Save individual db configs inside the kvstore and restore from there
 
@@ -242,16 +239,14 @@ struct DropDatabase : memgraph::system::ISystemAction {
   void DoDurability() override { /* Done during DBMS execution */
   }
 
-  bool DoReplication(replication::ReplicationClient &client, const utils::UUID &main_uuid,
-                     replication::ReplicationEpoch const &epoch,
+  bool DoReplication(replication::ReplicationClient &client, replication::ReplicationEpoch const &epoch,
                      memgraph::system::Transaction const &txn) const override {
     auto check_response = [](const storage::replication::DropDatabaseRes &response) {
       return response.result != storage::replication::DropDatabaseRes::Result::FAILURE;
     };
 
     return client.SteamAndFinalizeDelta<storage::replication::DropDatabaseRpc>(
-        check_response, main_uuid, std::string(epoch.id()), txn.last_committed_system_timestamp(), txn.timestamp(),
-        uuid_);
+        check_response, epoch.id(), txn.last_committed_system_timestamp(), txn.timestamp(), uuid_);
   }
   void PostReplication(replication::RoleMainData &mainData) const override {}
 
@@ -328,16 +323,14 @@ struct CreateDatabase : memgraph::system::ISystemAction {
     // Done during dbms execution
   }
 
-  bool DoReplication(replication::ReplicationClient &client, const utils::UUID &main_uuid,
-                     replication::ReplicationEpoch const &epoch,
+  bool DoReplication(replication::ReplicationClient &client, replication::ReplicationEpoch const &epoch,
                      memgraph::system::Transaction const &txn) const override {
     auto check_response = [](const storage::replication::CreateDatabaseRes &response) {
       return response.result != storage::replication::CreateDatabaseRes::Result::FAILURE;
     };
 
     return client.SteamAndFinalizeDelta<storage::replication::CreateDatabaseRpc>(
-        check_response, main_uuid, std::string(epoch.id()), txn.last_committed_system_timestamp(), txn.timestamp(),
-        config_);
+        check_response, epoch.id(), txn.last_committed_system_timestamp(), txn.timestamp(), config_);
   }
 
   void PostReplication(replication::RoleMainData &mainData) const override {
@@ -420,10 +413,7 @@ void DbmsHandler::UpdateDurability(const storage::Config &config, std::optional<
 #endif
 
 void DbmsHandler::RecoverStorageReplication(DatabaseAccess db_acc, replication::RoleMainData &role_main_data) {
-  using enum memgraph::flags::Experiments;
-  auto const is_enterprise = license::global_license_checker.IsEnterpriseValidFast();
-  auto experimental_system_replication = flags::AreExperimentsEnabled(SYSTEM_REPLICATION);
-  if ((is_enterprise && experimental_system_replication) || db_acc->name() == dbms::kDefaultDB) {
+  if (allow_mt_repl || db_acc->name() == dbms::kDefaultDB) {
     // Handle global replication state
     spdlog::info("Replication configuration will be stored and will be automatically restored in case of a crash.");
     // RECOVER REPLICA CONNECTIONS

src/dbms/dbms_handler.hpp

@@ -29,7 +29,6 @@
 #include "kvstore/kvstore.hpp"
 #include "license/license.hpp"
 #include "replication/replication_client.hpp"
-#include "replication_coordination_glue/handler.hpp"
 #include "storage/v2/config.hpp"
 #include "storage/v2/transaction.hpp"
 #include "system/system.hpp"
@@ -107,7 +106,8 @@ class DbmsHandler {
    * @param auth pointer to the global authenticator
    * @param recovery_on_startup restore databases (and its content) and authentication data
    */
-  DbmsHandler(storage::Config config, replication::ReplicationState &repl_state, auth::SynchedAuth &auth,
+  DbmsHandler(storage::Config config, memgraph::system::System &system, replication::ReplicationState &repl_state,
+              auth::SynchedAuth &auth,
               bool recovery_on_startup);  // TODO If more arguments are added use a config struct
 #else
   /**
@@ -115,8 +115,9 @@ class DbmsHandler {
    *
    * @param configs storage configuration
    */
-  DbmsHandler(storage::Config config, replication::ReplicationState &repl_state)
+  DbmsHandler(storage::Config config, memgraph::system::System &system, replication::ReplicationState &repl_state)
       : repl_state_{repl_state},
+        system_{&system},
         db_gatekeeper_{[&] {
                          config.salient.name = kDefaultDB;
                          return std::move(config);
@@ -260,30 +261,6 @@ class DbmsHandler {
 #endif
   }
 
-  replication::ReplicationState &ReplicationState() { return repl_state_; }
-  replication::ReplicationState const &ReplicationState() const { return repl_state_; }
-
-  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.
-   *
-   * @return std::vector<std::string>
-   */
-  auto Count() const -> std::size_t {
-#ifdef MG_ENTERPRISE
-    std::shared_lock<LockT> rd(lock_);
-    return db_handler_.size();
-#else
-    return 1;
-#endif
-  }
-
   /**
    * @brief Return the statistics all databases.
    *
@@ -599,6 +576,9 @@ class DbmsHandler {
   //       current replication role. TODO: make Database Access explicit about the role and remove this from
   //       dbms stuff
   replication::ReplicationState &repl_state_;  //!< Ref to global replication state
+ public:
+  // TODO fix to be non public/remove from dbms....maybe
+  system::System *system_;
 
 #ifndef MG_ENTERPRISE
   mutable utils::Gatekeeper<Database> db_gatekeeper_;  //!< Single databases gatekeeper

src/dbms/handler.hpp

@@ -144,8 +144,6 @@ class Handler {
   auto cbegin() const { return items_.cbegin(); }
   auto cend() const { return items_.cend(); }
 
-  auto size() const { return items_.size(); }
-
   struct string_hash {
     using is_transparent = void;
     [[nodiscard]] size_t operator()(const char *s) const { return std::hash<std::string_view>{}(s); }

src/dbms/inmemory/replication_handlers.cpp

@@ -76,110 +76,58 @@ std::optional<DatabaseAccess> GetDatabaseAccessor(dbms::DbmsHandler *dbms_handle
     return std::nullopt;
   }
 }
-
-void LogWrongMain(const std::optional<utils::UUID> &current_main_uuid, const utils::UUID &main_req_id,
-                  std::string_view rpc_req) {
-  spdlog::error("Received {} with main_id: {} != current_main_uuid: {}", rpc_req, std::string(main_req_id),
-                current_main_uuid.has_value() ? std::string(current_main_uuid.value()) : "");
-}
 }  // namespace
 
-void InMemoryReplicationHandlers::Register(dbms::DbmsHandler *dbms_handler, replication::RoleReplicaData &data) {
-  auto &server = *data.server;
-  server.rpc_server_.Register<storage::replication::HeartbeatRpc>(
-      [&data, dbms_handler](auto *req_reader, auto *res_builder) {
-        spdlog::debug("Received HeartbeatRpc");
-        InMemoryReplicationHandlers::HeartbeatHandler(dbms_handler, data.uuid_, req_reader, res_builder);
-      });
+void InMemoryReplicationHandlers::Register(dbms::DbmsHandler *dbms_handler, replication::ReplicationServer &server) {
+  server.rpc_server_.Register<storage::replication::HeartbeatRpc>([dbms_handler](auto *req_reader, auto *res_builder) {
+    spdlog::debug("Received HeartbeatRpc");
+    InMemoryReplicationHandlers::HeartbeatHandler(dbms_handler, req_reader, res_builder);
+  });
   server.rpc_server_.Register<storage::replication::AppendDeltasRpc>(
-      [&data, dbms_handler](auto *req_reader, auto *res_builder) {
+      [dbms_handler](auto *req_reader, auto *res_builder) {
         spdlog::debug("Received AppendDeltasRpc");
-        InMemoryReplicationHandlers::AppendDeltasHandler(dbms_handler, data.uuid_, req_reader, res_builder);
-      });
-  server.rpc_server_.Register<storage::replication::SnapshotRpc>(
-      [&data, dbms_handler](auto *req_reader, auto *res_builder) {
-        spdlog::debug("Received SnapshotRpc");
-        InMemoryReplicationHandlers::SnapshotHandler(dbms_handler, data.uuid_, req_reader, res_builder);
-      });
-  server.rpc_server_.Register<storage::replication::WalFilesRpc>(
-      [&data, dbms_handler](auto *req_reader, auto *res_builder) {
-        spdlog::debug("Received WalFilesRpc");
-        InMemoryReplicationHandlers::WalFilesHandler(dbms_handler, data.uuid_, req_reader, res_builder);
-      });
-  server.rpc_server_.Register<storage::replication::CurrentWalRpc>(
-      [&data, dbms_handler](auto *req_reader, auto *res_builder) {
-        spdlog::debug("Received CurrentWalRpc");
-        InMemoryReplicationHandlers::CurrentWalHandler(dbms_handler, data.uuid_, req_reader, res_builder);
-      });
-  server.rpc_server_.Register<storage::replication::TimestampRpc>(
-      [&data, dbms_handler](auto *req_reader, auto *res_builder) {
-        spdlog::debug("Received TimestampRpc");
-        InMemoryReplicationHandlers::TimestampHandler(dbms_handler, data.uuid_, req_reader, res_builder);
-      });
-  server.rpc_server_.Register<replication_coordination_glue::SwapMainUUIDRpc>(
-      [&data, dbms_handler](auto *req_reader, auto *res_builder) {
-        spdlog::debug("Received SwapMainUUIDHandler");
-        InMemoryReplicationHandlers::SwapMainUUIDHandler(dbms_handler, data, req_reader, res_builder);
+        InMemoryReplicationHandlers::AppendDeltasHandler(dbms_handler, req_reader, res_builder);
       });
+  server.rpc_server_.Register<storage::replication::SnapshotRpc>([dbms_handler](auto *req_reader, auto *res_builder) {
+    spdlog::debug("Received SnapshotRpc");
+    InMemoryReplicationHandlers::SnapshotHandler(dbms_handler, req_reader, res_builder);
+  });
+  server.rpc_server_.Register<storage::replication::WalFilesRpc>([dbms_handler](auto *req_reader, auto *res_builder) {
+    spdlog::debug("Received WalFilesRpc");
+    InMemoryReplicationHandlers::WalFilesHandler(dbms_handler, req_reader, res_builder);
+  });
+  server.rpc_server_.Register<storage::replication::CurrentWalRpc>([dbms_handler](auto *req_reader, auto *res_builder) {
+    spdlog::debug("Received CurrentWalRpc");
+    InMemoryReplicationHandlers::CurrentWalHandler(dbms_handler, req_reader, res_builder);
+  });
+  server.rpc_server_.Register<storage::replication::TimestampRpc>([dbms_handler](auto *req_reader, auto *res_builder) {
+    spdlog::debug("Received TimestampRpc");
+    InMemoryReplicationHandlers::TimestampHandler(dbms_handler, req_reader, res_builder);
+  });
 }
 
-void InMemoryReplicationHandlers::SwapMainUUIDHandler(dbms::DbmsHandler *dbms_handler,
-                                                      replication::RoleReplicaData &role_replica_data,
-                                                      slk::Reader *req_reader, slk::Builder *res_builder) {
-  if (!dbms_handler->IsReplica()) {
-    spdlog::error("Setting main uuid must be performed on replica.");
-    slk::Save(replication_coordination_glue::SwapMainUUIDRes{false}, res_builder);
-    return;
-  }
-
-  replication_coordination_glue::SwapMainUUIDReq req;
-  slk::Load(&req, req_reader);
-  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;
-
-  slk::Save(replication_coordination_glue::SwapMainUUIDRes{true}, res_builder);
-}
-
-void InMemoryReplicationHandlers::HeartbeatHandler(dbms::DbmsHandler *dbms_handler,
-                                                   const std::optional<utils::UUID> &current_main_uuid,
-                                                   slk::Reader *req_reader, slk::Builder *res_builder) {
+void InMemoryReplicationHandlers::HeartbeatHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader,
+                                                   slk::Builder *res_builder) {
   storage::replication::HeartbeatReq req;
   slk::Load(&req, req_reader);
   auto const db_acc = GetDatabaseAccessor(dbms_handler, req.uuid);
+  if (!db_acc) {
+    storage::replication::HeartbeatRes res{false, 0, ""};
+    slk::Save(res, res_builder);
+    return;
+  }
 
-  if (!current_main_uuid.has_value() || req.main_uuid != *current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, storage::replication::HeartbeatReq::kType.name);
-    storage::replication::HeartbeatRes res{false, 0, ""};
-    slk::Save(res, res_builder);
-    return;
-  }
   // TODO: this handler is agnostic of InMemory, move to be reused by on-disk
-  if (!db_acc.has_value()) {
-    spdlog::warn("No database accessor");
-    storage::replication::HeartbeatRes res{false, 0, ""};
-    slk::Save(res, res_builder);
-    return;
-  }
   auto const *storage = db_acc->get()->storage();
   storage::replication::HeartbeatRes res{true, storage->repl_storage_state_.last_commit_timestamp_.load(),
                                          std::string{storage->repl_storage_state_.epoch_.id()}};
   slk::Save(res, res_builder);
 }
 
-void InMemoryReplicationHandlers::AppendDeltasHandler(dbms::DbmsHandler *dbms_handler,
-                                                      const std::optional<utils::UUID> &current_main_uuid,
-                                                      slk::Reader *req_reader, slk::Builder *res_builder) {
+void InMemoryReplicationHandlers::AppendDeltasHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader,
+                                                      slk::Builder *res_builder) {
   storage::replication::AppendDeltasReq req;
   slk::Load(&req, req_reader);
-
-  if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, storage::replication::AppendDeltasReq::kType.name);
-    storage::replication::AppendDeltasRes res{false, 0};
-    slk::Save(res, res_builder);
-    return;
-  }
-
   auto db_acc = GetDatabaseAccessor(dbms_handler, req.uuid);
   if (!db_acc) {
     storage::replication::AppendDeltasRes res{false, 0};
@@ -239,9 +187,8 @@ void InMemoryReplicationHandlers::AppendDeltasHandler(dbms::DbmsHandler *dbms_ha
   spdlog::debug("Replication recovery from append deltas finished, replica is now up to date!");
 }
 
-void InMemoryReplicationHandlers::SnapshotHandler(dbms::DbmsHandler *dbms_handler,
-                                                  const std::optional<utils::UUID> &current_main_uuid,
-                                                  slk::Reader *req_reader, slk::Builder *res_builder) {
+void InMemoryReplicationHandlers::SnapshotHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader,
+                                                  slk::Builder *res_builder) {
   storage::replication::SnapshotReq req;
   slk::Load(&req, req_reader);
   auto db_acc = GetDatabaseAccessor(dbms_handler, req.uuid);
@@ -250,12 +197,6 @@ void InMemoryReplicationHandlers::SnapshotHandler(dbms::DbmsHandler *dbms_handle
     slk::Save(res, res_builder);
     return;
   }
-  if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, storage::replication::SnapshotReq::kType.name);
-    storage::replication::SnapshotRes res{false, 0};
-    slk::Save(res, res_builder);
-    return;
-  }
 
   storage::replication::Decoder decoder(req_reader);
 
@@ -329,9 +270,8 @@ void InMemoryReplicationHandlers::SnapshotHandler(dbms::DbmsHandler *dbms_handle
   spdlog::debug("Replication recovery from snapshot finished!");
 }
 
-void InMemoryReplicationHandlers::WalFilesHandler(dbms::DbmsHandler *dbms_handler,
-                                                  const std::optional<utils::UUID> &current_main_uuid,
-                                                  slk::Reader *req_reader, slk::Builder *res_builder) {
+void InMemoryReplicationHandlers::WalFilesHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader,
+                                                  slk::Builder *res_builder) {
   storage::replication::WalFilesReq req;
   slk::Load(&req, req_reader);
   auto db_acc = GetDatabaseAccessor(dbms_handler, req.uuid);
@@ -340,12 +280,6 @@ void InMemoryReplicationHandlers::WalFilesHandler(dbms::DbmsHandler *dbms_handle
     slk::Save(res, res_builder);
     return;
   }
-  if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, storage::replication::WalFilesReq::kType.name);
-    storage::replication::WalFilesRes res{false, 0};
-    slk::Save(res, res_builder);
-    return;
-  }
 
   const auto wal_file_number = req.file_number;
   spdlog::debug("Received WAL files: {}", wal_file_number);
@@ -364,9 +298,8 @@ void InMemoryReplicationHandlers::WalFilesHandler(dbms::DbmsHandler *dbms_handle
   spdlog::debug("Replication recovery from WAL files ended successfully, replica is now up to date!");
 }
 
-void InMemoryReplicationHandlers::CurrentWalHandler(dbms::DbmsHandler *dbms_handler,
-                                                    const std::optional<utils::UUID> &current_main_uuid,
-                                                    slk::Reader *req_reader, slk::Builder *res_builder) {
+void InMemoryReplicationHandlers::CurrentWalHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader,
+                                                    slk::Builder *res_builder) {
   storage::replication::CurrentWalReq req;
   slk::Load(&req, req_reader);
   auto db_acc = GetDatabaseAccessor(dbms_handler, req.uuid);
@@ -376,13 +309,6 @@ void InMemoryReplicationHandlers::CurrentWalHandler(dbms::DbmsHandler *dbms_hand
     return;
   }
 
-  if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, storage::replication::CurrentWalReq::kType.name);
-    storage::replication::CurrentWalRes res{false, 0};
-    slk::Save(res, res_builder);
-    return;
-  }
-
   storage::replication::Decoder decoder(req_reader);
 
   auto *storage = static_cast<storage::InMemoryStorage *>(db_acc->get()->storage());
@@ -444,9 +370,8 @@ void InMemoryReplicationHandlers::LoadWal(storage::InMemoryStorage *storage, sto
   }
 }
 
-void InMemoryReplicationHandlers::TimestampHandler(dbms::DbmsHandler *dbms_handler,
-                                                   const std::optional<utils::UUID> &current_main_uuid,
-                                                   slk::Reader *req_reader, slk::Builder *res_builder) {
+void InMemoryReplicationHandlers::TimestampHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader,
+                                                   slk::Builder *res_builder) {
   storage::replication::TimestampReq req;
   slk::Load(&req, req_reader);
   auto const db_acc = GetDatabaseAccessor(dbms_handler, req.uuid);
@@ -456,13 +381,6 @@ void InMemoryReplicationHandlers::TimestampHandler(dbms::DbmsHandler *dbms_handl
     return;
   }
 
-  if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, storage::replication::TimestampReq::kType.name);
-    storage::replication::CurrentWalRes res{false, 0};
-    slk::Save(res, res_builder);
-    return;
-  }
-
   // TODO: this handler is agnostic of InMemory, move to be reused by on-disk
   auto const *storage = db_acc->get()->storage();
   storage::replication::TimestampRes res{true, storage->repl_storage_state_.last_commit_timestamp_.load()};

src/dbms/inmemory/replication_handlers.hpp

@@ -12,7 +12,6 @@
 #pragma once
 
 #include "replication/replication_server.hpp"
-#include "replication/state.hpp"
 #include "storage/v2/replication/serialization.hpp"
 
 namespace memgraph::storage {
@@ -24,30 +23,21 @@ class DbmsHandler;
 
 class InMemoryReplicationHandlers {
  public:
-  static void Register(dbms::DbmsHandler *dbms_handler, replication::RoleReplicaData &data);
+  static void Register(dbms::DbmsHandler *dbms_handler, replication::ReplicationServer &server);
 
  private:
   // RPC handlers
-  static void HeartbeatHandler(dbms::DbmsHandler *dbms_handler, const std::optional<utils::UUID> &current_main_uuid,
-                               slk::Reader *req_reader, slk::Builder *res_builder);
+  static void HeartbeatHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder);
 
-  static void AppendDeltasHandler(dbms::DbmsHandler *dbms_handler, const std::optional<utils::UUID> &current_main_uuid,
-                                  slk::Reader *req_reader, slk::Builder *res_builder);
+  static void AppendDeltasHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder);
 
-  static void SnapshotHandler(dbms::DbmsHandler *dbms_handler, const std::optional<utils::UUID> &current_main_uuid,
-                              slk::Reader *req_reader, slk::Builder *res_builder);
+  static void SnapshotHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder);
 
-  static void WalFilesHandler(dbms::DbmsHandler *dbms_handler, const std::optional<utils::UUID> &current_main_uuid,
-                              slk::Reader *req_reader, slk::Builder *res_builder);
+  static void WalFilesHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder);
 
-  static void CurrentWalHandler(dbms::DbmsHandler *dbms_handler, const std::optional<utils::UUID> &current_main_uuid,
-                                slk::Reader *req_reader, slk::Builder *res_builder);
+  static void CurrentWalHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder);
 
-  static void TimestampHandler(dbms::DbmsHandler *dbms_handler, const std::optional<utils::UUID> &current_main_uuid,
-                               slk::Reader *req_reader, slk::Builder *res_builder);
-
-  static void SwapMainUUIDHandler(dbms::DbmsHandler *dbms_handler, replication::RoleReplicaData &role_replica_data,
-                                  slk::Reader *req_reader, slk::Builder *res_builder);
+  static void TimestampHandler(dbms::DbmsHandler *dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder);
 
   static void LoadWal(storage::InMemoryStorage *storage, storage::replication::Decoder *decoder);
 

src/dbms/replication_handlers.cpp

@@ -21,8 +21,7 @@ namespace memgraph::dbms {
 #ifdef MG_ENTERPRISE
 
 void CreateDatabaseHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access,
-                           const std::optional<utils::UUID> &current_main_uuid, DbmsHandler &dbms_handler,
-                           slk::Reader *req_reader, slk::Builder *res_builder) {
+                           DbmsHandler &dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder) {
   using memgraph::storage::replication::CreateDatabaseRes;
   CreateDatabaseRes res(CreateDatabaseRes::Result::FAILURE);
 
@@ -36,12 +35,6 @@ void CreateDatabaseHandler(memgraph::system::ReplicaHandlerAccessToState &system
   memgraph::storage::replication::CreateDatabaseReq req;
   memgraph::slk::Load(&req, req_reader);
 
-  if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, memgraph::storage::replication::CreateDatabaseReq::kType.name);
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
   // Note: No need to check epoch, recovery mechanism is done by a full uptodate snapshot
   //       of the set of databases. Hence no history exists to maintain regarding epoch change.
   //       If MAIN has changed we need to check this new group_timestamp is consistent with
@@ -70,8 +63,7 @@ void CreateDatabaseHandler(memgraph::system::ReplicaHandlerAccessToState &system
   memgraph::slk::Save(res, res_builder);
 }
 
-void DropDatabaseHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access,
-                         const std::optional<utils::UUID> &current_main_uuid, DbmsHandler &dbms_handler,
+void DropDatabaseHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access, DbmsHandler &dbms_handler,
                          slk::Reader *req_reader, slk::Builder *res_builder) {
   using memgraph::storage::replication::DropDatabaseRes;
   DropDatabaseRes res(DropDatabaseRes::Result::FAILURE);
@@ -86,12 +78,6 @@ void DropDatabaseHandler(memgraph::system::ReplicaHandlerAccessToState &system_s
   memgraph::storage::replication::DropDatabaseReq req;
   memgraph::slk::Load(&req, req_reader);
 
-  if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, memgraph::storage::replication::DropDatabaseReq::kType.name);
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
   // Note: No need to check epoch, recovery mechanism is done by a full uptodate snapshot
   //       of the set of databases. Hence no history exists to maintain regarding epoch change.
   //       If MAIN has changed we need to check this new group_timestamp is consistent with
@@ -191,14 +177,14 @@ void Register(replication::RoleReplicaData const &data, system::ReplicaHandlerAc
               dbms::DbmsHandler &dbms_handler) {
   // NOTE: Register even without license as the user could add a license at run-time
   data.server->rpc_server_.Register<storage::replication::CreateDatabaseRpc>(
-      [&data, system_state_access, &dbms_handler](auto *req_reader, auto *res_builder) mutable {
+      [system_state_access, &dbms_handler](auto *req_reader, auto *res_builder) mutable {
         spdlog::debug("Received CreateDatabaseRpc");
-        CreateDatabaseHandler(system_state_access, data.uuid_, dbms_handler, req_reader, res_builder);
+        CreateDatabaseHandler(system_state_access, dbms_handler, req_reader, res_builder);
       });
   data.server->rpc_server_.Register<storage::replication::DropDatabaseRpc>(
-      [&data, system_state_access, &dbms_handler](auto *req_reader, auto *res_builder) mutable {
+      [system_state_access, &dbms_handler](auto *req_reader, auto *res_builder) mutable {
         spdlog::debug("Received DropDatabaseRpc");
-        DropDatabaseHandler(system_state_access, data.uuid_, dbms_handler, req_reader, res_builder);
+        DropDatabaseHandler(system_state_access, dbms_handler, req_reader, res_builder);
       });
 }
 #endif

src/dbms/replication_handlers.hpp

@@ -17,21 +17,11 @@
 #include "system/state.hpp"
 
 namespace memgraph::dbms {
-
 #ifdef MG_ENTERPRISE
-
-inline void LogWrongMain(const std::optional<utils::UUID> &current_main_uuid, const utils::UUID &main_req_id,
-                         std::string_view rpc_req) {
-  spdlog::error("Received {} with main_id: {} != current_main_uuid: {}", rpc_req, std::string(main_req_id),
-                current_main_uuid.has_value() ? std::string(current_main_uuid.value()) : "");
-}
-
 // RPC handlers
 void CreateDatabaseHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access,
-                           const std::optional<utils::UUID> &current_main_uuid, DbmsHandler &dbms_handler,
-                           slk::Reader *req_reader, slk::Builder *res_builder);
-void DropDatabaseHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access,
-                         const std::optional<utils::UUID> &current_main_uuid, DbmsHandler &dbms_handler,
+                           DbmsHandler &dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder);
+void DropDatabaseHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access, DbmsHandler &dbms_handler,
                          slk::Reader *req_reader, slk::Builder *res_builder);
 bool SystemRecoveryHandler(DbmsHandler &dbms_handler, const std::vector<storage::SalientConfig> &database_configs);
 

src/dbms/rpc.cpp

@@ -57,7 +57,6 @@ namespace slk {
 // Serialize code for CreateDatabaseReq
 
 void Save(const memgraph::storage::replication::CreateDatabaseReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.main_uuid, builder);
   memgraph::slk::Save(self.epoch_id, builder);
   memgraph::slk::Save(self.expected_group_timestamp, builder);
   memgraph::slk::Save(self.new_group_timestamp, builder);
@@ -65,7 +64,6 @@ void Save(const memgraph::storage::replication::CreateDatabaseReq &self, memgrap
 }
 
 void Load(memgraph::storage::replication::CreateDatabaseReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->main_uuid, reader);
   memgraph::slk::Load(&self->epoch_id, reader);
   memgraph::slk::Load(&self->expected_group_timestamp, reader);
   memgraph::slk::Load(&self->new_group_timestamp, reader);
@@ -89,7 +87,6 @@ void Load(memgraph::storage::replication::CreateDatabaseRes *self, memgraph::slk
 // Serialize code for DropDatabaseReq
 
 void Save(const memgraph::storage::replication::DropDatabaseReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.main_uuid, builder);
   memgraph::slk::Save(self.epoch_id, builder);
   memgraph::slk::Save(self.expected_group_timestamp, builder);
   memgraph::slk::Save(self.new_group_timestamp, builder);
@@ -97,7 +94,6 @@ void Save(const memgraph::storage::replication::DropDatabaseReq &self, memgraph:
 }
 
 void Load(memgraph::storage::replication::DropDatabaseReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->main_uuid, reader);
   memgraph::slk::Load(&self->epoch_id, reader);
   memgraph::slk::Load(&self->expected_group_timestamp, reader);
   memgraph::slk::Load(&self->new_group_timestamp, reader);

src/dbms/rpc.hpp

@@ -29,15 +29,13 @@ struct CreateDatabaseReq {
   static void Load(CreateDatabaseReq *self, memgraph::slk::Reader *reader);
   static void Save(const CreateDatabaseReq &self, memgraph::slk::Builder *builder);
   CreateDatabaseReq() = default;
-  CreateDatabaseReq(const utils::UUID &main_uuid, std::string epoch_id, uint64_t expected_group_timestamp,
-                    uint64_t new_group_timestamp, storage::SalientConfig config)
-      : main_uuid(main_uuid),
-        epoch_id(std::move(epoch_id)),
+  CreateDatabaseReq(std::string_view epoch_id, uint64_t expected_group_timestamp, uint64_t new_group_timestamp,
+                    storage::SalientConfig config)
+      : epoch_id(std::string(epoch_id)),
         expected_group_timestamp{expected_group_timestamp},
         new_group_timestamp(new_group_timestamp),
         config(std::move(config)) {}
 
-  utils::UUID main_uuid;
   std::string epoch_id;
   uint64_t expected_group_timestamp;
   uint64_t new_group_timestamp;
@@ -67,15 +65,13 @@ struct DropDatabaseReq {
   static void Load(DropDatabaseReq *self, memgraph::slk::Reader *reader);
   static void Save(const DropDatabaseReq &self, memgraph::slk::Builder *builder);
   DropDatabaseReq() = default;
-  DropDatabaseReq(const utils::UUID &main_uuid, std::string epoch_id, uint64_t expected_group_timestamp,
-                  uint64_t new_group_timestamp, const utils::UUID &uuid)
-      : main_uuid(main_uuid),
-        epoch_id(std::move(epoch_id)),
+  DropDatabaseReq(std::string_view epoch_id, uint64_t expected_group_timestamp, uint64_t new_group_timestamp,
+                  const utils::UUID &uuid)
+      : epoch_id(std::string(epoch_id)),
         expected_group_timestamp{expected_group_timestamp},
         new_group_timestamp(new_group_timestamp),
         uuid(uuid) {}
 
-  utils::UUID main_uuid;
   std::string epoch_id;
   uint64_t expected_group_timestamp;
   uint64_t new_group_timestamp;

src/flags/CMakeLists.txt

@@ -1,17 +1,12 @@
-add_library(mg-flags STATIC
-        audit.cpp
-        bolt.cpp
-        general.cpp
-        isolation_level.cpp
-        log_level.cpp
-        memory_limit.cpp
-        run_time_configurable.cpp
-        storage_mode.cpp
-        query.cpp
-        replication.cpp
-        experimental.cpp
-        experimental.hpp)
-target_include_directories(mg-flags PUBLIC include)
-target_link_libraries(mg-flags
-        PUBLIC spdlog::spdlog mg-settings mg-utils
-        PRIVATE lib::rangev3)
+add_library(mg-flags STATIC audit.cpp
+                            bolt.cpp
+                            general.cpp
+                            isolation_level.cpp
+                            log_level.cpp
+                            memory_limit.cpp
+                            run_time_configurable.cpp
+                            storage_mode.cpp
+                            query.cpp
+                            replication.cpp)
+target_include_directories(mg-flags PUBLIC ${CMAKE_SOURCE_DIR}/include)
+target_link_libraries(mg-flags PUBLIC spdlog::spdlog mg-settings mg-utils)

src/flags/all.hpp

@@ -12,7 +12,6 @@
 
 #include "flags/audit.hpp"
 #include "flags/bolt.hpp"
-#include "flags/experimental.hpp"
 #include "flags/general.hpp"
 #include "flags/isolation_level.hpp"
 #include "flags/log_level.hpp"

src/flags/experimental.cpp

@@ -1,67 +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 "flags/experimental.hpp"
-#include "range/v3/all.hpp"
-#include "utils/string.hpp"
-
-#include <map>
-#include <string_view>
-
-// Bolt server flags.
-// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_string(experimental_enabled, "",
-              "Experimental features to be used, comma seperated. Options [system-replication]");
-
-using namespace std::string_view_literals;
-
-namespace memgraph::flags {
-
-auto const mapping = std::map{std::pair{"system-replication"sv, Experiments::SYSTEM_REPLICATION}};
-
-auto ExperimentsInstance() -> Experiments & {
-  static auto instance = Experiments{};
-  return instance;
-}
-
-bool AreExperimentsEnabled(Experiments experiments) {
-  using t = std::underlying_type_t<Experiments>;
-
-  auto actual = static_cast<t>(ExperimentsInstance());
-  auto check = static_cast<t>(experiments);
-
-  return (actual & check) == check;
-}
-
-void InitializeExperimental() {
-  namespace rv = ranges::views;
-
-  auto const connonicalize_string = [](auto &&rng) {
-    auto const is_space = [](auto c) { return c == ' '; };
-    auto const to_lower = [](unsigned char c) { return std::tolower(c); };
-
-    return rng | rv::drop_while(is_space) | rv::take_while(std::not_fn(is_space)) | rv::transform(to_lower) |
-           ranges::to<std::string>;
-  };
-
-  auto const mapping_end = mapping.cend();
-  using underlying_type = std::underlying_type_t<Experiments>;
-  auto to_set = underlying_type{};
-  for (auto &&experiment : FLAGS_experimental_enabled | rv::split(',') | rv::transform(connonicalize_string)) {
-    if (auto it = mapping.find(experiment); it != mapping_end) {
-      to_set |= static_cast<underlying_type>(it->second);
-    }
-  }
-
-  ExperimentsInstance() = static_cast<Experiments>(to_set);
-}
-
-}  // namespace memgraph::flags

src/flags/experimental.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 "gflags/gflags.h"
-
-// Short help flag.
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_string(experimental_enabled);
-
-namespace memgraph::flags {
-
-// Each bit is an enabled experiment
-// old experiments can be reused once code cleanup has happened
-enum class Experiments : uint8_t {
-  SYSTEM_REPLICATION = 1 << 0,
-};
-
-bool AreExperimentsEnabled(Experiments experiments);
-
-void InitializeExperimental();
-
-}  // namespace memgraph::flags

src/flags/replication.cpp

@@ -13,17 +13,9 @@
 
 #ifdef MG_ENTERPRISE
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_bool(coordinator, false, "Controls whether the instance is a replication coordinator.");
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_uint32(coordinator_server_port, 0, "Port on which coordinator servers will be started.");
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_uint32(raft_server_port, 0, "Port on which raft servers will be started.");
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_uint32(raft_server_id, 0, "Unique ID of the raft server.");
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_uint32(instance_down_timeout_sec, 5, "Time duration after which an instance is considered down.");
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_uint32(instance_health_check_frequency_sec, 1, "The time duration between two health checks/pings.");
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_uint32(instance_get_uuid_frequency_sec, 10, "The time duration between two instance uuid checks.");
 #endif
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)

src/flags/replication.hpp

@@ -15,17 +15,9 @@
 
 #ifdef MG_ENTERPRISE
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_bool(coordinator);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DECLARE_uint32(coordinator_server_port);
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_uint32(raft_server_port);
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_uint32(raft_server_id);
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_uint32(instance_down_timeout_sec);
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_uint32(instance_health_check_frequency_sec);
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_uint32(instance_get_uuid_frequency_sec);
 #endif
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)

src/flags/run_time_configurable.cpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -54,6 +54,13 @@ DEFINE_double(query_execution_timeout_sec, 600,
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_bool(cartesian_product_enabled, true, "Enable cartesian product expansion.");
 
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_int64(maximum_deltas_per_transaction, -1, "Limit of deltas per transaction, default -1 (no limit)");
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_int64(maximum_delete_deltas_per_transaction, -1,
+             "Limit of delete deltas per transaction, default -1 (no limit)");
+
 namespace {
 // Bolt server name
 constexpr auto kServerNameSettingKey = "server.name";
@@ -73,12 +80,24 @@ constexpr auto kLogToStderrGFlagsKey = "also_log_to_stderr";
 constexpr auto kCartesianProductEnabledSettingKey = "cartesian-product-enabled";
 constexpr auto kCartesianProductEnabledGFlagsKey = "cartesian-product-enabled";
 
+constexpr auto kMaximumDeltasPerTransactionSettingKey = "maximum-deltas-per-transaction";
+constexpr auto kMaximumDeltasPerTransactionGFlagsKey = "maximum-deltas-per-transaction";
+
+constexpr auto kMaximumDeleteDeltasPerTransactionSettingKey = "maximum-delete-deltas-per-transaction";
+constexpr auto kMaximumDeleteDeltasPerTransactionGFlagsKey = "maximum-delete-deltas-per-transaction";
+
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 std::atomic<double> execution_timeout_sec_;  // Local cache-like thing
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 std::atomic<bool> cartesian_product_enabled_{true};  // Local cache-like thing
 
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+std::atomic<int64_t> maximum_deltas_per_transaction_;  // Local cache-like thing
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+std::atomic<int64_t> maximum_delete_deltas_per_transaction_;  // Local cache-like thing
+
 auto ToLLEnum(std::string_view val) {
   const auto ll_enum = memgraph::flags::LogLevelToEnum(val);
   if (!ll_enum) {
@@ -186,6 +205,22 @@ void Initialize() {
   register_flag(
       kCartesianProductEnabledGFlagsKey, kCartesianProductEnabledSettingKey, !kRestore,
       [](const std::string &val) { cartesian_product_enabled_ = val == "true"; }, ValidBoolStr);
+
+  /*
+   * Register maximum deltas per transaction
+   */
+  register_flag(kMaximumDeltasPerTransactionGFlagsKey, kMaximumDeltasPerTransactionSettingKey, !kRestore,
+                [&](const std::string &val) {
+                  maximum_deltas_per_transaction_ = std::stoll(val);  // Cache for faster reads
+                });
+
+  /*
+   * Register maximum delete deltas per transaction
+   */
+  register_flag(kMaximumDeleteDeltasPerTransactionGFlagsKey, kMaximumDeleteDeltasPerTransactionSettingKey, !kRestore,
+                [&](const std::string &val) {
+                  maximum_delete_deltas_per_transaction_ = std::stoll(val);  // Cache for faster reads
+                });
 }
 
 std::string GetServerName() {
@@ -199,4 +234,8 @@ double GetExecutionTimeout() { return execution_timeout_sec_; }
 
 bool GetCartesianProductEnabled() { return cartesian_product_enabled_; }
 
+int64_t GetMaximumDeltasPerTransaction() { return maximum_deltas_per_transaction_; }
+
+int64_t GetMaximumDeleteDeltasPerTransaction() { return maximum_delete_deltas_per_transaction_; }
+
 }  // namespace memgraph::flags::run_time

src/flags/run_time_configurable.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -42,4 +42,18 @@ double GetExecutionTimeout();
  */
 bool GetCartesianProductEnabled();
 
+/**
+ * @brief Get the maximum amount of deltas per transaction
+ *
+ * @return int64_t
+ */
+int64_t GetMaximumDeltasPerTransaction();
+
+/**
+ * @brief Get the maximum amount of delete deltas per transaction
+ *
+ * @return int64_t
+ */
+int64_t GetMaximumDeleteDeltasPerTransaction();
+
 }  // namespace memgraph::flags::run_time

src/io/network/endpoint.cpp

@@ -39,7 +39,7 @@ Endpoint::IpFamily Endpoint::GetIpFamily(const std::string &address) {
 }
 
 std::optional<std::pair<std::string, uint16_t>> Endpoint::ParseSocketOrIpAddress(
-    const std::string &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"

src/io/network/endpoint.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
@@ -61,8 +61,8 @@ struct Endpoint {
    * it into an ip address and a port number; even if a default port is given,
    * 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(
-      const std::string &address, std::optional<uint16_t> default_port = {});
+  static std::optional<std::pair<std::string, uint16_t>> ParseSocketOrIpAddress(const std::string &address,
+                                                                                std::optional<uint16_t> default_port);
 
   /**
    * Tries to parse given string as either socket address or hostname.

src/memgraph.cpp

@@ -134,7 +134,6 @@ int main(int argc, char **argv) {
   }
 
   memgraph::flags::InitializeLogger();
-  memgraph::flags::InitializeExperimental();
 
   // Unhandled exception handler init.
   std::set_terminate(&memgraph::utils::TerminateHandler);
@@ -356,11 +355,6 @@ int main(int argc, char **argv) {
   memgraph::query::InterpreterConfig interp_config{
       .query = {.allow_load_csv = FLAGS_allow_load_csv},
       .replication_replica_check_frequency = std::chrono::seconds(FLAGS_replication_replica_check_frequency_sec),
-#ifdef MG_ENTERPRISE
-      .instance_down_timeout_sec = std::chrono::seconds(FLAGS_instance_down_timeout_sec),
-      .instance_health_check_frequency_sec = std::chrono::seconds(FLAGS_instance_health_check_frequency_sec),
-      .instance_get_uuid_frequency_sec = std::chrono::seconds(FLAGS_instance_get_uuid_frequency_sec),
-#endif
       .default_kafka_bootstrap_servers = FLAGS_kafka_bootstrap_servers,
       .default_pulsar_service_url = FLAGS_pulsar_service_url,
       .stream_transaction_conflict_retries = FLAGS_stream_transaction_conflict_retries,
@@ -402,7 +396,7 @@ int main(int argc, char **argv) {
   memgraph::coordination::CoordinatorState coordinator_state;
 #endif
 
-  memgraph::dbms::DbmsHandler dbms_handler(db_config, repl_state
+  memgraph::dbms::DbmsHandler dbms_handler(db_config, system, repl_state
 #ifdef MG_ENTERPRISE
                                            ,
                                            auth_, FLAGS_data_recovery_on_startup
@@ -415,7 +409,7 @@ int main(int argc, char **argv) {
   auto replication_handler = memgraph::replication::ReplicationHandler{repl_state, dbms_handler
 #ifdef MG_ENTERPRISE
                                                                        ,
-                                                                       system, auth_
+                                                                       &system, auth_
 #endif
   };
 

src/memory/global_memory_control.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
@@ -60,13 +60,10 @@ void *my_alloc(extent_hooks_t *extent_hooks, void *new_addr, size_t size, size_t
                unsigned arena_ind) {
   // This needs to be before, to throw exception in case of too big alloc
   if (*commit) [[likely]] {
+    memgraph::utils::total_memory_tracker.Alloc(static_cast<int64_t>(size));
     if (GetQueriesMemoryControl().IsThreadTracked()) [[unlikely]] {
-      bool ok = GetQueriesMemoryControl().TrackAllocOnCurrentThread(size);
-      if (!ok) return nullptr;
+      GetQueriesMemoryControl().TrackAllocOnCurrentThread(size);
     }
-    // This needs to be here so it doesn't get incremented in case the first TrackAlloc throws an exception
-    bool ok = memgraph::utils::total_memory_tracker.Alloc(static_cast<int64_t>(size));
-    if (!ok) return nullptr;
   }
 
   auto *ptr = old_hooks->alloc(extent_hooks, new_addr, size, alignment, zero, commit, arena_ind);
@@ -120,15 +117,11 @@ static bool my_commit(extent_hooks_t *extent_hooks, void *addr, size_t size, siz
     return err;
   }
 
-  [[maybe_unused]] auto blocker = memgraph::utils::MemoryTracker::OutOfMemoryExceptionBlocker{};
+  memgraph::utils::total_memory_tracker.Alloc(static_cast<int64_t>(length));
   if (GetQueriesMemoryControl().IsThreadTracked()) [[unlikely]] {
-    bool ok = GetQueriesMemoryControl().TrackAllocOnCurrentThread(length);
-    DMG_ASSERT(ok);
+    GetQueriesMemoryControl().TrackAllocOnCurrentThread(size);
   }
 
-  auto ok = memgraph::utils::total_memory_tracker.Alloc(static_cast<int64_t>(length));
-  DMG_ASSERT(ok);
-
   return false;
 }
 

src/memory/new_delete.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
@@ -28,12 +28,6 @@ void *newImpl(const std::size_t size) {
     return ptr;
   }
 
-  [[maybe_unused]] auto blocker = memgraph::utils::MemoryTracker::OutOfMemoryExceptionBlocker{};
-  auto maybe_msg = memgraph::utils::MemoryErrorStatus().msg();
-  if (maybe_msg) {
-    throw memgraph::utils::OutOfMemoryException{std::move(*maybe_msg)};
-  }
-
   throw std::bad_alloc{};
 }
 
@@ -43,21 +37,11 @@ void *newImpl(const std::size_t size, const std::align_val_t align) {
     return ptr;
   }
 
-  [[maybe_unused]] auto blocker = memgraph::utils::MemoryTracker::OutOfMemoryExceptionBlocker{};
-  auto maybe_msg = memgraph::utils::MemoryErrorStatus().msg();
-  if (maybe_msg) {
-    throw memgraph::utils::OutOfMemoryException{std::move(*maybe_msg)};
-  }
-
   throw std::bad_alloc{};
 }
 
-void *newNoExcept(const std::size_t size) noexcept {
-  [[maybe_unused]] auto blocker = memgraph::utils::MemoryTracker::OutOfMemoryExceptionBlocker{};
-  return malloc(size);
-}
+void *newNoExcept(const std::size_t size) noexcept { return malloc(size); }
 void *newNoExcept(const std::size_t size, const std::align_val_t align) noexcept {
-  [[maybe_unused]] auto blocker = memgraph::utils::MemoryTracker::OutOfMemoryExceptionBlocker{};
   return aligned_alloc(size, static_cast<std::size_t>(align));
 }
 

src/memory/query_memory_control.cpp

@@ -54,14 +54,14 @@ void QueriesMemoryControl::EraseThreadToTransactionId(const std::thread::id &thr
   }
 }
 
-bool QueriesMemoryControl::TrackAllocOnCurrentThread(size_t size) {
+void QueriesMemoryControl::TrackAllocOnCurrentThread(size_t size) {
   auto thread_id_to_transaction_id_accessor = thread_id_to_transaction_id.access();
 
   // we might be just constructing mapping between thread id and transaction id
   // so we miss this allocation
   auto thread_id_to_transaction_id_elem = thread_id_to_transaction_id_accessor.find(std::this_thread::get_id());
   if (thread_id_to_transaction_id_elem == thread_id_to_transaction_id_accessor.end()) {
-    return true;
+    return;
   }
 
   auto transaction_id_to_tracker_accessor = transaction_id_to_tracker.access();
@@ -71,10 +71,10 @@ bool QueriesMemoryControl::TrackAllocOnCurrentThread(size_t size) {
   // It can happen that some allocation happens between mapping thread to
   // transaction id, so we miss this allocation
   if (transaction_id_to_tracker == transaction_id_to_tracker_accessor.end()) [[unlikely]] {
-    return true;
+    return;
   }
   auto &query_tracker = transaction_id_to_tracker->tracker;
-  return query_tracker.TrackAlloc(size);
+  query_tracker.TrackAlloc(size);
 }
 
 void QueriesMemoryControl::TrackFreeOnCurrentThread(size_t size) {
@@ -110,7 +110,7 @@ void QueriesMemoryControl::CreateTransactionIdTracker(uint64_t transaction_id, s
 
 bool QueriesMemoryControl::EraseTransactionIdTracker(uint64_t transaction_id) {
   auto transaction_id_to_tracker_accessor = transaction_id_to_tracker.access();
-  auto removed = transaction_id_to_tracker_accessor.remove(transaction_id);
+  auto removed = transaction_id_to_tracker.access().remove(transaction_id);
   return removed;
 }
 

src/memory/query_memory_control.hpp

@@ -62,7 +62,7 @@ class QueriesMemoryControl {
   // Find tracker for current thread if exists, track
   // query allocation and procedure allocation if
   // necessary
-  bool TrackAllocOnCurrentThread(size_t size);
+  void TrackAllocOnCurrentThread(size_t size);
 
   // Find tracker for current thread if exists, track
   // query allocation and procedure allocation if

src/query/config.hpp

@@ -22,10 +22,6 @@ struct InterpreterConfig {
   // The same as \ref memgraph::replication::ReplicationClientConfig
   std::chrono::seconds replication_replica_check_frequency{1};
 
-  std::chrono::seconds instance_down_timeout_sec{5};
-  std::chrono::seconds instance_health_check_frequency_sec{1};
-  std::chrono::seconds instance_get_uuid_frequency_sec{10};
-
   std::string default_kafka_bootstrap_servers;
   std::string default_pulsar_service_url;
   uint32_t stream_transaction_conflict_retries;

src/query/db_accessor.hpp

@@ -54,10 +54,6 @@ class EdgeAccessor final {
     return impl_.GetProperty(key, view);
   }
 
-  storage::Result<uint64_t> GetPropertySize(storage::PropertyId key, storage::View view) const {
-    return impl_.GetPropertySize(key, view);
-  }
-
   storage::Result<storage::PropertyValue> SetProperty(storage::PropertyId key, const storage::PropertyValue &value) {
     return impl_.SetProperty(key, value);
   }
@@ -133,10 +129,6 @@ class VertexAccessor final {
     return impl_.GetProperty(key, view);
   }
 
-  storage::Result<uint64_t> GetPropertySize(storage::PropertyId key, storage::View view) const {
-    return impl_.GetPropertySize(key, view);
-  }
-
   storage::Result<storage::PropertyValue> SetProperty(storage::PropertyId key, const storage::PropertyValue &value) {
     return impl_.SetProperty(key, value);
   }
@@ -276,10 +268,6 @@ class SubgraphVertexAccessor final {
     return impl_.GetProperty(view, key);
   }
 
-  storage::Result<uint64_t> GetPropertySize(storage::PropertyId key, storage::View view) const {
-    return impl_.GetPropertySize(key, view);
-  }
-
   storage::Gid Gid() const noexcept { return impl_.Gid(); }
 
   storage::Result<size_t> InDegree(storage::View view) const { return impl_.InDegree(view); }
@@ -541,10 +529,6 @@ class DbAccessor final {
 
   storage::PropertyId NameToProperty(const std::string_view name) { return accessor_->NameToProperty(name); }
 
-  std::optional<storage::PropertyId> NameToPropertyIfExists(std::string_view name) const {
-    return accessor_->NameToPropertyIfExists(name);
-  }
-
   storage::LabelId NameToLabel(const std::string_view name) { return accessor_->NameToLabel(name); }
 
   storage::EdgeTypeId NameToEdgeType(const std::string_view name) { return accessor_->NameToEdgeType(name); }

src/query/frontend/ast/ast.hpp

@@ -3034,7 +3034,7 @@ class ReplicationQuery : public memgraph::query::Query {
 
   enum class SyncMode { SYNC, ASYNC };
 
-  enum class ReplicaState { READY, REPLICATING, RECOVERY, MAYBE_BEHIND, DIVERGED_FROM_MAIN };
+  enum class ReplicaState { READY, REPLICATING, RECOVERY, MAYBE_BEHIND };
 
   ReplicationQuery() = default;
 
@@ -3073,10 +3073,8 @@ class CoordinatorQuery : public memgraph::query::Query {
 
   enum class Action {
     REGISTER_INSTANCE,
-    UNREGISTER_INSTANCE,
     SET_INSTANCE_TO_MAIN,
-    SHOW_INSTANCES,
-    ADD_COORDINATOR_INSTANCE
+    SHOW_REPLICATION_CLUSTER,
   };
 
   enum class SyncMode { SYNC, ASYNC };
@@ -3089,8 +3087,6 @@ class CoordinatorQuery : public memgraph::query::Query {
   std::string instance_name_;
   memgraph::query::Expression *replication_socket_address_{nullptr};
   memgraph::query::Expression *coordinator_socket_address_{nullptr};
-  memgraph::query::Expression *raft_socket_address_{nullptr};
-  memgraph::query::Expression *raft_server_id_{nullptr};
   memgraph::query::CoordinatorQuery::SyncMode sync_mode_;
 
   CoordinatorQuery *Clone(AstStorage *storage) const override {
@@ -3102,8 +3098,6 @@ class CoordinatorQuery : public memgraph::query::Query {
     object->sync_mode_ = sync_mode_;
     object->coordinator_socket_address_ =
         coordinator_socket_address_ ? coordinator_socket_address_->Clone(storage) : nullptr;
-    object->raft_socket_address_ = raft_socket_address_ ? raft_socket_address_->Clone(storage) : nullptr;
-    object->raft_server_id_ = raft_server_id_ ? raft_server_id_->Clone(storage) : nullptr;
 
     return object;
   }

src/query/frontend/ast/cypher_main_visitor.cpp

@@ -374,6 +374,7 @@ antlrcpp::Any CypherMainVisitor::visitRegisterReplica(MemgraphCypher::RegisterRe
   return replication_query;
 }
 
+// License check is done in the interpreter.
 antlrcpp::Any CypherMainVisitor::visitRegisterInstanceOnCoordinator(
     MemgraphCypher::RegisterInstanceOnCoordinatorContext *ctx) {
   auto *coordinator_query = storage_->Create<CoordinatorQuery>();
@@ -399,36 +400,10 @@ antlrcpp::Any CypherMainVisitor::visitRegisterInstanceOnCoordinator(
   return coordinator_query;
 }
 
-antlrcpp::Any CypherMainVisitor::visitUnregisterInstanceOnCoordinator(
-    MemgraphCypher::UnregisterInstanceOnCoordinatorContext *ctx) {
-  auto *coordinator_query = storage_->Create<CoordinatorQuery>();
-  coordinator_query->action_ = CoordinatorQuery::Action::UNREGISTER_INSTANCE;
-  coordinator_query->instance_name_ = std::any_cast<std::string>(ctx->instanceName()->symbolicName()->accept(this));
-  return coordinator_query;
-}
-
-antlrcpp::Any CypherMainVisitor::visitAddCoordinatorInstance(MemgraphCypher::AddCoordinatorInstanceContext *ctx) {
-  auto *coordinator_query = storage_->Create<CoordinatorQuery>();
-
-  if (!ctx->raftSocketAddress()->literal()->StringLiteral()) {
-    throw SemanticException("Raft socket address should be a string literal!");
-  }
-
-  if (!ctx->raftServerId()->literal()->numberLiteral()) {
-    throw SemanticException("Raft server id should be a number literal!");
-  }
-
-  coordinator_query->action_ = CoordinatorQuery::Action::ADD_COORDINATOR_INSTANCE;
-  coordinator_query->raft_socket_address_ = std::any_cast<Expression *>(ctx->raftSocketAddress()->accept(this));
-  coordinator_query->raft_server_id_ = std::any_cast<Expression *>(ctx->raftServerId()->accept(this));
-
-  return coordinator_query;
-}
-
 // License check is done in the interpreter
-antlrcpp::Any CypherMainVisitor::visitShowInstances(MemgraphCypher::ShowInstancesContext * /*ctx*/) {
+antlrcpp::Any CypherMainVisitor::visitShowReplicationCluster(MemgraphCypher::ShowReplicationClusterContext * /*ctx*/) {
   auto *coordinator_query = storage_->Create<CoordinatorQuery>();
-  coordinator_query->action_ = CoordinatorQuery::Action::SHOW_INSTANCES;
+  coordinator_query->action_ = CoordinatorQuery::Action::SHOW_REPLICATION_CLUSTER;
   return coordinator_query;
 }
 
@@ -475,10 +450,8 @@ antlrcpp::Any CypherMainVisitor::visitLoadCsv(MemgraphCypher::LoadCsvContext *ct
 
   auto *load_csv = storage_->Create<LoadCsv>();
   // handle file name
-  if (ctx->csvFile()->literal() && ctx->csvFile()->literal()->StringLiteral()) {
+  if (ctx->csvFile()->literal()->StringLiteral()) {
     load_csv->file_ = std::any_cast<Expression *>(ctx->csvFile()->accept(this));
-  } else if (ctx->csvFile()->parameter()) {
-    load_csv->file_ = std::any_cast<ParameterLookup *>(ctx->csvFile()->accept(this));
   } else {
     throw SemanticException("CSV file path should be a string literal");
   }

src/query/frontend/ast/cypher_main_visitor.hpp

@@ -243,12 +243,6 @@ class CypherMainVisitor : public antlropencypher::MemgraphCypherBaseVisitor {
    */
   antlrcpp::Any visitRegisterInstanceOnCoordinator(MemgraphCypher::RegisterInstanceOnCoordinatorContext *ctx) override;
 
-  /**
-   * @return CoordinatorQuery*
-   */
-  antlrcpp::Any visitUnregisterInstanceOnCoordinator(
-      MemgraphCypher::UnregisterInstanceOnCoordinatorContext *ctx) override;
-
   /**
    * @return CoordinatorQuery*
    */
@@ -257,12 +251,7 @@ class CypherMainVisitor : public antlropencypher::MemgraphCypherBaseVisitor {
   /**
    * @return CoordinatorQuery*
    */
-  antlrcpp::Any visitAddCoordinatorInstance(MemgraphCypher::AddCoordinatorInstanceContext *ctx) override;
-
-  /**
-   * @return CoordinatorQuery*
-   */
-  antlrcpp::Any visitShowInstances(MemgraphCypher::ShowInstancesContext *ctx) override;
+  antlrcpp::Any visitShowReplicationCluster(MemgraphCypher::ShowReplicationClusterContext *ctx) override;
 
   /**
    * @return LockPathQuery*

src/query/frontend/opencypher/grammar/MemgraphCypher.g4

@@ -20,7 +20,6 @@ options { tokenVocab=MemgraphCypherLexer; }
 import Cypher ;
 
 memgraphCypherKeyword : cypherKeyword
-                      | ADD
                       | ACTIVE
                       | AFTER
                       | ALTER
@@ -65,7 +64,6 @@ memgraphCypherKeyword : cypherKeyword
                       | HEADER
                       | IDENTIFIED
                       | INSTANCE
-                      | INSTANCES
                       | NODE_LABELS
                       | NULLIF
                       | IMPORT
@@ -190,10 +188,8 @@ replicationQuery : setReplicationRole
                  ;
 
 coordinatorQuery : registerInstanceOnCoordinator
-                 | unregisterInstanceOnCoordinator
                  | setInstanceToMain
-                 | showInstances
-                 | addCoordinatorInstance
+                 | showReplicationCluster
                  ;
 
 triggerQuery : createTrigger
@@ -266,7 +262,7 @@ loadCsv : LOAD CSV FROM csvFile ( WITH | NO ) HEADER
          ( NULLIF nullif ) ?
          AS rowVar ;
 
-csvFile : literal | parameter ;
+csvFile : literal ;
 
 delimiter : literal ;
 
@@ -378,7 +374,7 @@ setReplicationRole : SET REPLICATION ROLE TO ( MAIN | REPLICA )
 
 showReplicationRole : SHOW REPLICATION ROLE ;
 
-showInstances : SHOW INSTANCES ;
+showReplicationCluster : SHOW REPLICATION CLUSTER ;
 
 instanceName : symbolicName ;
 
@@ -386,21 +382,14 @@ socketAddress : literal ;
 
 coordinatorSocketAddress : literal ;
 replicationSocketAddress : literal ;
-raftSocketAddress : literal ;
 
 registerReplica : REGISTER REPLICA instanceName ( SYNC | ASYNC )
                 TO socketAddress ;
 
 registerInstanceOnCoordinator : REGISTER INSTANCE instanceName ON coordinatorSocketAddress ( AS ASYNC ) ? WITH replicationSocketAddress ;
 
-unregisterInstanceOnCoordinator : UNREGISTER INSTANCE instanceName ;
-
 setInstanceToMain : SET INSTANCE instanceName TO MAIN ;
 
-raftServerId : literal ;
-
-addCoordinatorInstance : ADD COORDINATOR raftServerId ON raftSocketAddress ;
-
 dropReplica : DROP REPLICA instanceName ;
 
 showReplicas : SHOW REPLICAS ;

src/query/frontend/opencypher/grammar/MemgraphCypherLexer.g4

@@ -23,7 +23,6 @@ lexer grammar MemgraphCypherLexer ;
 
 import CypherLexer ;
 
-ADD                     : A D D ;
 ACTIVE                  : A C T I V E ;
 AFTER                   : A F T E R ;
 ALTER                   : A L T E R ;
@@ -40,6 +39,7 @@ BOOTSTRAP_SERVERS       : B O O T S T R A P UNDERSCORE S E R V E R S ;
 CALL                    : C A L L ;
 CHECK                   : C H E C K ;
 CLEAR                   : C L E A R ;
+CLUSTER                 : C L U S T E R ;
 COMMIT                  : C O M M I T ;
 COMMITTED               : C O M M I T T E D ;
 CONFIG                  : C O N F I G ;
@@ -80,7 +80,6 @@ INACTIVE                : I N A C T I V E ;
 IN_MEMORY_ANALYTICAL    : I N UNDERSCORE M E M O R Y UNDERSCORE A N A L Y T I C A L ;
 IN_MEMORY_TRANSACTIONAL : I N UNDERSCORE M E M O R Y UNDERSCORE T R A N S A C T I O N A L ;
 INSTANCE                : I N S T A N C E ;
-INSTANCES               : I N S T A N C E S ;
 ISOLATION               : I S O L A T I O N ;
 KAFKA                   : K A F K A ;
 LABELS                  : L A B E L S ;
@@ -141,7 +140,6 @@ TRIGGER                 : T R I G G E R ;
 TRIGGERS                : T R I G G E R S ;
 UNCOMMITTED             : U N C O M M I T T E D ;
 UNLOCK                  : U N L O C K ;
-UNREGISTER              : U N R E G I S T E R ;
 UPDATE                  : U P D A T E ;
 USE                     : U S E ;
 USER                    : U S E R ;

src/query/frontend/semantic/symbol_generator.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
@@ -394,16 +394,9 @@ SymbolGenerator::ReturnType SymbolGenerator::Visit(Identifier &ident) {
     // can reference symbols bound later in the same MATCH. We collect them
     // here, so that they can be checked after visiting Match.
     scope.identifiers_in_match.emplace_back(&ident);
-  } else if (scope.in_call_subquery && !scope.in_with) {
-    if (!scope.symbols.contains(ident.name_) && !ConsumePredefinedIdentifier(ident.name_)) {
-      throw UnboundVariableError(ident.name_);
-    }
-    symbol = GetOrCreateSymbol(ident.name_, ident.user_declared_, Symbol::Type::ANY);
   } else {
     // Everything else references a bound symbol.
-    if (!HasSymbol(ident.name_) && !ConsumePredefinedIdentifier(ident.name_)) {
-      throw UnboundVariableError(ident.name_);
-    }
+    if (!HasSymbol(ident.name_) && !ConsumePredefinedIdentifier(ident.name_)) throw UnboundVariableError(ident.name_);
     symbol = GetOrCreateSymbol(ident.name_, ident.user_declared_, Symbol::Type::ANY);
   }
   ident.MapTo(symbol);

src/query/frontend/stripped_lexer_constants.hpp

@@ -219,8 +219,7 @@ const trie::Trie kKeywords = {"union",
                               "lock",
                               "unlock",
                               "build",
-                              "instance",
-                              "coordinator"};
+                              "instance"};
 
 // Unicode codepoints that are allowed at the start of the unescaped name.
 const std::bitset<kBitsetSize> kUnescapedNameAllowedStarts(

src/query/interpret/awesome_memgraph_functions.cpp

@@ -442,29 +442,6 @@ TypedValue Size(const TypedValue *args, int64_t nargs, const FunctionContext &ct
   }
 }
 
-TypedValue PropertySize(const TypedValue *args, int64_t nargs, const FunctionContext &ctx) {
-  FType<Or<Null, Vertex, Edge>, Or<String>>("propertySize", args, nargs);
-
-  auto *dba = ctx.db_accessor;
-
-  const auto &property_name = args[1].ValueString();
-  const auto maybe_property_id = dba->NameToPropertyIfExists(property_name);
-
-  if (!maybe_property_id) {
-    return TypedValue(0, ctx.memory);
-  }
-
-  uint64_t property_size = 0;
-  const auto &graph_entity = args[0];
-  if (graph_entity.IsVertex()) {
-    property_size = graph_entity.ValueVertex().GetPropertySize(*maybe_property_id, ctx.view).GetValue();
-  } else if (graph_entity.IsEdge()) {
-    property_size = graph_entity.ValueEdge().GetPropertySize(*maybe_property_id, ctx.view).GetValue();
-  }
-
-  return TypedValue(static_cast<int64_t>(property_size), ctx.memory);
-}
-
 TypedValue StartNode(const TypedValue *args, int64_t nargs, const FunctionContext &ctx) {
   FType<Or<Null, Edge>>("startNode", args, nargs);
   if (args[0].IsNull()) return TypedValue(ctx.memory);
@@ -1348,7 +1325,6 @@ std::function<TypedValue(const TypedValue *, int64_t, const FunctionContext &ctx
   if (function_name == "PROPERTIES") return Properties;
   if (function_name == "RANDOMUUID") return RandomUuid;
   if (function_name == "SIZE") return Size;
-  if (function_name == "PROPERTYSIZE") return PropertySize;
   if (function_name == "STARTNODE") return StartNode;
   if (function_name == "TIMESTAMP") return Timestamp;
   if (function_name == "TOBOOLEAN") return ToBoolean;

src/query/interpreter.cpp

@@ -93,7 +93,6 @@
 #include "utils/exceptions.hpp"
 #include "utils/file.hpp"
 #include "utils/flag_validation.hpp"
-#include "utils/functional.hpp"
 #include "utils/likely.hpp"
 #include "utils/logging.hpp"
 #include "utils/memory.hpp"
@@ -110,7 +109,6 @@
 
 #ifdef MG_ENTERPRISE
 #include "coordination/constants.hpp"
-#include "flags/experimental.hpp"
 #endif
 
 namespace memgraph::metrics {
@@ -329,7 +327,7 @@ class ReplQueryHandler {
           .port = static_cast<uint16_t>(*port),
       };
 
-      if (!handler_->TrySetReplicationRoleReplica(config, std::nullopt)) {
+      if (!handler_->SetReplicationRoleReplica(config)) {
         throw QueryRuntimeException("Couldn't set role to replica!");
       }
     }
@@ -370,7 +368,7 @@ class ReplQueryHandler {
                                                .replica_check_frequency = replica_check_frequency,
                                                .ssl = std::nullopt};
 
-      const auto error = handler_->TryRegisterReplica(replication_config, true).HasError();
+      const auto error = handler_->TryRegisterReplica(replication_config).HasError();
 
       if (error) {
         throw QueryRuntimeException(fmt::format("Couldn't register replica '{}'!", name));
@@ -439,9 +437,6 @@ class ReplQueryHandler {
         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;
@@ -462,33 +457,10 @@ class CoordQueryHandler final : public query::CoordinatorQueryHandler {
 
       : coordinator_handler_(coordinator_state) {}
 
-  void UnregisterInstance(std::string const &instance_name) override {
-    auto status = coordinator_handler_.UnregisterReplicationInstance(instance_name);
-    switch (status) {
-      using enum memgraph::coordination::UnregisterInstanceCoordinatorStatus;
-      case NO_INSTANCE_WITH_NAME:
-        throw QueryRuntimeException("No instance with such name!");
-      case IS_MAIN:
-        throw QueryRuntimeException(
-            "Alive main instance can't be unregistered! Shut it down to trigger failover and then unregister it!");
-      case NOT_COORDINATOR:
-        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 RPC_FAILED:
-        throw QueryRuntimeException(
-            "Couldn't unregister replica instance because current main instance couldn't unregister replica!");
-      case SUCCESS:
-        break;
-    }
-  }
-
-  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 const &instance_name, CoordinatorQuery::SyncMode sync_mode) override {
+  /// @throw QueryRuntimeException if an error ocurred.
+  void RegisterInstance(const std::string &coordinator_socket_address, const std::string &replication_socket_address,
+                        const std::chrono::seconds instance_check_frequency, const std::string &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) {
@@ -513,13 +485,11 @@ class CoordQueryHandler final : public query::CoordinatorQueryHandler {
         coordination::CoordinatorClientConfig{.instance_name = instance_name,
                                               .ip_address = coordinator_server_ip,
                                               .port = coordinator_server_port,
-                                              .instance_health_check_frequency_sec = instance_check_frequency,
-                                              .instance_down_timeout_sec = instance_down_timeout,
-                                              .instance_get_uuid_frequency_sec = instance_get_uuid_frequency,
+                                              .health_check_frequency_sec = instance_check_frequency,
                                               .replication_client_info = repl_config,
                                               .ssl = std::nullopt};
 
-    auto status = coordinator_handler_.RegisterReplicationInstance(coordinator_client_config);
+    auto status = coordinator_handler_.RegisterInstance(coordinator_client_config);
     switch (status) {
       using enum memgraph::coordination::RegisterInstanceCoordinatorStatus;
       case NAME_EXISTS:
@@ -529,14 +499,6 @@ class CoordQueryHandler final : public query::CoordinatorQueryHandler {
             "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_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(
             "Couldn't register replica instance because setting instance to replica failed! Check logs on replica to "
@@ -546,38 +508,23 @@ class CoordQueryHandler final : public query::CoordinatorQueryHandler {
     }
   }
 
-  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);
-      coordinator_handler_.AddCoordinatorInstance(raft_server_id, port, ip);
-    } else {
-      spdlog::error("Invalid raft socket address {}.", raft_socket_address);
-    }
-  }
-
-  void SetReplicationInstanceToMain(const std::string &instance_name) override {
-    auto status = coordinator_handler_.SetReplicationInstanceToMain(instance_name);
+  void SetInstanceToMain(const std::string &instance_name) override {
+    auto status = coordinator_handler_.SetInstanceToMain(instance_name);
     switch (status) {
       using enum memgraph::coordination::SetInstanceToMainCoordinatorStatus;
       case NO_INSTANCE_WITH_NAME:
         throw QueryRuntimeException("No instance with such name!");
-      case MAIN_ALREADY_EXISTS:
-        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 COULD_NOT_PROMOTE_TO_MAIN:
         throw QueryRuntimeException(
-            "Couldn't set replica instance to main! Check coordinator and replica for more logs");
-      case SWAP_UUID_FAILED:
-        throw QueryRuntimeException("Couldn't set replica instance to main. Replicas didn't swap uuid of new main.");
+            "Couldn't set replica instance to main!. Check coordinator and replica for more logs");
       case SUCCESS:
         break;
     }
   }
 
-  std::vector<coordination::InstanceStatus> ShowInstances() const override {
+  std::vector<coordination::CoordinatorInstanceStatus> ShowInstances() const override {
     return coordinator_handler_.ShowInstances();
   }
 
@@ -981,7 +928,7 @@ Callback HandleReplicationQuery(ReplicationQuery *repl_query, const Parameters &
   switch (repl_query->action_) {
     case ReplicationQuery::Action::SET_REPLICATION_ROLE: {
 #ifdef MG_ENTERPRISE
-      if (FLAGS_raft_server_id) {
+      if (FLAGS_coordinator) {
         throw QueryRuntimeException("Coordinator can't set roles!");
       }
       if (FLAGS_coordinator_server_port) {
@@ -1011,7 +958,7 @@ Callback HandleReplicationQuery(ReplicationQuery *repl_query, const Parameters &
     }
     case ReplicationQuery::Action::SHOW_REPLICATION_ROLE: {
 #ifdef MG_ENTERPRISE
-      if (FLAGS_raft_server_id) {
+      if (FLAGS_coordinator) {
         throw QueryRuntimeException("Coordinator doesn't have a replication role!");
       }
 #endif
@@ -1068,8 +1015,8 @@ Callback HandleReplicationQuery(ReplicationQuery *repl_query, const Parameters &
     }
     case ReplicationQuery::Action::SHOW_REPLICAS: {
 #ifdef MG_ENTERPRISE
-      if (FLAGS_raft_server_id) {
-        throw QueryRuntimeException("Coordinator cannot call SHOW REPLICAS! Use SHOW INSTANCES instead.");
+      if (FLAGS_coordinator) {
+        throw QueryRuntimeException("Coordinator cannot call SHOW REPLICAS! Use SHOW REPLICATION CLUSTER instead.");
       }
 #endif
 
@@ -1113,9 +1060,6 @@ Callback HandleReplicationQuery(ReplicationQuery *repl_query, const Parameters &
             case ReplicationQuery::ReplicaState::MAYBE_BEHIND:
               typed_replica.emplace_back("invalid");
               break;
-            case ReplicationQuery::ReplicaState::DIVERGED_FROM_MAIN:
-              typed_replica.emplace_back("diverged");
-              break;
           }
 
           typed_replicas.emplace_back(std::move(typed_replica));
@@ -1133,37 +1077,6 @@ Callback HandleCoordinatorQuery(CoordinatorQuery *coordinator_query, const Param
                                 const query::InterpreterConfig &config, std::vector<Notification> *notifications) {
   Callback callback;
   switch (coordinator_query->action_) {
-    case CoordinatorQuery::Action::ADD_COORDINATOR_INSTANCE: {
-      if (!license::global_license_checker.IsEnterpriseValidFast()) {
-        throw QueryException("Trying to use enterprise feature without a valid license.");
-      }
-      if constexpr (!coordination::allow_ha) {
-        throw QueryRuntimeException(
-            "High availability is experimental feature. Please set MG_EXPERIMENTAL_HIGH_AVAILABILITY compile flag to "
-            "be able to use this functionality.");
-      }
-      if (!FLAGS_raft_server_id) {
-        throw QueryRuntimeException("Only coordinator can add coordinator instance!");
-      }
-
-      // TODO: MemoryResource for EvaluationContext, it should probably be passed as
-      // the argument to Callback.
-      EvaluationContext evaluation_context{.timestamp = QueryTimestamp(), .parameters = parameters};
-      auto evaluator = PrimitiveLiteralExpressionEvaluator{evaluation_context};
-
-      auto raft_socket_address_tv = coordinator_query->raft_socket_address_->Accept(evaluator);
-      auto raft_server_id_tv = coordinator_query->raft_server_id_->Accept(evaluator);
-      callback.fn = [handler = CoordQueryHandler{*coordinator_state}, raft_socket_address_tv,
-                     raft_server_id_tv]() mutable {
-        handler.AddCoordinatorInstance(raft_server_id_tv.ValueInt(), std::string(raft_socket_address_tv.ValueString()));
-        return std::vector<std::vector<TypedValue>>();
-      };
-
-      notifications->emplace_back(SeverityLevel::INFO, NotificationCode::ADD_COORDINATOR_INSTANCE,
-                                  fmt::format("Coordinator has added instance {} on coordinator server {}.",
-                                              coordinator_query->instance_name_, raft_socket_address_tv.ValueString()));
-      return callback;
-    }
     case CoordinatorQuery::Action::REGISTER_INSTANCE: {
       if (!license::global_license_checker.IsEnterpriseValidFast()) {
         throw QueryException("Trying to use enterprise feature without a valid license.");
@@ -1174,7 +1087,7 @@ Callback HandleCoordinatorQuery(CoordinatorQuery *coordinator_query, const Param
             "High availability is experimental feature. Please set MG_EXPERIMENTAL_HIGH_AVAILABILITY compile flag to "
             "be able to use this functionality.");
       }
-      if (!FLAGS_raft_server_id) {
+      if (!FLAGS_coordinator) {
         throw QueryRuntimeException("Only coordinator can register coordinator server!");
       }
       // TODO: MemoryResource for EvaluationContext, it should probably be passed as
@@ -1185,16 +1098,12 @@ Callback HandleCoordinatorQuery(CoordinatorQuery *coordinator_query, const Param
       auto coordinator_socket_address_tv = coordinator_query->coordinator_socket_address_->Accept(evaluator);
       auto replication_socket_address_tv = coordinator_query->replication_socket_address_->Accept(evaluator);
       callback.fn = [handler = CoordQueryHandler{*coordinator_state}, coordinator_socket_address_tv,
-                     replication_socket_address_tv,
-                     instance_health_check_frequency_sec = config.instance_health_check_frequency_sec,
+                     replication_socket_address_tv, main_check_frequency = config.replication_replica_check_frequency,
                      instance_name = coordinator_query->instance_name_,
-                     instance_down_timeout_sec = config.instance_down_timeout_sec,
-                     instance_get_uuid_frequency_sec = config.instance_get_uuid_frequency_sec,
                      sync_mode = coordinator_query->sync_mode_]() mutable {
-        handler.RegisterReplicationInstance(std::string(coordinator_socket_address_tv.ValueString()),
-                                            std::string(replication_socket_address_tv.ValueString()),
-                                            instance_health_check_frequency_sec, instance_down_timeout_sec,
-                                            instance_get_uuid_frequency_sec, instance_name, sync_mode);
+        handler.RegisterInstance(std::string(coordinator_socket_address_tv.ValueString()),
+                                 std::string(replication_socket_address_tv.ValueString()), main_check_frequency,
+                                 instance_name, sync_mode);
         return std::vector<std::vector<TypedValue>>();
       };
 
@@ -1204,30 +1113,6 @@ Callback HandleCoordinatorQuery(CoordinatorQuery *coordinator_query, const Param
                       coordinator_socket_address_tv.ValueString(), coordinator_query->instance_name_));
       return callback;
     }
-    case CoordinatorQuery::Action::UNREGISTER_INSTANCE:
-      if (!license::global_license_checker.IsEnterpriseValidFast()) {
-        throw QueryException("Trying to use enterprise feature without a valid license.");
-      }
-
-      if constexpr (!coordination::allow_ha) {
-        throw QueryRuntimeException(
-            "High availability is experimental feature. Please set MG_EXPERIMENTAL_HIGH_AVAILABILITY compile flag to "
-            "be able to use this functionality.");
-      }
-      if (!FLAGS_raft_server_id) {
-        throw QueryRuntimeException("Only coordinator can register coordinator server!");
-      }
-      callback.fn = [handler = CoordQueryHandler{*coordinator_state},
-                     instance_name = coordinator_query->instance_name_]() mutable {
-        handler.UnregisterInstance(instance_name);
-        return std::vector<std::vector<TypedValue>>();
-      };
-      notifications->emplace_back(
-          SeverityLevel::INFO, NotificationCode::UNREGISTER_INSTANCE,
-          fmt::format("Coordinator has unregistered instance {}.", coordinator_query->instance_name_));
-
-      return callback;
-
     case CoordinatorQuery::Action::SET_INSTANCE_TO_MAIN: {
       if (!license::global_license_checker.IsEnterpriseValidFast()) {
         throw QueryException("Trying to use enterprise feature without a valid license.");
@@ -1237,7 +1122,7 @@ Callback HandleCoordinatorQuery(CoordinatorQuery *coordinator_query, const Param
             "High availability is experimental feature. Please set MG_EXPERIMENTAL_HIGH_AVAILABILITY compile flag to "
             "be able to use this functionality.");
       }
-      if (!FLAGS_raft_server_id) {
+      if (!FLAGS_coordinator) {
         throw QueryRuntimeException("Only coordinator can register coordinator server!");
       }
       // TODO: MemoryResource for EvaluationContext, it should probably be passed as
@@ -1247,13 +1132,13 @@ Callback HandleCoordinatorQuery(CoordinatorQuery *coordinator_query, const Param
 
       callback.fn = [handler = CoordQueryHandler{*coordinator_state},
                      instance_name = coordinator_query->instance_name_]() mutable {
-        handler.SetReplicationInstanceToMain(instance_name);
+        handler.SetInstanceToMain(instance_name);
         return std::vector<std::vector<TypedValue>>();
       };
 
       return callback;
     }
-    case CoordinatorQuery::Action::SHOW_INSTANCES: {
+    case CoordinatorQuery::Action::SHOW_REPLICATION_CLUSTER: {
       if (!license::global_license_checker.IsEnterpriseValidFast()) {
         throw QueryException("Trying to use enterprise feature without a valid license.");
       }
@@ -1262,24 +1147,28 @@ Callback HandleCoordinatorQuery(CoordinatorQuery *coordinator_query, const Param
             "High availability is experimental feature. Please set MG_EXPERIMENTAL_HIGH_AVAILABILITY compile flag to "
             "be able to use this functionality.");
       }
-      if (!FLAGS_raft_server_id) {
-        throw QueryRuntimeException("Only coordinator can run SHOW INSTANCES.");
+      if (!FLAGS_coordinator) {
+        throw QueryRuntimeException("Only coordinator can run SHOW REPLICATION CLUSTER.");
       }
 
-      callback.header = {"name", "raft_socket_address", "coordinator_socket_address", "alive", "role"};
+      callback.header = {"name", "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.is_alive},
-                  TypedValue{status.cluster_role}};
-        };
+        std::vector<std::vector<TypedValue>> result{};
+        result.reserve(result.size());
 
-        return utils::fmap(converter, instances);
+        std::ranges::transform(instances, std::back_inserter(result),
+                               [](const auto &status) -> std::vector<TypedValue> {
+                                 return {TypedValue{status.instance_name}, TypedValue{status.socket_address},
+                                         TypedValue{status.is_alive}, TypedValue{status.replication_role}};
+                               });
+
+        return result;
       };
       return callback;
     }
+      return callback;
   }
 }
 #endif
@@ -3939,9 +3828,7 @@ PreparedQuery PrepareMultiDatabaseQuery(ParsedQuery parsed_query, CurrentDB &cur
       if (current_db.in_explicit_db_) {
         throw QueryException("Database switching is prohibited if session explicitly defines the used database");
       }
-
-      using enum memgraph::flags::Experiments;
-      if (!flags::AreExperimentsEnabled(SYSTEM_REPLICATION) && is_replica) {
+      if (!dbms::allow_mt_repl && is_replica) {
         throw QueryException("Query forbidden on the replica!");
       }
       return PreparedQuery{{"STATUS"},
@@ -4286,7 +4173,7 @@ Interpreter::PrepareResult Interpreter::Prepare(const std::string &query_string,
     }
 
 #ifdef MG_ENTERPRISE
-    if (FLAGS_raft_server_id && !utils::Downcast<CoordinatorQuery>(parsed_query.query) &&
+    if (FLAGS_coordinator && !utils::Downcast<CoordinatorQuery>(parsed_query.query) &&
         !utils::Downcast<SettingQuery>(parsed_query.query)) {
       throw QueryRuntimeException("Coordinator can run only coordinator queries!");
     }
@@ -4406,19 +4293,9 @@ Interpreter::PrepareResult Interpreter::Prepare(const std::string &query_string,
 
     UpdateTypeCount(rw_type);
 
-    bool const write_query = IsQueryWrite(rw_type);
-    if (write_query) {
-      if (interpreter_context_->repl_state->IsReplica()) {
-        query_execution = nullptr;
-        throw QueryException("Write query forbidden on the replica!");
-      }
-#ifdef MG_ENTERPRISE
-      if (FLAGS_coordinator_server_port && !interpreter_context_->repl_state->IsMainWriteable()) {
-        query_execution = nullptr;
-        throw QueryException(
-            "Write query forbidden on the main! Coordinator needs to enable writing on main by sending RPC message.");
-      }
-#endif
+    if (interpreter_context_->repl_state->IsReplica() && IsQueryWrite(rw_type)) {
+      query_execution = nullptr;
+      throw QueryException("Write query forbidden on the replica!");
     }
 
     // Set the target db to the current db (some queries have different target from the current db)
@@ -4605,8 +4482,7 @@ void Interpreter::Commit() {
     auto const main_commit = [&](replication::RoleMainData &mainData) {
     // Only enterprise can do system replication
 #ifdef MG_ENTERPRISE
-      using enum memgraph::flags::Experiments;
-      if (flags::AreExperimentsEnabled(SYSTEM_REPLICATION) && license::global_license_checker.IsEnterpriseValidFast()) {
+      if (license::global_license_checker.IsEnterpriseValidFast()) {
         return system_transaction_->Commit(memgraph::system::DoReplication{mainData});
       }
 #endif

src/query/interpreter.hpp

@@ -53,7 +53,7 @@
 #include "utils/tsc.hpp"
 
 #ifdef MG_ENTERPRISE
-#include "coordination/instance_status.hpp"
+#include "coordination/coordinator_instance_status.hpp"
 #endif
 
 namespace memgraph::metrics {
@@ -105,25 +105,16 @@ class CoordinatorQueryHandler {
   };
 
   /// @throw QueryRuntimeException if an error ocurred.
-  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 const &instance_name, CoordinatorQuery::SyncMode sync_mode) = 0;
+  virtual void RegisterInstance(const std::string &coordinator_socket_address,
+                                const std::string &replication_socket_address,
+                                const std::chrono::seconds instance_check_frequency, const std::string &instance_name,
+                                CoordinatorQuery::SyncMode sync_mode) = 0;
 
   /// @throw QueryRuntimeException if an error ocurred.
-  virtual void UnregisterInstance(std::string const &instance_name) = 0;
+  virtual void SetInstanceToMain(const std::string &instance_name) = 0;
 
   /// @throw QueryRuntimeException if an error ocurred.
-  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 const &coordinator_socket_address)
-      -> void = 0;
+  virtual std::vector<coordination::CoordinatorInstanceStatus> ShowInstances() const = 0;
 };
 #endif
 

src/query/metadata.cpp

@@ -69,10 +69,6 @@ constexpr std::string_view GetCodeString(const NotificationCode code) {
 #ifdef MG_ENTERPRISE
     case NotificationCode::REGISTER_COORDINATOR_SERVER:
       return "RegisterCoordinatorServer"sv;
-    case NotificationCode::ADD_COORDINATOR_INSTANCE:
-      return "AddCoordinatorInstance"sv;
-    case NotificationCode::UNREGISTER_INSTANCE:
-      return "UnregisterInstance"sv;
 #endif
     case NotificationCode::REPLICA_PORT_WARNING:
       return "ReplicaPortWarning"sv;

src/query/metadata.hpp

@@ -43,9 +43,7 @@ enum class NotificationCode : uint8_t {
   REPLICA_PORT_WARNING,
   REGISTER_REPLICA,
 #ifdef MG_ENTERPRISE
-  REGISTER_COORDINATOR_SERVER,  // TODO: (andi) What is this?
-  ADD_COORDINATOR_INSTANCE,
-  UNREGISTER_INSTANCE,
+  REGISTER_COORDINATOR_SERVER,
 #endif
   SET_REPLICA,
   START_STREAM,

src/query/path.hpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2022 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
@@ -114,17 +114,12 @@ class Path {
   /** Expands the path with the given vertex. */
   void Expand(const VertexAccessor &vertex) {
     DMG_ASSERT(vertices_.size() == edges_.size(), "Illegal path construction order");
-    DMG_ASSERT(edges_.empty() || (!edges_.empty() && (edges_.back().To().Gid() == vertex.Gid() ||
-                                                      edges_.back().From().Gid() == vertex.Gid())),
-               "Illegal path construction order");
     vertices_.emplace_back(vertex);
   }
 
   /** Expands the path with the given edge. */
   void Expand(const EdgeAccessor &edge) {
     DMG_ASSERT(vertices_.size() - 1 == edges_.size(), "Illegal path construction order");
-    DMG_ASSERT(vertices_.back().Gid() == edge.From().Gid() || vertices_.back().Gid() == edge.To().Gid(),
-               "Illegal path construction order");
     edges_.emplace_back(edge);
   }
 
@@ -135,14 +130,6 @@ class Path {
     Expand(others...);
   }
 
-  void Shrink() {
-    DMG_ASSERT(!vertices_.empty(), "Vertices should not be empty in the path before shrink.");
-    vertices_.pop_back();
-    if (!edges_.empty()) {
-      edges_.pop_back();
-    }
-  }
-
   /** Returns the number of expansions (edges) in this path. */
   auto size() const { return edges_.size(); }
 

src/query/plan/operator.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
@@ -1057,8 +1057,7 @@ class ExpandVariableCursor : public Cursor {
           if (!self_.common_.existing_node) {
             frame[self_.common_.node_symbol] = start_vertex;
             return true;
-          }
-          if (CheckExistingNode(start_vertex, self_.common_.node_symbol, frame)) {
+          } else if (CheckExistingNode(start_vertex, self_.common_.node_symbol, frame)) {
             return true;
           }
         }
@@ -1244,10 +1243,6 @@ class ExpandVariableCursor : public Cursor {
         MG_ASSERT(frame[self_.filter_lambda_.accumulated_path_symbol.value()].IsPath(),
                   "Accumulated path must be path");
         Path &accumulated_path = frame[self_.filter_lambda_.accumulated_path_symbol.value()].ValuePath();
-        // Shrink the accumulated path including current level if necessary
-        while (accumulated_path.size() >= edges_on_frame.size()) {
-          accumulated_path.Shrink();
-        }
         accumulated_path.Expand(current_edge.first);
         accumulated_path.Expand(current_vertex);
       }
@@ -1265,9 +1260,10 @@ class ExpandVariableCursor : public Cursor {
       if (self_.common_.existing_node && !CheckExistingNode(current_vertex, self_.common_.node_symbol, frame)) continue;
 
       // We only yield true if we satisfy the lower bound.
-      if (static_cast<int64_t>(edges_on_frame.size()) >= lower_bound_) {
+      if (static_cast<int64_t>(edges_on_frame.size()) >= lower_bound_)
         return true;
-      }
+      else
+        continue;
     }
   }
 };
@@ -1531,8 +1527,8 @@ class SingleSourceShortestPathCursor : public query::plan::Cursor {
       : self_(self),
         input_cursor_(self_.input()->MakeCursor(mem)),
         processed_(mem),
-        to_visit_next_(mem),
-        to_visit_current_(mem) {
+        to_visit_current_(mem),
+        to_visit_next_(mem) {
     MG_ASSERT(!self_.common_.existing_node,
               "Single source shortest path algorithm "
               "should not be used when `existing_node` "
@@ -1562,14 +1558,12 @@ class SingleSourceShortestPathCursor : public query::plan::Cursor {
 #endif
       frame[self_.filter_lambda_.inner_edge_symbol] = edge;
       frame[self_.filter_lambda_.inner_node_symbol] = vertex;
-      std::optional<Path> curr_acc_path = std::nullopt;
       if (self_.filter_lambda_.accumulated_path_symbol) {
         MG_ASSERT(frame[self_.filter_lambda_.accumulated_path_symbol.value()].IsPath(),
                   "Accumulated path must have Path type");
         Path &accumulated_path = frame[self_.filter_lambda_.accumulated_path_symbol.value()].ValuePath();
         accumulated_path.Expand(edge);
         accumulated_path.Expand(vertex);
-        curr_acc_path = accumulated_path;
       }
 
       if (self_.filter_lambda_.expression) {
@@ -1584,33 +1578,21 @@ class SingleSourceShortestPathCursor : public query::plan::Cursor {
             throw QueryRuntimeException("Expansion condition must evaluate to boolean or null.");
         }
       }
-      to_visit_next_.emplace_back(edge, vertex, std::move(curr_acc_path));
+      to_visit_next_.emplace_back(edge, vertex);
       processed_.emplace(vertex, edge);
     };
 
-    auto restore_frame_state_after_expansion = [this, &frame]() {
-      if (self_.filter_lambda_.accumulated_path_symbol) {
-        frame[self_.filter_lambda_.accumulated_path_symbol.value()].ValuePath().Shrink();
-      }
-    };
-
     // populates the to_visit_next_ structure with expansions
     // from the given vertex. skips expansions that don't satisfy
     // the "where" condition.
-    auto expand_from_vertex = [this, &expand_pair, &restore_frame_state_after_expansion](const auto &vertex) {
+    auto expand_from_vertex = [this, &expand_pair](const auto &vertex) {
       if (self_.common_.direction != EdgeAtom::Direction::IN) {
         auto out_edges = UnwrapEdgesResult(vertex.OutEdges(storage::View::OLD, self_.common_.edge_types)).edges;
-        for (const auto &edge : out_edges) {
-          expand_pair(edge, edge.To());
-          restore_frame_state_after_expansion();
-        }
+        for (const auto &edge : out_edges) expand_pair(edge, edge.To());
       }
       if (self_.common_.direction != EdgeAtom::Direction::OUT) {
         auto in_edges = UnwrapEdgesResult(vertex.InEdges(storage::View::OLD, self_.common_.edge_types)).edges;
-        for (const auto &edge : in_edges) {
-          expand_pair(edge, edge.From());
-          restore_frame_state_after_expansion();
-        }
+        for (const auto &edge : in_edges) expand_pair(edge, edge.From());
       }
     };
 
@@ -1656,14 +1638,14 @@ class SingleSourceShortestPathCursor : public query::plan::Cursor {
       }
 
       // take the next expansion from the queue
-      auto [curr_edge, curr_vertex, curr_acc_path] = to_visit_current_.back();
+      auto expansion = to_visit_current_.back();
       to_visit_current_.pop_back();
 
       // create the frame value for the edges
       auto *pull_memory = context.evaluation_context.memory;
       utils::pmr::vector<TypedValue> edge_list(pull_memory);
-      edge_list.emplace_back(curr_edge);
-      auto last_vertex = curr_vertex;
+      edge_list.emplace_back(expansion.first);
+      auto last_vertex = expansion.second;
       while (true) {
         const EdgeAccessor &last_edge = edge_list.back().ValueEdge();
         last_vertex = last_edge.From() == last_vertex ? last_edge.To() : last_edge.From();
@@ -1675,17 +1657,11 @@ class SingleSourceShortestPathCursor : public query::plan::Cursor {
       }
 
       // expand only if what we've just expanded is less then max depth
-      if (static_cast<int64_t>(edge_list.size()) < upper_bound_) {
-        if (self_.filter_lambda_.accumulated_path_symbol) {
-          MG_ASSERT(curr_acc_path.has_value(), "Expected non-null accumulated path");
-          frame[self_.filter_lambda_.accumulated_path_symbol.value()] = std::move(curr_acc_path.value());
-        }
-        expand_from_vertex(curr_vertex);
-      }
+      if (static_cast<int64_t>(edge_list.size()) < upper_bound_) expand_from_vertex(expansion.second);
 
       if (static_cast<int64_t>(edge_list.size()) < lower_bound_) continue;
 
-      frame[self_.common_.node_symbol] = curr_vertex;
+      frame[self_.common_.node_symbol] = expansion.second;
 
       // place edges on the frame in the correct order
       std::reverse(edge_list.begin(), edge_list.end());
@@ -1717,9 +1693,9 @@ class SingleSourceShortestPathCursor : public query::plan::Cursor {
   // edge because the root does not get expanded from anything.
   // contains visited vertices as well as those scheduled to be visited.
   utils::pmr::unordered_map<VertexAccessor, std::optional<EdgeAccessor>> processed_;
-  // edge, vertex we have yet to visit, for current and next depth and their accumulated paths
-  utils::pmr::vector<std::tuple<EdgeAccessor, VertexAccessor, std::optional<Path>>> to_visit_next_;
-  utils::pmr::vector<std::tuple<EdgeAccessor, VertexAccessor, std::optional<Path>>> to_visit_current_;
+  // edge/vertex pairs we have yet to visit, for current and next depth
+  utils::pmr::vector<std::pair<EdgeAccessor, VertexAccessor>> to_visit_current_;
+  utils::pmr::vector<std::pair<EdgeAccessor, VertexAccessor>> to_visit_next_;
 };
 
 namespace {
@@ -1792,7 +1768,6 @@ class ExpandWeightedShortestPathCursor : public query::plan::Cursor {
 
     ExpressionEvaluator evaluator(&frame, context.symbol_table, context.evaluation_context, context.db_accessor,
                                   storage::View::OLD);
-
     auto create_state = [this](const VertexAccessor &vertex, int64_t depth) {
       return std::make_pair(vertex, upper_bound_set_ ? depth : 0);
     };
@@ -1816,7 +1791,6 @@ class ExpandWeightedShortestPathCursor : public query::plan::Cursor {
       frame[self_.weight_lambda_->inner_node_symbol] = vertex;
       TypedValue next_weight = CalculateNextWeight(self_.weight_lambda_, total_weight, evaluator);
 
-      std::optional<Path> curr_acc_path = std::nullopt;
       if (self_.filter_lambda_.expression) {
         frame[self_.filter_lambda_.inner_edge_symbol] = edge;
         frame[self_.filter_lambda_.inner_node_symbol] = vertex;
@@ -1826,7 +1800,6 @@ class ExpandWeightedShortestPathCursor : public query::plan::Cursor {
           Path &accumulated_path = frame[self_.filter_lambda_.accumulated_path_symbol.value()].ValuePath();
           accumulated_path.Expand(edge);
           accumulated_path.Expand(vertex);
-          curr_acc_path = accumulated_path;
 
           if (self_.filter_lambda_.accumulated_weight_symbol) {
             frame[self_.filter_lambda_.accumulated_weight_symbol.value()] = next_weight;
@@ -1842,32 +1815,24 @@ class ExpandWeightedShortestPathCursor : public query::plan::Cursor {
       if (found_it != total_cost_.end() && (found_it->second.IsNull() || (found_it->second <= next_weight).ValueBool()))
         return;
 
-      pq_.emplace(next_weight, depth + 1, vertex, edge, curr_acc_path);
-    };
-
-    auto restore_frame_state_after_expansion = [this, &frame]() {
-      if (self_.filter_lambda_.accumulated_path_symbol) {
-        frame[self_.filter_lambda_.accumulated_path_symbol.value()].ValuePath().Shrink();
-      }
+      pq_.emplace(next_weight, depth + 1, vertex, edge);
     };
 
     // Populates the priority queue structure with expansions
     // from the given vertex. skips expansions that don't satisfy
     // the "where" condition.
-    auto expand_from_vertex = [this, &expand_pair, &restore_frame_state_after_expansion](
-                                  const VertexAccessor &vertex, const TypedValue &weight, int64_t depth) {
+    auto expand_from_vertex = [this, &expand_pair](const VertexAccessor &vertex, const TypedValue &weight,
+                                                   int64_t depth) {
       if (self_.common_.direction != EdgeAtom::Direction::IN) {
         auto out_edges = UnwrapEdgesResult(vertex.OutEdges(storage::View::OLD, self_.common_.edge_types)).edges;
         for (const auto &edge : out_edges) {
           expand_pair(edge, edge.To(), weight, depth);
-          restore_frame_state_after_expansion();
         }
       }
       if (self_.common_.direction != EdgeAtom::Direction::OUT) {
         auto in_edges = UnwrapEdgesResult(vertex.InEdges(storage::View::OLD, self_.common_.edge_types)).edges;
         for (const auto &edge : in_edges) {
           expand_pair(edge, edge.From(), weight, depth);
-          restore_frame_state_after_expansion();
         }
       }
     };
@@ -1885,12 +1850,9 @@ class ExpandWeightedShortestPathCursor : public query::plan::Cursor {
           // Skip expansion for such nodes.
           if (node.IsNull()) continue;
         }
-
-        std::optional<Path> curr_acc_path;
         if (self_.filter_lambda_.accumulated_path_symbol) {
           // Add initial vertex of path to the accumulated path
-          curr_acc_path = Path(vertex);
-          frame[self_.filter_lambda_.accumulated_path_symbol.value()] = curr_acc_path.value();
+          frame[self_.filter_lambda_.accumulated_path_symbol.value()] = Path(vertex);
         }
         if (self_.upper_bound_) {
           upper_bound_ = EvaluateInt(&evaluator, self_.upper_bound_, "Max depth in weighted shortest path expansion");
@@ -1914,7 +1876,7 @@ class ExpandWeightedShortestPathCursor : public query::plan::Cursor {
         total_cost_.clear();
         yielded_vertices_.clear();
 
-        pq_.emplace(current_weight, 0, vertex, std::nullopt, curr_acc_path);
+        pq_.emplace(current_weight, 0, vertex, std::nullopt);
         // We are adding the starting vertex to the set of yielded vertices
         // because we don't want to yield paths that end with the starting
         // vertex.
@@ -1923,7 +1885,7 @@ class ExpandWeightedShortestPathCursor : public query::plan::Cursor {
 
       while (!pq_.empty()) {
         AbortCheck(context);
-        auto [current_weight, current_depth, current_vertex, current_edge, curr_acc_path] = pq_.top();
+        auto [current_weight, current_depth, current_vertex, current_edge] = pq_.top();
         pq_.pop();
 
         auto current_state = create_state(current_vertex, current_depth);
@@ -1936,12 +1898,7 @@ class ExpandWeightedShortestPathCursor : public query::plan::Cursor {
         total_cost_.emplace(current_state, current_weight);
 
         // Expand only if what we've just expanded is less than max depth.
-        if (current_depth < upper_bound_) {
-          if (self_.filter_lambda_.accumulated_path_symbol) {
-            frame[self_.filter_lambda_.accumulated_path_symbol.value()] = std::move(curr_acc_path.value());
-          }
-          expand_from_vertex(current_vertex, current_weight, current_depth);
-        }
+        if (current_depth < upper_bound_) expand_from_vertex(current_vertex, current_weight, current_depth);
 
         // If we yielded a path for a vertex already, make the expansion but
         // don't return the path again.
@@ -1964,12 +1921,12 @@ class ExpandWeightedShortestPathCursor : public query::plan::Cursor {
         // Place destination node on the frame, handle existence flag.
         if (self_.common_.existing_node) {
           const auto &node = frame[self_.common_.node_symbol];
-          if ((node != TypedValue(current_vertex, pull_memory)).ValueBool()) {
+          if ((node != TypedValue(current_vertex, pull_memory)).ValueBool())
             continue;
-          }
-          // Prevent expanding other paths, because we found the
-          // shortest to existing node.
-          ClearQueue();
+          else
+            // Prevent expanding other paths, because we found the
+            // shortest to existing node.
+            ClearQueue();
         } else {
           frame[self_.common_.node_symbol] = current_vertex;
         }
@@ -2022,9 +1979,8 @@ class ExpandWeightedShortestPathCursor : public query::plan::Cursor {
   // Priority queue comparator. Keep lowest weight on top of the queue.
   class PriorityQueueComparator {
    public:
-    bool operator()(
-        const std::tuple<TypedValue, int64_t, VertexAccessor, std::optional<EdgeAccessor>, std::optional<Path>> &lhs,
-        const std::tuple<TypedValue, int64_t, VertexAccessor, std::optional<EdgeAccessor>, std::optional<Path>> &rhs) {
+    bool operator()(const std::tuple<TypedValue, int64_t, VertexAccessor, std::optional<EdgeAccessor>> &lhs,
+                    const std::tuple<TypedValue, int64_t, VertexAccessor, std::optional<EdgeAccessor>> &rhs) {
       const auto &lhs_weight = std::get<0>(lhs);
       const auto &rhs_weight = std::get<0>(rhs);
       // Null defines minimum value for all types
@@ -2041,9 +1997,8 @@ class ExpandWeightedShortestPathCursor : public query::plan::Cursor {
     }
   };
 
-  std::priority_queue<std::tuple<TypedValue, int64_t, VertexAccessor, std::optional<EdgeAccessor>, std::optional<Path>>,
-                      utils::pmr::vector<std::tuple<TypedValue, int64_t, VertexAccessor, std::optional<EdgeAccessor>,
-                                                    std::optional<Path>>>,
+  std::priority_queue<std::tuple<TypedValue, int64_t, VertexAccessor, std::optional<EdgeAccessor>>,
+                      utils::pmr::vector<std::tuple<TypedValue, int64_t, VertexAccessor, std::optional<EdgeAccessor>>>,
                       PriorityQueueComparator>
       pq_;
 
@@ -2069,9 +2024,6 @@ class ExpandAllShortestPathsCursor : public query::plan::Cursor {
 
     ExpressionEvaluator evaluator(&frame, context.symbol_table, context.evaluation_context, context.db_accessor,
                                   storage::View::OLD);
-
-    auto *memory = context.evaluation_context.memory;
-
     auto create_state = [this](const VertexAccessor &vertex, int64_t depth) {
       return std::make_pair(vertex, upper_bound_set_ ? depth : 0);
     };
@@ -2089,7 +2041,6 @@ class ExpandAllShortestPathsCursor : public query::plan::Cursor {
       TypedValue next_weight = CalculateNextWeight(self_.weight_lambda_, total_weight, evaluator);
 
       // If filter expression exists, evaluate filter
-      std::optional<Path> curr_acc_path = std::nullopt;
       if (self_.filter_lambda_.expression) {
         frame[self_.filter_lambda_.inner_edge_symbol] = edge;
         frame[self_.filter_lambda_.inner_node_symbol] = next_vertex;
@@ -2099,7 +2050,6 @@ class ExpandAllShortestPathsCursor : public query::plan::Cursor {
           Path &accumulated_path = frame[self_.filter_lambda_.accumulated_path_symbol.value()].ValuePath();
           accumulated_path.Expand(edge);
           accumulated_path.Expand(next_vertex);
-          curr_acc_path = accumulated_path;
 
           if (self_.filter_lambda_.accumulated_weight_symbol) {
             frame[self_.filter_lambda_.accumulated_weight_symbol.value()] = next_weight;
@@ -2126,20 +2076,14 @@ class ExpandAllShortestPathsCursor : public query::plan::Cursor {
       }
 
       DirectedEdge directed_edge = {edge, direction, next_weight};
-      pq_.emplace(next_weight, depth + 1, next_vertex, directed_edge, curr_acc_path);
-    };
-
-    auto restore_frame_state_after_expansion = [this, &frame]() {
-      if (self_.filter_lambda_.accumulated_path_symbol) {
-        frame[self_.filter_lambda_.accumulated_path_symbol.value()].ValuePath().Shrink();
-      }
+      pq_.emplace(next_weight, depth + 1, next_vertex, directed_edge);
     };
 
     // Populates the priority queue structure with expansions
     // from the given vertex. skips expansions that don't satisfy
     // the "where" condition.
-    auto expand_from_vertex = [this, &expand_vertex, &context, &restore_frame_state_after_expansion](
-                                  const VertexAccessor &vertex, const TypedValue &weight, int64_t depth) {
+    auto expand_from_vertex = [this, &expand_vertex, &context](const VertexAccessor &vertex, const TypedValue &weight,
+                                                               int64_t depth) {
       if (self_.common_.direction != EdgeAtom::Direction::IN) {
         auto out_edges = UnwrapEdgesResult(vertex.OutEdges(storage::View::OLD, self_.common_.edge_types)).edges;
         for (const auto &edge : out_edges) {
@@ -2152,7 +2096,6 @@ class ExpandAllShortestPathsCursor : public query::plan::Cursor {
           }
 #endif
           expand_vertex(edge, EdgeAtom::Direction::OUT, weight, depth);
-          restore_frame_state_after_expansion();
         }
       }
       if (self_.common_.direction != EdgeAtom::Direction::OUT) {
@@ -2167,12 +2110,12 @@ class ExpandAllShortestPathsCursor : public query::plan::Cursor {
           }
 #endif
           expand_vertex(edge, EdgeAtom::Direction::IN, weight, depth);
-          restore_frame_state_after_expansion();
         }
       }
     };
 
     std::optional<VertexAccessor> start_vertex;
+    auto *memory = context.evaluation_context.memory;
 
     auto create_path = [this, &frame, &memory]() {
       auto &current_level = traversal_stack_.back();
@@ -2224,11 +2167,11 @@ class ExpandAllShortestPathsCursor : public query::plan::Cursor {
       return true;
     };
 
-    auto create_DFS_traversal_tree = [this, &context, &memory, &frame, &create_state, &expand_from_vertex]() {
+    auto create_DFS_traversal_tree = [this, &context, &memory, &create_state, &expand_from_vertex]() {
       while (!pq_.empty()) {
         AbortCheck(context);
 
-        auto [current_weight, current_depth, current_vertex, directed_edge, acc_path] = pq_.top();
+        const auto [current_weight, current_depth, current_vertex, directed_edge] = pq_.top();
         pq_.pop();
 
         const auto &[current_edge, direction, weight] = directed_edge;
@@ -2240,10 +2183,6 @@ class ExpandAllShortestPathsCursor : public query::plan::Cursor {
         } else {
           total_cost_.emplace(current_state, current_weight);
           if (current_depth < upper_bound_) {
-            if (self_.filter_lambda_.accumulated_path_symbol) {
-              DMG_ASSERT(acc_path.has_value(), "Path must be already filled in AllShortestPath DFS traversals");
-              frame[self_.filter_lambda_.accumulated_path_symbol.value()] = std::move(acc_path.value());
-            }
             expand_from_vertex(current_vertex, current_weight, current_depth);
           }
         }
@@ -2376,8 +2315,8 @@ class ExpandAllShortestPathsCursor : public query::plan::Cursor {
   // Priority queue comparator. Keep lowest weight on top of the queue.
   class PriorityQueueComparator {
    public:
-    bool operator()(const std::tuple<TypedValue, int64_t, VertexAccessor, DirectedEdge, std::optional<Path>> &lhs,
-                    const std::tuple<TypedValue, int64_t, VertexAccessor, DirectedEdge, std::optional<Path>> &rhs) {
+    bool operator()(const std::tuple<TypedValue, int64_t, VertexAccessor, DirectedEdge> &lhs,
+                    const std::tuple<TypedValue, int64_t, VertexAccessor, DirectedEdge> &rhs) {
       const auto &lhs_weight = std::get<0>(lhs);
       const auto &rhs_weight = std::get<0>(rhs);
       // Null defines minimum value for all types
@@ -2396,10 +2335,9 @@ class ExpandAllShortestPathsCursor : public query::plan::Cursor {
 
   // Priority queue - core element of the algorithm.
   // Stores: {weight, depth, next vertex, edge and direction}
-  std::priority_queue<
-      std::tuple<TypedValue, int64_t, VertexAccessor, DirectedEdge, std::optional<Path>>,
-      utils::pmr::vector<std::tuple<TypedValue, int64_t, VertexAccessor, DirectedEdge, std::optional<Path>>>,
-      PriorityQueueComparator>
+  std::priority_queue<std::tuple<TypedValue, int64_t, VertexAccessor, DirectedEdge>,
+                      utils::pmr::vector<std::tuple<TypedValue, int64_t, VertexAccessor, DirectedEdge>>,
+                      PriorityQueueComparator>
       pq_;
 
   void ClearQueue() {

src/query/plan/rule_based_planner.hpp

@@ -232,6 +232,7 @@ class RuleBasedPlanner {
           } else if (auto *load_csv = utils::Downcast<query::LoadCsv>(clause)) {
             const auto &row_sym = context.symbol_table->at(*load_csv->row_var_);
             context.bound_symbols.insert(row_sym);
+
             input_op = std::make_unique<plan::LoadCsv>(std::move(input_op), load_csv->file_, load_csv->with_header_,
                                                        load_csv->ignore_bad_, load_csv->delimiter_, load_csv->quote_,
                                                        load_csv->nullif_, row_sym);

src/query/procedure/mg_procedure_impl.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
@@ -187,7 +187,6 @@ template <typename TFunc, typename... Args>
     spdlog::error("Memory allocation error during mg API call: {}", bae.what());
     return mgp_error::MGP_ERROR_UNABLE_TO_ALLOCATE;
   } catch (const memgraph::utils::OutOfMemoryException &oome) {
-    [[maybe_unused]] auto blocker = memgraph::utils::MemoryTracker::OutOfMemoryExceptionBlocker{};
     spdlog::error("Memory limit exceeded during mg API call: {}", oome.what());
     return mgp_error::MGP_ERROR_UNABLE_TO_ALLOCATE;
   } catch (const std::out_of_range &oore) {
@@ -199,12 +198,12 @@ template <typename TFunc, typename... Args>
   } catch (const std::logic_error &lee) {
     spdlog::error("Logic error during mg API call: {}", lee.what());
     return mgp_error::MGP_ERROR_LOGIC_ERROR;
-  } catch (const memgraph::utils::temporal::InvalidArgumentException &e) {
-    spdlog::error("Invalid argument was sent to an mg API call for temporal types: {}", e.what());
-    return mgp_error::MGP_ERROR_INVALID_ARGUMENT;
   } catch (const std::exception &e) {
     spdlog::error("Unexpected error during mg API call: {}", e.what());
     return mgp_error::MGP_ERROR_UNKNOWN_ERROR;
+  } catch (const memgraph::utils::temporal::InvalidArgumentException &e) {
+    spdlog::error("Invalid argument was sent to an mg API call for temporal types: {}", e.what());
+    return mgp_error::MGP_ERROR_INVALID_ARGUMENT;
   } catch (...) {
     spdlog::error("Unexpected error during mg API call");
     return mgp_error::MGP_ERROR_UNKNOWN_ERROR;

src/query/replication_query_handler.hpp

@@ -13,7 +13,6 @@
 
 #include "replication_coordination_glue/role.hpp"
 #include "utils/result.hpp"
-#include "utils/uuid.hpp"
 
 // BEGIN fwd declares
 namespace memgraph::replication {
@@ -24,13 +23,7 @@ struct ReplicationClientConfig;
 
 namespace memgraph::query {
 
-enum class RegisterReplicaError : uint8_t {
-  NAME_EXISTS,
-  ENDPOINT_EXISTS,
-  CONNECTION_FAILED,
-  COULD_NOT_BE_PERSISTED,
-  ERROR_ACCEPTING_MAIN
-};
+enum class RegisterReplicaError : uint8_t { NAME_EXISTS, ENDPOINT_EXISTS, CONNECTION_FAILED, COULD_NOT_BE_PERSISTED };
 enum class UnregisterReplicaResult : uint8_t {
   NOT_MAIN,
   COULD_NOT_BE_PERSISTED,
@@ -46,17 +39,13 @@ struct ReplicationQueryHandler {
   virtual bool SetReplicationRoleMain() = 0;
 
   // as MAIN, become REPLICA
-  virtual bool SetReplicationRoleReplica(const memgraph::replication::ReplicationServerConfig &config,
-                                         const std::optional<utils::UUID> &main_uuid) = 0;
-
-  virtual bool TrySetReplicationRoleReplica(const memgraph::replication::ReplicationServerConfig &config,
-                                            const std::optional<utils::UUID> &main_uuid) = 0;
+  virtual bool SetReplicationRoleReplica(const memgraph::replication::ReplicationServerConfig &config) = 0;
 
   // as MAIN, define and connect to REPLICAs
-  virtual auto TryRegisterReplica(const memgraph::replication::ReplicationClientConfig &config, bool send_swap_uuid)
+  virtual auto TryRegisterReplica(const memgraph::replication::ReplicationClientConfig &config)
       -> utils::BasicResult<RegisterReplicaError> = 0;
 
-  virtual auto RegisterReplica(const memgraph::replication::ReplicationClientConfig &config, bool send_swap_uuid)
+  virtual auto RegisterReplica(const memgraph::replication::ReplicationClientConfig &config)
       -> utils::BasicResult<RegisterReplicaError> = 0;
 
   // as MAIN, remove a REPLICA connection

src/replication/CMakeLists.txt

@@ -21,6 +21,6 @@ target_include_directories(mg-replication PUBLIC include)
 
 find_package(fmt REQUIRED)
 target_link_libraries(mg-replication
-    PUBLIC mg::utils mg::kvstore lib::json mg::rpc mg::slk mg::io mg::repl_coord_glue mg-flags
+    PUBLIC mg::utils mg::kvstore lib::json mg::rpc mg::slk mg::io mg::repl_coord_glue
     PRIVATE fmt::fmt
 )

src/replication/include/replication/replication_client.hpp

@@ -54,7 +54,7 @@ struct ReplicationClient {
             } catch (const rpc::RpcFailedException &) {
               // Nothing to do...wait for a reconnect
               // NOTE: Here we are communicating with the instance connection.
-              //       We don't have access to the underlying client; so the only thing we can do it
+              //       We don't have access to the undelying client; so the only thing we can do it
               //       tell the callback that this is a reconnection and to check the state
               reconnect = true;
             }
@@ -106,9 +106,6 @@ struct ReplicationClient {
   communication::ClientContext rpc_context_;
   rpc::Client rpc_client_;
   std::chrono::seconds replica_check_frequency_;
-  // True only when we are migrating from V1 or V2 to V3 in replication durability
-  // and we want to set replica to listen to main
-  bool try_set_uuid{false};
 
   // TODO: Better, this was the easiest place to put this
   enum class State {

src/replication/include/replication/state.hpp

@@ -21,12 +21,10 @@
 #include "status.hpp"
 #include "utils/result.hpp"
 #include "utils/synchronized.hpp"
-#include "utils/uuid.hpp"
 
 #include <atomic>
 #include <cstdint>
 #include <list>
-#include <optional>
 #include <variant>
 #include <vector>
 
@@ -39,12 +37,7 @@ enum class RegisterReplicaError : uint8_t { NAME_EXISTS, ENDPOINT_EXISTS, COULD_
 
 struct RoleMainData {
   RoleMainData() = default;
-  explicit RoleMainData(ReplicationEpoch e, bool writing_enabled, std::optional<utils::UUID> uuid = std::nullopt)
-      : epoch_(std::move(e)), writing_enabled_(writing_enabled) {
-    if (uuid) {
-      uuid_ = *uuid;
-    }
-  }
+  explicit RoleMainData(ReplicationEpoch e) : epoch_(std::move(e)) {}
   ~RoleMainData() = default;
 
   RoleMainData(RoleMainData const &) = delete;
@@ -54,15 +47,11 @@ struct RoleMainData {
 
   ReplicationEpoch epoch_;
   std::list<ReplicationClient> registered_replicas_{};  // TODO: data race issues
-  utils::UUID uuid_;
-  bool writing_enabled_{false};
 };
 
 struct RoleReplicaData {
   ReplicationServerConfig config;
   std::unique_ptr<ReplicationServer> server;
-  // uuid of main replica is listening to
-  std::optional<utils::UUID> uuid_;
 };
 
 // Global (instance) level object
@@ -92,36 +81,20 @@ struct ReplicationState {
   bool IsMain() const { return GetRole() == replication_coordination_glue::ReplicationRole::MAIN; }
   bool IsReplica() const { return GetRole() == replication_coordination_glue::ReplicationRole::REPLICA; }
 
-  auto IsMainWriteable() const -> bool {
-    if (auto const *main = std::get_if<RoleMainData>(&replication_data_)) {
-      return main->writing_enabled_;
-    }
-    return false;
-  }
-
-  auto EnableWritingOnMain() -> bool {
-    if (auto *main = std::get_if<RoleMainData>(&replication_data_)) {
-      main->writing_enabled_ = true;
-      return true;
-    }
-    return false;
-  }
-
   bool HasDurability() const { return nullptr != durability_; }
 
-  bool TryPersistRoleMain(std::string new_epoch, utils::UUID main_uuid);
-  bool TryPersistRoleReplica(const ReplicationServerConfig &config, const std::optional<utils::UUID> &main_uuid);
+  bool TryPersistRoleMain(std::string new_epoch);
+  bool TryPersistRoleReplica(const ReplicationServerConfig &config);
   bool TryPersistUnregisterReplica(std::string_view name);
-  bool TryPersistRegisteredReplica(const ReplicationClientConfig &config, utils::UUID main_uuid);
+  bool TryPersistRegisteredReplica(const ReplicationClientConfig &config);
 
   // TODO: locked access
   auto ReplicationData() -> ReplicationData_t & { return replication_data_; }
   auto ReplicationData() const -> ReplicationData_t const & { return replication_data_; }
   utils::BasicResult<RegisterReplicaError, ReplicationClient *> RegisterReplica(const ReplicationClientConfig &config);
 
-  bool SetReplicationRoleMain(const utils::UUID &main_uuid);
-  bool SetReplicationRoleReplica(const ReplicationServerConfig &config,
-                                 const std::optional<utils::UUID> &main_uuid = std::nullopt);
+  bool SetReplicationRoleMain();
+  bool SetReplicationRoleReplica(const ReplicationServerConfig &config);
 
  private:
   bool HandleVersionMigration(durability::ReplicationRoleEntry &data) const;

src/replication/include/replication/status.hpp

@@ -31,28 +31,25 @@ constexpr auto *kReplicationReplicaPrefix{"__replication_replica:"};  // introdu
 
 enum class DurabilityVersion : uint8_t {
   V1,  // no distinct key for replicas
-  V2,  // epoch, replica prefix introduced
-  V3,  // this version, main uuid introduced
+  V2,  // this version, epoch, replica prefix introduced
 };
 
 // fragment of key: "__replication_role"
 struct MainRole {
   ReplicationEpoch epoch{};
-  std::optional<utils::UUID> main_uuid{};
   friend bool operator==(MainRole const &, MainRole const &) = default;
 };
 
 // fragment of key: "__replication_role"
 struct ReplicaRole {
   ReplicationServerConfig config{};
-  std::optional<utils::UUID> main_uuid{};
   friend bool operator==(ReplicaRole const &, ReplicaRole const &) = default;
 };
 
 // from key: "__replication_role"
 struct ReplicationRoleEntry {
   DurabilityVersion version =
-      DurabilityVersion::V3;  // if not latest then migration required for kReplicationReplicaPrefix
+      DurabilityVersion::V2;  // if not latest then migration required for kReplicationReplicaPrefix
   std::variant<MainRole, ReplicaRole> role;
 
   friend bool operator==(ReplicationRoleEntry const &, ReplicationRoleEntry const &) = default;

src/replication/replication_server.cpp

@@ -10,7 +10,7 @@
 // licenses/APL.txt.
 
 #include "replication/replication_server.hpp"
-#include "replication_coordination_glue/handler.hpp"
+#include "replication_coordination_glue/messages.hpp"
 
 namespace memgraph::replication {
 namespace {

src/replication/state.cpp

@@ -10,15 +10,12 @@
 // licenses/APL.txt.
 
 #include "replication/state.hpp"
-#include <optional>
 
-#include "flags/replication.hpp"
 #include "replication/replication_client.hpp"
 #include "replication/replication_server.hpp"
 #include "replication/status.hpp"
 #include "utils/file.hpp"
 #include "utils/result.hpp"
-#include "utils/uuid.hpp"
 #include "utils/variant_helpers.hpp"
 
 constexpr auto kReplicationDirectory = std::string_view{"replication"};
@@ -39,9 +36,9 @@ ReplicationState::ReplicationState(std::optional<std::filesystem::path> durabili
   durability_ = std::make_unique<kvstore::KVStore>(std::move(repl_dir));
   spdlog::info("Replication configuration will be stored and will be automatically restored in case of a crash.");
 
-  auto fetched_replication_data = FetchReplicationData();
-  if (fetched_replication_data.HasError()) {
-    switch (fetched_replication_data.GetError()) {
+  auto replicationData = FetchReplicationData();
+  if (replicationData.HasError()) {
+    switch (replicationData.GetError()) {
       using enum ReplicationState::FetchReplicationError;
       case NOTHING_FETCHED: {
         spdlog::debug("Cannot find data needed for restore replication role in persisted metadata.");
@@ -54,29 +51,15 @@ ReplicationState::ReplicationState(std::optional<std::filesystem::path> durabili
       }
     }
   }
-  auto replication_data = std::move(fetched_replication_data).GetValue();
-#ifdef MG_ENTERPRISE
-  if (FLAGS_coordinator_server_port && std::holds_alternative<RoleReplicaData>(replication_data)) {
-    spdlog::trace("Restarted replication uuid for replica");
-    std::get<RoleReplicaData>(replication_data).uuid_.reset();
-  }
-#endif
-  if (std::holds_alternative<RoleReplicaData>(replication_data)) {
-    auto &replica_uuid = std::get<RoleReplicaData>(replication_data).uuid_;
-    std::string uuid = replica_uuid.has_value() ? std::string(replica_uuid.value()) : "";
-    spdlog::trace("Recovered main's uuid for replica {}", uuid);
-  } else {
-    spdlog::trace("Recovered uuid for main {}", std::string(std::get<RoleMainData>(replication_data).uuid_));
-  }
-  replication_data_ = std::move(replication_data);
+  replication_data_ = std::move(replicationData).GetValue();
 }
 
-bool ReplicationState::TryPersistRoleReplica(const ReplicationServerConfig &config,
-                                             const std::optional<utils::UUID> &main_uuid) {
+bool ReplicationState::TryPersistRoleReplica(const ReplicationServerConfig &config) {
   if (!HasDurability()) return true;
 
-  auto data =
-      durability::ReplicationRoleEntry{.role = durability::ReplicaRole{.config = config, .main_uuid = main_uuid}};
+  auto data = durability::ReplicationRoleEntry{.role = durability::ReplicaRole{
+                                                   .config = config,
+                                               }};
 
   if (!durability_->Put(durability::kReplicationRoleName, nlohmann::json(data).dump())) {
     spdlog::error("Error when saving REPLICA replication role in settings.");
@@ -95,11 +78,11 @@ bool ReplicationState::TryPersistRoleReplica(const ReplicationServerConfig &conf
   return true;
 }
 
-bool ReplicationState::TryPersistRoleMain(std::string new_epoch, utils::UUID main_uuid) {
+bool ReplicationState::TryPersistRoleMain(std::string new_epoch) {
   if (!HasDurability()) return true;
 
-  auto data = durability::ReplicationRoleEntry{
-      .role = durability::MainRole{.epoch = ReplicationEpoch{std::move(new_epoch)}, .main_uuid = main_uuid}};
+  auto data =
+      durability::ReplicationRoleEntry{.role = durability::MainRole{.epoch = ReplicationEpoch{std::move(new_epoch)}}};
 
   if (durability_->Put(durability::kReplicationRoleName, nlohmann::json(data).dump())) {
     role_persisted = RolePersisted::YES;
@@ -145,8 +128,7 @@ auto ReplicationState::FetchReplicationData() -> FetchReplicationResult_t {
     return std::visit(
         utils::Overloaded{
             [&](durability::MainRole &&r) -> FetchReplicationResult_t {
-              auto res = RoleMainData{std::move(r.epoch), false,
-                                      r.main_uuid.has_value() ? r.main_uuid.value() : utils::UUID{}};
+              auto res = RoleMainData{std::move(r.epoch)};
               auto b = durability_->begin(durability::kReplicationReplicaPrefix);
               auto e = durability_->end(durability::kReplicationReplicaPrefix);
               for (; b != e; ++b) {
@@ -161,8 +143,6 @@ auto ReplicationState::FetchReplicationData() -> FetchReplicationResult_t {
                   }
                   // Instance clients
                   res.registered_replicas_.emplace_back(data.config);
-                  // Bump for each replica uuid
-                  res.registered_replicas_.back().try_set_uuid = !r.main_uuid.has_value();
                 } catch (...) {
                   return FetchReplicationError::PARSE_ERROR;
                 }
@@ -170,9 +150,7 @@ auto ReplicationState::FetchReplicationData() -> FetchReplicationResult_t {
               return {std::move(res)};
             },
             [&](durability::ReplicaRole &&r) -> FetchReplicationResult_t {
-              // False positive report for the std::make_unique
-              // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
-              return {RoleReplicaData{r.config, std::make_unique<ReplicationServer>(r.config), r.main_uuid}};
+              return {RoleReplicaData{r.config, std::make_unique<ReplicationServer>(r.config)}};
             },
         },
         std::move(data.role));
@@ -214,29 +192,21 @@ bool ReplicationState::HandleVersionMigration(durability::ReplicationRoleEntry &
       [[fallthrough]];
     }
     case durability::DurabilityVersion::V2: {
-      if (std::holds_alternative<durability::MainRole>(data.role)) {
-        auto &main = std::get<durability::MainRole>(data.role);
-        main.main_uuid = utils::UUID{};
-      }
-      data.version = durability::DurabilityVersion::V3;
-      break;
-    }
-    case durability::DurabilityVersion::V3: {
-      // do nothing - add code if V4 ever happens
+      // do nothing - add code if V3 ever happens
       break;
     }
   }
   return true;
 }
 
-bool ReplicationState::TryPersistRegisteredReplica(const ReplicationClientConfig &config, utils::UUID main_uuid) {
+bool ReplicationState::TryPersistRegisteredReplica(const ReplicationClientConfig &config) {
   if (!HasDurability()) return true;
 
   // If any replicas are persisted then Role must be persisted
   if (role_persisted != RolePersisted::YES) {
     DMG_ASSERT(IsMain(), "MAIN is expected");
     auto epoch_str = std::string(std::get<RoleMainData>(replication_data_).epoch_.id());
-    if (!TryPersistRoleMain(std::move(epoch_str), main_uuid)) return false;
+    if (!TryPersistRoleMain(std::move(epoch_str))) return false;
   }
 
   auto data = durability::ReplicationReplicaEntry{.config = config};
@@ -247,28 +217,22 @@ bool ReplicationState::TryPersistRegisteredReplica(const ReplicationClientConfig
   return false;
 }
 
-bool ReplicationState::SetReplicationRoleMain(const utils::UUID &main_uuid) {
+bool ReplicationState::SetReplicationRoleMain() {
   auto new_epoch = utils::GenerateUUID();
 
-  if (!TryPersistRoleMain(new_epoch, main_uuid)) {
+  if (!TryPersistRoleMain(new_epoch)) {
     return false;
   }
-
-  replication_data_ = RoleMainData{ReplicationEpoch{new_epoch}, true, main_uuid};
+  replication_data_ = RoleMainData{ReplicationEpoch{new_epoch}};
 
   return true;
 }
 
-bool ReplicationState::SetReplicationRoleReplica(const ReplicationServerConfig &config,
-                                                 const std::optional<utils::UUID> &main_uuid) {
-  // False positive report for the std::make_unique
-  // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
-  if (!TryPersistRoleReplica(config, main_uuid)) {
+bool ReplicationState::SetReplicationRoleReplica(const ReplicationServerConfig &config) {
+  if (!TryPersistRoleReplica(config)) {
     return false;
   }
-  // False positive report for the std::make_unique
-  // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
-  replication_data_ = RoleReplicaData{config, std::make_unique<ReplicationServer>(config), std::nullopt};
+  replication_data_ = RoleReplicaData{config, std::make_unique<ReplicationServer>(config)};
   return true;
 }
 
@@ -300,7 +264,7 @@ utils::BasicResult<RegisterReplicaError, ReplicationClient *> ReplicationState::
     }
 
     // Durability
-    if (!TryPersistRegisteredReplica(config, mainData.uuid_)) {
+    if (!TryPersistRegisteredReplica(config)) {
       return RegisterReplicaError::COULD_NOT_BE_PERSISTED;
     }