Merge branch 'master' into add-mgbuilder-workflow

.clang-format

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

.clang-tidy

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

.github/ISSUE_TEMPLATE/bug_report.md

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

.github/workflows/diff.yaml

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

.github/workflows/release_debian10.yaml

@@ -1,7 +1,4 @@
 name: Release Debian 10
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref_name }}
-  cancel-in-progress: true
 
 on:
   workflow_dispatch:
@@ -13,12 +10,7 @@ on:
         options:
           - Release
           - RelWithDebInfo
-  push:
-    branches:
-      - "release/**"
-    tags:
-      - "v*.*.*-rc*"
-      - "v*.*-rc*"
+
   schedule:
     - cron: "0 22 * * *"
 
@@ -32,7 +24,7 @@ jobs:
   community_build:
     name: "Community build"
     runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
+    timeout-minutes: 90
 
     steps:
       - name: Set up repository
@@ -71,7 +63,7 @@ jobs:
       THREADS: 24
       MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
       MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
-    timeout-minutes: 60
+    timeout-minutes: 90
 
     steps:
       - name: Set up repository
@@ -125,7 +117,7 @@ jobs:
   debug_build:
     name: "Debug build"
     runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
+    timeout-minutes: 90
 
     steps:
       - name: Set up repository
@@ -179,7 +171,7 @@ jobs:
   debug_integration_test:
     name: "Debug integration tests"
     runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
+    timeout-minutes: 90
 
     steps:
       - name: Set up repository
@@ -209,7 +201,7 @@ jobs:
   release_build:
     name: "Release build"
     runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
+    timeout-minutes: 90
 
     steps:
       - name: Set up repository
@@ -280,7 +272,7 @@ jobs:
   release_benchmark_tests:
     name: "Release Benchmark Tests"
     runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
+    timeout-minutes: 90
 
     steps:
       - name: Set up repository
@@ -329,9 +321,10 @@ jobs:
             --no-strict
 
   release_e2e_test:
+    if: false
     name: "Release End-to-end Test"
     runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
+    timeout-minutes: 90
 
     steps:
       - name: Set up repository
@@ -379,7 +372,7 @@ jobs:
   release_durability_stress_tests:
     name: "Release durability and stress tests"
     runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
+    timeout-minutes: 90
 
     steps:
       - name: Set up repository
@@ -427,7 +420,7 @@ jobs:
   release_jepsen_test:
     name: "Release Jepsen Test"
     runs-on: [self-hosted, Linux, X64, Debian10, JepsenControl]
-    timeout-minutes: 60
+    timeout-minutes: 90
 
     steps:
       - name: Set up repository

.github/workflows/release_mgbuilder.yml

@@ -0,0 +1,190 @@
+name: Publish memgraph-builder docker images
+
+on:
+  workflow_dispatch:
+    inputs:
+      toolchain_version:
+        type: choice
+        description: "Toolchain version for the builder"
+        options:
+          - v4
+          - v5
+      target_os:
+        type: choice
+        description: "Target OS for the builder"
+        default: 'debian-11'
+        options:
+          - all
+          - all-amd64
+          - all-arm
+          - amzn-2
+          - centos-7
+          - centos-9
+          - debian-10
+          - debian-11
+          - debian-11-arm
+          - fedora-36
+          - ubuntu-18_04
+          - ubuntu-20_04
+          - ubuntu-22_04
+          - ubuntu-22_04-arm
+      force_release:
+        type: boolean
+        description: "Overwrite existing image on dockerhub"
+        required: false
+        default: false
+
+jobs:
+  amd_build:
+    if: ${{ !startsWith(github.event.inputs.target_os, 'all') && !endsWith(github.event.inputs.target_os, '-arm') }}
+    name: "Build and publish specific amd64 image"
+    runs-on: [self-hosted, DockerMgBuild, X64]
+    env:
+      DOCKER_ORG: "memgraph"
+      DOCKER_REPO: "memgraph-builder"
+      DOCKER_IMAGE_TAG: "${{ github.event.inputs.toolchain_version }}_${{ github.event.inputs.target_os }}"
+      ARCHITECTURE: "amd64"
+    steps:
+      - name: "Set up repository"
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0 # Required because of release/get_version.py
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Check if specified image is already pushed
+        run: |
+          if [[ $FORCE_RELEASE = true ]]; then
+            EXISTS=1
+          else
+            EXISTS=$(docker manifest inspect $DOCKER_ORG/$DOCKER_REPO:$DOCKER_IMAGE_TAG > /dev/null; echo $?)
+          fi
+          if [[ $EXISTS -eq 0 ]]; then
+            echo "Image $DOCKER_ORG/$DOCKER_REPO:$DOCKER_IMAGE_TAG already exists, skipping next step ..."
+          fi
+          echo "EXISTS=$EXISTS" >> $GITHUB_ENV
+      - name: "Build and publish image" 
+        if: env.EXISTS == 1
+        run: |
+          echo "Building and publishing $DOCKER_ORG/$DOCKER_REPO:$DOCKER_IMAGE_TAG"
+          ./release/package/run.sh build ${{ github.event.inputs.toolchain_version }} ${{ github.event.inputs.target_os }} $ARCHITECTURE --publish
+
+  arm_build:
+    if: ${{ !startsWith(github.event.inputs.target_os, 'all') && endsWith(github.event.inputs.target_os, '-arm') }}
+    name: "Build and publish specific arm image"
+    runs-on: [self-hosted, DockerMgBuild, ARM64, strange]
+    env:
+      DOCKER_ORG: "memgraph"
+      DOCKER_REPO: "memgraph-builder"
+      DOCKER_IMAGE_TAG: "${{ github.event.inputs.toolchain_version }}_${{ github.event.inputs.target_os }}"
+      ARCHITECTURE: "arm64"
+    steps:
+      - name: "Set up repository"
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0 # Required because of release/get_version.py
+      - name: "Unlock keychain for current session" # Required beacuse ARM builds run on macos
+        run: security -v unlock-keychain -p ${{ secrets.SELF_HOSTED_RUNNER_PASSWORD }} ~/Library/Keychains/login.keychain-db
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Check if specified image is already pushed
+        run: |
+          if [[ $FORCE_RELEASE = true ]]; then
+            EXISTS=1
+          else
+            EXISTS=$(docker manifest inspect $DOCKER_ORG/$DOCKER_REPO:$DOCKER_IMAGE_TAG > /dev/null; echo $?)
+          fi
+          if [[ $EXISTS -eq 0 ]]; then
+            echo "Image $DOCKER_ORG/$DOCKER_REPO:$DOCKER_IMAGE_TAG already exists, skipping next step ..."
+          fi
+          echo "EXISTS=$EXISTS" >> $GITHUB_ENV
+      - name: "Build and publish image" 
+        if: env.EXISTS == 1
+        run: |
+          echo "Building and publishing $DOCKER_ORG/$DOCKER_REPO:$DOCKER_IMAGE_TAG"
+          ./release/package/run.sh build ${{ github.event.inputs.toolchain_version }} ${{ github.event.inputs.target_os }} $ARCHITECTURE --publish
+
+  all_amd_build:
+    if: ${{ github.event.inputs.target_os == 'all-amd64' ||  github.event.inputs.target_os == 'all'}}
+    name: "Build and publish all amd64 images"
+    runs-on: [self-hosted, DockerMgBuild, X64]
+    strategy:
+      matrix:
+        target_os: [amzn-2, centos-7, centos-9, debian-10, debian-11, fedora-36, ubuntu-18_04, ubuntu-20_04, ubuntu-22_04]
+    env:
+      DOCKER_ORG: "memgraph"
+      DOCKER_REPO: "memgraph-builder"
+      DOCKER_IMAGE_TAG: "${{ github.event.inputs.toolchain_version }}_${{ github.event.inputs.target_os }}"
+      ARCHITECTURE: "amd64"
+    steps:
+      - name: "Set up repository"
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0 # Required because of release/get_version.py
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Check if specified image is already pushed
+        run: |
+          if [[ $FORCE_RELEASE = true ]]; then
+            EXISTS=1
+          else
+            EXISTS=$(docker manifest inspect $DOCKER_ORG/$DOCKER_REPO:$DOCKER_IMAGE_TAG > /dev/null; echo $?)
+          fi
+          if [[ $EXISTS -eq 0 ]]; then
+            echo "Image $DOCKER_ORG/$DOCKER_REPO:$DOCKER_IMAGE_TAG already exists, skipping next step ..."
+          fi
+          echo "EXISTS=$EXISTS" >> $GITHUB_ENV
+      - name: "Build and publish image" 
+        if: env.EXISTS == 1
+        run: |
+          echo "Building and publishing $DOCKER_ORG/$DOCKER_REPO:$DOCKER_IMAGE_TAG"
+          ./release/package/run.sh build ${{ github.event.inputs.toolchain_version }} ${{ github.event.inputs.target_os }} $ARCHITECTURE --publish
+
+  all_arm_build:
+    if: ${{ github.event.inputs.target_os == 'all-arm' ||  github.event.inputs.target_os == 'all'}}
+    name: "Build and publish all arm images"
+    runs-on: [self-hosted, DockerMgBuild, ARM64, strange]
+    strategy:
+      matrix:
+        target_os: [debian-11-arm, ubuntu-22_04-arm]
+    env:
+      DOCKER_ORG: "memgraph"
+      DOCKER_REPO: "memgraph-builder"
+      DOCKER_IMAGE_TAG: "${{ github.event.inputs.toolchain_version }}_${{ github.event.inputs.target_os }}"
+      ARCHITECTURE: "arm64"
+    steps:
+      - name: "Set up repository"
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0 # Required because of release/get_version.py
+      - name: "Unlock keychain for current session" # Required beacuse ARM builds run on macos
+        run: security -v unlock-keychain -p ${{ secrets.SELF_HOSTED_RUNNER_PASSWORD }} ~/Library/Keychains/login.keychain-db
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Check if specified image is already pushed
+        run: |
+          if [[ $FORCE_RELEASE = true ]]; then
+            EXISTS=1
+          else
+            EXISTS=$(docker manifest inspect $DOCKER_ORG/$DOCKER_REPO:$DOCKER_IMAGE_TAG > /dev/null; echo $?)
+          fi
+          if [[ $EXISTS -eq 0 ]]; then
+            echo "Image $DOCKER_ORG/$DOCKER_REPO:$DOCKER_IMAGE_TAG already exists, skipping next step ..."
+          fi
+          echo "EXISTS=$EXISTS" >> $GITHUB_ENV
+      - name: "Build and publish image" 
+        if: env.EXISTS == 1
+        run: |
+          echo "Building and publishing $DOCKER_ORG/$DOCKER_REPO:$DOCKER_IMAGE_TAG"
+          ./release/package/run.sh build ${{ github.event.inputs.toolchain_version }} ${{ github.event.inputs.target_os }} $ARCHITECTURE --publish

.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 * * *"
 
@@ -32,7 +24,7 @@ jobs:
   community_build:
     name: "Community build"
     runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
+    timeout-minutes: 90
 
     steps:
       - name: Set up repository
@@ -67,7 +59,7 @@ jobs:
   coverage_build:
     name: "Coverage build"
     runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
+    timeout-minutes: 90
 
     steps:
       - name: Set up repository
@@ -121,7 +113,7 @@ jobs:
   debug_build:
     name: "Debug build"
     runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
+    timeout-minutes: 90
 
     steps:
       - name: Set up repository
@@ -175,7 +167,7 @@ jobs:
   debug_integration_test:
     name: "Debug integration tests"
     runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
+    timeout-minutes: 90
 
     steps:
       - name: Set up repository
@@ -205,7 +197,7 @@ jobs:
   release_build:
     name: "Release build"
     runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
+    timeout-minutes: 90
 
     steps:
       - name: Set up repository
@@ -276,7 +268,7 @@ jobs:
   release_benchmark_tests:
     name: "Release Benchmark Tests"
     runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
+    timeout-minutes: 90
 
     steps:
       - name: Set up repository
@@ -325,9 +317,10 @@ 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
+    timeout-minutes: 90
 
     steps:
       - name: Set up repository
@@ -375,7 +368,7 @@ jobs:
   release_durability_stress_tests:
     name: "Release durability and stress tests"
     runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
+    timeout-minutes: 90
 
     steps:
       - name: Set up repository

.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 * * *"
 
@@ -29,7 +23,7 @@ env:
 jobs:
   stress_test_large:
     name: "Stress test large"
-    timeout-minutes: 720
+    timeout-minutes: 600
     strategy:
       matrix:
         os: [Debian10, Ubuntu20.04]

.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

ADRs/003_rocksdb.md

@@ -1,38 +0,0 @@
-# RocksDB ADR
-
-**Author**
-Marko Budiselic (github.com/gitbuda)
-
-**Status**
-ACCEPTED
-
-**Date**
-January 23, 2024
-
-**Problem**
-
-Interacting with data (reads and writes) on disk in a concurrent, safe, and
-fast way is a challenging task. Implementing all low-level primitives to
-interact with various disk hardware efficiently consumes significant
-engineering people. Whenever Memgraph has to store data on disk (or any
-other colder than RAM storage system), the problem is how to do that in the
-least amount of development time while satisfying all functional requirements
-(often performance).
-
-**Criteria**
-
-- working efficiently in a highly concurrent environment
-- easy integration with Memgraph's C++ codebase
-- providing low-level key-value API
-- heavily tested in production environments
-- providing abstractions for the storage hardware (even for cloud-based
-  storages like S3)
-
-**Decision**
-
-There are a few robust key-value stores, but finding one that is
-production-ready and compatible with Memgraph's C++ codebase is challenging.
-**We select [RocksDB](https://github.com/facebook/rocksdb)** because it
-delivers robust API to manage data on disk; it's battle-tested in many
-production environments (many databases systems are embedding RocksDB), and
-it's the most compatible one.

CMakeLists.txt

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

init

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

libs/CMakeLists.txt

@@ -294,10 +294,3 @@ set_path_external_library(jemalloc STATIC
   ${CMAKE_CURRENT_SOURCE_DIR}/jemalloc/include/)
 
 import_header_library(rangev3 ${CMAKE_CURRENT_SOURCE_DIR}/rangev3/include)
-
-# Setup NuRaft
-import_external_library(nuraft STATIC
-  ${CMAKE_CURRENT_SOURCE_DIR}/nuraft/lib/libnuraft.a
-  ${CMAKE_CURRENT_SOURCE_DIR}/nuraft/include/)
-find_package(OpenSSL REQUIRED)
-target_link_libraries(nuraft INTERFACE ${OPENSSL_LIBRARIES})

libs/setup.sh

@@ -123,10 +123,9 @@ declare -A primary_urls=(
   ["pulsar"]="http://$local_cache_host/git/pulsar.git"
   ["librdtsc"]="http://$local_cache_host/git/librdtsc.git"
   ["ctre"]="http://$local_cache_host/file/hanickadot/compile-time-regular-expressions/v3.7.2/single-header/ctre.hpp"
-  ["absl"]="http://$local_cache_host/git/abseil-cpp.git"
-  ["jemalloc"]="http://$local_cache_host/git/jemalloc.git"
-  ["range-v3"]="http://$local_cache_host/git/range-v3.git"
-  ["nuraft"]="http://$local_cache_host/git/NuRaft.git"
+  ["absl"]="https://$local_cache_host/git/abseil-cpp.git"
+  ["jemalloc"]="https://$local_cache_host/git/jemalloc.git"
+  ["range-v3"]="https://$local_cache_host/git/ericniebler/range-v3.git"
 )
 
 # The goal of secondary urls is to have links to the "source of truth" of
@@ -156,7 +155,6 @@ declare -A secondary_urls=(
   ["absl"]="https://github.com/abseil/abseil-cpp.git"
   ["jemalloc"]="https://github.com/jemalloc/jemalloc.git"
   ["range-v3"]="https://github.com/ericniebler/range-v3.git"
-  ["nuraft"]="https://github.com/eBay/NuRaft.git"
 )
 
 # antlr
@@ -270,8 +268,6 @@ pushd jemalloc
 MALLOC_CONF="retain:false,percpu_arena:percpu,oversize_threshold:0,muzzy_decay_ms:5000,dirty_decay_ms:5000" \
 ./configure \
   --disable-cxx \
-  --with-lg-page=12 \
-  --with-lg-hugepage=21 \
   --enable-shared=no --prefix=$working_dir \
   --with-malloc-conf="retain:false,percpu_arena:percpu,oversize_threshold:0,muzzy_decay_ms:5000,dirty_decay_ms:5000"
 
@@ -281,10 +277,3 @@ popd
 #range-v3 release-0.12.0
 range_v3_ref="release-0.12.0"
 repo_clone_try_double "${primary_urls[range-v3]}" "${secondary_urls[range-v3]}" "rangev3" "$range_v3_ref"
-
-# NuRaft
-nuraft_tag="v2.1.0"
-repo_clone_try_double "${primary_urls[nuraft]}" "${secondary_urls[nuraft]}" "nuraft" "$nuraft_tag" true
-pushd nuraft
-./prepare.sh
-popd

release/package/run.sh

@@ -10,15 +10,21 @@ SUPPORTED_OS=(
     fedora-36
     amzn-2
 )
-
+SUPPORTED_TOOLCAHINS=(
+    v4
+    v5
+  )
 SUPPORTED_BUILD_TYPES=(
     Debug
     Release
     RelWithDebInfo
 )
-
+SUPPORTED_ARCHITECTURES=(
+    amd64
+    arm64
+  )
 PROJECT_ROOT="$SCRIPT_DIR/../.."
-TOOLCHAIN_VERSION="toolchain-v4"
+TOOLCHAIN_VERSION="${TOOLCHAIN_VERSION:-toolchain-v4}"
 ACTIVATE_TOOLCHAIN="source /opt/${TOOLCHAIN_VERSION}/activate"
 HOST_OUTPUT_DIR="$PROJECT_ROOT/build/output"
 
@@ -30,6 +36,14 @@ print_help () {
     echo "    Build types: ${SUPPORTED_BUILD_TYPES[*]}"
     exit 1
 }
+print_help_build () {
+    echo "$0 build {toolchain_version} {os} {architecture} [--publish]"
+    echo ""
+    echo "    Toolchain versions: ${SUPPORTED_TOOLCAHINS[*]}"
+    echo "    OSs: ${SUPPORTED_OS[*]}"
+    echo "    Architectures: ${SUPPORTED_ARCHITECTURES[*]}"
+    exit 1
+}
 
 make_package () {
     os="$1"
@@ -187,15 +201,26 @@ case "$1" in
 
     build)
       shift 1
-      if [[ "$#" -ne 2 ]]; then
-          print_help
+      if [[ "$#" -lt 3 || "$#" -gt 4 ]]; then
+          print_help_build
       fi
       # in the vX format, e.g. v5
       toolchain_version="$1"
       # a name of the os folder, e.g. ubuntu-22.04-arm
       os="$2"
       cd "$SCRIPT_DIR/$os"
-      docker build -f Dockerfile --build-arg TOOLCHAIN_VERSION="toolchain-$toolchain_version" -t "memgraph/memgraph-builder:${toolchain_version}_$os" .
+      # architecture for which the image will be built, e.g. linux/arm64
+      architecture="$3"
+      if [[ "$#" -eq 4 ]]; then
+        if [[ "$4" == "--publish" ]]; then
+          docker buildx build --file Dockerfile --build-arg TOOLCHAIN_VERSION="toolchain-$toolchain_version" --platform "linux/$architecture" --tag "memgraph/memgraph-builder:${toolchain_version}_$os" --push .
+        else
+          print_help_build
+          exit
+        fi
+      else
+          docker buildx build --file Dockerfile --build-arg TOOLCHAIN_VERSION="toolchain-$toolchain_version" --platform "linux/$architecture" --tag "memgraph/memgraph-builder:${toolchain_version}_$os" .
+      fi
     ;;
 
     test)

src/CMakeLists.txt

@@ -22,10 +22,8 @@ add_subdirectory(dbms)
 add_subdirectory(flags)
 add_subdirectory(distributed)
 add_subdirectory(replication)
-add_subdirectory(replication_handler)
 add_subdirectory(coordination)
 add_subdirectory(replication_coordination_glue)
-add_subdirectory(system)
 
 string(TOLOWER ${CMAKE_BUILD_TYPE} lower_build_type)
 
@@ -45,10 +43,10 @@ set(mg_single_node_v2_sources
 add_executable(memgraph ${mg_single_node_v2_sources})
 target_include_directories(memgraph PUBLIC ${CMAKE_SOURCE_DIR}/include)
 target_link_libraries(memgraph stdc++fs Threads::Threads
-        mg-telemetry mg-communication mg-communication-metrics mg-memory mg-utils mg-license mg-settings mg-glue mg-flags mg::system mg::replication_handler)
+        mg-telemetry mg-communication mg-communication-metrics mg-memory mg-utils mg-license mg-settings mg-glue mg-flags)
 
 # NOTE: `include/mg_procedure.syms` describes a pattern match for symbols which
-# should be dynamically exported, so that `dlopen` can correctly link th
+# should be dynamically exported, so that `dlopen` can correctly link the
 # symbols in custom procedure module libraries.
 target_link_libraries(memgraph "-Wl,--dynamic-list=${CMAKE_SOURCE_DIR}/include/mg_procedure.syms")
 set_target_properties(memgraph PROPERTIES

src/auth/CMakeLists.txt

@@ -2,9 +2,7 @@ set(auth_src_files
     auth.cpp
     crypto.cpp
     models.cpp
-    module.cpp
-    rpc.cpp
-    replication_handlers.cpp)
+    module.cpp)
 
 find_package(Seccomp REQUIRED)
 find_package(fmt REQUIRED)
@@ -13,7 +11,7 @@ find_package(gflags REQUIRED)
 
 add_library(mg-auth STATIC ${auth_src_files})
 target_link_libraries(mg-auth json libbcrypt gflags fmt::fmt)
-target_link_libraries(mg-auth mg-utils mg-kvstore mg-license mg::system mg-replication)
+target_link_libraries(mg-auth mg-utils mg-kvstore mg-license )
 
 target_link_libraries(mg-auth ${Seccomp_LIBRARIES})
 target_include_directories(mg-auth SYSTEM PRIVATE ${Seccomp_INCLUDE_DIRS})

src/auth/auth.cpp

@@ -9,16 +9,13 @@
 #include "auth/auth.hpp"
 
 #include <iostream>
-#include <optional>
 #include <utility>
 
 #include <fmt/format.h>
 
 #include "auth/crypto.hpp"
 #include "auth/exceptions.hpp"
-#include "auth/rpc.hpp"
 #include "license/license.hpp"
-#include "system/transaction.hpp"
 #include "utils/flag_validation.hpp"
 #include "utils/message.hpp"
 #include "utils/settings.hpp"
@@ -44,89 +41,12 @@ DEFINE_VALIDATED_int32(auth_module_timeout_ms, 10000,
                        FLAG_IN_RANGE(100, 1800000));
 
 namespace memgraph::auth {
-
-namespace {
-#ifdef MG_ENTERPRISE
-/**
- * REPLICATION SYSTEM ACTION IMPLEMENTATIONS
- */
-struct UpdateAuthData : memgraph::system::ISystemAction {
-  explicit UpdateAuthData(User user) : user_{std::move(user)}, role_{std::nullopt} {}
-  explicit UpdateAuthData(Role role) : user_{std::nullopt}, role_{std::move(role)} {}
-
-  void DoDurability() override { /* Done during Auth execution */
-  }
-
-  bool DoReplication(replication::ReplicationClient &client, const utils::UUID &main_uuid,
-                     replication::ReplicationEpoch const &epoch,
-                     memgraph::system::Transaction const &txn) const override {
-    auto check_response = [](const replication::UpdateAuthDataRes &response) { return response.success; };
-    if (user_) {
-      return client.SteamAndFinalizeDelta<replication::UpdateAuthDataRpc>(
-          check_response, main_uuid, std::string{epoch.id()}, txn.last_committed_system_timestamp(), txn.timestamp(),
-          *user_);
-    }
-    if (role_) {
-      return client.SteamAndFinalizeDelta<replication::UpdateAuthDataRpc>(
-          check_response, main_uuid, std::string{epoch.id()}, txn.last_committed_system_timestamp(), txn.timestamp(),
-          *role_);
-    }
-    // Should never get here
-    MG_ASSERT(false, "Trying to update auth data that is not a user nor a role");
-    return {};
-  }
-
-  void PostReplication(replication::RoleMainData &mainData) const override {}
-
- private:
-  std::optional<User> user_;
-  std::optional<Role> role_;
-};
-
-struct DropAuthData : memgraph::system::ISystemAction {
-  enum class AuthDataType { USER, ROLE };
-
-  explicit DropAuthData(AuthDataType type, std::string_view name) : type_{type}, name_{name} {}
-
-  void DoDurability() override { /* Done during Auth execution */
-  }
-
-  bool DoReplication(replication::ReplicationClient &client, const utils::UUID &main_uuid,
-                     replication::ReplicationEpoch const &epoch,
-                     memgraph::system::Transaction const &txn) const override {
-    auto check_response = [](const replication::DropAuthDataRes &response) { return response.success; };
-
-    memgraph::replication::DropAuthDataReq::DataType type{};
-    switch (type_) {
-      case AuthDataType::USER:
-        type = memgraph::replication::DropAuthDataReq::DataType::USER;
-        break;
-      case AuthDataType::ROLE:
-        type = memgraph::replication::DropAuthDataReq::DataType::ROLE;
-        break;
-    }
-    return client.SteamAndFinalizeDelta<replication::DropAuthDataRpc>(
-        check_response, main_uuid, std::string{epoch.id()}, txn.last_committed_system_timestamp(), txn.timestamp(),
-        type, name_);
-  }
-  void PostReplication(replication::RoleMainData &mainData) const override {}
-
- private:
-  AuthDataType type_;
-  std::string name_;
-};
-#endif
-
-/**
- * CONSTANTS
- */
 const std::string kUserPrefix = "user:";
 const std::string kRolePrefix = "role:";
 const std::string kLinkPrefix = "link:";
 const std::string kVersion = "version";
 
 static constexpr auto kVersionV1 = "V1";
-}  // namespace
 
 /**
  * All data stored in the `Auth` storage is stored in an underlying
@@ -228,12 +148,6 @@ std::optional<User> Auth::Authenticate(const std::string &username, const std::s
     // Authenticate the user.
     if (!is_authenticated) return std::nullopt;
 
-    /**
-     * TODO
-     * The auth module should not update auth data.
-     * There is now way to replicate it and we should not be storing sensitive data if we don't have to.
-     */
-
     // Find or create the user and return it.
     auto user = GetUser(username);
     if (!user) {
@@ -326,7 +240,7 @@ std::optional<User> Auth::GetUser(const std::string &username_orig) const {
   return user;
 }
 
-void Auth::SaveUser(const User &user, system::Transaction *system_tx) {
+void Auth::SaveUser(const User &user) {
   bool success = false;
   if (const auto *role = user.role(); role != nullptr) {
     success = storage_.PutMultiple(
@@ -338,12 +252,6 @@ void Auth::SaveUser(const User &user, system::Transaction *system_tx) {
   if (!success) {
     throw AuthException("Couldn't save user '{}'!", user.username());
   }
-  // All changes to the user end up calling this function, so no need to add a delta anywhere else
-  if (system_tx) {
-#ifdef MG_ENTERPRISE
-    system_tx->AddAction<UpdateAuthData>(user);
-#endif
-  }
 }
 
 void Auth::UpdatePassword(auth::User &user, const std::optional<std::string> &password) {
@@ -376,8 +284,7 @@ void Auth::UpdatePassword(auth::User &user, const std::optional<std::string> &pa
   user.UpdatePassword(password);
 }
 
-std::optional<User> Auth::AddUser(const std::string &username, const std::optional<std::string> &password,
-                                  system::Transaction *system_tx) {
+std::optional<User> Auth::AddUser(const std::string &username, const std::optional<std::string> &password) {
   if (!NameRegexMatch(username)) {
     throw AuthException("Invalid user name.");
   }
@@ -387,23 +294,17 @@ std::optional<User> Auth::AddUser(const std::string &username, const std::option
   if (existing_role) return std::nullopt;
   auto new_user = User(username);
   UpdatePassword(new_user, password);
-  SaveUser(new_user, system_tx);
+  SaveUser(new_user);
   return new_user;
 }
 
-bool Auth::RemoveUser(const std::string &username_orig, system::Transaction *system_tx) {
+bool Auth::RemoveUser(const std::string &username_orig) {
   auto username = utils::ToLowerCase(username_orig);
   if (!storage_.Get(kUserPrefix + username)) return false;
   std::vector<std::string> keys({kLinkPrefix + username, kUserPrefix + username});
   if (!storage_.DeleteMultiple(keys)) {
     throw AuthException("Couldn't remove user '{}'!", username);
   }
-  // Handling drop user delta
-  if (system_tx) {
-#ifdef MG_ENTERPRISE
-    system_tx->AddAction<DropAuthData>(DropAuthData::AuthDataType::USER, username);
-#endif
-  }
   return true;
 }
 
@@ -420,19 +321,6 @@ std::vector<auth::User> Auth::AllUsers() const {
   return ret;
 }
 
-std::vector<std::string> Auth::AllUsernames() const {
-  std::vector<std::string> ret;
-  for (auto it = storage_.begin(kUserPrefix); it != storage_.end(kUserPrefix); ++it) {
-    auto username = it->first.substr(kUserPrefix.size());
-    if (username != utils::ToLowerCase(username)) continue;
-    auto user = GetUser(username);
-    if (user) {
-      ret.push_back(username);
-    }
-  }
-  return ret;
-}
-
 bool Auth::HasUsers() const { return storage_.begin(kUserPrefix) != storage_.end(kUserPrefix); }
 
 std::optional<Role> Auth::GetRole(const std::string &rolename_orig) const {
@@ -450,30 +338,24 @@ std::optional<Role> Auth::GetRole(const std::string &rolename_orig) const {
   return Role::Deserialize(data);
 }
 
-void Auth::SaveRole(const Role &role, system::Transaction *system_tx) {
+void Auth::SaveRole(const Role &role) {
   if (!storage_.Put(kRolePrefix + role.rolename(), role.Serialize().dump())) {
     throw AuthException("Couldn't save role '{}'!", role.rolename());
   }
-  // All changes to the role end up calling this function, so no need to add a delta anywhere else
-  if (system_tx) {
-#ifdef MG_ENTERPRISE
-    system_tx->AddAction<UpdateAuthData>(role);
-#endif
-  }
 }
 
-std::optional<Role> Auth::AddRole(const std::string &rolename, system::Transaction *system_tx) {
+std::optional<Role> Auth::AddRole(const std::string &rolename) {
   if (!NameRegexMatch(rolename)) {
     throw AuthException("Invalid role name.");
   }
   if (auto existing_role = GetRole(rolename)) return std::nullopt;
   if (auto existing_user = GetUser(rolename)) return std::nullopt;
   auto new_role = Role(rolename);
-  SaveRole(new_role, system_tx);
+  SaveRole(new_role);
   return new_role;
 }
 
-bool Auth::RemoveRole(const std::string &rolename_orig, system::Transaction *system_tx) {
+bool Auth::RemoveRole(const std::string &rolename_orig) {
   auto rolename = utils::ToLowerCase(rolename_orig);
   if (!storage_.Get(kRolePrefix + rolename)) return false;
   std::vector<std::string> keys;
@@ -486,12 +368,6 @@ bool Auth::RemoveRole(const std::string &rolename_orig, system::Transaction *sys
   if (!storage_.DeleteMultiple(keys)) {
     throw AuthException("Couldn't remove role '{}'!", rolename);
   }
-  // Handling drop role delta
-  if (system_tx) {
-#ifdef MG_ENTERPRISE
-    system_tx->AddAction<DropAuthData>(DropAuthData::AuthDataType::ROLE, rolename);
-#endif
-  }
   return true;
 }
 
@@ -509,18 +385,6 @@ std::vector<auth::Role> Auth::AllRoles() const {
   return ret;
 }
 
-std::vector<std::string> Auth::AllRolenames() const {
-  std::vector<std::string> ret;
-  for (auto it = storage_.begin(kRolePrefix); it != storage_.end(kRolePrefix); ++it) {
-    auto rolename = it->first.substr(kRolePrefix.size());
-    if (rolename != utils::ToLowerCase(rolename)) continue;
-    if (auto role = GetRole(rolename)) {
-      ret.push_back(rolename);
-    }
-  }
-  return ret;
-}
-
 std::vector<auth::User> Auth::AllUsersForRole(const std::string &rolename_orig) const {
   const auto rolename = utils::ToLowerCase(rolename_orig);
   std::vector<auth::User> ret;
@@ -540,48 +404,48 @@ std::vector<auth::User> Auth::AllUsersForRole(const std::string &rolename_orig)
 }
 
 #ifdef MG_ENTERPRISE
-bool Auth::GrantDatabaseToUser(const std::string &db, const std::string &name, system::Transaction *system_tx) {
+bool Auth::GrantDatabaseToUser(const std::string &db, const std::string &name) {
   if (auto user = GetUser(name)) {
     if (db == kAllDatabases) {
       user->db_access().GrantAll();
     } else {
       user->db_access().Add(db);
     }
-    SaveUser(*user, system_tx);
+    SaveUser(*user);
     return true;
   }
   return false;
 }
 
-bool Auth::RevokeDatabaseFromUser(const std::string &db, const std::string &name, system::Transaction *system_tx) {
+bool Auth::RevokeDatabaseFromUser(const std::string &db, const std::string &name) {
   if (auto user = GetUser(name)) {
     if (db == kAllDatabases) {
       user->db_access().DenyAll();
     } else {
       user->db_access().Remove(db);
     }
-    SaveUser(*user, system_tx);
+    SaveUser(*user);
     return true;
   }
   return false;
 }
 
-void Auth::DeleteDatabase(const std::string &db, system::Transaction *system_tx) {
+void Auth::DeleteDatabase(const std::string &db) {
   for (auto it = storage_.begin(kUserPrefix); it != storage_.end(kUserPrefix); ++it) {
     auto username = it->first.substr(kUserPrefix.size());
     if (auto user = GetUser(username)) {
       user->db_access().Delete(db);
-      SaveUser(*user, system_tx);
+      SaveUser(*user);
     }
   }
 }
 
-bool Auth::SetMainDatabase(std::string_view db, const std::string &name, system::Transaction *system_tx) {
+bool Auth::SetMainDatabase(std::string_view db, const std::string &name) {
   if (auto user = GetUser(name)) {
     if (!user->db_access().SetDefault(db)) {
       throw AuthException("Couldn't set default database '{}' for user '{}'!", db, name);
     }
-    SaveUser(*user, system_tx);
+    SaveUser(*user);
     return true;
   }
   return false;

src/auth/auth.hpp

@@ -18,15 +18,10 @@
 #include "auth/module.hpp"
 #include "glue/auth_global.hpp"
 #include "kvstore/kvstore.hpp"
-#include "system/action.hpp"
 #include "utils/settings.hpp"
-#include "utils/synchronized.hpp"
 
 namespace memgraph::auth {
 
-class Auth;
-using SynchedAuth = memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock>;
-
 static const constexpr char *const kAllDatabases = "*";
 
 /**
@@ -73,13 +68,6 @@ class Auth final {
     config_ = std::move(config);
   }
 
-  /**
-   * @brief
-   *
-   * @return Config
-   */
-  Config GetConfig() const { return config_; }
-
   /**
    * Authenticates a user using his username and password.
    *
@@ -108,7 +96,7 @@ class Auth final {
    *
    * @throw AuthException if unable to save the user.
    */
-  void SaveUser(const User &user, system::Transaction *system_tx = nullptr);
+  void SaveUser(const User &user);
 
   /**
    * Creates a user if the user doesn't exist.
@@ -119,8 +107,7 @@ class Auth final {
    * @return a user when the user is created, nullopt if the user exists
    * @throw AuthException if unable to save the user.
    */
-  std::optional<User> AddUser(const std::string &username, const std::optional<std::string> &password = std::nullopt,
-                              system::Transaction *system_tx = nullptr);
+  std::optional<User> AddUser(const std::string &username, const std::optional<std::string> &password = std::nullopt);
 
   /**
    * Removes a user from the storage.
@@ -131,7 +118,7 @@ class Auth final {
    *         doesn't exist
    * @throw AuthException if unable to remove the user.
    */
-  bool RemoveUser(const std::string &username, system::Transaction *system_tx = nullptr);
+  bool RemoveUser(const std::string &username);
 
   /**
    * @brief
@@ -149,13 +136,6 @@ class Auth final {
    */
   std::vector<User> AllUsers() const;
 
-  /**
-   * @brief
-   *
-   * @return std::vector<std::string>
-   */
-  std::vector<std::string> AllUsernames() const;
-
   /**
    * Returns whether there are users in the storage.
    *
@@ -180,7 +160,7 @@ class Auth final {
    *
    * @throw AuthException if unable to save the role.
    */
-  void SaveRole(const Role &role, system::Transaction *system_tx = nullptr);
+  void SaveRole(const Role &role);
 
   /**
    * Creates a role if the role doesn't exist.
@@ -190,7 +170,7 @@ class Auth final {
    * @return a role when the role is created, nullopt if the role exists
    * @throw AuthException if unable to save the role.
    */
-  std::optional<Role> AddRole(const std::string &rolename, system::Transaction *system_tx = nullptr);
+  std::optional<Role> AddRole(const std::string &rolename);
 
   /**
    * Removes a role from the storage.
@@ -201,7 +181,7 @@ class Auth final {
    *         doesn't exist
    * @throw AuthException if unable to remove the role.
    */
-  bool RemoveRole(const std::string &rolename, system::Transaction *system_tx = nullptr);
+  bool RemoveRole(const std::string &rolename);
 
   /**
    * Gets all roles from the storage.
@@ -211,13 +191,6 @@ class Auth final {
    */
   std::vector<Role> AllRoles() const;
 
-  /**
-   * @brief
-   *
-   * @return std::vector<std::string>
-   */
-  std::vector<std::string> AllRolenames() const;
-
   /**
    * Gets all users for a role from the storage.
    *
@@ -237,7 +210,7 @@ class Auth final {
    * @return true on success
    * @throw AuthException if unable to find or update the user
    */
-  bool RevokeDatabaseFromUser(const std::string &db, const std::string &name, system::Transaction *system_tx = nullptr);
+  bool RevokeDatabaseFromUser(const std::string &db, const std::string &name);
 
   /**
    * @brief Grant access to individual database for a user.
@@ -247,7 +220,7 @@ class Auth final {
    * @return true on success
    * @throw AuthException if unable to find or update the user
    */
-  bool GrantDatabaseToUser(const std::string &db, const std::string &name, system::Transaction *system_tx = nullptr);
+  bool GrantDatabaseToUser(const std::string &db, const std::string &name);
 
   /**
    * @brief Delete a database from all users.
@@ -255,7 +228,7 @@ class Auth final {
    * @param db name of the database to delete
    * @throw AuthException if unable to read data
    */
-  void DeleteDatabase(const std::string &db, system::Transaction *system_tx = nullptr);
+  void DeleteDatabase(const std::string &db);
 
   /**
    * @brief Set main database for an individual user.
@@ -265,7 +238,7 @@ class Auth final {
    * @return true on success
    * @throw AuthException if unable to find or update the user
    */
-  bool SetMainDatabase(std::string_view db, const std::string &name, system::Transaction *system_tx = nullptr);
+  bool SetMainDatabase(std::string_view db, const std::string &name);
 #endif
 
  private:

src/auth/models.cpp

@@ -611,49 +611,27 @@ Permissions User::GetPermissions() const {
 
 #ifdef MG_ENTERPRISE
 FineGrainedAccessPermissions User::GetFineGrainedAccessLabelPermissions() const {
-  return Merge(GetUserFineGrainedAccessLabelPermissions(), GetRoleFineGrainedAccessLabelPermissions());
-}
-
-FineGrainedAccessPermissions User::GetFineGrainedAccessEdgeTypePermissions() const {
-  return Merge(GetUserFineGrainedAccessEdgeTypePermissions(), GetRoleFineGrainedAccessEdgeTypePermissions());
-}
-
-FineGrainedAccessPermissions User::GetUserFineGrainedAccessEdgeTypePermissions() const {
   if (!memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
     return FineGrainedAccessPermissions{};
   }
 
-  return fine_grained_access_handler_.edge_type_permissions();
-}
-
-FineGrainedAccessPermissions User::GetUserFineGrainedAccessLabelPermissions() const {
-  if (!memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
-    return FineGrainedAccessPermissions{};
+  if (role_) {
+    return Merge(role()->fine_grained_access_handler().label_permissions(),
+                 fine_grained_access_handler_.label_permissions());
   }
 
   return fine_grained_access_handler_.label_permissions();
 }
 
-FineGrainedAccessPermissions User::GetRoleFineGrainedAccessEdgeTypePermissions() const {
+FineGrainedAccessPermissions User::GetFineGrainedAccessEdgeTypePermissions() const {
   if (!memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
     return FineGrainedAccessPermissions{};
   }
-
   if (role_) {
-    return role()->fine_grained_access_handler().edge_type_permissions();
+    return Merge(role()->fine_grained_access_handler().edge_type_permissions(),
+                 fine_grained_access_handler_.edge_type_permissions());
   }
-  return FineGrainedAccessPermissions{};
-}
-
-FineGrainedAccessPermissions User::GetRoleFineGrainedAccessLabelPermissions() const {
-  if (!memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
-    return FineGrainedAccessPermissions{};
-  }
-
-  if (role_) {
-    return role()->fine_grained_access_handler().label_permissions();
-  }
-  return FineGrainedAccessPermissions{};
+  return fine_grained_access_handler_.edge_type_permissions();
 }
 #endif
 

src/auth/models.hpp

@@ -207,8 +207,6 @@ bool operator==(const FineGrainedAccessHandler &first, const FineGrainedAccessHa
 
 class Role final {
  public:
-  Role() = default;
-
   explicit Role(const std::string &rolename);
   Role(const std::string &rolename, const Permissions &permissions);
 #ifdef MG_ENTERPRISE
@@ -371,10 +369,6 @@ class User final {
 #ifdef MG_ENTERPRISE
   FineGrainedAccessPermissions GetFineGrainedAccessLabelPermissions() const;
   FineGrainedAccessPermissions GetFineGrainedAccessEdgeTypePermissions() const;
-  FineGrainedAccessPermissions GetUserFineGrainedAccessLabelPermissions() const;
-  FineGrainedAccessPermissions GetUserFineGrainedAccessEdgeTypePermissions() const;
-  FineGrainedAccessPermissions GetRoleFineGrainedAccessLabelPermissions() const;
-  FineGrainedAccessPermissions GetRoleFineGrainedAccessEdgeTypePermissions() const;
   const FineGrainedAccessHandler &fine_grained_access_handler() const;
   FineGrainedAccessHandler &fine_grained_access_handler();
 #endif

src/auth/replication_handlers.cpp

@@ -1,190 +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 "auth/replication_handlers.hpp"
-
-#include "auth/auth.hpp"
-#include "auth/rpc.hpp"
-#include "license/license.hpp"
-
-namespace memgraph::auth {
-
-void LogWrongMain(const std::optional<utils::UUID> &current_main_uuid, const utils::UUID &main_req_id,
-                  std::string_view rpc_req) {
-  spdlog::error(fmt::format("Received {} with main_id: {} != current_main_uuid: {}", rpc_req, std::string(main_req_id),
-                            current_main_uuid.has_value() ? std::string(current_main_uuid.value()) : ""));
-}
-
-#ifdef MG_ENTERPRISE
-void UpdateAuthDataHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access,
-                           const std::optional<utils::UUID> &current_main_uuid, auth::SynchedAuth &auth,
-                           slk::Reader *req_reader, slk::Builder *res_builder) {
-  replication::UpdateAuthDataReq req;
-  memgraph::slk::Load(&req, req_reader);
-
-  using memgraph::replication::UpdateAuthDataRes;
-  UpdateAuthDataRes res(false);
-
-  if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, replication::UpdateAuthDataReq::kType.name);
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
-  // Note: No need to check epoch, recovery mechanism is done by a full uptodate snapshot
-  //       of the set of databases. Hence no history exists to maintain regarding epoch change.
-  //       If MAIN has changed we need to check this new group_timestamp is consistent with
-  //       what we have so far.
-
-  if (req.expected_group_timestamp != system_state_access.LastCommitedTS()) {
-    spdlog::debug("UpdateAuthDataHandler: bad expected timestamp {},{}", req.expected_group_timestamp,
-                  system_state_access.LastCommitedTS());
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
-  try {
-    // Update
-    if (req.user) auth->SaveUser(*req.user);
-    if (req.role) auth->SaveRole(*req.role);
-    // Success
-    system_state_access.SetLastCommitedTS(req.new_group_timestamp);
-    res = UpdateAuthDataRes(true);
-    spdlog::debug("UpdateAuthDataHandler: SUCCESS updated LCTS to {}", req.new_group_timestamp);
-  } catch (const auth::AuthException & /* not used */) {
-    // Failure
-  }
-
-  memgraph::slk::Save(res, res_builder);
-}
-
-void DropAuthDataHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access,
-                         const std::optional<utils::UUID> &current_main_uuid, auth::SynchedAuth &auth,
-                         slk::Reader *req_reader, slk::Builder *res_builder) {
-  replication::DropAuthDataReq req;
-  memgraph::slk::Load(&req, req_reader);
-
-  using memgraph::replication::DropAuthDataRes;
-  DropAuthDataRes res(false);
-
-  if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, replication::DropAuthDataRes::kType.name);
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
-  // Note: No need to check epoch, recovery mechanism is done by a full uptodate snapshot
-  //       of the set of databases. Hence no history exists to maintain regarding epoch change.
-  //       If MAIN has changed we need to check this new group_timestamp is consistent with
-  //       what we have so far.
-
-  if (req.expected_group_timestamp != system_state_access.LastCommitedTS()) {
-    spdlog::debug("DropAuthDataHandler: bad expected timestamp {},{}", req.expected_group_timestamp,
-                  system_state_access.LastCommitedTS());
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
-  try {
-    // Remove
-    switch (req.type) {
-      case replication::DropAuthDataReq::DataType::USER:
-        auth->RemoveUser(req.name);
-        break;
-      case replication::DropAuthDataReq::DataType::ROLE:
-        auth->RemoveRole(req.name);
-        break;
-    }
-    // Success
-    system_state_access.SetLastCommitedTS(req.new_group_timestamp);
-    res = DropAuthDataRes(true);
-    spdlog::debug("DropAuthDataHandler: SUCCESS updated LCTS to {}", req.new_group_timestamp);
-  } catch (const auth::AuthException & /* not used */) {
-    // Failure
-  }
-
-  memgraph::slk::Save(res, res_builder);
-}
-
-bool SystemRecoveryHandler(auth::SynchedAuth &auth, auth::Auth::Config auth_config,
-                           const std::vector<auth::User> &users, const std::vector<auth::Role> &roles) {
-  return auth.WithLock([&](auto &locked_auth) {
-    // Update config
-    locked_auth.SetConfig(std::move(auth_config));
-    // Get all current users
-    auto old_users = locked_auth.AllUsernames();
-    // Save incoming users
-    for (const auto &user : users) {
-      // Missing users
-      try {
-        locked_auth.SaveUser(user);
-      } catch (const auth::AuthException &) {
-        spdlog::debug("SystemRecoveryHandler: Failed to save user");
-        return false;
-      }
-      const auto it = std::find(old_users.begin(), old_users.end(), user.username());
-      if (it != old_users.end()) old_users.erase(it);
-    }
-    // Delete all the leftover users
-    for (const auto &user : old_users) {
-      if (!locked_auth.RemoveUser(user)) {
-        spdlog::debug("SystemRecoveryHandler: Failed to remove user \"{}\".", user);
-        return false;
-      }
-    }
-
-    // Roles are only supported with a license
-    if (license::global_license_checker.IsEnterpriseValidFast()) {
-      // Get all current roles
-      auto old_roles = locked_auth.AllRolenames();
-      // Save incoming users
-      for (const auto &role : roles) {
-        // Missing users
-        try {
-          locked_auth.SaveRole(role);
-        } catch (const auth::AuthException &) {
-          spdlog::debug("SystemRecoveryHandler: Failed to save user");
-          return false;
-        }
-        const auto it = std::find(old_roles.begin(), old_roles.end(), role.rolename());
-        if (it != old_roles.end()) old_roles.erase(it);
-      }
-      // Delete all the leftover users
-      for (const auto &role : old_roles) {
-        if (!locked_auth.RemoveRole(role)) {
-          spdlog::debug("SystemRecoveryHandler: Failed to remove user \"{}\".", role);
-          return false;
-        }
-      }
-    }
-
-    // Success
-    return true;
-  });
-}
-
-void Register(replication::RoleReplicaData const &data, system::ReplicaHandlerAccessToState &system_state_access,
-              auth::SynchedAuth &auth) {
-  // NOTE: Register even without license as the user could add a license at run-time
-  data.server->rpc_server_.Register<replication::UpdateAuthDataRpc>(
-      [&data, system_state_access, &auth](auto *req_reader, auto *res_builder) mutable {
-        spdlog::debug("Received UpdateAuthDataRpc");
-        UpdateAuthDataHandler(system_state_access, data.uuid_, auth, req_reader, res_builder);
-      });
-  data.server->rpc_server_.Register<replication::DropAuthDataRpc>(
-      [&data, system_state_access, &auth](auto *req_reader, auto *res_builder) mutable {
-        spdlog::debug("Received DropAuthDataRpc");
-        DropAuthDataHandler(system_state_access, data.uuid_, auth, req_reader, res_builder);
-      });
-}
-#endif
-
-}  // namespace memgraph::auth

src/auth/replication_handlers.hpp

@@ -1,37 +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 "auth/auth.hpp"
-#include "replication/state.hpp"
-#include "slk/streams.hpp"
-#include "system/state.hpp"
-
-namespace memgraph::auth {
-
-void LogWrongMain(const std::optional<utils::UUID> &current_main_uuid, const utils::UUID &main_req_id,
-                  std::string_view rpc_req);
-
-#ifdef MG_ENTERPRISE
-void UpdateAuthDataHandler(system::ReplicaHandlerAccessToState &system_state_access,
-                           const std::optional<utils::UUID> &current_main_uuid, auth::SynchedAuth &auth,
-                           slk::Reader *req_reader, slk::Builder *res_builder);
-void DropAuthDataHandler(system::ReplicaHandlerAccessToState &system_state_access,
-                         const std::optional<utils::UUID> &current_main_uuid, auth::SynchedAuth &auth,
-                         slk::Reader *req_reader, slk::Builder *res_builder);
-
-bool SystemRecoveryHandler(auth::SynchedAuth &auth, auth::Auth::Config auth_config,
-                           const std::vector<auth::User> &users, const std::vector<auth::Role> &roles);
-void Register(replication::RoleReplicaData const &data, system::ReplicaHandlerAccessToState &system_state_access,
-              auth::SynchedAuth &auth);
-#endif
-}  // namespace memgraph::auth

src/auth/rpc.cpp

@@ -1,182 +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 "auth/rpc.hpp"
-
-#include <json/json.hpp>
-#include "auth/auth.hpp"
-#include "slk/serialization.hpp"
-#include "slk/streams.hpp"
-#include "utils/enum.hpp"
-
-namespace memgraph::slk {
-
-// Serialize code for auth::Role
-void Save(const auth::Role &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.Serialize().dump(), builder);
-}
-namespace {
-auth::Role LoadAuthRole(memgraph::slk::Reader *reader) {
-  std::string tmp;
-  memgraph::slk::Load(&tmp, reader);
-  const auto json = nlohmann::json::parse(tmp);
-  return memgraph::auth::Role::Deserialize(json);
-}
-}  // namespace
-// Deserialize code for auth::Role
-void Load(auth::Role *self, memgraph::slk::Reader *reader) { *self = LoadAuthRole(reader); }
-// Special case for optional<Role>
-template <>
-inline void Load<auth::Role>(std::optional<auth::Role> *obj, Reader *reader) {
-  bool exists = false;
-  Load(&exists, reader);
-  if (exists) {
-    obj->emplace(LoadAuthRole(reader));
-  } else {
-    *obj = std::nullopt;
-  }
-}
-
-// Serialize code for auth::User
-void Save(const auth::User &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.Serialize().dump(), builder);
-  std::optional<auth::Role> role{};
-  if (const auto *role_ptr = self.role(); role_ptr) {
-    role.emplace(*role_ptr);
-  }
-  memgraph::slk::Save(role, builder);
-}
-// Deserialize code for auth::User
-void Load(auth::User *self, memgraph::slk::Reader *reader) {
-  std::string tmp;
-  memgraph::slk::Load(&tmp, reader);
-  const auto json = nlohmann::json::parse(tmp);
-  *self = memgraph::auth::User::Deserialize(json);
-  std::optional<auth::Role> role{};
-  memgraph::slk::Load(&role, reader);
-  if (role)
-    self->SetRole(*role);
-  else
-    self->ClearRole();
-}
-
-// Serialize code for auth::Auth::Config
-void Save(const auth::Auth::Config &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.name_regex_str, builder);
-  memgraph::slk::Save(self.password_regex_str, builder);
-  memgraph::slk::Save(self.password_permit_null, builder);
-}
-// Deserialize code for auth::Auth::Config
-void Load(auth::Auth::Config *self, memgraph::slk::Reader *reader) {
-  std::string name_regex_str{};
-  std::string password_regex_str{};
-  bool password_permit_null{};
-
-  memgraph::slk::Load(&name_regex_str, reader);
-  memgraph::slk::Load(&password_regex_str, reader);
-  memgraph::slk::Load(&password_permit_null, reader);
-
-  *self = auth::Auth::Config{std::move(name_regex_str), std::move(password_regex_str), password_permit_null};
-}
-
-// Serialize code for UpdateAuthDataReq
-void Save(const memgraph::replication::UpdateAuthDataReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.main_uuid, builder);
-  memgraph::slk::Save(self.epoch_id, builder);
-  memgraph::slk::Save(self.expected_group_timestamp, builder);
-  memgraph::slk::Save(self.new_group_timestamp, builder);
-  memgraph::slk::Save(self.user, builder);
-  memgraph::slk::Save(self.role, builder);
-}
-void Load(memgraph::replication::UpdateAuthDataReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->main_uuid, reader);
-  memgraph::slk::Load(&self->epoch_id, reader);
-  memgraph::slk::Load(&self->expected_group_timestamp, reader);
-  memgraph::slk::Load(&self->new_group_timestamp, reader);
-  memgraph::slk::Load(&self->user, reader);
-  memgraph::slk::Load(&self->role, reader);
-}
-
-// Serialize code for UpdateAuthDataRes
-void Save(const memgraph::replication::UpdateAuthDataRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.success, builder);
-}
-void Load(memgraph::replication::UpdateAuthDataRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->success, reader);
-}
-
-// Serialize code for DropAuthDataReq
-void Save(const memgraph::replication::DropAuthDataReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.main_uuid, builder);
-  memgraph::slk::Save(self.epoch_id, builder);
-  memgraph::slk::Save(self.expected_group_timestamp, builder);
-  memgraph::slk::Save(self.new_group_timestamp, builder);
-  memgraph::slk::Save(utils::EnumToNum<2, uint8_t>(self.type), builder);
-  memgraph::slk::Save(self.name, builder);
-}
-void Load(memgraph::replication::DropAuthDataReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->main_uuid, reader);
-  memgraph::slk::Load(&self->epoch_id, reader);
-  memgraph::slk::Load(&self->expected_group_timestamp, reader);
-  memgraph::slk::Load(&self->new_group_timestamp, reader);
-  uint8_t type_tmp = 0;
-  memgraph::slk::Load(&type_tmp, reader);
-  if (!utils::NumToEnum<2>(type_tmp, self->type)) {
-    throw SlkReaderException("Unexpected result line:{}!", __LINE__);
-  }
-  memgraph::slk::Load(&self->name, reader);
-}
-
-// Serialize code for DropAuthDataRes
-void Save(const memgraph::replication::DropAuthDataRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.success, builder);
-}
-void Load(memgraph::replication::DropAuthDataRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->success, reader);
-}
-
-}  // namespace memgraph::slk
-
-namespace memgraph::replication {
-
-constexpr utils::TypeInfo UpdateAuthDataReq::kType{utils::TypeId::REP_UPDATE_AUTH_DATA_REQ, "UpdateAuthDataReq",
-                                                   nullptr};
-
-constexpr utils::TypeInfo UpdateAuthDataRes::kType{utils::TypeId::REP_UPDATE_AUTH_DATA_RES, "UpdateAuthDataRes",
-                                                   nullptr};
-
-constexpr utils::TypeInfo DropAuthDataReq::kType{utils::TypeId::REP_DROP_AUTH_DATA_REQ, "DropAuthDataReq", nullptr};
-
-constexpr utils::TypeInfo DropAuthDataRes::kType{utils::TypeId::REP_DROP_AUTH_DATA_RES, "DropAuthDataRes", nullptr};
-
-void UpdateAuthDataReq::Save(const UpdateAuthDataReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void UpdateAuthDataReq::Load(UpdateAuthDataReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-void UpdateAuthDataRes::Save(const UpdateAuthDataRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void UpdateAuthDataRes::Load(UpdateAuthDataRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-
-void DropAuthDataReq::Save(const DropAuthDataReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void DropAuthDataReq::Load(DropAuthDataReq *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
-void DropAuthDataRes::Save(const DropAuthDataRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void DropAuthDataRes::Load(DropAuthDataRes *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
-
-}  // namespace memgraph::replication

src/auth/rpc.hpp

@@ -1,127 +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 <optional>
-
-#include "auth/auth.hpp"
-#include "auth/models.hpp"
-#include "rpc/messages.hpp"
-#include "slk/streams.hpp"
-
-namespace memgraph::replication {
-
-struct UpdateAuthDataReq {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(UpdateAuthDataReq *self, memgraph::slk::Reader *reader);
-  static void Save(const UpdateAuthDataReq &self, memgraph::slk::Builder *builder);
-  UpdateAuthDataReq() = default;
-  UpdateAuthDataReq(const utils::UUID &main_uuid, std::string epoch_id, uint64_t expected_ts, uint64_t new_ts,
-                    auth::User user)
-      : main_uuid(main_uuid),
-        epoch_id{std::move(epoch_id)},
-        expected_group_timestamp{expected_ts},
-        new_group_timestamp{new_ts},
-        user{std::move(user)} {}
-  UpdateAuthDataReq(const utils::UUID &main_uuid, std::string epoch_id, uint64_t expected_ts, uint64_t new_ts,
-                    auth::Role role)
-      : main_uuid(main_uuid),
-        epoch_id{std::move(epoch_id)},
-        expected_group_timestamp{expected_ts},
-        new_group_timestamp{new_ts},
-        role{std::move(role)} {}
-
-  utils::UUID main_uuid;
-  std::string epoch_id;
-  uint64_t expected_group_timestamp;
-  uint64_t new_group_timestamp;
-  std::optional<auth::User> user;
-  std::optional<auth::Role> role;
-};
-
-struct UpdateAuthDataRes {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(UpdateAuthDataRes *self, memgraph::slk::Reader *reader);
-  static void Save(const UpdateAuthDataRes &self, memgraph::slk::Builder *builder);
-  UpdateAuthDataRes() = default;
-  explicit UpdateAuthDataRes(bool success) : success{success} {}
-
-  bool success;
-};
-
-using UpdateAuthDataRpc = rpc::RequestResponse<UpdateAuthDataReq, UpdateAuthDataRes>;
-
-struct DropAuthDataReq {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(DropAuthDataReq *self, memgraph::slk::Reader *reader);
-  static void Save(const DropAuthDataReq &self, memgraph::slk::Builder *builder);
-  DropAuthDataReq() = default;
-
-  enum class DataType { USER, ROLE };
-
-  DropAuthDataReq(const utils::UUID &main_uuid, std::string epoch_id, uint64_t expected_ts, uint64_t new_ts,
-                  DataType type, std::string_view name)
-      : main_uuid(main_uuid),
-        epoch_id{std::move(epoch_id)},
-        expected_group_timestamp{expected_ts},
-        new_group_timestamp{new_ts},
-        type{type},
-        name{name} {}
-
-  utils::UUID main_uuid;
-  std::string epoch_id;
-  uint64_t expected_group_timestamp;
-  uint64_t new_group_timestamp;
-  DataType type;
-  std::string name;
-};
-
-struct DropAuthDataRes {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(DropAuthDataRes *self, memgraph::slk::Reader *reader);
-  static void Save(const DropAuthDataRes &self, memgraph::slk::Builder *builder);
-  DropAuthDataRes() = default;
-  explicit DropAuthDataRes(bool success) : success{success} {}
-
-  bool success;
-};
-
-using DropAuthDataRpc = rpc::RequestResponse<DropAuthDataReq, DropAuthDataRes>;
-
-}  // namespace memgraph::replication
-
-namespace memgraph::slk {
-
-void Save(const auth::Role &self, memgraph::slk::Builder *builder);
-void Load(auth::Role *self, memgraph::slk::Reader *reader);
-void Save(const auth::User &self, memgraph::slk::Builder *builder);
-void Load(auth::User *self, memgraph::slk::Reader *reader);
-void Save(const auth::Auth::Config &self, memgraph::slk::Builder *builder);
-void Load(auth::Auth::Config *self, memgraph::slk::Reader *reader);
-
-void Save(const memgraph::replication::UpdateAuthDataRes &self, memgraph::slk::Builder *builder);
-void Load(memgraph::replication::UpdateAuthDataRes *self, memgraph::slk::Reader *reader);
-void Save(const memgraph::replication::UpdateAuthDataReq & /*self*/, memgraph::slk::Builder * /*builder*/);
-void Load(memgraph::replication::UpdateAuthDataReq * /*self*/, memgraph::slk::Reader * /*reader*/);
-void Save(const memgraph::replication::DropAuthDataRes &self, memgraph::slk::Builder *builder);
-void Load(memgraph::replication::DropAuthDataRes *self, memgraph::slk::Reader *reader);
-void Save(const memgraph::replication::DropAuthDataReq & /*self*/, memgraph::slk::Builder * /*builder*/);
-void Load(memgraph::replication::DropAuthDataReq * /*self*/, memgraph::slk::Reader * /*reader*/);
-}  // namespace memgraph::slk

src/communication/websocket/auth.hpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2022 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -14,6 +14,8 @@
 #include <string>
 
 #include "auth/auth.hpp"
+#include "utils/spin_lock.hpp"
+#include "utils/synchronized.hpp"
 
 namespace memgraph::communication::websocket {
 
@@ -28,7 +30,7 @@ class AuthenticationInterface {
 
 class SafeAuth : public AuthenticationInterface {
  public:
-  explicit SafeAuth(auth::SynchedAuth *auth) : auth_{auth} {}
+  explicit SafeAuth(utils::Synchronized<auth::Auth, utils::WritePrioritizedRWLock> *auth) : auth_{auth} {}
 
   bool Authenticate(const std::string &username, const std::string &password) const override;
 
@@ -37,6 +39,6 @@ class SafeAuth : public AuthenticationInterface {
   bool HasAnyUsers() const override;
 
  private:
-  auth::SynchedAuth *auth_;
+  utils::Synchronized<auth::Auth, utils::WritePrioritizedRWLock> *auth_;
 };
 }  // namespace memgraph::communication::websocket

src/coordination/CMakeLists.txt

@@ -8,35 +8,22 @@ target_sources(mg-coordination
         include/coordination/coordinator_server.hpp
         include/coordination/coordinator_config.hpp
         include/coordination/coordinator_exceptions.hpp
-        include/coordination/coordinator_slk.hpp
         include/coordination/coordinator_instance.hpp
-        include/coordination/coordinator_handlers.hpp
+        include/coordination/coordinator_slk.hpp
+        include/coordination/coordinator_data.hpp
         include/coordination/constants.hpp
-        include/coordination/instance_status.hpp
-        include/coordination/replication_instance.hpp
-        include/coordination/raft_state.hpp
-        include/coordination/rpc_errors.hpp
-
-        include/nuraft/coordinator_log_store.hpp
-        include/nuraft/coordinator_state_machine.hpp
-        include/nuraft/coordinator_state_manager.hpp
+        include/coordination/failover_status.hpp
+        include/coordination/coordinator_cluster_config.hpp
 
         PRIVATE
         coordinator_client.cpp
         coordinator_state.cpp
         coordinator_rpc.cpp
         coordinator_server.cpp
-        coordinator_handlers.cpp
-        coordinator_instance.cpp
-        replication_instance.cpp
-        raft_state.cpp
-
-        coordinator_log_store.cpp
-        coordinator_state_machine.cpp
-        coordinator_state_manager.cpp
+        coordinator_data.cpp
 )
 target_include_directories(mg-coordination PUBLIC include)
 
 target_link_libraries(mg-coordination
-    PUBLIC mg::utils mg::rpc mg::slk mg::io mg::repl_coord_glue lib::rangev3 nuraft mg-replication_handler
+    PUBLIC mg::utils mg::rpc mg::slk mg::io mg::repl_coord_glue lib::rangev3
 )

src/coordination/coordinator_client.cpp

@@ -9,7 +9,6 @@
 // by the Apache License, Version 2.0, included in the file
 // licenses/APL.txt.
 
-#include "utils/uuid.hpp"
 #ifdef MG_ENTERPRISE
 
 #include "coordination/coordinator_client.hpp"
@@ -17,156 +16,91 @@
 #include "coordination/coordinator_config.hpp"
 #include "coordination/coordinator_rpc.hpp"
 #include "replication_coordination_glue/messages.hpp"
-#include "utils/result.hpp"
 
 namespace memgraph::coordination {
 
 namespace {
-auto CreateClientContext(memgraph::coordination::CoordinatorClientConfig const &config)
+auto CreateClientContext(const memgraph::coordination::CoordinatorClientConfig &config)
     -> communication::ClientContext {
   return (config.ssl) ? communication::ClientContext{config.ssl->key_file, config.ssl->cert_file}
                       : communication::ClientContext{};
 }
 }  // namespace
 
-CoordinatorClient::CoordinatorClient(CoordinatorInstance *coord_instance, CoordinatorClientConfig config,
+CoordinatorClient::CoordinatorClient(CoordinatorData *coord_data, CoordinatorClientConfig config,
                                      HealthCheckCallback succ_cb, HealthCheckCallback fail_cb)
     : rpc_context_{CreateClientContext(config)},
       rpc_client_{io::network::Endpoint(io::network::Endpoint::needs_resolving, config.ip_address, config.port),
                   &rpc_context_},
       config_{std::move(config)},
-      coord_instance_{coord_instance},
+      coord_data_{coord_data},
       succ_cb_{std::move(succ_cb)},
       fail_cb_{std::move(fail_cb)} {}
 
 auto CoordinatorClient::InstanceName() const -> std::string { return config_.instance_name; }
 auto CoordinatorClient::SocketAddress() const -> std::string { return rpc_client_.Endpoint().SocketAddress(); }
 
-auto CoordinatorClient::InstanceDownTimeoutSec() const -> std::chrono::seconds {
-  return config_.instance_down_timeout_sec;
-}
-
-auto CoordinatorClient::InstanceGetUUIDFrequencySec() const -> std::chrono::seconds {
-  return config_.instance_get_uuid_frequency_sec;
-}
-
 void CoordinatorClient::StartFrequentCheck() {
-  if (instance_checker_.IsRunning()) {
-    return;
-  }
-
-  MG_ASSERT(config_.instance_health_check_frequency_sec > std::chrono::seconds(0),
+  MG_ASSERT(config_.health_check_frequency_sec > std::chrono::seconds(0),
             "Health check frequency must be greater than 0");
 
   instance_checker_.Run(
-      config_.instance_name, config_.instance_health_check_frequency_sec,
-      [this, instance_name = config_.instance_name] {
+      "Coord checker", 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());
-          {  // NOTE: This is intentionally scoped so that stream lock could get released.
-            auto stream{rpc_client_.Stream<memgraph::replication_coordination_glue::FrequentHeartbeatRpc>()};
-            stream.AwaitResponse();
-          }
-          succ_cb_(coord_instance_, instance_name);
-        } catch (rpc::RpcFailedException const &) {
-          fail_cb_(coord_instance_, instance_name);
+          auto stream{rpc_client_.Stream<memgraph::replication_coordination_glue::FrequentHeartbeatRpc>()};
+          stream.AwaitResponse();
+          succ_cb_(coord_data_, instance_name);
+        } catch (const rpc::RpcFailedException &) {
+          fail_cb_(coord_data_, instance_name);
         }
       });
 }
 
 void CoordinatorClient::StopFrequentCheck() { instance_checker_.Stop(); }
+
 void CoordinatorClient::PauseFrequentCheck() { instance_checker_.Pause(); }
 void CoordinatorClient::ResumeFrequentCheck() { instance_checker_.Resume(); }
 
-auto CoordinatorClient::SetCallbacks(HealthCheckCallback succ_cb, HealthCheckCallback fail_cb) -> void {
-  succ_cb_ = std::move(succ_cb);
-  fail_cb_ = std::move(fail_cb);
+auto CoordinatorClient::SetSuccCallback(HealthCheckCallback succ_cb) -> void { succ_cb_ = std::move(succ_cb); }
+auto CoordinatorClient::SetFailCallback(HealthCheckCallback fail_cb) -> void { fail_cb_ = std::move(fail_cb); }
+
+auto CoordinatorClient::ReplicationClientInfo() const -> const CoordinatorClientConfig::ReplicationClientInfo & {
+  return config_.replication_client_info;
 }
 
-auto CoordinatorClient::ReplicationClientInfo() const -> ReplClientInfo { return config_.replication_client_info; }
+auto CoordinatorClient::ResetReplicationClientInfo() -> void {
+  // TODO (antoniofilipovic) Sync with Andi on this one
+  // config_.replication_client_info.reset();
+}
 
-auto CoordinatorClient::SendPromoteReplicaToMainRpc(const utils::UUID &uuid,
-                                                    ReplicationClientsInfo replication_clients_info) const -> bool {
+auto CoordinatorClient::SendPromoteReplicaToMainRpc(
+    std::vector<CoordinatorClientConfig::ReplicationClientInfo> replication_clients_info) const -> bool {
   try {
-    auto stream{rpc_client_.Stream<PromoteReplicaToMainRpc>(uuid, std::move(replication_clients_info))};
+    auto stream{rpc_client_.Stream<PromoteReplicaToMainRpc>(std::move(replication_clients_info))};
     if (!stream.AwaitResponse().success) {
-      spdlog::error("Failed to receive successful PromoteReplicaToMainRpc response!");
+      spdlog::error("Failed to receive successful RPC failover response!");
       return false;
     }
     return true;
-  } catch (rpc::RpcFailedException const &) {
-    spdlog::error("RPC error occurred while sending PromoteReplicaToMainRpc!");
+  } catch (const rpc::RpcFailedException &) {
+    spdlog::error("RPC error occurred while sending failover RPC!");
   }
   return false;
 }
 
-auto CoordinatorClient::DemoteToReplica() const -> bool {
-  auto const &instance_name = config_.instance_name;
+auto CoordinatorClient::SendSetToReplicaRpc(CoordinatorClient::ReplClientInfo replication_client_info) const -> bool {
   try {
-    auto stream{rpc_client_.Stream<DemoteMainToReplicaRpc>(config_.replication_client_info)};
+    auto stream{rpc_client_.Stream<SetMainToReplicaRpc>(std::move(replication_client_info))};
     if (!stream.AwaitResponse().success) {
-      spdlog::error("Failed to receive successful RPC response for setting instance {} to replica!", instance_name);
+      spdlog::error("Failed to set main to replica!");
       return false;
     }
     spdlog::info("Sent request RPC from coordinator to instance to set it as replica!");
     return true;
-  } catch (rpc::RpcFailedException const &) {
-    spdlog::error("Failed to set instance {} to replica!", instance_name);
-  }
-  return false;
-}
-
-auto CoordinatorClient::SendSwapMainUUIDRpc(const utils::UUID &uuid) const -> bool {
-  try {
-    auto stream{rpc_client_.Stream<replication_coordination_glue::SwapMainUUIDRpc>(uuid)};
-    if (!stream.AwaitResponse().success) {
-      spdlog::error("Failed to receive successful RPC swapping of uuid response!");
-      return false;
-    }
-    return true;
   } catch (const rpc::RpcFailedException &) {
-    spdlog::error("RPC error occurred while sending swapping uuid RPC!");
-  }
-  return false;
-}
-
-auto CoordinatorClient::SendUnregisterReplicaRpc(std::string const &instance_name) const -> bool {
-  try {
-    auto stream{rpc_client_.Stream<UnregisterReplicaRpc>(instance_name)};
-    if (!stream.AwaitResponse().success) {
-      spdlog::error("Failed to receive successful RPC response for unregistering replica!");
-      return false;
-    }
-    return true;
-  } catch (rpc::RpcFailedException const &) {
-    spdlog::error("Failed to unregister replica!");
-  }
-  return false;
-}
-
-auto CoordinatorClient::SendGetInstanceUUIDRpc() const
-    -> utils::BasicResult<GetInstanceUUIDError, std::optional<utils::UUID>> {
-  try {
-    auto stream{rpc_client_.Stream<GetInstanceUUIDRpc>()};
-    auto res = stream.AwaitResponse();
-    return res.uuid;
-  } catch (const rpc::RpcFailedException &) {
-    spdlog::error("RPC error occured while sending GetInstance UUID RPC");
-    return GetInstanceUUIDError::RPC_EXCEPTION;
-  }
-}
-
-auto CoordinatorClient::SendEnableWritingOnMainRpc() const -> bool {
-  try {
-    auto stream{rpc_client_.Stream<EnableWritingOnMainRpc>()};
-    if (!stream.AwaitResponse().success) {
-      spdlog::error("Failed to receive successful RPC response for enabling writing on main!");
-      return false;
-    }
-    return true;
-  } catch (rpc::RpcFailedException const &) {
-    spdlog::error("Failed to enable writing on main!");
+    spdlog::error("Failed to send failover RPC from coordinator to new main!");
   }
   return false;
 }

src/coordination/coordinator_data.cpp

@@ -0,0 +1,220 @@
+// Copyright 2024 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#include "coordination/coordinator_instance.hpp"
+#include "coordination/register_main_replica_coordinator_status.hpp"
+#ifdef MG_ENTERPRISE
+
+#include "coordination/coordinator_data.hpp"
+
+#include <range/v3/view.hpp>
+#include <shared_mutex>
+
+namespace memgraph::coordination {
+
+CoordinatorData::CoordinatorData() {
+  auto find_instance = [](CoordinatorData *coord_data, std::string_view instance_name) -> CoordinatorInstance & {
+    auto instance = std::ranges::find_if(
+        coord_data->registered_instances_,
+        [instance_name](const CoordinatorInstance &instance) { return instance.InstanceName() == instance_name; });
+
+    MG_ASSERT(instance != coord_data->registered_instances_.end(), "Instance {} not found during callback!",
+              instance_name);
+    return *instance;
+  };
+
+  replica_succ_cb_ = [find_instance](CoordinatorData *coord_data, std::string_view instance_name) -> void {
+    auto lock = std::lock_guard{coord_data->coord_data_lock_};
+    spdlog::trace("Instance {} performing replica successful callback", instance_name);
+    auto &instance = find_instance(coord_data, instance_name);
+    MG_ASSERT(instance.IsReplica(), "Instance {} is not a replica!", instance_name);
+    instance.UpdateLastResponseTime();
+  };
+
+  replica_fail_cb_ = [find_instance](CoordinatorData *coord_data, std::string_view instance_name) -> void {
+    auto lock = std::lock_guard{coord_data->coord_data_lock_};
+    spdlog::trace("Instance {} performing replica failure callback", instance_name);
+    auto &instance = find_instance(coord_data, instance_name);
+    MG_ASSERT(instance.IsReplica(), "Instance {} is not a replica!", instance_name);
+    instance.UpdateInstanceStatus();
+  };
+
+  main_succ_cb_ = [find_instance](CoordinatorData *coord_data, std::string_view instance_name) -> void {
+    auto lock = std::lock_guard{coord_data->coord_data_lock_};
+    spdlog::trace("Instance {} performing main successful callback", instance_name);
+    auto &instance = find_instance(coord_data, instance_name);
+    MG_ASSERT(instance.IsMain(), "Instance {} is not a main!", instance_name);
+    instance.UpdateLastResponseTime();
+  };
+
+  main_fail_cb_ = [this, find_instance](CoordinatorData *coord_data, std::string_view instance_name) -> void {
+    auto lock = std::lock_guard{coord_data->coord_data_lock_};
+    spdlog::trace("Instance {} performing main failure callback", instance_name);
+    auto &instance = find_instance(coord_data, instance_name);
+    MG_ASSERT(instance.IsMain(), "Instance {} is not a main!", instance_name);
+    if (bool main_alive = instance.UpdateInstanceStatus(); !main_alive) {
+      spdlog::info("Main instance {} is not alive, starting automatic failover", instance_name);
+      switch (auto failover_status = DoFailover(); failover_status) {
+        using enum DoFailoverStatus;
+        case ALL_REPLICAS_DOWN:
+          spdlog::warn("Failover aborted since all replicas are down!");
+          break;
+        case MAIN_ALIVE:
+          spdlog::warn("Failover aborted since main is alive!");
+          break;
+        case RPC_FAILED:
+          spdlog::warn("Failover aborted since promoting replica to main failed!");
+          break;
+        case SUCCESS:
+          break;
+      }
+    }
+  };
+}
+
+auto CoordinatorData::DoFailover() -> DoFailoverStatus {
+  using ReplicationClientInfo = CoordinatorClientConfig::ReplicationClientInfo;
+
+  auto replica_instances = registered_instances_ | ranges::views::filter(&CoordinatorInstance::IsReplica);
+
+  auto chosen_replica_instance = std::ranges::find_if(replica_instances, &CoordinatorInstance::IsAlive);
+  if (chosen_replica_instance == replica_instances.end()) {
+    return DoFailoverStatus::ALL_REPLICAS_DOWN;
+  }
+
+  chosen_replica_instance->PrepareForFailover();
+
+  std::vector<ReplicationClientInfo> repl_clients_info;
+  repl_clients_info.reserve(std::ranges::distance(replica_instances));
+
+  auto const not_chosen_replica_instance = [&chosen_replica_instance](const CoordinatorInstance &instance) {
+    return instance != *chosen_replica_instance;
+  };
+  auto const not_main = [](const CoordinatorInstance &instance) { return !instance.IsMain(); };
+
+  // TODO (antoniofilipovic): Should we send also data on old MAIN???
+  // TODO: (andi) Don't send replicas which aren't alive
+  for (const auto &unchosen_replica_instance :
+       replica_instances | ranges::views::filter(not_chosen_replica_instance) | ranges::views::filter(not_main)) {
+    repl_clients_info.emplace_back(unchosen_replica_instance.client_.ReplicationClientInfo());
+  }
+
+  if (!chosen_replica_instance->client_.SendPromoteReplicaToMainRpc(std::move(repl_clients_info))) {
+    chosen_replica_instance->RestoreAfterFailedFailover();
+    return DoFailoverStatus::RPC_FAILED;
+  }
+
+  auto old_main = std::ranges::find_if(registered_instances_, &CoordinatorInstance::IsMain);
+  // TODO: (andi) For performing restoration we will have to improve this
+  old_main->client_.PauseFrequentCheck();
+
+  chosen_replica_instance->PostFailover(main_succ_cb_, main_fail_cb_);
+
+  return DoFailoverStatus::SUCCESS;
+}
+
+auto CoordinatorData::ShowInstances() const -> std::vector<CoordinatorInstanceStatus> {
+  std::vector<CoordinatorInstanceStatus> instances_status;
+  instances_status.reserve(registered_instances_.size());
+
+  auto const stringify_repl_role = [](const CoordinatorInstance &instance) -> std::string {
+    if (!instance.IsAlive()) return "";
+    if (instance.IsMain()) return "main";
+    return "replica";
+  };
+
+  auto const instance_to_status =
+      [&stringify_repl_role](const CoordinatorInstance &instance) -> CoordinatorInstanceStatus {
+    return {.instance_name = instance.InstanceName(),
+            .socket_address = instance.SocketAddress(),
+            .replication_role = stringify_repl_role(instance),
+            .is_alive = instance.IsAlive()};
+  };
+
+  {
+    auto lock = std::shared_lock{coord_data_lock_};
+    std::ranges::transform(registered_instances_, std::back_inserter(instances_status), instance_to_status);
+  }
+
+  return instances_status;
+}
+
+auto CoordinatorData::SetInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus {
+  auto lock = std::lock_guard{coord_data_lock_};
+
+  // Find replica we already registered
+  auto registered_replica = std::find_if(
+      registered_instances_.begin(), registered_instances_.end(),
+      [instance_name](const CoordinatorInstance &instance) { return instance.InstanceName() == instance_name; });
+
+  // if replica not found...
+  if (registered_replica == registered_instances_.end()) {
+    spdlog::error("You didn't register instance with given name {}", instance_name);
+    return SetInstanceToMainCoordinatorStatus::NO_INSTANCE_WITH_NAME;
+  }
+
+  registered_replica->client_.PauseFrequentCheck();
+
+  std::vector<CoordinatorClientConfig::ReplicationClientInfo> repl_clients_info;
+  repl_clients_info.reserve(registered_instances_.size() - 1);
+  std::ranges::for_each(registered_instances_,
+                        [registered_replica, &repl_clients_info](const CoordinatorInstance &replica) {
+                          if (replica != *registered_replica) {
+                            repl_clients_info.emplace_back(replica.client_.ReplicationClientInfo());
+                          }
+                        });
+
+  // PROMOTE REPLICA TO MAIN
+  // THIS SHOULD FAIL HERE IF IT IS DOWN
+  if (auto result = registered_replica->client_.SendPromoteReplicaToMainRpc(std::move(repl_clients_info)); !result) {
+    registered_replica->client_.ResumeFrequentCheck();
+    return SetInstanceToMainCoordinatorStatus::COULD_NOT_PROMOTE_TO_MAIN;
+  }
+
+  registered_replica->client_.SetSuccCallback(main_succ_cb_);
+  registered_replica->client_.SetFailCallback(main_fail_cb_);
+  registered_replica->replication_role_ = replication_coordination_glue::ReplicationRole::MAIN;
+  registered_replica->client_.ResumeFrequentCheck();
+
+  return SetInstanceToMainCoordinatorStatus::SUCCESS;
+}
+
+auto CoordinatorData::RegisterInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus {
+  auto lock = std::lock_guard{coord_data_lock_};
+  if (std::ranges::any_of(registered_instances_, [&config](const CoordinatorInstance &instance) {
+        return instance.InstanceName() == config.instance_name;
+      })) {
+    return RegisterInstanceCoordinatorStatus::NAME_EXISTS;
+  }
+
+  if (std::ranges::any_of(registered_instances_, [&config](const CoordinatorInstance &instance) {
+        spdlog::trace("Comparing {} with {}", instance.SocketAddress(), config.SocketAddress());
+        return instance.SocketAddress() == config.SocketAddress();
+      })) {
+    return RegisterInstanceCoordinatorStatus::END_POINT_EXISTS;
+  }
+
+  CoordinatorClientConfig::ReplicationClientInfo replication_client_info_copy = config.replication_client_info;
+
+  // TODO (antoniofilipovic) create and then push back
+  auto *instance = &registered_instances_.emplace_back(this, std::move(config), replica_succ_cb_, replica_fail_cb_,
+                                                       replication_coordination_glue::ReplicationRole::REPLICA);
+  if (auto res = instance->client_.SendSetToReplicaRpc(replication_client_info_copy); !res) {
+    return RegisterInstanceCoordinatorStatus::RPC_FAILED;
+  }
+
+  instance->client_.StartFrequentCheck();
+
+  return RegisterInstanceCoordinatorStatus::SUCCESS;
+}
+
+}  // namespace memgraph::coordination
+#endif

src/coordination/coordinator_handlers.cpp

@@ -1,218 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#ifdef MG_ENTERPRISE
-#include "coordination/coordinator_handlers.hpp"
-
-#include <range/v3/view.hpp>
-
-#include "coordination/coordinator_rpc.hpp"
-#include "coordination/include/coordination/coordinator_server.hpp"
-#include "replication/state.hpp"
-
-namespace memgraph::dbms {
-
-void CoordinatorHandlers::Register(memgraph::coordination::CoordinatorServer &server,
-                                   replication::ReplicationHandler &replication_handler) {
-  server.Register<coordination::PromoteReplicaToMainRpc>(
-      [&](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
-        spdlog::info("Received PromoteReplicaToMainRpc");
-        CoordinatorHandlers::PromoteReplicaToMainHandler(replication_handler, req_reader, res_builder);
-      });
-
-  server.Register<coordination::DemoteMainToReplicaRpc>(
-      [&replication_handler](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
-        spdlog::info("Received DemoteMainToReplicaRpc from coordinator server");
-        CoordinatorHandlers::DemoteMainToReplicaHandler(replication_handler, req_reader, res_builder);
-      });
-
-  server.Register<replication_coordination_glue::SwapMainUUIDRpc>(
-      [&replication_handler](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
-        spdlog::info("Received SwapMainUUIDRPC on coordinator server");
-        CoordinatorHandlers::SwapMainUUIDHandler(replication_handler, req_reader, res_builder);
-      });
-
-  server.Register<coordination::UnregisterReplicaRpc>(
-      [&replication_handler](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
-        spdlog::info("Received UnregisterReplicaRpc on coordinator server");
-        CoordinatorHandlers::UnregisterReplicaHandler(replication_handler, req_reader, res_builder);
-      });
-
-  server.Register<coordination::EnableWritingOnMainRpc>(
-      [&replication_handler](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
-        spdlog::info("Received EnableWritingOnMainRpc on coordinator server");
-        CoordinatorHandlers::EnableWritingOnMainHandler(replication_handler, req_reader, res_builder);
-      });
-
-  server.Register<coordination::GetInstanceUUIDRpc>(
-      [&replication_handler](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
-        spdlog::info("Received GetInstanceUUIDRpc on coordinator server");
-        CoordinatorHandlers::GetInstanceUUIDHandler(replication_handler, req_reader, res_builder);
-      });
-}
-
-void CoordinatorHandlers::SwapMainUUIDHandler(replication::ReplicationHandler &replication_handler,
-                                              slk::Reader *req_reader, slk::Builder *res_builder) {
-  if (!replication_handler.IsReplica()) {
-    spdlog::error("Setting main uuid must be performed on replica.");
-    slk::Save(replication_coordination_glue::SwapMainUUIDRes{false}, res_builder);
-    return;
-  }
-
-  replication_coordination_glue::SwapMainUUIDReq req;
-  slk::Load(&req, req_reader);
-  spdlog::info(fmt::format("Set replica data UUID  to main uuid {}", std::string(req.uuid)));
-  std::get<memgraph::replication::RoleReplicaData>(replication_handler.GetReplState().ReplicationData()).uuid_ =
-      req.uuid;
-
-  slk::Save(replication_coordination_glue::SwapMainUUIDRes{true}, res_builder);
-}
-
-void CoordinatorHandlers::DemoteMainToReplicaHandler(replication::ReplicationHandler &replication_handler,
-                                                     slk::Reader *req_reader, slk::Builder *res_builder) {
-  spdlog::info("Executing DemoteMainToReplicaHandler");
-
-  coordination::DemoteMainToReplicaReq req;
-  slk::Load(&req, req_reader);
-
-  const replication::ReplicationServerConfig clients_config{
-      .ip_address = req.replication_client_info.replication_ip_address,
-      .port = req.replication_client_info.replication_port};
-
-  if (!replication_handler.SetReplicationRoleReplica(clients_config, std::nullopt)) {
-    spdlog::error("Demoting main to replica failed!");
-    slk::Save(coordination::DemoteMainToReplicaRes{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);
-}
-
-void CoordinatorHandlers::PromoteReplicaToMainHandler(replication::ReplicationHandler &replication_handler,
-                                                      slk::Reader *req_reader, slk::Builder *res_builder) {
-  if (!replication_handler.IsReplica()) {
-    spdlog::error("Failover must be performed on replica!");
-    slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
-    return;
-  }
-  coordination::PromoteReplicaToMainReq req;
-  slk::Load(&req, req_reader);
-
-  // This can fail because of disk. If it does, the cluster state could get inconsistent.
-  // We don't handle disk issues.
-  if (const bool success = replication_handler.DoReplicaToMainPromotion(req.main_uuid_); !success) {
-    spdlog::error("Promoting replica to main failed!");
-    slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
-    return;
-  }
-
-  auto const converter = [](const auto &repl_info_config) {
-    return replication::ReplicationClientConfig{
-        .name = repl_info_config.instance_name,
-        .mode = repl_info_config.replication_mode,
-        .ip_address = repl_info_config.replication_ip_address,
-        .port = repl_info_config.replication_port,
-    };
-  };
-
-  // registering replicas
-  for (auto const &config : req.replication_clients_info | ranges::views::transform(converter)) {
-    auto instance_client = replication_handler.RegisterReplica(config, false);
-    if (instance_client.HasError()) {
-      using enum memgraph::replication::RegisterReplicaError;
-      switch (instance_client.GetError()) {
-        // Can't happen, checked on the coordinator side
-        case memgraph::query::RegisterReplicaError::NAME_EXISTS:
-          spdlog::error("Replica with the same name already exists!");
-          slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
-          return;
-        // Can't happen, checked on the coordinator side
-        case memgraph::query::RegisterReplicaError::ENDPOINT_EXISTS:
-          spdlog::error("Replica with the same endpoint already exists!");
-          slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
-          return;
-        // We don't handle disk issues
-        case memgraph::query::RegisterReplicaError::COULD_NOT_BE_PERSISTED:
-          spdlog::error("Registered replica could not be persisted!");
-          slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
-          return;
-        case memgraph::query::RegisterReplicaError::ERROR_ACCEPTING_MAIN:
-          spdlog::error("Replica didn't accept change of main!");
-          slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
-          return;
-        case memgraph::query::RegisterReplicaError::CONNECTION_FAILED:
-          // Connection failure is not a fatal error
-          break;
-      }
-    }
-  }
-  spdlog::info("Promote replica to main was success {}", std::string(req.main_uuid_));
-  slk::Save(coordination::PromoteReplicaToMainRes{true}, res_builder);
-}
-
-void CoordinatorHandlers::UnregisterReplicaHandler(replication::ReplicationHandler &replication_handler,
-                                                   slk::Reader *req_reader, slk::Builder *res_builder) {
-  if (!replication_handler.IsMain()) {
-    spdlog::error("Unregistering replica must be performed on main.");
-    slk::Save(coordination::UnregisterReplicaRes{false}, res_builder);
-    return;
-  }
-
-  coordination::UnregisterReplicaReq req;
-  slk::Load(&req, req_reader);
-
-  auto res = replication_handler.UnregisterReplica(req.instance_name);
-  switch (res) {
-    using enum memgraph::query::UnregisterReplicaResult;
-    case SUCCESS:
-      slk::Save(coordination::UnregisterReplicaRes{true}, res_builder);
-      break;
-    case NOT_MAIN:
-      spdlog::error("Unregistering replica must be performed on main.");
-      slk::Save(coordination::UnregisterReplicaRes{false}, res_builder);
-      break;
-    case CAN_NOT_UNREGISTER:
-      spdlog::error("Could not unregister replica.");
-      slk::Save(coordination::UnregisterReplicaRes{false}, res_builder);
-      break;
-    case COULD_NOT_BE_PERSISTED:
-      spdlog::error("Could not persist replica unregistration.");
-      slk::Save(coordination::UnregisterReplicaRes{false}, res_builder);
-      break;
-  }
-}
-
-void CoordinatorHandlers::EnableWritingOnMainHandler(replication::ReplicationHandler &replication_handler,
-                                                     slk::Reader * /*req_reader*/, slk::Builder *res_builder) {
-  if (!replication_handler.IsMain()) {
-    spdlog::error("Enable writing on main must be performed on main!");
-    slk::Save(coordination::EnableWritingOnMainRes{false}, res_builder);
-    return;
-  }
-
-  if (!replication_handler.GetReplState().EnableWritingOnMain()) {
-    spdlog::error("Enabling writing on main failed!");
-    slk::Save(coordination::EnableWritingOnMainRes{false}, res_builder);
-    return;
-  }
-
-  slk::Save(coordination::EnableWritingOnMainRes{true}, res_builder);
-}
-
-}  // namespace memgraph::dbms
-#endif

src/coordination/coordinator_instance.cpp

@@ -1,348 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#ifdef MG_ENTERPRISE
-
-#include "coordination/coordinator_instance.hpp"
-
-#include "coordination/coordinator_exceptions.hpp"
-#include "nuraft/coordinator_state_machine.hpp"
-#include "nuraft/coordinator_state_manager.hpp"
-#include "utils/counter.hpp"
-#include "utils/functional.hpp"
-
-#include <range/v3/view.hpp>
-#include <shared_mutex>
-
-namespace memgraph::coordination {
-
-using nuraft::ptr;
-using nuraft::srv_config;
-
-CoordinatorInstance::CoordinatorInstance()
-    : raft_state_(RaftState::MakeRaftState(
-          [this] { std::ranges::for_each(repl_instances_, &ReplicationInstance::StartFrequentCheck); },
-          [this] { std::ranges::for_each(repl_instances_, &ReplicationInstance::StopFrequentCheck); })) {
-  auto find_repl_instance = [](CoordinatorInstance *self,
-                               std::string_view repl_instance_name) -> ReplicationInstance & {
-    auto repl_instance =
-        std::ranges::find_if(self->repl_instances_, [repl_instance_name](ReplicationInstance const &instance) {
-          return instance.InstanceName() == repl_instance_name;
-        });
-
-    MG_ASSERT(repl_instance != self->repl_instances_.end(), "Instance {} not found during callback!",
-              repl_instance_name);
-    return *repl_instance;
-  };
-
-  replica_succ_cb_ = [find_repl_instance](CoordinatorInstance *self, std::string_view repl_instance_name) -> void {
-    auto lock = std::lock_guard{self->coord_instance_lock_};
-    spdlog::trace("Instance {} performing replica successful callback", repl_instance_name);
-    auto &repl_instance = find_repl_instance(self, repl_instance_name);
-
-    // We need to get replicas UUID from time to time to ensure replica is listening to correct main
-    // and that it didn't go down for less time than we could notice
-    // We need to get id of main replica is listening to
-    // and swap if necessary
-    if (!repl_instance.EnsureReplicaHasCorrectMainUUID(self->GetMainUUID())) {
-      spdlog::error("Failed to swap uuid for replica instance {} which is alive", repl_instance.InstanceName());
-      return;
-    }
-
-    repl_instance.OnSuccessPing();
-  };
-
-  replica_fail_cb_ = [find_repl_instance](CoordinatorInstance *self, std::string_view repl_instance_name) -> void {
-    auto lock = std::lock_guard{self->coord_instance_lock_};
-    spdlog::trace("Instance {} performing replica failure callback", repl_instance_name);
-    auto &repl_instance = find_repl_instance(self, repl_instance_name);
-    repl_instance.OnFailPing();
-  };
-
-  main_succ_cb_ = [find_repl_instance](CoordinatorInstance *self, std::string_view repl_instance_name) -> void {
-    auto lock = std::lock_guard{self->coord_instance_lock_};
-    spdlog::trace("Instance {} performing main successful callback", repl_instance_name);
-
-    auto &repl_instance = find_repl_instance(self, repl_instance_name);
-
-    if (repl_instance.IsAlive()) {
-      repl_instance.OnSuccessPing();
-      return;
-    }
-
-    const auto &repl_instance_uuid = repl_instance.GetMainUUID();
-    MG_ASSERT(repl_instance_uuid.has_value(), "Instance must have uuid set.");
-
-    auto const curr_main_uuid = self->GetMainUUID();
-    if (curr_main_uuid == repl_instance_uuid.value()) {
-      if (!repl_instance.EnableWritingOnMain()) {
-        spdlog::error("Failed to enable writing on main instance {}", repl_instance_name);
-        return;
-      }
-
-      repl_instance.OnSuccessPing();
-      return;
-    }
-
-    // TODO(antoniof) make demoteToReplica idempotent since main can be demoted to replica but
-    // swapUUID can fail
-    if (repl_instance.DemoteToReplica(self->replica_succ_cb_, self->replica_fail_cb_)) {
-      repl_instance.OnSuccessPing();
-      spdlog::info("Instance {} demoted to replica", repl_instance_name);
-    } else {
-      spdlog::error("Instance {} failed to become replica", repl_instance_name);
-      return;
-    }
-
-    if (!repl_instance.SendSwapAndUpdateUUID(curr_main_uuid)) {
-      spdlog::error(fmt::format("Failed to swap uuid for demoted main instance {}", repl_instance.InstanceName()));
-      return;
-    }
-  };
-
-  main_fail_cb_ = [find_repl_instance](CoordinatorInstance *self, std::string_view repl_instance_name) -> void {
-    auto lock = std::lock_guard{self->coord_instance_lock_};
-    spdlog::trace("Instance {} performing main failure callback", repl_instance_name);
-    auto &repl_instance = find_repl_instance(self, repl_instance_name);
-    repl_instance.OnFailPing();
-    const auto &repl_instance_uuid = repl_instance.GetMainUUID();
-    MG_ASSERT(repl_instance_uuid.has_value(), "Instance must have uuid set");
-
-    if (!repl_instance.IsAlive() && self->GetMainUUID() == repl_instance_uuid.value()) {
-      spdlog::info("Cluster without main instance, trying automatic failover");
-      self->TryFailover();  // TODO: (andi) Initiate failover
-    }
-  };
-}
-
-auto CoordinatorInstance::ShowInstances() const -> std::vector<InstanceStatus> {
-  auto const coord_instances = raft_state_.GetAllCoordinators();
-
-  auto const stringify_repl_role = [](ReplicationInstance const &instance) -> std::string {
-    if (!instance.IsAlive()) return "unknown";
-    if (instance.IsMain()) return "main";
-    return "replica";
-  };
-
-  auto const repl_instance_to_status = [&stringify_repl_role](ReplicationInstance const &instance) -> InstanceStatus {
-    return {.instance_name = instance.InstanceName(),
-            .coord_socket_address = instance.SocketAddress(),
-            .cluster_role = stringify_repl_role(instance),
-            .is_alive = instance.IsAlive()};
-  };
-
-  auto const coord_instance_to_status = [](ptr<srv_config> const &instance) -> InstanceStatus {
-    return {.instance_name = "coordinator_" + std::to_string(instance->get_id()),
-            .raft_socket_address = instance->get_endpoint(),
-            .cluster_role = "coordinator",
-            .is_alive = true};  // TODO: (andi) Get this info from RAFT and test it or when we will move
-                                // CoordinatorState to every instance, we can be smarter about this using our RPC.
-  };
-
-  auto instances_status = utils::fmap(coord_instance_to_status, coord_instances);
-  {
-    auto lock = std::shared_lock{coord_instance_lock_};
-    std::ranges::transform(repl_instances_, std::back_inserter(instances_status), repl_instance_to_status);
-  }
-
-  return instances_status;
-}
-
-auto CoordinatorInstance::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;
-  };
-  auto new_main = std::ranges::find_if(repl_instances_, is_new_main);
-
-  if (new_main == repl_instances_.end()) {
-    spdlog::error("Instance {} not registered. Please register it using REGISTER INSTANCE {}", instance_name,
-                  instance_name);
-    return SetInstanceToMainCoordinatorStatus::NO_INSTANCE_WITH_NAME;
-  }
-
-  new_main->PauseFrequentCheck();
-  utils::OnScopeExit scope_exit{[&new_main] { new_main->ResumeFrequentCheck(); }};
-
-  auto const is_not_new_main = [&instance_name](ReplicationInstance const &instance) {
-    return instance.InstanceName() != instance_name;
-  };
-
-  auto const new_main_uuid = utils::UUID{};
-
-  for (auto &other_instance : repl_instances_ | ranges::views::filter(is_not_new_main)) {
-    if (!other_instance.SendSwapAndUpdateUUID(new_main_uuid)) {
-      spdlog::error(
-          fmt::format("Failed to swap uuid for instance {}, aborting failover", other_instance.InstanceName()));
-      return SetInstanceToMainCoordinatorStatus::SWAP_UUID_FAILED;
-    }
-  }
-
-  ReplicationClientsInfo repl_clients_info;
-  repl_clients_info.reserve(repl_instances_.size() - 1);
-  std::ranges::transform(repl_instances_ | ranges::views::filter(is_not_new_main),
-                         std::back_inserter(repl_clients_info), &ReplicationInstance::ReplicationClientInfo);
-
-  if (!new_main->PromoteToMain(new_main_uuid, std::move(repl_clients_info), main_succ_cb_, main_fail_cb_)) {
-    return SetInstanceToMainCoordinatorStatus::COULD_NOT_PROMOTE_TO_MAIN;
-  }
-
-  // TODO: (andi) This should be replicated across all coordinator instances with Raft log
-  SetMainUUID(new_main_uuid);
-  spdlog::info("Instance {} promoted to main", instance_name);
-  return SetInstanceToMainCoordinatorStatus::SUCCESS;
-}
-
-auto CoordinatorInstance::RegisterReplicationInstance(CoordinatorClientConfig config)
-    -> RegisterInstanceCoordinatorStatus {
-  auto lock = std::lock_guard{coord_instance_lock_};
-
-  auto instance_name = config.instance_name;
-
-  auto const name_matches = [&instance_name](ReplicationInstance const &instance) {
-    return instance.InstanceName() == instance_name;
-  };
-
-  if (std::ranges::any_of(repl_instances_, name_matches)) {
-    return RegisterInstanceCoordinatorStatus::NAME_EXISTS;
-  }
-
-  auto const socket_address_matches = [&config](ReplicationInstance const &instance) {
-    return instance.SocketAddress() == config.SocketAddress();
-  };
-
-  if (std::ranges::any_of(repl_instances_, socket_address_matches)) {
-    return RegisterInstanceCoordinatorStatus::ENDPOINT_EXISTS;
-  }
-
-  if (!raft_state_.RequestLeadership()) {
-    return RegisterInstanceCoordinatorStatus::NOT_LEADER;
-  }
-
-  auto const res = raft_state_.AppendRegisterReplicationInstance(instance_name);
-  if (!res->get_accepted()) {
-    spdlog::error(
-        "Failed to accept request for registering instance {}. Most likely the reason is that the instance is not "
-        "the "
-        "leader.",
-        config.instance_name);
-    return RegisterInstanceCoordinatorStatus::RAFT_COULD_NOT_ACCEPT;
-  }
-
-  spdlog::info("Request for registering instance {} accepted", instance_name);
-  try {
-    repl_instances_.emplace_back(this, std::move(config), replica_succ_cb_, replica_fail_cb_);
-  } catch (CoordinatorRegisterInstanceException const &) {
-    return RegisterInstanceCoordinatorStatus::RPC_FAILED;
-  }
-
-  if (res->get_result_code() != nuraft::cmd_result_code::OK) {
-    spdlog::error("Failed to register instance {} with error code {}", instance_name, res->get_result_code());
-    return RegisterInstanceCoordinatorStatus::RAFT_COULD_NOT_APPEND;
-  }
-
-  spdlog::info("Instance {} registered", instance_name);
-  return RegisterInstanceCoordinatorStatus::SUCCESS;
-}
-
-auto CoordinatorInstance::UnregisterReplicationInstance(std::string instance_name)
-    -> UnregisterInstanceCoordinatorStatus {
-  auto lock = std::lock_guard{coord_instance_lock_};
-
-  auto const name_matches = [&instance_name](ReplicationInstance const &instance) {
-    return instance.InstanceName() == instance_name;
-  };
-
-  auto inst_to_remove = std::ranges::find_if(repl_instances_, name_matches);
-  if (inst_to_remove == repl_instances_.end()) {
-    return UnregisterInstanceCoordinatorStatus::NO_INSTANCE_WITH_NAME;
-  }
-
-  if (inst_to_remove->IsMain() && inst_to_remove->IsAlive()) {
-    return UnregisterInstanceCoordinatorStatus::IS_MAIN;
-  }
-
-  inst_to_remove->StopFrequentCheck();
-  auto curr_main = std::ranges::find_if(repl_instances_, &ReplicationInstance::IsMain);
-  MG_ASSERT(curr_main != repl_instances_.end(), "There must be a main instance when unregistering a replica");
-  if (!curr_main->SendUnregisterReplicaRpc(instance_name)) {
-    inst_to_remove->StartFrequentCheck();
-    return UnregisterInstanceCoordinatorStatus::RPC_FAILED;
-  }
-  std::erase_if(repl_instances_, name_matches);
-
-  return UnregisterInstanceCoordinatorStatus::SUCCESS;
-}
-
-auto CoordinatorInstance::AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address)
-    -> void {
-  raft_state_.AddCoordinatorInstance(raft_server_id, raft_port, std::move(raft_address));
-}
-
-auto CoordinatorInstance::GetMainUUID() const -> utils::UUID { return main_uuid_; }
-
-// TODO: (andi) Add to the RAFT log.
-auto CoordinatorInstance::SetMainUUID(utils::UUID new_uuid) -> void { main_uuid_ = new_uuid; }
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/coordinator_log_store.cpp

@@ -1,201 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#ifdef MG_ENTERPRISE
-
-#include "nuraft/coordinator_log_store.hpp"
-
-#include "coordination/coordinator_exceptions.hpp"
-#include "utils/logging.hpp"
-
-namespace memgraph::coordination {
-
-using nuraft::cs_new;
-
-namespace {
-
-ptr<log_entry> MakeClone(const ptr<log_entry> &entry) {
-  return cs_new<log_entry>(entry->get_term(), buffer::clone(entry->get_buf()), entry->get_val_type(),
-                           entry->get_timestamp());
-}
-
-}  // namespace
-
-CoordinatorLogStore::CoordinatorLogStore() : start_idx_(1) {
-  ptr<buffer> buf = buffer::alloc(sizeof(uint64_t));
-  logs_[0] = cs_new<log_entry>(0, buf);
-}
-
-CoordinatorLogStore::~CoordinatorLogStore() {}
-
-auto CoordinatorLogStore::FindOrDefault_(uint64_t index) const -> ptr<log_entry> {
-  auto entry = logs_.find(index);
-  if (entry == logs_.end()) {
-    entry = logs_.find(0);
-  }
-  return entry->second;
-}
-
-uint64_t CoordinatorLogStore::next_slot() const {
-  auto lock = std::lock_guard{logs_lock_};
-  return start_idx_ + logs_.size() - 1;
-}
-
-uint64_t CoordinatorLogStore::start_index() const { return start_idx_; }
-
-ptr<log_entry> CoordinatorLogStore::last_entry() const {
-  auto lock = std::lock_guard{logs_lock_};
-
-  uint64_t const last_idx = start_idx_ + logs_.size() - 1;
-  auto const last_src = FindOrDefault_(last_idx - 1);
-
-  return MakeClone(last_src);
-}
-
-uint64_t CoordinatorLogStore::append(ptr<log_entry> &entry) {
-  ptr<log_entry> clone = MakeClone(entry);
-  uint64_t next_slot{0};
-  {
-    auto lock = std::lock_guard{logs_lock_};
-    next_slot = start_idx_ + logs_.size() - 1;
-    logs_[next_slot] = clone;
-  }
-  return next_slot;
-}
-
-void CoordinatorLogStore::write_at(uint64_t index, ptr<log_entry> &entry) {
-  ptr<log_entry> clone = MakeClone(entry);
-
-  // Discard all logs equal to or greater than `index.
-  {
-    auto lock = std::lock_guard{logs_lock_};
-    auto itr = logs_.lower_bound(index);
-    while (itr != logs_.end()) {
-      itr = logs_.erase(itr);
-    }
-    logs_[index] = clone;
-  }
-}
-
-ptr<std::vector<ptr<log_entry>>> CoordinatorLogStore::log_entries(uint64_t start, uint64_t end) {
-  auto ret = cs_new<std::vector<ptr<log_entry>>>();
-  ret->resize(end - start);
-
-  for (uint64_t i = start, curr_index = 0; i < end; ++i, ++curr_index) {
-    ptr<log_entry> src = nullptr;
-    {
-      auto lock = std::lock_guard{logs_lock_};
-      if (auto const entry = logs_.find(i); entry != logs_.end()) {
-        src = entry->second;
-      } else {
-        throw RaftCouldNotFindEntryException("Could not find entry at index {}", i);
-      }
-    }
-    (*ret)[curr_index] = MakeClone(src);
-  }
-  return ret;
-}
-
-ptr<log_entry> CoordinatorLogStore::entry_at(uint64_t index) {
-  ptr<log_entry> src = nullptr;
-  {
-    auto lock = std::lock_guard{logs_lock_};
-    src = FindOrDefault_(index);
-  }
-  return MakeClone(src);
-}
-
-uint64_t CoordinatorLogStore::term_at(uint64_t index) {
-  uint64_t term = 0;
-  {
-    auto lock = std::lock_guard{logs_lock_};
-    term = FindOrDefault_(index)->get_term();
-  }
-  return term;
-}
-
-ptr<buffer> CoordinatorLogStore::pack(uint64_t index, int32 cnt) {
-  std::vector<ptr<buffer>> logs;
-
-  size_t size_total = 0;
-  uint64_t const end_index = index + cnt;
-  for (uint64_t i = index; i < end_index; ++i) {
-    ptr<log_entry> le = nullptr;
-    {
-      auto lock = std::lock_guard{logs_lock_};
-      le = logs_[i];
-    }
-    MG_ASSERT(le.get(), "Could not find log entry at index {}", i);
-    auto buf = le->serialize();
-    size_total += buf->size();
-    logs.push_back(buf);
-  }
-
-  auto buf_out = buffer::alloc(sizeof(int32) + cnt * sizeof(int32) + size_total);
-  buf_out->pos(0);
-  buf_out->put((int32)cnt);
-
-  for (auto &entry : logs) {
-    buf_out->put(static_cast<int32>(entry->size()));
-    buf_out->put(*entry);
-  }
-  return buf_out;
-}
-
-void CoordinatorLogStore::apply_pack(uint64_t index, buffer &pack) {
-  pack.pos(0);
-  int32 const num_logs = pack.get_int();
-
-  for (int32 i = 0; i < num_logs; ++i) {
-    uint64_t cur_idx = index + i;
-    int32 buf_size = pack.get_int();
-
-    ptr<buffer> buf_local = buffer::alloc(buf_size);
-    pack.get(buf_local);
-
-    ptr<log_entry> le = log_entry::deserialize(*buf_local);
-    {
-      auto lock = std::lock_guard{logs_lock_};
-      logs_[cur_idx] = le;
-    }
-  }
-
-  {
-    auto lock = std::lock_guard{logs_lock_};
-    auto const entry = logs_.upper_bound(0);
-    if (entry != logs_.end()) {
-      start_idx_ = entry->first;
-    } else {
-      start_idx_ = 1;
-    }
-  }
-}
-
-// NOTE: Remove all logs up to given 'last_log_index' (inclusive).
-bool CoordinatorLogStore::compact(uint64_t last_log_index) {
-  auto lock = std::lock_guard{logs_lock_};
-  for (uint64_t ii = start_idx_; ii <= last_log_index; ++ii) {
-    auto const entry = logs_.find(ii);
-    if (entry != logs_.end()) {
-      logs_.erase(entry);
-    }
-  }
-
-  if (start_idx_ <= last_log_index) {
-    start_idx_ = last_log_index + 1;
-  }
-  return true;
-}
-
-bool CoordinatorLogStore::flush() { return true; }
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/coordinator_rpc.cpp

@@ -36,64 +36,19 @@ void PromoteReplicaToMainRes::Load(PromoteReplicaToMainRes *self, memgraph::slk:
   memgraph::slk::Load(self, reader);
 }
 
-void DemoteMainToReplicaReq::Save(const DemoteMainToReplicaReq &self, memgraph::slk::Builder *builder) {
+void SetMainToReplicaReq::Save(const SetMainToReplicaReq &self, memgraph::slk::Builder *builder) {
   memgraph::slk::Save(self, builder);
 }
 
-void DemoteMainToReplicaReq::Load(DemoteMainToReplicaReq *self, memgraph::slk::Reader *reader) {
+void SetMainToReplicaReq::Load(SetMainToReplicaReq *self, memgraph::slk::Reader *reader) {
   memgraph::slk::Load(self, reader);
 }
 
-void DemoteMainToReplicaRes::Save(const DemoteMainToReplicaRes &self, memgraph::slk::Builder *builder) {
+void SetMainToReplicaRes::Save(const SetMainToReplicaRes &self, memgraph::slk::Builder *builder) {
   memgraph::slk::Save(self, builder);
 }
 
-void DemoteMainToReplicaRes::Load(DemoteMainToReplicaRes *self, memgraph::slk::Reader *reader) {
-  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) {
+void SetMainToReplicaRes::Load(SetMainToReplicaRes *self, memgraph::slk::Reader *reader) {
   memgraph::slk::Load(self, reader);
 }
 
@@ -105,35 +60,14 @@ constexpr utils::TypeInfo coordination::PromoteReplicaToMainReq::kType{utils::Ty
 constexpr utils::TypeInfo coordination::PromoteReplicaToMainRes::kType{utils::TypeId::COORD_FAILOVER_RES,
                                                                        "CoordPromoteReplicaToMainRes", nullptr};
 
-constexpr utils::TypeInfo coordination::DemoteMainToReplicaReq::kType{utils::TypeId::COORD_SET_REPL_MAIN_REQ,
-                                                                      "CoordDemoteToReplicaReq", nullptr};
+constexpr utils::TypeInfo coordination::SetMainToReplicaReq::kType{utils::TypeId::COORD_SET_REPL_MAIN_REQ,
+                                                                   "CoordSetReplMainReq", 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};
+constexpr utils::TypeInfo coordination::SetMainToReplicaRes::kType{utils::TypeId::COORD_SET_REPL_MAIN_RES,
+                                                                   "CoordSetReplMainRes", nullptr};
 
 namespace slk {
 
-// PromoteReplicaToMainRpc
-
 void Save(const memgraph::coordination::PromoteReplicaToMainRes &self, memgraph::slk::Builder *builder) {
   memgraph::slk::Save(self.success, builder);
 }
@@ -143,76 +77,29 @@ void Load(memgraph::coordination::PromoteReplicaToMainRes *self, memgraph::slk::
 }
 
 void Save(const memgraph::coordination::PromoteReplicaToMainReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.main_uuid_, builder);
   memgraph::slk::Save(self.replication_clients_info, builder);
 }
 
 void Load(memgraph::coordination::PromoteReplicaToMainReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->main_uuid_, reader);
   memgraph::slk::Load(&self->replication_clients_info, reader);
 }
 
-// DemoteMainToReplicaRpc
-void Save(const memgraph::coordination::DemoteMainToReplicaReq &self, memgraph::slk::Builder *builder) {
+void Save(const memgraph::coordination::SetMainToReplicaReq &self, memgraph::slk::Builder *builder) {
   memgraph::slk::Save(self.replication_client_info, builder);
 }
 
-void Load(memgraph::coordination::DemoteMainToReplicaReq *self, memgraph::slk::Reader *reader) {
+void Load(memgraph::coordination::SetMainToReplicaReq *self, memgraph::slk::Reader *reader) {
   memgraph::slk::Load(&self->replication_client_info, reader);
 }
 
-void Save(const memgraph::coordination::DemoteMainToReplicaRes &self, memgraph::slk::Builder *builder) {
+void Save(const memgraph::coordination::SetMainToReplicaRes &self, memgraph::slk::Builder *builder) {
   memgraph::slk::Save(self.success, builder);
 }
 
-void Load(memgraph::coordination::DemoteMainToReplicaRes *self, memgraph::slk::Reader *reader) {
+void Load(memgraph::coordination::SetMainToReplicaRes *self, memgraph::slk::Reader *reader) {
   memgraph::slk::Load(&self->success, reader);
 }
 
-// UnregisterReplicaRpc
-
-void Save(memgraph::coordination::UnregisterReplicaReq const &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.instance_name, builder);
-}
-
-void Load(memgraph::coordination::UnregisterReplicaReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->instance_name, reader);
-}
-
-void Save(memgraph::coordination::UnregisterReplicaRes const &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.success, builder);
-}
-
-void Load(memgraph::coordination::UnregisterReplicaRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->success, reader);
-}
-
-void Save(memgraph::coordination::EnableWritingOnMainRes const &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.success, builder);
-}
-
-void Load(memgraph::coordination::EnableWritingOnMainRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->success, reader);
-}
-
-// GetInstanceUUIDRpc
-
-void Save(const memgraph::coordination::GetInstanceUUIDReq & /*self*/, memgraph::slk::Builder * /*builder*/) {
-  /* nothing to serialize*/
-}
-
-void Load(memgraph::coordination::GetInstanceUUIDReq * /*self*/, memgraph::slk::Reader * /*reader*/) {
-  /* nothing to serialize*/
-}
-
-void Save(const memgraph::coordination::GetInstanceUUIDRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.uuid, builder);
-}
-
-void Load(memgraph::coordination::GetInstanceUUIDRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->uuid, reader);
-}
-
 }  // namespace slk
 
 }  // namespace memgraph

src/coordination/coordinator_server.cpp

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

src/coordination/coordinator_state.cpp

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

src/coordination/coordinator_state_machine.cpp

@@ -1,111 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#ifdef MG_ENTERPRISE
-
-#include "nuraft/coordinator_state_machine.hpp"
-
-namespace memgraph::coordination {
-
-auto CoordinatorStateMachine::EncodeRegisterReplicationInstance(const std::string &name) -> ptr<buffer> {
-  std::string str_log = name + "_replica";
-  ptr<buffer> log = buffer::alloc(sizeof(uint32_t) + str_log.size());
-  buffer_serializer bs(log);
-  bs.put_str(str_log);
-  return log;
-}
-
-auto CoordinatorStateMachine::DecodeRegisterReplicationInstance(buffer &data) -> std::string {
-  buffer_serializer bs(data);
-  return bs.get_str();
-}
-
-auto CoordinatorStateMachine::pre_commit(ulong const log_idx, buffer &data) -> ptr<buffer> {
-  buffer_serializer bs(data);
-  std::string str = bs.get_str();
-
-  spdlog::info("pre_commit {} : {}", log_idx, str);
-  return nullptr;
-}
-
-auto CoordinatorStateMachine::commit(ulong const log_idx, buffer &data) -> ptr<buffer> {
-  buffer_serializer bs(data);
-  std::string str = bs.get_str();
-
-  spdlog::info("commit {} : {}", log_idx, str);
-
-  last_committed_idx_ = log_idx;
-  return nullptr;
-}
-
-auto CoordinatorStateMachine::commit_config(ulong const log_idx, ptr<cluster_config> & /*new_conf*/) -> void {
-  last_committed_idx_ = log_idx;
-}
-
-auto CoordinatorStateMachine::rollback(ulong const log_idx, buffer &data) -> void {
-  buffer_serializer bs(data);
-  std::string str = bs.get_str();
-
-  spdlog::info("rollback {} : {}", log_idx, str);
-}
-
-auto CoordinatorStateMachine::read_logical_snp_obj(snapshot & /*snapshot*/, void *& /*user_snp_ctx*/, ulong /*obj_id*/,
-                                                   ptr<buffer> &data_out, bool &is_last_obj) -> int {
-  // Put dummy data.
-  data_out = buffer::alloc(sizeof(int32));
-  buffer_serializer bs(data_out);
-  bs.put_i32(0);
-
-  is_last_obj = true;
-  return 0;
-}
-
-auto CoordinatorStateMachine::save_logical_snp_obj(snapshot &s, ulong &obj_id, buffer & /*data*/, bool /*is_first_obj*/,
-                                                   bool /*is_last_obj*/) -> void {
-  spdlog::info("save snapshot {} term {} object ID", s.get_last_log_idx(), s.get_last_log_term(), obj_id);
-  // Request next object.
-  obj_id++;
-}
-
-auto CoordinatorStateMachine::apply_snapshot(snapshot &s) -> bool {
-  spdlog::info("apply snapshot {} term {}", s.get_last_log_idx(), s.get_last_log_term());
-  {
-    auto lock = std::lock_guard{last_snapshot_lock_};
-    ptr<buffer> snp_buf = s.serialize();
-    last_snapshot_ = snapshot::deserialize(*snp_buf);
-  }
-  return true;
-}
-
-auto CoordinatorStateMachine::free_user_snp_ctx(void *&user_snp_ctx) -> void {}
-
-auto CoordinatorStateMachine::last_snapshot() -> ptr<snapshot> {
-  auto lock = std::lock_guard{last_snapshot_lock_};
-  return last_snapshot_;
-}
-
-auto CoordinatorStateMachine::last_commit_index() -> ulong { return last_committed_idx_; }
-
-auto CoordinatorStateMachine::create_snapshot(snapshot &s, async_result<bool>::handler_type &when_done) -> void {
-  spdlog::info("create snapshot {} term {}", s.get_last_log_idx(), s.get_last_log_term());
-  // Clone snapshot from `s`.
-  {
-    auto lock = std::lock_guard{last_snapshot_lock_};
-    ptr<buffer> snp_buf = s.serialize();
-    last_snapshot_ = snapshot::deserialize(*snp_buf);
-  }
-  ptr<std::exception> except(nullptr);
-  bool ret = true;
-  when_done(ret, except);
-}
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/coordinator_state_manager.cpp

@@ -1,68 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#ifdef MG_ENTERPRISE
-
-#include "nuraft/coordinator_state_manager.hpp"
-
-namespace memgraph::coordination {
-
-using nuraft::cluster_config;
-using nuraft::cs_new;
-using nuraft::srv_config;
-using nuraft::srv_state;
-using nuraft::state_mgr;
-
-CoordinatorStateManager::CoordinatorStateManager(int srv_id, std::string const &endpoint)
-    : my_id_(srv_id), my_endpoint_(endpoint), cur_log_store_(cs_new<CoordinatorLogStore>()) {
-  my_srv_config_ = cs_new<srv_config>(srv_id, endpoint);
-
-  // Initial cluster config: contains only one server (myself).
-  cluster_config_ = cs_new<cluster_config>();
-  cluster_config_->get_servers().push_back(my_srv_config_);
-}
-
-auto CoordinatorStateManager::load_config() -> ptr<cluster_config> {
-  // Just return in-memory data in this example.
-  // May require reading from disk here, if it has been written to disk.
-  return cluster_config_;
-}
-
-auto CoordinatorStateManager::save_config(cluster_config const &config) -> void {
-  // Just keep in memory in this example.
-  // Need to write to disk here, if want to make it durable.
-  ptr<buffer> buf = config.serialize();
-  cluster_config_ = cluster_config::deserialize(*buf);
-}
-
-auto CoordinatorStateManager::save_state(srv_state const &state) -> void {
-  // Just keep in memory in this example.
-  // Need to write to disk here, if want to make it durable.
-  ptr<buffer> buf = state.serialize();
-  saved_state_ = srv_state::deserialize(*buf);
-}
-
-auto CoordinatorStateManager::read_state() -> ptr<srv_state> {
-  // Just return in-memory data in this example.
-  // May require reading from disk here, if it has been written to disk.
-  return saved_state_;
-}
-
-auto CoordinatorStateManager::load_log_store() -> ptr<log_store> { return cur_log_store_; }
-
-auto CoordinatorStateManager::server_id() -> int32 { return my_id_; }
-
-auto CoordinatorStateManager::system_exit(int const exit_code) -> void {}
-
-auto CoordinatorStateManager::GetSrvConfig() const -> ptr<srv_config> { return my_srv_config_; }
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/include/coordination/coordinator_client.hpp

@@ -15,21 +15,20 @@
 
 #include "coordination/coordinator_config.hpp"
 #include "rpc/client.hpp"
-#include "rpc_errors.hpp"
-#include "utils/result.hpp"
 #include "utils/scheduler.hpp"
-#include "utils/uuid.hpp"
 
 namespace memgraph::coordination {
 
-class CoordinatorInstance;
-using HealthCheckCallback = std::function<void(CoordinatorInstance *, std::string_view)>;
-using ReplicationClientsInfo = std::vector<ReplClientInfo>;
+class CoordinatorData;
+using HealthCheckCallback = std::function<void(CoordinatorData *, std::string_view)>;
 
 class CoordinatorClient {
  public:
-  explicit CoordinatorClient(CoordinatorInstance *coord_instance, CoordinatorClientConfig config,
-                             HealthCheckCallback succ_cb, HealthCheckCallback fail_cb);
+  using ReplClientInfo = CoordinatorClientConfig::ReplicationClientInfo;
+  using ReplicationClientsInfo = std::vector<ReplClientInfo>;
+
+  explicit CoordinatorClient(CoordinatorData *coord_data_, CoordinatorClientConfig config, HealthCheckCallback succ_cb,
+                             HealthCheckCallback fail_cb);
 
   ~CoordinatorClient() = default;
 
@@ -47,28 +46,15 @@ class CoordinatorClient {
   auto InstanceName() const -> std::string;
   auto SocketAddress() const -> std::string;
 
-  [[nodiscard]] auto DemoteToReplica() const -> bool;
+  auto SendPromoteReplicaToMainRpc(ReplicationClientsInfo replication_clients_info) const -> bool;
 
-  auto SendPromoteReplicaToMainRpc(const utils::UUID &uuid, ReplicationClientsInfo replication_clients_info) const
-      -> bool;
+  auto ReplicationClientInfo() const -> const ReplClientInfo &;
+  auto ResetReplicationClientInfo() -> void;
 
-  auto SendSwapMainUUIDRpc(const utils::UUID &uuid) const -> bool;
+  auto SendSetToReplicaRpc(ReplClientInfo replication_client_info) 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;
+  auto SetSuccCallback(HealthCheckCallback succ_cb) -> void;
+  auto SetFailCallback(HealthCheckCallback fail_cb) -> void;
 
   friend bool operator==(CoordinatorClient const &first, CoordinatorClient const &second) {
     return first.config_ == second.config_;
@@ -77,11 +63,12 @@ class CoordinatorClient {
  private:
   utils::Scheduler instance_checker_;
 
+  // TODO: (andi) Pimpl?
   communication::ClientContext rpc_context_;
   mutable rpc::Client rpc_client_;
 
   CoordinatorClientConfig config_;
-  CoordinatorInstance *coord_instance_;
+  CoordinatorData *coord_data_;
   HealthCheckCallback succ_cb_;
   HealthCheckCallback fail_cb_;
 };

src/coordination/include/coordination/coordinator_cluster_config.hpp

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

src/coordination/include/coordination/coordinator_config.hpp

@@ -28,13 +28,13 @@ 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); }
 
+  // Info which coordinator will send to new main when performing failover
   struct ReplicationClientInfo {
+    // Must be the same as CoordinatorClientConfig's instance_name
     std::string instance_name;
     replication_coordination_glue::ReplicationMode replication_mode{};
     std::string replication_ip_address;
@@ -43,6 +43,7 @@ struct CoordinatorClientConfig {
     friend bool operator==(ReplicationClientInfo const &, ReplicationClientInfo const &) = default;
   };
 
+  // Each instance has replication config in case it fails
   ReplicationClientInfo replication_client_info;
 
   struct SSL {
@@ -57,8 +58,6 @@ struct CoordinatorClientConfig {
   friend bool operator==(CoordinatorClientConfig const &, CoordinatorClientConfig const &) = default;
 };
 
-using ReplClientInfo = CoordinatorClientConfig::ReplicationClientInfo;
-
 struct CoordinatorServerConfig {
   std::string ip_address;
   uint16_t port{};

src/coordination/include/coordination/coordinator_data.hpp

@@ -0,0 +1,49 @@
+// Copyright 2024 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+#ifdef MG_ENTERPRISE
+
+#include "coordination/coordinator_instance.hpp"
+#include "coordination/coordinator_instance_status.hpp"
+#include "coordination/coordinator_server.hpp"
+#include "coordination/failover_status.hpp"
+#include "coordination/register_main_replica_coordinator_status.hpp"
+#include "utils/rw_lock.hpp"
+
+#include <list>
+
+namespace memgraph::coordination {
+class CoordinatorData {
+ public:
+  CoordinatorData();
+
+  [[nodiscard]] auto DoFailover() -> DoFailoverStatus;
+
+  [[nodiscard]] auto RegisterInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus;
+  [[nodiscard]] auto SetInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus;
+
+  auto ShowInstances() const -> std::vector<CoordinatorInstanceStatus>;
+
+ private:
+  mutable utils::RWLock coord_data_lock_{utils::RWLock::Priority::READ};
+  HealthCheckCallback main_succ_cb_, main_fail_cb_, replica_succ_cb_, replica_fail_cb_;
+  // Must be std::list because we rely on pointer stability
+  std::list<CoordinatorInstance> registered_instances_;
+};
+
+struct CoordinatorMainReplicaData {
+  std::unique_ptr<CoordinatorServer> coordinator_server_;
+};
+
+}  // namespace memgraph::coordination
+#endif

src/coordination/include/coordination/coordinator_exceptions.hpp

@@ -16,71 +16,16 @@
 #include "utils/exceptions.hpp"
 
 namespace memgraph::coordination {
-class CoordinatorRegisterInstanceException final : public utils::BasicException {
+class CoordinatorFailoverException final : public utils::BasicException {
  public:
-  explicit CoordinatorRegisterInstanceException(const std::string_view what) noexcept
-      : BasicException("Failed to create instance: " + std::string(what)) {}
+  explicit CoordinatorFailoverException(const std::string_view what) noexcept
+      : BasicException("Failover didn't complete successfully: " + std::string(what)) {}
 
   template <class... Args>
-  explicit CoordinatorRegisterInstanceException(fmt::format_string<Args...> fmt, Args &&...args) noexcept
-      : CoordinatorRegisterInstanceException(fmt::format(fmt, std::forward<Args>(args)...)) {}
+  explicit CoordinatorFailoverException(fmt::format_string<Args...> fmt, Args &&...args) noexcept
+      : CoordinatorFailoverException(fmt::format(fmt, std::forward<Args>(args)...)) {}
 
-  SPECIALIZE_GET_EXCEPTION_NAME(CoordinatorRegisterInstanceException)
-};
-
-class RaftServerStartException final : public utils::BasicException {
- public:
-  explicit RaftServerStartException(std::string_view what) noexcept : BasicException(what) {}
-
-  template <class... Args>
-  explicit RaftServerStartException(fmt::format_string<Args...> fmt, Args &&...args) noexcept
-      : RaftServerStartException(fmt::format(fmt, std::forward<Args>(args)...)) {}
-
-  SPECIALIZE_GET_EXCEPTION_NAME(RaftServerStartException)
-};
-
-class RaftAddServerException final : public utils::BasicException {
- public:
-  explicit RaftAddServerException(std::string_view what) noexcept : BasicException(what) {}
-
-  template <class... Args>
-  explicit RaftAddServerException(fmt::format_string<Args...> fmt, Args &&...args) noexcept
-      : RaftAddServerException(fmt::format(fmt, std::forward<Args>(args)...)) {}
-
-  SPECIALIZE_GET_EXCEPTION_NAME(RaftAddServerException)
-};
-
-class RaftBecomeLeaderException final : public utils::BasicException {
- public:
-  explicit RaftBecomeLeaderException(std::string_view what) noexcept : BasicException(what) {}
-
-  template <class... Args>
-  explicit RaftBecomeLeaderException(fmt::format_string<Args...> fmt, Args &&...args) noexcept
-      : RaftBecomeLeaderException(fmt::format(fmt, std::forward<Args>(args)...)) {}
-
-  SPECIALIZE_GET_EXCEPTION_NAME(RaftBecomeLeaderException)
-};
-
-class RaftCouldNotFindEntryException final : public utils::BasicException {
- public:
-  explicit RaftCouldNotFindEntryException(std::string_view what) noexcept : BasicException(what) {}
-
-  template <class... Args>
-  explicit RaftCouldNotFindEntryException(fmt::format_string<Args...> fmt, Args &&...args) noexcept
-      : RaftCouldNotFindEntryException(fmt::format(fmt, std::forward<Args>(args)...)) {}
-
-  SPECIALIZE_GET_EXCEPTION_NAME(RaftCouldNotFindEntryException)
-};
-
-class RaftCouldNotParseFlagsException final : public utils::BasicException {
- public:
-  explicit RaftCouldNotParseFlagsException(std::string_view what) noexcept : BasicException(what) {}
-
-  template <class... Args>
-  explicit RaftCouldNotParseFlagsException(fmt::format_string<Args...> fmt, Args &&...args) noexcept
-      : RaftCouldNotParseFlagsException(fmt::format(fmt, std::forward<Args>(args)...)) {}
-
-  SPECIALIZE_GET_EXCEPTION_NAME(RaftCouldNotParseFlagsException)
+  SPECIALIZE_GET_EXCEPTION_NAME(CoordinatorFailoverException)
 };
 
 }  // namespace memgraph::coordination

src/coordination/include/coordination/coordinator_handlers.hpp

@@ -1,48 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include "coordination/coordinator_server.hpp"
-#include "replication_handler/replication_handler.hpp"
-#include "slk/streams.hpp"
-
-namespace memgraph::dbms {
-
-class DbmsHandler;
-
-class CoordinatorHandlers {
- public:
-  static void Register(memgraph::coordination::CoordinatorServer &server,
-                       replication::ReplicationHandler &replication_handler);
-
- private:
-  static void PromoteReplicaToMainHandler(replication::ReplicationHandler &replication_handler, slk::Reader *req_reader,
-                                          slk::Builder *res_builder);
-  static void DemoteMainToReplicaHandler(replication::ReplicationHandler &replication_handler, slk::Reader *req_reader,
-                                         slk::Builder *res_builder);
-  static void SwapMainUUIDHandler(replication::ReplicationHandler &replication_handler, slk::Reader *req_reader,
-                                  slk::Builder *res_builder);
-
-  static void UnregisterReplicaHandler(replication::ReplicationHandler &replication_handler, slk::Reader *req_reader,
-                                       slk::Builder *res_builder);
-  static void EnableWritingOnMainHandler(replication::ReplicationHandler &replication_handler, slk::Reader *req_reader,
-                                         slk::Builder *res_builder);
-
-  static void GetInstanceUUIDHandler(replication::ReplicationHandler &replication_handler, slk::Reader *req_reader,
-                                     slk::Builder *res_builder);
-};
-
-}  // namespace memgraph::dbms
-
-#endif

src/coordination/include/coordination/coordinator_instance.hpp

@@ -13,47 +13,64 @@
 
 #ifdef MG_ENTERPRISE
 
-#include "coordination/coordinator_server.hpp"
-#include "coordination/instance_status.hpp"
-#include "coordination/raft_state.hpp"
-#include "coordination/register_main_replica_coordinator_status.hpp"
-#include "coordination/replication_instance.hpp"
-#include "utils/rw_lock.hpp"
-#include "utils/thread_pool.hpp"
-
-#include <list>
+#include "coordination/coordinator_client.hpp"
+#include "coordination/coordinator_cluster_config.hpp"
+#include "replication_coordination_glue/role.hpp"
 
 namespace memgraph::coordination {
 
+class CoordinatorData;
+
 class CoordinatorInstance {
  public:
-  CoordinatorInstance();
+  CoordinatorInstance(CoordinatorData *data, CoordinatorClientConfig config, HealthCheckCallback succ_cb,
+                      HealthCheckCallback fail_cb, replication_coordination_glue::ReplicationRole replication_role)
+      : client_(data, std::move(config), std::move(succ_cb), std::move(fail_cb)),
+        replication_role_(replication_role),
+        is_alive_(true) {}
 
-  [[nodiscard]] auto RegisterReplicationInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus;
-  [[nodiscard]] auto UnregisterReplicationInstance(std::string instance_name) -> UnregisterInstanceCoordinatorStatus;
+  CoordinatorInstance(CoordinatorInstance const &other) = delete;
+  CoordinatorInstance &operator=(CoordinatorInstance const &other) = delete;
+  CoordinatorInstance(CoordinatorInstance &&other) noexcept = delete;
+  CoordinatorInstance &operator=(CoordinatorInstance &&other) noexcept = delete;
+  ~CoordinatorInstance() = default;
 
-  [[nodiscard]] auto SetReplicationInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus;
+  auto UpdateInstanceStatus() -> bool {
+    is_alive_ = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - last_response_time_)
+                    .count() < CoordinatorClusterConfig::alive_response_time_difference_sec_;
+    return is_alive_;
+  }
+  auto UpdateLastResponseTime() -> void { last_response_time_ = std::chrono::system_clock::now(); }
 
-  auto ShowInstances() const -> std::vector<InstanceStatus>;
+  auto InstanceName() const -> std::string { return client_.InstanceName(); }
+  auto SocketAddress() const -> std::string { return client_.SocketAddress(); }
+  auto IsAlive() const -> bool { return is_alive_; }
 
-  auto TryFailover() -> void;
+  auto IsReplica() const -> bool {
+    return replication_role_ == replication_coordination_glue::ReplicationRole::REPLICA;
+  }
+  auto IsMain() const -> bool { return replication_role_ == replication_coordination_glue::ReplicationRole::MAIN; }
 
-  auto AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address) -> void;
+  auto PrepareForFailover() -> void { client_.PauseFrequentCheck(); }
+  auto RestoreAfterFailedFailover() -> void { client_.ResumeFrequentCheck(); }
 
-  auto GetMainUUID() const -> utils::UUID;
+  auto PostFailover(HealthCheckCallback main_succ_cb, HealthCheckCallback main_fail_cb) -> void {
+    replication_role_ = replication_coordination_glue::ReplicationRole::MAIN;
+    client_.SetSuccCallback(std::move(main_succ_cb));
+    client_.SetFailCallback(std::move(main_fail_cb));
+    // Comment with Andi but we shouldn't delete this, what if this MAIN FAILS AGAIN
+    // client_.ResetReplicationClientInfo();
+    client_.ResumeFrequentCheck();
+  }
 
-  auto SetMainUUID(utils::UUID new_uuid) -> void;
+  CoordinatorClient client_;
+  replication_coordination_glue::ReplicationRole replication_role_;
+  std::chrono::system_clock::time_point last_response_time_{};
+  bool is_alive_{false};
 
- private:
-  HealthCheckCallback main_succ_cb_, main_fail_cb_, replica_succ_cb_, replica_fail_cb_;
-
-  // NOTE: Must be std::list because we rely on pointer stability
-  std::list<ReplicationInstance> repl_instances_;
-  mutable utils::RWLock coord_instance_lock_{utils::RWLock::Priority::READ};
-
-  utils::UUID main_uuid_;
-
-  RaftState raft_state_;
+  friend bool operator==(CoordinatorInstance const &first, CoordinatorInstance const &second) {
+    return first.client_ == second.client_ && first.replication_role_ == second.replication_role_;
+  }
 };
 
 }  // namespace memgraph::coordination

src/coordination/include/coordination/coordinator_instance_status.hpp

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

src/coordination/include/coordination/coordinator_rpc.hpp

@@ -11,7 +11,6 @@
 
 #pragma once
 
-#include "utils/uuid.hpp"
 #ifdef MG_ENTERPRISE
 
 #include "coordination/coordinator_config.hpp"
@@ -27,13 +26,10 @@ struct PromoteReplicaToMainReq {
   static void Load(PromoteReplicaToMainReq *self, memgraph::slk::Reader *reader);
   static void Save(const PromoteReplicaToMainReq &self, memgraph::slk::Builder *builder);
 
-  explicit PromoteReplicaToMainReq(const utils::UUID &uuid,
-                                   std::vector<CoordinatorClientConfig::ReplicationClientInfo> replication_clients_info)
-      : main_uuid_(uuid), replication_clients_info(std::move(replication_clients_info)) {}
+  explicit PromoteReplicaToMainReq(std::vector<CoordinatorClientConfig::ReplicationClientInfo> replication_clients_info)
+      : replication_clients_info(std::move(replication_clients_info)) {}
   PromoteReplicaToMainReq() = default;
 
-  // get uuid here
-  utils::UUID main_uuid_;
   std::vector<CoordinatorClientConfig::ReplicationClientInfo> replication_clients_info;
 };
 
@@ -52,145 +48,56 @@ struct PromoteReplicaToMainRes {
 
 using PromoteReplicaToMainRpc = rpc::RequestResponse<PromoteReplicaToMainReq, PromoteReplicaToMainRes>;
 
-struct DemoteMainToReplicaReq {
+struct SetMainToReplicaReq {
   static const utils::TypeInfo kType;
   static const utils::TypeInfo &GetTypeInfo() { return kType; }
 
-  static void Load(DemoteMainToReplicaReq *self, memgraph::slk::Reader *reader);
-  static void Save(const DemoteMainToReplicaReq &self, memgraph::slk::Builder *builder);
+  static void Load(SetMainToReplicaReq *self, memgraph::slk::Reader *reader);
+  static void Save(const SetMainToReplicaReq &self, memgraph::slk::Builder *builder);
 
-  explicit DemoteMainToReplicaReq(CoordinatorClientConfig::ReplicationClientInfo replication_client_info)
+  explicit SetMainToReplicaReq(CoordinatorClientConfig::ReplicationClientInfo replication_client_info)
       : replication_client_info(std::move(replication_client_info)) {}
 
-  DemoteMainToReplicaReq() = default;
+  SetMainToReplicaReq() = default;
 
   CoordinatorClientConfig::ReplicationClientInfo replication_client_info;
 };
 
-struct DemoteMainToReplicaRes {
+struct SetMainToReplicaRes {
   static const utils::TypeInfo kType;
   static const utils::TypeInfo &GetTypeInfo() { return kType; }
 
-  static void Load(DemoteMainToReplicaRes *self, memgraph::slk::Reader *reader);
-  static void Save(const DemoteMainToReplicaRes &self, memgraph::slk::Builder *builder);
+  static void Load(SetMainToReplicaRes *self, memgraph::slk::Reader *reader);
+  static void Save(const SetMainToReplicaRes &self, memgraph::slk::Builder *builder);
 
-  explicit DemoteMainToReplicaRes(bool success) : success(success) {}
-  DemoteMainToReplicaRes() = default;
+  explicit SetMainToReplicaRes(bool success) : success(success) {}
+  SetMainToReplicaRes() = default;
 
   bool success;
 };
 
-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>;
+using SetMainToReplicaRpc = rpc::RequestResponse<SetMainToReplicaReq, SetMainToReplicaRes>;
 
 }  // namespace memgraph::coordination
 
 // SLK serialization declarations
 namespace memgraph::slk {
 
-// PromoteReplicaToMainRpc
 void Save(const memgraph::coordination::PromoteReplicaToMainRes &self, memgraph::slk::Builder *builder);
+
 void Load(memgraph::coordination::PromoteReplicaToMainRes *self, memgraph::slk::Reader *reader);
+
 void Save(const memgraph::coordination::PromoteReplicaToMainReq &self, memgraph::slk::Builder *builder);
+
 void Load(memgraph::coordination::PromoteReplicaToMainReq *self, memgraph::slk::Reader *reader);
 
-// DemoteMainToReplicaRpc
-void Save(const memgraph::coordination::DemoteMainToReplicaRes &self, memgraph::slk::Builder *builder);
-void Load(memgraph::coordination::DemoteMainToReplicaRes *self, memgraph::slk::Reader *reader);
-void Save(const memgraph::coordination::DemoteMainToReplicaReq &self, memgraph::slk::Builder *builder);
-void Load(memgraph::coordination::DemoteMainToReplicaReq *self, memgraph::slk::Reader *reader);
+void Save(const memgraph::coordination::SetMainToReplicaRes &self, memgraph::slk::Builder *builder);
 
-// 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 Load(memgraph::coordination::SetMainToReplicaRes *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);
+void Save(const memgraph::coordination::SetMainToReplicaReq &self, memgraph::slk::Builder *builder);
+
+void Load(memgraph::coordination::SetMainToReplicaReq *self, memgraph::slk::Reader *reader);
 
 }  // namespace memgraph::slk
 

src/coordination/include/coordination/coordinator_state.hpp

@@ -13,9 +13,10 @@
 
 #ifdef MG_ENTERPRISE
 
-#include "coordination/coordinator_instance.hpp"
+#include "coordination/coordinator_data.hpp"
+#include "coordination/coordinator_instance_status.hpp"
 #include "coordination/coordinator_server.hpp"
-#include "coordination/instance_status.hpp"
+#include "coordination/failover_status.hpp"
 #include "coordination/register_main_replica_coordinator_status.hpp"
 
 #include <variant>
@@ -27,30 +28,25 @@ class CoordinatorState {
   CoordinatorState();
   ~CoordinatorState() = default;
 
-  CoordinatorState(CoordinatorState const &) = delete;
-  CoordinatorState &operator=(CoordinatorState const &) = delete;
+  CoordinatorState(const CoordinatorState &) = delete;
+  CoordinatorState &operator=(const CoordinatorState &) = delete;
 
   CoordinatorState(CoordinatorState &&) noexcept = delete;
   CoordinatorState &operator=(CoordinatorState &&) noexcept = delete;
 
-  [[nodiscard]] auto RegisterReplicationInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus;
-  [[nodiscard]] auto UnregisterReplicationInstance(std::string instance_name) -> UnregisterInstanceCoordinatorStatus;
+  [[nodiscard]] auto RegisterInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus;
 
-  [[nodiscard]] auto SetReplicationInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus;
+  [[nodiscard]] auto SetInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus;
 
-  auto ShowInstances() const -> std::vector<InstanceStatus>;
+  auto ShowInstances() const -> std::vector<CoordinatorInstanceStatus>;
 
-  auto AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address) -> void;
-
-  // NOTE: The client code must check that the server exists before calling this method.
+  // The client code must check that the server exists before calling this method.
   auto GetCoordinatorServer() const -> CoordinatorServer &;
 
- private:
-  struct CoordinatorMainReplicaData {
-    std::unique_ptr<CoordinatorServer> coordinator_server_;
-  };
+  [[nodiscard]] auto DoFailover() -> DoFailoverStatus;
 
-  std::variant<CoordinatorInstance, CoordinatorMainReplicaData> data_;
+ private:
+  std::variant<CoordinatorData, CoordinatorMainReplicaData> data_;
 };
 
 }  // namespace memgraph::coordination

src/coordination/include/coordination/failover_status.hpp

@@ -8,4 +8,14 @@
 // 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 "system/include/system/transaction.hpp"
+
+#pragma once
+
+#ifdef MG_ENTERPRISE
+
+#include <cstdint>
+
+namespace memgraph::coordination {
+enum class DoFailoverStatus : uint8_t { SUCCESS, ALL_REPLICAS_DOWN, MAIN_ALIVE, RPC_FAILED };
+}  // namespace memgraph::coordination
+#endif

src/coordination/include/coordination/raft_state.hpp

@@ -1,79 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include <flags/replication.hpp>
-
-#include <libnuraft/nuraft.hxx>
-
-namespace memgraph::coordination {
-
-using BecomeLeaderCb = std::function<void()>;
-using BecomeFollowerCb = std::function<void()>;
-
-using nuraft::buffer;
-using nuraft::logger;
-using nuraft::ptr;
-using nuraft::raft_launcher;
-using nuraft::raft_server;
-using nuraft::srv_config;
-using nuraft::state_machine;
-using nuraft::state_mgr;
-using raft_result = nuraft::cmd_result<ptr<buffer>>;
-
-class RaftState {
- private:
-  explicit RaftState(BecomeLeaderCb become_leader_cb, BecomeFollowerCb become_follower_cb, uint32_t raft_server_id,
-                     uint32_t raft_port, std::string raft_address);
-
-  auto InitRaftServer() -> void;
-
- public:
-  RaftState() = delete;
-  RaftState(RaftState const &other) = default;
-  RaftState &operator=(RaftState const &other) = default;
-  RaftState(RaftState &&other) noexcept = default;
-  RaftState &operator=(RaftState &&other) noexcept = default;
-  ~RaftState();
-
-  static auto MakeRaftState(BecomeLeaderCb become_leader_cb, BecomeFollowerCb become_follower_cb) -> RaftState;
-
-  auto InstanceName() const -> std::string;
-  auto RaftSocketAddress() const -> std::string;
-
-  auto AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address) -> void;
-  auto GetAllCoordinators() const -> std::vector<ptr<srv_config>>;
-
-  auto RequestLeadership() -> bool;
-  auto IsLeader() const -> bool;
-
-  auto AppendRegisterReplicationInstance(std::string const &instance) -> ptr<raft_result>;
-
-  // TODO: (andi) I think variables below can be abstracted
-  uint32_t raft_server_id_;
-  uint32_t raft_port_;
-  std::string raft_address_;
-
-  ptr<state_machine> state_machine_;
-  ptr<state_mgr> state_manager_;
-  ptr<raft_server> raft_server_;
-  ptr<logger> logger_;
-  raft_launcher launcher_;
-
-  BecomeLeaderCb become_leader_cb_;
-  BecomeFollowerCb become_follower_cb_;
-};
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/include/coordination/register_main_replica_coordinator_status.hpp

@@ -19,31 +19,18 @@ namespace memgraph::coordination {
 
 enum class RegisterInstanceCoordinatorStatus : uint8_t {
   NAME_EXISTS,
-  ENDPOINT_EXISTS,
+  END_POINT_EXISTS,
+  COULD_NOT_BE_PERSISTED,
   NOT_COORDINATOR,
   RPC_FAILED,
-  NOT_LEADER,
-  RAFT_COULD_NOT_ACCEPT,
-  RAFT_COULD_NOT_APPEND,
   SUCCESS
 };
 
-enum class UnregisterInstanceCoordinatorStatus : uint8_t {
-  NO_INSTANCE_WITH_NAME,
-  IS_MAIN,
-  NOT_COORDINATOR,
-  NOT_LEADER,
-  RPC_FAILED,
-  SUCCESS,
-};
-
 enum class SetInstanceToMainCoordinatorStatus : uint8_t {
   NO_INSTANCE_WITH_NAME,
-  MAIN_ALREADY_EXISTS,
   NOT_COORDINATOR,
   SUCCESS,
   COULD_NOT_PROMOTE_TO_MAIN,
-  SWAP_UUID_FAILED
 };
 
 }  // namespace memgraph::coordination

src/coordination/include/coordination/replication_instance.hpp

@@ -1,99 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include "coordination/coordinator_client.hpp"
-#include "coordination/coordinator_exceptions.hpp"
-#include "replication_coordination_glue/role.hpp"
-
-#include <libnuraft/nuraft.hxx>
-#include "utils/result.hpp"
-#include "utils/uuid.hpp"
-
-namespace memgraph::coordination {
-
-class CoordinatorInstance;
-
-class ReplicationInstance {
- public:
-  ReplicationInstance(CoordinatorInstance *peer, CoordinatorClientConfig config, HealthCheckCallback succ_cb,
-                      HealthCheckCallback fail_cb);
-
-  ReplicationInstance(ReplicationInstance const &other) = delete;
-  ReplicationInstance &operator=(ReplicationInstance const &other) = delete;
-  ReplicationInstance(ReplicationInstance &&other) noexcept = delete;
-  ReplicationInstance &operator=(ReplicationInstance &&other) noexcept = delete;
-  ~ReplicationInstance() = default;
-
-  auto OnSuccessPing() -> void;
-  auto OnFailPing() -> bool;
-  auto IsReadyForUUIDPing() -> bool;
-
-  void UpdateReplicaLastResponseUUID();
-
-  auto IsAlive() const -> bool;
-
-  auto InstanceName() const -> std::string;
-  auto SocketAddress() const -> std::string;
-
-  auto IsReplica() const -> bool;
-  auto IsMain() const -> bool;
-
-  auto PromoteToMain(utils::UUID uuid, ReplicationClientsInfo repl_clients_info, HealthCheckCallback main_succ_cb,
-                     HealthCheckCallback main_fail_cb) -> bool;
-  auto DemoteToReplica(HealthCheckCallback replica_succ_cb, HealthCheckCallback replica_fail_cb) -> bool;
-
-  auto StartFrequentCheck() -> void;
-  auto StopFrequentCheck() -> void;
-  auto PauseFrequentCheck() -> void;
-  auto ResumeFrequentCheck() -> void;
-
-  auto ReplicationClientInfo() const -> ReplClientInfo;
-
-  auto EnsureReplicaHasCorrectMainUUID(utils::UUID const &curr_main_uuid) -> bool;
-
-  auto SendSwapAndUpdateUUID(const utils::UUID &new_main_uuid) -> bool;
-  auto SendUnregisterReplicaRpc(std::string const &instance_name) -> bool;
-
-
-  auto SendGetInstanceUUID() -> utils::BasicResult<coordination::GetInstanceUUIDError, std::optional<utils::UUID>>;
-  auto GetClient() -> CoordinatorClient &;
-
-  auto EnableWritingOnMain() -> bool;
-
-  auto SetNewMainUUID(utils::UUID const &main_uuid) -> void;
-  auto ResetMainUUID() -> void;
-  auto GetMainUUID() const -> const std::optional<utils::UUID> &;
-
- private:
-  CoordinatorClient client_;
-  replication_coordination_glue::ReplicationRole replication_role_;
-  std::chrono::system_clock::time_point last_response_time_{};
-  bool is_alive_{false};
-  std::chrono::system_clock::time_point last_check_of_uuid_{};
-
-  // for replica this is main uuid of current main
-  // for "main" main this same as in CoordinatorData
-  // it is set to nullopt when replica is down
-  // TLDR; when replica is down and comes back up we reset uuid of main replica is listening to
-  // so we need to send swap uuid again
-  std::optional<utils::UUID> main_uuid_;
-
-  friend bool operator==(ReplicationInstance const &first, ReplicationInstance const &second) {
-    return first.client_ == second.client_ && first.replication_role_ == second.replication_role_;
-  }
-};
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/include/nuraft/coordinator_log_store.hpp

@@ -1,70 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include <libnuraft/nuraft.hxx>
-
-namespace memgraph::coordination {
-
-using nuraft::buffer;
-using nuraft::int32;
-using nuraft::int64;
-using nuraft::log_entry;
-using nuraft::log_store;
-using nuraft::ptr;
-using nuraft::raft_server;
-
-class CoordinatorLogStore : public log_store {
- public:
-  CoordinatorLogStore();
-  CoordinatorLogStore(CoordinatorLogStore const &) = delete;
-  CoordinatorLogStore &operator=(CoordinatorLogStore const &) = delete;
-  CoordinatorLogStore(CoordinatorLogStore &&) = delete;
-  CoordinatorLogStore &operator=(CoordinatorLogStore &&) = delete;
-  ~CoordinatorLogStore() override;
-
-  ulong next_slot() const override;
-
-  ulong start_index() const override;
-
-  ptr<log_entry> last_entry() const override;
-
-  ulong append(ptr<log_entry> &entry) override;
-
-  void write_at(ulong index, ptr<log_entry> &entry) override;
-
-  ptr<std::vector<ptr<log_entry>>> log_entries(ulong start, ulong end) override;
-
-  ptr<log_entry> entry_at(ulong index) override;
-
-  ulong term_at(ulong index) override;
-
-  ptr<buffer> pack(ulong index, int32 cnt) override;
-
-  void apply_pack(ulong index, buffer &pack) override;
-
-  bool compact(ulong last_log_index) override;
-
-  bool flush() override;
-
- private:
-  auto FindOrDefault_(ulong index) const -> ptr<log_entry>;
-
-  std::map<ulong, ptr<log_entry>> logs_;
-  mutable std::mutex logs_lock_;
-  std::atomic<ulong> start_idx_;
-};
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/include/nuraft/coordinator_state_machine.hpp

@@ -1,76 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include <spdlog/spdlog.h>
-#include <libnuraft/nuraft.hxx>
-
-namespace memgraph::coordination {
-
-using nuraft::async_result;
-using nuraft::buffer;
-using nuraft::buffer_serializer;
-using nuraft::cluster_config;
-using nuraft::int32;
-using nuraft::ptr;
-using nuraft::snapshot;
-using nuraft::state_machine;
-
-class CoordinatorStateMachine : public state_machine {
- public:
-  CoordinatorStateMachine() = default;
-  CoordinatorStateMachine(CoordinatorStateMachine const &) = delete;
-  CoordinatorStateMachine &operator=(CoordinatorStateMachine const &) = delete;
-  CoordinatorStateMachine(CoordinatorStateMachine &&) = delete;
-  CoordinatorStateMachine &operator=(CoordinatorStateMachine &&) = delete;
-  ~CoordinatorStateMachine() override {}
-
-  static auto EncodeRegisterReplicationInstance(const std::string &name) -> ptr<buffer>;
-
-  static auto DecodeRegisterReplicationInstance(buffer &data) -> std::string;
-
-  auto pre_commit(ulong log_idx, buffer &data) -> ptr<buffer> override;
-
-  auto commit(ulong log_idx, buffer &data) -> ptr<buffer> override;
-
-  auto commit_config(ulong log_idx, ptr<cluster_config> & /*new_conf*/) -> void override;
-
-  auto rollback(ulong log_idx, buffer &data) -> void override;
-
-  auto read_logical_snp_obj(snapshot & /*snapshot*/, void *& /*user_snp_ctx*/, ulong /*obj_id*/, ptr<buffer> &data_out,
-                            bool &is_last_obj) -> int override;
-
-  auto save_logical_snp_obj(snapshot &s, ulong &obj_id, buffer & /*data*/, bool /*is_first_obj*/, bool /*is_last_obj*/)
-      -> void override;
-
-  auto apply_snapshot(snapshot &s) -> bool override;
-
-  auto free_user_snp_ctx(void *&user_snp_ctx) -> void override;
-
-  auto last_snapshot() -> ptr<snapshot> override;
-
-  auto last_commit_index() -> ulong override;
-
-  auto create_snapshot(snapshot &s, async_result<bool>::handler_type &when_done) -> void override;
-
- private:
-  std::atomic<uint64_t> last_committed_idx_{0};
-
-  ptr<snapshot> last_snapshot_;
-
-  std::mutex last_snapshot_lock_;
-};
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/include/nuraft/coordinator_state_manager.hpp

@@ -1,66 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include "nuraft/coordinator_log_store.hpp"
-
-#include <spdlog/spdlog.h>
-#include <libnuraft/nuraft.hxx>
-
-namespace memgraph::coordination {
-
-using nuraft::cluster_config;
-using nuraft::cs_new;
-using nuraft::srv_config;
-using nuraft::srv_state;
-using nuraft::state_mgr;
-
-class CoordinatorStateManager : public state_mgr {
- public:
-  explicit CoordinatorStateManager(int srv_id, std::string const &endpoint);
-
-  CoordinatorStateManager(CoordinatorStateManager const &) = delete;
-  CoordinatorStateManager &operator=(CoordinatorStateManager const &) = delete;
-  CoordinatorStateManager(CoordinatorStateManager &&) = delete;
-  CoordinatorStateManager &operator=(CoordinatorStateManager &&) = delete;
-
-  ~CoordinatorStateManager() override = default;
-
-  auto load_config() -> ptr<cluster_config> override;
-
-  auto save_config(cluster_config const &config) -> void override;
-
-  auto save_state(srv_state const &state) -> void override;
-
-  auto read_state() -> ptr<srv_state> override;
-
-  auto load_log_store() -> ptr<log_store> override;
-
-  auto server_id() -> int32 override;
-
-  auto system_exit(int exit_code) -> void override;
-
-  auto GetSrvConfig() const -> ptr<srv_config>;
-
- private:
-  int my_id_;
-  std::string my_endpoint_;
-  ptr<CoordinatorLogStore> cur_log_store_;
-  ptr<srv_config> my_srv_config_;
-  ptr<cluster_config> cluster_config_;
-  ptr<srv_state> saved_state_;
-};
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/raft_state.cpp

@@ -1,140 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#ifdef MG_ENTERPRISE
-
-#include "coordination/raft_state.hpp"
-
-#include "coordination/coordinator_exceptions.hpp"
-#include "nuraft/coordinator_state_machine.hpp"
-#include "nuraft/coordinator_state_manager.hpp"
-#include "utils/counter.hpp"
-
-namespace memgraph::coordination {
-
-using nuraft::asio_service;
-using nuraft::cb_func;
-using nuraft::CbReturnCode;
-using nuraft::cmd_result;
-using nuraft::cs_new;
-using nuraft::ptr;
-using nuraft::raft_params;
-using nuraft::raft_server;
-using nuraft::srv_config;
-using raft_result = cmd_result<ptr<buffer>>;
-
-RaftState::RaftState(BecomeLeaderCb become_leader_cb, BecomeFollowerCb become_follower_cb, uint32_t raft_server_id,
-                     uint32_t raft_port, std::string raft_address)
-    : raft_server_id_(raft_server_id),
-      raft_port_(raft_port),
-      raft_address_(std::move(raft_address)),
-      state_machine_(cs_new<CoordinatorStateMachine>()),
-      state_manager_(
-          cs_new<CoordinatorStateManager>(raft_server_id_, raft_address_ + ":" + std::to_string(raft_port_))),
-      logger_(nullptr),
-      become_leader_cb_(std::move(become_leader_cb)),
-      become_follower_cb_(std::move(become_follower_cb)) {}
-
-auto RaftState::InitRaftServer() -> void {
-  asio_service::options asio_opts;
-  asio_opts.thread_pool_size_ = 1;  // TODO: (andi) Improve this
-
-  raft_params params;
-  params.heart_beat_interval_ = 100;
-  params.election_timeout_lower_bound_ = 200;
-  params.election_timeout_upper_bound_ = 400;
-  // 5 logs are preserved before the last snapshot
-  params.reserved_log_items_ = 5;
-  // Create snapshot for every 5 log appends
-  params.snapshot_distance_ = 5;
-  params.client_req_timeout_ = 3000;
-  params.return_method_ = raft_params::blocking;
-
-  raft_server::init_options init_opts;
-  init_opts.raft_callback_ = [this](cb_func::Type event_type, cb_func::Param *param) -> nuraft::CbReturnCode {
-    if (event_type == cb_func::BecomeLeader) {
-      spdlog::info("Node {} became leader", param->leaderId);
-      become_leader_cb_();
-    } else if (event_type == cb_func::BecomeFollower) {
-      spdlog::info("Node {} became follower", param->myId);
-      become_follower_cb_();
-    }
-    return CbReturnCode::Ok;
-  };
-
-  raft_launcher launcher;
-
-  raft_server_ = launcher.init(state_machine_, state_manager_, logger_, static_cast<int>(raft_port_), asio_opts, params,
-                               init_opts);
-
-  if (!raft_server_) {
-    throw RaftServerStartException("Failed to launch raft server on {}:{}", raft_address_, raft_port_);
-  }
-
-  auto maybe_stop = utils::ResettableCounter<20>();
-  do {
-    if (raft_server_->is_initialized()) {
-      return;
-    }
-    std::this_thread::sleep_for(std::chrono::milliseconds(250));
-  } while (!maybe_stop());
-
-  throw RaftServerStartException("Failed to initialize raft server on {}:{}", raft_address_, raft_port_);
-}
-
-auto RaftState::MakeRaftState(BecomeLeaderCb become_leader_cb, BecomeFollowerCb become_follower_cb) -> RaftState {
-  uint32_t raft_server_id{0};
-  uint32_t raft_port{0};
-  try {
-    raft_server_id = FLAGS_raft_server_id;
-    raft_port = FLAGS_raft_server_port;
-  } catch (std::exception const &e) {
-    throw RaftCouldNotParseFlagsException("Failed to parse flags: {}", e.what());
-  }
-
-  auto raft_state =
-      RaftState(std::move(become_leader_cb), std::move(become_follower_cb), raft_server_id, raft_port, "127.0.0.1");
-  raft_state.InitRaftServer();
-  return raft_state;
-}
-
-RaftState::~RaftState() { launcher_.shutdown(); }
-
-auto RaftState::InstanceName() const -> std::string { return "coordinator_" + std::to_string(raft_server_id_); }
-
-auto RaftState::RaftSocketAddress() const -> std::string { return raft_address_ + ":" + std::to_string(raft_port_); }
-
-auto RaftState::AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address) -> void {
-  auto const endpoint = raft_address + ":" + std::to_string(raft_port);
-  srv_config const srv_config_to_add(static_cast<int>(raft_server_id), endpoint);
-  if (!raft_server_->add_srv(srv_config_to_add)->get_accepted()) {
-    throw RaftAddServerException("Failed to add server {} to the cluster", endpoint);
-  }
-  spdlog::info("Request to add server {} to the cluster accepted", endpoint);
-}
-
-auto RaftState::GetAllCoordinators() const -> std::vector<ptr<srv_config>> {
-  std::vector<ptr<srv_config>> all_srv_configs;
-  raft_server_->get_srv_config_all(all_srv_configs);
-  return all_srv_configs;
-}
-
-auto RaftState::IsLeader() const -> bool { return raft_server_->is_leader(); }
-
-auto RaftState::RequestLeadership() -> bool { return raft_server_->is_leader() || raft_server_->request_leadership(); }
-
-auto RaftState::AppendRegisterReplicationInstance(std::string const &instance) -> ptr<raft_result> {
-  auto new_log = CoordinatorStateMachine::EncodeRegisterReplicationInstance(instance);
-  return raft_server_->append_entries({new_log});
-}
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/replication_instance.cpp

@@ -1,138 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#ifdef MG_ENTERPRISE
-
-#include "coordination/replication_instance.hpp"
-
-#include "replication_coordination_glue/handler.hpp"
-#include "utils/result.hpp"
-
-namespace memgraph::coordination {
-
-ReplicationInstance::ReplicationInstance(CoordinatorInstance *peer, CoordinatorClientConfig config,
-                                         HealthCheckCallback succ_cb, HealthCheckCallback fail_cb)
-    : client_(peer, std::move(config), std::move(succ_cb), std::move(fail_cb)),
-      replication_role_(replication_coordination_glue::ReplicationRole::REPLICA) {
-  if (!client_.DemoteToReplica()) {
-    throw CoordinatorRegisterInstanceException("Failed to demote instance {} to replica", client_.InstanceName());
-  }
-
-  client_.StartFrequentCheck();
-}
-
-auto ReplicationInstance::OnSuccessPing() -> void {
-  last_response_time_ = std::chrono::system_clock::now();
-  is_alive_ = true;
-}
-
-auto ReplicationInstance::OnFailPing() -> bool {
-  auto elapsed_time = std::chrono::system_clock::now() - last_response_time_;
-  is_alive_ = elapsed_time < client_.InstanceDownTimeoutSec();
-  return is_alive_;
-}
-
-auto ReplicationInstance::IsReadyForUUIDPing() -> bool {
-  return std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - last_check_of_uuid_) >
-         client_.InstanceGetUUIDFrequencySec();
-}
-
-auto ReplicationInstance::InstanceName() const -> std::string { return client_.InstanceName(); }
-auto ReplicationInstance::SocketAddress() const -> std::string { return client_.SocketAddress(); }
-auto ReplicationInstance::IsAlive() const -> bool { return is_alive_; }
-
-auto ReplicationInstance::IsReplica() const -> bool {
-  return replication_role_ == replication_coordination_glue::ReplicationRole::REPLICA;
-}
-auto ReplicationInstance::IsMain() const -> bool {
-  return replication_role_ == replication_coordination_glue::ReplicationRole::MAIN;
-}
-
-auto ReplicationInstance::PromoteToMain(utils::UUID new_uuid, ReplicationClientsInfo repl_clients_info,
-                                        HealthCheckCallback main_succ_cb, HealthCheckCallback main_fail_cb) -> bool {
-  if (!client_.SendPromoteReplicaToMainRpc(new_uuid, std::move(repl_clients_info))) {
-    return false;
-  }
-
-  replication_role_ = replication_coordination_glue::ReplicationRole::MAIN;
-  main_uuid_ = new_uuid;
-  client_.SetCallbacks(std::move(main_succ_cb), std::move(main_fail_cb));
-
-  return true;
-}
-
-auto ReplicationInstance::DemoteToReplica(HealthCheckCallback replica_succ_cb, HealthCheckCallback replica_fail_cb)
-    -> bool {
-  if (!client_.DemoteToReplica()) {
-    return false;
-  }
-
-  replication_role_ = replication_coordination_glue::ReplicationRole::REPLICA;
-  client_.SetCallbacks(std::move(replica_succ_cb), std::move(replica_fail_cb));
-
-  return true;
-}
-
-auto ReplicationInstance::StartFrequentCheck() -> void { client_.StartFrequentCheck(); }
-auto ReplicationInstance::StopFrequentCheck() -> void { client_.StopFrequentCheck(); }
-auto ReplicationInstance::PauseFrequentCheck() -> void { client_.PauseFrequentCheck(); }
-auto ReplicationInstance::ResumeFrequentCheck() -> void { client_.ResumeFrequentCheck(); }
-
-auto ReplicationInstance::ReplicationClientInfo() const -> CoordinatorClientConfig::ReplicationClientInfo {
-  return client_.ReplicationClientInfo();
-}
-
-auto ReplicationInstance::GetClient() -> CoordinatorClient & { return client_; }
-
-auto ReplicationInstance::SetNewMainUUID(utils::UUID const &main_uuid) -> void { main_uuid_ = main_uuid; }
-auto ReplicationInstance::ResetMainUUID() -> void { main_uuid_ = std::nullopt; }
-auto ReplicationInstance::GetMainUUID() const -> std::optional<utils::UUID> const & { return main_uuid_; }
-
-auto ReplicationInstance::EnsureReplicaHasCorrectMainUUID(utils::UUID const &curr_main_uuid) -> bool {
-  if (!IsReadyForUUIDPing()) {
-    return true;
-  }
-  auto res = SendGetInstanceUUID();
-  if (res.HasError()) {
-    return false;
-  }
-  UpdateReplicaLastResponseUUID();
-
-  if (res.GetValue().has_value() && res.GetValue().value() == curr_main_uuid) {
-    return true;
-  }
-
-  return SendSwapAndUpdateUUID(curr_main_uuid);
-}
-
-auto ReplicationInstance::SendSwapAndUpdateUUID(const utils::UUID &new_main_uuid) -> bool {
-  if (!replication_coordination_glue::SendSwapMainUUIDRpc(client_.RpcClient(), new_main_uuid)) {
-    return false;
-  }
-  SetNewMainUUID(new_main_uuid);
-  return true;
-}
-
-auto ReplicationInstance::SendUnregisterReplicaRpc(std::string const &instance_name) -> bool {
-  return client_.SendUnregisterReplicaRpc(instance_name);
-}
-
-auto ReplicationInstance::EnableWritingOnMain() -> bool { return client_.SendEnableWritingOnMainRpc(); }
-
-auto ReplicationInstance::SendGetInstanceUUID()
-    -> utils::BasicResult<coordination::GetInstanceUUIDError, std::optional<utils::UUID>> {
-  return client_.SendGetInstanceUUIDRpc();
-}
-
-void ReplicationInstance::UpdateReplicaLastResponseUUID() { last_check_of_uuid_ = std::chrono::system_clock::now(); }
-
-}  // namespace memgraph::coordination
-#endif

src/dbms/CMakeLists.txt

@@ -1,10 +1,2 @@
-add_library(mg-dbms STATIC
-        dbms_handler.cpp
-        database.cpp
-        coordinator_handler.cpp
-        inmemory/replication_handlers.cpp
-        replication_handlers.cpp
-        rpc.cpp
-
-)
-target_link_libraries(mg-dbms mg-utils mg-storage-v2 mg-query mg-auth mg-replication mg-coordination)
+add_library(mg-dbms STATIC dbms_handler.cpp database.cpp replication_handler.cpp coordinator_handler.cpp replication_client.cpp inmemory/replication_handlers.cpp coordinator_handlers.cpp)
+target_link_libraries(mg-dbms mg-utils mg-storage-v2 mg-query mg-replication mg-coordination)

src/dbms/constants.hpp

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

src/dbms/coordinator_handler.cpp

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

src/dbms/coordinator_handler.hpp

@@ -13,11 +13,15 @@
 
 #ifdef MG_ENTERPRISE
 
+#include "utils/result.hpp"
+
 #include "coordination/coordinator_config.hpp"
-#include "coordination/coordinator_state.hpp"
-#include "coordination/instance_status.hpp"
+#include "coordination/coordinator_instance_status.hpp"
+#include "coordination/failover_status.hpp"
 #include "coordination/register_main_replica_coordinator_status.hpp"
 
+#include <cstdint>
+#include <optional>
 #include <vector>
 
 namespace memgraph::dbms {
@@ -26,23 +30,17 @@ class DbmsHandler;
 
 class CoordinatorHandler {
  public:
-  explicit CoordinatorHandler(coordination::CoordinatorState &coordinator_state);
+  explicit CoordinatorHandler(DbmsHandler &dbms_handler);
 
-  // TODO: (andi) When moving coordinator state on same instances, rename from RegisterReplicationInstance to
-  // RegisterInstance
-  auto RegisterReplicationInstance(coordination::CoordinatorClientConfig config)
+  auto RegisterInstance(coordination::CoordinatorClientConfig config)
       -> coordination::RegisterInstanceCoordinatorStatus;
 
-  auto UnregisterReplicationInstance(std::string instance_name) -> coordination::UnregisterInstanceCoordinatorStatus;
+  auto SetInstanceToMain(std::string instance_name) -> coordination::SetInstanceToMainCoordinatorStatus;
 
-  auto SetReplicationInstanceToMain(std::string instance_name) -> coordination::SetInstanceToMainCoordinatorStatus;
-
-  auto ShowInstances() const -> std::vector<coordination::InstanceStatus>;
-
-  auto AddCoordinatorInstance(uint32_t raft_server_id, uint32_t raft_port, std::string raft_address) -> void;
+  auto ShowInstances() const -> std::vector<coordination::CoordinatorInstanceStatus>;
 
  private:
-  coordination::CoordinatorState &coordinator_state_;
+  DbmsHandler &dbms_handler_;
 };
 
 }  // namespace memgraph::dbms

src/dbms/coordinator_handlers.cpp

@@ -0,0 +1,153 @@
+// Copyright 2024 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#ifdef MG_ENTERPRISE
+
+#include "dbms/coordinator_handlers.hpp"
+#include "dbms/utils.hpp"
+
+#include "coordination/coordinator_exceptions.hpp"
+#include "coordination/coordinator_rpc.hpp"
+#include "dbms/dbms_handler.hpp"
+#include "dbms/replication_client.hpp"
+
+#include "range/v3/view.hpp"
+
+namespace memgraph::dbms {
+
+void CoordinatorHandlers::Register(DbmsHandler &dbms_handler) {
+  auto &server = dbms_handler.CoordinatorState().GetCoordinatorServer();
+
+  server.Register<coordination::PromoteReplicaToMainRpc>(
+      [&dbms_handler](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
+        spdlog::info("Received PromoteReplicaToMainRpc");
+        CoordinatorHandlers::PromoteReplicaToMainHandler(dbms_handler, req_reader, res_builder);
+      });
+
+  server.Register<coordination::SetMainToReplicaRpc>(
+      [&dbms_handler](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
+        spdlog::info("Received SetMainToReplicaRpc from coordinator server");
+        CoordinatorHandlers::SetMainToReplicaHandler(dbms_handler, req_reader, res_builder);
+      });
+}
+
+void CoordinatorHandlers::SetMainToReplicaHandler(DbmsHandler &dbms_handler, slk::Reader *req_reader,
+                                                  slk::Builder *res_builder) {
+  auto &repl_state = dbms_handler.ReplicationState();
+
+  if (!repl_state.IsMain()) {
+    spdlog::error("Setting to replica must be performed on main.");
+    slk::Save(coordination::SetMainToReplicaRes{false}, res_builder);
+    return;
+  }
+
+  coordination::SetMainToReplicaReq req;
+  slk::Load(&req, req_reader);
+
+  replication::ReplicationServerConfig clients_config{.ip_address = req.replication_client_info.replication_ip_address,
+                                                      .port = req.replication_client_info.replication_port};
+
+  if (bool success = memgraph::dbms::SetReplicationRoleReplica(dbms_handler, clients_config); !success) {
+    spdlog::error("Setting main to replica failed!");
+    slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
+    return;
+  }
+
+  slk::Save(coordination::PromoteReplicaToMainRes{true}, res_builder);
+}
+
+void CoordinatorHandlers::PromoteReplicaToMainHandler(DbmsHandler &dbms_handler, slk::Reader *req_reader,
+                                                      slk::Builder *res_builder) {
+  auto &repl_state = dbms_handler.ReplicationState();
+
+  if (!repl_state.IsReplica()) {
+    spdlog::error("Failover must be performed on replica!");
+    slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
+    return;
+  }
+
+  auto repl_server_config = std::get<replication::RoleReplicaData>(repl_state.ReplicationData()).config;
+
+  // This can fail because of disk. If it does, the cluster state could get inconsistent.
+  // We don't handle disk issues.
+  if (bool success = memgraph::dbms::DoReplicaToMainPromotion(dbms_handler); !success) {
+    spdlog::error("Promoting replica to main failed!");
+    slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
+    return;
+  }
+
+  coordination::PromoteReplicaToMainReq req;
+  slk::Load(&req, req_reader);
+
+  auto const converter = [](const auto &repl_info_config) {
+    return replication::ReplicationClientConfig{
+        .name = repl_info_config.instance_name,
+        .mode = repl_info_config.replication_mode,
+        .ip_address = repl_info_config.replication_ip_address,
+        .port = repl_info_config.replication_port,
+    };
+  };
+
+  MG_ASSERT(
+      std::get<replication::RoleMainData>(repl_state.ReplicationData()).registered_replicas_.empty(),
+      "No replicas should be registered after promoting replica to main and before registering replication clients!");
+
+  // registering replicas
+  for (auto const &config : req.replication_clients_info | ranges::views::transform(converter)) {
+    auto instance_client = repl_state.RegisterReplica(config);
+    if (instance_client.HasError()) {
+      switch (instance_client.GetError()) {
+        // Can't happen, we are already replica
+        case memgraph::replication::RegisterReplicaError::NOT_MAIN:
+          spdlog::error("Failover must be performed to main!");
+          slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
+          return;
+        // Can't happen, checked on the coordinator side
+        case memgraph::replication::RegisterReplicaError::NAME_EXISTS:
+          spdlog::error("Replica with the same name already exists!");
+          slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
+          return;
+        // Can't happen, checked on the coordinator side
+        case memgraph::replication::RegisterReplicaError::ENDPOINT_EXISTS:
+          spdlog::error("Replica with the same endpoint already exists!");
+          slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
+          return;
+        // We don't handle disk issues
+        case memgraph::replication::RegisterReplicaError::COULD_NOT_BE_PERSISTED:
+          spdlog::error("Registered replica could not be persisted!");
+          slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
+          return;
+        case memgraph::replication::RegisterReplicaError::SUCCESS:
+          break;
+      }
+    }
+    if (!allow_mt_repl && dbms_handler.All().size() > 1) {
+      spdlog::warn("Multi-tenant replication is currently not supported!");
+    }
+
+    auto &instance_client_ref = *instance_client.GetValue();
+
+    // Update system before enabling individual storage <-> replica clients
+    dbms_handler.SystemRestore(instance_client_ref);
+
+    // TODO: (andi) Policy for register all databases
+    // Will be resolved after deciding about choosing new replica
+    const bool all_clients_good = memgraph::dbms::RegisterAllDatabasesClients(dbms_handler, instance_client_ref);
+    MG_ASSERT(all_clients_good, "Failed to register one or more databases to the REPLICA \"{}\".", config.name);
+
+    StartReplicaClient(dbms_handler, instance_client_ref);
+  }
+
+  slk::Save(coordination::PromoteReplicaToMainRes{true}, res_builder);
+}
+
+}  // namespace memgraph::dbms
+#endif

src/dbms/coordinator_handlers.hpp

@@ -11,22 +11,24 @@
 
 #pragma once
 
-#include "gflags/gflags.h"
+#ifdef MG_ENTERPRISE
 
-// Short help flag.
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_string(experimental_enabled);
+#include "slk/serialization.hpp"
 
-namespace memgraph::flags {
+namespace memgraph::dbms {
 
-// 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,
+class DbmsHandler;
+
+class CoordinatorHandlers {
+ public:
+  static void Register(DbmsHandler &dbms_handler);
+
+ private:
+  static void PromoteReplicaToMainHandler(DbmsHandler &dbms_handler, slk::Reader *req_reader,
+                                          slk::Builder *res_builder);
+  static void SetMainToReplicaHandler(DbmsHandler &dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder);
 };
 
-bool AreExperimentsEnabled(Experiments experiments);
+}  // namespace memgraph::dbms
 
-void InitializeExperimental();
-
-}  // namespace memgraph::flags
+#endif

src/dbms/database.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
@@ -11,7 +11,10 @@
 
 #include "dbms/database.hpp"
 #include "dbms/inmemory/storage_helper.hpp"
+#include "dbms/replication_handler.hpp"
+#include "flags/storage_mode.hpp"
 #include "storage/v2/disk/storage.hpp"
+#include "storage/v2/inmemory/storage.hpp"
 #include "storage/v2/storage_mode.hpp"
 
 template struct memgraph::utils::Gatekeeper<memgraph::dbms::Database>;

src/dbms/dbms_handler.cpp

@@ -11,76 +11,29 @@
 
 #include "dbms/dbms_handler.hpp"
 
+#include "dbms/coordinator_handlers.hpp"
+#include "flags/replication.hpp"
+
 #include <cstdint>
 #include <filesystem>
 
 #include "dbms/constants.hpp"
 #include "dbms/global.hpp"
-#include "flags/experimental.hpp"
+#include "dbms/replication_client.hpp"
 #include "spdlog/spdlog.h"
-#include "system/include/system/system.hpp"
 #include "utils/exceptions.hpp"
 #include "utils/logging.hpp"
 #include "utils/uuid.hpp"
 
 namespace memgraph::dbms {
 
+#ifdef MG_ENTERPRISE
+
 namespace {
-constexpr std::string_view kDBPrefix = "database:";  // Key prefix for database durability
-
-std::string RegisterReplicaErrorToString(query::RegisterReplicaError error) {
-  switch (error) {
-    using enum query::RegisterReplicaError;
-    case NAME_EXISTS:
-      return "NAME_EXISTS";
-    case ENDPOINT_EXISTS:
-      return "ENDPOINT_EXISTS";
-    case CONNECTION_FAILED:
-      return "CONNECTION_FAILED";
-    case COULD_NOT_BE_PERSISTED:
-      return "COULD_NOT_BE_PERSISTED";
-    case ERROR_ACCEPTING_MAIN:
-      return "ERROR_ACCEPTING_MAIN";
-  }
-}
-
-// Per storage
-// NOTE Storage will connect to all replicas. Future work might change this
-void RestoreReplication(replication::RoleMainData &mainData, DatabaseAccess db_acc) {
-  spdlog::info("Restoring replication role.");
-
-  // Each individual client has already been restored and started. Here we just go through each database and start its
-  // client
-  for (auto &instance_client : mainData.registered_replicas_) {
-    spdlog::info("Replica {} restoration started for {}.", instance_client.name_, db_acc->name());
-    const auto &ret = db_acc->storage()->repl_storage_state_.replication_clients_.WithLock(
-        [&, db_acc](auto &storage_clients) mutable -> utils::BasicResult<query::RegisterReplicaError> {
-          auto client = std::make_unique<storage::ReplicationStorageClient>(instance_client, mainData.uuid_);
-          auto *storage = db_acc->storage();
-          client->Start(storage, std::move(db_acc));
-          // After start the storage <-> replica state should be READY or RECOVERING (if correctly started)
-          // MAYBE_BEHIND isn't a statement of the current state, this is the default value
-          // Failed to start due to branching of MAIN and REPLICA
-          if (client->State() == storage::replication::ReplicaState::MAYBE_BEHIND) {
-            spdlog::warn("Connection failed when registering replica {}. Replica will still be registered.",
-                         instance_client.name_);
-          }
-          storage_clients.push_back(std::move(client));
-          return {};
-        });
-
-    if (ret.HasError()) {
-      MG_ASSERT(query::RegisterReplicaError::CONNECTION_FAILED != ret.GetError());
-      LOG_FATAL("Failure when restoring replica {}: {}.", instance_client.name_,
-                RegisterReplicaErrorToString(ret.GetError()));
-    }
-    spdlog::info("Replica {} restored for {}.", instance_client.name_, db_acc->name());
-  }
-  spdlog::info("Replication role restored to MAIN.");
-}
+constexpr std::string_view kDBPrefix = "database:";                               // Key prefix for database durability
+constexpr std::string_view kLastCommitedSystemTsKey = "last_commited_system_ts";  // Key for timestamp durability
 }  // namespace
 
-#ifdef MG_ENTERPRISE
 struct Durability {
   enum class DurabilityVersion : uint8_t {
     V0 = 0,
@@ -159,9 +112,11 @@ 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::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth,
+    bool recovery_on_startup)
+    : default_config_{std::move(config)}, repl_state_{ReplicationStateRootPath(default_config_)} {
   // TODO: Decouple storage config from dbms config
   // TODO: Save individual db configs inside the kvstore and restore from there
 
@@ -195,13 +150,19 @@ DbmsHandler::DbmsHandler(storage::Config config, replication::ReplicationState &
       const auto uuid = json.at("uuid").get<utils::UUID>();
       const auto rel_dir = json.at("rel_dir").get<std::filesystem::path>();
       spdlog::info("Restoring database {} at {}.", name, rel_dir);
-      auto new_db = New_(name, uuid, nullptr, rel_dir);
+      auto new_db = New_(name, uuid, rel_dir);
       MG_ASSERT(!new_db.HasError(), "Failed while creating database {}.", name);
       directories.emplace(rel_dir.filename());
       spdlog::info("Database {} restored.", name);
     }
+    // Read the last timestamp
+    auto lcst = durability_->Get(kLastCommitedSystemTsKey);
+    if (lcst) {
+      last_commited_system_timestamp_ = std::stoul(*lcst);
+      system_timestamp_ = last_commited_system_timestamp_;
+    }
   } else {  // Clear databases from the durability list and auth
-    auto locked_auth = auth_.Lock();
+    auto locked_auth = auth->Lock();
     auto it = durability_->begin(std::string{kDBPrefix});
     auto end = durability_->end(std::string{kDBPrefix});
     for (; it != end; ++it) {
@@ -211,6 +172,8 @@ DbmsHandler::DbmsHandler(storage::Config config, replication::ReplicationState &
       locked_auth->DeleteDatabase(name);
       durability_->Delete(key);
     }
+    // Delete the last timestamp
+    durability_->Delete(kLastCommitedSystemTsKey);
   }
 
   /*
@@ -235,31 +198,45 @@ DbmsHandler::DbmsHandler(storage::Config config, replication::ReplicationState &
    */
   // Setup the default DB
   SetupDefault_();
+
+  /*
+   * REPLICATION RECOVERY AND STARTUP
+   */
+  // Startup replication state (if recovered at startup)
+  auto replica = [this](replication::RoleReplicaData const &data) { return StartRpcServer(*this, data); };
+  // Replication recovery and frequent check start
+  auto main = [this](replication::RoleMainData &data) {
+    for (auto &client : data.registered_replicas_) {
+      SystemRestore(client);
+    }
+    ForEach([this](DatabaseAccess db) { RecoverReplication(db); });
+    for (auto &client : data.registered_replicas_) {
+      StartReplicaClient(*this, client);
+    }
+    return true;
+  };
+  // Startup proccess for main/replica
+  MG_ASSERT(std::visit(memgraph::utils::Overloaded{replica, main}, repl_state_.ReplicationData()),
+            "Replica recovery failure!");
+
+  // Warning
+  if (default_config_.durability.snapshot_wal_mode == storage::Config::Durability::SnapshotWalMode::DISABLED &&
+      repl_state_.IsMain()) {
+    spdlog::warn(
+        "The instance has the MAIN replication role, but durability logs and snapshots are disabled. Please "
+        "consider "
+        "enabling durability by using --storage-snapshot-interval-sec and --storage-wal-enabled flags because "
+        "without write-ahead logs this instance is not replicating any data.");
+  }
+
+  // MAIN or REPLICA instance
+  if (FLAGS_coordinator_server_port) {
+    CoordinatorHandlers::Register(*this);
+    MG_ASSERT(coordinator_state_.GetCoordinatorServer().Start(), "Failed to start coordinator server!");
+  }
 }
 
-struct DropDatabase : memgraph::system::ISystemAction {
-  explicit DropDatabase(utils::UUID uuid) : uuid_{uuid} {}
-  void DoDurability() override { /* Done during DBMS execution */
-  }
-
-  bool DoReplication(replication::ReplicationClient &client, const utils::UUID &main_uuid,
-                     replication::ReplicationEpoch const &epoch,
-                     memgraph::system::Transaction const &txn) const override {
-    auto check_response = [](const storage::replication::DropDatabaseRes &response) {
-      return response.result != storage::replication::DropDatabaseRes::Result::FAILURE;
-    };
-
-    return client.SteamAndFinalizeDelta<storage::replication::DropDatabaseRpc>(
-        check_response, main_uuid, std::string(epoch.id()), txn.last_committed_system_timestamp(), txn.timestamp(),
-        uuid_);
-  }
-  void PostReplication(replication::RoleMainData &mainData) const override {}
-
- private:
-  utils::UUID uuid_;
-};
-
-DbmsHandler::DeleteResult DbmsHandler::TryDelete(std::string_view db_name, system::Transaction *transaction) {
+DbmsHandler::DeleteResult DbmsHandler::TryDelete(std::string_view db_name) {
   std::lock_guard<LockT> wr(lock_);
   if (db_name == kDefaultDB) {
     // MSG cannot delete the default db
@@ -296,10 +273,9 @@ DbmsHandler::DeleteResult DbmsHandler::TryDelete(std::string_view db_name, syste
 
   // Success
   // Save delta
-  if (transaction) {
-    transaction->AddAction<DropDatabase>(uuid);
+  if (system_transaction_) {
+    system_transaction_->delta.emplace(SystemTransaction::Delta::drop_database, uuid);
   }
-
   return {};
 }
 
@@ -320,50 +296,18 @@ DbmsHandler::DeleteResult DbmsHandler::Delete(utils::UUID uuid) {
   return Delete_(db_name);
 }
 
-struct CreateDatabase : memgraph::system::ISystemAction {
-  explicit CreateDatabase(storage::SalientConfig config, DatabaseAccess db_acc)
-      : config_{std::move(config)}, db_acc(db_acc) {}
-
-  void DoDurability() override {
-    // Done during dbms execution
-  }
-
-  bool DoReplication(replication::ReplicationClient &client, const utils::UUID &main_uuid,
-                     replication::ReplicationEpoch const &epoch,
-                     memgraph::system::Transaction const &txn) const override {
-    auto check_response = [](const storage::replication::CreateDatabaseRes &response) {
-      return response.result != storage::replication::CreateDatabaseRes::Result::FAILURE;
-    };
-
-    return client.SteamAndFinalizeDelta<storage::replication::CreateDatabaseRpc>(
-        check_response, main_uuid, std::string(epoch.id()), txn.last_committed_system_timestamp(), txn.timestamp(),
-        config_);
-  }
-
-  void PostReplication(replication::RoleMainData &mainData) const override {
-    // Sync database with REPLICAs
-    // NOTE: The function bellow is used to create ReplicationStorageClient, so it must be called on a new storage
-    // We don't need to have it here, since the function won't fail even if the replication client fails to
-    // connect We will just have everything ready, for recovery at some point.
-    dbms::DbmsHandler::RecoverStorageReplication(db_acc, mainData);
-  }
-
- private:
-  storage::SalientConfig config_;
-  DatabaseAccess db_acc;
-};
-
-DbmsHandler::NewResultT DbmsHandler::New_(storage::Config storage_config, system::Transaction *txn) {
+DbmsHandler::NewResultT DbmsHandler::New_(storage::Config storage_config) {
   auto new_db = db_handler_.New(storage_config, repl_state_);
 
   if (new_db.HasValue()) {  // Success
                             // Save delta
-    UpdateDurability(storage_config);
-    if (txn) {
-      txn->AddAction<CreateDatabase>(storage_config.salient, new_db.GetValue());
+    if (system_transaction_) {
+      system_transaction_->delta.emplace(SystemTransaction::Delta::create_database, storage_config.salient);
     }
+    UpdateDurability(storage_config);
+    return new_db.GetValue();
   }
-  return new_db;
+  return new_db.GetError();
 }
 
 DbmsHandler::DeleteResult DbmsHandler::Delete_(std::string_view db_name) {
@@ -417,19 +361,89 @@ void DbmsHandler::UpdateDurability(const storage::Config &config, std::optional<
   durability_->Put(key, val);
 }
 
-#endif
+AllSyncReplicaStatus DbmsHandler::Commit() {
+  if (system_transaction_ == std::nullopt || system_transaction_->delta == std::nullopt)
+    return AllSyncReplicaStatus::AllCommitsConfirmed;  // Nothing to commit
+  const auto &delta = *system_transaction_->delta;
 
-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) {
-    // Handle global replication state
-    spdlog::info("Replication configuration will be stored and will be automatically restored in case of a crash.");
-    // RECOVER REPLICA CONNECTIONS
-    memgraph::dbms::RestoreReplication(role_main_data, db_acc);
-  } else if (!role_main_data.registered_replicas_.empty()) {
-    spdlog::warn("Multi-tenant replication is currently not supported!");
+  auto sync_status = AllSyncReplicaStatus::AllCommitsConfirmed;
+  // TODO Create a system client that can handle all of this automatically
+  switch (delta.action) {
+    using enum SystemTransaction::Delta::Action;
+    case CREATE_DATABASE: {
+      // Replication
+      auto main_handler = [&](memgraph::replication::RoleMainData &main_data) {
+        // TODO: data race issue? registered_replicas_ access not protected
+        // This is sync in any case, as this is the startup
+        for (auto &client : main_data.registered_replicas_) {
+          bool completed = SteamAndFinalizeDelta<storage::replication::CreateDatabaseRpc>(
+              client,
+              [](const storage::replication::CreateDatabaseRes &response) {
+                return response.result != storage::replication::CreateDatabaseRes::Result::FAILURE;
+              },
+              std::string(main_data.epoch_.id()), last_commited_system_timestamp_,
+              system_transaction_->system_timestamp, delta.config);
+          // TODO: reduce duplicate code
+          if (!completed && client.mode_ == replication_coordination_glue::ReplicationMode::SYNC) {
+            sync_status = AllSyncReplicaStatus::SomeCommitsUnconfirmed;
+          }
+        }
+        // Sync database with REPLICAs
+        RecoverReplication(Get_(delta.config.name));
+      };
+      auto replica_handler = [](memgraph::replication::RoleReplicaData &) { /* Nothing to do */ };
+      std::visit(utils::Overloaded{main_handler, replica_handler}, repl_state_.ReplicationData());
+    } break;
+    case DROP_DATABASE: {
+      // Replication
+      auto main_handler = [&](memgraph::replication::RoleMainData &main_data) {
+        // TODO: data race issue? registered_replicas_ access not protected
+        // This is sync in any case, as this is the startup
+        for (auto &client : main_data.registered_replicas_) {
+          bool completed = SteamAndFinalizeDelta<storage::replication::DropDatabaseRpc>(
+              client,
+              [](const storage::replication::DropDatabaseRes &response) {
+                return response.result != storage::replication::DropDatabaseRes::Result::FAILURE;
+              },
+              std::string(main_data.epoch_.id()), last_commited_system_timestamp_,
+              system_transaction_->system_timestamp, delta.uuid);
+          // TODO: reduce duplicate code
+          if (!completed && client.mode_ == replication_coordination_glue::ReplicationMode::SYNC) {
+            sync_status = AllSyncReplicaStatus::SomeCommitsUnconfirmed;
+          }
+        }
+      };
+      auto replica_handler = [](memgraph::replication::RoleReplicaData &) { /* Nothing to do */ };
+      std::visit(utils::Overloaded{main_handler, replica_handler}, repl_state_.ReplicationData());
+    } break;
   }
+
+  durability_->Put(kLastCommitedSystemTsKey, std::to_string(system_transaction_->system_timestamp));
+  last_commited_system_timestamp_ = system_transaction_->system_timestamp;
+  ResetSystemTransaction();
+  return sync_status;
 }
+
+#else  // not MG_ENTERPRISE
+
+AllSyncReplicaStatus DbmsHandler::Commit() {
+  if (system_transaction_ == std::nullopt || system_transaction_->delta == std::nullopt) {
+    return AllSyncReplicaStatus::AllCommitsConfirmed;  // Nothing to commit
+  }
+  const auto &delta = *system_transaction_->delta;
+
+  switch (delta.action) {
+    using enum SystemTransaction::Delta::Action;
+    case CREATE_DATABASE:
+    case DROP_DATABASE:
+      /* Community edition doesn't support multi-tenant replication */
+      break;
+  }
+
+  last_commited_system_timestamp_ = system_transaction_->system_timestamp;
+  ResetSystemTransaction();
+  return AllSyncReplicaStatus::AllCommitsConfirmed;
+}
+
+#endif
 }  // namespace memgraph::dbms

src/dbms/dbms_handler.hpp

@@ -25,25 +25,24 @@
 #include "constants.hpp"
 #include "dbms/database.hpp"
 #include "dbms/inmemory/replication_handlers.hpp"
-#include "dbms/rpc.hpp"
+#include "dbms/replication_handler.hpp"
 #include "kvstore/kvstore.hpp"
-#include "license/license.hpp"
 #include "replication/replication_client.hpp"
-#include "replication_coordination_glue/handler.hpp"
 #include "storage/v2/config.hpp"
+#include "storage/v2/replication/enums.hpp"
+#include "storage/v2/replication/rpc.hpp"
 #include "storage/v2/transaction.hpp"
-#include "system/system.hpp"
 #include "utils/thread_pool.hpp"
 #ifdef MG_ENTERPRISE
 #include "coordination/coordinator_state.hpp"
 #include "dbms/database_handler.hpp"
 #endif
+#include "dbms/transaction.hpp"
 #include "global.hpp"
 #include "query/config.hpp"
 #include "query/interpreter_context.hpp"
 #include "spdlog/spdlog.h"
 #include "storage/v2/isolation_level.hpp"
-#include "system/system.hpp"
 #include "utils/logging.hpp"
 #include "utils/result.hpp"
 #include "utils/rw_lock.hpp"
@@ -52,6 +51,11 @@
 
 namespace memgraph::dbms {
 
+enum class AllSyncReplicaStatus {
+  AllCommitsConfirmed,
+  SomeCommitsUnconfirmed,
+};
+
 struct Statistics {
   uint64_t num_vertex;           //!< Sum of vertexes in every database
   uint64_t num_edges;            //!< Sum of edges in every database
@@ -107,7 +111,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::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth,
               bool recovery_on_startup);  // TODO If more arguments are added use a config struct
 #else
   /**
@@ -115,13 +120,15 @@ class DbmsHandler {
    *
    * @param configs storage configuration
    */
-  DbmsHandler(storage::Config config, replication::ReplicationState &repl_state)
-      : repl_state_{repl_state},
+  DbmsHandler(storage::Config config)
+      : repl_state_{ReplicationStateRootPath(config)},
         db_gatekeeper_{[&] {
                          config.salient.name = kDefaultDB;
                          return std::move(config);
                        }(),
-                       repl_state_} {}
+                       repl_state_} {
+    RecoverReplication(Get());
+  }
 #endif
 
 #ifdef MG_ENTERPRISE
@@ -131,10 +138,10 @@ class DbmsHandler {
    * @param name name of the database
    * @return NewResultT context on success, error on failure
    */
-  NewResultT New(const std::string &name, system::Transaction *txn = nullptr) {
+  NewResultT New(const std::string &name) {
     std::lock_guard<LockT> wr(lock_);
     const auto uuid = utils::UUID{};
-    return New_(name, uuid, txn);
+    return New_(name, uuid);
   }
 
   /**
@@ -227,7 +234,7 @@ class DbmsHandler {
    * @param db_name database name
    * @return DeleteResult error on failure
    */
-  DeleteResult TryDelete(std::string_view db_name, system::Transaction *transaction = nullptr);
+  DeleteResult TryDelete(std::string_view db_name);
 
   /**
    * @brief Delete or defer deletion of database.
@@ -267,29 +274,16 @@ class DbmsHandler {
   bool IsReplica() const { return repl_state_.IsReplica(); }
 
 #ifdef MG_ENTERPRISE
-  // coordination::CoordinatorState &CoordinatorState() { return coordinator_state_; }
+  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.
    *
    * @return Statistics
    */
-  Statistics Stats(memgraph::replication_coordination_glue::ReplicationRole replication_role) {
+  Statistics Stats() {
+    auto const replication_role = repl_state_.GetRole();
     Statistics stats{};
     // TODO: Handle overflow?
 #ifdef MG_ENTERPRISE
@@ -325,7 +319,8 @@ class DbmsHandler {
    *
    * @return std::vector<DatabaseInfo>
    */
-  std::vector<DatabaseInfo> Info(memgraph::replication_coordination_glue::ReplicationRole replication_role) {
+  std::vector<DatabaseInfo> Info() {
+    auto const replication_role = repl_state_.GetRole();
     std::vector<DatabaseInfo> res;
 #ifdef MG_ENTERPRISE
     std::shared_lock<LockT> rd(lock_);
@@ -412,18 +407,99 @@ class DbmsHandler {
     }
   }
 
-  static void RecoverStorageReplication(DatabaseAccess db_acc, replication::RoleMainData &role_main_data);
-
-  auto default_config() const -> storage::Config const & {
-#ifdef MG_ENTERPRISE
-    return default_config_;
-#else
-    const auto acc = db_gatekeeper_.access();
-    MG_ASSERT(acc, "Failed to get default database!");
-    return acc->get()->config();
-#endif
+  void NewSystemTransaction() {
+    DMG_ASSERT(!system_transaction_, "Already running a system transaction");
+    system_transaction_.emplace(++system_timestamp_);
   }
 
+  void ResetSystemTransaction() { system_transaction_.reset(); }
+
+  //! \tparam RPC An rpc::RequestResponse
+  //! \tparam Args the args type
+  //! \param client the client to use for rpc communication
+  //! \param check predicate to check response is ok
+  //! \param args arguments to forward to the rpc request
+  //! \return If replica stream is completed or enqueued
+  template <typename RPC, typename... Args>
+  bool SteamAndFinalizeDelta(auto &client, auto &&check, Args &&...args) {
+    try {
+      auto stream = client.rpc_client_.template Stream<RPC>(std::forward<Args>(args)...);
+      auto task = [&client, check = std::forward<decltype(check)>(check), stream = std::move(stream)]() mutable {
+        if (stream.IsDefunct()) {
+          client.state_.WithLock([](auto &state) { state = memgraph::replication::ReplicationClient::State::BEHIND; });
+          return false;
+        }
+        try {
+          if (check(stream.AwaitResponse())) {
+            return true;
+          }
+        } catch (memgraph::rpc::GenericRpcFailedException const &e) {
+          // swallow error, fallthrough to error handling
+        }
+        // This replica needs SYSTEM recovery
+        client.state_.WithLock([](auto &state) { state = memgraph::replication::ReplicationClient::State::BEHIND; });
+        return false;
+      };
+
+      if (client.mode_ == memgraph::replication_coordination_glue::ReplicationMode::ASYNC) {
+        client.thread_pool_.AddTask([task = utils::CopyMovableFunctionWrapper{std::move(task)}]() mutable { task(); });
+        return true;
+      }
+
+      return task();
+    } catch (memgraph::rpc::GenericRpcFailedException const &e) {
+      // This replica needs SYSTEM recovery
+      client.state_.WithLock([](auto &state) { state = memgraph::replication::ReplicationClient::State::BEHIND; });
+      return false;
+    }
+  };
+
+  AllSyncReplicaStatus Commit();
+
+  auto LastCommitedTS() const -> uint64_t { return last_commited_system_timestamp_; }
+  void SetLastCommitedTS(uint64_t new_ts) { last_commited_system_timestamp_.store(new_ts); }
+
+#ifdef MG_ENTERPRISE
+  // When being called by intepreter 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_commited_system_timestamp_
+  template <bool REQUIRE_LOCK = false>
+  void SystemRestore(replication::ReplicationClient &client) {
+    // Check if system is up to date
+    if (client.state_.WithLock(
+            [](auto &state) { return state == memgraph::replication::ReplicationClient::State::READY; }))
+      return;
+
+    // Try to recover...
+    {
+      auto [database_configs, last_commited_system_timestamp] = std::invoke([&] {
+        auto sys_guard =
+            std::unique_lock{system_lock_, std::defer_lock};  // ensure no other system transaction in progress
+        if constexpr (REQUIRE_LOCK) {
+          sys_guard.lock();
+        }
+        auto configs = std::vector<storage::SalientConfig>{};
+        ForEach([&configs](DatabaseAccess acc) { configs.emplace_back(acc->config().salient); });
+        return std::pair{configs, last_commited_system_timestamp_.load()};
+      });
+      try {
+        auto stream = client.rpc_client_.Stream<storage::replication::SystemRecoveryRpc>(last_commited_system_timestamp,
+                                                                                         std::move(database_configs));
+        const auto response = stream.AwaitResponse();
+        if (response.result == storage::replication::SystemRecoveryRes::Result::FAILURE) {
+          client.state_.WithLock([](auto &state) { state = memgraph::replication::ReplicationClient::State::BEHIND; });
+          return;
+        }
+      } catch (memgraph::rpc::GenericRpcFailedException const &e) {
+        client.state_.WithLock([](auto &state) { state = memgraph::replication::ReplicationClient::State::BEHIND; });
+        return;
+      }
+    }
+
+    // Successfully recovered
+    client.state_.WithLock([](auto &state) { state = memgraph::replication::ReplicationClient::State::READY; });
+  }
+#endif
+
  private:
 #ifdef MG_ENTERPRISE
   /**
@@ -448,8 +524,7 @@ class DbmsHandler {
    * @param uuid undelying RocksDB directory
    * @return NewResultT context on success, error on failure
    */
-  NewResultT New_(std::string_view name, utils::UUID uuid, system::Transaction *txn = nullptr,
-                  std::optional<std::filesystem::path> rel_dir = {}) {
+  NewResultT New_(std::string_view name, utils::UUID uuid, std::optional<std::filesystem::path> rel_dir = {}) {
     auto config_copy = default_config_;
     config_copy.salient.name = name;
     config_copy.salient.uuid = uuid;
@@ -460,7 +535,7 @@ class DbmsHandler {
       storage::UpdatePaths(config_copy,
                            default_config_.durability.storage_directory / kMultiTenantDir / std::string{uuid});
     }
-    return New_(std::move(config_copy), txn);
+    return New_(std::move(config_copy));
   }
 
   /**
@@ -469,11 +544,11 @@ class DbmsHandler {
    * @param config configuration to be used
    * @return NewResultT context on success, error on failure
    */
-  NewResultT New_(const storage::SalientConfig &config, system::Transaction *txn = nullptr) {
+  NewResultT New_(const storage::SalientConfig &config) {
     auto config_copy = default_config_;
     config_copy.salient = config;  // name, uuid, mode, etc
     UpdatePaths(config_copy, config_copy.durability.storage_directory / kMultiTenantDir / std::string{config.uuid});
-    return New_(std::move(config_copy), txn);
+    return New_(std::move(config_copy));
   }
 
   /**
@@ -482,7 +557,7 @@ class DbmsHandler {
    * @param storage_config storage configuration
    * @return NewResultT context on success, error on failure
    */
-  DbmsHandler::NewResultT New_(storage::Config storage_config, system::Transaction *txn = nullptr);
+  NewResultT New_(storage::Config storage_config);
 
   // TODO: new overload of Delete_ with DatabaseAccess
   DeleteResult Delete_(std::string_view db_name);
@@ -497,8 +572,7 @@ class DbmsHandler {
       Get(kDefaultDB);
     } catch (const UnknownDatabaseException &) {
       // No default DB restored, create it
-      MG_ASSERT(New_(kDefaultDB, {/* random UUID */}, nullptr, ".").HasValue(),
-                "Failed while creating the default database");
+      MG_ASSERT(New_(kDefaultDB, {/* random UUID */}, ".").HasValue(), "Failed while creating the default database");
     }
 
     // For back-compatibility...
@@ -585,21 +659,35 @@ class DbmsHandler {
   }
 #endif
 
+  void RecoverReplication(DatabaseAccess db_acc) {
+    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
+      memgraph::dbms::RestoreReplication(repl_state_, std::move(db_acc));
+    } else if (const ::memgraph::replication::RoleMainData *data =
+                   std::get_if<::memgraph::replication::RoleMainData>(&repl_state_.ReplicationData());
+               data && !data->registered_replicas_.empty()) {
+      spdlog::warn("Multi-tenant replication is currently not supported!");
+    }
+  }
+
 #ifdef MG_ENTERPRISE
   mutable LockT lock_{utils::RWLock::Priority::READ};  //!< protective lock
   storage::Config default_config_;                     //!< Storage configuration used when creating new databases
   DatabaseHandler db_handler_;                         //!< multi-tenancy storage handler
-  // TODO: move to be common
-  std::unique_ptr<kvstore::KVStore> durability_;  //!< list of active dbs (pointer so we can postpone its creation)
-  auth::SynchedAuth &auth_;                       //!< Synchronized auth::Auth
+  std::unique_ptr<kvstore::KVStore> durability_;       //!< list of active dbs (pointer so we can postpone its creation)
+  coordination::CoordinatorState coordinator_state_;  //!< Replication coordinator
 #endif
+  // TODO: Make an api
+ public:
+  utils::ResourceLock system_lock_{};  //!> Ensure exclusive access for system queries
  private:
-  // NOTE: atm the only reason this exists here, is because we pass it into the construction of New Database's
-  //       Database only uses it as a convience to make the correct Access without out needing to be told the
-  //       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
-
+  std::optional<SystemTransaction> system_transaction_;      //!< Current system transaction (only one at a time)
+  uint64_t system_timestamp_{storage::kTimestampInitialId};  //!< System timestamp
+  std::atomic_uint64_t last_commited_system_timestamp_{
+      storage::kTimestampInitialId};          //!< Last commited system timestamp
+  replication::ReplicationState repl_state_;  //!< Global replication state
 #ifndef MG_ENTERPRISE
   mutable utils::Gatekeeper<Database> db_gatekeeper_;  //!< Single databases gatekeeper
 #endif

src/dbms/handler.hpp

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

src/dbms/inmemory/replication_handlers.cpp

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

src/dbms/inmemory/replication_handlers.hpp

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

src/dbms/inmemory/storage_helper.hpp

@@ -11,6 +11,10 @@
 
 #pragma once
 
+#include <variant>
+
+#include "dbms/constants.hpp"
+#include "dbms/replication_handler.hpp"
 #include "replication/state.hpp"
 #include "storage/v2/config.hpp"
 #include "storage/v2/inmemory/storage.hpp"

src/dbms/replication_client.cpp

@@ -0,0 +1,43 @@
+// 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 "dbms/replication_client.hpp"
+#include "replication/replication_client.hpp"
+
+namespace memgraph::dbms {
+
+void StartReplicaClient(DbmsHandler &dbms_handler, replication::ReplicationClient &client) {
+  // 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([&dbms_handler](bool reconnect, replication::ReplicationClient &client) {
+    // Working connection
+    // Check if system needs restoration
+    if (reconnect) {
+      client.state_.WithLock([](auto &state) { state = memgraph::replication::ReplicationClient::State::BEHIND; });
+    }
+#ifdef MG_ENTERPRISE
+    dbms_handler.SystemRestore<true>(client);
+#endif
+    // Check if any database has been left behind
+    dbms_handler.ForEach([&name = client.name_, reconnect](dbms::DatabaseAccess db_acc) {
+      // Specific database <-> replica client
+      db_acc->storage()->repl_storage_state_.WithClient(name, [&](storage::ReplicationStorageClient *client) {
+        if (reconnect || client->State() == storage::replication::ReplicaState::MAYBE_BEHIND) {
+          // Database <-> replica might be behind, check and recover
+          client->TryCheckReplicaStateAsync(db_acc->storage(), db_acc);
+        }
+      });
+    });
+  });
+}  // namespace memgraph::dbms
+
+}  // namespace memgraph::dbms

src/dbms/replication_client.hpp

@@ -8,4 +8,14 @@
 // 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 "system/include/system/action.hpp"
+
+#pragma once
+
+#include "dbms/dbms_handler.hpp"
+#include "replication/replication_client.hpp"
+
+namespace memgraph::dbms {
+
+void StartReplicaClient(DbmsHandler &dbms_handler, replication::ReplicationClient &client);
+
+}  // namespace memgraph::dbms

src/dbms/replication_handler.cpp

@@ -0,0 +1,400 @@
+// 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 "dbms/replication_handler.hpp"
+
+#include <algorithm>
+
+#include "dbms/constants.hpp"
+#include "dbms/dbms_handler.hpp"
+#include "dbms/global.hpp"
+#include "dbms/inmemory/replication_handlers.hpp"
+#include "dbms/replication_client.hpp"
+#include "dbms/utils.hpp"
+#include "replication/messages.hpp"
+#include "replication/state.hpp"
+#include "spdlog/spdlog.h"
+#include "storage/v2/config.hpp"
+#include "storage/v2/replication/rpc.hpp"
+#include "utils/on_scope_exit.hpp"
+
+using memgraph::replication::RoleMainData;
+using memgraph::replication::RoleReplicaData;
+
+namespace memgraph::dbms {
+
+namespace {
+
+std::string RegisterReplicaErrorToString(RegisterReplicaError error) {
+  switch (error) {
+    using enum RegisterReplicaError;
+    case NAME_EXISTS:
+      return "NAME_EXISTS";
+    case ENDPOINT_EXISTS:
+      return "ENDPOINT_EXISTS";
+    case CONNECTION_FAILED:
+      return "CONNECTION_FAILED";
+    case COULD_NOT_BE_PERSISTED:
+      return "COULD_NOT_BE_PERSISTED";
+  }
+}
+}  // namespace
+
+ReplicationHandler::ReplicationHandler(DbmsHandler &dbms_handler) : dbms_handler_(dbms_handler) {}
+
+bool ReplicationHandler::SetReplicationRoleMain() {
+  auto const main_handler = [](RoleMainData &) {
+    // If we are already MAIN, we don't want to change anything
+    return false;
+  };
+
+  auto const replica_handler = [this](RoleReplicaData const &) {
+    return memgraph::dbms::DoReplicaToMainPromotion(dbms_handler_);
+  };
+
+  // TODO: under lock
+  return std::visit(utils::Overloaded{main_handler, replica_handler},
+                    dbms_handler_.ReplicationState().ReplicationData());
+}
+
+bool ReplicationHandler::SetReplicationRoleReplica(const memgraph::replication::ReplicationServerConfig &config) {
+  // We don't want to restart the server if we're already a REPLICA
+  if (dbms_handler_.ReplicationState().IsReplica()) {
+    return false;
+  }
+
+  // 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([&](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<RoleMainData>(dbms_handler_.ReplicationState().ReplicationData()).registered_replicas_.clear();
+
+  // Creates the server
+  dbms_handler_.ReplicationState().SetReplicationRoleReplica(config);
+
+  // Start
+  const auto success =
+      std::visit(utils::Overloaded{[](RoleMainData const &) {
+                                     // ASSERT
+                                     return false;
+                                   },
+                                   [this](RoleReplicaData const &data) { return StartRpcServer(dbms_handler_, data); }},
+                 dbms_handler_.ReplicationState().ReplicationData());
+  // TODO Handle error (restore to main?)
+  return success;
+}
+
+auto ReplicationHandler::RegisterReplica(const memgraph::replication::ReplicationClientConfig &config)
+    -> memgraph::utils::BasicResult<RegisterReplicaError> {
+  MG_ASSERT(dbms_handler_.ReplicationState().IsMain(), "Only main instance can register a replica!");
+
+  auto maybe_client = dbms_handler_.ReplicationState().RegisterReplica(config);
+  if (maybe_client.HasError()) {
+    switch (maybe_client.GetError()) {
+      case memgraph::replication::RegisterReplicaError::NOT_MAIN:
+        MG_ASSERT(false, "Only main instance can register a replica!");
+        return {};
+      case memgraph::replication::RegisterReplicaError::NAME_EXISTS:
+        return memgraph::dbms::RegisterReplicaError::NAME_EXISTS;
+      case memgraph::replication::RegisterReplicaError::ENDPOINT_EXISTS:
+        return memgraph::dbms::RegisterReplicaError::ENDPOINT_EXISTS;
+      case memgraph::replication::RegisterReplicaError::COULD_NOT_BE_PERSISTED:
+        return memgraph::dbms::RegisterReplicaError::COULD_NOT_BE_PERSISTED;
+      case memgraph::replication::RegisterReplicaError::SUCCESS:
+        break;
+    }
+  }
+
+  if (!allow_mt_repl && dbms_handler_.All().size() > 1) {
+    spdlog::warn("Multi-tenant replication is currently not supported!");
+  }
+
+#ifdef MG_ENTERPRISE
+  // Update system before enabling individual storage <-> replica clients
+  dbms_handler_.SystemRestore(*maybe_client.GetValue());
+#endif
+
+  const auto dbms_error = memgraph::dbms::HandleRegisterReplicaStatus(maybe_client);
+  if (dbms_error.has_value()) {
+    return *dbms_error;
+  }
+  auto &instance_client_ptr = maybe_client.GetValue();
+  const bool all_clients_good = memgraph::dbms::RegisterAllDatabasesClients(dbms_handler_, *instance_client_ptr);
+
+  // 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 RegisterReplicaError::CONNECTION_FAILED;
+  }
+
+  // No client error, start instance level client
+  StartReplicaClient(dbms_handler_, *instance_client_ptr);
+  return {};
+}
+
+auto ReplicationHandler::UnregisterReplica(std::string_view name) -> UnregisterReplicaResult {
+  auto const replica_handler = [](RoleReplicaData const &) -> UnregisterReplicaResult {
+    return UnregisterReplicaResult::NOT_MAIN;
+  };
+  auto const main_handler = [this, name](RoleMainData &mainData) -> UnregisterReplicaResult {
+    if (!dbms_handler_.ReplicationState().TryPersistUnregisterReplica(name)) {
+      return UnregisterReplicaResult::COULD_NOT_BE_PERSISTED;
+    }
+    // Remove database specific clients
+    dbms_handler_.ForEach([name](DatabaseAccess db_acc) {
+      db_acc->storage()->repl_storage_state_.replication_clients_.WithLock([&name](auto &clients) {
+        std::erase_if(clients, [name](const auto &client) { return client->Name() == name; });
+      });
+    });
+    // Remove instance level clients
+    auto const n_unregistered =
+        std::erase_if(mainData.registered_replicas_, [name](auto const &client) { return client.name_ == name; });
+    return n_unregistered != 0 ? UnregisterReplicaResult::SUCCESS : UnregisterReplicaResult::CAN_NOT_UNREGISTER;
+  };
+
+  return std::visit(utils::Overloaded{main_handler, replica_handler},
+                    dbms_handler_.ReplicationState().ReplicationData());
+}
+
+auto ReplicationHandler::GetRole() const -> memgraph::replication_coordination_glue::ReplicationRole {
+  return dbms_handler_.ReplicationState().GetRole();
+}
+
+bool ReplicationHandler::IsMain() const { return dbms_handler_.ReplicationState().IsMain(); }
+
+bool ReplicationHandler::IsReplica() const { return dbms_handler_.ReplicationState().IsReplica(); }
+
+// Per storage
+// NOTE Storage will connect to all replicas. Future work might change this
+void RestoreReplication(replication::ReplicationState &repl_state, DatabaseAccess db_acc) {
+  spdlog::info("Restoring replication role.");
+
+  /// MAIN
+  auto const recover_main = [db_acc = std::move(db_acc)](RoleMainData &mainData) mutable {  // NOLINT
+    // Each individual client has already been restored and started. Here we just go through each database and start its
+    // client
+    for (auto &instance_client : mainData.registered_replicas_) {
+      spdlog::info("Replica {} restoration started for {}.", instance_client.name_, db_acc->name());
+      const auto &ret = db_acc->storage()->repl_storage_state_.replication_clients_.WithLock(
+          [&, db_acc](auto &storage_clients) mutable -> utils::BasicResult<RegisterReplicaError> {
+            auto client = std::make_unique<storage::ReplicationStorageClient>(instance_client);
+            auto *storage = db_acc->storage();
+            client->Start(storage, std::move(db_acc));
+            // After start the storage <-> replica state should be READY or RECOVERING (if correctly started)
+            // MAYBE_BEHIND isn't a statement of the current state, this is the default value
+            // Failed to start due to branching of MAIN and REPLICA
+            if (client->State() == storage::replication::ReplicaState::MAYBE_BEHIND) {
+              spdlog::warn("Connection failed when registering replica {}. Replica will still be registered.",
+                           instance_client.name_);
+            }
+            storage_clients.push_back(std::move(client));
+            return {};
+          });
+
+      if (ret.HasError()) {
+        MG_ASSERT(RegisterReplicaError::CONNECTION_FAILED != ret.GetError());
+        LOG_FATAL("Failure when restoring replica {}: {}.", instance_client.name_,
+                  RegisterReplicaErrorToString(ret.GetError()));
+      }
+      spdlog::info("Replica {} restored for {}.", instance_client.name_, db_acc->name());
+    }
+    spdlog::info("Replication role restored to MAIN.");
+  };
+
+  /// REPLICA
+  auto const recover_replica = [](RoleReplicaData const &data) { /*nothing to do*/ };
+
+  std::visit(
+      utils::Overloaded{
+          recover_main,
+          recover_replica,
+      },
+      repl_state.ReplicationData());
+}
+
+namespace system_replication {
+#ifdef MG_ENTERPRISE
+void SystemHeartbeatHandler(const uint64_t ts, slk::Reader *req_reader, slk::Builder *res_builder) {
+  replication::SystemHeartbeatReq req;
+  replication::SystemHeartbeatReq::Load(&req, req_reader);
+
+  replication::SystemHeartbeatRes res(ts);
+  memgraph::slk::Save(res, res_builder);
+}
+
+void CreateDatabaseHandler(DbmsHandler &dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder) {
+  memgraph::storage::replication::CreateDatabaseReq req;
+  memgraph::slk::Load(&req, req_reader);
+
+  using memgraph::storage::replication::CreateDatabaseRes;
+  CreateDatabaseRes res(CreateDatabaseRes::Result::FAILURE);
+
+  // Note: No need to check epoch, recovery mechanism is done by a full uptodate snapshot
+  //       of the set of databases. Hence no history exists to maintain regarding epoch change.
+  //       If MAIN has changed we need to check this new group_timestamp is consistent with
+  //       what we have so far.
+
+  if (req.expected_group_timestamp != dbms_handler.LastCommitedTS()) {
+    spdlog::debug("CreateDatabaseHandler: bad expected timestamp {},{}", req.expected_group_timestamp,
+                  dbms_handler.LastCommitedTS());
+    memgraph::slk::Save(res, res_builder);
+    return;
+  }
+
+  try {
+    // Create new
+    auto new_db = dbms_handler.Update(req.config);
+    if (new_db.HasValue()) {
+      // Successfully create db
+      dbms_handler.SetLastCommitedTS(req.new_group_timestamp);
+      res = CreateDatabaseRes(CreateDatabaseRes::Result::SUCCESS);
+      spdlog::debug("CreateDatabaseHandler: SUCCESS updated LCTS to {}", req.new_group_timestamp);
+    }
+  } catch (...) {
+    // Failure
+  }
+
+  memgraph::slk::Save(res, res_builder);
+}
+
+void DropDatabaseHandler(DbmsHandler &dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder) {
+  memgraph::storage::replication::DropDatabaseReq req;
+  memgraph::slk::Load(&req, req_reader);
+
+  using memgraph::storage::replication::DropDatabaseRes;
+  DropDatabaseRes res(DropDatabaseRes::Result::FAILURE);
+
+  // Note: No need to check epoch, recovery mechanism is done by a full uptodate snapshot
+  //       of the set of databases. Hence no history exists to maintain regarding epoch change.
+  //       If MAIN has changed we need to check this new group_timestamp is consistent with
+  //       what we have so far.
+
+  if (req.expected_group_timestamp != dbms_handler.LastCommitedTS()) {
+    spdlog::debug("DropDatabaseHandler: bad expected timestamp {},{}", req.expected_group_timestamp,
+                  dbms_handler.LastCommitedTS());
+    memgraph::slk::Save(res, res_builder);
+    return;
+  }
+
+  try {
+    // NOTE: Single communication channel can exist at a time, no other database can be deleted/created at the moment.
+    auto new_db = dbms_handler.Delete(req.uuid);
+    if (new_db.HasError()) {
+      if (new_db.GetError() == DeleteError::NON_EXISTENT) {
+        // Nothing to drop
+        dbms_handler.SetLastCommitedTS(req.new_group_timestamp);
+        res = DropDatabaseRes(DropDatabaseRes::Result::NO_NEED);
+      }
+    } else {
+      // Successfully drop db
+      dbms_handler.SetLastCommitedTS(req.new_group_timestamp);
+      res = DropDatabaseRes(DropDatabaseRes::Result::SUCCESS);
+      spdlog::debug("DropDatabaseHandler: SUCCESS updated LCTS to {}", req.new_group_timestamp);
+    }
+  } catch (...) {
+    // Failure
+  }
+
+  memgraph::slk::Save(res, res_builder);
+}
+
+void SystemRecoveryHandler(DbmsHandler &dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder) {
+  // TODO Speed up
+  memgraph::storage::replication::SystemRecoveryReq req;
+  memgraph::slk::Load(&req, req_reader);
+
+  using memgraph::storage::replication::SystemRecoveryRes;
+  SystemRecoveryRes res(SystemRecoveryRes::Result::FAILURE);
+
+  utils::OnScopeExit send_on_exit([&]() { memgraph::slk::Save(res, res_builder); });
+
+  // Get all current dbs
+  auto old = dbms_handler.All();
+
+  // Check/create the incoming dbs
+  for (const auto &config : req.database_configs) {
+    // Missing db
+    try {
+      if (dbms_handler.Update(config).HasError()) {
+        spdlog::debug("SystemRecoveryHandler: Failed to update database \"{}\".", config.name);
+        return;  // Send failure on exit
+      }
+    } catch (const UnknownDatabaseException &) {
+      spdlog::debug("SystemRecoveryHandler: UnknownDatabaseException");
+      return;  // Send failure on exit
+    }
+    const auto it = std::find(old.begin(), old.end(), config.name);
+    if (it != old.end()) old.erase(it);
+  }
+
+  // Delete all the leftover old dbs
+  for (const auto &remove_db : old) {
+    const auto del = dbms_handler.Delete(remove_db);
+    if (del.HasError()) {
+      // Some errors are not terminal
+      if (del.GetError() == DeleteError::DEFAULT_DB || del.GetError() == DeleteError::NON_EXISTENT) {
+        spdlog::debug("SystemRecoveryHandler: Dropped database \"{}\".", remove_db);
+        continue;
+      }
+      spdlog::debug("SystemRecoveryHandler: Failed to drop database \"{}\".", remove_db);
+      return;  // Send failure on exit
+    }
+  }
+  // Successfully recovered
+  dbms_handler.SetLastCommitedTS(req.forced_group_timestamp);
+  spdlog::debug("SystemRecoveryHandler: SUCCESS updated LCTS to {}", req.forced_group_timestamp);
+  res = SystemRecoveryRes(SystemRecoveryRes::Result::SUCCESS);
+}
+#endif
+
+void Register(replication::RoleReplicaData const &data, dbms::DbmsHandler &dbms_handler) {
+#ifdef MG_ENTERPRISE
+  data.server->rpc_server_.Register<replication::SystemHeartbeatRpc>(
+      [&dbms_handler](auto *req_reader, auto *res_builder) {
+        spdlog::debug("Received SystemHeartbeatRpc");
+        SystemHeartbeatHandler(dbms_handler.LastCommitedTS(), req_reader, res_builder);
+      });
+  data.server->rpc_server_.Register<storage::replication::CreateDatabaseRpc>(
+      [&dbms_handler](auto *req_reader, auto *res_builder) {
+        spdlog::debug("Received CreateDatabaseRpc");
+        CreateDatabaseHandler(dbms_handler, req_reader, res_builder);
+      });
+  data.server->rpc_server_.Register<storage::replication::DropDatabaseRpc>(
+      [&dbms_handler](auto *req_reader, auto *res_builder) {
+        spdlog::debug("Received DropDatabaseRpc");
+        DropDatabaseHandler(dbms_handler, req_reader, res_builder);
+      });
+  data.server->rpc_server_.Register<storage::replication::SystemRecoveryRpc>(
+      [&dbms_handler](auto *req_reader, auto *res_builder) {
+        spdlog::debug("Received SystemRecoveryRpc");
+        SystemRecoveryHandler(dbms_handler, req_reader, res_builder);
+      });
+#endif
+}
+}  // namespace system_replication
+
+bool StartRpcServer(DbmsHandler &dbms_handler, const replication::RoleReplicaData &data) {
+  // Register handlers
+  InMemoryReplicationHandlers::Register(&dbms_handler, *data.server);
+  system_replication::Register(data, dbms_handler);
+  // Start server
+  if (!data.server->Start()) {
+    spdlog::error("Unable to start the replication server.");
+    return false;
+  }
+  return true;
+}
+}  // namespace memgraph::dbms

src/dbms/replication_handler.hpp

@@ -0,0 +1,82 @@
+// 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 "replication_coordination_glue/role.hpp"
+#include "dbms/database.hpp"
+#include "utils/result.hpp"
+
+namespace memgraph::replication {
+struct ReplicationState;
+struct ReplicationServerConfig;
+struct ReplicationClientConfig;
+}  // namespace memgraph::replication
+
+namespace memgraph::dbms {
+
+class DbmsHandler;
+
+enum class RegisterReplicaError : uint8_t { NAME_EXISTS, ENDPOINT_EXISTS, CONNECTION_FAILED, COULD_NOT_BE_PERSISTED };
+
+enum class UnregisterReplicaResult : uint8_t {
+  NOT_MAIN,
+  COULD_NOT_BE_PERSISTED,
+  CAN_NOT_UNREGISTER,
+  SUCCESS,
+};
+
+/// A handler type that keep in sync current ReplicationState and the MAIN/REPLICA-ness of Storage
+/// TODO: extend to do multiple storages
+struct ReplicationHandler {
+  explicit ReplicationHandler(DbmsHandler &dbms_handler);
+
+  // as REPLICA, become MAIN
+  bool SetReplicationRoleMain();
+
+  // as MAIN, become REPLICA
+  bool SetReplicationRoleReplica(const memgraph::replication::ReplicationServerConfig &config);
+
+  // as MAIN, define and connect to REPLICAs
+  auto RegisterReplica(const memgraph::replication::ReplicationClientConfig &config)
+      -> utils::BasicResult<RegisterReplicaError>;
+
+  // as MAIN, remove a REPLICA connection
+  auto UnregisterReplica(std::string_view name) -> UnregisterReplicaResult;
+
+  // Helper pass-through (TODO: remove)
+  auto GetRole() const -> memgraph::replication_coordination_glue::ReplicationRole;
+  bool IsMain() const;
+  bool IsReplica() const;
+
+ private:
+  DbmsHandler &dbms_handler_;
+};
+
+/// A handler type that keep in sync current ReplicationState and the MAIN/REPLICA-ness of Storage
+/// TODO: extend to do multiple storages
+void RestoreReplication(replication::ReplicationState &repl_state, DatabaseAccess db_acc);
+
+namespace system_replication {
+// System handlers
+#ifdef MG_ENTERPRISE
+void CreateDatabaseHandler(DbmsHandler &dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder);
+void SystemHeartbeatHandler(uint64_t ts, slk::Reader *req_reader, slk::Builder *res_builder);
+void SystemRecoveryHandler(DbmsHandler &dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder);
+#endif
+
+/// Register all DBMS level RPC handlers
+void Register(replication::RoleReplicaData const &data, DbmsHandler &dbms_handler);
+}  // namespace system_replication
+
+bool StartRpcServer(DbmsHandler &dbms_handler, const replication::RoleReplicaData &data);
+
+}  // namespace memgraph::dbms

src/dbms/replication_handlers.cpp

@@ -1,205 +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 "dbms/replication_handlers.hpp"
-
-#include "dbms/database.hpp"
-#include "dbms/dbms_handler.hpp"
-#include "storage/v2/storage.hpp"
-#include "system/state.hpp"
-
-namespace memgraph::dbms {
-
-#ifdef MG_ENTERPRISE
-
-void CreateDatabaseHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access,
-                           const std::optional<utils::UUID> &current_main_uuid, DbmsHandler &dbms_handler,
-                           slk::Reader *req_reader, slk::Builder *res_builder) {
-  using memgraph::storage::replication::CreateDatabaseRes;
-  CreateDatabaseRes res(CreateDatabaseRes::Result::FAILURE);
-
-  // Ignore if no license
-  if (!license::global_license_checker.IsEnterpriseValidFast()) {
-    spdlog::error("Handling CreateDatabase, an enterprise RPC message, without license.");
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
-  memgraph::storage::replication::CreateDatabaseReq req;
-  memgraph::slk::Load(&req, req_reader);
-
-  if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, memgraph::storage::replication::CreateDatabaseReq::kType.name);
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
-  // Note: No need to check epoch, recovery mechanism is done by a full uptodate snapshot
-  //       of the set of databases. Hence no history exists to maintain regarding epoch change.
-  //       If MAIN has changed we need to check this new group_timestamp is consistent with
-  //       what we have so far.
-
-  if (req.expected_group_timestamp != system_state_access.LastCommitedTS()) {
-    spdlog::debug("CreateDatabaseHandler: bad expected timestamp {},{}", req.expected_group_timestamp,
-                  system_state_access.LastCommitedTS());
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
-  try {
-    // Create new
-    auto new_db = dbms_handler.Update(req.config);
-    if (new_db.HasValue()) {
-      // Successfully create db
-      system_state_access.SetLastCommitedTS(req.new_group_timestamp);
-      res = CreateDatabaseRes(CreateDatabaseRes::Result::SUCCESS);
-      spdlog::debug("CreateDatabaseHandler: SUCCESS updated LCTS to {}", req.new_group_timestamp);
-    }
-  } catch (...) {
-    // Failure
-  }
-
-  memgraph::slk::Save(res, res_builder);
-}
-
-void DropDatabaseHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access,
-                         const std::optional<utils::UUID> &current_main_uuid, DbmsHandler &dbms_handler,
-                         slk::Reader *req_reader, slk::Builder *res_builder) {
-  using memgraph::storage::replication::DropDatabaseRes;
-  DropDatabaseRes res(DropDatabaseRes::Result::FAILURE);
-
-  // Ignore if no license
-  if (!license::global_license_checker.IsEnterpriseValidFast()) {
-    spdlog::error("Handling DropDatabase, an enterprise RPC message, without license.");
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
-  memgraph::storage::replication::DropDatabaseReq req;
-  memgraph::slk::Load(&req, req_reader);
-
-  if (!current_main_uuid.has_value() || req.main_uuid != current_main_uuid) [[unlikely]] {
-    LogWrongMain(current_main_uuid, req.main_uuid, memgraph::storage::replication::DropDatabaseReq::kType.name);
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
-  // Note: No need to check epoch, recovery mechanism is done by a full uptodate snapshot
-  //       of the set of databases. Hence no history exists to maintain regarding epoch change.
-  //       If MAIN has changed we need to check this new group_timestamp is consistent with
-  //       what we have so far.
-
-  if (req.expected_group_timestamp != system_state_access.LastCommitedTS()) {
-    spdlog::debug("DropDatabaseHandler: bad expected timestamp {},{}", req.expected_group_timestamp,
-                  system_state_access.LastCommitedTS());
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
-  try {
-    // NOTE: Single communication channel can exist at a time, no other database can be deleted/created at the moment.
-    auto new_db = dbms_handler.Delete(req.uuid);
-    if (new_db.HasError()) {
-      if (new_db.GetError() == DeleteError::NON_EXISTENT) {
-        // Nothing to drop
-        system_state_access.SetLastCommitedTS(req.new_group_timestamp);
-        res = DropDatabaseRes(DropDatabaseRes::Result::NO_NEED);
-      }
-    } else {
-      // Successfully drop db
-      system_state_access.SetLastCommitedTS(req.new_group_timestamp);
-      res = DropDatabaseRes(DropDatabaseRes::Result::SUCCESS);
-      spdlog::debug("DropDatabaseHandler: SUCCESS updated LCTS to {}", req.new_group_timestamp);
-    }
-  } catch (...) {
-    // Failure
-  }
-
-  memgraph::slk::Save(res, res_builder);
-}
-
-bool SystemRecoveryHandler(DbmsHandler &dbms_handler, const std::vector<storage::SalientConfig> &database_configs) {
-  /*
-   * NO LICENSE
-   */
-  if (!license::global_license_checker.IsEnterpriseValidFast()) {
-    spdlog::error("Handling SystemRecovery, an enterprise RPC message, without license.");
-    for (const auto &config : database_configs) {
-      // Only handle default DB
-      if (config.name != kDefaultDB) continue;
-      try {
-        if (dbms_handler.Update(config).HasError()) {
-          return false;
-        }
-      } catch (const UnknownDatabaseException &) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  /*
-   * MULTI-TENANCY
-   */
-  // Get all current dbs
-  auto old = dbms_handler.All();
-  // Check/create the incoming dbs
-  for (const auto &config : database_configs) {
-    // Missing db
-    try {
-      if (dbms_handler.Update(config).HasError()) {
-        spdlog::debug("SystemRecoveryHandler: Failed to update database \"{}\".", config.name);
-        return false;
-      }
-    } catch (const UnknownDatabaseException &) {
-      spdlog::debug("SystemRecoveryHandler: UnknownDatabaseException");
-      return false;
-    }
-    const auto it = std::find(old.begin(), old.end(), config.name);
-    if (it != old.end()) old.erase(it);
-  }
-
-  // Delete all the leftover old dbs
-  for (const auto &remove_db : old) {
-    const auto del = dbms_handler.Delete(remove_db);
-    if (del.HasError()) {
-      // Some errors are not terminal
-      if (del.GetError() == DeleteError::DEFAULT_DB || del.GetError() == DeleteError::NON_EXISTENT) {
-        spdlog::debug("SystemRecoveryHandler: Dropped database \"{}\".", remove_db);
-        continue;
-      }
-      spdlog::debug("SystemRecoveryHandler: Failed to drop database \"{}\".", remove_db);
-      return false;
-    }
-  }
-
-  /*
-   * SUCCESS
-   */
-  return true;
-}
-
-void Register(replication::RoleReplicaData const &data, system::ReplicaHandlerAccessToState &system_state_access,
-              dbms::DbmsHandler &dbms_handler) {
-  // NOTE: Register even without license as the user could add a license at run-time
-  data.server->rpc_server_.Register<storage::replication::CreateDatabaseRpc>(
-      [&data, system_state_access, &dbms_handler](auto *req_reader, auto *res_builder) mutable {
-        spdlog::debug("Received CreateDatabaseRpc");
-        CreateDatabaseHandler(system_state_access, data.uuid_, dbms_handler, req_reader, res_builder);
-      });
-  data.server->rpc_server_.Register<storage::replication::DropDatabaseRpc>(
-      [&data, system_state_access, &dbms_handler](auto *req_reader, auto *res_builder) mutable {
-        spdlog::debug("Received DropDatabaseRpc");
-        DropDatabaseHandler(system_state_access, data.uuid_, dbms_handler, req_reader, res_builder);
-      });
-}
-#endif
-}  // namespace memgraph::dbms

src/dbms/replication_handlers.hpp

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

src/dbms/rpc.cpp

@@ -1,122 +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 "dbms/rpc.hpp"
-
-#include "slk/streams.hpp"
-#include "storage/v2/replication/rpc.hpp"
-#include "utils/enum.hpp"
-#include "utils/typeinfo.hpp"
-
-namespace memgraph {
-
-namespace storage::replication {
-
-void CreateDatabaseReq::Save(const CreateDatabaseReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void CreateDatabaseReq::Load(CreateDatabaseReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-void CreateDatabaseRes::Save(const CreateDatabaseRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void CreateDatabaseRes::Load(CreateDatabaseRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-void DropDatabaseReq::Save(const DropDatabaseReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void DropDatabaseReq::Load(DropDatabaseReq *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
-void DropDatabaseRes::Save(const DropDatabaseRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void DropDatabaseRes::Load(DropDatabaseRes *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
-
-const utils::TypeInfo CreateDatabaseReq::kType{utils::TypeId::REP_CREATE_DATABASE_REQ, "CreateDatabaseReq", nullptr};
-
-const utils::TypeInfo CreateDatabaseRes::kType{utils::TypeId::REP_CREATE_DATABASE_RES, "CreateDatabaseRes", nullptr};
-
-const utils::TypeInfo DropDatabaseReq::kType{utils::TypeId::REP_DROP_DATABASE_REQ, "DropDatabaseReq", nullptr};
-
-const utils::TypeInfo DropDatabaseRes::kType{utils::TypeId::REP_DROP_DATABASE_RES, "DropDatabaseRes", nullptr};
-
-}  // namespace storage::replication
-
-// Autogenerated SLK serialization code
-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);
-  memgraph::slk::Save(self.config, builder);
-}
-
-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);
-  memgraph::slk::Load(&self->config, reader);
-}
-
-// Serialize code for CreateDatabaseRes
-
-void Save(const memgraph::storage::replication::CreateDatabaseRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(utils::EnumToNum<uint8_t>(self.result), builder);
-}
-
-void Load(memgraph::storage::replication::CreateDatabaseRes *self, memgraph::slk::Reader *reader) {
-  uint8_t res = 0;
-  memgraph::slk::Load(&res, reader);
-  if (!utils::NumToEnum(res, self->result)) {
-    throw SlkReaderException("Unexpected result line:{}!", __LINE__);
-  }
-}
-
-// 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);
-  memgraph::slk::Save(self.uuid, builder);
-}
-
-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);
-  memgraph::slk::Load(&self->uuid, reader);
-}
-
-// Serialize code for DropDatabaseRes
-
-void Save(const memgraph::storage::replication::DropDatabaseRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(utils::EnumToNum<uint8_t>(self.result), builder);
-}
-
-void Load(memgraph::storage::replication::DropDatabaseRes *self, memgraph::slk::Reader *reader) {
-  uint8_t res = 0;
-  memgraph::slk::Load(&res, reader);
-  if (!utils::NumToEnum(res, self->result)) {
-    throw SlkReaderException("Unexpected result line:{}!", __LINE__);
-  }
-}
-
-}  // namespace slk
-}  // namespace memgraph

src/dbms/rpc.hpp

@@ -1,122 +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 <cstdint>
-#include <string>
-#include <utility>
-
-#include "rpc/messages.hpp"
-#include "slk/streams.hpp"
-#include "storage/v2/config.hpp"
-#include "utils/uuid.hpp"
-
-namespace memgraph::storage::replication {
-
-struct CreateDatabaseReq {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(CreateDatabaseReq *self, memgraph::slk::Reader *reader);
-  static void Save(const CreateDatabaseReq &self, memgraph::slk::Builder *builder);
-  CreateDatabaseReq() = default;
-  CreateDatabaseReq(const utils::UUID &main_uuid, std::string epoch_id, uint64_t expected_group_timestamp,
-                    uint64_t new_group_timestamp, storage::SalientConfig config)
-      : main_uuid(main_uuid),
-        epoch_id(std::move(epoch_id)),
-        expected_group_timestamp{expected_group_timestamp},
-        new_group_timestamp(new_group_timestamp),
-        config(std::move(config)) {}
-
-  utils::UUID main_uuid;
-  std::string epoch_id;
-  uint64_t expected_group_timestamp;
-  uint64_t new_group_timestamp;
-  storage::SalientConfig config;
-};
-
-struct CreateDatabaseRes {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  enum class Result : uint8_t { SUCCESS, NO_NEED, FAILURE, /* Leave at end */ N };
-
-  static void Load(CreateDatabaseRes *self, memgraph::slk::Reader *reader);
-  static void Save(const CreateDatabaseRes &self, memgraph::slk::Builder *builder);
-  CreateDatabaseRes() = default;
-  explicit CreateDatabaseRes(Result res) : result(res) {}
-
-  Result result;
-};
-
-using CreateDatabaseRpc = rpc::RequestResponse<CreateDatabaseReq, CreateDatabaseRes>;
-
-struct DropDatabaseReq {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(DropDatabaseReq *self, memgraph::slk::Reader *reader);
-  static void Save(const DropDatabaseReq &self, memgraph::slk::Builder *builder);
-  DropDatabaseReq() = default;
-  DropDatabaseReq(const utils::UUID &main_uuid, std::string epoch_id, uint64_t expected_group_timestamp,
-                  uint64_t new_group_timestamp, const utils::UUID &uuid)
-      : main_uuid(main_uuid),
-        epoch_id(std::move(epoch_id)),
-        expected_group_timestamp{expected_group_timestamp},
-        new_group_timestamp(new_group_timestamp),
-        uuid(uuid) {}
-
-  utils::UUID main_uuid;
-  std::string epoch_id;
-  uint64_t expected_group_timestamp;
-  uint64_t new_group_timestamp;
-  utils::UUID uuid;
-};
-
-struct DropDatabaseRes {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  enum class Result : uint8_t { SUCCESS, NO_NEED, FAILURE, /* Leave at end */ N };
-
-  static void Load(DropDatabaseRes *self, memgraph::slk::Reader *reader);
-  static void Save(const DropDatabaseRes &self, memgraph::slk::Builder *builder);
-  DropDatabaseRes() = default;
-  explicit DropDatabaseRes(Result res) : result(res) {}
-
-  Result result;
-};
-
-using DropDatabaseRpc = rpc::RequestResponse<DropDatabaseReq, DropDatabaseRes>;
-
-}  // namespace memgraph::storage::replication
-
-// SLK serialization declarations
-namespace memgraph::slk {
-
-void Save(const memgraph::storage::replication::CreateDatabaseReq &self, memgraph::slk::Builder *builder);
-
-void Load(memgraph::storage::replication::CreateDatabaseReq *self, memgraph::slk::Reader *reader);
-
-void Save(const memgraph::storage::replication::CreateDatabaseRes &self, memgraph::slk::Builder *builder);
-
-void Load(memgraph::storage::replication::CreateDatabaseRes *self, memgraph::slk::Reader *reader);
-
-void Save(const memgraph::storage::replication::DropDatabaseReq &self, memgraph::slk::Builder *builder);
-
-void Load(memgraph::storage::replication::DropDatabaseReq *self, memgraph::slk::Reader *reader);
-
-void Save(const memgraph::storage::replication::DropDatabaseRes &self, memgraph::slk::Builder *builder);
-
-void Load(memgraph::storage::replication::DropDatabaseRes *self, memgraph::slk::Reader *reader);
-
-}  // namespace memgraph::slk

src/dbms/transaction.hpp

@@ -11,10 +11,7 @@
 
 #pragma once
 
-#include <list>
 #include <memory>
-#include <optional>
-#include "auth/models.hpp"
 #include "storage/v2/config.hpp"
 
 namespace memgraph::dbms {
@@ -23,70 +20,17 @@ struct SystemTransaction {
     enum class Action {
       CREATE_DATABASE,
       DROP_DATABASE,
-      UPDATE_AUTH_DATA,
-      DROP_AUTH_DATA,
-      /**
-       *
-       * CREATE USER user_name [IDENTIFIED BY 'password'];
-       * SET PASSWORD FOR user_name TO 'new_password';
-       * ^ SaveUser
-       *
-       * DROP USER user_name;
-       * ^ Directly on KVStore
-       *
-       * CREATE ROLE role_name;
-       * ^ SaveRole
-       *
-       * DROP ROLE
-       * ^ RemoveRole
-       *
-       * SET ROLE FOR user_name TO role_name;
-       * CLEAR ROLE FOR user_name;
-       * ^ Do stuff then do SaveUser
-       *
-       * GRANT privilege_list TO user_or_role;
-       * DENY AUTH, INDEX TO moderator:
-       * REVOKE AUTH, INDEX TO moderator:
-       * GRANT permission_level ON (LABELS | EDGE_TYPES) label_list TO user_or_role;
-       * REVOKE (LABELS | EDGE_TYPES) label_or_edge_type_list FROM user_or_role
-       * DENY (LABELS | EDGE_TYPES) label_or_edge_type_list TO user_or_role
-       * ^ all of these are EditPermissions <-> SaveUser/Role
-       *
-       * Multi-tenant TODO Doc;
-       * ^ Should all call SaveUser
-       *
-       */
     };
 
     static constexpr struct CreateDatabase {
     } create_database;
     static constexpr struct DropDatabase {
     } drop_database;
-    static constexpr struct UpdateAuthData {
-    } update_auth_data;
-    static constexpr struct DropAuthData {
-    } drop_auth_data;
 
-    enum class AuthData { USER, ROLE };
-
-    // Multi-tenancy
     Delta(CreateDatabase /*tag*/, storage::SalientConfig config)
         : action(Action::CREATE_DATABASE), config(std::move(config)) {}
     Delta(DropDatabase /*tag*/, const utils::UUID &uuid) : action(Action::DROP_DATABASE), uuid(uuid) {}
 
-    // Auth
-    Delta(UpdateAuthData /*tag*/, std::optional<auth::User> user)
-        : action(Action::UPDATE_AUTH_DATA), auth_data{std::move(user), std::nullopt} {}
-    Delta(UpdateAuthData /*tag*/, std::optional<auth::Role> role)
-        : action(Action::UPDATE_AUTH_DATA), auth_data{std::nullopt, std::move(role)} {}
-    Delta(DropAuthData /*tag*/, AuthData type, std::string_view name)
-        : action(Action::DROP_AUTH_DATA),
-          auth_data_key{
-              .type = type,
-              .name = std::string{name},
-          } {}
-
-    // Generic
     Delta(const Delta &) = delete;
     Delta(Delta &&) = delete;
     Delta &operator=(const Delta &) = delete;
@@ -98,14 +42,8 @@ struct SystemTransaction {
           std::destroy_at(&config);
           break;
         case Action::DROP_DATABASE:
-          std::destroy_at(&uuid);
-          break;
-        case Action::UPDATE_AUTH_DATA:
-          std::destroy_at(&auth_data);
-          break;
-        case Action::DROP_AUTH_DATA:
-          std::destroy_at(&auth_data_key);
           break;
+          // Some deltas might have special destructor handling
       }
     }
 
@@ -113,20 +51,13 @@ struct SystemTransaction {
     union {
       storage::SalientConfig config;
       utils::UUID uuid;
-      struct {
-        std::optional<auth::User> user;
-        std::optional<auth::Role> role;
-      } auth_data;
-      struct {
-        AuthData type;
-        std::string name;
-      } auth_data_key;
     };
   };
 
   explicit SystemTransaction(uint64_t timestamp) : system_timestamp(timestamp) {}
 
-  std::list<Delta> deltas{};
+  // Currently system transitions support a single delta
+  std::optional<Delta> delta{};
   uint64_t system_timestamp;
 };
 

src/dbms/utils.hpp

@@ -0,0 +1,133 @@
+// 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 "dbms/dbms_handler.hpp"
+#include "dbms/replication_handler.hpp"
+#include "replication/include/replication/state.hpp"
+#include "utils/result.hpp"
+
+namespace memgraph::dbms {
+
+inline bool DoReplicaToMainPromotion(dbms::DbmsHandler &dbms_handler) {
+  auto &repl_state = dbms_handler.ReplicationState();
+  // STEP 1) bring down all REPLICA servers
+  dbms_handler.ForEach([](DatabaseAccess db_acc) {
+    auto *storage = db_acc->storage();
+    // Remember old epoch + storage timestamp association
+    storage->PrepareForNewEpoch();
+  });
+
+  // STEP 2) Change to MAIN
+  // TODO: restore replication servers if false?
+  if (!repl_state.SetReplicationRoleMain()) {
+    // TODO: Handle recovery on failure???
+    return false;
+  }
+
+  // STEP 3) We are now MAIN, update storage local epoch
+  const auto &epoch =
+      std::get<replication::RoleMainData>(std::as_const(dbms_handler.ReplicationState()).ReplicationData()).epoch_;
+  dbms_handler.ForEach([&](DatabaseAccess db_acc) {
+    auto *storage = db_acc->storage();
+    storage->repl_storage_state_.epoch_ = epoch;
+  });
+
+  return true;
+};
+
+inline bool SetReplicationRoleReplica(dbms::DbmsHandler &dbms_handler,
+                                      const memgraph::replication::ReplicationServerConfig &config) {
+  if (dbms_handler.ReplicationState().IsReplica()) {
+    return false;
+  }
+
+  // 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([&](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<replication::RoleMainData>(dbms_handler.ReplicationState().ReplicationData()).registered_replicas_.clear();
+
+  // Creates the server
+  dbms_handler.ReplicationState().SetReplicationRoleReplica(config);
+
+  // Start
+  const auto success = std::visit(utils::Overloaded{[](replication::RoleMainData const &) {
+                                                      // ASSERT
+                                                      return false;
+                                                    },
+                                                    [&dbms_handler](replication::RoleReplicaData const &data) {
+                                                      return StartRpcServer(dbms_handler, data);
+                                                    }},
+                                  dbms_handler.ReplicationState().ReplicationData());
+  // TODO Handle error (restore to main?)
+  return success;
+}
+
+inline bool RegisterAllDatabasesClients(dbms::DbmsHandler &dbms_handler,
+                                        replication::ReplicationClient &instance_client) {
+  if (!allow_mt_repl && dbms_handler.All().size() > 1) {
+    spdlog::warn("Multi-tenant replication is currently not supported!");
+  }
+
+  bool all_clients_good = true;
+
+  // Add database specific clients (NOTE Currently all databases are connected to each replica)
+  dbms_handler.ForEach([&](DatabaseAccess db_acc) {
+    auto *storage = db_acc->storage();
+    if (!allow_mt_repl && storage->name() != 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, db_acc = std::move(db_acc)](auto &storage_clients) mutable {  // NOLINT
+          auto client = std::make_unique<storage::ReplicationStorageClient>(instance_client);
+          // All good, start replica client
+          client->Start(storage, std::move(db_acc));
+          // After start the storage <-> replica state should be READY or RECOVERING (if correctly started)
+          // MAYBE_BEHIND isn't a statement of the current state, this is the default value
+          // Failed to start due an error like branching of MAIN and REPLICA
+          if (client->State() == storage::replication::ReplicaState::MAYBE_BEHIND) {
+            return false;  // TODO: sometimes we need to still add to storage_clients
+          }
+          storage_clients.push_back(std::move(client));
+          return true;
+        });
+  });
+
+  return all_clients_good;
+}
+
+inline std::optional<RegisterReplicaError> HandleRegisterReplicaStatus(
+    utils::BasicResult<replication::RegisterReplicaError, replication::ReplicationClient *> &instance_client) {
+  if (instance_client.HasError()) switch (instance_client.GetError()) {
+      case replication::RegisterReplicaError::NOT_MAIN:
+        MG_ASSERT(false, "Only main instance can register a replica!");
+        return {};
+      case replication::RegisterReplicaError::NAME_EXISTS:
+        return dbms::RegisterReplicaError::NAME_EXISTS;
+      case replication::RegisterReplicaError::ENDPOINT_EXISTS:
+        return dbms::RegisterReplicaError::ENDPOINT_EXISTS;
+      case replication::RegisterReplicaError::COULD_NOT_BE_PERSISTED:
+        return dbms::RegisterReplicaError::COULD_NOT_BE_PERSISTED;
+      case replication::RegisterReplicaError::SUCCESS:
+        break;
+    }
+  return {};
+}
+
+}  // namespace memgraph::dbms

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

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

src/flags/replication.hpp

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

src/glue/ServerT.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
@@ -33,7 +33,7 @@ class WritePrioritizedRWLock;
 
 struct Context {
   memgraph::query::InterpreterContext *ic;
-  memgraph::auth::SynchedAuth *auth;
+  memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth;
 #if MG_ENTERPRISE
   memgraph::audit::Log *audit_log;
 #endif

src/glue/SessionHL.cpp

@@ -319,7 +319,8 @@ void SessionHL::Configure(const std::map<std::string, memgraph::communication::b
 SessionHL::SessionHL(memgraph::query::InterpreterContext *interpreter_context,
                      memgraph::communication::v2::ServerEndpoint endpoint,
                      memgraph::communication::v2::InputStream *input_stream,
-                     memgraph::communication::v2::OutputStream *output_stream, memgraph::auth::SynchedAuth *auth
+                     memgraph::communication::v2::OutputStream *output_stream,
+                     memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth
 #ifdef MG_ENTERPRISE
                      ,
                      memgraph::audit::Log *audit_log

src/glue/SessionHL.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
@@ -25,7 +25,8 @@ class SessionHL final : public memgraph::communication::bolt::Session<memgraph::
   SessionHL(memgraph::query::InterpreterContext *interpreter_context,
             memgraph::communication::v2::ServerEndpoint endpoint,
             memgraph::communication::v2::InputStream *input_stream,
-            memgraph::communication::v2::OutputStream *output_stream, memgraph::auth::SynchedAuth *auth
+            memgraph::communication::v2::OutputStream *output_stream,
+            memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth
 #ifdef MG_ENTERPRISE
             ,
             memgraph::audit::Log *audit_log
@@ -87,7 +88,7 @@ class SessionHL final : public memgraph::communication::bolt::Session<memgraph::
   memgraph::audit::Log *audit_log_;
   bool in_explicit_db_{false};  //!< If true, the user has defined the database to use via metadata
 #endif
-  memgraph::auth::SynchedAuth *auth_;
+  memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth_;
   memgraph::communication::v2::ServerEndpoint endpoint_;
   std::optional<std::string> implicit_db_;
 };

src/glue/auth_checker.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
@@ -66,7 +66,9 @@ bool IsUserAuthorizedEdgeType(const memgraph::auth::User &user, const memgraph::
 #endif
 namespace memgraph::glue {
 
-AuthChecker::AuthChecker(memgraph::auth::SynchedAuth *auth) : auth_(auth) {}
+AuthChecker::AuthChecker(
+    memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth)
+    : auth_(auth) {}
 
 bool AuthChecker::IsUserAuthorized(const std::optional<std::string> &username,
                                    const std::vector<memgraph::query::AuthQuery::Privilege> &privileges,

src/glue/auth_checker.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
@@ -22,7 +22,8 @@ namespace memgraph::glue {
 
 class AuthChecker : public query::AuthChecker {
  public:
-  explicit AuthChecker(memgraph::auth::SynchedAuth *auth);
+  explicit AuthChecker(
+      memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth);
 
   bool IsUserAuthorized(const std::optional<std::string> &username,
                         const std::vector<query::AuthQuery::Privilege> &privileges,
@@ -40,7 +41,7 @@ class AuthChecker : public query::AuthChecker {
                                              const std::string &db_name = "");
 
  private:
-  memgraph::auth::SynchedAuth *auth_;
+  memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth_;
   mutable memgraph::utils::Synchronized<auth::User, memgraph::utils::SpinLock> user_;  // cached user
 };
 #ifdef MG_ENTERPRISE

src/glue/auth_handler.cpp

@@ -210,25 +210,16 @@ std::vector<std::vector<memgraph::query::TypedValue>> ShowFineGrainedUserPrivile
   if (!memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
     return {};
   }
+  const auto &label_permissions = user->GetFineGrainedAccessLabelPermissions();
+  const auto &edge_type_permissions = user->GetFineGrainedAccessEdgeTypePermissions();
 
-  auto all_fine_grained_permissions = GetFineGrainedPermissionForPrivilegeForUserOrRole(
-      user->GetUserFineGrainedAccessLabelPermissions(), "LABEL", "USER");
-  auto all_role_fine_grained_permissions = GetFineGrainedPermissionForPrivilegeForUserOrRole(
-      user->GetRoleFineGrainedAccessLabelPermissions(), "LABEL", "ROLE");
-  all_fine_grained_permissions.insert(all_fine_grained_permissions.end(),
-                                      std::make_move_iterator(all_role_fine_grained_permissions.begin()),
-                                      std::make_move_iterator(all_role_fine_grained_permissions.end()));
+  auto all_fine_grained_permissions =
+      GetFineGrainedPermissionForPrivilegeForUserOrRole(label_permissions, "LABEL", "USER");
+  auto edge_type_fine_grained_permissions =
+      GetFineGrainedPermissionForPrivilegeForUserOrRole(edge_type_permissions, "EDGE_TYPE", "USER");
 
-  auto edge_type_fine_grained_permissions = GetFineGrainedPermissionForPrivilegeForUserOrRole(
-      user->GetUserFineGrainedAccessEdgeTypePermissions(), "EDGE_TYPE", "USER");
-  auto role_edge_type_fine_grained_permissions = GetFineGrainedPermissionForPrivilegeForUserOrRole(
-      user->GetRoleFineGrainedAccessEdgeTypePermissions(), "EDGE_TYPE", "ROLE");
-  all_fine_grained_permissions.insert(all_fine_grained_permissions.end(),
-                                      std::make_move_iterator(edge_type_fine_grained_permissions.begin()),
-                                      std::make_move_iterator(edge_type_fine_grained_permissions.end()));
-  all_fine_grained_permissions.insert(all_fine_grained_permissions.end(),
-                                      std::make_move_iterator(role_edge_type_fine_grained_permissions.begin()),
-                                      std::make_move_iterator(role_edge_type_fine_grained_permissions.end()));
+  all_fine_grained_permissions.insert(all_fine_grained_permissions.end(), edge_type_fine_grained_permissions.begin(),
+                                      edge_type_fine_grained_permissions.end());
 
   return ConstructFineGrainedPrivilegesResult(all_fine_grained_permissions);
 }
@@ -242,9 +233,9 @@ std::vector<std::vector<memgraph::query::TypedValue>> ShowFineGrainedRolePrivile
   const auto &edge_type_permissions = role->GetFineGrainedAccessEdgeTypePermissions();
 
   auto all_fine_grained_permissions =
-      GetFineGrainedPermissionForPrivilegeForUserOrRole(label_permissions, "LABEL", "ROLE");
+      GetFineGrainedPermissionForPrivilegeForUserOrRole(label_permissions, "LABEL", "USER");
   auto edge_type_fine_grained_permissions =
-      GetFineGrainedPermissionForPrivilegeForUserOrRole(edge_type_permissions, "EDGE_TYPE", "ROLE");
+      GetFineGrainedPermissionForPrivilegeForUserOrRole(edge_type_permissions, "EDGE_TYPE", "USER");
 
   all_fine_grained_permissions.insert(all_fine_grained_permissions.end(), edge_type_fine_grained_permissions.begin(),
                                       edge_type_fine_grained_permissions.end());
@@ -257,15 +248,16 @@ std::vector<std::vector<memgraph::query::TypedValue>> ShowFineGrainedRolePrivile
 
 namespace memgraph::glue {
 
-AuthQueryHandler::AuthQueryHandler(memgraph::auth::SynchedAuth *auth) : auth_(auth) {}
+AuthQueryHandler::AuthQueryHandler(
+    memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth)
+    : auth_(auth) {}
 
-bool AuthQueryHandler::CreateUser(const std::string &username, const std::optional<std::string> &password,
-                                  system::Transaction *system_tx) {
+bool AuthQueryHandler::CreateUser(const std::string &username, const std::optional<std::string> &password) {
   try {
     const auto [first_user, user_added] = std::invoke([&, this] {
       auto locked_auth = auth_->Lock();
       const auto first_user = !locked_auth->HasUsers();
-      const auto user_added = locked_auth->AddUser(username, password, system_tx).has_value();
+      const auto user_added = locked_auth->AddUser(username, password).has_value();
       return std::make_pair(first_user, user_added);
     });
 
@@ -284,11 +276,10 @@ bool AuthQueryHandler::CreateUser(const std::string &username, const std::option
             }
           }
 #endif
-          ,
-          system_tx);
+      );
 #ifdef MG_ENTERPRISE
-      GrantDatabaseToUser(auth::kAllDatabases, username, system_tx);
-      SetMainDatabase(dbms::kDefaultDB, username, system_tx);
+      GrantDatabaseToUser(auth::kAllDatabases, username);
+      SetMainDatabase(dbms::kDefaultDB, username);
 #endif
     }
 
@@ -298,19 +289,18 @@ bool AuthQueryHandler::CreateUser(const std::string &username, const std::option
   }
 }
 
-bool AuthQueryHandler::DropUser(const std::string &username, system::Transaction *system_tx) {
+bool AuthQueryHandler::DropUser(const std::string &username) {
   try {
     auto locked_auth = auth_->Lock();
     auto user = locked_auth->GetUser(username);
     if (!user) return false;
-    return locked_auth->RemoveUser(username, system_tx);
+    return locked_auth->RemoveUser(username);
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());
   }
 }
 
-void AuthQueryHandler::SetPassword(const std::string &username, const std::optional<std::string> &password,
-                                   system::Transaction *system_tx) {
+void AuthQueryHandler::SetPassword(const std::string &username, const std::optional<std::string> &password) {
   try {
     auto locked_auth = auth_->Lock();
     auto user = locked_auth->GetUser(username);
@@ -318,41 +308,39 @@ void AuthQueryHandler::SetPassword(const std::string &username, const std::optio
       throw memgraph::query::QueryRuntimeException("User '{}' doesn't exist.", username);
     }
     locked_auth->UpdatePassword(*user, password);
-    locked_auth->SaveUser(*user, system_tx);
+    locked_auth->SaveUser(*user);
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());
   }
 }
 
-bool AuthQueryHandler::CreateRole(const std::string &rolename, system::Transaction *system_tx) {
+bool AuthQueryHandler::CreateRole(const std::string &rolename) {
   try {
     auto locked_auth = auth_->Lock();
-    return locked_auth->AddRole(rolename, system_tx).has_value();
+    return locked_auth->AddRole(rolename).has_value();
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());
   }
 }
 
 #ifdef MG_ENTERPRISE
-bool AuthQueryHandler::RevokeDatabaseFromUser(const std::string &db_name, const std::string &username,
-                                              system::Transaction *system_tx) {
+bool AuthQueryHandler::RevokeDatabaseFromUser(const std::string &db, const std::string &username) {
   try {
     auto locked_auth = auth_->Lock();
     auto user = locked_auth->GetUser(username);
     if (!user) return false;
-    return locked_auth->RevokeDatabaseFromUser(db_name, username, system_tx);
+    return locked_auth->RevokeDatabaseFromUser(db, username);
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());
   }
 }
 
-bool AuthQueryHandler::GrantDatabaseToUser(const std::string &db_name, const std::string &username,
-                                           system::Transaction *system_tx) {
+bool AuthQueryHandler::GrantDatabaseToUser(const std::string &db, const std::string &username) {
   try {
     auto locked_auth = auth_->Lock();
     auto user = locked_auth->GetUser(username);
     if (!user) return false;
-    return locked_auth->GrantDatabaseToUser(db_name, username, system_tx);
+    return locked_auth->GrantDatabaseToUser(db, username);
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());
   }
@@ -372,28 +360,27 @@ std::vector<std::vector<memgraph::query::TypedValue>> AuthQueryHandler::GetDatab
   }
 }
 
-bool AuthQueryHandler::SetMainDatabase(std::string_view db_name, const std::string &username,
-                                       system::Transaction *system_tx) {
+bool AuthQueryHandler::SetMainDatabase(std::string_view db, const std::string &username) {
   try {
     auto locked_auth = auth_->Lock();
     auto user = locked_auth->GetUser(username);
     if (!user) return false;
-    return locked_auth->SetMainDatabase(db_name, username, system_tx);
+    return locked_auth->SetMainDatabase(db, username);
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());
   }
 }
 
-void AuthQueryHandler::DeleteDatabase(std::string_view db_name, system::Transaction *system_tx) {
+void AuthQueryHandler::DeleteDatabase(std::string_view db) {
   try {
-    auth_->Lock()->DeleteDatabase(std::string(db_name), system_tx);
+    auth_->Lock()->DeleteDatabase(std::string(db));
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());
   }
 }
 #endif
 
-bool AuthQueryHandler::DropRole(const std::string &rolename, system::Transaction *system_tx) {
+bool AuthQueryHandler::DropRole(const std::string &rolename) {
   try {
     auto locked_auth = auth_->Lock();
     auto role = locked_auth->GetRole(rolename);
@@ -402,7 +389,7 @@ bool AuthQueryHandler::DropRole(const std::string &rolename, system::Transaction
       return false;
     };
 
-    return locked_auth->RemoveRole(rolename, system_tx);
+    return locked_auth->RemoveRole(rolename);
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());
   }
@@ -474,8 +461,7 @@ std::vector<memgraph::query::TypedValue> AuthQueryHandler::GetUsernamesForRole(c
   }
 }
 
-void AuthQueryHandler::SetRole(const std::string &username, const std::string &rolename,
-                               system::Transaction *system_tx) {
+void AuthQueryHandler::SetRole(const std::string &username, const std::string &rolename) {
   try {
     auto locked_auth = auth_->Lock();
     auto user = locked_auth->GetUser(username);
@@ -491,13 +477,13 @@ void AuthQueryHandler::SetRole(const std::string &username, const std::string &r
                                                    current_role->rolename());
     }
     user->SetRole(*role);
-    locked_auth->SaveUser(*user, system_tx);
+    locked_auth->SaveUser(*user);
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());
   }
 }
 
-void AuthQueryHandler::ClearRole(const std::string &username, system::Transaction *system_tx) {
+void AuthQueryHandler::ClearRole(const std::string &username) {
   try {
     auto locked_auth = auth_->Lock();
     auto user = locked_auth->GetUser(username);
@@ -505,7 +491,7 @@ void AuthQueryHandler::ClearRole(const std::string &username, system::Transactio
       throw memgraph::query::QueryRuntimeException("User '{}' doesn't exist .", username);
     }
     user->ClearRole();
-    locked_auth->SaveUser(*user, system_tx);
+    locked_auth->SaveUser(*user);
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());
   }
@@ -559,8 +545,7 @@ void AuthQueryHandler::GrantPrivilege(
     const std::vector<std::unordered_map<memgraph::query::AuthQuery::FineGrainedPrivilege, std::vector<std::string>>>
         &edge_type_privileges
 #endif
-    ,
-    system::Transaction *system_tx) {
+) {
   EditPermissions(
       user_or_role, privileges,
 #ifdef MG_ENTERPRISE
@@ -583,13 +568,11 @@ void AuthQueryHandler::GrantPrivilege(
         }
       }
 #endif
-      ,
-      system_tx);
+  );
 }  // namespace memgraph::glue
 
 void AuthQueryHandler::DenyPrivilege(const std::string &user_or_role,
-                                     const std::vector<memgraph::query::AuthQuery::Privilege> &privileges,
-                                     system::Transaction *system_tx) {
+                                     const std::vector<memgraph::query::AuthQuery::Privilege> &privileges) {
   EditPermissions(
       user_or_role, privileges,
 #ifdef MG_ENTERPRISE
@@ -605,8 +588,7 @@ void AuthQueryHandler::DenyPrivilege(const std::string &user_or_role,
       ,
       [](auto &fine_grained_permissions, const auto &privilege_collection) {}
 #endif
-      ,
-      system_tx);
+  );
 }
 
 void AuthQueryHandler::RevokePrivilege(
@@ -618,8 +600,7 @@ void AuthQueryHandler::RevokePrivilege(
     const std::vector<std::unordered_map<memgraph::query::AuthQuery::FineGrainedPrivilege, std::vector<std::string>>>
         &edge_type_privileges
 #endif
-    ,
-    system::Transaction *system_tx) {
+) {
   EditPermissions(
       user_or_role, privileges,
 #ifdef MG_ENTERPRISE
@@ -641,8 +622,7 @@ void AuthQueryHandler::RevokePrivilege(
         }
       }
 #endif
-      ,
-      system_tx);
+  );
 }  // namespace memgraph::glue
 
 template <class TEditPermissionsFun
@@ -666,8 +646,7 @@ void AuthQueryHandler::EditPermissions(
     ,
     const TEditFineGrainedPermissionsFun &edit_fine_grained_permissions_fun
 #endif
-    ,
-    system::Transaction *system_tx) {
+) {
   try {
     std::vector<memgraph::auth::Permission> permissions;
     permissions.reserve(privileges.size());
@@ -696,7 +675,7 @@ void AuthQueryHandler::EditPermissions(
         }
       }
 #endif
-      locked_auth->SaveUser(*user, system_tx);
+      locked_auth->SaveUser(*user);
     } else {
       for (const auto &permission : permissions) {
         edit_permissions_fun(role->permissions(), permission);
@@ -712,7 +691,7 @@ void AuthQueryHandler::EditPermissions(
         }
       }
 #endif
-      locked_auth->SaveRole(*role, system_tx);
+      locked_auth->SaveRole(*role);
     }
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());

src/glue/auth_handler.hpp

@@ -23,36 +23,32 @@
 namespace memgraph::glue {
 
 class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
-  memgraph::auth::SynchedAuth *auth_;
+  memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth_;
 
  public:
-  explicit AuthQueryHandler(memgraph::auth::SynchedAuth *auth);
+  AuthQueryHandler(memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth);
 
-  bool CreateUser(const std::string &username, const std::optional<std::string> &password,
-                  system::Transaction *system_tx) override;
+  bool CreateUser(const std::string &username, const std::optional<std::string> &password) override;
 
-  bool DropUser(const std::string &username, system::Transaction *system_tx) override;
+  bool DropUser(const std::string &username) override;
 
-  void SetPassword(const std::string &username, const std::optional<std::string> &password,
-                   system::Transaction *system_tx) override;
+  void SetPassword(const std::string &username, const std::optional<std::string> &password) override;
 
 #ifdef MG_ENTERPRISE
-  bool RevokeDatabaseFromUser(const std::string &db_name, const std::string &username,
-                              system::Transaction *system_tx) override;
+  bool RevokeDatabaseFromUser(const std::string &db, const std::string &username) override;
 
-  bool GrantDatabaseToUser(const std::string &db_name, const std::string &username,
-                           system::Transaction *system_tx) override;
+  bool GrantDatabaseToUser(const std::string &db, const std::string &username) override;
 
   std::vector<std::vector<memgraph::query::TypedValue>> GetDatabasePrivileges(const std::string &username) override;
 
-  bool SetMainDatabase(std::string_view db_name, const std::string &username, system::Transaction *system_tx) override;
+  bool SetMainDatabase(std::string_view db, const std::string &username) override;
 
-  void DeleteDatabase(std::string_view db_name, system::Transaction *system_tx) override;
+  void DeleteDatabase(std::string_view db) override;
 #endif
 
-  bool CreateRole(const std::string &rolename, system::Transaction *system_tx) override;
+  bool CreateRole(const std::string &rolename) override;
 
-  bool DropRole(const std::string &rolename, system::Transaction *system_tx) override;
+  bool DropRole(const std::string &rolename) override;
 
   std::vector<memgraph::query::TypedValue> GetUsernames() override;
 
@@ -62,9 +58,9 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
 
   std::vector<memgraph::query::TypedValue> GetUsernamesForRole(const std::string &rolename) override;
 
-  void SetRole(const std::string &username, const std::string &rolename, system::Transaction *system_tx) override;
+  void SetRole(const std::string &username, const std::string &rolename) override;
 
-  void ClearRole(const std::string &username, system::Transaction *system_tx) override;
+  void ClearRole(const std::string &username) override;
 
   std::vector<std::vector<memgraph::query::TypedValue>> GetPrivileges(const std::string &user_or_role) override;
 
@@ -78,12 +74,10 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
       const std::vector<std::unordered_map<memgraph::query::AuthQuery::FineGrainedPrivilege, std::vector<std::string>>>
           &edge_type_privileges
 #endif
-      ,
-      system::Transaction *system_tx) override;
+      ) override;
 
   void DenyPrivilege(const std::string &user_or_role,
-                     const std::vector<memgraph::query::AuthQuery::Privilege> &privileges,
-                     system::Transaction *system_tx) override;
+                     const std::vector<memgraph::query::AuthQuery::Privilege> &privileges) override;
 
   void RevokePrivilege(
       const std::string &user_or_role, const std::vector<memgraph::query::AuthQuery::Privilege> &privileges
@@ -94,8 +88,7 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
       const std::vector<std::unordered_map<memgraph::query::AuthQuery::FineGrainedPrivilege, std::vector<std::string>>>
           &edge_type_privileges
 #endif
-      ,
-      system::Transaction *system_tx) override;
+      ) override;
 
  private:
   template <class TEditPermissionsFun
@@ -119,7 +112,6 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
       ,
       const TEditFineGrainedPermissionsFun &edit_fine_grained_permissions_fun
 #endif
-      ,
-      system::Transaction *system_tx);
+  );
 };
 }  // namespace memgraph::glue

src/io/network/endpoint.cpp

@@ -39,7 +39,7 @@ Endpoint::IpFamily Endpoint::GetIpFamily(const std::string &address) {
 }
 
 std::optional<std::pair<std::string, uint16_t>> Endpoint::ParseSocketOrIpAddress(
-    const std::string &address, const std::optional<uint16_t> default_port) {
+    const std::string &address, const std::optional<uint16_t> default_port = {}) {
   /// expected address format:
   ///   - "ip_address:port_number"
   ///   - "ip_address"

src/io/network/endpoint.hpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -61,8 +61,8 @@ struct Endpoint {
    * it into an ip address and a port number; even if a default port is given,
    * it won't be used, as we expect that it is given in the address string.
    */
-  static std::optional<std::pair<std::string, uint16_t>> ParseSocketOrIpAddress(
-      const std::string &address, std::optional<uint16_t> default_port = {});
+  static std::optional<std::pair<std::string, uint16_t>> ParseSocketOrIpAddress(const std::string &address,
+                                                                                std::optional<uint16_t> default_port);
 
   /**
    * Tries to parse given string as either socket address or hostname.

src/kvstore/kvstore.cpp

@@ -37,7 +37,6 @@ KVStore::KVStore(std::filesystem::path storage) : pimpl_(std::make_unique<impl>(
 }
 
 KVStore::~KVStore() {
-  if (pimpl_ == nullptr) return;
   spdlog::debug("Destroying KVStore at {}", pimpl_->storage.string());
   const auto sync = pimpl_->db->SyncWAL();
   if (!sync.ok()) spdlog::error("KVStore sync failed!");

src/memgraph.cpp

@@ -11,12 +11,9 @@
 
 #include <cstdint>
 #include "audit/log.hpp"
-#include "auth/auth.hpp"
 #include "communication/websocket/auth.hpp"
 #include "communication/websocket/server.hpp"
-#include "coordination/coordinator_handlers.hpp"
 #include "dbms/constants.hpp"
-#include "dbms/dbms_handler.hpp"
 #include "dbms/inmemory/replication_handlers.hpp"
 #include "flags/all.hpp"
 #include "glue/MonitoringServerT.hpp"
@@ -27,19 +24,14 @@
 #include "helpers.hpp"
 #include "license/license_sender.hpp"
 #include "memory/global_memory_control.hpp"
-#include "query/auth_query_handler.hpp"
 #include "query/config.hpp"
 #include "query/discard_value_stream.hpp"
 #include "query/interpreter.hpp"
-#include "query/interpreter_context.hpp"
 #include "query/procedure/callable_alias_mapper.hpp"
 #include "query/procedure/module.hpp"
 #include "query/procedure/py_module.hpp"
-#include "replication_handler/replication_handler.hpp"
-#include "replication_handler/system_replication.hpp"
 #include "requests/requests.hpp"
 #include "storage/v2/durability/durability.hpp"
-#include "system/system.hpp"
 #include "telemetry/telemetry.hpp"
 #include "utils/signals.hpp"
 #include "utils/sysinfo/memory.hpp"
@@ -47,6 +39,10 @@
 #include "utils/terminate_handler.hpp"
 #include "version.hpp"
 
+#include "dbms/dbms_handler.hpp"
+#include "query/auth_query_handler.hpp"
+#include "query/interpreter_context.hpp"
+
 namespace {
 constexpr const char *kMgUser = "MEMGRAPH_USER";
 constexpr const char *kMgPassword = "MEMGRAPH_PASSWORD";
@@ -134,7 +130,6 @@ int main(int argc, char **argv) {
   }
 
   memgraph::flags::InitializeLogger();
-  memgraph::flags::InitializeExperimental();
 
   // Unhandled exception handler init.
   std::set_terminate(&memgraph::utils::TerminateHandler);
@@ -356,85 +351,49 @@ 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,
       .stream_transaction_retry_interval = std::chrono::milliseconds(FLAGS_stream_transaction_retry_interval)};
 
-  auto auth_glue = [](memgraph::auth::SynchedAuth *auth, std::unique_ptr<memgraph::query::AuthQueryHandler> &ah,
-                      std::unique_ptr<memgraph::query::AuthChecker> &ac) {
-    // Glue high level auth implementations to the query side
-    ah = std::make_unique<memgraph::glue::AuthQueryHandler>(auth);
-    ac = std::make_unique<memgraph::glue::AuthChecker>(auth);
-    // Handle users passed via arguments
-    auto *maybe_username = std::getenv(kMgUser);
-    auto *maybe_password = std::getenv(kMgPassword);
-    auto *maybe_pass_file = std::getenv(kMgPassfile);
-    if (maybe_username && maybe_password) {
-      ah->CreateUser(maybe_username, maybe_password, nullptr);
-    } else if (maybe_pass_file) {
-      const auto [username, password] = LoadUsernameAndPassword(maybe_pass_file);
-      if (!username.empty() && !password.empty()) {
-        ah->CreateUser(username, password, nullptr);
-      }
-    }
-  };
+  auto auth_glue =
+      [](memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth,
+         std::unique_ptr<memgraph::query::AuthQueryHandler> &ah, std::unique_ptr<memgraph::query::AuthChecker> &ac) {
+        // Glue high level auth implementations to the query side
+        ah = std::make_unique<memgraph::glue::AuthQueryHandler>(auth);
+        ac = std::make_unique<memgraph::glue::AuthChecker>(auth);
+        // Handle users passed via arguments
+        auto *maybe_username = std::getenv(kMgUser);
+        auto *maybe_password = std::getenv(kMgPassword);
+        auto *maybe_pass_file = std::getenv(kMgPassfile);
+        if (maybe_username && maybe_password) {
+          ah->CreateUser(maybe_username, maybe_password);
+        } else if (maybe_pass_file) {
+          const auto [username, password] = LoadUsernameAndPassword(maybe_pass_file);
+          if (!username.empty() && !password.empty()) {
+            ah->CreateUser(username, password);
+          }
+        }
+      };
 
   memgraph::auth::Auth::Config auth_config{FLAGS_auth_user_or_role_name_regex, FLAGS_auth_password_strength_regex,
                                            FLAGS_auth_password_permit_null};
-  memgraph::auth::SynchedAuth auth_{data_directory / "auth", auth_config};
+  memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> auth_{
+      data_directory / "auth", auth_config};
   std::unique_ptr<memgraph::query::AuthQueryHandler> auth_handler;
   std::unique_ptr<memgraph::query::AuthChecker> auth_checker;
   auth_glue(&auth_, auth_handler, auth_checker);
 
-  auto system = memgraph::system::System{db_config.durability.storage_directory, FLAGS_data_recovery_on_startup};
-
-  // singleton replication state
-  memgraph::replication::ReplicationState repl_state{ReplicationStateRootPath(db_config)};
-
-  // singleton coordinator state
-#ifdef MG_ENTERPRISE
-  memgraph::coordination::CoordinatorState coordinator_state;
-#endif
-
-  memgraph::dbms::DbmsHandler dbms_handler(db_config, repl_state
+  memgraph::dbms::DbmsHandler dbms_handler(db_config
 #ifdef MG_ENTERPRISE
                                            ,
-                                           auth_, FLAGS_data_recovery_on_startup
+                                           &auth_, FLAGS_data_recovery_on_startup
 #endif
   );
-
-  // Note: Now that all system's subsystems are initialised (dbms & auth)
-  //       We can now initialise the recovery of replication (which will include those subsystems)
-  //       ReplicationHandler will handle the recovery
-  auto replication_handler = memgraph::replication::ReplicationHandler{repl_state, dbms_handler
-#ifdef MG_ENTERPRISE
-                                                                       ,
-                                                                       system, auth_
-#endif
-  };
-
-#ifdef MG_ENTERPRISE
-  // MAIN or REPLICA instance
-  if (FLAGS_coordinator_server_port) {
-    memgraph::dbms::CoordinatorHandlers::Register(coordinator_state.GetCoordinatorServer(), replication_handler);
-    MG_ASSERT(coordinator_state.GetCoordinatorServer().Start(), "Failed to start coordinator server!");
-  }
-#endif
-
   auto db_acc = dbms_handler.Get();
 
-  memgraph::query::InterpreterContext interpreter_context_(interp_config, &dbms_handler, &repl_state, system,
-#ifdef MG_ENTERPRISE
-                                                           &coordinator_state,
-#endif
-                                                           auth_handler.get(), auth_checker.get(),
-                                                           &replication_handler);
+  memgraph::query::InterpreterContext interpreter_context_(
+      interp_config, &dbms_handler, &dbms_handler.ReplicationState(), auth_handler.get(), auth_checker.get());
   MG_ASSERT(db_acc, "Failed to access the main database");
 
   memgraph::query::procedure::gModuleRegistry.SetModulesDirectory(memgraph::flags::ParseQueryModulesDirectory(),
@@ -501,9 +460,9 @@ int main(int argc, char **argv) {
   if (FLAGS_telemetry_enabled) {
     telemetry.emplace(telemetry_server, data_directory / "telemetry", memgraph::glue::run_id_, machine_id,
                       service_name == "BoltS", FLAGS_data_directory, std::chrono::minutes(10));
-    telemetry->AddStorageCollector(dbms_handler, auth_, repl_state);
+    telemetry->AddStorageCollector(dbms_handler, auth_);
 #ifdef MG_ENTERPRISE
-    telemetry->AddDatabaseCollector(dbms_handler, repl_state);
+    telemetry->AddDatabaseCollector(dbms_handler);
 #else
     telemetry->AddDatabaseCollector();
 #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/CMakeLists.txt

@@ -56,7 +56,6 @@ target_link_libraries(mg-query PUBLIC dl
     mg-kvstore
     mg-memory
     mg::csv
-    mg::system
     mg-flags
     mg-dbms
     mg-events)