add RPC to get data

.github/workflows/diff.yaml

@@ -336,6 +336,117 @@ jobs:
             # multiple paths could be defined
             build/logs
 
+  experimental_build_ha:
+    name: "High availability 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: |
+          source /opt/toolchain-v4/activate
+          ./init
+          cd build
+          cmake -DCMAKE_BUILD_TYPE=Release -DMG_EXPERIMENTAL_HIGH_AVAILABILITY=ON ..
+          make -j$THREADS
+      - name: Run unit tests
+        run: |
+          source /opt/toolchain-v4/activate
+          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
+          ./run.sh "Coordinator"
+          ./run.sh "Client initiated failover"
+          ./run.sh "Uninitialized cluster"
+      - name: Save test data
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: "Test data(High availability build)"
+          path: |
+            # 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
+        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_build_test.yaml

@@ -1,162 +0,0 @@
-name: Release build test
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref_name }}
-  cancel-in-progress: true
-
-on:
-  workflow_dispatch:
-    inputs:
-      build_type:
-        type: choice
-        description: "Memgraph Build type. Default value is Release."
-        default: 'Release'
-        options:
-          - Release
-          - RelWithDebInfo
-
-  push:
-    branches:
-      - "release/**"
-    tags:
-      - "v*.*.*-rc*"
-      - "v*.*-rc*"
-  schedule:
-    # UTC
-    - cron: "0 22 * * *"
-
-env:
-  THREADS: 24
-  MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
-  MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
-  BUILD_TYPE: ${{ github.event.inputs.build_type || 'Release' }}
-
-jobs:
-  Debian10:
-    uses: ./.github/workflows/release_debian10.yaml
-    with:
-      build_type: ${{ github.event.inputs.build_type || 'Release' }}
-    secrets: inherit
-
-  Ubuntu20_04:
-    uses: ./.github/workflows/release_ubuntu2004.yaml
-    with:
-      build_type: ${{ github.event.inputs.build_type || 'Release' }}
-    secrets: inherit
-
-  PackageDebian10:
-    if: github.ref_type == 'tag'
-    needs: [Debian10]
-    runs-on: [self-hosted, DockerMgBuild, X64]
-    timeout-minutes: 60
-    steps:
-      - name: "Set up repository"
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0 # Required because of release/get_version.py
-      - name: "Build package"
-        run: |
-          ./release/package/run.sh package debian-10 $BUILD_TYPE
-      - name: "Upload package"
-        uses: actions/upload-artifact@v4
-        with:
-          name: debian-10
-          path: build/output/debian-10/memgraph*.deb
-
-  PackageUbuntu20_04:
-    if: github.ref_type == 'tag'
-    needs: [Ubuntu20_04]
-    runs-on: [self-hosted, DockerMgBuild, X64]
-    timeout-minutes: 60
-    steps:
-      - name: "Set up repository"
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0 # Required because of release/get_version.py
-      - name: "Build package"
-        run: |
-          ./release/package/run.sh package ubuntu-22.04 $BUILD_TYPE
-      - name: "Upload package"
-        uses: actions/upload-artifact@v4
-        with:
-          name: ubuntu-22.04
-          path: build/output/ubuntu-22.04/memgraph*.deb
-
-  PackageUbuntu20_04_ARM:
-    if: github.ref_type == 'tag'
-    needs: [Ubuntu20_04]
-    runs-on: [self-hosted, DockerMgBuild, ARM64]
-    # M1 Mac mini is sometimes slower
-    timeout-minutes: 90
-    steps:
-      - name: "Set up repository"
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0 # Required because of release/get_version.py
-      - name: "Build package"
-        run: |
-          ./release/package/run.sh package ubuntu-22.04-arm $BUILD_TYPE
-      - name: "Upload package"
-        uses: actions/upload-artifact@v4
-        with:
-          name: ubuntu-22.04-aarch64
-          path: build/output/ubuntu-22.04-arm/memgraph*.deb
-
-  PackageDebian11:
-    if: github.ref_type == 'tag'
-    needs: [Debian10, Ubuntu20_04]
-    runs-on: [self-hosted, DockerMgBuild, X64]
-    timeout-minutes: 60
-    steps:
-      - name: "Set up repository"
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0 # Required because of release/get_version.py
-      - name: "Build package"
-        run: |
-          ./release/package/run.sh package debian-11 $BUILD_TYPE
-      - name: "Upload package"
-        uses: actions/upload-artifact@v4
-        with:
-          name: debian-11
-          path: build/output/debian-11/memgraph*.deb
-
-  PackageDebian11_ARM:
-    if: github.ref_type == 'tag'
-    needs: [Debian10, Ubuntu20_04]
-    runs-on: [self-hosted, DockerMgBuild, ARM64]
-    # M1 Mac mini is sometimes slower
-    timeout-minutes: 90
-    steps:
-      - name: "Set up repository"
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0 # Required because of release/get_version.py
-      - name: "Build package"
-        run: |
-          ./release/package/run.sh package debian-11-arm $BUILD_TYPE
-      - name: "Upload package"
-        uses: actions/upload-artifact@v4
-        with:
-          name: debian-11-aarch64
-          path: build/output/debian-11-arm/memgraph*.deb
-
-  PushToS3:
-    if: github.ref_type == 'tag'
-    needs: [PackageDebian10, PackageDebian11, PackageDebian11_ARM, PackageUbuntu20_04, PackageUbuntu20_04_ARM]
-    runs-on: ubuntu-latest
-    steps:
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          # name: # if name input parameter is not provided, all artifacts are downloaded
-                  # and put in directories named after each one.
-          path: build/output/release
-      - name: Upload to S3
-        uses: jakejarvis/s3-sync-action@v0.5.1
-        env:
-          AWS_S3_BUCKET: "deps.memgraph.io"
-          AWS_ACCESS_KEY_ID: ${{ secrets.S3_AWS_ACCESS_KEY_ID }}
-          AWS_SECRET_ACCESS_KEY: ${{ secrets.S3_AWS_SECRET_ACCESS_KEY }}
-          AWS_REGION: "eu-west-1"
-          SOURCE_DIR: "build/output/release"
-          DEST_DIR: "memgraph-unofficial/${{ github.ref_name }}/"

.github/workflows/release_debian10.yaml

@@ -1,12 +1,6 @@
 name: Release Debian 10
 
 on:
-  workflow_call:
-    inputs:
-      build_type:
-        type: string
-        description: "Memgraph Build type. Default value is Release."
-        default: 'Release'
   workflow_dispatch:
     inputs:
       build_type:
@@ -17,8 +11,10 @@ on:
           - Release
           - RelWithDebInfo
 
+  schedule:
+    - cron: "0 22 * * *"
+
 env:
-  OS: "Debian10"
   THREADS: 24
   MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
   MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
@@ -115,7 +111,7 @@ jobs:
       - name: Save code coverage
         uses: actions/upload-artifact@v4
         with:
-          name: "Code coverage(Coverage build)-${{ env.OS }}"
+          name: "Code coverage(Coverage build)"
           path: tools/github/generated/code_coverage.tar.gz
 
   debug_build:
@@ -169,7 +165,7 @@ jobs:
       - name: Save cppcheck and clang-format errors
         uses: actions/upload-artifact@v4
         with:
-          name: "Code coverage(Debug build)-${{ env.OS }}"
+          name: "Code coverage(Debug build)"
           path: tools/github/cppcheck_and_clang_format.txt
 
   debug_integration_test:
@@ -246,7 +242,7 @@ jobs:
       - name: Save enterprise DEB package
         uses: actions/upload-artifact@v4
         with:
-          name: "Enterprise DEB package-${{ env.OS}}"
+          name: "Enterprise DEB package"
           path: build/output/memgraph*.deb
 
       - name: Run GQL Behave tests
@@ -259,7 +255,7 @@ jobs:
       - name: Save quality assurance status
         uses: actions/upload-artifact@v4
         with:
-          name: "GQL Behave Status-${{ env.OS }}"
+          name: "GQL Behave Status"
           path: |
             tests/gql_behave/gql_behave_status.csv
             tests/gql_behave/gql_behave_status.html
@@ -325,6 +321,7 @@ jobs:
             --no-strict
 
   release_e2e_test:
+    if: false
     name: "Release End-to-end Test"
     runs-on: [self-hosted, Linux, X64, Debian10]
     timeout-minutes: 60
@@ -459,5 +456,5 @@ jobs:
         uses: actions/upload-artifact@v4
         if: ${{ always() }}
         with:
-          name: "Jepsen Report-${{ env.OS }}"
+          name: "Jepsen Report"
           path: tests/jepsen/Jepsen.tar.gz

.github/workflows/release_ubuntu2004.yaml

@@ -1,12 +1,6 @@
 name: Release Ubuntu 20.04
 
 on:
-  workflow_call:
-    inputs:
-      build_type:
-        type: string
-        description: "Memgraph Build type. Default value is Release."
-        default: 'Release'
   workflow_dispatch:
     inputs:
       build_type:
@@ -17,8 +11,10 @@ on:
           - Release
           - RelWithDebInfo
 
+  schedule:
+    - cron: "0 22 * * *"
+
 env:
-  OS: "Ubuntu 20.04"
   THREADS: 24
   MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
   MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
@@ -111,7 +107,7 @@ jobs:
       - name: Save code coverage
         uses: actions/upload-artifact@v4
         with:
-          name: "Code coverage(Coverage build)-${{ env.OS }}"
+          name: "Code coverage(Coverage build)"
           path: tools/github/generated/code_coverage.tar.gz
 
   debug_build:
@@ -165,7 +161,7 @@ jobs:
       - name: Save cppcheck and clang-format errors
         uses: actions/upload-artifact@v4
         with:
-          name: "Code coverage(Debug build)-${{ env.OS }}"
+          name: "Code coverage(Debug build)"
           path: tools/github/cppcheck_and_clang_format.txt
 
   debug_integration_test:
@@ -242,7 +238,7 @@ jobs:
       - name: Save enterprise DEB package
         uses: actions/upload-artifact@v4
         with:
-          name: "Enterprise DEB package-${{ env.OS }}"
+          name: "Enterprise DEB package"
           path: build/output/memgraph*.deb
 
       - name: Run GQL Behave tests
@@ -255,7 +251,7 @@ jobs:
       - name: Save quality assurance status
         uses: actions/upload-artifact@v4
         with:
-          name: "GQL Behave Status-${{ env.OS }}"
+          name: "GQL Behave Status"
           path: |
             tests/gql_behave/gql_behave_status.csv
             tests/gql_behave/gql_behave_status.html
@@ -321,6 +317,7 @@ jobs:
             --no-strict
 
   release_e2e_test:
+    if: false
     name: "Release End-to-end Test"
     runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
     timeout-minutes: 60

.github/workflows/stress_test_large.yaml

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

CMakeLists.txt

@@ -64,11 +64,11 @@ option(MG_ENTERPRISE "Build Memgraph Enterprise Edition" ON)
 # Set the current version here to override the automatic version detection. The
 # version must be specified as `X.Y.Z`. Primarily used when building new patch
 # versions.
-set(MEMGRAPH_OVERRIDE_VERSION "2.15.0")
+set(MEMGRAPH_OVERRIDE_VERSION "")
 
 # Custom suffix that this version should have. The suffix can be any arbitrary
 # string. Primarily used when building a version for a specific customer.
-set(MEMGRAPH_OVERRIDE_VERSION_SUFFIX "rc3")
+set(MEMGRAPH_OVERRIDE_VERSION_SUFFIX "")
 
 # Variables used to generate the versions.
 if (MG_ENTERPRISE)
@@ -211,13 +211,8 @@ set(CMAKE_CXX_FLAGS_RELWITHDEBINFO
 # ** Static linking is allowed only for executables! **
 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libgcc -static-libstdc++")
 
-# Use lld linker to speedup build and use less memory.
-add_link_options(-fuse-ld=lld)
-# NOTE: Moving to latest Clang (probably starting from 15), lld stopped to work
-# without explicit link_directories call.
-string(REPLACE ":" " " LD_LIBS $ENV{LD_LIBRARY_PATH})
-separate_arguments(LD_LIBS)
-link_directories(${LD_LIBS})
+# Use lld linker to speedup build
+add_link_options(-fuse-ld=lld) # TODO: use mold linker
 
 # release flags
 set(CMAKE_CXX_FLAGS_RELEASE "-O2 -DNDEBUG")
@@ -276,6 +271,18 @@ endif()
 set(libs_dir ${CMAKE_SOURCE_DIR}/libs)
 add_subdirectory(libs EXCLUDE_FROM_ALL)
 
+option(MG_EXPERIMENTAL_HIGH_AVAILABILITY "Feature flag for experimental high availability" OFF)
+
+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.")
+endif ()
+
+if (MG_EXPERIMENTAL_HIGH_AVAILABILITY)
+    add_compile_definitions(MG_EXPERIMENTAL_HIGH_AVAILABILITY)
+endif ()
+
+# Optional subproject configuration -------------------------------------------
 option(TEST_COVERAGE "Generate coverage reports from running memgraph" OFF)
 option(TOOLS "Build tools binaries" ON)
 option(QUERY_MODULES "Build query modules containing custom procedures" ON)
@@ -284,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)

include/_mgp.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
@@ -283,7 +283,7 @@ inline mgp_list *list_all_unique_constraints(mgp_graph *graph, mgp_memory *memor
 }
 
 // mgp_graph
-
+  
 inline bool graph_is_transactional(mgp_graph *graph) { return MgInvoke<int>(mgp_graph_is_transactional, graph); }
 
 inline bool graph_is_mutable(mgp_graph *graph) { return MgInvoke<int>(mgp_graph_is_mutable, graph); }

libs/.gitignore

@@ -7,4 +7,3 @@
 !pulsar.patch
 !antlr4.10.1.patch
 !rocksdb8.1.1.patch
-!nuraft2.1.0.patch

libs/CMakeLists.txt

@@ -16,7 +16,7 @@ set(GFLAGS_NOTHREADS OFF)
 
 # NOTE: config/generate.py depends on the gflags help XML format.
 find_package(gflags REQUIRED)
-find_package(fmt 8.0.1 REQUIRED)
+find_package(fmt 8.0.1)
 find_package(ZLIB 1.2.11 REQUIRED)
 
 set(LIB_DIR ${CMAKE_CURRENT_SOURCE_DIR})

libs/librdtsc.patch

@@ -5,7 +5,7 @@ index ee9b58c..31359a9 100644
 @@ -48,7 +48,7 @@ option(LIBRDTSC_USE_PMU     "Enables PMU usage on ARM platforms"        OFF)
  # |          Library Build and Install Properties          |
  # +--------------------------------------------------------+
-
+ 
 -add_library(rdtsc SHARED
 +add_library(rdtsc
      src/cycles.c
@@ -14,7 +14,7 @@ index ee9b58c..31359a9 100644
 @@ -72,15 +72,6 @@ target_include_directories(rdtsc
    PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include
  )
-
+ 
 -# Install directory changes depending on build mode
 -if (CMAKE_BUILD_TYPE MATCHES "^[Dd]ebug")
 -    # During debug, the library will be installed into a local directory
@@ -27,15 +27,3 @@ index ee9b58c..31359a9 100644
  # Specifying what to export when installing (GNUInstallDirs required)
  install(TARGETS rdtsc
          EXPORT librstsc-config
-diff --git a/include/librdtsc/common_timer.h b/include/librdtsc/common_timer.h
-index a6922d8..080dc77 100644
---- a/include/librdtsc/common_timer.h
-+++ b/include/librdtsc/common_timer.h
-@@ -2,6 +2,7 @@
- #define LIBRDTSC_COMMON_TIMER_H
-
- #include <librdtsc/common.h>
-+#include <librdtsc/cycles.h>
-
- extern uint64_t rdtsc_get_tsc_freq_arch();
- extern uint64_t rdtsc_get_tsc_freq();

libs/nuraft2.1.0.patch

@@ -1,24 +0,0 @@
-diff --git a/include/libnuraft/asio_service_options.hxx b/include/libnuraft/asio_service_options.hxx
-index 8fe1ec9..9497355 100644
---- a/include/libnuraft/asio_service_options.hxx
-+++ b/include/libnuraft/asio_service_options.hxx
-@@ -17,6 +17,7 @@ limitations under the License.
- 
- #pragma once
- 
-+#include <cstdint>
- #include <functional>
- #include <string>
- #include <system_error>
-diff --git a/include/libnuraft/callback.hxx b/include/libnuraft/callback.hxx
-index 7b71624..d48c1e2 100644
---- a/include/libnuraft/callback.hxx
-+++ b/include/libnuraft/callback.hxx
-@@ -18,6 +18,7 @@ limitations under the License.
- #ifndef _CALLBACK_H_
- #define _CALLBACK_H_
- 
-+#include <cstdint>
- #include <functional>
- #include <string>
- 

libs/rocksdb.patch

@@ -0,0 +1,21 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 6761929..6a369af 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -220,6 +220,7 @@ else()
+       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -momit-leaf-frame-pointer")
+     endif()
+   endif()
++  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-copy -Wno-unused-but-set-variable")
+ endif()
+ 
+ include(CheckCCompilerFlag)
+@@ -997,7 +998,7 @@ if(NOT WIN32 OR ROCKSDB_INSTALL_ON_WINDOWS)
+ 
+   if(ROCKSDB_BUILD_SHARED)
+     install(
+-      TARGETS ${ROCKSDB_SHARED_LIB}
++      TARGETS ${ROCKSDB_SHARED_LIB} OPTIONAL
+       EXPORT RocksDBTargets
+       COMPONENT runtime
+       ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"

libs/setup.sh

@@ -168,11 +168,12 @@ pushd antlr4
 git apply ../antlr4.10.1.patch
 popd
 
-cppitertools_ref="v2.1" # 2021-01-15
+# cppitertools v2.0 2019-12-23
+cppitertools_ref="cb3635456bdb531121b82b4d2e3afc7ae1f56d47"
 repo_clone_try_double "${primary_urls[cppitertools]}" "${secondary_urls[cppitertools]}" "cppitertools" "$cppitertools_ref"
 
 # rapidcheck
-rapidcheck_tag="1c91f40e64d87869250cfb610376c629307bf77d" # (2023-08-15)
+rapidcheck_tag="7bc7d302191a4f3d0bf005692677126136e02f60" # (2020-05-04)
 repo_clone_try_double "${primary_urls[rapidcheck]}" "${secondary_urls[rapidcheck]}" "rapidcheck" "$rapidcheck_tag"
 
 # google benchmark
@@ -220,7 +221,7 @@ repo_clone_try_double "${primary_urls[pymgclient]}" "${secondary_urls[pymgclient
 mgconsole_tag="v1.4.0" # (2023-05-21)
 repo_clone_try_double "${primary_urls[mgconsole]}" "${secondary_urls[mgconsole]}" "mgconsole" "$mgconsole_tag" true
 
-spdlog_tag="v1.12.0" # (2022-11-02)
+spdlog_tag="v1.9.2" # (2021-08-12)
 repo_clone_try_double "${primary_urls[spdlog]}" "${secondary_urls[spdlog]}" "spdlog" "$spdlog_tag" true
 
 # librdkafka
@@ -285,6 +286,5 @@ repo_clone_try_double "${primary_urls[range-v3]}" "${secondary_urls[range-v3]}"
 nuraft_tag="v2.1.0"
 repo_clone_try_double "${primary_urls[nuraft]}" "${secondary_urls[nuraft]}" "nuraft" "$nuraft_tag" true
 pushd nuraft
-git apply ../nuraft2.1.0.patch
 ./prepare.sh
 popd

licenses/BSL.txt

@@ -36,7 +36,7 @@ ADDITIONAL USE GRANT:   You may use the Licensed Work in accordance with the
                         3. using the Licensed Work to create a work or solution
                         which competes (or might reasonably be expected to
                         compete) with the Licensed Work.
-CHANGE DATE:            2028-28-02
+CHANGE DATE:            2028-21-01
 CHANGE LICENSE:         Apache License, Version 2.0
 
 For information about alternative licensing arrangements, please visit: https://memgraph.com/legal.

src/auth/crypto.hpp

@@ -8,12 +8,10 @@
 
 #pragma once
 
-#include <cstdint>
+#include <json/json.hpp>
 #include <optional>
 #include <string>
 
-#include <json/json.hpp>
-
 namespace memgraph::auth {
 /// Need to be stable, auth durability depends on this
 enum class PasswordHashAlgorithm : uint8_t { BCRYPT = 0, SHA256 = 1, SHA256_MULTIPLE = 2 };

src/communication/bolt/client.cpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -15,9 +15,6 @@
 #include "communication/bolt/v1/value.hpp"
 #include "utils/logging.hpp"
 
-#include "communication/bolt/v1/fmt.hpp"
-#include "io/network/fmt.hpp"
-
 namespace {
 constexpr uint8_t kBoltV43Version[4] = {0x00, 0x00, 0x03, 0x04};
 constexpr uint8_t kEmptyBoltVersion[4] = {0x00, 0x00, 0x00, 0x00};

src/communication/bolt/v1/fmt.hpp

@@ -1,27 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#if FMT_VERSION > 90000
-#include <fmt/ostream.h>
-
-#include "communication/bolt/v1/value.hpp"
-
-template <>
-class fmt::formatter<memgraph::communication::bolt::Value> : public fmt::ostream_formatter {};
-
-template <>
-class fmt::formatter<std::vector<memgraph::communication::bolt::Value>> : public fmt::ostream_formatter {};
-
-template <>
-class fmt::formatter<std::map<std::string, memgraph::communication::bolt::Value>> : public fmt::ostream_formatter {};
-#endif

src/communication/fmt.hpp

@@ -1,20 +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
-
-#if FMT_VERSION > 90000
-#include <fmt/ostream.h>
-#include <boost/asio/ip/tcp.hpp>
-
-template <>
-class fmt::formatter<boost::asio::ip::tcp::endpoint> : public fmt::ostream_formatter {};
-#endif

src/communication/http/listener.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
@@ -21,7 +21,6 @@
 #include <boost/beast/core.hpp>
 
 #include "communication/context.hpp"
-#include "communication/fmt.hpp"
 #include "communication/http/session.hpp"
 #include "utils/spin_lock.hpp"
 #include "utils/synchronized.hpp"
@@ -83,7 +82,7 @@ class Listener final : public std::enable_shared_from_this<Listener<TRequestHand
       return;
     }
 
-    spdlog::info("HTTP server is listening on {}", endpoint);
+    spdlog::info("HTTP server is listening on {}:{}", endpoint.address(), endpoint.port());
   }
 
   void DoAccept() {

src/communication/listener.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
@@ -23,7 +23,6 @@
 
 #include "communication/session.hpp"
 #include "io/network/epoll.hpp"
-#include "io/network/fmt.hpp"
 #include "io/network/socket.hpp"
 #include "utils/logging.hpp"
 #include "utils/signals.hpp"

src/communication/server.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,6 @@
 
 #include "communication/init.hpp"
 #include "communication/listener.hpp"
-#include "io/network/fmt.hpp"
 #include "io/network/socket.hpp"
 #include "utils/logging.hpp"
 #include "utils/message.hpp"

src/communication/v2/server.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
@@ -26,7 +26,6 @@
 #include <boost/asio/ip/tcp.hpp>
 
 #include "communication/context.hpp"
-#include "communication/fmt.hpp"
 #include "communication/init.hpp"
 #include "communication/v2/listener.hpp"
 #include "communication/v2/pool.hpp"
@@ -130,7 +129,7 @@ bool Server<TSession, TSessionContext>::Start() {
   listener_->Start();
 
   spdlog::info("{} server is fully armed and operational", service_name_);
-  spdlog::info("{} listening on {}", service_name_, endpoint_);
+  spdlog::info("{} listening on {}", service_name_, endpoint_.address());
   context_thread_pool_.Run();
 
   return true;

src/communication/v2/session.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
@@ -47,7 +47,6 @@
 #include "communication/buffer.hpp"
 #include "communication/context.hpp"
 #include "communication/exceptions.hpp"
-#include "communication/fmt.hpp"
 #include "dbms/global.hpp"
 #include "utils/event_counter.hpp"
 #include "utils/logging.hpp"
@@ -213,11 +212,14 @@ class WebsocketSession : public std::enable_shared_from_this<WebsocketSession<TS
       session_.Execute();
       DoRead();
     } catch (const SessionClosedException &e) {
-      spdlog::info("{} client {} closed the connection.", service_name_, remote_endpoint_);
+      spdlog::info("{} client {}:{} closed the connection.", service_name_, remote_endpoint_.address(),
+                   remote_endpoint_.port());
       DoClose();
     } catch (const std::exception &e) {
-      spdlog::error("Exception was thrown while processing event in {} session associated with {}", service_name_,
-                    remote_endpoint_);
+      spdlog::error(
+          "Exception was thrown while processing event in {} session "
+          "associated with {}:{}",
+          service_name_, remote_endpoint_.address(), remote_endpoint_.port());
       spdlog::debug("Exception message: {}", e.what());
       DoClose();
     }
@@ -374,7 +376,8 @@ class Session final : public std::enable_shared_from_this<Session<TSession, TSes
       socket.lowest_layer().non_blocking(false);
     });
     timeout_timer_.expires_at(boost::asio::steady_timer::time_point::max());
-    spdlog::info("Accepted a connection from {}: {}", service_name_, remote_endpoint_);
+    spdlog::info("Accepted a connection from {}: {}:{}", service_name_, remote_endpoint_.address(),
+                 remote_endpoint_.port());
   }
 
   void DoRead() {
@@ -434,11 +437,14 @@ class Session final : public std::enable_shared_from_this<Session<TSession, TSes
       session_.Execute();
       DoRead();
     } catch (const SessionClosedException &e) {
-      spdlog::info("{} client {} closed the connection.", service_name_, remote_endpoint_);
+      spdlog::info("{} client {}:{} closed the connection.", service_name_, remote_endpoint_.address(),
+                   remote_endpoint_.port());
       DoShutdown();
     } catch (const std::exception &e) {
-      spdlog::error("Exception was thrown while processing event in {} session associated with {}", service_name_,
-                    remote_endpoint_);
+      spdlog::error(
+          "Exception was thrown while processing event in {} session "
+          "associated with {}:{}",
+          service_name_, remote_endpoint_.address(), remote_endpoint_.port());
       spdlog::debug("Exception message: {}", e.what());
       DoShutdown();
     }

src/communication/websocket/listener.cpp

@@ -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
@@ -10,7 +10,6 @@
 // licenses/APL.txt.
 
 #include "communication/websocket/listener.hpp"
-#include "communication/fmt.hpp"
 
 namespace memgraph::communication::websocket {
 namespace {
@@ -62,7 +61,7 @@ Listener::Listener(boost::asio::io_context &ioc, ServerContext *context, tcp::en
     return;
   }
 
-  spdlog::info("WebSocket server is listening on {}", endpoint);
+  spdlog::info("WebSocket server is listening on {}:{}", endpoint.address(), endpoint.port());
 }
 
 void Listener::DoAccept() {

src/coordination/CMakeLists.txt

@@ -10,7 +10,9 @@ target_sources(mg-coordination
         include/coordination/coordinator_exceptions.hpp
         include/coordination/coordinator_slk.hpp
         include/coordination/coordinator_instance.hpp
+        include/coordination/coordinator_cluster_config.hpp
         include/coordination/coordinator_handlers.hpp
+        include/coordination/constants.hpp
         include/coordination/instance_status.hpp
         include/coordination/replication_instance.hpp
         include/coordination/raft_state.hpp

src/coordination/coordinator_client.cpp

@@ -16,6 +16,7 @@
 
 #include "coordination/coordinator_config.hpp"
 #include "coordination/coordinator_rpc.hpp"
+#include "replication_coordination_glue/common.hpp"
 #include "replication_coordination_glue/messages.hpp"
 #include "utils/result.hpp"
 
@@ -42,25 +43,16 @@ CoordinatorClient::CoordinatorClient(CoordinatorInstance *coord_instance, Coordi
 auto CoordinatorClient::InstanceName() const -> std::string { return config_.instance_name; }
 auto CoordinatorClient::SocketAddress() const -> std::string { return rpc_client_.Endpoint().SocketAddress(); }
 
-auto CoordinatorClient::InstanceDownTimeoutSec() const -> std::chrono::seconds {
-  return config_.instance_down_timeout_sec;
-}
-
-auto CoordinatorClient::InstanceGetUUIDFrequencySec() const -> std::chrono::seconds {
-  return config_.instance_get_uuid_frequency_sec;
-}
-
 void CoordinatorClient::StartFrequentCheck() {
   if (instance_checker_.IsRunning()) {
     return;
   }
 
-  MG_ASSERT(config_.instance_health_check_frequency_sec > std::chrono::seconds(0),
+  MG_ASSERT(config_.health_check_frequency_sec > std::chrono::seconds(0),
             "Health check frequency must be greater than 0");
 
   instance_checker_.Run(
-      config_.instance_name, config_.instance_health_check_frequency_sec,
-      [this, instance_name = config_.instance_name] {
+      config_.instance_name, config_.health_check_frequency_sec, [this, instance_name = config_.instance_name] {
         try {
           spdlog::trace("Sending frequent heartbeat to machine {} on {}", instance_name,
                         rpc_client_.Endpoint().SocketAddress());
@@ -131,45 +123,38 @@ auto CoordinatorClient::SendSwapMainUUIDRpc(const utils::UUID &uuid) const -> bo
   return false;
 }
 
-auto CoordinatorClient::SendUnregisterReplicaRpc(std::string const &instance_name) const -> bool {
-  try {
-    auto stream{rpc_client_.Stream<UnregisterReplicaRpc>(instance_name)};
-    if (!stream.AwaitResponse().success) {
-      spdlog::error("Failed to receive successful RPC response for unregistering replica!");
-      return false;
-    }
-    return true;
-  } catch (rpc::RpcFailedException const &) {
-    spdlog::error("Failed to unregister replica!");
-  }
-  return false;
-}
-
-auto CoordinatorClient::SendGetInstanceUUIDRpc() const
+auto CoordinatorClient::SendGetInstanceUUID() const
     -> utils::BasicResult<GetInstanceUUIDError, std::optional<utils::UUID>> {
+  std::optional<utils::UUID> instance_uuid;
   try {
     auto stream{rpc_client_.Stream<GetInstanceUUIDRpc>()};
     auto res = stream.AwaitResponse();
-    return res.uuid;
+    if (!res.uuid) {
+      return instance_uuid;
+    }
+    instance_uuid = res.uuid;
+
+  } catch (const rpc::RpcFailedException &) {
+    spdlog::error("RPC error occured while sending GetInstance UUID RPC");
+    return GetInstanceUUIDError::RPC_EXCEPTION;
+  }
+  return instance_uuid;
+}
+
+auto CoordinatorClient::SendGetInstanceTimestampsRpc() const
+    -> utils::BasicResult<GetInstanceUUIDError,
+                          std::vector<replication_coordination_glue::ReplicationTimestampResult>> {
+  try {
+    auto stream{rpc_client_.Stream<coordination::GetInstanceTimestampsRpc>()};
+    auto res = stream.AwaitResponse();
+
+    return res.replica_timestamps;
+
   } catch (const rpc::RpcFailedException &) {
     spdlog::error("RPC error occured while sending GetInstance UUID RPC");
     return GetInstanceUUIDError::RPC_EXCEPTION;
   }
 }
 
-auto CoordinatorClient::SendEnableWritingOnMainRpc() const -> bool {
-  try {
-    auto stream{rpc_client_.Stream<EnableWritingOnMainRpc>()};
-    if (!stream.AwaitResponse().success) {
-      spdlog::error("Failed to receive successful RPC response for enabling writing on main!");
-      return false;
-    }
-    return true;
-  } catch (rpc::RpcFailedException const &) {
-    spdlog::error("Failed to enable writing on main!");
-  }
-  return false;
-}
-
 }  // namespace memgraph::coordination
 #endif

src/coordination/coordinator_handlers.cpp

@@ -40,23 +40,25 @@ void CoordinatorHandlers::Register(memgraph::coordination::CoordinatorServer &se
         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);
       });
+
+  server.Register<coordination::GetInstanceTimestampsRpc>(
+      [&replication_handler](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
+        spdlog::info("Received GetInstanceTimestampsRpc on coordinator server");
+        CoordinatorHandlers::GetInstanceTimestampsHandler(replication_handler, req_reader, res_builder);
+      });
+}
+
+void CoordinatorHandlers::GetInstanceTimestampsHandler(replication::ReplicationHandler &replication_handler,
+                                                       slk::Reader *req_reader, slk::Builder *res_builder) {
+  coordination::GetInstanceTimestampsReq req;
+  slk::Load(&req, req_reader);
+
+  slk::Save(coordination::GetInstanceTimestampsRes{replication_handler.GetTimestampsForEachDb()}, res_builder);
 }
 
 void CoordinatorHandlers::SwapMainUUIDHandler(replication::ReplicationHandler &replication_handler,
@@ -97,9 +99,12 @@ void CoordinatorHandlers::DemoteMainToReplicaHandler(replication::ReplicationHan
 }
 
 void CoordinatorHandlers::GetInstanceUUIDHandler(replication::ReplicationHandler &replication_handler,
-                                                 slk::Reader * /*req_reader*/, slk::Builder *res_builder) {
+                                                 slk::Reader *req_reader, slk::Builder *res_builder) {
   spdlog::info("Executing GetInstanceUUIDHandler");
 
+  coordination::GetInstanceUUIDReq req;
+  slk::Load(&req, req_reader);
+
   slk::Save(coordination::GetInstanceUUIDRes{replication_handler.GetReplicaUUID()}, res_builder);
 }
 
@@ -132,7 +137,7 @@ void CoordinatorHandlers::PromoteReplicaToMainHandler(replication::ReplicationHa
 
   // registering replicas
   for (auto const &config : req.replication_clients_info | ranges::views::transform(converter)) {
-    auto instance_client = replication_handler.RegisterReplica(config);
+    auto instance_client = replication_handler.RegisterReplica(config, false);
     if (instance_client.HasError()) {
       using enum memgraph::replication::RegisterReplicaError;
       switch (instance_client.GetError()) {
@@ -161,58 +166,9 @@ void CoordinatorHandlers::PromoteReplicaToMainHandler(replication::ReplicationHa
       }
     }
   }
-  spdlog::info("Promote replica to main was success {}", std::string(req.main_uuid_));
+  spdlog::error(fmt::format("FICO : Promote replica to main was success {}", std::string(req.main_uuid_)));
   slk::Save(coordination::PromoteReplicaToMainRes{true}, res_builder);
 }
 
-void CoordinatorHandlers::UnregisterReplicaHandler(replication::ReplicationHandler &replication_handler,
-                                                   slk::Reader *req_reader, slk::Builder *res_builder) {
-  if (!replication_handler.IsMain()) {
-    spdlog::error("Unregistering replica must be performed on main.");
-    slk::Save(coordination::UnregisterReplicaRes{false}, res_builder);
-    return;
-  }
-
-  coordination::UnregisterReplicaReq req;
-  slk::Load(&req, req_reader);
-
-  auto res = replication_handler.UnregisterReplica(req.instance_name);
-  switch (res) {
-    using enum memgraph::query::UnregisterReplicaResult;
-    case SUCCESS:
-      slk::Save(coordination::UnregisterReplicaRes{true}, res_builder);
-      break;
-    case NOT_MAIN:
-      spdlog::error("Unregistering replica must be performed on main.");
-      slk::Save(coordination::UnregisterReplicaRes{false}, res_builder);
-      break;
-    case CAN_NOT_UNREGISTER:
-      spdlog::error("Could not unregister replica.");
-      slk::Save(coordination::UnregisterReplicaRes{false}, res_builder);
-      break;
-    case COULD_NOT_BE_PERSISTED:
-      spdlog::error("Could not persist replica unregistration.");
-      slk::Save(coordination::UnregisterReplicaRes{false}, res_builder);
-      break;
-  }
-}
-
-void CoordinatorHandlers::EnableWritingOnMainHandler(replication::ReplicationHandler &replication_handler,
-                                                     slk::Reader * /*req_reader*/, slk::Builder *res_builder) {
-  if (!replication_handler.IsMain()) {
-    spdlog::error("Enable writing on main must be performed on main!");
-    slk::Save(coordination::EnableWritingOnMainRes{false}, res_builder);
-    return;
-  }
-
-  if (!replication_handler.GetReplState().EnableWritingOnMain()) {
-    spdlog::error("Enabling writing on main failed!");
-    slk::Save(coordination::EnableWritingOnMainRes{false}, res_builder);
-    return;
-  }
-
-  slk::Save(coordination::EnableWritingOnMainRes{true}, res_builder);
-}
-
 }  // namespace memgraph::dbms
 #endif

src/coordination/coordinator_instance.cpp

@@ -14,11 +14,9 @@
 #include "coordination/coordinator_instance.hpp"
 
 #include "coordination/coordinator_exceptions.hpp"
-#include "coordination/fmt.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>
@@ -54,7 +52,8 @@ CoordinatorInstance::CoordinatorInstance()
     // 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());
+      spdlog::error(
+          fmt::format("Failed to swap uuid for replica instance {} which is alive", repl_instance.InstanceName()));
       return;
     }
 
@@ -84,11 +83,6 @@ CoordinatorInstance::CoordinatorInstance()
 
     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;
     }
@@ -124,9 +118,17 @@ CoordinatorInstance::CoordinatorInstance()
   };
 }
 
+auto CoordinatorInstance::ClusterHasAliveMain_() const -> bool {
+  auto const alive_main = [](ReplicationInstance const &instance) { return instance.IsMain() && instance.IsAlive(); };
+  return std::ranges::any_of(repl_instances_, alive_main);
+}
+
 auto CoordinatorInstance::ShowInstances() const -> std::vector<InstanceStatus> {
   auto const coord_instances = raft_state_.GetAllCoordinators();
 
+  std::vector<InstanceStatus> instances_status;
+  instances_status.reserve(repl_instances_.size() + coord_instances.size());
+
   auto const stringify_repl_role = [](ReplicationInstance const &instance) -> std::string {
     if (!instance.IsAlive()) return "unknown";
     if (instance.IsMain()) return "main";
@@ -148,7 +150,8 @@ auto CoordinatorInstance::ShowInstances() const -> std::vector<InstanceStatus> {
                                 // CoordinatorState to every instance, we can be smarter about this using our RPC.
   };
 
-  auto instances_status = utils::fmap(coord_instance_to_status, coord_instances);
+  std::ranges::transform(coord_instances, std::back_inserter(instances_status), coord_instance_to_status);
+
   {
     auto lock = std::shared_lock{coord_instance_lock_};
     std::ranges::transform(repl_instances_, std::back_inserter(instances_status), repl_instance_to_status);
@@ -167,6 +170,20 @@ auto CoordinatorInstance::TryFailover() -> void {
   }
 
   // TODO: Smarter choice
+  {
+    // for each DB we get one ReplicationTimestampResult, that is why we have vector here
+    using ReplicaTimestampsRes = std::vector<replication_coordination_glue::ReplicationTimestampResult>;
+    std::unordered_map<std::string, ReplicaTimestampsRes> instance_replica_timestamps_res;
+    std::for_each(alive_replicas.begin(), alive_replicas.end(),
+                  [&instance_replica_timestamps_res](ReplicationInstance &replica) {
+                    auto res = replica.GetClient().SendGetInstanceTimestampsRpc();
+                    if (res.HasError()) {
+                      return;
+                    }
+
+                    instance_replica_timestamps_res.emplace(replica.InstanceName(), std::move(res.GetValue()));
+                  });
+  }
   auto new_main = ranges::begin(alive_replicas);
 
   new_main->PauseFrequentCheck();
@@ -187,9 +204,10 @@ auto CoordinatorInstance::TryFailover() -> void {
     }
   }
 
-  auto repl_clients_info = repl_instances_ | ranges::views::filter(is_not_new_main) |
-                           ranges::views::transform(&ReplicationInstance::ReplicationClientInfo) |
-                           ranges::to<ReplicationClientsInfo>();
+  ReplicationClientsInfo repl_clients_info;
+  repl_clients_info.reserve(repl_instances_.size() - 1);
+  std::ranges::transform(repl_instances_ | ranges::views::filter(is_not_new_main),
+                         std::back_inserter(repl_clients_info), &ReplicationInstance::ReplicationClientInfo);
 
   if (!new_main->PromoteToMain(new_main_uuid, std::move(repl_clients_info), main_succ_cb_, main_fail_cb_)) {
     spdlog::warn("Failover failed since promoting replica to main failed!");
@@ -205,10 +223,6 @@ 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;
   };
@@ -304,35 +318,6 @@ auto CoordinatorInstance::RegisterReplicationInstance(CoordinatorClientConfig co
   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));

src/coordination/coordinator_rpc.cpp

@@ -52,34 +52,6 @@ void DemoteMainToReplicaRes::Load(DemoteMainToReplicaRes *self, memgraph::slk::R
   memgraph::slk::Load(self, reader);
 }
 
-void UnregisterReplicaReq::Save(UnregisterReplicaReq const &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-
-void UnregisterReplicaReq::Load(UnregisterReplicaReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-
-void UnregisterReplicaRes::Save(UnregisterReplicaRes const &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-
-void UnregisterReplicaRes::Load(UnregisterReplicaRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-
-void EnableWritingOnMainRes::Save(EnableWritingOnMainRes const &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-
-void EnableWritingOnMainRes::Load(EnableWritingOnMainRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-
-void EnableWritingOnMainReq::Save(EnableWritingOnMainReq const &self, memgraph::slk::Builder *builder) {}
-
-void EnableWritingOnMainReq::Load(EnableWritingOnMainReq *self, memgraph::slk::Reader *reader) {}
-
 // GetInstanceUUID
 void GetInstanceUUIDReq::Save(const GetInstanceUUIDReq &self, memgraph::slk::Builder *builder) {
   memgraph::slk::Save(self, builder);
@@ -97,6 +69,23 @@ void GetInstanceUUIDRes::Load(GetInstanceUUIDRes *self, memgraph::slk::Reader *r
   memgraph::slk::Load(self, reader);
 }
 
+// GetInstanceUUID
+void GetInstanceTimestampsReq::Save(const GetInstanceTimestampsReq &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self, builder);
+}
+
+void GetInstanceTimestampsReq::Load(GetInstanceTimestampsReq *self, memgraph::slk::Reader *reader) {
+  memgraph::slk::Load(self, reader);
+}
+
+void GetInstanceTimestampsRes::Save(const GetInstanceTimestampsRes &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self, builder);
+}
+
+void GetInstanceTimestampsRes::Load(GetInstanceTimestampsRes *self, memgraph::slk::Reader *reader) {
+  memgraph::slk::Load(self, reader);
+}
+
 }  // namespace coordination
 
 constexpr utils::TypeInfo coordination::PromoteReplicaToMainReq::kType{utils::TypeId::COORD_FAILOVER_REQ,
@@ -109,27 +98,20 @@ constexpr utils::TypeInfo coordination::DemoteMainToReplicaReq::kType{utils::Typ
                                                                       "CoordDemoteToReplicaReq", nullptr};
 
 constexpr utils::TypeInfo coordination::DemoteMainToReplicaRes::kType{utils::TypeId::COORD_SET_REPL_MAIN_RES,
-
                                                                       "CoordDemoteToReplicaRes", nullptr};
 
-constexpr utils::TypeInfo coordination::UnregisterReplicaReq::kType{utils::TypeId::COORD_UNREGISTER_REPLICA_REQ,
-                                                                    "UnregisterReplicaReq", nullptr};
-
-constexpr utils::TypeInfo coordination::UnregisterReplicaRes::kType{utils::TypeId::COORD_UNREGISTER_REPLICA_RES,
-                                                                    "UnregisterReplicaRes", nullptr};
-
-constexpr utils::TypeInfo coordination::EnableWritingOnMainReq::kType{utils::TypeId::COORD_ENABLE_WRITING_ON_MAIN_REQ,
-                                                                      "CoordEnableWritingOnMainReq", nullptr};
-
-constexpr utils::TypeInfo coordination::EnableWritingOnMainRes::kType{utils::TypeId::COORD_ENABLE_WRITING_ON_MAIN_RES,
-                                                                      "CoordEnableWritingOnMainRes", nullptr};
-
 constexpr utils::TypeInfo coordination::GetInstanceUUIDReq::kType{utils::TypeId::COORD_GET_UUID_REQ, "CoordGetUUIDReq",
                                                                   nullptr};
 
 constexpr utils::TypeInfo coordination::GetInstanceUUIDRes::kType{utils::TypeId::COORD_GET_UUID_RES, "CoordGetUUIDRes",
                                                                   nullptr};
 
+constexpr utils::TypeInfo coordination::GetInstanceTimestampsReq::kType{
+    utils::TypeId::COORD_GET_INSTANCE_TIMESTAMPS_REQ, "GetInstanceTimestampsReq", nullptr};
+
+constexpr utils::TypeInfo coordination::GetInstanceTimestampsRes::kType{
+    utils::TypeId::COORD_GET_INSTANCE_TIMESTAMPS_RES, "GetInstanceTimestampsRes", nullptr};
+
 namespace slk {
 
 // PromoteReplicaToMainRpc
@@ -169,32 +151,6 @@ void Load(memgraph::coordination::DemoteMainToReplicaRes *self, memgraph::slk::R
   memgraph::slk::Load(&self->success, reader);
 }
 
-// UnregisterReplicaRpc
-
-void Save(memgraph::coordination::UnregisterReplicaReq const &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.instance_name, builder);
-}
-
-void Load(memgraph::coordination::UnregisterReplicaReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->instance_name, reader);
-}
-
-void Save(memgraph::coordination::UnregisterReplicaRes const &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.success, builder);
-}
-
-void Load(memgraph::coordination::UnregisterReplicaRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->success, reader);
-}
-
-void Save(memgraph::coordination::EnableWritingOnMainRes const &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.success, builder);
-}
-
-void Load(memgraph::coordination::EnableWritingOnMainRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->success, reader);
-}
-
 // GetInstanceUUIDRpc
 
 void Save(const memgraph::coordination::GetInstanceUUIDReq & /*self*/, memgraph::slk::Builder * /*builder*/) {
@@ -213,6 +169,24 @@ void Load(memgraph::coordination::GetInstanceUUIDRes *self, memgraph::slk::Reade
   memgraph::slk::Load(&self->uuid, reader);
 }
 
+// GetInstanceTimestampsReq
+
+void Save(const memgraph::coordination::GetInstanceTimestampsReq & /*self*/, memgraph::slk::Builder * /*builder*/) {
+  /* nothing to serialize*/
+}
+
+void Load(memgraph::coordination::GetInstanceTimestampsReq * /*self*/, memgraph::slk::Reader * /*reader*/) {
+  /* nothing to serialize*/
+}
+
+void Save(const memgraph::coordination::GetInstanceTimestampsRes &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self.replica_timestamps, builder);
+}
+
+void Load(memgraph::coordination::GetInstanceTimestampsRes *self, memgraph::slk::Reader *reader) {
+  memgraph::slk::Load(&self->replica_timestamps, reader);
+}
+
 }  // namespace slk
 
 }  // namespace memgraph

src/coordination/coordinator_state.cpp

@@ -56,20 +56,6 @@ auto CoordinatorState::RegisterReplicationInstance(CoordinatorClientConfig confi
       data_);
 }
 
-auto CoordinatorState::UnregisterReplicationInstance(std::string instance_name) -> UnregisterInstanceCoordinatorStatus {
-  MG_ASSERT(std::holds_alternative<CoordinatorInstance>(data_),
-            "Coordinator cannot unregister instance since variant holds wrong alternative");
-
-  return std::visit(
-      memgraph::utils::Overloaded{[](const CoordinatorMainReplicaData & /*coordinator_main_replica_data*/) {
-                                    return UnregisterInstanceCoordinatorStatus::NOT_COORDINATOR;
-                                  },
-                                  [&instance_name](CoordinatorInstance &coordinator_instance) {
-                                    return coordinator_instance.UnregisterReplicationInstance(instance_name);
-                                  }},
-      data_);
-}
-
 auto CoordinatorState::SetReplicationInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus {
   MG_ASSERT(std::holds_alternative<CoordinatorInstance>(data_),
             "Coordinator cannot register replica since variant holds wrong alternative");

src/coordination/fmt.hpp

@@ -1,60 +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
-
-#if FMT_VERSION > 90000
-#include <fmt/ostream.h>
-#include <string>
-
-#include <libnuraft/nuraft.hxx>
-#include "utils/logging.hpp"
-
-inline std::string ToString(const nuraft::cmd_result_code &code) {
-  switch (code) {
-    case nuraft::cmd_result_code::OK:
-      return "OK";
-    case nuraft::cmd_result_code::FAILED:
-      return "FAILED";
-    case nuraft::cmd_result_code::RESULT_NOT_EXIST_YET:
-      return "RESULT_NOT_EXIST_YET";
-    case nuraft::cmd_result_code::TERM_MISMATCH:
-      return "TERM_MISMATCH";
-    case nuraft::cmd_result_code::SERVER_IS_LEAVING:
-      return "SERVER_IS_LEAVING";
-    case nuraft::cmd_result_code::CANNOT_REMOVE_LEADER:
-      return "CANNOT_REMOVE_LEADER";
-    case nuraft::cmd_result_code::SERVER_NOT_FOUND:
-      return "SERVER_NOT_FOUND";
-    case nuraft::cmd_result_code::SERVER_IS_JOINING:
-      return "SERVER_IS_JOINING";
-    case nuraft::cmd_result_code::CONFIG_CHANGING:
-      return "CONFIG_CHANGING";
-    case nuraft::cmd_result_code::SERVER_ALREADY_EXISTS:
-      return "SERVER_ALREADY_EXISTS";
-    case nuraft::cmd_result_code::BAD_REQUEST:
-      return "BAD_REQUEST";
-    case nuraft::cmd_result_code::NOT_LEADER:
-      return "NOT_LEADER";
-    case nuraft::cmd_result_code::TIMEOUT:
-      return "TIMEOUT";
-    case nuraft::cmd_result_code::CANCELLED:
-      return "CANCELLED";
-  }
-  LOG_FATAL("ToString of a nuraft::cmd_result_code -> check missing switch case");
-}
-inline std::ostream &operator<<(std::ostream &os, const nuraft::cmd_result_code &code) {
-  os << ToString(code);
-  return os;
-}
-template <>
-class fmt::formatter<nuraft::cmd_result_code> : public fmt::ostream_formatter {};
-#endif

src/coordination/include/coordination/constants.hpp

@@ -11,11 +11,12 @@
 
 #pragma once
 
-#if FMT_VERSION > 90000
-#include <fmt/ostream.h>
+namespace memgraph::coordination {
 
-#include "io/network/endpoint.hpp"
-
-template <>
-class fmt::formatter<memgraph::io::network::Endpoint> : public fmt::ostream_formatter {};
+#ifdef MG_EXPERIMENTAL_HIGH_AVAILABILITY
+constexpr bool allow_ha = true;
+#else
+constexpr bool allow_ha = false;
 #endif
+
+}  // namespace memgraph::coordination

src/coordination/include/coordination/coordinator_client.hpp

@@ -11,14 +11,15 @@
 
 #pragma once
 
+#include "utils/uuid.hpp"
 #ifdef MG_ENTERPRISE
 
 #include "coordination/coordinator_config.hpp"
+#include "replication_coordination_glue/common.hpp"
 #include "rpc/client.hpp"
 #include "rpc_errors.hpp"
 #include "utils/result.hpp"
 #include "utils/scheduler.hpp"
-#include "utils/uuid.hpp"
 
 namespace memgraph::coordination {
 
@@ -48,28 +49,23 @@ class CoordinatorClient {
   auto SocketAddress() const -> std::string;
 
   [[nodiscard]] auto DemoteToReplica() const -> bool;
-
   auto SendPromoteReplicaToMainRpc(const utils::UUID &uuid, ReplicationClientsInfo replication_clients_info) const
       -> bool;
 
   auto SendSwapMainUUIDRpc(const utils::UUID &uuid) const -> bool;
 
-  auto SendUnregisterReplicaRpc(std::string const &instance_name) const -> bool;
-
-  auto SendEnableWritingOnMainRpc() const -> bool;
-
-  auto SendGetInstanceUUIDRpc() const -> memgraph::utils::BasicResult<GetInstanceUUIDError, std::optional<utils::UUID>>;
+  auto SendGetInstanceUUID() const -> memgraph::utils::BasicResult<GetInstanceUUIDError, std::optional<utils::UUID>>;
 
   auto ReplicationClientInfo() const -> ReplClientInfo;
 
   auto SetCallbacks(HealthCheckCallback succ_cb, HealthCheckCallback fail_cb) -> void;
 
+  auto SendGetInstanceTimestampsRpc() const
+      -> utils::BasicResult<GetInstanceUUIDError,
+                            std::vector<replication_coordination_glue::ReplicationTimestampResult>>;
+
   auto RpcClient() -> rpc::Client & { return rpc_client_; }
 
-  auto InstanceDownTimeoutSec() const -> std::chrono::seconds;
-
-  auto InstanceGetUUIDFrequencySec() const -> std::chrono::seconds;
-
   friend bool operator==(CoordinatorClient const &first, CoordinatorClient const &second) {
     return first.config_ == second.config_;
   }
@@ -77,6 +73,7 @@ class CoordinatorClient {
  private:
   utils::Scheduler instance_checker_;
 
+  // TODO: (andi) Pimpl?
   communication::ClientContext rpc_context_;
   mutable rpc::Client rpc_client_;
 

src/coordination/include/coordination/coordinator_cluster_config.hpp

@@ -11,11 +11,13 @@
 
 #pragma once
 
-#if FMT_VERSION > 90000
-#include <fmt/ostream.h>
+#ifdef MG_ENTERPRISE
+namespace memgraph::coordination {
 
-#include "integrations/pulsar/consumer.hpp"
+struct CoordinatorClusterConfig {
+  static constexpr int alive_response_time_difference_sec_{5};
+  static constexpr int replica_uuid_last_check_time_difference_sec_{10};
+};
 
-template <>
-class fmt::formatter<memgraph::integrations::pulsar::pulsar_client::Result> : public fmt::ostream_formatter {};
+}  // namespace memgraph::coordination
 #endif

src/coordination/include/coordination/coordinator_config.hpp

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

src/coordination/include/coordination/coordinator_handlers.hpp

@@ -34,13 +34,11 @@ class CoordinatorHandlers {
   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);
+
+  static void GetInstanceTimestampsHandler(replication::ReplicationHandler &replication_handler,
+                                           slk::Reader *req_reader, slk::Builder *res_builder);
 };
 
 }  // namespace memgraph::dbms

src/coordination/include/coordination/coordinator_instance.hpp

@@ -30,7 +30,6 @@ class CoordinatorInstance {
   CoordinatorInstance();
 
   [[nodiscard]] auto RegisterReplicationInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus;
-  [[nodiscard]] auto UnregisterReplicationInstance(std::string instance_name) -> UnregisterInstanceCoordinatorStatus;
 
   [[nodiscard]] auto SetReplicationInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus;
 
@@ -45,6 +44,8 @@ class CoordinatorInstance {
   auto SetMainUUID(utils::UUID new_uuid) -> void;
 
  private:
+  auto ClusterHasAliveMain_() const -> bool;
+
   HealthCheckCallback main_succ_cb_, main_fail_cb_, replica_succ_cb_, replica_fail_cb_;
 
   // NOTE: Must be std::list because we rely on pointer stability

src/coordination/include/coordination/coordinator_rpc.hpp

@@ -15,6 +15,7 @@
 #ifdef MG_ENTERPRISE
 
 #include "coordination/coordinator_config.hpp"
+#include "replication_coordination_glue/common.hpp"
 #include "rpc/messages.hpp"
 #include "slk/serialization.hpp"
 
@@ -82,60 +83,6 @@ struct DemoteMainToReplicaRes {
 
 using DemoteMainToReplicaRpc = rpc::RequestResponse<DemoteMainToReplicaReq, DemoteMainToReplicaRes>;
 
-struct UnregisterReplicaReq {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(UnregisterReplicaReq *self, memgraph::slk::Reader *reader);
-  static void Save(UnregisterReplicaReq const &self, memgraph::slk::Builder *builder);
-
-  explicit UnregisterReplicaReq(std::string instance_name) : instance_name(std::move(instance_name)) {}
-
-  UnregisterReplicaReq() = default;
-
-  std::string instance_name;
-};
-
-struct UnregisterReplicaRes {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(UnregisterReplicaRes *self, memgraph::slk::Reader *reader);
-  static void Save(const UnregisterReplicaRes &self, memgraph::slk::Builder *builder);
-
-  explicit UnregisterReplicaRes(bool success) : success(success) {}
-  UnregisterReplicaRes() = default;
-
-  bool success;
-};
-
-using UnregisterReplicaRpc = rpc::RequestResponse<UnregisterReplicaReq, UnregisterReplicaRes>;
-
-struct EnableWritingOnMainReq {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(EnableWritingOnMainReq *self, memgraph::slk::Reader *reader);
-  static void Save(EnableWritingOnMainReq const &self, memgraph::slk::Builder *builder);
-
-  EnableWritingOnMainReq() = default;
-};
-
-struct EnableWritingOnMainRes {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(EnableWritingOnMainRes *self, memgraph::slk::Reader *reader);
-  static void Save(EnableWritingOnMainRes const &self, memgraph::slk::Builder *builder);
-
-  explicit EnableWritingOnMainRes(bool success) : success(success) {}
-  EnableWritingOnMainRes() = default;
-
-  bool success;
-};
-
-using EnableWritingOnMainRpc = rpc::RequestResponse<EnableWritingOnMainReq, EnableWritingOnMainRes>;
-
 struct GetInstanceUUIDReq {
   static const utils::TypeInfo kType;
   static const utils::TypeInfo &GetTypeInfo() { return kType; }
@@ -144,6 +91,8 @@ struct GetInstanceUUIDReq {
   static void Save(const GetInstanceUUIDReq &self, memgraph::slk::Builder *builder);
 
   GetInstanceUUIDReq() = default;
+
+  bool success;
 };
 
 struct GetInstanceUUIDRes {
@@ -161,6 +110,35 @@ struct GetInstanceUUIDRes {
 
 using GetInstanceUUIDRpc = rpc::RequestResponse<GetInstanceUUIDReq, GetInstanceUUIDRes>;
 
+struct GetInstanceTimestampsReq {
+  static const utils::TypeInfo kType;
+  static const utils::TypeInfo &GetTypeInfo() { return kType; }
+
+  static void Load(GetInstanceTimestampsReq *self, memgraph::slk::Reader *reader);
+  static void Save(const GetInstanceTimestampsReq &self, memgraph::slk::Builder *builder);
+
+  GetInstanceTimestampsReq() = default;
+
+  bool success;
+};
+
+struct GetInstanceTimestampsRes {
+  static const utils::TypeInfo kType;
+  static const utils::TypeInfo &GetTypeInfo() { return kType; }
+
+  static void Load(GetInstanceTimestampsRes *self, memgraph::slk::Reader *reader);
+  static void Save(const GetInstanceTimestampsRes &self, memgraph::slk::Builder *builder);
+
+  explicit GetInstanceTimestampsRes(
+      const std::vector<replication_coordination_glue::ReplicationTimestampResult> &replica_timestamps)
+      : replica_timestamps(replica_timestamps) {}
+  GetInstanceTimestampsRes() = default;
+
+  std::vector<replication_coordination_glue::ReplicationTimestampResult> replica_timestamps;
+};
+
+using GetInstanceTimestampsRpc = rpc::RequestResponse<GetInstanceTimestampsReq, GetInstanceTimestampsRes>;
+
 }  // namespace memgraph::coordination
 
 // SLK serialization declarations
@@ -183,14 +161,12 @@ void Save(const memgraph::coordination::GetInstanceUUIDReq &self, memgraph::slk:
 void Load(memgraph::coordination::GetInstanceUUIDReq *self, memgraph::slk::Reader *reader);
 void Save(const memgraph::coordination::GetInstanceUUIDRes &self, memgraph::slk::Builder *builder);
 void Load(memgraph::coordination::GetInstanceUUIDRes *self, memgraph::slk::Reader *reader);
-// UnregisterReplicaRpc
-void Save(memgraph::coordination::UnregisterReplicaRes const &self, memgraph::slk::Builder *builder);
-void Load(memgraph::coordination::UnregisterReplicaRes *self, memgraph::slk::Reader *reader);
-void Save(memgraph::coordination::UnregisterReplicaReq const &self, memgraph::slk::Builder *builder);
-void Load(memgraph::coordination::UnregisterReplicaReq *self, memgraph::slk::Reader *reader);
 
-void Save(memgraph::coordination::EnableWritingOnMainRes const &self, memgraph::slk::Builder *builder);
-void Load(memgraph::coordination::EnableWritingOnMainRes *self, memgraph::slk::Reader *reader);
+// GetInstanceTimestampsRpc
+void Save(const memgraph::coordination::GetInstanceTimestampsReq &self, memgraph::slk::Builder *builder);
+void Load(memgraph::coordination::GetInstanceTimestampsReq *self, memgraph::slk::Reader *reader);
+void Save(const memgraph::coordination::GetInstanceTimestampsRes &self, memgraph::slk::Builder *builder);
+void Load(memgraph::coordination::GetInstanceTimestampsRes *self, memgraph::slk::Reader *reader);
 
 }  // namespace memgraph::slk
 

src/coordination/include/coordination/coordinator_slk.hpp

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

src/coordination/include/coordination/coordinator_state.hpp

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

src/coordination/include/coordination/raft_state.hpp

@@ -15,6 +15,8 @@
 
 #include <flags/replication.hpp>
 
+#include <optional>
+
 #include <libnuraft/nuraft.hxx>
 
 namespace memgraph::coordination {

src/coordination/include/coordination/register_main_replica_coordinator_status.hpp

@@ -28,18 +28,8 @@ enum class RegisterInstanceCoordinatorStatus : uint8_t {
   SUCCESS
 };
 
-enum class UnregisterInstanceCoordinatorStatus : uint8_t {
-  NO_INSTANCE_WITH_NAME,
-  IS_MAIN,
-  NOT_COORDINATOR,
-  NOT_LEADER,
-  RPC_FAILED,
-  SUCCESS,
-};
-
 enum class SetInstanceToMainCoordinatorStatus : uint8_t {
   NO_INSTANCE_WITH_NAME,
-  MAIN_ALREADY_EXISTS,
   NOT_COORDINATOR,
   SUCCESS,
   COULD_NOT_PROMOTE_TO_MAIN,

src/coordination/include/coordination/replication_instance.hpp

@@ -14,6 +14,7 @@
 #ifdef MG_ENTERPRISE
 
 #include "coordination/coordinator_client.hpp"
+#include "coordination/coordinator_cluster_config.hpp"
 #include "coordination/coordinator_exceptions.hpp"
 #include "replication_coordination_glue/role.hpp"
 
@@ -62,19 +63,13 @@ class ReplicationInstance {
   auto ReplicationClientInfo() const -> ReplClientInfo;
 
   auto EnsureReplicaHasCorrectMainUUID(utils::UUID const &curr_main_uuid) -> bool;
-
   auto SendSwapAndUpdateUUID(const utils::UUID &new_main_uuid) -> bool;
-  auto SendUnregisterReplicaRpc(std::string const &instance_name) -> bool;
-
-
   auto SendGetInstanceUUID() -> utils::BasicResult<coordination::GetInstanceUUIDError, std::optional<utils::UUID>>;
   auto GetClient() -> CoordinatorClient &;
 
-  auto EnableWritingOnMain() -> bool;
-
   auto SetNewMainUUID(utils::UUID const &main_uuid) -> void;
   auto ResetMainUUID() -> void;
-  auto GetMainUUID() const -> const std::optional<utils::UUID> &;
+  auto GetMainUUID() -> const std::optional<utils::UUID> &;
 
  private:
   CoordinatorClient client_;

src/coordination/include/coordination/rpc_errors.hpp

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

src/coordination/replication_instance.cpp

@@ -35,14 +35,15 @@ auto ReplicationInstance::OnSuccessPing() -> void {
 }
 
 auto ReplicationInstance::OnFailPing() -> bool {
-  auto elapsed_time = std::chrono::system_clock::now() - last_response_time_;
-  is_alive_ = elapsed_time < client_.InstanceDownTimeoutSec();
+  is_alive_ =
+      std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - last_response_time_).count() <
+      CoordinatorClusterConfig::alive_response_time_difference_sec_;
   return is_alive_;
 }
 
 auto ReplicationInstance::IsReadyForUUIDPing() -> bool {
-  return std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - last_check_of_uuid_) >
-         client_.InstanceGetUUIDFrequencySec();
+  return std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - last_check_of_uuid_)
+             .count() > CoordinatorClusterConfig::replica_uuid_last_check_time_difference_sec_;
 }
 
 auto ReplicationInstance::InstanceName() const -> std::string { return client_.InstanceName(); }
@@ -91,10 +92,9 @@ auto ReplicationInstance::ReplicationClientInfo() const -> CoordinatorClientConf
 }
 
 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::GetMainUUID() -> const std::optional<utils::UUID> & { return main_uuid_; }
 
 auto ReplicationInstance::EnsureReplicaHasCorrectMainUUID(utils::UUID const &curr_main_uuid) -> bool {
   if (!IsReadyForUUIDPing()) {
@@ -121,15 +121,9 @@ auto ReplicationInstance::SendSwapAndUpdateUUID(const utils::UUID &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();
+  return client_.SendGetInstanceUUID();
 }
 
 void ReplicationInstance::UpdateReplicaLastResponseUUID() { last_check_of_uuid_ = std::chrono::system_clock::now(); }

src/dbms/constants.hpp

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

src/dbms/coordinator_handler.cpp

@@ -25,11 +25,6 @@ auto CoordinatorHandler::RegisterReplicationInstance(memgraph::coordination::Coo
   return coordinator_state_.RegisterReplicationInstance(config);
 }
 
-auto CoordinatorHandler::UnregisterReplicationInstance(std::string instance_name)
-    -> coordination::UnregisterInstanceCoordinatorStatus {
-  return coordinator_state_.UnregisterReplicationInstance(std::move(instance_name));
-}
-
 auto CoordinatorHandler::SetReplicationInstanceToMain(std::string instance_name)
     -> coordination::SetInstanceToMainCoordinatorStatus {
   return coordinator_state_.SetReplicationInstanceToMain(std::move(instance_name));

src/dbms/coordinator_handler.hpp

@@ -28,13 +28,9 @@ class CoordinatorHandler {
  public:
   explicit CoordinatorHandler(coordination::CoordinatorState &coordinator_state);
 
-  // TODO: (andi) When moving coordinator state on same instances, rename from RegisterReplicationInstance to
-  // RegisterInstance
   auto RegisterReplicationInstance(coordination::CoordinatorClientConfig config)
       -> coordination::RegisterInstanceCoordinatorStatus;
 
-  auto UnregisterReplicationInstance(std::string instance_name) -> coordination::UnregisterInstanceCoordinatorStatus;
-
   auto SetReplicationInstanceToMain(std::string instance_name) -> coordination::SetInstanceToMainCoordinatorStatus;
 
   auto ShowInstances() const -> std::vector<coordination::InstanceStatus>;

src/dbms/dbms_handler.cpp

@@ -16,7 +16,6 @@
 
 #include "dbms/constants.hpp"
 #include "dbms/global.hpp"
-#include "flags/experimental.hpp"
 #include "spdlog/spdlog.h"
 #include "system/include/system/system.hpp"
 #include "utils/exceptions.hpp"
@@ -159,9 +158,9 @@ struct Durability {
   }
 };
 
-DbmsHandler::DbmsHandler(storage::Config config, replication::ReplicationState &repl_state, auth::SynchedAuth &auth,
-                         bool recovery_on_startup)
-    : default_config_{std::move(config)}, auth_{auth}, repl_state_{repl_state} {
+DbmsHandler::DbmsHandler(storage::Config config, memgraph::system::System &system,
+                         replication::ReplicationState &repl_state, auth::SynchedAuth &auth, bool recovery_on_startup)
+    : default_config_{std::move(config)}, auth_{auth}, repl_state_{repl_state}, system_{&system} {
   // TODO: Decouple storage config from dbms config
   // TODO: Save individual db configs inside the kvstore and restore from there
 
@@ -420,10 +419,7 @@ void DbmsHandler::UpdateDurability(const storage::Config &config, std::optional<
 #endif
 
 void DbmsHandler::RecoverStorageReplication(DatabaseAccess db_acc, replication::RoleMainData &role_main_data) {
-  using enum memgraph::flags::Experiments;
-  auto const is_enterprise = license::global_license_checker.IsEnterpriseValidFast();
-  auto experimental_system_replication = flags::AreExperimentsEnabled(SYSTEM_REPLICATION);
-  if ((is_enterprise && experimental_system_replication) || db_acc->name() == dbms::kDefaultDB) {
+  if (allow_mt_repl || db_acc->name() == dbms::kDefaultDB) {
     // Handle global replication state
     spdlog::info("Replication configuration will be stored and will be automatically restored in case of a crash.");
     // RECOVER REPLICA CONNECTIONS

src/dbms/dbms_handler.hpp

@@ -107,7 +107,8 @@ class DbmsHandler {
    * @param auth pointer to the global authenticator
    * @param recovery_on_startup restore databases (and its content) and authentication data
    */
-  DbmsHandler(storage::Config config, replication::ReplicationState &repl_state, auth::SynchedAuth &auth,
+  DbmsHandler(storage::Config config, memgraph::system::System &system, replication::ReplicationState &repl_state,
+              auth::SynchedAuth &auth,
               bool recovery_on_startup);  // TODO If more arguments are added use a config struct
 #else
   /**
@@ -115,8 +116,9 @@ class DbmsHandler {
    *
    * @param configs storage configuration
    */
-  DbmsHandler(storage::Config config, replication::ReplicationState &repl_state)
+  DbmsHandler(storage::Config config, memgraph::system::System &system, replication::ReplicationState &repl_state)
       : repl_state_{repl_state},
+        system_{&system},
         db_gatekeeper_{[&] {
                          config.salient.name = kDefaultDB;
                          return std::move(config);
@@ -266,24 +268,6 @@ class DbmsHandler {
   bool IsMain() const { return repl_state_.IsMain(); }
   bool IsReplica() const { return repl_state_.IsReplica(); }
 
-#ifdef MG_ENTERPRISE
-  // coordination::CoordinatorState &CoordinatorState() { return coordinator_state_; }
-#endif
-
-  /**
-   * @brief Return all active databases.
-   *
-   * @return std::vector<std::string>
-   */
-  auto Count() const -> std::size_t {
-#ifdef MG_ENTERPRISE
-    std::shared_lock<LockT> rd(lock_);
-    return db_handler_.size();
-#else
-    return 1;
-#endif
-  }
-
   /**
    * @brief Return the statistics all databases.
    *
@@ -599,6 +583,9 @@ class DbmsHandler {
   //       current replication role. TODO: make Database Access explicit about the role and remove this from
   //       dbms stuff
   replication::ReplicationState &repl_state_;  //!< Ref to global replication state
+ public:
+  // TODO fix to be non public/remove from dbms....maybe
+  system::System *system_;
 
 #ifndef MG_ENTERPRISE
   mutable utils::Gatekeeper<Database> db_gatekeeper_;  //!< Single databases gatekeeper

src/dbms/handler.hpp

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

src/dbms/inmemory/replication_handlers.cpp

@@ -19,7 +19,6 @@
 #include "storage/v2/durability/durability.hpp"
 #include "storage/v2/durability/snapshot.hpp"
 #include "storage/v2/durability/version.hpp"
-#include "storage/v2/fmt.hpp"
 #include "storage/v2/indices/label_index_stats.hpp"
 #include "storage/v2/inmemory/storage.hpp"
 #include "storage/v2/inmemory/unique_constraints.hpp"

src/distributed/include/distributed/lamport_clock.hpp

@@ -10,7 +10,6 @@
 // licenses/APL.txt.
 #pragma once
 
-#include <algorithm>
 #include <atomic>
 #include <compare>
 #include <cstdint>

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,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.
-
-#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, high-availability]");
-
-using namespace std::string_view_literals;
-
-namespace memgraph::flags {
-
-auto const mapping = std::map{std::pair{"system-replication"sv, Experiments::SYSTEM_REPLICATION},
-                              std::pair{"high-availability"sv, Experiments::HIGH_AVAILABILITY}};
-
-auto ExperimentsInstance() -> Experiments & {
-  static auto instance = Experiments{};
-  return instance;
-}
-
-bool AreExperimentsEnabled(Experiments experiments) {
-  using t = std::underlying_type_t<Experiments>;
-
-  auto actual = static_cast<t>(ExperimentsInstance());
-  auto check = static_cast<t>(experiments);
-
-  return (actual & check) == check;
-}
-
-void InitializeExperimental() {
-  namespace rv = ranges::views;
-
-  auto const connonicalize_string = [](auto &&rng) {
-    auto const is_space = [](auto c) { return c == ' '; };
-    auto const to_lower = [](unsigned char c) { return std::tolower(c); };
-
-    return rng | rv::drop_while(is_space) | rv::take_while(std::not_fn(is_space)) | rv::transform(to_lower) |
-           ranges::to<std::string>;
-  };
-
-  auto const mapping_end = mapping.cend();
-  using underlying_type = std::underlying_type_t<Experiments>;
-  auto to_set = underlying_type{};
-  for (auto &&experiment : FLAGS_experimental_enabled | rv::split(',') | rv::transform(connonicalize_string)) {
-    if (auto it = mapping.find(experiment); it != mapping_end) {
-      to_set |= static_cast<underlying_type>(it->second);
-    }
-  }
-
-  ExperimentsInstance() = static_cast<Experiments>(to_set);
-}
-
-}  // namespace memgraph::flags

src/flags/experimental.hpp

@@ -1,33 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include "gflags/gflags.h"
-
-// Short help flag.
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_string(experimental_enabled);
-
-namespace memgraph::flags {
-
-// Each bit is an enabled experiment
-// old experiments can be reused once code cleanup has happened
-enum class Experiments : uint8_t {
-  SYSTEM_REPLICATION = 1 << 0,
-  HIGH_AVAILABILITY = 1 << 1,
-};
-
-bool AreExperimentsEnabled(Experiments experiments);
-
-void InitializeExperimental();
-
-}  // namespace memgraph::flags

src/flags/replication.cpp

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

src/flags/replication.hpp

@@ -20,12 +20,6 @@ DECLARE_uint32(coordinator_server_port);
 DECLARE_uint32(raft_server_port);
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DECLARE_uint32(raft_server_id);
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_uint32(instance_down_timeout_sec);
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_uint32(instance_health_check_frequency_sec);
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_uint32(instance_get_uuid_frequency_sec);
 #endif
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)

src/integrations/kafka/consumer.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
@@ -22,7 +22,6 @@
 
 #include "integrations/constants.hpp"
 #include "integrations/kafka/exceptions.hpp"
-#include "integrations/kafka/fmt.hpp"
 #include "utils/exceptions.hpp"
 #include "utils/logging.hpp"
 #include "utils/on_scope_exit.hpp"

src/integrations/kafka/fmt.hpp

@@ -1,25 +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
-
-#if FMT_VERSION > 90000
-#include <fmt/ostream.h>
-
-#include <librdkafka/rdkafkacpp.h>
-
-inline std::ostream &operator<<(std::ostream &os, const RdKafka::ErrorCode &code) {
-  os << RdKafka::err2str(code);
-  return os;
-}
-template <>
-class fmt::formatter<RdKafka::ErrorCode> : public fmt::ostream_formatter {};
-#endif

src/integrations/pulsar/consumer.cpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -15,12 +15,12 @@
 #include <chrono>
 #include <thread>
 
+#include <fmt/format.h>
 #include <pulsar/Client.h>
 #include <pulsar/InitialPosition.h>
 
 #include "integrations/constants.hpp"
 #include "integrations/pulsar/exceptions.hpp"
-#include "integrations/pulsar/fmt.hpp"
 #include "utils/concepts.hpp"
 #include "utils/logging.hpp"
 #include "utils/on_scope_exit.hpp"

src/io/network/stream_buffer.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 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
@@ -11,7 +11,6 @@
 
 #pragma once
 
-#include <cstddef>
 #include <cstdint>
 
 namespace memgraph::io::network {

src/kvstore/kvstore.hpp

@@ -160,14 +160,13 @@ class KVStore final {
    * and behaves as if all of those pairs are stored in a single iterable
    * collection of std::pair<std::string, std::string>.
    */
-  class iterator final {
+  class iterator final : public std::iterator<std::input_iterator_tag,                      // iterator_category
+                                              std::pair<std::string, std::string>,          // value_type
+                                              long,                                         // difference_type
+                                              const std::pair<std::string, std::string> *,  // pointer
+                                              const std::pair<std::string, std::string> &   // reference
+                                              > {
    public:
-    using iterator_concept [[maybe_unused]] = std::input_iterator_tag;
-    using value_type = std::pair<std::string, std::string>;
-    using difference_type = long;
-    using pointer = const std::pair<std::string, std::string> *;
-    using reference = const std::pair<std::string, std::string> &;
-
     explicit iterator(const KVStore *kvstore, const std::string &prefix = "", bool at_end = false);
 
     iterator(const iterator &other) = delete;

src/memgraph.cpp

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

src/memory/global_memory_control.cpp

@@ -61,12 +61,10 @@ void *my_alloc(extent_hooks_t *extent_hooks, void *new_addr, size_t size, size_t
   // This needs to be before, to throw exception in case of too big alloc
   if (*commit) [[likely]] {
     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;
+    memgraph::utils::total_memory_tracker.Alloc(static_cast<int64_t>(size));
   }
 
   auto *ptr = old_hooks->alloc(extent_hooks, new_addr, size, alignment, zero, commit, arena_ind);
@@ -120,14 +118,10 @@ 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{};
   if (GetQueriesMemoryControl().IsThreadTracked()) [[unlikely]] {
-    bool ok = GetQueriesMemoryControl().TrackAllocOnCurrentThread(length);
-    DMG_ASSERT(ok);
+    GetQueriesMemoryControl().TrackAllocOnCurrentThread(length);
   }
-
-  auto ok = memgraph::utils::total_memory_tracker.Alloc(static_cast<int64_t>(length));
-  DMG_ASSERT(ok);
+  memgraph::utils::total_memory_tracker.Alloc(static_cast<int64_t>(length));
 
   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) {

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

@@ -139,11 +139,6 @@ struct NodeId {
   std::string id_space;
 };
 
-#if FMT_VERSION > 90000
-template <>
-class fmt::formatter<NodeId> : public fmt::ostream_formatter {};
-#endif
-
 bool operator==(const NodeId &a, const NodeId &b) { return a.id == b.id && a.id_space == b.id_space; }
 
 std::ostream &operator<<(std::ostream &stream, const NodeId &node_id) {

src/py/py.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 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
@@ -274,8 +274,3 @@ inline void RestoreError(ExceptionInfo exc_info) {
 }
 
 }  // namespace memgraph::py
-
-#if FMT_VERSION > 90000
-template <>
-class fmt::formatter<memgraph::py::ExceptionInfo> : public fmt::ostream_formatter {};
-#endif

src/query/common.hpp

@@ -19,7 +19,6 @@
 
 #include "query/db_accessor.hpp"
 #include "query/exceptions.hpp"
-#include "query/fmt.hpp"
 #include "query/frontend/ast/ast.hpp"
 #include "query/frontend/semantic/symbol.hpp"
 #include "query/typed_value.hpp"

src/query/config.hpp

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

src/query/db_accessor.hpp

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

src/query/fmt.hpp

@@ -1,23 +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
-
-#if FMT_VERSION > 90000
-#include <fmt/ostream.h>
-
-#include "query/typed_value.hpp"
-
-template <>
-class fmt::formatter<memgraph::query::TypedValue> : public fmt::ostream_formatter {};
-template <>
-class fmt::formatter<memgraph::query::TypedValue::Type> : public fmt::ostream_formatter {};
-#endif

src/query/frontend/ast/ast.hpp

@@ -3034,7 +3034,7 @@ class ReplicationQuery : public memgraph::query::Query {
 
   enum class SyncMode { SYNC, ASYNC };
 
-  enum class ReplicaState { READY, REPLICATING, RECOVERY, MAYBE_BEHIND, DIVERGED_FROM_MAIN };
+  enum class ReplicaState { READY, REPLICATING, RECOVERY, MAYBE_BEHIND };
 
   ReplicationQuery() = default;
 
@@ -3071,13 +3071,7 @@ class CoordinatorQuery : public memgraph::query::Query {
   static const utils::TypeInfo kType;
   const utils::TypeInfo &GetTypeInfo() const override { return kType; }
 
-  enum class Action {
-    REGISTER_INSTANCE,
-    UNREGISTER_INSTANCE,
-    SET_INSTANCE_TO_MAIN,
-    SHOW_INSTANCES,
-    ADD_COORDINATOR_INSTANCE
-  };
+  enum class Action { REGISTER_INSTANCE, SET_INSTANCE_TO_MAIN, SHOW_INSTANCES, ADD_COORDINATOR_INSTANCE };
 
   enum class SyncMode { SYNC, ASYNC };
 

src/query/frontend/ast/cypher_main_visitor.cpp

@@ -399,14 +399,6 @@ antlrcpp::Any CypherMainVisitor::visitRegisterInstanceOnCoordinator(
   return coordinator_query;
 }
 
-antlrcpp::Any CypherMainVisitor::visitUnregisterInstanceOnCoordinator(
-    MemgraphCypher::UnregisterInstanceOnCoordinatorContext *ctx) {
-  auto *coordinator_query = storage_->Create<CoordinatorQuery>();
-  coordinator_query->action_ = CoordinatorQuery::Action::UNREGISTER_INSTANCE;
-  coordinator_query->instance_name_ = std::any_cast<std::string>(ctx->instanceName()->symbolicName()->accept(this));
-  return coordinator_query;
-}
-
 antlrcpp::Any CypherMainVisitor::visitAddCoordinatorInstance(MemgraphCypher::AddCoordinatorInstanceContext *ctx) {
   auto *coordinator_query = storage_->Create<CoordinatorQuery>();
 

src/query/frontend/ast/cypher_main_visitor.hpp

@@ -243,12 +243,6 @@ class CypherMainVisitor : public antlropencypher::MemgraphCypherBaseVisitor {
    */
   antlrcpp::Any visitRegisterInstanceOnCoordinator(MemgraphCypher::RegisterInstanceOnCoordinatorContext *ctx) override;
 
-  /**
-   * @return CoordinatorQuery*
-   */
-  antlrcpp::Any visitUnregisterInstanceOnCoordinator(
-      MemgraphCypher::UnregisterInstanceOnCoordinatorContext *ctx) override;
-
   /**
    * @return CoordinatorQuery*
    */

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

@@ -190,7 +190,6 @@ replicationQuery : setReplicationRole
                  ;
 
 coordinatorQuery : registerInstanceOnCoordinator
-                 | unregisterInstanceOnCoordinator
                  | setInstanceToMain
                  | showInstances
                  | addCoordinatorInstance
@@ -393,8 +392,6 @@ registerReplica : REGISTER REPLICA instanceName ( SYNC | ASYNC )
 
 registerInstanceOnCoordinator : REGISTER INSTANCE instanceName ON coordinatorSocketAddress ( AS ASYNC ) ? WITH replicationSocketAddress ;
 
-unregisterInstanceOnCoordinator : UNREGISTER INSTANCE instanceName ;
-
 setInstanceToMain : SET INSTANCE instanceName TO MAIN ;
 
 raftServerId : literal ;

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

@@ -141,7 +141,6 @@ TRIGGER                 : T R I G G E R ;
 TRIGGERS                : T R I G G E R S ;
 UNCOMMITTED             : U N C O M M I T T E D ;
 UNLOCK                  : U N L O C K ;
-UNREGISTER              : U N R E G I S T E R ;
 UPDATE                  : U P D A T E ;
 USE                     : U S E ;
 USER                    : U S E R ;

src/query/interpret/awesome_memgraph_functions.cpp

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

src/query/interpreter.cpp

@@ -93,7 +93,6 @@
 #include "utils/exceptions.hpp"
 #include "utils/file.hpp"
 #include "utils/flag_validation.hpp"
-#include "utils/functional.hpp"
 #include "utils/likely.hpp"
 #include "utils/logging.hpp"
 #include "utils/memory.hpp"
@@ -109,7 +108,7 @@
 #include "utils/variant_helpers.hpp"
 
 #ifdef MG_ENTERPRISE
-#include "flags/experimental.hpp"
+#include "coordination/constants.hpp"
 #endif
 
 namespace memgraph::metrics {
@@ -369,7 +368,7 @@ class ReplQueryHandler {
                                                .replica_check_frequency = replica_check_frequency,
                                                .ssl = std::nullopt};
 
-      const auto error = handler_->TryRegisterReplica(replication_config).HasError();
+      const auto error = handler_->TryRegisterReplica(replication_config, true).HasError();
 
       if (error) {
         throw QueryRuntimeException(fmt::format("Couldn't register replica '{}'!", name));
@@ -438,9 +437,6 @@ class ReplQueryHandler {
         case storage::replication::ReplicaState::MAYBE_BEHIND:
           replica.state = ReplicationQuery::ReplicaState::MAYBE_BEHIND;
           break;
-        case storage::replication::ReplicaState::DIVERGED_FROM_MAIN:
-          replica.state = ReplicationQuery::ReplicaState::DIVERGED_FROM_MAIN;
-          break;
       }
 
       return replica;
@@ -461,33 +457,11 @@ class CoordQueryHandler final : public query::CoordinatorQueryHandler {
 
       : coordinator_handler_(coordinator_state) {}
 
-  void UnregisterInstance(std::string const &instance_name) override {
-    auto status = coordinator_handler_.UnregisterReplicationInstance(instance_name);
-    switch (status) {
-      using enum memgraph::coordination::UnregisterInstanceCoordinatorStatus;
-      case NO_INSTANCE_WITH_NAME:
-        throw QueryRuntimeException("No instance with such name!");
-      case IS_MAIN:
-        throw QueryRuntimeException(
-            "Alive main instance can't be unregistered! Shut it down to trigger failover and then unregister it!");
-      case NOT_COORDINATOR:
-        throw QueryRuntimeException("UNREGISTER INSTANCE query can only be run on a coordinator!");
-      case NOT_LEADER:
-        throw QueryRuntimeException("Couldn't unregister replica instance since coordinator is not a leader!");
-      case RPC_FAILED:
-        throw QueryRuntimeException(
-            "Couldn't unregister replica instance because current main instance couldn't unregister replica!");
-      case SUCCESS:
-        break;
-    }
-  }
-
-  void RegisterReplicationInstance(std::string const &coordinator_socket_address,
-                                   std::string const &replication_socket_address,
-                                   std::chrono::seconds const &instance_check_frequency,
-                                   std::chrono::seconds const &instance_down_timeout,
-                                   std::chrono::seconds const &instance_get_uuid_frequency,
-                                   std::string const &instance_name, CoordinatorQuery::SyncMode sync_mode) override {
+  /// @throw QueryRuntimeException if an error ocurred.
+  void RegisterReplicationInstance(const std::string &coordinator_socket_address,
+                                   const std::string &replication_socket_address,
+                                   const std::chrono::seconds instance_check_frequency,
+                                   const std::string &instance_name, CoordinatorQuery::SyncMode sync_mode) override {
     const auto maybe_replication_ip_port =
         io::network::Endpoint::ParseSocketOrAddress(replication_socket_address, std::nullopt);
     if (!maybe_replication_ip_port) {
@@ -512,9 +486,7 @@ class CoordQueryHandler final : public query::CoordinatorQueryHandler {
         coordination::CoordinatorClientConfig{.instance_name = instance_name,
                                               .ip_address = coordinator_server_ip,
                                               .port = coordinator_server_port,
-                                              .instance_health_check_frequency_sec = instance_check_frequency,
-                                              .instance_down_timeout_sec = instance_down_timeout,
-                                              .instance_get_uuid_frequency_sec = instance_get_uuid_frequency,
+                                              .health_check_frequency_sec = instance_check_frequency,
                                               .replication_client_info = repl_config,
                                               .ssl = std::nullopt};
 
@@ -562,8 +534,6 @@ class CoordQueryHandler final : public query::CoordinatorQueryHandler {
       using enum memgraph::coordination::SetInstanceToMainCoordinatorStatus;
       case NO_INSTANCE_WITH_NAME:
         throw QueryRuntimeException("No instance with such name!");
-      case MAIN_ALREADY_EXISTS:
-        throw QueryRuntimeException("Couldn't set instance to main since there is already a main instance in cluster!");
       case NOT_COORDINATOR:
         throw QueryRuntimeException("SET INSTANCE TO MAIN query can only be run on a coordinator!");
       case COULD_NOT_PROMOTE_TO_MAIN:
@@ -1112,9 +1082,6 @@ Callback HandleReplicationQuery(ReplicationQuery *repl_query, const Parameters &
             case ReplicationQuery::ReplicaState::MAYBE_BEHIND:
               typed_replica.emplace_back("invalid");
               break;
-            case ReplicationQuery::ReplicaState::DIVERGED_FROM_MAIN:
-              typed_replica.emplace_back("diverged");
-              break;
           }
 
           typed_replicas.emplace_back(std::move(typed_replica));
@@ -1130,21 +1097,17 @@ Callback HandleReplicationQuery(ReplicationQuery *repl_query, const Parameters &
 Callback HandleCoordinatorQuery(CoordinatorQuery *coordinator_query, const Parameters &parameters,
                                 coordination::CoordinatorState *coordinator_state,
                                 const query::InterpreterConfig &config, std::vector<Notification> *notifications) {
-  using enum memgraph::flags::Experiments;
-
-  if (!license::global_license_checker.IsEnterpriseValidFast()) {
-    throw QueryRuntimeException("High availability is only available in Memgraph Enterprise.");
-  }
-
-  if (!flags::AreExperimentsEnabled(HIGH_AVAILABILITY)) {
-    throw QueryRuntimeException(
-        "High availability is experimental feature. If you want to use it, add high-availability option to the "
-        "--experimental-enabled flag.");
-  }
-
   Callback callback;
   switch (coordinator_query->action_) {
     case CoordinatorQuery::Action::ADD_COORDINATOR_INSTANCE: {
+      if (!license::global_license_checker.IsEnterpriseValidFast()) {
+        throw QueryException("Trying to use enterprise feature without a valid license.");
+      }
+      if constexpr (!coordination::allow_ha) {
+        throw QueryRuntimeException(
+            "High availability is experimental feature. Please set MG_EXPERIMENTAL_HIGH_AVAILABILITY compile flag to "
+            "be able to use this functionality.");
+      }
       if (!FLAGS_raft_server_id) {
         throw QueryRuntimeException("Only coordinator can add coordinator instance!");
       }
@@ -1168,6 +1131,15 @@ Callback HandleCoordinatorQuery(CoordinatorQuery *coordinator_query, const Param
       return callback;
     }
     case CoordinatorQuery::Action::REGISTER_INSTANCE: {
+      if (!license::global_license_checker.IsEnterpriseValidFast()) {
+        throw QueryException("Trying to use enterprise feature without a valid license.");
+      }
+
+      if constexpr (!coordination::allow_ha) {
+        throw QueryRuntimeException(
+            "High availability is experimental feature. Please set MG_EXPERIMENTAL_HIGH_AVAILABILITY compile flag to "
+            "be able to use this functionality.");
+      }
       if (!FLAGS_raft_server_id) {
         throw QueryRuntimeException("Only coordinator can register coordinator server!");
       }
@@ -1179,16 +1151,12 @@ Callback HandleCoordinatorQuery(CoordinatorQuery *coordinator_query, const Param
       auto coordinator_socket_address_tv = coordinator_query->coordinator_socket_address_->Accept(evaluator);
       auto replication_socket_address_tv = coordinator_query->replication_socket_address_->Accept(evaluator);
       callback.fn = [handler = CoordQueryHandler{*coordinator_state}, coordinator_socket_address_tv,
-                     replication_socket_address_tv,
-                     instance_health_check_frequency_sec = config.instance_health_check_frequency_sec,
+                     replication_socket_address_tv, main_check_frequency = config.replication_replica_check_frequency,
                      instance_name = coordinator_query->instance_name_,
-                     instance_down_timeout_sec = config.instance_down_timeout_sec,
-                     instance_get_uuid_frequency_sec = config.instance_get_uuid_frequency_sec,
                      sync_mode = coordinator_query->sync_mode_]() mutable {
         handler.RegisterReplicationInstance(std::string(coordinator_socket_address_tv.ValueString()),
                                             std::string(replication_socket_address_tv.ValueString()),
-                                            instance_health_check_frequency_sec, instance_down_timeout_sec,
-                                            instance_get_uuid_frequency_sec, instance_name, sync_mode);
+                                            main_check_frequency, instance_name, sync_mode);
         return std::vector<std::vector<TypedValue>>();
       };
 
@@ -1198,22 +1166,15 @@ Callback HandleCoordinatorQuery(CoordinatorQuery *coordinator_query, const Param
                       coordinator_socket_address_tv.ValueString(), coordinator_query->instance_name_));
       return callback;
     }
-    case CoordinatorQuery::Action::UNREGISTER_INSTANCE:
-      if (!FLAGS_raft_server_id) {
-        throw QueryRuntimeException("Only coordinator can register coordinator server!");
-      }
-      callback.fn = [handler = CoordQueryHandler{*coordinator_state},
-                     instance_name = coordinator_query->instance_name_]() mutable {
-        handler.UnregisterInstance(instance_name);
-        return std::vector<std::vector<TypedValue>>();
-      };
-      notifications->emplace_back(
-          SeverityLevel::INFO, NotificationCode::UNREGISTER_INSTANCE,
-          fmt::format("Coordinator has unregistered instance {}.", coordinator_query->instance_name_));
-
-      return callback;
-
     case CoordinatorQuery::Action::SET_INSTANCE_TO_MAIN: {
+      if (!license::global_license_checker.IsEnterpriseValidFast()) {
+        throw QueryException("Trying to use enterprise feature without a valid license.");
+      }
+      if constexpr (!coordination::allow_ha) {
+        throw QueryRuntimeException(
+            "High availability is experimental feature. Please set MG_EXPERIMENTAL_HIGH_AVAILABILITY compile flag to "
+            "be able to use this functionality.");
+      }
       if (!FLAGS_raft_server_id) {
         throw QueryRuntimeException("Only coordinator can register coordinator server!");
       }
@@ -1231,6 +1192,14 @@ Callback HandleCoordinatorQuery(CoordinatorQuery *coordinator_query, const Param
       return callback;
     }
     case CoordinatorQuery::Action::SHOW_INSTANCES: {
+      if (!license::global_license_checker.IsEnterpriseValidFast()) {
+        throw QueryException("Trying to use enterprise feature without a valid license.");
+      }
+      if constexpr (!coordination::allow_ha) {
+        throw QueryRuntimeException(
+            "High availability is experimental feature. Please set MG_EXPERIMENTAL_HIGH_AVAILABILITY compile flag to "
+            "be able to use this functionality.");
+      }
       if (!FLAGS_raft_server_id) {
         throw QueryRuntimeException("Only coordinator can run SHOW INSTANCES.");
       }
@@ -1239,13 +1208,17 @@ Callback HandleCoordinatorQuery(CoordinatorQuery *coordinator_query, const Param
       callback.fn = [handler = CoordQueryHandler{*coordinator_state},
                      replica_nfields = callback.header.size()]() mutable {
         auto const instances = handler.ShowInstances();
-        auto const converter = [](const auto &status) -> std::vector<TypedValue> {
-          return {TypedValue{status.instance_name}, TypedValue{status.raft_socket_address},
-                  TypedValue{status.coord_socket_address}, TypedValue{status.is_alive},
-                  TypedValue{status.cluster_role}};
-        };
+        std::vector<std::vector<TypedValue>> result{};
+        result.reserve(result.size());
 
-        return utils::fmap(converter, instances);
+        std::ranges::transform(instances, std::back_inserter(result),
+                               [](const auto &status) -> std::vector<TypedValue> {
+                                 return {TypedValue{status.instance_name}, TypedValue{status.raft_socket_address},
+                                         TypedValue{status.coord_socket_address}, TypedValue{status.is_alive},
+                                         TypedValue{status.cluster_role}};
+                               });
+
+        return result;
       };
       return callback;
     }
@@ -3908,9 +3881,7 @@ PreparedQuery PrepareMultiDatabaseQuery(ParsedQuery parsed_query, CurrentDB &cur
       if (current_db.in_explicit_db_) {
         throw QueryException("Database switching is prohibited if session explicitly defines the used database");
       }
-
-      using enum memgraph::flags::Experiments;
-      if (!flags::AreExperimentsEnabled(SYSTEM_REPLICATION) && is_replica) {
+      if (!dbms::allow_mt_repl && is_replica) {
         throw QueryException("Query forbidden on the replica!");
       }
       return PreparedQuery{{"STATUS"},
@@ -4375,19 +4346,9 @@ Interpreter::PrepareResult Interpreter::Prepare(const std::string &query_string,
 
     UpdateTypeCount(rw_type);
 
-    bool const write_query = IsQueryWrite(rw_type);
-    if (write_query) {
-      if (interpreter_context_->repl_state->IsReplica()) {
-        query_execution = nullptr;
-        throw QueryException("Write query forbidden on the replica!");
-      }
-#ifdef MG_ENTERPRISE
-      if (FLAGS_coordinator_server_port && !interpreter_context_->repl_state->IsMainWriteable()) {
-        query_execution = nullptr;
-        throw QueryException(
-            "Write query forbidden on the main! Coordinator needs to enable writing on main by sending RPC message.");
-      }
-#endif
+    if (interpreter_context_->repl_state->IsReplica() && IsQueryWrite(rw_type)) {
+      query_execution = nullptr;
+      throw QueryException("Write query forbidden on the replica!");
     }
 
     // Set the target db to the current db (some queries have different target from the current db)
@@ -4574,8 +4535,7 @@ void Interpreter::Commit() {
     auto const main_commit = [&](replication::RoleMainData &mainData) {
     // Only enterprise can do system replication
 #ifdef MG_ENTERPRISE
-      using enum memgraph::flags::Experiments;
-      if (flags::AreExperimentsEnabled(SYSTEM_REPLICATION) && license::global_license_checker.IsEnterpriseValidFast()) {
+      if (license::global_license_checker.IsEnterpriseValidFast()) {
         return system_transaction_->Commit(memgraph::system::DoReplication{mainData});
       }
 #endif

src/query/interpreter.hpp

@@ -105,15 +105,10 @@ class CoordinatorQueryHandler {
   };
 
   /// @throw QueryRuntimeException if an error ocurred.
-  virtual void RegisterReplicationInstance(std::string const &coordinator_socket_address,
-                                           std::string const &replication_socket_address,
-                                           std::chrono::seconds const &instance_health_check_frequency,
-                                           std::chrono::seconds const &instance_down_timeout,
-                                           std::chrono::seconds const &instance_get_uuid_frequency,
-                                           std::string const &instance_name, CoordinatorQuery::SyncMode sync_mode) = 0;
-
-  /// @throw QueryRuntimeException if an error ocurred.
-  virtual void UnregisterInstance(std::string const &instance_name) = 0;
+  virtual void RegisterReplicationInstance(const std::string &coordinator_socket_address,
+                                           const std::string &replication_socket_address,
+                                           const std::chrono::seconds instance_check_frequency,
+                                           const std::string &instance_name, CoordinatorQuery::SyncMode sync_mode) = 0;
 
   /// @throw QueryRuntimeException if an error ocurred.
   virtual void SetReplicationInstanceToMain(const std::string &instance_name) = 0;

src/query/metadata.cpp

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

src/query/metadata.hpp

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

src/query/plan/preprocess.cpp

@@ -313,7 +313,7 @@ void Filters::CollectPatternFilters(Pattern &pattern, SymbolTable &symbol_table,
           auto *property_lookup = storage.Create<PropertyLookup>(atom->filter_lambda_.inner_edge, prop_pair.first);
           auto *prop_equal = storage.Create<EqualOperator>(property_lookup, prop_pair.second);
           // Currently, variable expand has no gains if we set PropertyFilter.
-          all_filters_.emplace_back(FilterInfo::Type::Generic, prop_equal, collector.symbols_);
+          all_filters_.emplace_back(FilterInfo{FilterInfo::Type::Generic, prop_equal, collector.symbols_});
         }
         {
           collector.symbols_.clear();
@@ -328,9 +328,9 @@ void Filters::CollectPatternFilters(Pattern &pattern, SymbolTable &symbol_table,
           auto *prop_equal = storage.Create<EqualOperator>(property_lookup, prop_pair.second);
           // Currently, variable expand has no gains if we set PropertyFilter.
           all_filters_.emplace_back(
-              FilterInfo::Type::Generic,
-              storage.Create<All>(identifier, atom->identifier_, storage.Create<Where>(prop_equal)),
-              collector.symbols_);
+              FilterInfo{FilterInfo::Type::Generic,
+                         storage.Create<All>(identifier, atom->identifier_, storage.Create<Where>(prop_equal)),
+                         collector.symbols_});
         }
       }
       return;
@@ -639,12 +639,6 @@ void AddMatching(const Match &match, SymbolTable &symbol_table, AstStorage &stor
   }
 }
 
-PatternFilterVisitor::PatternFilterVisitor(SymbolTable &symbol_table, AstStorage &storage)
-    : symbol_table_(symbol_table), storage_(storage) {}
-PatternFilterVisitor::PatternFilterVisitor(const PatternFilterVisitor &) = default;
-PatternFilterVisitor::PatternFilterVisitor(PatternFilterVisitor &&) noexcept = default;
-PatternFilterVisitor::~PatternFilterVisitor() = default;
-
 void PatternFilterVisitor::Visit(Exists &op) {
   std::vector<Pattern *> patterns;
   patterns.push_back(op.pattern_);
@@ -658,8 +652,6 @@ void PatternFilterVisitor::Visit(Exists &op) {
   matchings_.push_back(std::move(filter_matching));
 }
 
-std::vector<FilterMatching> PatternFilterVisitor::getMatchings() { return matchings_; }
-
 static void ParseForeach(query::Foreach &foreach, SingleQueryPart &query_part, AstStorage &storage,
                          SymbolTable &symbol_table) {
   for (auto *clause : foreach.clauses_) {
@@ -731,18 +723,4 @@ QueryParts CollectQueryParts(SymbolTable &symbol_table, AstStorage &storage, Cyp
   return QueryParts{query_parts, distinct};
 }
 
-FilterInfo::FilterInfo(Type type, Expression *expression, std::unordered_set<Symbol> used_symbols,
-                       std::optional<PropertyFilter> property_filter, std::optional<IdFilter> id_filter)
-    : type(type),
-      expression(expression),
-      used_symbols(std::move(used_symbols)),
-      property_filter(std::move(property_filter)),
-      id_filter(std::move(id_filter)),
-      matchings({}) {}
-FilterInfo::FilterInfo(const FilterInfo &) = default;
-FilterInfo &FilterInfo::operator=(const FilterInfo &) = default;
-FilterInfo::FilterInfo(FilterInfo &&) noexcept = default;
-FilterInfo &FilterInfo::operator=(FilterInfo &&) noexcept = default;
-FilterInfo::~FilterInfo() = default;
-
 }  // namespace memgraph::query::plan

src/query/plan/preprocess.hpp

@@ -19,7 +19,6 @@
 #include <vector>
 
 #include "query/frontend/ast/ast.hpp"
-#include "query/frontend/ast/ast_visitor.hpp"
 #include "query/frontend/semantic/symbol_table.hpp"
 
 namespace memgraph::query::plan {
@@ -160,12 +159,8 @@ enum class PatternFilterType { EXISTS };
 /// Collects matchings from filters that include patterns
 class PatternFilterVisitor : public ExpressionVisitor<void> {
  public:
-  explicit PatternFilterVisitor(SymbolTable &symbol_table, AstStorage &storage);
-  PatternFilterVisitor(const PatternFilterVisitor &);
-  PatternFilterVisitor &operator=(const PatternFilterVisitor &) = delete;
-  PatternFilterVisitor(PatternFilterVisitor &&) noexcept;
-  PatternFilterVisitor &operator=(PatternFilterVisitor &&) noexcept = delete;
-  ~PatternFilterVisitor() override;
+  explicit PatternFilterVisitor(SymbolTable &symbol_table, AstStorage &storage)
+      : symbol_table_(symbol_table), storage_(storage) {}
 
   using ExpressionVisitor<void>::Visit;
 
@@ -237,7 +232,7 @@ class PatternFilterVisitor : public ExpressionVisitor<void> {
   void Visit(RegexMatch &op) override{};
   void Visit(PatternComprehension &op) override{};
 
-  std::vector<FilterMatching> getMatchings();
+  std::vector<FilterMatching> getMatchings() { return matchings_; }
 
   SymbolTable &symbol_table_;
   AstStorage &storage_;
@@ -303,23 +298,9 @@ struct FilterInfo {
   /// elements.
   enum class Type { Generic, Label, Property, Id, Pattern };
 
-  // FilterInfo is tricky because FilterMatching is not yet defined:
-  //   * if no declared constructor -> FilterInfo is std::__is_complete_or_unbounded
-  //   * if any user-declared constructor -> non-aggregate type -> no designated initializers are possible
-  //   * IMPORTANT: Matchings will always be initialized to an empty container.
-  explicit FilterInfo(Type type = Type::Generic, Expression *expression = nullptr,
-                      std::unordered_set<Symbol> used_symbols = {}, std::optional<PropertyFilter> property_filter = {},
-                      std::optional<IdFilter> id_filter = {});
-  // All other constructors are also defined in the cpp file because this struct is incomplete here.
-  FilterInfo(const FilterInfo &);
-  FilterInfo &operator=(const FilterInfo &);
-  FilterInfo(FilterInfo &&) noexcept;
-  FilterInfo &operator=(FilterInfo &&) noexcept;
-  ~FilterInfo();
-
-  Type type{Type::Generic};
+  Type type;
   /// The original filter expression which must be satisfied.
-  Expression *expression{nullptr};
+  Expression *expression;
   /// Set of used symbols by the filter @c expression.
   std::unordered_set<Symbol> used_symbols{};
   /// Labels for Type::Label filtering.
@@ -329,8 +310,7 @@ struct FilterInfo {
   /// Information for Type::Id filtering.
   std::optional<IdFilter> id_filter{};
   /// Matchings for filters that include patterns
-  /// NOTE: The vector is not defined here because FilterMatching is forward declared above.
-  std::vector<FilterMatching> matchings;
+  std::vector<FilterMatching> matchings{};
 };
 
 /// Stores information on filters used inside the @c Matching of a @c QueryPart.
@@ -349,15 +329,34 @@ class Filters final {
 
   auto empty() const { return all_filters_.empty(); }
 
-  auto erase(iterator pos) -> iterator;
-  auto erase(const_iterator pos) -> iterator;
-  auto erase(iterator first, iterator last) -> iterator;
-  auto erase(const_iterator first, const_iterator last) -> iterator;
+  auto erase(iterator pos) { return all_filters_.erase(pos); }
+  auto erase(const_iterator pos) { return all_filters_.erase(pos); }
+  auto erase(iterator first, iterator last) { return all_filters_.erase(first, last); }
+  auto erase(const_iterator first, const_iterator last) { return all_filters_.erase(first, last); }
 
   void SetFilters(std::vector<FilterInfo> &&all_filters) { all_filters_ = std::move(all_filters); }
 
-  auto FilteredLabels(const Symbol &symbol) const -> std::unordered_set<LabelIx>;
-  auto FilteredProperties(const Symbol &symbol) const -> std::unordered_set<PropertyIx>;
+  auto FilteredLabels(const Symbol &symbol) const {
+    std::unordered_set<LabelIx> labels;
+    for (const auto &filter : all_filters_) {
+      if (filter.type == FilterInfo::Type::Label && utils::Contains(filter.used_symbols, symbol)) {
+        MG_ASSERT(filter.used_symbols.size() == 1U, "Expected a single used symbol for label filter");
+        labels.insert(filter.labels.begin(), filter.labels.end());
+      }
+    }
+    return labels;
+  }
+
+  auto FilteredProperties(const Symbol &symbol) const -> std::unordered_set<PropertyIx> {
+    std::unordered_set<PropertyIx> properties;
+
+    for (const auto &filter : all_filters_) {
+      if (filter.type == FilterInfo::Type::Property && filter.property_filter->symbol_ == symbol) {
+        properties.insert(filter.property_filter->property_);
+      }
+    }
+    return properties;
+  }
 
   /// Remove a filter; may invalidate iterators.
   /// Removal is done by comparing only the expression, so that multiple
@@ -371,10 +370,26 @@ class Filters final {
                         std::vector<Expression *> *removed_filters = nullptr);
 
   /// Returns a vector of FilterInfo for properties.
-  auto PropertyFilters(const Symbol &symbol) const -> std::vector<FilterInfo>;
+  auto PropertyFilters(const Symbol &symbol) const {
+    std::vector<FilterInfo> filters;
+    for (const auto &filter : all_filters_) {
+      if (filter.type == FilterInfo::Type::Property && filter.property_filter->symbol_ == symbol) {
+        filters.push_back(filter);
+      }
+    }
+    return filters;
+  }
 
   /// Return a vector of FilterInfo for ID equality filtering.
-  auto IdFilters(const Symbol &symbol) const -> std::vector<FilterInfo>;
+  auto IdFilters(const Symbol &symbol) const {
+    std::vector<FilterInfo> filters;
+    for (const auto &filter : all_filters_) {
+      if (filter.type == FilterInfo::Type::Id && filter.id_filter->symbol_ == symbol) {
+        filters.push_back(filter);
+      }
+    }
+    return filters;
+  }
 
   /// Collects filtering information from a pattern.
   ///
@@ -444,57 +459,6 @@ struct FilterMatching : Matching {
   std::optional<Symbol> symbol;
 };
 
-inline auto Filters::erase(Filters::iterator pos) -> iterator { return all_filters_.erase(pos); }
-inline auto Filters::erase(Filters::const_iterator pos) -> iterator { return all_filters_.erase(pos); }
-inline auto Filters::erase(Filters::iterator first, Filters::iterator last) -> iterator {
-  return all_filters_.erase(first, last);
-}
-inline auto Filters::erase(Filters::const_iterator first, Filters::const_iterator last) -> iterator {
-  return all_filters_.erase(first, last);
-}
-
-inline auto Filters::FilteredLabels(const Symbol &symbol) const -> std::unordered_set<LabelIx> {
-  std::unordered_set<LabelIx> labels;
-  for (const auto &filter : all_filters_) {
-    if (filter.type == FilterInfo::Type::Label && utils::Contains(filter.used_symbols, symbol)) {
-      MG_ASSERT(filter.used_symbols.size() == 1U, "Expected a single used symbol for label filter");
-      labels.insert(filter.labels.begin(), filter.labels.end());
-    }
-  }
-  return labels;
-}
-
-inline auto Filters::FilteredProperties(const Symbol &symbol) const -> std::unordered_set<PropertyIx> {
-  std::unordered_set<PropertyIx> properties;
-
-  for (const auto &filter : all_filters_) {
-    if (filter.type == FilterInfo::Type::Property && filter.property_filter->symbol_ == symbol) {
-      properties.insert(filter.property_filter->property_);
-    }
-  }
-  return properties;
-}
-
-inline auto Filters::PropertyFilters(const Symbol &symbol) const -> std::vector<FilterInfo> {
-  std::vector<FilterInfo> filters;
-  for (const auto &filter : all_filters_) {
-    if (filter.type == FilterInfo::Type::Property && filter.property_filter->symbol_ == symbol) {
-      filters.push_back(filter);
-    }
-  }
-  return filters;
-}
-
-inline auto Filters::IdFilters(const Symbol &symbol) const -> std::vector<FilterInfo> {
-  std::vector<FilterInfo> filters;
-  for (const auto &filter : all_filters_) {
-    if (filter.type == FilterInfo::Type::Id && filter.id_filter->symbol_ == symbol) {
-      filters.push_back(filter);
-    }
-  }
-  return filters;
-}
-
 /// @brief Represents a read (+ write) part of a query. Parts are split on
 /// `WITH` clauses.
 ///

src/query/procedure/fmt.hpp

@@ -1,82 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#if FMT_VERSION > 90000
-#include <fmt/ostream.h>
-#include <string>
-
-#include "mg_procedure.h"
-#include "utils/logging.hpp"
-
-inline std::string ToString(const mgp_log_level &log_level) {
-  switch (log_level) {
-    case mgp_log_level::MGP_LOG_LEVEL_CRITICAL:
-      return "CRITICAL";
-    case mgp_log_level::MGP_LOG_LEVEL_ERROR:
-      return "ERROR";
-    case mgp_log_level::MGP_LOG_LEVEL_WARN:
-      return "WARN";
-    case mgp_log_level::MGP_LOG_LEVEL_INFO:
-      return "INFO";
-    case mgp_log_level::MGP_LOG_LEVEL_DEBUG:
-      return "DEBUG";
-    case mgp_log_level::MGP_LOG_LEVEL_TRACE:
-      return "TRACE";
-  }
-  LOG_FATAL("ToString of a wrong mgp_log_level -> check missing switch case");
-}
-inline std::ostream &operator<<(std::ostream &os, const mgp_log_level &log_level) {
-  os << ToString(log_level);
-  return os;
-}
-template <>
-class fmt::formatter<mgp_log_level> : public fmt::ostream_formatter {};
-
-inline std::string ToString(const mgp_error &error) {
-  switch (error) {
-    case mgp_error::MGP_ERROR_NO_ERROR:
-      return "NO ERROR";
-    case mgp_error::MGP_ERROR_UNKNOWN_ERROR:
-      return "UNKNOWN ERROR";
-    case mgp_error::MGP_ERROR_UNABLE_TO_ALLOCATE:
-      return "UNABLE TO ALLOCATE ERROR";
-    case mgp_error::MGP_ERROR_INSUFFICIENT_BUFFER:
-      return "INSUFFICIENT BUFFER ERROR";
-    case mgp_error::MGP_ERROR_OUT_OF_RANGE:
-      return "OUT OF RANGE ERROR";
-    case mgp_error::MGP_ERROR_LOGIC_ERROR:
-      return "LOGIC ERROR";
-    case mgp_error::MGP_ERROR_DELETED_OBJECT:
-      return "DELETED OBJECT ERROR";
-    case mgp_error::MGP_ERROR_INVALID_ARGUMENT:
-      return "INVALID ARGUMENT ERROR";
-    case mgp_error::MGP_ERROR_KEY_ALREADY_EXISTS:
-      return "KEY ALREADY EXISTS ERROR";
-    case mgp_error::MGP_ERROR_IMMUTABLE_OBJECT:
-      return "IMMUTABLE OBJECT ERROR";
-    case mgp_error::MGP_ERROR_VALUE_CONVERSION:
-      return "VALUE CONVERSION ERROR";
-    case mgp_error::MGP_ERROR_SERIALIZATION_ERROR:
-      return "SERIALIZATION ERROR";
-    case mgp_error::MGP_ERROR_AUTHORIZATION_ERROR:
-      return "AUTHORIZATION ERROR";
-  }
-  LOG_FATAL("ToString of a wrong mgp_error -> check missing switch case");
-}
-inline std::ostream &operator<<(std::ostream &os, const mgp_error &error) {
-  os << ToString(error);
-  return os;
-}
-template <>
-class fmt::formatter<mgp_error> : public fmt::ostream_formatter {};
-#endif

src/query/procedure/mg_procedure_helpers.cpp

@@ -1,4 +1,4 @@
-// Copyright 2023 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
@@ -10,7 +10,6 @@
 // licenses/APL.txt.
 
 #include "query/procedure/mg_procedure_helpers.hpp"
-#include "query/procedure/fmt.hpp"
 
 namespace memgraph::query::procedure {
 MgpUniquePtr<mgp_value> GetStringValueOrSetError(const char *string, mgp_memory *memory, mgp_result *result) {

src/query/procedure/mg_procedure_helpers.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 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
@@ -18,7 +18,6 @@
 #include <fmt/format.h>
 
 #include "mg_procedure.h"
-#include "query/procedure/fmt.hpp"
 
 namespace memgraph::query::procedure {
 template <typename TResult, typename TFunc, typename... TArgs>

src/query/procedure/mg_procedure_impl.cpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -29,7 +29,6 @@
 #include "query/db_accessor.hpp"
 #include "query/frontend/ast/ast.hpp"
 #include "query/procedure/cypher_types.hpp"
-#include "query/procedure/fmt.hpp"
 #include "query/procedure/mg_procedure_helpers.hpp"
 #include "query/stream/common.hpp"
 #include "storage/v2/property_value.hpp"
@@ -188,7 +187,6 @@ template <typename TFunc, typename... Args>
     spdlog::error("Memory allocation error during mg API call: {}", bae.what());
     return mgp_error::MGP_ERROR_UNABLE_TO_ALLOCATE;
   } catch (const memgraph::utils::OutOfMemoryException &oome) {
-    [[maybe_unused]] auto blocker = memgraph::utils::MemoryTracker::OutOfMemoryExceptionBlocker{};
     spdlog::error("Memory limit exceeded during mg API call: {}", oome.what());
     return mgp_error::MGP_ERROR_UNABLE_TO_ALLOCATE;
   } catch (const std::out_of_range &oore) {
@@ -200,12 +198,12 @@ template <typename TFunc, typename... Args>
   } catch (const std::logic_error &lee) {
     spdlog::error("Logic error during mg API call: {}", lee.what());
     return mgp_error::MGP_ERROR_LOGIC_ERROR;
-  } catch (const memgraph::utils::temporal::InvalidArgumentException &e) {
-    spdlog::error("Invalid argument was sent to an mg API call for temporal types: {}", e.what());
-    return mgp_error::MGP_ERROR_INVALID_ARGUMENT;
   } catch (const std::exception &e) {
     spdlog::error("Unexpected error during mg API call: {}", e.what());
     return mgp_error::MGP_ERROR_UNKNOWN_ERROR;
+  } catch (const memgraph::utils::temporal::InvalidArgumentException &e) {
+    spdlog::error("Invalid argument was sent to an mg API call for temporal types: {}", e.what());
+    return mgp_error::MGP_ERROR_INVALID_ARGUMENT;
   } catch (...) {
     spdlog::error("Unexpected error during mg API call");
     return mgp_error::MGP_ERROR_UNKNOWN_ERROR;

src/query/replication_query_handler.hpp

@@ -53,10 +53,10 @@ struct ReplicationQueryHandler {
                                             const std::optional<utils::UUID> &main_uuid) = 0;
 
   // as MAIN, define and connect to REPLICAs
-  virtual auto TryRegisterReplica(const memgraph::replication::ReplicationClientConfig &config)
+  virtual auto TryRegisterReplica(const memgraph::replication::ReplicationClientConfig &config, bool send_swap_uuid)
       -> utils::BasicResult<RegisterReplicaError> = 0;
 
-  virtual auto RegisterReplica(const memgraph::replication::ReplicationClientConfig &config)
+  virtual auto RegisterReplica(const memgraph::replication::ReplicationClientConfig &config, bool send_swap_uuid)
       -> utils::BasicResult<RegisterReplicaError> = 0;
 
   // as MAIN, remove a REPLICA connection

src/query/typed_value.cpp

@@ -19,7 +19,6 @@
 #include <string_view>
 #include <utility>
 
-#include "query/fmt.hpp"
 #include "storage/v2/temporal.hpp"
 #include "utils/exceptions.hpp"
 #include "utils/fnv.hpp"
@@ -327,11 +326,13 @@ TypedValue::operator storage::PropertyValue() const {
       throw TypedValueException("TypedValue is of type '{}', not '{}'", type_, Type::type_enum); \
     return field;                                                                                \
   }                                                                                              \
+                                                                                                 \
   const type_param &TypedValue::Value##type_enum() const {                                       \
     if (type_ != Type::type_enum) [[unlikely]]                                                   \
       throw TypedValueException("TypedValue is of type '{}', not '{}'", type_, Type::type_enum); \
     return field;                                                                                \
   }                                                                                              \
+                                                                                                 \
   bool TypedValue::Is##type_enum() const { return type_ == Type::type_enum; }
 
 DEFINE_VALUE_AND_TYPE_GETTERS(bool, Bool, bool_v)
@@ -782,13 +783,10 @@ TypedValue operator<(const TypedValue &a, const TypedValue &b) {
         return false;
     }
   };
-  if (!is_legal(a.type()) || !is_legal(b.type())) {
+  if (!is_legal(a.type()) || !is_legal(b.type()))
     throw TypedValueException("Invalid 'less' operand types({} + {})", a.type(), b.type());
-  }
 
-  if (a.IsNull() || b.IsNull()) {
-    return TypedValue(a.GetMemoryResource());
-  }
+  if (a.IsNull() || b.IsNull()) return TypedValue(a.GetMemoryResource());
 
   if (a.IsString() || b.IsString()) {
     if (a.type() != b.type()) {
@@ -958,9 +956,8 @@ inline void EnsureArithmeticallyOk(const TypedValue &a, const TypedValue &b, boo
   // checked here because they are handled before this check is performed in
   // arithmetic op implementations.
 
-  if (!is_legal(a) || !is_legal(b)) {
+  if (!is_legal(a) || !is_legal(b))
     throw TypedValueException("Invalid {} operand types {}, {}", op_name, a.type(), b.type());
-  }
 }
 
 namespace {
@@ -1110,9 +1107,8 @@ TypedValue operator%(const TypedValue &a, const TypedValue &b) {
 }
 
 inline void EnsureLogicallyOk(const TypedValue &a, const TypedValue &b, const std::string &op_name) {
-  if (!((a.IsBool() || a.IsNull()) && (b.IsBool() || b.IsNull()))) {
+  if (!((a.IsBool() || a.IsNull()) && (b.IsBool() || b.IsNull())))
     throw TypedValueException("Invalid {} operand types({} && {})", op_name, a.type(), b.type());
-  }
 }
 
 TypedValue operator&&(const TypedValue &a, const TypedValue &b) {

src/replication/include/replication/state.hpp

@@ -39,8 +39,7 @@ enum class RegisterReplicaError : uint8_t { NAME_EXISTS, ENDPOINT_EXISTS, COULD_
 
 struct RoleMainData {
   RoleMainData() = default;
-  explicit RoleMainData(ReplicationEpoch e, bool writing_enabled, std::optional<utils::UUID> uuid = std::nullopt)
-      : epoch_(std::move(e)), writing_enabled_(writing_enabled) {
+  explicit RoleMainData(ReplicationEpoch e, std::optional<utils::UUID> uuid = std::nullopt) : epoch_(std::move(e)) {
     if (uuid) {
       uuid_ = *uuid;
     }
@@ -55,7 +54,6 @@ struct RoleMainData {
   ReplicationEpoch epoch_;
   std::list<ReplicationClient> registered_replicas_{};  // TODO: data race issues
   utils::UUID uuid_;
-  bool writing_enabled_{false};
 };
 
 struct RoleReplicaData {
@@ -92,21 +90,6 @@ struct ReplicationState {
   bool IsMain() const { return GetRole() == replication_coordination_glue::ReplicationRole::MAIN; }
   bool IsReplica() const { return GetRole() == replication_coordination_glue::ReplicationRole::REPLICA; }
 
-  auto IsMainWriteable() const -> bool {
-    if (auto const *main = std::get_if<RoleMainData>(&replication_data_)) {
-      return main->writing_enabled_;
-    }
-    return false;
-  }
-
-  auto EnableWritingOnMain() -> bool {
-    if (auto *main = std::get_if<RoleMainData>(&replication_data_)) {
-      main->writing_enabled_ = true;
-      return true;
-    }
-    return false;
-  }
-
   bool HasDurability() const { return nullptr != durability_; }
 
   bool TryPersistRoleMain(std::string new_epoch, utils::UUID main_uuid);

src/replication/replication_client.cpp

@@ -10,7 +10,6 @@
 // licenses/APL.txt.
 
 #include "replication/replication_client.hpp"
-#include "io/network/fmt.hpp"
 
 namespace memgraph::replication {
 
@@ -31,7 +30,7 @@ ReplicationClient::ReplicationClient(const memgraph::replication::ReplicationCli
 ReplicationClient::~ReplicationClient() {
   try {
     auto const &endpoint = rpc_client_.Endpoint();
-    spdlog::trace("Closing replication client on {}", endpoint);
+    spdlog::trace("Closing replication client on {}:{}", endpoint.address, endpoint.port);
   } catch (...) {
     // Logging can throw. Not a big deal, just ignore.
   }

src/replication/state.cpp

@@ -62,8 +62,9 @@ ReplicationState::ReplicationState(std::optional<std::filesystem::path> durabili
   }
 #endif
   if (std::holds_alternative<RoleReplicaData>(replication_data)) {
-    auto &replica_uuid = std::get<RoleReplicaData>(replication_data).uuid_;
-    std::string uuid = replica_uuid.has_value() ? std::string(replica_uuid.value()) : "";
+    std::string uuid = std::get<RoleReplicaData>(replication_data).uuid_.has_value()
+                           ? std::string(std::get<RoleReplicaData>(replication_data).uuid_.value())
+                           : "";
     spdlog::trace("Recovered main's uuid for replica {}", uuid);
   } else {
     spdlog::trace("Recovered uuid for main {}", std::string(std::get<RoleMainData>(replication_data).uuid_));
@@ -145,8 +146,8 @@ auto ReplicationState::FetchReplicationData() -> FetchReplicationResult_t {
     return std::visit(
         utils::Overloaded{
             [&](durability::MainRole &&r) -> FetchReplicationResult_t {
-              auto res = RoleMainData{std::move(r.epoch), false,
-                                      r.main_uuid.has_value() ? r.main_uuid.value() : utils::UUID{}};
+              auto res =
+                  RoleMainData{std::move(r.epoch), r.main_uuid.has_value() ? r.main_uuid.value() : utils::UUID{}};
               auto b = durability_->begin(durability::kReplicationReplicaPrefix);
               auto e = durability_->end(durability::kReplicationReplicaPrefix);
               for (; b != e; ++b) {
@@ -254,7 +255,7 @@ bool ReplicationState::SetReplicationRoleMain(const utils::UUID &main_uuid) {
     return false;
   }
 
-  replication_data_ = RoleMainData{ReplicationEpoch{new_epoch}, true, main_uuid};
+  replication_data_ = RoleMainData{ReplicationEpoch{new_epoch}, main_uuid};
 
   return true;
 }

src/replication_coordination_glue/CMakeLists.txt

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