Add unreachable replica state

.clang-format

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

.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`).
@@ -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"

src/coordination/CMakeLists.txt

@@ -10,12 +10,12 @@ target_sources(mg-coordination
         include/coordination/coordinator_exceptions.hpp
         include/coordination/coordinator_slk.hpp
         include/coordination/coordinator_instance.hpp
+        include/coordination/coordinator_cluster_config.hpp
         include/coordination/coordinator_handlers.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/coordination/raft_instance.hpp
 
         include/nuraft/coordinator_log_store.hpp
         include/nuraft/coordinator_state_machine.hpp
@@ -29,7 +29,7 @@ target_sources(mg-coordination
         coordinator_handlers.cpp
         coordinator_instance.cpp
         replication_instance.cpp
-        raft_state.cpp
+        raft_instance.cpp
 
         coordinator_log_store.cpp
         coordinator_state_machine.cpp

src/coordination/coordinator_client.cpp

@@ -17,7 +17,6 @@
 #include "coordination/coordinator_config.hpp"
 #include "coordination/coordinator_rpc.hpp"
 #include "replication_coordination_glue/messages.hpp"
-#include "utils/result.hpp"
 
 namespace memgraph::coordination {
 
@@ -42,25 +41,16 @@ CoordinatorClient::CoordinatorClient(CoordinatorInstance *coord_instance, Coordi
 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());
@@ -131,45 +121,5 @@ auto CoordinatorClient::SendSwapMainUUIDRpc(const utils::UUID &uuid) const -> bo
   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_handlers.cpp

@@ -39,24 +39,6 @@ void CoordinatorHandlers::Register(memgraph::coordination::CoordinatorServer &se
         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,
@@ -80,6 +62,12 @@ void CoordinatorHandlers::DemoteMainToReplicaHandler(replication::ReplicationHan
                                                      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);
 
@@ -89,18 +77,11 @@ void CoordinatorHandlers::DemoteMainToReplicaHandler(replication::ReplicationHan
 
   if (!replication_handler.SetReplicationRoleReplica(clients_config, std::nullopt)) {
     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,
@@ -161,58 +142,9 @@ void CoordinatorHandlers::PromoteReplicaToMainHandler(replication::ReplicationHa
       }
     }
   }
-  spdlog::info("Promote replica to main was success {}", std::string(req.main_uuid_));
+  spdlog::error(fmt::format("FICO : 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

@@ -17,7 +17,6 @@
 #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>
@@ -28,103 +27,127 @@ 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;
-        });
+    : self_([this] { std::ranges::for_each(repl_instances_, &ReplicationInstance::StartFrequentCheck); },
+            [this] { std::ranges::for_each(repl_instances_, &ReplicationInstance::StopFrequentCheck); }) {
+  auto find_instance = [](CoordinatorInstance *coord_instance,
+                          std::string_view instance_name) -> ReplicationInstance & {
+    auto instance = std::ranges::find_if(
+        coord_instance->repl_instances_,
+        [instance_name](ReplicationInstance const &instance) { return instance.InstanceName() == instance_name; });
 
-    MG_ASSERT(repl_instance != self->repl_instances_.end(), "Instance {} not found during callback!",
-              repl_instance_name);
-    return *repl_instance;
+    MG_ASSERT(instance != coord_instance->repl_instances_.end(), "Instance {} not found during callback!",
+              instance_name);
+    return *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);
+  replica_succ_cb_ = [find_instance](CoordinatorInstance *coord_instance, std::string_view instance_name) -> void {
+    auto lock = std::lock_guard{coord_instance->coord_instance_lock_};
+    spdlog::trace("Instance {} performing replica successful callback", instance_name);
+    find_instance(coord_instance, instance_name).OnSuccessPing();
+  };
 
-    // 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());
+  replica_fail_cb_ = [find_instance](CoordinatorInstance *coord_instance, std::string_view instance_name) -> void {
+    auto lock = std::lock_guard{coord_instance->coord_instance_lock_};
+    spdlog::trace("Instance {} performing replica failure callback", instance_name);
+    find_instance(coord_instance, instance_name).OnFailPing();
+  };
+
+  main_succ_cb_ = [find_instance](CoordinatorInstance *coord_instance, std::string_view instance_name) -> void {
+    auto lock = std::lock_guard{coord_instance->coord_instance_lock_};
+    spdlog::trace("Instance {} performing main successful callback", instance_name);
+
+    auto &instance = find_instance(coord_instance, instance_name);
+
+    if (instance.IsAlive()) {
+      instance.OnSuccessPing();
       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();
+    bool const is_latest_main = !coord_instance->ClusterHasAliveMain_();
+    if (is_latest_main) {
+      spdlog::info("Instance {} is the latest main", instance_name);
+      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);
+    bool const demoted = instance.DemoteToReplica(coord_instance->replica_succ_cb_, coord_instance->replica_fail_cb_);
+    if (demoted) {
+      instance.OnSuccessPing();
+      spdlog::info("Instance {} demoted to replica", 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;
+      spdlog::error("Instance {} failed to become replica", instance_name);
     }
   };
 
-  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");
+  main_fail_cb_ = [find_instance](CoordinatorInstance *coord_instance, std::string_view instance_name) -> void {
+    auto lock = std::lock_guard{coord_instance->coord_instance_lock_};
+    spdlog::trace("Instance {} performing main failure callback", instance_name);
+    find_instance(coord_instance, instance_name).OnFailPing();
 
-    if (!repl_instance.IsAlive() && self->GetMainUUID() == repl_instance_uuid.value()) {
+    if (!coord_instance->ClusterHasAliveMain_()) {
       spdlog::info("Cluster without main instance, trying automatic failover");
-      self->TryFailover();  // TODO: (andi) Initiate failover
+      coord_instance->TryFailover();
     }
   };
 }
 
+auto CoordinatorInstance::ClusterHasAliveMain_() const -> bool {
+  auto const alive_main = [](ReplicationInstance const &instance) { return instance.IsMain() && instance.IsAlive(); };
+  return std::ranges::any_of(repl_instances_, alive_main);
+}
+
+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 chosen_replica_instance = ranges::begin(alive_replicas);
+
+  chosen_replica_instance->PauseFrequentCheck();
+  utils::OnScopeExit scope_exit{[&chosen_replica_instance] { chosen_replica_instance->ResumeFrequentCheck(); }};
+
+  auto const potential_new_main_uuid = utils::UUID{};
+
+  auto const is_not_chosen_replica_instance = [&chosen_replica_instance](ReplicationInstance &instance) {
+    return instance != *chosen_replica_instance;
+  };
+
+  // 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_chosen_replica_instance)) {
+    if (!other_replica_instance.SendSwapAndUpdateUUID(potential_new_main_uuid)) {
+      spdlog::error(fmt::format("Failed to swap uuid for instance {} which is alive, aborting failover",
+                                other_replica_instance.InstanceName()));
+      return;
+    }
+  }
+
+  std::vector<ReplClientInfo> repl_clients_info;
+  repl_clients_info.reserve(repl_instances_.size() - 1);
+  std::ranges::transform(repl_instances_ | ranges::views::filter(is_not_chosen_replica_instance),
+                         std::back_inserter(repl_clients_info), &ReplicationInstance::ReplicationClientInfo);
+
+  if (!chosen_replica_instance->PromoteToMain(potential_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;
+  }
+  chosen_replica_instance->SetNewMainUUID(potential_new_main_uuid);
+  main_uuid_ = potential_new_main_uuid;
+
+  spdlog::info("Failover successful! Instance {} promoted to main.", chosen_replica_instance->InstanceName());
+}
+
 auto CoordinatorInstance::ShowInstances() const -> std::vector<InstanceStatus> {
-  auto const coord_instances = raft_state_.GetAllCoordinators();
+  auto const coord_instances = self_.GetAllCoordinators();
+
+  std::vector<InstanceStatus> instances_status;
+  instances_status.reserve(repl_instances_.size() + coord_instances.size());
 
   auto const stringify_repl_role = [](ReplicationInstance const &instance) -> std::string {
     if (!instance.IsAlive()) return "unknown";
@@ -147,7 +170,8 @@ auto CoordinatorInstance::ShowInstances() const -> std::vector<InstanceStatus> {
                                 // CoordinatorState to every instance, we can be smarter about this using our RPC.
   };
 
-  auto instances_status = utils::fmap(coord_instance_to_status, coord_instances);
+  std::ranges::transform(coord_instances, std::back_inserter(instances_status), coord_instance_to_status);
+
   {
     auto lock = std::shared_lock{coord_instance_lock_};
     std::ranges::transform(repl_instances_, std::back_inserter(instances_status), repl_instance_to_status);
@@ -156,60 +180,11 @@ auto CoordinatorInstance::ShowInstances() const -> std::vector<InstanceStatus> {
   return instances_status;
 }
 
-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());
-}
-
 // 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_};
 
-  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;
   };
@@ -224,31 +199,34 @@ auto CoordinatorInstance::SetReplicationInstanceToMain(std::string instance_name
   new_main->PauseFrequentCheck();
   utils::OnScopeExit scope_exit{[&new_main] { new_main->ResumeFrequentCheck(); }};
 
+  ReplicationClientsInfo repl_clients_info;
+  repl_clients_info.reserve(repl_instances_.size() - 1);
+
   auto const is_not_new_main = [&instance_name](ReplicationInstance const &instance) {
     return instance.InstanceName() != instance_name;
   };
 
-  auto const new_main_uuid = utils::UUID{};
+  auto potential_new_main_uuid = utils::UUID{};
+  spdlog::trace("Generated potential new main uuid");
 
   for (auto &other_instance : repl_instances_ | ranges::views::filter(is_not_new_main)) {
-    if (!other_instance.SendSwapAndUpdateUUID(new_main_uuid)) {
+    if (!other_instance.SendSwapAndUpdateUUID(potential_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);
+                         std::back_inserter(repl_clients_info),
+                         [](const ReplicationInstance &instance) { return instance.ReplicationClientInfo(); });
 
-  if (!new_main->PromoteToMain(new_main_uuid, std::move(repl_clients_info), main_succ_cb_, main_fail_cb_)) {
+  if (!new_main->PromoteToMain(potential_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);
+  new_main->SetNewMainUUID(potential_new_main_uuid);
+  main_uuid_ = potential_new_main_uuid;
   spdlog::info("Instance {} promoted to main", instance_name);
   return SetInstanceToMainCoordinatorStatus::SUCCESS;
 }
@@ -257,10 +235,8 @@ auto CoordinatorInstance::RegisterReplicationInstance(CoordinatorClientConfig co
     -> 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;
+  auto const name_matches = [&config](ReplicationInstance const &instance) {
+    return instance.InstanceName() == config.instance_name;
   };
 
   if (std::ranges::any_of(repl_instances_, name_matches)) {
@@ -275,21 +251,20 @@ auto CoordinatorInstance::RegisterReplicationInstance(CoordinatorClientConfig co
     return RegisterInstanceCoordinatorStatus::ENDPOINT_EXISTS;
   }
 
-  if (!raft_state_.RequestLeadership()) {
+  if (!self_.RequestLeadership()) {
     return RegisterInstanceCoordinatorStatus::NOT_LEADER;
   }
 
-  auto const res = raft_state_.AppendRegisterReplicationInstance(instance_name);
+  auto const res = self_.AppendRegisterReplicationInstance(config.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 "
+        "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);
+  spdlog::info("Request for registering instance {} accepted", config.instance_name);
   try {
     repl_instances_.emplace_back(this, std::move(config), replica_succ_cb_, replica_fail_cb_);
   } catch (CoordinatorRegisterInstanceException const &) {
@@ -297,52 +272,18 @@ auto CoordinatorInstance::RegisterReplicationInstance(CoordinatorClientConfig co
   }
 
   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());
+    spdlog::error("Failed to register instance {} with error code {}", config.instance_name, res->get_result_code());
     return RegisterInstanceCoordinatorStatus::RAFT_COULD_NOT_APPEND;
   }
 
-  spdlog::info("Instance {} registered", instance_name);
+  spdlog::info("Instance {} registered", config.instance_name);
   return RegisterInstanceCoordinatorStatus::SUCCESS;
 }
 
-auto CoordinatorInstance::UnregisterReplicationInstance(std::string instance_name)
-    -> UnregisterInstanceCoordinatorStatus {
-  auto lock = std::lock_guard{coord_instance_lock_};
-
-  auto const name_matches = [&instance_name](ReplicationInstance const &instance) {
-    return instance.InstanceName() == instance_name;
-  };
-
-  auto inst_to_remove = std::ranges::find_if(repl_instances_, name_matches);
-  if (inst_to_remove == repl_instances_.end()) {
-    return UnregisterInstanceCoordinatorStatus::NO_INSTANCE_WITH_NAME;
-  }
-
-  if (inst_to_remove->IsMain() && inst_to_remove->IsAlive()) {
-    return UnregisterInstanceCoordinatorStatus::IS_MAIN;
-  }
-
-  inst_to_remove->StopFrequentCheck();
-  auto curr_main = std::ranges::find_if(repl_instances_, &ReplicationInstance::IsMain);
-  MG_ASSERT(curr_main != repl_instances_.end(), "There must be a main instance when unregistering a replica");
-  if (!curr_main->SendUnregisterReplicaRpc(instance_name)) {
-    inst_to_remove->StartFrequentCheck();
-    return UnregisterInstanceCoordinatorStatus::RPC_FAILED;
-  }
-  std::erase_if(repl_instances_, name_matches);
-
-  return UnregisterInstanceCoordinatorStatus::SUCCESS;
-}
-
 auto CoordinatorInstance::AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address)
     -> void {
-  raft_state_.AddCoordinatorInstance(raft_server_id, raft_port, std::move(raft_address));
+  self_.AddCoordinatorInstance(raft_server_id, raft_port, std::move(raft_address));
 }
 
-auto CoordinatorInstance::GetMainUUID() const -> utils::UUID { return main_uuid_; }
-
-// TODO: (andi) Add to the RAFT log.
-auto CoordinatorInstance::SetMainUUID(utils::UUID new_uuid) -> void { main_uuid_ = new_uuid; }
-
 }  // namespace memgraph::coordination
 #endif

src/coordination/coordinator_log_store.cpp

@@ -14,7 +14,6 @@
 #include "nuraft/coordinator_log_store.hpp"
 
 #include "coordination/coordinator_exceptions.hpp"
-#include "utils/logging.hpp"
 
 namespace memgraph::coordination {
 
@@ -133,7 +132,7 @@ ptr<buffer> CoordinatorLogStore::pack(uint64_t index, int32 cnt) {
       auto lock = std::lock_guard{logs_lock_};
       le = logs_[i];
     }
-    MG_ASSERT(le.get(), "Could not find log entry at index {}", i);
+    assert(le.get());
     auto buf = le->serialize();
     size_total += buf->size();
     logs.push_back(buf);
@@ -144,8 +143,9 @@ ptr<buffer> CoordinatorLogStore::pack(uint64_t index, int32 cnt) {
   buf_out->put((int32)cnt);
 
   for (auto &entry : logs) {
-    buf_out->put(static_cast<int32>(entry->size()));
-    buf_out->put(*entry);
+    auto &bb = entry;  // TODO: (andi) This smells like not needed
+    buf_out->put(static_cast<int32>(bb->size()));
+    buf_out->put(*bb);
   }
   return buf_out;
 }

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);
 }
@@ -152,7 +86,6 @@ void Load(memgraph::coordination::PromoteReplicaToMainReq *self, memgraph::slk::
   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 +102,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_state.cpp

@@ -56,20 +56,6 @@ auto CoordinatorState::RegisterReplicationInstance(CoordinatorClientConfig confi
       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_),
             "Coordinator cannot register replica since variant holds wrong alternative");

src/coordination/include/coordination/coordinator_client.hpp

@@ -11,14 +11,12 @@
 
 #pragma once
 
+#include "utils/uuid.hpp"
 #ifdef MG_ENTERPRISE
 
 #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 {
 
@@ -48,28 +46,17 @@ class CoordinatorClient {
   auto SocketAddress() const -> std::string;
 
   [[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,6 +64,7 @@ class CoordinatorClient {
  private:
   utils::Scheduler instance_checker_;
 
+  // TODO: (andi) Pimpl?
   communication::ClientContext rpc_context_;
   mutable rpc::Client rpc_client_;
 

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

@@ -72,16 +72,5 @@ class RaftCouldNotFindEntryException final : public utils::BasicException {
   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

@@ -33,14 +33,6 @@ class CoordinatorHandlers {
                                          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

@@ -15,7 +15,7 @@
 
 #include "coordination/coordinator_server.hpp"
 #include "coordination/instance_status.hpp"
-#include "coordination/raft_state.hpp"
+#include "coordination/raft_instance.hpp"
 #include "coordination/register_main_replica_coordinator_status.hpp"
 #include "coordination/replication_instance.hpp"
 #include "utils/rw_lock.hpp"
@@ -30,7 +30,6 @@ class CoordinatorInstance {
   CoordinatorInstance();
 
   [[nodiscard]] auto RegisterReplicationInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus;
-  [[nodiscard]] auto UnregisterReplicationInstance(std::string instance_name) -> UnregisterInstanceCoordinatorStatus;
 
   [[nodiscard]] auto SetReplicationInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus;
 
@@ -40,11 +39,9 @@ class CoordinatorInstance {
 
   auto AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address) -> void;
 
-  auto GetMainUUID() const -> utils::UUID;
-
-  auto SetMainUUID(utils::UUID new_uuid) -> void;
-
  private:
+  auto ClusterHasAliveMain_() const -> bool;
+
   HealthCheckCallback main_succ_cb_, main_fail_cb_, replica_succ_cb_, replica_fail_cb_;
 
   // NOTE: Must be std::list because we rely on pointer stability
@@ -53,7 +50,7 @@ class CoordinatorInstance {
 
   utils::UUID main_uuid_;
 
-  RaftState raft_state_;
+  RaftInstance self_;
 };
 
 }  // namespace memgraph::coordination

src/coordination/include/coordination/coordinator_rpc.hpp

@@ -82,85 +82,6 @@ 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
@@ -178,19 +99,6 @@ void Load(memgraph::coordination::DemoteMainToReplicaRes *self, memgraph::slk::R
 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
 

src/coordination/include/coordination/coordinator_state.hpp

@@ -34,7 +34,6 @@ class CoordinatorState {
   CoordinatorState &operator=(CoordinatorState &&) noexcept = delete;
 
   [[nodiscard]] auto RegisterReplicationInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus;
-  [[nodiscard]] auto UnregisterReplicationInstance(std::string instance_name) -> UnregisterInstanceCoordinatorStatus;
 
   [[nodiscard]] auto SetReplicationInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus;
 

src/coordination/include/coordination/raft_instance.hpp

@@ -32,22 +32,15 @@ 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;
-
+class RaftInstance {
  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();
+  RaftInstance(BecomeLeaderCb become_leader_cb, BecomeFollowerCb become_follower_cb);
 
-  static auto MakeRaftState(BecomeLeaderCb become_leader_cb, BecomeFollowerCb become_follower_cb) -> RaftState;
+  RaftInstance(RaftInstance const &other) = delete;
+  RaftInstance &operator=(RaftInstance const &other) = delete;
+  RaftInstance(RaftInstance &&other) noexcept = delete;
+  RaftInstance &operator=(RaftInstance &&other) noexcept = delete;
+  ~RaftInstance();
 
   auto InstanceName() const -> std::string;
   auto RaftSocketAddress() const -> std::string;
@@ -60,17 +53,18 @@ class RaftState {
 
   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_;
-
+ private:
   ptr<state_machine> state_machine_;
   ptr<state_mgr> state_manager_;
   ptr<raft_server> raft_server_;
   ptr<logger> logger_;
   raft_launcher launcher_;
 
+  // TODO: (andi) I think variables below can be abstracted
+  uint32_t raft_server_id_;
+  uint32_t raft_port_;
+  std::string raft_address_;
+
   BecomeLeaderCb become_leader_cb_;
   BecomeFollowerCb become_follower_cb_;
 };

src/coordination/include/coordination/register_main_replica_coordinator_status.hpp

@@ -28,18 +28,8 @@ enum class RegisterInstanceCoordinatorStatus : uint8_t {
   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,

src/coordination/include/coordination/replication_instance.hpp

@@ -14,11 +14,11 @@
 #ifdef MG_ENTERPRISE
 
 #include "coordination/coordinator_client.hpp"
+#include "coordination/coordinator_cluster_config.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 {
@@ -38,9 +38,6 @@ class ReplicationInstance {
 
   auto OnSuccessPing() -> void;
   auto OnFailPing() -> bool;
-  auto IsReadyForUUIDPing() -> bool;
-
-  void UpdateReplicaLastResponseUUID();
 
   auto IsAlive() const -> bool;
 
@@ -61,27 +58,17 @@ class ReplicationInstance {
 
   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 SendSwapAndUpdateUUID(const utils::UUID &main_uuid) -> bool;
   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> &;
+  void SetNewMainUUID(const std::optional<utils::UUID> &main_uuid = std::nullopt);
+  auto GetMainUUID() -> 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

src/coordination/raft_instance.cpp

@@ -11,7 +11,7 @@
 
 #ifdef MG_ENTERPRISE
 
-#include "coordination/raft_state.hpp"
+#include "coordination/raft_instance.hpp"
 
 #include "coordination/coordinator_exceptions.hpp"
 #include "nuraft/coordinator_state_machine.hpp"
@@ -31,19 +31,19 @@ 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),
+RaftInstance::RaftInstance(BecomeLeaderCb become_leader_cb, BecomeFollowerCb become_follower_cb)
+    : raft_server_id_(FLAGS_raft_server_id),
+      raft_port_(FLAGS_raft_server_port),
+      raft_address_("127.0.0.1"),
       become_leader_cb_(std::move(become_leader_cb)),
-      become_follower_cb_(std::move(become_follower_cb)) {}
+      become_follower_cb_(std::move(become_follower_cb)) {
+  auto raft_endpoint = raft_address_ + ":" + std::to_string(raft_port_);
+  state_manager_ = cs_new<CoordinatorStateManager>(raft_server_id_, raft_endpoint);
+  state_machine_ = cs_new<CoordinatorStateMachine>();
+  logger_ = nullptr;
+
+  // TODO: (andi) Maybe params file
 
-auto RaftState::InitRaftServer() -> void {
   asio_service::options asio_opts;
   asio_opts.thread_pool_size_ = 1;  // TODO: (andi) Improve this
 
@@ -70,49 +70,33 @@ auto RaftState::InitRaftServer() -> void {
     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);
+  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_);
+    throw RaftServerStartException("Failed to launch raft server on {}", raft_endpoint);
   }
 
   auto maybe_stop = utils::ResettableCounter<20>();
-  do {
-    if (raft_server_->is_initialized()) {
-      return;
-    }
+  while (!raft_server_->is_initialized() && !maybe_stop()) {
     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;
+  if (!raft_server_->is_initialized()) {
+    throw RaftServerStartException("Failed to initialize raft server on {}", raft_endpoint);
+  }
+
+  spdlog::info("Raft server started on {}", raft_endpoint);
 }
 
-RaftState::~RaftState() { launcher_.shutdown(); }
+RaftInstance::~RaftInstance() { launcher_.shutdown(); }
 
-auto RaftState::InstanceName() const -> std::string { return "coordinator_" + std::to_string(raft_server_id_); }
+auto RaftInstance::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 RaftInstance::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 RaftInstance::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()) {
@@ -121,17 +105,19 @@ auto RaftState::AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_po
   spdlog::info("Request to add server {} to the cluster accepted", endpoint);
 }
 
-auto RaftState::GetAllCoordinators() const -> std::vector<ptr<srv_config>> {
+auto RaftInstance::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 RaftInstance::IsLeader() const -> bool { return raft_server_->is_leader(); }
 
-auto RaftState::RequestLeadership() -> bool { return raft_server_->is_leader() || raft_server_->request_leadership(); }
+auto RaftInstance::RequestLeadership() -> bool {
+  return raft_server_->is_leader() || raft_server_->request_leadership();
+}
 
-auto RaftState::AppendRegisterReplicationInstance(std::string const &instance) -> ptr<raft_result> {
+auto RaftInstance::AppendRegisterReplicationInstance(std::string const &instance) -> ptr<raft_result> {
   auto new_log = CoordinatorStateMachine::EncodeRegisterReplicationInstance(instance);
   return raft_server_->append_entries({new_log});
 }

src/coordination/replication_instance.cpp

@@ -14,7 +14,6 @@
 #include "coordination/replication_instance.hpp"
 
 #include "replication_coordination_glue/handler.hpp"
-#include "utils/result.hpp"
 
 namespace memgraph::coordination {
 
@@ -35,16 +34,12 @@ auto ReplicationInstance::OnSuccessPing() -> void {
 }
 
 auto ReplicationInstance::OnFailPing() -> bool {
-  auto elapsed_time = std::chrono::system_clock::now() - last_response_time_;
-  is_alive_ = elapsed_time < client_.InstanceDownTimeoutSec();
+  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_;
 }
 
-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_; }
@@ -56,14 +51,13 @@ auto ReplicationInstance::IsMain() const -> bool {
   return replication_role_ == replication_coordination_glue::ReplicationRole::MAIN;
 }
 
-auto ReplicationInstance::PromoteToMain(utils::UUID new_uuid, ReplicationClientsInfo repl_clients_info,
+auto ReplicationInstance::PromoteToMain(utils::UUID uuid, ReplicationClientsInfo repl_clients_info,
                                         HealthCheckCallback main_succ_cb, HealthCheckCallback main_fail_cb) -> bool {
-  if (!client_.SendPromoteReplicaToMainRpc(new_uuid, std::move(repl_clients_info))) {
+  if (!client_.SendPromoteReplicaToMainRpc(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;
@@ -91,48 +85,16 @@ auto ReplicationInstance::ReplicationClientInfo() const -> CoordinatorClientConf
 }
 
 auto ReplicationInstance::GetClient() -> CoordinatorClient & { return client_; }
+void ReplicationInstance::SetNewMainUUID(const std::optional<utils::UUID> &main_uuid) { main_uuid_ = main_uuid; }
+auto ReplicationInstance::GetMainUUID() -> const std::optional<utils::UUID> & { return main_uuid_; }
 
-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()) {
+auto ReplicationInstance::SendSwapAndUpdateUUID(const utils::UUID &main_uuid) -> bool {
+  if (!replication_coordination_glue::SendSwapMainUUIDRpc(client_.RpcClient(), main_uuid)) {
     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);
+  SetNewMainUUID(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

@@ -25,11 +25,6 @@ auto CoordinatorHandler::RegisterReplicationInstance(memgraph::coordination::Coo
   return coordinator_state_.RegisterReplicationInstance(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)
     -> coordination::SetInstanceToMainCoordinatorStatus {
   return coordinator_state_.SetReplicationInstanceToMain(std::move(instance_name));

src/dbms/coordinator_handler.hpp

@@ -28,13 +28,9 @@ 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)
       -> coordination::RegisterInstanceCoordinatorStatus;
 
-  auto UnregisterReplicationInstance(std::string instance_name) -> coordination::UnregisterInstanceCoordinatorStatus;
-
   auto SetReplicationInstanceToMain(std::string instance_name) -> coordination::SetInstanceToMainCoordinatorStatus;
 
   auto ShowInstances() const -> std::vector<coordination::InstanceStatus>;

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"
@@ -159,9 +158,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
 
@@ -420,10 +419,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

@@ -107,7 +107,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 +116,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);
@@ -270,20 +272,6 @@ class DbmsHandler {
   // 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 +587,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

@@ -155,12 +155,6 @@ void InMemoryReplicationHandlers::HeartbeatHandler(dbms::DbmsHandler *dbms_handl
     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()}};
@@ -469,6 +463,7 @@ void InMemoryReplicationHandlers::TimestampHandler(dbms::DbmsHandler *dbms_handl
   slk::Save(res, res_builder);
 }
 
+/////// AF how does this work, does it get all deltas at once or what?
 uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage *storage,
                                                         storage::durability::BaseDecoder *decoder,
                                                         const uint64_t version) {

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/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

@@ -18,12 +18,6 @@ DEFINE_uint32(coordinator_server_port, 0, "Port on which coordinator servers wil
 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

@@ -20,12 +20,6 @@ DECLARE_uint32(coordinator_server_port);
 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/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, UNREACHABLE };
 
   ReplicationQuery() = default;
 
@@ -3071,13 +3071,7 @@ class CoordinatorQuery : public memgraph::query::Query {
   static const utils::TypeInfo kType;
   const utils::TypeInfo &GetTypeInfo() const override { return kType; }
 
-  enum class Action {
-    REGISTER_INSTANCE,
-    UNREGISTER_INSTANCE,
-    SET_INSTANCE_TO_MAIN,
-    SHOW_INSTANCES,
-    ADD_COORDINATOR_INSTANCE
-  };
+  enum class Action { REGISTER_INSTANCE, SET_INSTANCE_TO_MAIN, SHOW_INSTANCES, ADD_COORDINATOR_INSTANCE };
 
   enum class SyncMode { SYNC, ASYNC };
 

src/query/frontend/ast/cypher_main_visitor.cpp

@@ -399,14 +399,6 @@ 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>();
 
@@ -475,10 +467,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*
    */

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

@@ -190,7 +190,6 @@ replicationQuery : setReplicationRole
                  ;
 
 coordinatorQuery : registerInstanceOnCoordinator
-                 | unregisterInstanceOnCoordinator
                  | setInstanceToMain
                  | showInstances
                  | addCoordinatorInstance
@@ -266,7 +265,7 @@ loadCsv : LOAD CSV FROM csvFile ( WITH | NO ) HEADER
          ( NULLIF nullif ) ?
          AS rowVar ;
 
-csvFile : literal | parameter ;
+csvFile : literal ;
 
 delimiter : literal ;
 
@@ -393,8 +392,6 @@ registerReplica : REGISTER REPLICA instanceName ( SYNC | ASYNC )
 
 registerInstanceOnCoordinator : REGISTER INSTANCE instanceName ON coordinatorSocketAddress ( AS ASYNC ) ? WITH replicationSocketAddress ;
 
-unregisterInstanceOnCoordinator : UNREGISTER INSTANCE instanceName ;
-
 setInstanceToMain : SET INSTANCE instanceName TO MAIN ;
 
 raftServerId : literal ;

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

@@ -141,7 +141,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/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, std::nullopt)) {
         throw QueryRuntimeException("Couldn't set role to replica!");
       }
     }
@@ -439,8 +437,8 @@ 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;
+        case storage::replication::ReplicaState::UNREACHABLE:
+          replica.state = ReplicationQuery::ReplicaState::UNREACHABLE;
           break;
       }
 
@@ -462,33 +460,11 @@ 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 RegisterReplicationInstance(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,9 +489,7 @@ 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};
 
@@ -563,8 +537,6 @@ class CoordQueryHandler final : public query::CoordinatorQueryHandler {
       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:
@@ -1113,8 +1085,8 @@ 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");
+            case ReplicationQuery::ReplicaState::UNREACHABLE:
+              typed_replica.emplace_back("unreachable");
               break;
           }
 
@@ -1185,16 +1157,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);
+                                            main_check_frequency, instance_name, sync_mode);
         return std::vector<std::vector<TypedValue>>();
       };
 
@@ -1204,30 +1172,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.");
@@ -1270,13 +1214,17 @@ Callback HandleCoordinatorQuery(CoordinatorQuery *coordinator_query, const Param
       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.raft_socket_address},
+                                         TypedValue{status.coord_socket_address}, TypedValue{status.is_alive},
+                                         TypedValue{status.cluster_role}};
+                               });
+
+        return result;
       };
       return callback;
     }
@@ -3939,9 +3887,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"},
@@ -4406,19 +4352,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 +4541,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

@@ -105,15 +105,10 @@ 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;
-
-  /// @throw QueryRuntimeException if an error ocurred.
-  virtual void UnregisterInstance(std::string const &instance_name) = 0;
+  virtual void RegisterReplicationInstance(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 SetReplicationInstanceToMain(const std::string &instance_name) = 0;

src/query/metadata.cpp

@@ -71,8 +71,6 @@ constexpr std::string_view GetCodeString(const NotificationCode code) {
       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,8 @@ enum class NotificationCode : uint8_t {
   REPLICA_PORT_WARNING,
   REGISTER_REPLICA,
 #ifdef MG_ENTERPRISE
-  REGISTER_COORDINATOR_SERVER,  // TODO: (andi) What is this?
+  REGISTER_COORDINATOR_SERVER,
   ADD_COORDINATOR_INSTANCE,
-  UNREGISTER_INSTANCE,
 #endif
   SET_REPLICA,
   START_STREAM,

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

@@ -49,9 +49,6 @@ struct ReplicationQueryHandler {
   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;
-
   // as MAIN, define and connect to REPLICAs
   virtual auto TryRegisterReplica(const memgraph::replication::ReplicationClientConfig &config, bool send_swap_uuid)
       -> utils::BasicResult<RegisterReplicaError> = 0;

src/replication/include/replication/state.hpp

@@ -39,8 +39,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) {
+  explicit RoleMainData(ReplicationEpoch e, std::optional<utils::UUID> uuid = std::nullopt) : epoch_(std::move(e)) {
     if (uuid) {
       uuid_ = *uuid;
     }
@@ -55,7 +54,6 @@ struct RoleMainData {
   ReplicationEpoch epoch_;
   std::list<ReplicationClient> registered_replicas_{};  // TODO: data race issues
   utils::UUID uuid_;
-  bool writing_enabled_{false};
 };
 
 struct RoleReplicaData {
@@ -92,21 +90,6 @@ 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);

src/replication/state.cpp

@@ -57,17 +57,9 @@ 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);
 }
 
@@ -145,8 +137,8 @@ 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), r.main_uuid.has_value() ? r.main_uuid.value() : utils::UUID{}};
               auto b = durability_->begin(durability::kReplicationReplicaPrefix);
               auto e = durability_->end(durability::kReplicationReplicaPrefix);
               for (; b != e; ++b) {
@@ -254,7 +246,7 @@ bool ReplicationState::SetReplicationRoleMain(const utils::UUID &main_uuid) {
     return false;
   }
 
-  replication_data_ = RoleMainData{ReplicationEpoch{new_epoch}, true, main_uuid};
+  replication_data_ = RoleMainData{ReplicationEpoch{new_epoch}, main_uuid};
 
   return true;
 }

src/replication_handler/include/replication_handler/replication_handler.hpp

@@ -12,9 +12,7 @@
 
 #include "auth/auth.hpp"
 #include "dbms/dbms_handler.hpp"
-#include "flags/experimental.hpp"
 #include "replication/include/replication/state.hpp"
-#include "replication_handler/system_replication.hpp"
 #include "replication_handler/system_rpc.hpp"
 #include "utils/result.hpp"
 
@@ -24,8 +22,8 @@ inline std::optional<query::RegisterReplicaError> HandleRegisterReplicaStatus(
     utils::BasicResult<replication::RegisterReplicaError, replication::ReplicationClient *> &instance_client);
 
 #ifdef MG_ENTERPRISE
-void StartReplicaClient(replication::ReplicationClient &client, system::System &system, dbms::DbmsHandler &dbms_handler,
-                        utils::UUID main_uuid, auth::SynchedAuth &auth);
+void StartReplicaClient(replication::ReplicationClient &client, dbms::DbmsHandler &dbms_handler, utils::UUID main_uuid,
+                        system::System *system, auth::SynchedAuth &auth);
 #else
 void StartReplicaClient(replication::ReplicationClient &client, dbms::DbmsHandler &dbms_handler, utils::UUID main_uuid);
 #endif
@@ -35,8 +33,8 @@ void StartReplicaClient(replication::ReplicationClient &client, dbms::DbmsHandle
 // When being called by interpreter no need to gain lock, it should already be under a system transaction
 // But concurrently the FrequentCheck is running and will need to lock before reading last_committed_system_timestamp_
 template <bool REQUIRE_LOCK = false>
-void SystemRestore(replication::ReplicationClient &client, system::System &system, dbms::DbmsHandler &dbms_handler,
-                   const utils::UUID &main_uuid, auth::SynchedAuth &auth) {
+void SystemRestore(replication::ReplicationClient &client, dbms::DbmsHandler &dbms_handler,
+                   const utils::UUID &main_uuid, system::System *system, auth::SynchedAuth &auth) {
   // Check if system is up to date
   if (client.state_.WithLock(
           [](auto &state) { return state == memgraph::replication::ReplicationClient::State::READY; }))
@@ -44,10 +42,6 @@ void SystemRestore(replication::ReplicationClient &client, system::System &syste
 
   // Try to recover...
   {
-    using enum memgraph::flags::Experiments;
-    bool full_system_replication =
-        flags::AreExperimentsEnabled(SYSTEM_REPLICATION) && license::global_license_checker.IsEnterpriseValidFast();
-    // We still need to system replicate
     struct DbInfo {
       std::vector<storage::SalientConfig> configs;
       uint64_t last_committed_timestamp;
@@ -55,25 +49,25 @@ void SystemRestore(replication::ReplicationClient &client, system::System &syste
     DbInfo db_info = std::invoke([&] {
       auto guard = std::invoke([&]() -> std::optional<memgraph::system::TransactionGuard> {
         if constexpr (REQUIRE_LOCK) {
-          return system.GenTransactionGuard();
+          return system->GenTransactionGuard();
         }
         return std::nullopt;
       });
 
-      if (full_system_replication) {
+      if (license::global_license_checker.IsEnterpriseValidFast()) {
         auto configs = std::vector<storage::SalientConfig>{};
         dbms_handler.ForEach([&configs](dbms::DatabaseAccess acc) { configs.emplace_back(acc->config().salient); });
         // TODO: This is `SystemRestore` maybe DbInfo is incorrect as it will need Auth also
-        return DbInfo{configs, system.LastCommittedSystemTimestamp()};
+        return DbInfo{configs, system->LastCommittedSystemTimestamp()};
       }
 
       // No license -> send only default config
-      return DbInfo{{dbms_handler.Get()->config().salient}, system.LastCommittedSystemTimestamp()};
+      return DbInfo{{dbms_handler.Get()->config().salient}, system->LastCommittedSystemTimestamp()};
     });
     try {
       auto stream = std::invoke([&]() {
         // Handle only default database is no license
-        if (!full_system_replication) {
+        if (!license::global_license_checker.IsEnterpriseValidFast()) {
           return client.rpc_client_.Stream<replication::SystemRecoveryRpc>(
               main_uuid, db_info.last_committed_timestamp, std::move(db_info.configs), auth::Auth::Config{},
               std::vector<auth::User>{}, std::vector<auth::Role>{});
@@ -104,7 +98,7 @@ void SystemRestore(replication::ReplicationClient &client, system::System &syste
 struct ReplicationHandler : public memgraph::query::ReplicationQueryHandler {
 #ifdef MG_ENTERPRISE
   explicit ReplicationHandler(memgraph::replication::ReplicationState &repl_state,
-                              memgraph::dbms::DbmsHandler &dbms_handler, memgraph::system::System &system,
+                              memgraph::dbms::DbmsHandler &dbms_handler, memgraph::system::System *system,
                               memgraph::auth::SynchedAuth &auth);
 #else
   explicit ReplicationHandler(memgraph::replication::ReplicationState &repl_state,
@@ -114,14 +108,10 @@ struct ReplicationHandler : public memgraph::query::ReplicationQueryHandler {
   // as REPLICA, become MAIN
   bool SetReplicationRoleMain() override;
 
-  // as MAIN, become REPLICA, can be called on MAIN and REPLICA
+  // as MAIN, become REPLICA
   bool SetReplicationRoleReplica(const memgraph::replication::ReplicationServerConfig &config,
                                  const std::optional<utils::UUID> &main_uuid) override;
 
-  // as MAIN, become REPLICA, can be called only on MAIN
-  bool TrySetReplicationRoleReplica(const memgraph::replication::ReplicationServerConfig &config,
-                                    const std::optional<utils::UUID> &main_uuid) override;
-
   // as MAIN, define and connect to REPLICAs
   auto TryRegisterReplica(const memgraph::replication::ReplicationClientConfig &config, bool send_swap_uuid)
       -> memgraph::utils::BasicResult<memgraph::query::RegisterReplicaError> override;
@@ -142,152 +132,100 @@ struct ReplicationHandler : public memgraph::query::ReplicationQueryHandler {
   auto GetReplState() const -> const memgraph::replication::ReplicationState &;
   auto GetReplState() -> memgraph::replication::ReplicationState &;
 
-  auto GetReplicaUUID() -> std::optional<utils::UUID>;
-
  private:
-  template <bool AllowRPCFailure>
-  auto RegisterReplica_(const memgraph::replication::ReplicationClientConfig &config, bool send_swap_uuid)
-      -> memgraph::utils::BasicResult<memgraph::query::RegisterReplicaError> {
+  template <bool AllowReplicaToBeUnreachable>
+  auto RegisterReplica_(const replication::ReplicationClientConfig &config, bool send_swap_uuid)
+      -> utils::BasicResult<memgraph::query::RegisterReplicaError> {
     MG_ASSERT(repl_state_.IsMain(), "Only main instance can register a replica!");
+
     auto maybe_client = repl_state_.RegisterReplica(config);
     if (maybe_client.HasError()) {
       switch (maybe_client.GetError()) {
-        case memgraph::replication::RegisterReplicaError::NOT_MAIN:
+        case replication::RegisterReplicaError::NOT_MAIN:
           MG_ASSERT(false, "Only main instance can register a replica!");
           return {};
-        case memgraph::replication::RegisterReplicaError::NAME_EXISTS:
-          return memgraph::query::RegisterReplicaError::NAME_EXISTS;
-        case memgraph::replication::RegisterReplicaError::ENDPOINT_EXISTS:
-          return memgraph::query::RegisterReplicaError::ENDPOINT_EXISTS;
-        case memgraph::replication::RegisterReplicaError::COULD_NOT_BE_PERSISTED:
-          return memgraph::query::RegisterReplicaError::COULD_NOT_BE_PERSISTED;
-        case memgraph::replication::RegisterReplicaError::SUCCESS:
+        case replication::RegisterReplicaError::NAME_EXISTS:
+          return query::RegisterReplicaError::NAME_EXISTS;
+        case replication::RegisterReplicaError::ENDPOINT_EXISTS:
+          return query::RegisterReplicaError::ENDPOINT_EXISTS;
+        case replication::RegisterReplicaError::COULD_NOT_BE_PERSISTED:
+          return query::RegisterReplicaError::COULD_NOT_BE_PERSISTED;
+        case replication::RegisterReplicaError::SUCCESS:
           break;
       }
     }
-    using enum memgraph::flags::Experiments;
-    bool system_replication_enabled = flags::AreExperimentsEnabled(SYSTEM_REPLICATION);
-    if (!system_replication_enabled && dbms_handler_.Count() > 1) {
+
+    if (!dbms::allow_mt_repl && dbms_handler_.All().size() > 1) {
       spdlog::warn("Multi-tenant replication is currently not supported!");
     }
-    const auto main_uuid =
-        std::get<memgraph::replication::RoleMainData>(dbms_handler_.ReplicationState().ReplicationData()).uuid_;
-    if (send_swap_uuid) {
-      if (!memgraph::replication_coordination_glue::SendSwapMainUUIDRpc(maybe_client.GetValue()->rpc_client_,
-                                                                        main_uuid)) {
-        return memgraph::query::RegisterReplicaError::ERROR_ACCEPTING_MAIN;
-      }
+
+    auto const main_uuid =
+        std::get<replication::RoleMainData>(dbms_handler_.ReplicationState().ReplicationData()).uuid_;
+
+    if (send_swap_uuid &&
+        !replication_coordination_glue::SendSwapMainUUIDRpc(maybe_client.GetValue()->rpc_client_, main_uuid)) {
+      return query::RegisterReplicaError::ERROR_ACCEPTING_MAIN;
     }
+
 #ifdef MG_ENTERPRISE
     // Update system before enabling individual storage <-> replica clients
-    SystemRestore(*maybe_client.GetValue(), system_, dbms_handler_, main_uuid, auth_);
+    SystemRestore(*maybe_client.GetValue(), dbms_handler_, main_uuid, system_, auth_);
 #endif
+
     const auto dbms_error = HandleRegisterReplicaStatus(maybe_client);
     if (dbms_error.has_value()) {
       return *dbms_error;
     }
     auto &instance_client_ptr = maybe_client.GetValue();
+
     bool all_clients_good = true;
     // Add database specific clients (NOTE Currently all databases are connected to each replica)
     dbms_handler_.ForEach([&](dbms::DatabaseAccess db_acc) {
       auto *storage = db_acc->storage();
-      if (!system_replication_enabled && storage->name() != dbms::kDefaultDB) {
+      if (!dbms::allow_mt_repl && storage->name() != dbms::kDefaultDB) {
         return;
       }
       // TODO: ATM only IN_MEMORY_TRANSACTIONAL, fix other modes
       if (storage->storage_mode_ != storage::StorageMode::IN_MEMORY_TRANSACTIONAL) return;
+
       all_clients_good &= storage->repl_storage_state_.replication_clients_.WithLock(
           [storage, &instance_client_ptr, db_acc = std::move(db_acc),
            main_uuid](auto &storage_clients) mutable {  // NOLINT
             auto client = std::make_unique<storage::ReplicationStorageClient>(*instance_client_ptr, main_uuid);
             client->Start(storage, std::move(db_acc));
-            bool const success = std::invoke([state = client->State()]() {
-              if (state == storage::replication::ReplicaState::DIVERGED_FROM_MAIN) {
-                return false;
-              }
-              if (state == storage::replication::ReplicaState::MAYBE_BEHIND) {
-                return AllowRPCFailure;
-              }
-              return true;
-            });
-
+            // After start the storage <-> replica state shouldn't be MAYBE_BEHIND.
+            // When part of coordinator cluster we allow replica to be UNREACHABLE.
+            auto state = client->State();
+            bool const success =
+                (state != storage::replication::ReplicaState::MAYBE_BEHIND) ||
+                (state == storage::replication::ReplicaState::UNREACHABLE && AllowReplicaToBeUnreachable);
             if (success) {
               storage_clients.push_back(std::move(client));
             }
             return success;
           });
     });
-    // NOTE Currently if any databases fails, we revert back
+
     if (!all_clients_good) {
       spdlog::error("Failed to register all databases on the REPLICA \"{}\"", config.name);
       UnregisterReplica(config.name);
       return memgraph::query::RegisterReplicaError::CONNECTION_FAILED;
     }
+
     // No client error, start instance level client
 #ifdef MG_ENTERPRISE
-    StartReplicaClient(*instance_client_ptr, system_, dbms_handler_, main_uuid, auth_);
+    StartReplicaClient(*instance_client_ptr, dbms_handler_, main_uuid, system_, auth_);
 #else
     StartReplicaClient(*instance_client_ptr, dbms_handler_, main_uuid);
 #endif
     return {};
   }
 
-  template <bool AllowIdempotency>
-  bool SetReplicationRoleReplica_(const memgraph::replication::ReplicationServerConfig &config,
-                                  const std::optional<utils::UUID> &main_uuid) {
-    if (repl_state_.IsReplica()) {
-      if (!AllowIdempotency) {
-        return false;
-      }
-      // We don't want to restart the server if we're already a REPLICA with correct config
-      auto &replica_data = std::get<memgraph::replication::RoleReplicaData>(repl_state_.ReplicationData());
-      if (replica_data.config == config) {
-        return true;
-      }
-      repl_state_.SetReplicationRoleReplica(config, main_uuid);
-#ifdef MG_ENTERPRISE
-      return StartRpcServer(dbms_handler_, replica_data, auth_, system_);
-#else
-      return StartRpcServer(dbms_handler_, replica_data);
-#endif
-    }
-
-    // TODO StorageState needs to be synched. Could have a dangling reference if someone adds a database as we are
-    //      deleting the replica.
-    // Remove database specific clients
-    dbms_handler_.ForEach([&](memgraph::dbms::DatabaseAccess db_acc) {
-      auto *storage = db_acc->storage();
-      storage->repl_storage_state_.replication_clients_.WithLock([](auto &clients) { clients.clear(); });
-    });
-    // Remove instance level clients
-    std::get<memgraph::replication::RoleMainData>(repl_state_.ReplicationData()).registered_replicas_.clear();
-
-    // Creates the server
-    repl_state_.SetReplicationRoleReplica(config, main_uuid);
-
-    // Start
-    const auto success =
-        std::visit(memgraph::utils::Overloaded{[](memgraph::replication::RoleMainData &) {
-                                                 // ASSERT
-                                                 return false;
-                                               },
-                                               [this](memgraph::replication::RoleReplicaData &data) {
-#ifdef MG_ENTERPRISE
-                                                 return StartRpcServer(dbms_handler_, data, auth_, system_);
-#else
-                                                 return StartRpcServer(dbms_handler_, data);
-#endif
-                                               }},
-                   repl_state_.ReplicationData());
-    // TODO Handle error (restore to main?)
-    return success;
-  }
-
   memgraph::replication::ReplicationState &repl_state_;
   memgraph::dbms::DbmsHandler &dbms_handler_;
 
 #ifdef MG_ENTERPRISE
-  memgraph::system::System &system_;
+  memgraph::system::System *system_;
   memgraph::auth::SynchedAuth &auth_;
 #endif
 };

src/replication_handler/include/replication_handler/system_replication.hpp

@@ -27,16 +27,11 @@ inline void LogWrongMain(const std::optional<utils::UUID> &current_main_uuid, co
 #ifdef MG_ENTERPRISE
 void SystemHeartbeatHandler(uint64_t ts, const std::optional<utils::UUID> &current_main_uuid, slk::Reader *req_reader,
                             slk::Builder *res_builder);
-
 void SystemRecoveryHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access,
                            std::optional<utils::UUID> &current_main_uuid, dbms::DbmsHandler &dbms_handler,
                            auth::SynchedAuth &auth, slk::Reader *req_reader, slk::Builder *res_builder);
-
-void Register(replication::RoleReplicaData const &data, system::System &system, dbms::DbmsHandler &dbms_handler,
-              auth::SynchedAuth &auth);
-
-bool StartRpcServer(dbms::DbmsHandler &dbms_handler, replication::RoleReplicaData &data, auth::SynchedAuth &auth,
-                    system::System &system);
+void Register(replication::RoleReplicaData const &data, dbms::DbmsHandler &dbms_handler, auth::SynchedAuth &auth);
+bool StartRpcServer(dbms::DbmsHandler &dbms_handler, replication::RoleReplicaData &data, auth::SynchedAuth &auth);
 #else
 bool StartRpcServer(dbms::DbmsHandler &dbms_handler, replication::RoleReplicaData &data);
 #endif

src/replication_handler/replication_handler.cpp

@@ -17,25 +17,25 @@ namespace memgraph::replication {
 
 namespace {
 #ifdef MG_ENTERPRISE
-void RecoverReplication(memgraph::replication::ReplicationState &repl_state, memgraph::system::System &system,
+void RecoverReplication(memgraph::replication::ReplicationState &repl_state, memgraph::system::System *system,
                         memgraph::dbms::DbmsHandler &dbms_handler, memgraph::auth::SynchedAuth &auth) {
   /*
    * REPLICATION RECOVERY AND STARTUP
    */
 
   // Startup replication state (if recovered at startup)
-  auto replica = [&dbms_handler, &auth, &system](memgraph::replication::RoleReplicaData &data) {
-    return memgraph::replication::StartRpcServer(dbms_handler, data, auth, system);
+  auto replica = [&dbms_handler, &auth](memgraph::replication::RoleReplicaData &data) {
+    return StartRpcServer(dbms_handler, data, auth);
   };
 
   // Replication recovery and frequent check start
-  auto main = [&system, &dbms_handler, &auth](memgraph::replication::RoleMainData &mainData) {
+  auto main = [system, &dbms_handler, &auth](memgraph::replication::RoleMainData &mainData) {
     for (auto &client : mainData.registered_replicas_) {
       if (client.try_set_uuid &&
           replication_coordination_glue::SendSwapMainUUIDRpc(client.rpc_client_, mainData.uuid_)) {
         client.try_set_uuid = false;
       }
-      SystemRestore(client, system, dbms_handler, mainData.uuid_, auth);
+      SystemRestore(client, dbms_handler, mainData.uuid_, system, auth);
     }
     // DBMS here
     dbms_handler.ForEach([&mainData](memgraph::dbms::DatabaseAccess db_acc) {
@@ -43,7 +43,7 @@ void RecoverReplication(memgraph::replication::ReplicationState &repl_state, mem
     });
 
     for (auto &client : mainData.registered_replicas_) {
-      StartReplicaClient(client, system, dbms_handler, mainData.uuid_, auth);
+      StartReplicaClient(client, dbms_handler, mainData.uuid_, system, auth);
     }
 
     // Warning
@@ -120,8 +120,8 @@ inline std::optional<query::RegisterReplicaError> HandleRegisterReplicaStatus(
 }
 
 #ifdef MG_ENTERPRISE
-void StartReplicaClient(replication::ReplicationClient &client, system::System &system, dbms::DbmsHandler &dbms_handler,
-                        utils::UUID main_uuid, auth::SynchedAuth &auth) {
+void StartReplicaClient(replication::ReplicationClient &client, dbms::DbmsHandler &dbms_handler, utils::UUID main_uuid,
+                        system::System *system, auth::SynchedAuth &auth) {
 #else
 void StartReplicaClient(replication::ReplicationClient &client, dbms::DbmsHandler &dbms_handler,
                         utils::UUID main_uuid) {
@@ -129,8 +129,12 @@ void StartReplicaClient(replication::ReplicationClient &client, dbms::DbmsHandle
   // No client error, start instance level client
   auto const &endpoint = client.rpc_client_.Endpoint();
   spdlog::trace("Replication client started at: {}:{}", endpoint.address, endpoint.port);
-  client.StartFrequentCheck([&, license = license::global_license_checker.IsEnterpriseValidFast(), main_uuid](
-                                bool reconnect, replication::ReplicationClient &client) mutable {
+  client.StartFrequentCheck([&,
+#ifdef MG_ENTERPRISE
+                             system = system,
+#endif
+                             license = license::global_license_checker.IsEnterpriseValidFast(),
+                             main_uuid](bool reconnect, replication::ReplicationClient &client) mutable {
     if (client.try_set_uuid &&
         memgraph::replication_coordination_glue::SendSwapMainUUIDRpc(client.rpc_client_, main_uuid)) {
       client.try_set_uuid = false;
@@ -147,7 +151,7 @@ void StartReplicaClient(replication::ReplicationClient &client, dbms::DbmsHandle
       client.state_.WithLock([](auto &state) { state = memgraph::replication::ReplicationClient::State::BEHIND; });
     }
 #ifdef MG_ENTERPRISE
-    SystemRestore<true>(client, system, dbms_handler, main_uuid, auth);
+    SystemRestore<true>(client, dbms_handler, main_uuid, system, auth);
 #endif
     // Check if any database has been left behind
     dbms_handler.ForEach([&name = client.name_, reconnect](dbms::DatabaseAccess db_acc) {
@@ -164,7 +168,7 @@ void StartReplicaClient(replication::ReplicationClient &client, dbms::DbmsHandle
 
 #ifdef MG_ENTERPRISE
 ReplicationHandler::ReplicationHandler(memgraph::replication::ReplicationState &repl_state,
-                                       memgraph::dbms::DbmsHandler &dbms_handler, memgraph::system::System &system,
+                                       memgraph::dbms::DbmsHandler &dbms_handler, memgraph::system::System *system,
                                        memgraph::auth::SynchedAuth &auth)
     : repl_state_{repl_state}, dbms_handler_{dbms_handler}, system_{system}, auth_{auth} {
   RecoverReplication(repl_state_, system_, dbms_handler_, auth_);
@@ -192,12 +196,39 @@ bool ReplicationHandler::SetReplicationRoleMain() {
 
 bool ReplicationHandler::SetReplicationRoleReplica(const memgraph::replication::ReplicationServerConfig &config,
                                                    const std::optional<utils::UUID> &main_uuid) {
-  return SetReplicationRoleReplica_<false>(config, main_uuid);
-}
+  // We don't want to restart the server if we're already a REPLICA
+  if (repl_state_.IsReplica()) {
+    return false;
+  }
 
-bool ReplicationHandler::TrySetReplicationRoleReplica(const memgraph::replication::ReplicationServerConfig &config,
-                                                      const std::optional<utils::UUID> &main_uuid) {
-  return SetReplicationRoleReplica_<true>(config, main_uuid);
+  // TODO StorageState needs to be synched. Could have a dangling reference if someone adds a database as we are
+  //      deleting the replica.
+  // Remove database specific clients
+  dbms_handler_.ForEach([&](memgraph::dbms::DatabaseAccess db_acc) {
+    auto *storage = db_acc->storage();
+    storage->repl_storage_state_.replication_clients_.WithLock([](auto &clients) { clients.clear(); });
+  });
+  // Remove instance level clients
+  std::get<memgraph::replication::RoleMainData>(repl_state_.ReplicationData()).registered_replicas_.clear();
+
+  // Creates the server
+  repl_state_.SetReplicationRoleReplica(config, main_uuid);
+
+  // Start
+  const auto success = std::visit(memgraph::utils::Overloaded{[](memgraph::replication::RoleMainData &) {
+                                                                // ASSERT
+                                                                return false;
+                                                              },
+                                                              [this](memgraph::replication::RoleReplicaData &data) {
+#ifdef MG_ENTERPRISE
+                                                                return StartRpcServer(dbms_handler_, data, auth_);
+#else
+                                                                return StartRpcServer(dbms_handler_, data);
+#endif
+                                                              }},
+                                  repl_state_.ReplicationData());
+  // TODO Handle error (restore to main?)
+  return success;
 }
 
 bool ReplicationHandler::DoReplicaToMainPromotion(const utils::UUID &main_uuid) {
@@ -229,13 +260,13 @@ bool ReplicationHandler::DoReplicaToMainPromotion(const utils::UUID &main_uuid)
 auto ReplicationHandler::TryRegisterReplica(const memgraph::replication::ReplicationClientConfig &config,
                                             bool send_swap_uuid)
     -> memgraph::utils::BasicResult<memgraph::query::RegisterReplicaError> {
-  return RegisterReplica_<true>(config, send_swap_uuid);
+  return RegisterReplica_<false>(config, send_swap_uuid);
 }
 
 auto ReplicationHandler::RegisterReplica(const memgraph::replication::ReplicationClientConfig &config,
                                          bool send_swap_uuid)
     -> memgraph::utils::BasicResult<memgraph::query::RegisterReplicaError> {
-  return RegisterReplica_<false>(config, send_swap_uuid);
+  return RegisterReplica_<true>(config, send_swap_uuid);
 }
 
 auto ReplicationHandler::UnregisterReplica(std::string_view name) -> memgraph::query::UnregisterReplicaResult {
@@ -268,11 +299,6 @@ auto ReplicationHandler::GetRole() const -> memgraph::replication_coordination_g
   return repl_state_.GetRole();
 }
 
-auto ReplicationHandler::GetReplicaUUID() -> std::optional<utils::UUID> {
-  MG_ASSERT(repl_state_.IsReplica());
-  return std::get<RoleReplicaData>(repl_state_.ReplicationData()).uuid_;
-}
-
 auto ReplicationHandler::GetReplState() const -> const memgraph::replication::ReplicationState & { return repl_state_; }
 
 auto ReplicationHandler::GetReplState() -> memgraph::replication::ReplicationState & { return repl_state_; }

src/replication_handler/system_replication.cpp

@@ -15,7 +15,6 @@
 
 #include "auth/replication_handlers.hpp"
 #include "dbms/replication_handlers.hpp"
-#include "flags/experimental.hpp"
 #include "license/license.hpp"
 #include "replication_handler/system_rpc.hpp"
 
@@ -57,24 +56,10 @@ void SystemRecoveryHandler(memgraph::system::ReplicaHandlerAccessToState &system
   memgraph::replication::SystemRecoveryReq req;
   memgraph::slk::Load(&req, req_reader);
 
-  using enum memgraph::flags::Experiments;
-  auto experimental_system_replication = flags::AreExperimentsEnabled(SYSTEM_REPLICATION);
-
-  // validate
   if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
     LogWrongMain(current_main_uuid, req.main_uuid, SystemRecoveryReq::kType.name);
     return;
   }
-  if (!experimental_system_replication) {
-    if (req.database_configs.size() != 1 && req.database_configs[0].name != dbms::kDefaultDB) {
-      // a partial system recovery should be only be updating the default database uuid
-      return;  // Failure sent on exit
-    }
-    if (!req.users.empty() || !req.roles.empty()) {
-      // a partial system recovery should not be updating any users or roles
-      return;  // Failure sent on exit
-    }
-  }
 
   /*
    * DBMS
@@ -84,9 +69,7 @@ void SystemRecoveryHandler(memgraph::system::ReplicaHandlerAccessToState &system
   /*
    * AUTH
    */
-  if (experimental_system_replication) {
-    if (!auth::SystemRecoveryHandler(auth, req.auth_config, req.users, req.roles)) return;  // Failure sent on exit
-  }
+  if (!auth::SystemRecoveryHandler(auth, req.auth_config, req.users, req.roles)) return;  // Failure sent on exit
 
   /*
    * SUCCESSFUL RECOVERY
@@ -96,44 +79,35 @@ void SystemRecoveryHandler(memgraph::system::ReplicaHandlerAccessToState &system
   res = SystemRecoveryRes(SystemRecoveryRes::Result::SUCCESS);
 }
 
-void Register(replication::RoleReplicaData const &data, system::System &system, dbms::DbmsHandler &dbms_handler,
-              auth::SynchedAuth &auth) {
+void Register(replication::RoleReplicaData const &data, dbms::DbmsHandler &dbms_handler, auth::SynchedAuth &auth) {
   // NOTE: Register even without license as the user could add a license at run-time
+  // TODO: fix Register when system is removed from DbmsHandler
 
-  auto system_state_access = system.CreateSystemStateAccess();
-
-  using enum memgraph::flags::Experiments;
-  auto experimental_system_replication = flags::AreExperimentsEnabled(SYSTEM_REPLICATION);
+  auto system_state_access = dbms_handler.system_->CreateSystemStateAccess();
 
   // System
-  if (experimental_system_replication) {
-    data.server->rpc_server_.Register<replication::SystemHeartbeatRpc>(
-        [&data, system_state_access](auto *req_reader, auto *res_builder) {
-          spdlog::debug("Received SystemHeartbeatRpc");
-          SystemHeartbeatHandler(system_state_access.LastCommitedTS(), data.uuid_, req_reader, res_builder);
-        });
-  }
-  // Needed even with experimental_system_replication=false becasue
-  // need to tell REPLICA the uuid to use for "memgraph" default database
+  // TODO: remove, as this is not used
+  data.server->rpc_server_.Register<replication::SystemHeartbeatRpc>(
+      [&data, system_state_access](auto *req_reader, auto *res_builder) {
+        spdlog::debug("Received SystemHeartbeatRpc");
+        SystemHeartbeatHandler(system_state_access.LastCommitedTS(), data.uuid_, req_reader, res_builder);
+      });
   data.server->rpc_server_.Register<replication::SystemRecoveryRpc>(
       [&data, system_state_access, &dbms_handler, &auth](auto *req_reader, auto *res_builder) mutable {
         spdlog::debug("Received SystemRecoveryRpc");
         SystemRecoveryHandler(system_state_access, data.uuid_, dbms_handler, auth, req_reader, res_builder);
       });
 
-  if (experimental_system_replication) {
-    // DBMS
-    dbms::Register(data, system_state_access, dbms_handler);
+  // DBMS
+  dbms::Register(data, system_state_access, dbms_handler);
 
-    // Auth
-    auth::Register(data, system_state_access, auth);
-  }
+  // Auth
+  auth::Register(data, system_state_access, auth);
 }
 #endif
 
 #ifdef MG_ENTERPRISE
-bool StartRpcServer(dbms::DbmsHandler &dbms_handler, replication::RoleReplicaData &data, auth::SynchedAuth &auth,
-                    system::System &system) {
+bool StartRpcServer(dbms::DbmsHandler &dbms_handler, replication::RoleReplicaData &data, auth::SynchedAuth &auth) {
 #else
 bool StartRpcServer(dbms::DbmsHandler &dbms_handler, replication::RoleReplicaData &data) {
 #endif
@@ -141,7 +115,7 @@ bool StartRpcServer(dbms::DbmsHandler &dbms_handler, replication::RoleReplicaDat
   dbms::InMemoryReplicationHandlers::Register(&dbms_handler, data);
 #ifdef MG_ENTERPRISE
   // Register system handlers
-  Register(data, system, dbms_handler, auth);
+  Register(data, dbms_handler, auth);
 #endif
   // Start server
   if (!data.server->Start()) {

src/storage/v2/edge_accessor.cpp

@@ -17,7 +17,6 @@
 
 #include "storage/v2/delta.hpp"
 #include "storage/v2/mvcc.hpp"
-#include "storage/v2/property_store.hpp"
 #include "storage/v2/property_value.hpp"
 #include "storage/v2/result.hpp"
 #include "storage/v2/storage.hpp"
@@ -265,27 +264,6 @@ Result<PropertyValue> EdgeAccessor::GetProperty(PropertyId property, View view)
   return *std::move(value);
 }
 
-Result<uint64_t> EdgeAccessor::GetPropertySize(PropertyId property, View view) const {
-  if (!storage_->config_.salient.items.properties_on_edges) return 0;
-
-  auto guard = std::shared_lock{edge_.ptr->lock};
-  Delta *delta = edge_.ptr->delta;
-  if (!delta) {
-    return edge_.ptr->properties.PropertySize(property);
-  }
-
-  auto property_result = this->GetProperty(property, view);
-
-  if (property_result.HasError()) {
-    return property_result.GetError();
-  }
-
-  auto property_store = storage::PropertyStore();
-  property_store.SetProperty(property, *property_result);
-
-  return property_store.PropertySize(property);
-};
-
 Result<std::map<PropertyId, PropertyValue>> EdgeAccessor::Properties(View view) const {
   if (!storage_->config_.salient.items.properties_on_edges) return std::map<PropertyId, PropertyValue>{};
   bool exists = true;

src/storage/v2/edge_accessor.hpp

@@ -82,9 +82,6 @@ class EdgeAccessor final {
   /// @throw std::bad_alloc
   Result<PropertyValue> GetProperty(PropertyId property, View view) const;
 
-  /// Returns the size of the encoded edge property in bytes.
-  Result<uint64_t> GetPropertySize(PropertyId property, View view) const;
-
   /// @throw std::bad_alloc
   Result<std::map<PropertyId, PropertyValue>> Properties(View view) const;
 

src/storage/v2/name_id_mapper.hpp

@@ -83,18 +83,6 @@ class NameIdMapper {
     return id;
   }
 
-  /// This method unlike NameToId does not insert the new property id if not found
-  /// but just returns either std::nullopt or the value of the property id if it
-  /// finds it.
-  virtual std::optional<uint64_t> NameToIdIfExists(const std::string_view name) {
-    auto name_to_id_acc = name_to_id_.access();
-    auto found = name_to_id_acc.find(name);
-    if (found == name_to_id_acc.end()) {
-      return std::nullopt;
-    }
-    return found->id;
-  }
-
   // NOTE: Currently this function returns a `const std::string &` instead of a
   // `std::string` to avoid making unnecessary copies of the string.
   // Usually, this wouldn't be correct because the accessor to the

src/storage/v2/property_store.cpp

@@ -93,19 +93,6 @@ enum class Size : uint8_t {
   INT64 = 0x03,
 };
 
-uint64_t SizeToByteSize(Size size) {
-  switch (size) {
-    case Size::INT8:
-      return 1;
-    case Size::INT16:
-      return 2;
-    case Size::INT32:
-      return 4;
-    case Size::INT64:
-      return 8;
-  }
-}
-
 // All of these values must have the lowest 4 bits set to zero because they are
 // used to store two `Size` values as described in the comment above.
 enum class Type : uint8_t {
@@ -499,27 +486,6 @@ std::optional<TemporalData> DecodeTemporalData(Reader &reader) {
   return TemporalData{static_cast<TemporalType>(*type_value), *microseconds_value};
 }
 
-std::optional<uint64_t> DecodeTemporalDataSize(Reader &reader) {
-  uint64_t temporal_data_size = 0;
-
-  auto metadata = reader.ReadMetadata();
-  if (!metadata || metadata->type != Type::TEMPORAL_DATA) return std::nullopt;
-
-  temporal_data_size += 1;
-
-  auto type_value = reader.ReadUint(metadata->id_size);
-  if (!type_value) return std::nullopt;
-
-  temporal_data_size += SizeToByteSize(metadata->id_size);
-
-  auto microseconds_value = reader.ReadInt(metadata->payload_size);
-  if (!microseconds_value) return std::nullopt;
-
-  temporal_data_size += SizeToByteSize(metadata->payload_size);
-
-  return temporal_data_size;
-}
-
 }  // namespace
 
 // Function used to decode a PropertyValue from a byte stream.
@@ -606,92 +572,6 @@ std::optional<uint64_t> DecodeTemporalDataSize(Reader &reader) {
   }
 }
 
-[[nodiscard]] bool DecodePropertyValueSize(Reader *reader, Type type, Size payload_size, uint64_t &property_size) {
-  switch (type) {
-    case Type::EMPTY: {
-      return false;
-    }
-    case Type::NONE:
-    case Type::BOOL: {
-      return true;
-    }
-    case Type::INT: {
-      reader->ReadInt(payload_size);
-      property_size += SizeToByteSize(payload_size);
-      return true;
-    }
-    case Type::DOUBLE: {
-      reader->ReadDouble(payload_size);
-      property_size += SizeToByteSize(payload_size);
-      return true;
-    }
-    case Type::STRING: {
-      auto size = reader->ReadUint(payload_size);
-      if (!size) return false;
-      property_size += SizeToByteSize(payload_size);
-
-      std::string str_v(*size, '\0');
-      if (!reader->SkipBytes(*size)) return false;
-      property_size += *size;
-
-      return true;
-    }
-    case Type::LIST: {
-      auto size = reader->ReadUint(payload_size);
-      if (!size) return false;
-
-      uint64_t list_property_size = SizeToByteSize(payload_size);
-
-      for (uint64_t i = 0; i < *size; ++i) {
-        auto metadata = reader->ReadMetadata();
-        if (!metadata) return false;
-
-        list_property_size += 1;
-        if (!DecodePropertyValueSize(reader, metadata->type, metadata->payload_size, list_property_size)) return false;
-      }
-
-      property_size += list_property_size;
-      return true;
-    }
-    case Type::MAP: {
-      auto size = reader->ReadUint(payload_size);
-      if (!size) return false;
-
-      uint64_t map_property_size = SizeToByteSize(payload_size);
-
-      for (uint64_t i = 0; i < *size; ++i) {
-        auto metadata = reader->ReadMetadata();
-        if (!metadata) return false;
-
-        map_property_size += 1;
-
-        auto key_size = reader->ReadUint(metadata->id_size);
-        if (!key_size) return false;
-
-        map_property_size += SizeToByteSize(metadata->id_size);
-
-        std::string key(*key_size, '\0');
-        if (!reader->ReadBytes(key.data(), *key_size)) return false;
-
-        map_property_size += *key_size;
-
-        if (!DecodePropertyValueSize(reader, metadata->type, metadata->payload_size, map_property_size)) return false;
-      }
-
-      property_size += map_property_size;
-      return true;
-    }
-
-    case Type::TEMPORAL_DATA: {
-      const auto maybe_temporal_data_size = DecodeTemporalDataSize(*reader);
-      if (!maybe_temporal_data_size) return false;
-
-      property_size += *maybe_temporal_data_size;
-      return true;
-    }
-  }
-}
-
 // Function used to skip a PropertyValue from a byte stream.
 //
 // @sa ComparePropertyValue
@@ -908,27 +788,6 @@ enum class ExpectedPropertyStatus {
                                                      : ExpectedPropertyStatus::GREATER;
 }
 
-[[nodiscard]] ExpectedPropertyStatus DecodeExpectedPropertySize(Reader *reader, PropertyId expected_property,
-                                                                uint64_t &size) {
-  auto metadata = reader->ReadMetadata();
-  if (!metadata) return ExpectedPropertyStatus::MISSING_DATA;
-
-  auto property_id = reader->ReadUint(metadata->id_size);
-  if (!property_id) return ExpectedPropertyStatus::MISSING_DATA;
-
-  if (*property_id == expected_property.AsUint()) {
-    // Add one byte for reading metadata + add the number of bytes for the property key
-    size += (1 + SizeToByteSize(metadata->id_size));
-    if (!DecodePropertyValueSize(reader, metadata->type, metadata->payload_size, size))
-      return ExpectedPropertyStatus::MISSING_DATA;
-    return ExpectedPropertyStatus::EQUAL;
-  }
-  // Don't load the value if this isn't the expected property.
-  if (!SkipPropertyValue(reader, metadata->type, metadata->payload_size)) return ExpectedPropertyStatus::MISSING_DATA;
-  return (*property_id < expected_property.AsUint()) ? ExpectedPropertyStatus::SMALLER
-                                                     : ExpectedPropertyStatus::GREATER;
-}
-
 // Function used to check a property exists (PropertyId) from a byte stream.
 // It will skip the encoded PropertyValue.
 //
@@ -1016,13 +875,6 @@ enum class ExpectedPropertyStatus {
   }
 }
 
-[[nodiscard]] ExpectedPropertyStatus FindSpecificPropertySize(Reader *reader, PropertyId property, uint64_t &size) {
-  ExpectedPropertyStatus ret = ExpectedPropertyStatus::SMALLER;
-  while ((ret = DecodeExpectedPropertySize(reader, property, size)) == ExpectedPropertyStatus::SMALLER) {
-  }
-  return ret;
-}
-
 // Function used to find if property is set. It relies on the fact that the properties
 // are sorted (by ID) in the buffer.
 //
@@ -1131,31 +983,6 @@ std::pair<uint64_t, uint8_t *> GetSizeData(const uint8_t *buffer) {
   return {size, data};
 }
 
-struct BufferInfo {
-  uint64_t size;
-  uint8_t *data{nullptr};
-  bool in_local_buffer;
-};
-
-template <size_t N>
-BufferInfo GetBufferInfo(const uint8_t (&buffer)[N]) {
-  uint64_t size = 0;
-  const uint8_t *data = nullptr;
-  bool in_local_buffer = false;
-  std::tie(size, data) = GetSizeData(buffer);
-  if (size % 8 != 0) {
-    // We are storing the data in the local buffer.
-    size = sizeof(buffer) - 1;
-    data = &buffer[1];
-    in_local_buffer = true;
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
-  auto *non_const_data = const_cast<uint8_t *>(data);
-
-  return {size, non_const_data, in_local_buffer};
-}
-
 void SetSizeData(uint8_t *buffer, uint64_t size, uint8_t *data) {
   memcpy(buffer, &size, sizeof(uint64_t));
   memcpy(buffer + sizeof(uint64_t), &data, sizeof(uint8_t *));
@@ -1196,27 +1023,30 @@ PropertyStore::~PropertyStore() {
 }
 
 PropertyValue PropertyStore::GetProperty(PropertyId property) const {
-  BufferInfo buffer_info = GetBufferInfo(buffer_);
-  Reader reader(buffer_info.data, buffer_info.size);
-
+  uint64_t size;
+  const uint8_t *data;
+  std::tie(size, data) = GetSizeData(buffer_);
+  if (size % 8 != 0) {
+    // We are storing the data in the local buffer.
+    size = sizeof(buffer_) - 1;
+    data = &buffer_[1];
+  }
+  Reader reader(data, size);
   PropertyValue value;
   if (FindSpecificProperty(&reader, property, value) != ExpectedPropertyStatus::EQUAL) return {};
   return value;
 }
 
-uint64_t PropertyStore::PropertySize(PropertyId property) const {
-  auto data_size_localbuffer = GetBufferInfo(buffer_);
-  Reader reader(data_size_localbuffer.data, data_size_localbuffer.size);
-
-  uint64_t property_size = 0;
-  if (FindSpecificPropertySize(&reader, property, property_size) != ExpectedPropertyStatus::EQUAL) return 0;
-  return property_size;
-}
-
 bool PropertyStore::HasProperty(PropertyId property) const {
-  BufferInfo buffer_info = GetBufferInfo(buffer_);
-  Reader reader(buffer_info.data, buffer_info.size);
-
+  uint64_t size;
+  const uint8_t *data;
+  std::tie(size, data) = GetSizeData(buffer_);
+  if (size % 8 != 0) {
+    // We are storing the data in the local buffer.
+    size = sizeof(buffer_) - 1;
+    data = &buffer_[1];
+  }
+  Reader reader(data, size);
   return ExistsSpecificProperty(&reader, property) == ExpectedPropertyStatus::EQUAL;
 }
 
@@ -1251,20 +1081,32 @@ std::optional<std::vector<PropertyValue>> PropertyStore::ExtractPropertyValues(
 }
 
 bool PropertyStore::IsPropertyEqual(PropertyId property, const PropertyValue &value) const {
-  BufferInfo buffer_info = GetBufferInfo(buffer_);
-  Reader reader(buffer_info.data, buffer_info.size);
-
+  uint64_t size;
+  const uint8_t *data;
+  std::tie(size, data) = GetSizeData(buffer_);
+  if (size % 8 != 0) {
+    // We are storing the data in the local buffer.
+    size = sizeof(buffer_) - 1;
+    data = &buffer_[1];
+  }
+  Reader reader(data, size);
   auto info = FindSpecificPropertyAndBufferInfo(&reader, property);
   if (info.property_size == 0) return value.IsNull();
-  Reader prop_reader(buffer_info.data + info.property_begin, info.property_size);
+  Reader prop_reader(data + info.property_begin, info.property_size);
   if (!CompareExpectedProperty(&prop_reader, property, value)) return false;
   return prop_reader.GetPosition() == info.property_size;
 }
 
 std::map<PropertyId, PropertyValue> PropertyStore::Properties() const {
-  BufferInfo buffer_info = GetBufferInfo(buffer_);
-  Reader reader(buffer_info.data, buffer_info.size);
-
+  uint64_t size;
+  const uint8_t *data;
+  std::tie(size, data) = GetSizeData(buffer_);
+  if (size % 8 != 0) {
+    // We are storing the data in the local buffer.
+    size = sizeof(buffer_) - 1;
+    data = &buffer_[1];
+  }
+  Reader reader(data, size);
   std::map<PropertyId, PropertyValue> props;
   while (true) {
     PropertyValue value;
@@ -1498,20 +1340,33 @@ bool PropertyStore::InitProperties(std::vector<std::pair<storage::PropertyId, st
 }
 
 bool PropertyStore::ClearProperties() {
-  BufferInfo buffer_info = GetBufferInfo(buffer_);
-
-  if (!buffer_info.size) return false;
-  if (!buffer_info.in_local_buffer) delete[] buffer_info.data;
+  bool in_local_buffer = false;
+  uint64_t size;
+  uint8_t *data;
+  std::tie(size, data) = GetSizeData(buffer_);
+  if (size % 8 != 0) {
+    // We are storing the data in the local buffer.
+    size = sizeof(buffer_) - 1;
+    data = &buffer_[1];
+    in_local_buffer = true;
+  }
+  if (!size) return false;
+  if (!in_local_buffer) delete[] data;
   SetSizeData(buffer_, 0, nullptr);
   return true;
 }
 
 std::string PropertyStore::StringBuffer() const {
-  BufferInfo buffer_info = GetBufferInfo(buffer_);
-
-  std::string arr(buffer_info.size, ' ');
-  for (uint i = 0; i < buffer_info.size; ++i) {
-    arr[i] = static_cast<char>(buffer_info.data[i]);
+  uint64_t size = 0;
+  const uint8_t *data = nullptr;
+  std::tie(size, data) = GetSizeData(buffer_);
+  if (size % 8 != 0) {  // We are storing the data in the local buffer.
+    size = sizeof(buffer_) - 1;
+    data = &buffer_[1];
+  }
+  std::string arr(size, ' ');
+  for (uint i = 0; i < size; ++i) {
+    arr[i] = static_cast<char>(data[i]);
   }
   return arr;
 }

src/storage/v2/property_store.hpp

@@ -45,11 +45,6 @@ class PropertyStore {
   /// @throw std::bad_alloc
   PropertyValue GetProperty(PropertyId property) const;
 
-  /// Returns the size of the encoded property in bytes.
-  /// Returns 0 if the property does not exist.
-  /// The time complexity of this function is O(n).
-  uint64_t PropertySize(PropertyId property) const;
-
   /// Checks whether the property `property` exists in the store. The time
   /// complexity of this function is O(n).
   bool HasProperty(PropertyId property) const;

src/storage/v2/replication/enums.hpp

@@ -14,6 +14,6 @@
 
 namespace memgraph::storage::replication {
 
-enum class ReplicaState : std::uint8_t { READY, REPLICATING, RECOVERY, MAYBE_BEHIND, DIVERGED_FROM_MAIN };
+enum class ReplicaState : std::uint8_t { READY, REPLICATING, RECOVERY, MAYBE_BEHIND, UNREACHABLE };
 
 }  // namespace memgraph::storage::replication

src/storage/v2/replication/replication_client.cpp

@@ -46,6 +46,9 @@ void ReplicationStorageClient::UpdateReplicaState(Storage *storage, DatabaseAcce
                     std::string{storage->uuid()});
       state = memgraph::replication::ReplicationClient::State::BEHIND;
     });
+
+    replica_state_.WithLock([](auto &state) { state = replication::ReplicaState::UNREACHABLE; });
+
     return;
   }
 #endif
@@ -69,7 +72,7 @@ void ReplicationStorageClient::UpdateReplicaState(Storage *storage, DatabaseAcce
         "now hold unique data. Please resolve data conflicts and start the "
         "replication on a clean instance.",
         client_.name_, client_.name_, client_.name_);
-    replica_state_.WithLock([](auto &val) { val = replication::ReplicaState::DIVERGED_FROM_MAIN; });
+    // State not updated, hence in MAYBE_BEHIND state
     return;
   }
 
@@ -149,6 +152,9 @@ void ReplicationStorageClient::StartTransactionReplication(const uint64_t curren
   auto locked_state = replica_state_.Lock();
   switch (*locked_state) {
     using enum replication::ReplicaState;
+    case UNREACHABLE:
+      spdlog::debug("Replica {} is unreachable", client_.name_);
+      return;
     case RECOVERY:
       spdlog::debug("Replica {} is behind MAIN instance", client_.name_);
       return;
@@ -171,10 +177,6 @@ void ReplicationStorageClient::StartTransactionReplication(const uint64_t curren
           utils::MessageWithLink("Couldn't replicate data to {}.", client_.name_, "https://memgr.ph/replication"));
       TryCheckReplicaStateAsync(storage, std::move(db_acc));
       return;
-    case DIVERGED_FROM_MAIN:
-      spdlog::error(utils::MessageWithLink("Couldn't replicate data to {} since replica has diverged from main.",
-                                           client_.name_, "https://memgr.ph/replication"));
-      return;
     case READY:
       MG_ASSERT(!replica_stream_);
       try {

src/storage/v2/storage.hpp

@@ -250,10 +250,6 @@ class Storage {
 
     PropertyId NameToProperty(std::string_view name) { return storage_->NameToProperty(name); }
 
-    std::optional<PropertyId> NameToPropertyIfExists(std::string_view name) const {
-      return storage_->NameToPropertyIfExists(name);
-    }
-
     EdgeTypeId NameToEdgeType(std::string_view name) { return storage_->NameToEdgeType(name); }
 
     StorageMode GetCreationStorageMode() const noexcept;
@@ -322,14 +318,6 @@ class Storage {
     return PropertyId::FromUint(name_id_mapper_->NameToId(name));
   }
 
-  std::optional<PropertyId> NameToPropertyIfExists(std::string_view name) const {
-    const auto id = name_id_mapper_->NameToIdIfExists(name);
-    if (!id) {
-      return std::nullopt;
-    }
-    return PropertyId::FromUint(*id);
-  }
-
   EdgeTypeId NameToEdgeType(const std::string_view name) const {
     return EdgeTypeId::FromUint(name_id_mapper_->NameToId(name));
   }

src/storage/v2/vertex_accessor.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
@@ -438,26 +438,6 @@ Result<PropertyValue> VertexAccessor::GetProperty(PropertyId property, View view
   return std::move(value);
 }
 
-Result<uint64_t> VertexAccessor::GetPropertySize(PropertyId property, View view) const {
-  {
-    auto guard = std::shared_lock{vertex_->lock};
-    Delta *delta = vertex_->delta;
-    if (!delta) {
-      return vertex_->properties.PropertySize(property);
-    }
-  }
-
-  auto property_result = this->GetProperty(property, view);
-  if (property_result.HasError()) {
-    return property_result.GetError();
-  }
-
-  auto property_store = storage::PropertyStore();
-  property_store.SetProperty(property, *property_result);
-
-  return property_store.PropertySize(property);
-};
-
 Result<std::map<PropertyId, PropertyValue>> VertexAccessor::Properties(View view) const {
   bool exists = true;
   bool deleted = false;

src/storage/v2/vertex_accessor.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
@@ -80,9 +80,6 @@ class VertexAccessor final {
   /// @throw std::bad_alloc
   Result<PropertyValue> GetProperty(PropertyId property, View view) const;
 
-  /// Returns the size of the encoded vertex property in bytes.
-  Result<uint64_t> GetPropertySize(PropertyId property, View view) const;
-
   /// @throw std::bad_alloc
   Result<std::map<PropertyId, PropertyValue>> Properties(View view) const;
 

src/storage/v2/vertex_info_cache.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
@@ -15,8 +15,6 @@
 
 #include "utils/flag_validation.hpp"
 
-#include <type_traits>
-
 // NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_VALIDATED_uint64(delta_chain_cache_threshold, 128,
                         "The threshold for when to cache long delta chains. This is used for heavy read + write "
@@ -33,7 +31,6 @@ auto FetchHelper(VertexInfoCache const &caches, Func &&getCache, View view, Keys
   // check empty first, cheaper than the relative cost of doing an actual hash + find
   if (cache.empty()) return std::nullopt;
 
-  return std::nullopt;
   // defer building the key, maybe a cost at construction
   using key_type = typename std::remove_cvref_t<decltype(cache)>::key_type;
   auto const it = cache.find(key_type{std::forward<Keys>(keys)...});
@@ -79,8 +76,8 @@ void VertexInfoCache::Invalidate(Vertex const *vertex) {
   new_.outDegreeCache_.erase(vertex);
 
   // aggressive cache invalidation, TODO: be smarter
-  // new_.hasLabelCache_.clear();
-  // new_.propertyValueCache_.clear();
+  new_.hasLabelCache_.clear();
+  new_.propertyValueCache_.clear();
   new_.inEdgesCache_.clear();
   new_.outEdgesCache_.clear();
 }
@@ -90,38 +87,36 @@ auto VertexInfoCache::GetLabels(View view, Vertex const *vertex) const
   return FetchHelper<std::vector<LabelId>>(*this, std::mem_fn(&VertexInfoCache::Caches::labelCache_), view, vertex);
 }
 void VertexInfoCache::StoreLabels(View view, Vertex const *vertex, const std::vector<LabelId> &res) {
-  // Store(res, *this, std::mem_fn(&Caches::labelCache_), view, vertex);
+  Store(res, *this, std::mem_fn(&Caches::labelCache_), view, vertex);
 }
 auto VertexInfoCache::GetHasLabel(View view, Vertex const *vertex, LabelId label) const -> std::optional<bool> {
-  // return FetchHelper<bool>(*this, std::mem_fn(&Caches::hasLabelCache_), view, vertex, label);
-  return std::nullopt;
+  return FetchHelper<bool>(*this, std::mem_fn(&Caches::hasLabelCache_), view, vertex, label);
 }
 void VertexInfoCache::StoreHasLabel(View view, Vertex const *vertex, LabelId label, bool res) {
-  // Store(res, *this, std::mem_fn(&Caches::hasLabelCache_), view, vertex, label);
+  Store(res, *this, std::mem_fn(&Caches::hasLabelCache_), view, vertex, label);
 }
 void VertexInfoCache::Invalidate(Vertex const *vertex, LabelId label) {
   new_.labelCache_.erase(vertex);
-  // new_.hasLabelCache_.erase(std::tuple{vertex, label});
+  new_.hasLabelCache_.erase(std::tuple{vertex, label});
 }
 
 auto VertexInfoCache::GetProperty(View view, Vertex const *vertex, PropertyId property) const
     -> std::optional<std::reference_wrapper<PropertyValue const>> {
-  // return FetchHelper<PropertyValue>(*this, std::mem_fn(&Caches::propertyValueCache_), view, vertex, property);
-  return std::nullopt;
+  return FetchHelper<PropertyValue>(*this, std::mem_fn(&Caches::propertyValueCache_), view, vertex, property);
 }
 void VertexInfoCache::StoreProperty(View view, Vertex const *vertex, PropertyId property, PropertyValue value) {
-  // Store(std::move(value), *this, std::mem_fn(&Caches::propertyValueCache_), view, vertex, property);
+  Store(std::move(value), *this, std::mem_fn(&Caches::propertyValueCache_), view, vertex, property);
 }
 auto VertexInfoCache::GetProperties(View view, Vertex const *vertex) const
     -> std::optional<std::reference_wrapper<std::map<PropertyId, PropertyValue> const>> {
   return FetchHelper<std::map<PropertyId, PropertyValue>>(*this, std::mem_fn(&Caches::propertiesCache_), view, vertex);
 }
 void VertexInfoCache::StoreProperties(View view, Vertex const *vertex, std::map<PropertyId, PropertyValue> properties) {
-  // Store(std::move(properties), *this, std::mem_fn(&Caches::propertiesCache_), view, vertex);
+  Store(std::move(properties), *this, std::mem_fn(&Caches::propertiesCache_), view, vertex);
 }
 void VertexInfoCache::Invalidate(Vertex const *vertex, PropertyId property_key) {
   new_.propertiesCache_.erase(vertex);
-  // new_.propertyValueCache_.erase(std::tuple{vertex, property_key});
+  new_.propertyValueCache_.erase(std::tuple{vertex, property_key});
 }
 
 auto VertexInfoCache::GetInEdges(View view, Vertex const *src_vertex, Vertex const *dst_vertex,
@@ -131,8 +126,8 @@ auto VertexInfoCache::GetInEdges(View view, Vertex const *src_vertex, Vertex con
 }
 void VertexInfoCache::StoreInEdges(View view, Vertex const *src_vertex, Vertex const *dst_vertex,
                                    std::vector<EdgeTypeId> edge_types, EdgeStore in_edges) {
-  // Store(std::move(in_edges), *this, std::mem_fn(&Caches::inEdgesCache_), view, src_vertex, dst_vertex,
-  //       std::move(edge_types));
+  Store(std::move(in_edges), *this, std::mem_fn(&Caches::inEdgesCache_), view, src_vertex, dst_vertex,
+        std::move(edge_types));
 }
 auto VertexInfoCache::GetOutEdges(View view, Vertex const *src_vertex, Vertex const *dst_vertex,
                                   const std::vector<EdgeTypeId> &edge_types) const
@@ -141,8 +136,8 @@ auto VertexInfoCache::GetOutEdges(View view, Vertex const *src_vertex, Vertex co
 }
 void VertexInfoCache::StoreOutEdges(View view, Vertex const *src_vertex, Vertex const *dst_vertex,
                                     std::vector<EdgeTypeId> edge_types, EdgeStore out_edges) {
-  // Store(std::move(out_edges), *this, std::mem_fn(&Caches::outEdgesCache_), view, src_vertex, dst_vertex,
-  //      std::move(edge_types));
+  Store(std::move(out_edges), *this, std::mem_fn(&Caches::outEdgesCache_), view, src_vertex, dst_vertex,
+        std::move(edge_types));
 }
 
 auto VertexInfoCache::GetInDegree(View view, Vertex const *vertex) const -> std::optional<std::size_t> {
@@ -150,7 +145,7 @@ auto VertexInfoCache::GetInDegree(View view, Vertex const *vertex) const -> std:
 }
 
 void VertexInfoCache::StoreInDegree(View view, Vertex const *vertex, std::size_t in_degree) {
-  // Store(in_degree, *this, std::mem_fn(&Caches::inDegreeCache_), view, vertex);
+  Store(in_degree, *this, std::mem_fn(&Caches::inDegreeCache_), view, vertex);
 }
 
 auto VertexInfoCache::GetOutDegree(View view, Vertex const *vertex) const -> std::optional<std::size_t> {
@@ -158,7 +153,7 @@ auto VertexInfoCache::GetOutDegree(View view, Vertex const *vertex) const -> std
 }
 
 void VertexInfoCache::StoreOutDegree(View view, Vertex const *vertex, std::size_t out_degree) {
-  // Store(out_degree, *this, std::mem_fn(&Caches::outDegreeCache_), view, vertex);
+  Store(out_degree, *this, std::mem_fn(&Caches::outDegreeCache_), view, vertex);
 }
 
 void VertexInfoCache::Invalidate(Vertex const *vertex, EdgeTypeId /*unused*/, EdgeDirection direction) {
@@ -180,8 +175,8 @@ void VertexInfoCache::Clear() {
 void VertexInfoCache::Caches::Clear() {
   existsCache_.clear();
   deletedCache_.clear();
-  // hasLabelCache_.clear();
-  // propertyValueCache_.clear();
+  hasLabelCache_.clear();
+  propertyValueCache_.clear();
   labelCache_.clear();
   propertiesCache_.clear();
   inEdgesCache_.clear();

src/system/include/system/action.hpp

@@ -26,14 +26,12 @@ struct ISystemAction {
   /// Durability step which is defered until commit time
   virtual void DoDurability() = 0;
 
-#ifdef MG_ENTERPRISE
   /// Prepare the RPC payload that will be sent to all replicas clients
   virtual bool DoReplication(memgraph::replication::ReplicationClient &client, const utils::UUID &main_uuid,
                              memgraph::replication::ReplicationEpoch const &epoch,
                              Transaction const &system_tx) const = 0;
 
   virtual void PostReplication(memgraph::replication::RoleMainData &main_data) const = 0;
-#endif
 
   virtual ~ISystemAction() = default;
 };

src/system/include/system/transaction.hpp

@@ -57,13 +57,11 @@ struct Transaction {
       /// durability
       action->DoDurability();
 
-#ifdef MG_ENTERPRISE
-      /// replication
+      /// replication prep
       auto action_sync_status = handler.ApplyAction(*action, *this);
       if (action_sync_status != AllSyncReplicaStatus::AllCommitsConfirmed) {
         sync_status = AllSyncReplicaStatus::SomeCommitsUnconfirmed;
       }
-#endif
 
       actions_.pop_front();
     }
@@ -95,7 +93,6 @@ struct Transaction {
   std::list<std::unique_ptr<ISystemAction>> actions_;
 };
 
-#ifdef MG_ENTERPRISE
 struct DoReplication {
   explicit DoReplication(replication::RoleMainData &main_data) : main_data_{main_data} {}
   auto ApplyAction(ISystemAction const &action, Transaction const &system_tx) -> AllSyncReplicaStatus {
@@ -116,7 +113,6 @@ struct DoReplication {
   replication::RoleMainData &main_data_;
 };
 static_assert(ReplicationPolicy<DoReplication>);
-#endif
 
 struct DoNothing {
   auto ApplyAction(ISystemAction const & /*action*/, Transaction const & /*system_tx*/) -> AllSyncReplicaStatus {

src/utils/exceptions.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
@@ -41,26 +41,12 @@ namespace memgraph::utils {
  */
 class BasicException : public std::exception {
  public:
-  /**
-   * @brief Constructor (C++ STL strings_view).
-   *
-   * @param message The error message.
-   */
-  explicit BasicException(std::string_view message) noexcept : msg_(message) {}
-
-  /**
-   * @brief Constructor (string literal).
-   *
-   * @param message The error message.
-   */
-  explicit BasicException(const char *message) noexcept : msg_(message) {}
-
   /**
    * @brief Constructor (C++ STL strings).
    *
    * @param message The error message.
    */
-  explicit BasicException(std::string message) noexcept : msg_(std::move(message)) {}
+  explicit BasicException(std::string_view message) noexcept : msg_(message) {}
 
   /**
    * @brief Constructor with format string (C++ STL strings).

src/utils/functional.hpp

@@ -1,27 +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 <algorithm>
-#include <vector>
-
-namespace memgraph::utils {
-
-template <class F, class T, class R = typename std::result_of<F(T)>::type, class V = std::vector<R>>
-V fmap(F &&f, const std::vector<T> &v) {
-  V r;
-  r.reserve(v.size());
-  std::ranges::transform(v, std::back_inserter(r), std::forward<F>(f));
-  return r;
-}
-
-}  // namespace memgraph::utils

src/utils/memory_tracker.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
@@ -104,7 +104,7 @@ void MemoryTracker::SetMaximumHardLimit(const int64_t limit) {
   maximum_hard_limit_ = limit;
 }
 
-bool MemoryTracker::Alloc(int64_t const size) {
+void MemoryTracker::Alloc(const int64_t size) {
   MG_ASSERT(size >= 0, "Negative size passed to the MemoryTracker.");
 
   const int64_t will_be = size + amount_.fetch_add(size, std::memory_order_relaxed);
@@ -116,13 +116,12 @@ bool MemoryTracker::Alloc(int64_t const size) {
 
     amount_.fetch_sub(size, std::memory_order_relaxed);
 
-    // register our error data, we will pick this up on the other side of jemalloc
-    MemoryErrorStatus().set({size, will_be, current_hard_limit});
-
-    return false;
+    throw OutOfMemoryException(
+        fmt::format("Memory limit exceeded! Attempting to allocate a chunk of {} which would put the current "
+                    "use to {}, while the maximum allowed size for allocation is set to {}.",
+                    GetReadableSize(size), GetReadableSize(will_be), GetReadableSize(current_hard_limit)));
   }
   UpdatePeak(will_be);
-  return true;
 }
 
 void MemoryTracker::DoCheck() {
@@ -140,23 +139,4 @@ void MemoryTracker::DoCheck() {
 
 void MemoryTracker::Free(const int64_t size) { amount_.fetch_sub(size, std::memory_order_relaxed); }
 
-// DEVNOTE: important that this is allocated at thread construction time
-//          otherwise subtle bug where jemalloc will try to lock an non-recursive mutex
-//          that it already owns
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-thread_local MemoryTrackerStatus status;
-auto MemoryErrorStatus() -> MemoryTrackerStatus & { return status; }
-
-auto MemoryTrackerStatus::msg() -> std::optional<std::string> {
-  if (!data_) return std::nullopt;
-
-  auto [size, will_be, hard_limit] = *data_;
-  data_.reset();
-  return fmt::format(
-      "Memory limit exceeded! Attempting to allocate a chunk of {} which would put the current "
-      "use to {}, while the maximum allowed size for allocation is set to {}.",
-      // NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
-      GetReadableSize(size), GetReadableSize(will_be), GetReadableSize(hard_limit));
-}
-
 }  // namespace memgraph::utils

src/utils/memory_tracker.hpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -12,35 +12,15 @@
 #pragma once
 
 #include <atomic>
-#include <optional>
-#include <string>
 #include <type_traits>
 
 #include "utils/exceptions.hpp"
 
 namespace memgraph::utils {
 
-struct MemoryTrackerStatus {
-  struct data {
-    int64_t size;
-    int64_t will_be;
-    int64_t hard_limit;
-  };
-
-  // DEVNOTE: Do not call from within allocator, will cause another allocation
-  auto msg() -> std::optional<std::string>;
-
-  void set(data d) { data_ = d; }
-
- private:
-  std::optional<data> data_;
-};
-
-auto MemoryErrorStatus() -> MemoryTrackerStatus &;
-
 class OutOfMemoryException : public utils::BasicException {
  public:
-  explicit OutOfMemoryException(std::string msg) : utils::BasicException(std::move(msg)) {}
+  explicit OutOfMemoryException(const std::string &msg) : utils::BasicException(msg) {}
   SPECIALIZE_GET_EXCEPTION_NAME(OutOfMemoryException)
 };
 
@@ -67,7 +47,7 @@ class MemoryTracker final {
 
   MemoryTracker &operator=(MemoryTracker &&) = delete;
 
-  bool Alloc(int64_t size);
+  void Alloc(int64_t size);
   void Free(int64_t size);
   void DoCheck();
 

src/utils/query_memory_tracker.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
@@ -17,19 +17,18 @@
 
 namespace memgraph::utils {
 
-bool QueryMemoryTracker::TrackAlloc(size_t size) {
+void QueryMemoryTracker::TrackAlloc(size_t size) {
   if (query_tracker_.has_value()) [[likely]] {
-    bool ok = query_tracker_->Alloc(static_cast<int64_t>(size));
-    if (!ok) return false;
+    query_tracker_->Alloc(static_cast<int64_t>(size));
   }
 
   auto *proc_tracker = GetActiveProc();
 
   if (proc_tracker == nullptr) {
-    return true;
+    return;
   }
 
-  return proc_tracker->Alloc(static_cast<int64_t>(size));
+  proc_tracker->Alloc(static_cast<int64_t>(size));
 }
 void QueryMemoryTracker::TrackFree(size_t size) {
   if (query_tracker_.has_value()) [[likely]] {

src/utils/query_memory_tracker.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
@@ -44,7 +44,7 @@ class QueryMemoryTracker {
   ~QueryMemoryTracker() = default;
 
   // Track allocation on query and procedure if active
-  bool TrackAlloc(size_t size);
+  void TrackAlloc(size_t);
 
   // Track Free on query and procedure if active
   void TrackFree(size_t);

src/utils/typeinfo.hpp

@@ -107,13 +107,6 @@ enum class TypeId : uint64_t {
   COORD_SET_REPL_MAIN_RES,
   COORD_SWAP_UUID_REQ,
   COORD_SWAP_UUID_RES,
-  COORD_UNREGISTER_REPLICA_REQ,
-  COORD_UNREGISTER_REPLICA_RES,
-  COORD_ENABLE_WRITING_ON_MAIN_REQ,
-  COORD_ENABLE_WRITING_ON_MAIN_RES,
-
-  COORD_GET_UUID_REQ,
-  COORD_GET_UUID_RES,
 
   // AST
   AST_LABELIX = 3000,

tests/drivers/go/v4/metadata.go

@@ -47,12 +47,9 @@ func check_tx(driver neo4j.Driver) {
     log.Fatal("An error occurred while creating a session: %s", err)
   }
 
+  defer session.Close()
 
   result, err := session.Run("SHOW TRANSACTIONS", nil)
-  if err != nil {
-    log.Fatal("An error occurred while running a query: %s", err)
-  }
-  defer session.Close()
   check_md(result, err)
 }
 
@@ -86,7 +83,7 @@ func main() {
     handle_error(err)
   }
   tx.Run("MATCH (n) RETURN n LIMIT 1", map[string]interface{}{})
-  check_tx(driver)
+  go check_tx(driver)
   tx.Commit()
 
   fmt.Println("All ok!")

tests/e2e/CMakeLists.txt

@@ -56,7 +56,7 @@ add_subdirectory(python_query_modules_reloading)
 add_subdirectory(analyze_graph)
 add_subdirectory(transaction_queue)
 add_subdirectory(mock_api)
-#add_subdirectory(graphql)
+add_subdirectory(graphql)
 add_subdirectory(disk_storage)
 add_subdirectory(load_csv)
 add_subdirectory(init_file_flags)
@@ -76,13 +76,15 @@ add_subdirectory(queries)
 add_subdirectory(query_modules_storage_modes)
 add_subdirectory(garbage_collection)
 add_subdirectory(query_planning)
-add_subdirectory(awesome_functions)
 
 if (MG_EXPERIMENTAL_HIGH_AVAILABILITY)
   add_subdirectory(high_availability_experimental)
 endif ()
 
-add_subdirectory(replication_experimental)
+
+if (MG_EXPERIMENTAL_REPLICATION_MULTITENANCY)
+  add_subdirectory(replication_experimental)
+endif ()
 
 copy_e2e_python_files(pytest_runner pytest_runner.sh "")
 copy_e2e_python_files(x x.sh "")

tests/e2e/awesome_functions/CMakeLists.txt

@@ -1,6 +0,0 @@
-function(copy_awesome_functions_e2e_python_files FILE_NAME)
-    copy_e2e_python_files(awesome_functions ${FILE_NAME})
-endfunction()
-
-copy_awesome_functions_e2e_python_files(common.py)
-copy_awesome_functions_e2e_python_files(awesome_functions.py)

tests/e2e/awesome_functions/awesome_functions.py

@@ -1,269 +0,0 @@
-# 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
-# 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.
-
-import sys
-
-import pytest
-from common import get_bytes, memgraph
-
-
-def test_property_size_on_null_prop(memgraph):
-    memgraph.execute(
-        """
-        CREATE (n:Node)
-        SET n.null_prop = null;
-        """
-    )
-
-    null_bytes = get_bytes(memgraph, "null_prop")
-
-    # No property stored, no bytes allocated
-    assert null_bytes == 0
-
-
-def test_property_size_on_bool_prop(memgraph):
-    memgraph.execute(
-        """
-        CREATE (n:Node)
-        SET n.bool_prop = True;
-        """
-    )
-
-    bool_bytes = get_bytes(memgraph, "bool_prop")
-
-    # 1 byte metadata, 1 byte prop id, but value is encoded in the metadata
-    assert bool_bytes == 2
-
-
-def test_property_size_on_one_byte_int_prop(memgraph):
-    memgraph.execute(
-        """
-        CREATE (n:Node)
-        SET n.S_int_prop = 4;
-        """
-    )
-
-    s_int_bytes = get_bytes(memgraph, "S_int_prop")
-
-    # 1 byte metadata, 1 byte prop id + payload size 1 byte to store the int
-    assert s_int_bytes == 3
-
-
-def test_property_size_on_two_byte_int_prop(memgraph):
-    memgraph.execute(
-        """
-        CREATE (n:Node)
-        SET n.M_int_prop = 500;
-        """
-    )
-
-    m_int_bytes = get_bytes(memgraph, "M_int_prop")
-
-    # 1 byte metadata, 1 byte prop id + payload size 2 bytes to store the int
-    assert m_int_bytes == 4
-
-
-def test_property_size_on_four_byte_int_prop(memgraph):
-    memgraph.execute(
-        """
-        CREATE (n:Node)
-        SET n.L_int_prop = 1000000000;
-        """
-    )
-
-    l_int_bytes = get_bytes(memgraph, "L_int_prop")
-
-    # 1 byte metadata, 1 byte prop id + payload size 4 bytes to store the int
-    assert l_int_bytes == 6
-
-
-def test_property_size_on_eight_byte_int_prop(memgraph):
-    memgraph.execute(
-        """
-        CREATE (n:Node)
-        SET n.XL_int_prop = 1000000000000;
-        """
-    )
-
-    xl_int_bytes = get_bytes(memgraph, "XL_int_prop")
-
-    # 1 byte metadata, 1 byte prop id + payload size 8 bytes to store the int
-    assert xl_int_bytes == 10
-
-
-def test_property_size_on_float_prop(memgraph):
-    memgraph.execute(
-        """
-        CREATE (n:Node)
-        SET n.float_prop = 4.0;
-        """
-    )
-
-    float_bytes = get_bytes(memgraph, "float_prop")
-
-    # 1 byte metadata, 1 byte prop id + payload size 8 bytes to store the float
-    assert float_bytes == 10
-
-
-def test_property_size_on_string_prop(memgraph):
-    memgraph.execute(
-        """
-        CREATE (n:Node)
-        SET n.str_prop = 'str_value';
-        """
-    )
-
-    str_bytes = get_bytes(memgraph, "str_prop")
-
-    # 1 byte metadata
-    # 1 byte prop id
-    #   - the payload size contains the amount of bytes stored for the size in the next sequence
-    # X bytes for the length of the string (1, 2, 4 or 8 bytes) -> "str_value" has 1 byte for the length of 9
-    # Y bytes for the string content -> 9 bytes for "str_value"
-    assert str_bytes == 12
-
-
-def test_property_size_on_list_prop(memgraph):
-    memgraph.execute(
-        """
-        CREATE (n:Node)
-        SET n.list_prop = [1, 2, 3];
-        """
-    )
-
-    list_bytes = get_bytes(memgraph, "list_prop")
-
-    # 1 byte metadata
-    # 1 byte prop id
-    #   - the payload size contains the amount of bytes stored for the size of the list
-    # X bytes for the size of the list (1, 2, 4 or 8 bytes)
-    # for each list element:
-    #   - 1 byte for the metadata
-    #   - the amount of bytes for the payload of the type (a small int is 1 additional byte)
-    # in this case 1 + 1 + 3 * (1 + 1)
-    assert list_bytes == 9
-
-
-def test_property_size_on_map_prop(memgraph):
-    memgraph.execute(
-        """
-        CREATE (n:Node)
-        SET  n.map_prop = {key1: 'value', key2: 4};
-        """
-    )
-
-    map_bytes = get_bytes(memgraph, "map_prop")
-
-    # 1 byte metadata
-    # 1 byte prop id
-    #   - the payload size contains the amount of bytes stored for the size of the map
-    # X bytes for the size of the map (1, 2, 4 or 8 bytes - in this case 1)
-    # for every map element:
-    #   - 1 byte for metadata
-    #   - 1, 2, 4 or 8 bytes for the key length (read from the metadata payload) -> this case 1
-    #   - Y bytes for the key content -> this case 4
-    #   - Z amount of bytes for the type
-    #       - for 'value' -> 1 byte for size and 5 for length
-    #       - for 4 -> 1 byte for content read from payload
-    # total: 1 + 1 + (1 + 1 + 4 + (1 + 5)) + (1 + 1 + 4 + (1))
-    assert map_bytes == 22
-
-
-def test_property_size_on_date_prop(memgraph):
-    memgraph.execute(
-        """
-        CREATE (n:Node)
-        SET n.date_prop = date('2023-01-01');
-        """
-    )
-
-    date_bytes = get_bytes(memgraph, "date_prop")
-
-    # 1 byte metadata (to see that it's temporal data)
-    # 1 byte prop id
-    # 1 byte metadata
-    #   - type is again the same
-    #   - id field contains the length of the specific temporal type (1, 2, 4 or 8 bytes) -> probably always 1
-    #   - payload field contains the length of the microseconds (1, 2, 4, or 8 bytes) -> probably always 8
-    assert date_bytes == 12
-
-
-def test_property_size_on_local_time_prop(memgraph):
-    memgraph.execute(
-        """
-        CREATE (n:Node)
-        SET n.localtime_prop = localtime('23:00:00');
-        """
-    )
-
-    local_time_bytes = get_bytes(memgraph, "localtime_prop")
-
-    # 1 byte metadata (to see that it's temporal data)
-    # 1 byte prop id
-    # 1 byte metadata
-    #   - type is again the same
-    #   - id field contains the length of the specific temporal type (1, 2, 4 or 8 bytes) -> probably always 1
-    #   - payload field contains the length of the microseconds (1, 2, 4, or 8 bytes) -> probably always 8
-    assert local_time_bytes == 12
-
-
-def test_property_size_on_local_date_time_prop(memgraph):
-    memgraph.execute(
-        """
-        CREATE (n:Node)
-        SET n.localdatetime_prop = localdatetime('2022-01-01T23:00:00');
-        """
-    )
-
-    local_date_time_bytes = get_bytes(memgraph, "localdatetime_prop")
-
-    # 1 byte metadata (to see that it's temporal data)
-    # 1 byte prop id
-    # 1 byte metadata
-    #   - type is again the same
-    #   - id field contains the length of the specific temporal type (1, 2, 4 or 8 bytes) -> probably always 1
-    #   - payload field contains the length of the microseconds (1, 2, 4, or 8 bytes) -> probably always 8
-    assert local_date_time_bytes == 12
-
-
-def test_property_size_on_duration_prop(memgraph):
-    memgraph.execute(
-        """
-        CREATE (n:Node)
-        SET n.duration_prop = duration('P5DT2M2.33S');
-        """
-    )
-
-    duration_bytes = get_bytes(memgraph, "duration_prop")
-
-    # 1 byte metadata (to see that it's temporal data)
-    # 1 byte prop id
-    # 1 byte metadata
-    #   - type is again the same
-    #   - id field contains the length of the specific temporal type (1, 2, 4 or 8 bytes) -> probably always 1
-    #   - payload field contains the length of the microseconds (1, 2, 4, or 8 bytes) -> probably always 8
-    assert duration_bytes == 12
-
-
-def test_property_size_on_nonexistent_prop(memgraph):
-    memgraph.execute(
-        """
-        CREATE (n:Node);
-        """
-    )
-
-    nonexistent_bytes = get_bytes(memgraph, "nonexistent_prop")
-
-    assert nonexistent_bytes == 0
-
-
-if __name__ == "__main__":
-    sys.exit(pytest.main([__file__, "-rA"]))

tests/e2e/awesome_functions/common.py

@@ -1,29 +0,0 @@
-# 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
-# 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.
-
-import pytest
-from gqlalchemy import Memgraph
-
-
-@pytest.fixture
-def memgraph(**kwargs) -> Memgraph:
-    memgraph = Memgraph()
-
-    yield memgraph
-
-    memgraph.drop_indexes()
-    memgraph.ensure_constraints([])
-    memgraph.drop_database()
-
-
-def get_bytes(memgraph, prop_name):
-    res = list(memgraph.execute_and_fetch(f"MATCH (n) RETURN propertySize(n, '{prop_name}') AS size"))
-    return res[0]["size"]

tests/e2e/awesome_functions/workloads.yaml

@@ -1,14 +0,0 @@
-awesome_functions_cluster: &awesome_functions_cluster
-  cluster:
-    main:
-      args: ["--bolt-port", "7687", "--log-level=TRACE"]
-      log_file: "awesome_functions.log"
-      setup_queries: []
-      validation_queries: []
-
-
-workloads:
-  - name: "Awesome Functions"
-    binary: "tests/e2e/pytest_runner.sh"
-    args: ["awesome_functions/awesome_functions.py"]
-    <<: *awesome_functions_cluster

tests/e2e/configuration/default_config.py

@@ -69,9 +69,6 @@ startup_config_dict = {
     "coordinator_server_port": ("0", "0", "Port on which coordinator servers will be started."),
     "raft_server_port": ("0", "0", "Port on which raft servers will be started."),
     "raft_server_id": ("0", "0", "Unique ID of the raft server."),
-    "instance_down_timeout_sec": ("5", "5", "Time duration after which an instance is considered down."),
-    "instance_health_check_frequency_sec": ("1", "1", "The time duration between two health checks/pings."),
-    "instance_get_uuid_frequency_sec": ("10", "10", "The time duration between two instance uuid checks."),
     "data_directory": ("mg_data", "mg_data", "Path to directory in which to save all permanent data."),
     "data_recovery_on_startup": (
         "false",
@@ -225,9 +222,4 @@ startup_config_dict = {
         "128",
         "The threshold for when to cache long delta chains. This is used for heavy read + write workloads where repeated processing of delta chains can become costly.",
     ),
-    "experimental_enabled": (
-        "",
-        "",
-        "Experimental features to be used, comma seperated. Options [system-replication]",
-    ),
 }