Split SHOW DATABASES in two

.github/workflows/daily_benchmark.yaml

@@ -16,7 +16,7 @@ jobs:
 
     steps:
       - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           # Number of commits to fetch. `0` indicates all history for all
           # branches and tags. (default: 1)

.github/workflows/diff.yaml

@@ -27,7 +27,7 @@ jobs:
 
     steps:
       - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           # Number of commits to fetch. `0` indicates all history for all
           # branches and tags. (default: 1)
@@ -65,7 +65,7 @@ jobs:
 
     steps:
       - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           # Number of commits to fetch. `0` indicates all history for all
           # branches and tags. (default: 1)
@@ -96,7 +96,7 @@ jobs:
 
       - name: Python code analysis
         run: |
-          CHANGED_FILES=$(git diff -U0 ${{ env.BASE_BRANCH }}... --name-only --diff-filter=d)
+          CHANGED_FILES=$(git diff -U0 ${{ env.BASE_BRANCH }}... --name-only)
           for file in ${CHANGED_FILES}; do
             echo ${file}
             if [[ ${file} == *.py ]]; then
@@ -137,9 +137,9 @@ jobs:
           tar -czf code_coverage.tar.gz coverage.json html report.json summary.rmu
 
       - name: Save code coverage
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
-          name: "Code coverage(Code analysis)"
+          name: "Code coverage"
           path: tools/github/generated/code_coverage.tar.gz
 
       - name: Run clang-tidy
@@ -162,7 +162,7 @@ jobs:
 
     steps:
       - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           # Number of commits to fetch. `0` indicates all history for all
           # branches and tags. (default: 1)
@@ -208,9 +208,9 @@ jobs:
           ./cppcheck_and_clang_format diff
 
       - name: Save cppcheck and clang-format errors
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
-          name: "Code coverage(Debug build)"
+          name: "Code coverage"
           path: tools/github/cppcheck_and_clang_format.txt
 
   release_build:
@@ -223,7 +223,7 @@ jobs:
 
     steps:
       - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           # Number of commits to fetch. `0` indicates all history for all
           # branches and tags. (default: 1)
@@ -251,7 +251,7 @@ jobs:
           ./continuous_integration
 
       - name: Save quality assurance status
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: "GQL Behave Status"
           path: |
@@ -268,7 +268,6 @@ jobs:
           ctest -R memgraph__unit --output-on-failure -j$THREADS
 
       - name: Ensure Kafka and Pulsar are up
-        if: false
         run: |
           cd tests/e2e/streams/kafka
           docker-compose up -d
@@ -276,7 +275,6 @@ jobs:
           docker-compose up -d
 
       - name: Run e2e tests
-        if: false
         run: |
           cd tests
           ./setup.sh /opt/toolchain-v4/activate
@@ -285,7 +283,7 @@ jobs:
           ./run.sh
 
       - name: Ensure Kafka and Pulsar are down
-        if: false
+        if: always()
         run: |
           cd tests/e2e/streams/kafka
           docker-compose down
@@ -325,128 +323,16 @@ jobs:
           cpack -G DEB --config ../CPackConfig.cmake
 
       - name: Save enterprise DEB package
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: "Enterprise DEB package"
           path: build/output/memgraph*.deb
 
       - name: Save test data
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         if: always()
         with:
-          name: "Test data(Release build)"
-          path: |
-            # 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
-        if: false
-        run: |
-          cd tests
-          ./setup.sh /opt/toolchain-v4/activate
-          source ve3/bin/activate_e2e
-          cd e2e
-
-          # Just the replication based e2e tests
-          ./run.sh "Replicate multitenancy"
-          ./run.sh "Show"
-          ./run.sh "Show while creating invalid state"
-          ./run.sh "Delete edge replication"
-          ./run.sh "Read-write benchmark"
-          ./run.sh "Index replication"
-          ./run.sh "Constraints"
-
-      - name: Save test data
-        uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: "Test data(MultiTenancy replication build)"
+          name: "Test data"
           path: |
             # multiple paths could be defined
             build/logs
@@ -462,7 +348,7 @@ jobs:
 
     steps:
       - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           # Number of commits to fetch. `0` indicates all history for all
           # branches and tags. (default: 1)
@@ -479,18 +365,13 @@ jobs:
           cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo ..
           make -j$THREADS memgraph
 
-      - name: Refresh Jepsen Cluster
-        run: |
-          cd tests/jepsen
-          ./run.sh cluster-refresh
-
       - name: Run Jepsen tests
         run: |
           cd tests/jepsen
           ./run.sh test-all-individually --binary ../../build/memgraph --ignore-run-stdout-logs --ignore-run-stderr-logs
 
       - name: Save Jepsen report
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         if: ${{ always() }}
         with:
           name: "Jepsen Report"
@@ -506,7 +387,7 @@ jobs:
 
     steps:
       - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           # Number of commits to fetch. `0` indicates all history for all
           # branches and tags. (default: 1)

.github/workflows/full_clang_tidy.yaml

@@ -14,7 +14,7 @@ jobs:
 
     steps:
       - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           # Number of commits to fetch. `0` indicates all history for all
           # branches and tags. (default: 1)

.github/workflows/package_memgraph.yaml

@@ -42,14 +42,14 @@ jobs:
     timeout-minutes: 60
     steps:
       - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0 # Required because of release/get_version.py
       - name: "Build package"
         run: |
           ./release/package/run.sh package amzn-2 ${{ github.event.inputs.build_type }}
       - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: amzn-2
           path: build/output/amzn-2/memgraph*.rpm
@@ -60,14 +60,14 @@ jobs:
     timeout-minutes: 60
     steps:
       - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0 # Required because of release/get_version.py
       - name: "Build package"
         run: |
           ./release/package/run.sh package centos-7 ${{ github.event.inputs.build_type }}
       - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: centos-7
           path: build/output/centos-7/memgraph*.rpm
@@ -78,14 +78,14 @@ jobs:
     timeout-minutes: 60
     steps:
       - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0 # Required because of release/get_version.py
       - name: "Build package"
         run: |
           ./release/package/run.sh package centos-9 ${{ github.event.inputs.build_type }}
       - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: centos-9
           path: build/output/centos-9/memgraph*.rpm
@@ -96,14 +96,14 @@ jobs:
     timeout-minutes: 60
     steps:
       - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0 # Required because of release/get_version.py
       - name: "Build package"
         run: |
           ./release/package/run.sh package debian-10 ${{ github.event.inputs.build_type }}
       - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: debian-10
           path: build/output/debian-10/memgraph*.deb
@@ -114,14 +114,14 @@ jobs:
     timeout-minutes: 60
     steps:
       - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0 # Required because of release/get_version.py
       - name: "Build package"
         run: |
           ./release/package/run.sh package debian-11 ${{ github.event.inputs.build_type }}
       - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: debian-11
           path: build/output/debian-11/memgraph*.deb
@@ -132,14 +132,14 @@ jobs:
     timeout-minutes: 120
     steps:
       - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0 # Required because of release/get_version.py
       - name: "Build package"
         run: |
           ./release/package/run.sh package debian-11-arm ${{ github.event.inputs.build_type }}
       - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: debian-11-aarch64
           path: build/output/debian-11-arm/memgraph*.deb
@@ -150,14 +150,14 @@ jobs:
     timeout-minutes: 60
     steps:
       - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0 # Required because of release/get_version.py
       - name: "Build package"
         run: |
           ./release/package/run.sh package debian-11 ${{ github.event.inputs.build_type }} --for-platform
       - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: debian-11-platform
           path: build/output/debian-11/memgraph*.deb
@@ -168,7 +168,7 @@ jobs:
     timeout-minutes: 60
     steps:
       - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0 # Required because of release/get_version.py
       - name: "Build package"
@@ -177,7 +177,7 @@ jobs:
           ./run.sh package debian-11 ${{ github.event.inputs.build_type }} --for-docker
           ./run.sh docker
       - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: docker
           path: build/output/docker/memgraph*.tar.gz
@@ -188,14 +188,14 @@ jobs:
     timeout-minutes: 60
     steps:
       - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0 # Required because of release/get_version.py
       - name: "Build package"
         run: |
           ./release/package/run.sh package fedora-36 ${{ github.event.inputs.build_type }}
       - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: fedora-36
           path: build/output/fedora-36/memgraph*.rpm
@@ -206,14 +206,14 @@ jobs:
     timeout-minutes: 60
     steps:
       - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0 # Required because of release/get_version.py
       - name: "Build package"
         run: |
           ./release/package/run.sh package ubuntu-18.04 ${{ github.event.inputs.build_type }}
       - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: ubuntu-18.04
           path: build/output/ubuntu-18.04/memgraph*.deb
@@ -224,14 +224,14 @@ jobs:
     timeout-minutes: 60
     steps:
       - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0 # Required because of release/get_version.py
       - name: "Build package"
         run: |
           ./release/package/run.sh package ubuntu-20.04 ${{ github.event.inputs.build_type }}
       - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: ubuntu-20.04
           path: build/output/ubuntu-20.04/memgraph*.deb
@@ -242,14 +242,14 @@ jobs:
     timeout-minutes: 60
     steps:
       - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0 # Required because of release/get_version.py
       - name: "Build package"
         run: |
           ./release/package/run.sh package ubuntu-22.04 ${{ github.event.inputs.build_type }}
       - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: ubuntu-22.04
           path: build/output/ubuntu-22.04/memgraph*.deb
@@ -260,14 +260,14 @@ jobs:
     timeout-minutes: 120
     steps:
       - name: "Set up repository"
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0 # Required because of release/get_version.py
       - name: "Build package"
         run: |
           ./release/package/run.sh package ubuntu-22.04-arm ${{ github.event.inputs.build_type }}
       - name: "Upload package"
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: ubuntu-22.04-aarch64
           path: build/output/ubuntu-22.04-arm/memgraph*.deb
@@ -279,7 +279,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Download artifacts
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v3
         with:
           # name: # if name input parameter is not provided, all artifacts are downloaded
                   # and put in directories named after each one.

.github/workflows/performance_benchmarks.yaml

@@ -14,7 +14,7 @@ jobs:
 
     steps:
       - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           # Number of commits to fetch. `0` indicates all history for all
           # branches and tags. (default: 1)

.github/workflows/release_debian10.yaml

@@ -14,21 +14,19 @@ on:
   schedule:
     - 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:
   community_build:
     name: "Community build"
     runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+    timeout-minutes: 960
 
     steps:
       - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           # Number of commits to fetch. `0` indicates all history for all
           # branches and tags. (default: 1)
@@ -42,6 +40,10 @@ jobs:
           # Initialize dependencies.
           ./init
 
+          # Set default build_type to Release
+          INPUT_BUILD_TYPE=${{ github.event.inputs.build_type }}
+          BUILD_TYPE=${INPUT_BUILD_TYPE:-"Release"}
+
           # Build community binaries.
           cd build
           cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DMG_ENTERPRISE=OFF ..
@@ -63,11 +65,10 @@ jobs:
       THREADS: 24
       MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
       MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
-    timeout-minutes: 60
 
     steps:
       - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           # Number of commits to fetch. `0` indicates all history for all
           # branches and tags. (default: 1)
@@ -109,19 +110,22 @@ jobs:
           tar -czf code_coverage.tar.gz coverage.json html report.json summary.rmu
 
       - name: Save code coverage
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
-          name: "Code coverage(Coverage build)"
+          name: "Code coverage"
           path: tools/github/generated/code_coverage.tar.gz
 
   debug_build:
     name: "Debug build"
     runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
+    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
+        uses: actions/checkout@v3
         with:
           # Number of commits to fetch. `0` indicates all history for all
           # branches and tags. (default: 1)
@@ -153,6 +157,10 @@ jobs:
         run: |
           ./tests/drivers/run.sh
 
+      - name: Run integration tests
+        run: |
+          tests/integration/run.sh
+
       - name: Run cppcheck and clang-format
         run: |
           # Activate toolchain.
@@ -163,49 +171,23 @@ jobs:
           ./cppcheck_and_clang_format diff
 
       - name: Save cppcheck and clang-format errors
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
-          name: "Code coverage(Debug build)"
+          name: "Code coverage"
           path: tools/github/cppcheck_and_clang_format.txt
 
-  debug_integration_test:
-    name: "Debug integration tests"
-    runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
-
-    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 debug binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build debug binaries.
-          cd build
-          cmake ..
-          make -j$THREADS
-
-      - name: Run integration tests
-        run: |
-          tests/integration/run.sh
-
   release_build:
     name: "Release build"
-    runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
+    runs-on: [self-hosted, Linux, X64, Debian10, BigMemory]
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+    timeout-minutes: 960
 
     steps:
       - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           # Number of commits to fetch. `0` indicates all history for all
           # branches and tags. (default: 1)
@@ -219,6 +201,10 @@ jobs:
           # Initialize dependencies.
           ./init
 
+          # Set default build_type to Release
+          INPUT_BUILD_TYPE=${{ github.event.inputs.build_type }}
+          BUILD_TYPE=${INPUT_BUILD_TYPE:-"Release"}
+
           # Build release binaries.
           cd build
           cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
@@ -240,60 +226,11 @@ jobs:
           cpack -G DEB --config ../CPackConfig.cmake
 
       - name: Save enterprise DEB package
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: "Enterprise DEB package"
           path: build/output/memgraph*.deb
 
-      - name: Run GQL Behave tests
-        run: |
-          cd tests
-          ./setup.sh /opt/toolchain-v4/activate
-          cd gql_behave
-          ./continuous_integration
-
-      - name: Save quality assurance status
-        uses: actions/upload-artifact@v4
-        with:
-          name: "GQL Behave Status"
-          path: |
-            tests/gql_behave/gql_behave_status.csv
-            tests/gql_behave/gql_behave_status.html
-
-      - name: Run unit tests
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-
-          # Run unit tests.
-          cd build
-          ctest -R memgraph__unit --output-on-failure
-
-  release_benchmark_tests:
-    name: "Release Benchmark Tests"
-    runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
-
-    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 release binaries
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
-          make -j$THREADS
-
       - name: Run micro benchmark tests
         run: |
           # Activate toolchain.
@@ -320,38 +257,29 @@ jobs:
             --num-database-workers 9 --num-clients-workers 30 \
             --no-strict
 
-  release_e2e_test:
-    if: false
-    name: "Release End-to-end Test"
-    runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
+      - name: Run GQL Behave tests
+        run: |
+          cd tests
+          ./setup.sh /opt/toolchain-v4/activate
+          cd gql_behave
+          ./continuous_integration
 
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v4
+      - name: Save quality assurance status
+        uses: actions/upload-artifact@v3
         with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
+          name: "GQL Behave Status"
+          path: |
+            tests/gql_behave/gql_behave_status.csv
+            tests/gql_behave/gql_behave_status.html
 
-      - name: Build release binaries
+      - name: Run unit tests
         run: |
           # Activate toolchain.
           source /opt/toolchain-v4/activate
-          # Initialize dependencies.
-          ./init
 
-          # Build release binaries
+          # Run unit tests.
           cd build
-          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
-          make -j$THREADS
-
-      - name: Ensure Kafka and Pulsar are up
-        run: |
-          cd tests/e2e/streams/kafka
-          docker-compose up -d
-          cd ../pulsar
-          docker-compose up -d
+          ctest -R memgraph__unit --output-on-failure
 
       - name: Run e2e tests
         run: |
@@ -361,40 +289,6 @@ jobs:
           cd e2e
           ./run.sh
 
-      - name: Ensure Kafka and Pulsar are down
-        if: always()
-        run: |
-          cd tests/e2e/streams/kafka
-          docker-compose down
-          cd ../pulsar
-          docker-compose down
-
-  release_durability_stress_tests:
-    name: "Release durability and stress tests"
-    runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
-
-    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 release binaries.
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
-          make -j$THREADS
-
       - name: Run stress test (plain)
         run: |
           cd tests/stress
@@ -405,6 +299,11 @@ jobs:
           cd tests/stress
           ./continuous_integration --use-ssl
 
+      - name: Run stress test (large)
+        run: |
+          cd tests/stress
+          ./continuous_integration --large-dataset
+
       - name: Run durability test (plain)
         run: |
           cd tests/stress
@@ -420,11 +319,15 @@ jobs:
   release_jepsen_test:
     name: "Release Jepsen Test"
     runs-on: [self-hosted, Linux, X64, Debian10, JepsenControl]
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
     timeout-minutes: 60
 
     steps:
       - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           # Number of commits to fetch. `0` indicates all history for all
           # branches and tags. (default: 1)
@@ -437,23 +340,22 @@ jobs:
           # Initialize dependencies.
           ./init
 
+          # Set default build_type to Release
+          INPUT_BUILD_TYPE=${{ github.event.inputs.build_type }}
+          BUILD_TYPE=${INPUT_BUILD_TYPE:-"Release"}
+
           # Build only memgraph release binary.
           cd build
           cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
           make -j$THREADS memgraph
 
-      - name: Refresh Jepsen Cluster
-        run: |
-          cd tests/jepsen
-          ./run.sh cluster-refresh
-
       - name: Run Jepsen tests
         run: |
           cd tests/jepsen
           ./run.sh test-all-individually --binary ../../build/memgraph --ignore-run-stdout-logs --ignore-run-stderr-logs
 
       - name: Save Jepsen report
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         if: ${{ always() }}
         with:
           name: "Jepsen Report"

.github/workflows/release_docker.yaml

@@ -19,7 +19,7 @@ jobs:
       DOCKER_REPOSITORY_NAME: memgraph
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
 
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v2

.github/workflows/release_mgbench_client.yaml

@@ -20,7 +20,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
 
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v2

.github/workflows/release_ubuntu2004.yaml

@@ -14,21 +14,19 @@ on:
   schedule:
     - 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:
   community_build:
     name: "Community build"
     runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+    timeout-minutes: 960
 
     steps:
       - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           # Number of commits to fetch. `0` indicates all history for all
           # branches and tags. (default: 1)
@@ -42,6 +40,10 @@ jobs:
           # Initialize dependencies.
           ./init
 
+          # Set default build_type to Release
+          INPUT_BUILD_TYPE=${{ github.event.inputs.build_type }}
+          BUILD_TYPE=${INPUT_BUILD_TYPE:-"Release"}
+
           # Build community binaries.
           cd build
           cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DMG_ENTERPRISE=OFF ..
@@ -59,11 +61,14 @@ jobs:
   coverage_build:
     name: "Coverage build"
     runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
+    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
+        uses: actions/checkout@v3
         with:
           # Number of commits to fetch. `0` indicates all history for all
           # branches and tags. (default: 1)
@@ -105,19 +110,22 @@ jobs:
           tar -czf code_coverage.tar.gz coverage.json html report.json summary.rmu
 
       - name: Save code coverage
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
-          name: "Code coverage(Coverage build)"
+          name: "Code coverage"
           path: tools/github/generated/code_coverage.tar.gz
 
   debug_build:
     name: "Debug build"
     runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
+    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
+        uses: actions/checkout@v3
         with:
           # Number of commits to fetch. `0` indicates all history for all
           # branches and tags. (default: 1)
@@ -149,6 +157,10 @@ jobs:
         run: |
           ./tests/drivers/run.sh
 
+      - name: Run integration tests
+        run: |
+          tests/integration/run.sh
+
       - name: Run cppcheck and clang-format
         run: |
           # Activate toolchain.
@@ -159,49 +171,23 @@ jobs:
           ./cppcheck_and_clang_format diff
 
       - name: Save cppcheck and clang-format errors
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
-          name: "Code coverage(Debug build)"
+          name: "Code coverage"
           path: tools/github/cppcheck_and_clang_format.txt
 
-  debug_integration_test:
-    name: "Debug integration tests"
-    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
-
-    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 debug binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build debug binaries.
-          cd build
-          cmake ..
-          make -j$THREADS
-
-      - name: Run integration tests
-        run: |
-          tests/integration/run.sh
-
   release_build:
     name: "Release build"
     runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+    timeout-minutes: 960
 
     steps:
       - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           # Number of commits to fetch. `0` indicates all history for all
           # branches and tags. (default: 1)
@@ -215,6 +201,10 @@ jobs:
           # Initialize dependencies.
           ./init
 
+          # Set default build_type to Release
+          INPUT_BUILD_TYPE=${{ github.event.inputs.build_type }}
+          BUILD_TYPE=${INPUT_BUILD_TYPE:-"Release"}
+
           # Build release binaries.
           cd build
           cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
@@ -236,60 +226,11 @@ jobs:
           cpack -G DEB --config ../CPackConfig.cmake
 
       - name: Save enterprise DEB package
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: "Enterprise DEB package"
           path: build/output/memgraph*.deb
 
-      - name: Run GQL Behave tests
-        run: |
-          cd tests
-          ./setup.sh /opt/toolchain-v4/activate
-          cd gql_behave
-          ./continuous_integration
-
-      - name: Save quality assurance status
-        uses: actions/upload-artifact@v4
-        with:
-          name: "GQL Behave Status"
-          path: |
-            tests/gql_behave/gql_behave_status.csv
-            tests/gql_behave/gql_behave_status.html
-
-      - name: Run unit tests
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-
-          # Run unit tests.
-          cd build
-          ctest -R memgraph__unit --output-on-failure
-
-  release_benchmark_tests:
-    name: "Release Benchmark Tests"
-    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
-
-    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 release binaries
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
-          make -j$THREADS
-
       - name: Run micro benchmark tests
         run: |
           # Activate toolchain.
@@ -316,38 +257,29 @@ jobs:
             --num-database-workers 9 --num-clients-workers 30 \
             --no-strict
 
-  release_e2e_test:
-    if: false
-    name: "Release End-to-end Test"
-    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
+      - name: Run GQL Behave tests
+        run: |
+          cd tests
+          ./setup.sh /opt/toolchain-v4/activate
+          cd gql_behave
+          ./continuous_integration
 
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v4
+      - name: Save quality assurance status
+        uses: actions/upload-artifact@v3
         with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
+          name: "GQL Behave Status"
+          path: |
+            tests/gql_behave/gql_behave_status.csv
+            tests/gql_behave/gql_behave_status.html
 
-      - name: Build release binaries
+      - name: Run unit tests
         run: |
           # Activate toolchain.
           source /opt/toolchain-v4/activate
-          # Initialize dependencies.
-          ./init
 
-          # Build release binaries
+          # Run unit tests.
           cd build
-          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
-          make -j$THREADS
-
-      - name: Ensure Kafka and Pulsar are up
-        run: |
-          cd tests/e2e/streams/kafka
-          docker-compose up -d
-          cd ../pulsar
-          docker-compose up -d
+          ctest -R memgraph__unit --output-on-failure
 
       - name: Run e2e tests
         run: |
@@ -357,40 +289,6 @@ jobs:
           cd e2e
           ./run.sh
 
-      - name: Ensure Kafka and Pulsar are down
-        if: always()
-        run: |
-          cd tests/e2e/streams/kafka
-          docker-compose down
-          cd ../pulsar
-          docker-compose down
-
-  release_durability_stress_tests:
-    name: "Release durability and stress tests"
-    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
-
-    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 release binaries.
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
-          make -j$THREADS
-
       - name: Run stress test (plain)
         run: |
           cd tests/stress
@@ -401,6 +299,11 @@ jobs:
           cd tests/stress
           ./continuous_integration --use-ssl
 
+      - name: Run stress test (large)
+        run: |
+          cd tests/stress
+          ./continuous_integration --large-dataset
+
       - name: Run durability test (plain)
         run: |
           cd tests/stress

.github/workflows/stress_test_large.yaml

@@ -1,62 +0,0 @@
-name: Stress test large
-
-on:
-  workflow_dispatch:
-    inputs:
-      build_type:
-        type: choice
-        description: "Memgraph Build type. Default value is Release."
-        default: 'Release'
-        options:
-          - Release
-          - RelWithDebInfo
-
-  schedule:
-    - 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:
-  stress_test_large:
-    name: "Stress test large"
-    timeout-minutes: 720
-    strategy:
-      matrix:
-        os: [Debian10, Ubuntu20.04]
-        extra: [BigMemory, Gen8]
-        exclude:
-          - os: Debian10
-            extra: Gen8
-          - os: Ubuntu20.04
-            extra: BigMemory
-    runs-on: [self-hosted, Linux, X64, "${{ matrix.os }}", "${{ matrix.extra }}"]
-
-    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 release binaries.
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
-          make -j$THREADS
-
-      - name: Run stress test (large)
-        run: |
-          cd tests/stress
-          ./continuous_integration --large-dataset

.github/workflows/upload_to_s3.yaml

@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Download artifacts
-        uses: dawidd6/action-download-artifact@v4
+        uses: dawidd6/action-download-artifact@v2
         with:
           workflow: package_all.yaml
           workflow_conclusion: success

ADRs/001_tantivy.md

@@ -1,32 +0,0 @@
-# Tantivy ADR
-
-**Author**
-Marko Budiselic (github.com/gitbuda)
-
-**Status**
-APPROVED
-
-**Date**
-January 5, 2024
-
-**Problem**
-
-For some of Memgraph workloads, text search is a required feature. We don't
-want to build a new text search engine because that's not Memgraph's core
-value.
-
-**Criteria**
-
-- easy integration with our C++ codebase
-- ability to operate in-memory and on-disk
-- sufficient features (regex, full-text search, fuzzy search, aggregations over
-  text data)
-- production-ready
-
-**Decision**
-
-All known C++ libraries are not production-ready. Recent Rust libraries, in
-particular [Tantivy](https://github.com/quickwit-oss/tantivy), seem to provide
-much more features, it is production ready. The way how we'll integrate Tantivy
-into the current Memgraph codebase is via
-[cxx](https://github.com/dtolnay/cxx). **We select Tantivy.**

ADRs/002_nuraft.md

@@ -1,34 +0,0 @@
-# NuRaft ADR
-
-**Author**
-Marko Budiselic (github.com/gitbuda)
-
-**Status**
-PROPOSED
-
-**Date**
-January 10, 2024
-
-**Problem**
-
-In order to enhance Memgraph to have High Availability features as requested by
-customers, we want to have reliable coordinators backed by RAFT consensus algorithm. Implementing
-RAFT to be correct and performant is a very challenging task. Skillful Memgraph
-engineers already tried 3 times and failed to deliver in a reasonable timeframe
-all three times (approximately 4 person-weeks of engineering work each time).
-
-**Criteria**
-
-- easy integration with our C++ codebase
-- heavily tested in production environments
-- implementation of performance optimizations on top of the canonical Raft
-  implementation
-
-**Decision**
-
-There are a few, robust C++ implementations of Raft but as a part of other
-projects or bigger libraries. **We select
-[NuRaft](https://github.com/eBay/NuRaft)** because it focuses on delivering
-Raft without bloatware, and it's used by
-[Clickhouse](https://github.com/ClickHouse/ClickHouse) (an comparable peer to
-Memgraph, a very well-established product).

ADRs/003_rocksdb.md

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

ADRs/README.md

@@ -1,67 +0,0 @@
-# Architecture Decision Records
-
-Also known as ADRs. This practice has become widespread in many
-high performing engineering teams. It is a technique for communicating
-between software engineers. ADRs provide a clear and documented
-history of architectural choices, ensuring that everyone on the
-team is on the same page. This improves communication and reduces
-misunderstandings. The act of recording decisions encourages
-thoughtful consideration before making choices. This can lead to
-more robust and better-informed architectural decisions.
-
-Links must be created, pointing both to and from the Github Issues
-and/or the Notion Program Management "Initiative" database.
-
-ADRs are complimentary to any tech specs that get written while
-designing a solution. ADRs are very short and to the point, while
-tech specs will include diagrams and can be quite verbose.
-
-## HOWTO
-
-Each ADR will be assigned a monotonically increasing unique numeric
-identifier, which will be zero-padded to 3 digits. Each ADR will
-be in a single markdown file containing no more than one page of
-text, and the filename will start with that unique identifier,
-followed by a camel case phrase summarizing the problem.  For
-example: `001_architecture_decision_records.md` or
-`002_big_integration_cap_theorem.md`.
-
-We want to use an ADR when:
-1. Significant Impact: This includes choices that affect scalability, performance, or fundamental design principles.
-1. Long-Term Ramifications: When a decision is expected to have long-term ramifications or is difficult to reverse.
-1. Architectural Principles: ADRs are suitable for documenting decisions related to architectural principles, frameworks, or patterns that shape the system's structure.
-1. Controversial Choices: When a decision is likely to be controversial or may require justification in the future.
-
-The most senior engineer on a project will evaluate and decide
-whether or not an ADR is needed.
-
-## Do
-
-1. Keep them brief and concise.
-1. Explain the trade-offs.
-1. Each ADR should be about one AD, not multiple ADs
-1. Don't alter existing information in an ADR. Instead, amend the ADR by adding new information, or supersede the ADR by creating a new ADR.
-1. Explain your organization's situation and business priorities.
-1. Include rationale and considerations based on social and skills makeups of your teams.
-1. Include pros and cons that are relevant, and describe them in terms that align with your needs and goals.
-1. Explain what follows from making the decision. This can include the effects, outcomes, outputs, follow ups, and more.
-
-## Don't
-
-1. Try to guess what the executive leader wants, and then attempt to please them. Be objective.
-1. Try to solve everything all at once. A pretty good solution now is MUCH BETTER than a perfect solution later. Carpe diem!
-1. Hide any doubts or unanswered questions.
-1. Make it a sales pitch. Everything has upsides and downsides - be authentic and honest about them.
-1. Perform merely a superficial investigation. If an ADR doesn't call for some deep thinking, then it probably shouldn't exist.
-1. Ignore the long-term costs such as performance, tech debt or hardware and maintenance.
-1. Get tunnel vision where creative or surprising approaches are not explored.
-
-# Template - use the format below for each new ADR
-
-1. **Author** - who has written the ADR
-1. **Status** - one of: PROPOSED, ACCEPTED, REJECTED, SUPERSEDED-BY or DEPRECATED
-1. **Date** - when the status was most recently updated
-1. **Problem** - a concise paragraph explaining the context
-1. **Criteria** - a list of the two or three metrics by which the solution was evaluated, and their relative weights (importance)
-1. **Decision** - what was chosen as the way forward, and what the consequences are of the decision
-

CMakeLists.txt

@@ -271,17 +271,6 @@ 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 must 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)
@@ -290,18 +279,6 @@ option(ASAN "Build with Address Sanitizer. To get a reasonable performance optio
 option(TSAN "Build with Thread Sanitizer. To get a reasonable performance option should be used only in Release or RelWithDebInfo build " OFF)
 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)
   if (NOT lower_build_type STREQUAL "debug")

include/mg_exceptions.hpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -25,7 +25,7 @@ namespace mg_exception {
 template <typename FirstArg, typename... Args>
 std::string StringSerialize(FirstArg &&firstArg, Args &&...args) {
   std::stringstream stream;
-  stream << std::forward<FirstArg>(firstArg);
+  stream << firstArg;
   ((stream << " " << args), ...);
   return stream.str();
 }

libs/CMakeLists.txt

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

libs/setup.sh

@@ -126,7 +126,6 @@ declare -A primary_urls=(
   ["absl"]="https://$local_cache_host/git/abseil-cpp.git"
   ["jemalloc"]="https://$local_cache_host/git/jemalloc.git"
   ["range-v3"]="https://$local_cache_host/git/ericniebler/range-v3.git"
-  ["nuraft"]="https://$local_cache_host/git/eBay/NuRaft.git"
 )
 
 # The goal of secondary urls is to have links to the "source of truth" of
@@ -156,7 +155,6 @@ declare -A secondary_urls=(
   ["absl"]="https://github.com/abseil/abseil-cpp.git"
   ["jemalloc"]="https://github.com/jemalloc/jemalloc.git"
   ["range-v3"]="https://github.com/ericniebler/range-v3.git"
-  ["nuraft"]="https://github.com/eBay/NuRaft.git"
 )
 
 # antlr
@@ -279,10 +277,3 @@ popd
 #range-v3 release-0.12.0
 range_v3_ref="release-0.12.0"
 repo_clone_try_double "${primary_urls[range-v3]}" "${secondary_urls[range-v3]}" "rangev3" "$range_v3_ref"
-
-# NuRaft
-nuraft_tag="v2.1.0"
-repo_clone_try_double "${primary_urls[nuraft]}" "${secondary_urls[nuraft]}" "nuraft" "$nuraft_tag" true
-pushd nuraft
-./prepare.sh
-popd

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-21-01
+CHANGE DATE:            2027-08-12
 CHANGE LICENSE:         Apache License, Version 2.0
 
 For information about alternative licensing arrangements, please visit: https://memgraph.com/legal.

src/CMakeLists.txt

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

src/auth/CMakeLists.txt

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

src/auth/auth.cpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Licensed as a Memgraph Enterprise file under the Memgraph Enterprise
 // License (the "License"); by using this file, you agree to be bound by the terms of the License, and you may not use
@@ -8,18 +8,17 @@
 
 #include "auth/auth.hpp"
 
+#include <cstring>
 #include <iostream>
-#include <optional>
+#include <limits>
 #include <utility>
 
 #include <fmt/format.h>
 
-#include "auth/crypto.hpp"
 #include "auth/exceptions.hpp"
-#include "auth/rpc.hpp"
 #include "license/license.hpp"
-#include "system/transaction.hpp"
 #include "utils/flag_validation.hpp"
+#include "utils/logging.hpp"
 #include "utils/message.hpp"
 #include "utils/settings.hpp"
 #include "utils/string.hpp"
@@ -44,84 +43,9 @@ DEFINE_VALIDATED_int32(auth_module_timeout_ms, 10000,
                        FLAG_IN_RANGE(100, 1800000));
 
 namespace memgraph::auth {
-
-namespace {
-#ifdef MG_ENTERPRISE
-/**
- * REPLICATION SYSTEM ACTION IMPLEMENTATIONS
- */
-struct UpdateAuthData : memgraph::system::ISystemAction {
-  explicit UpdateAuthData(User user) : user_{std::move(user)}, role_{std::nullopt} {}
-  explicit UpdateAuthData(Role role) : user_{std::nullopt}, role_{std::move(role)} {}
-
-  void DoDurability() override { /* Done during Auth execution */
-  }
-
-  bool DoReplication(replication::ReplicationClient &client, replication::ReplicationEpoch const &epoch,
-                     memgraph::system::Transaction const &txn) const override {
-    auto check_response = [](const replication::UpdateAuthDataRes &response) { return response.success; };
-    if (user_) {
-      return client.SteamAndFinalizeDelta<replication::UpdateAuthDataRpc>(
-          check_response, std::string{epoch.id()}, txn.last_committed_system_timestamp(), txn.timestamp(), *user_);
-    }
-    if (role_) {
-      return client.SteamAndFinalizeDelta<replication::UpdateAuthDataRpc>(
-          check_response, std::string{epoch.id()}, txn.last_committed_system_timestamp(), txn.timestamp(), *role_);
-    }
-    // Should never get here
-    MG_ASSERT(false, "Trying to update auth data that is not a user nor a role");
-    return {};
-  }
-
-  void PostReplication(replication::RoleMainData &mainData) const override {}
-
- private:
-  std::optional<User> user_;
-  std::optional<Role> role_;
-};
-
-struct DropAuthData : memgraph::system::ISystemAction {
-  enum class AuthDataType { USER, ROLE };
-
-  explicit DropAuthData(AuthDataType type, std::string_view name) : type_{type}, name_{name} {}
-
-  void DoDurability() override { /* Done during Auth execution */
-  }
-
-  bool DoReplication(replication::ReplicationClient &client, replication::ReplicationEpoch const &epoch,
-                     memgraph::system::Transaction const &txn) const override {
-    auto check_response = [](const replication::DropAuthDataRes &response) { return response.success; };
-
-    memgraph::replication::DropAuthDataReq::DataType type{};
-    switch (type_) {
-      case AuthDataType::USER:
-        type = memgraph::replication::DropAuthDataReq::DataType::USER;
-        break;
-      case AuthDataType::ROLE:
-        type = memgraph::replication::DropAuthDataReq::DataType::ROLE;
-        break;
-    }
-    return client.SteamAndFinalizeDelta<replication::DropAuthDataRpc>(
-        check_response, std::string{epoch.id()}, txn.last_committed_system_timestamp(), txn.timestamp(), type, name_);
-  }
-  void PostReplication(replication::RoleMainData &mainData) const override {}
-
- private:
-  AuthDataType type_;
-  std::string name_;
-};
-#endif
-
-/**
- * CONSTANTS
- */
 const std::string kUserPrefix = "user:";
 const std::string kRolePrefix = "role:";
 const std::string kLinkPrefix = "link:";
-const std::string kVersion = "version";
-
-static constexpr auto kVersionV1 = "V1";
-}  // namespace
 
 /**
  * All data stored in the `Auth` storage is stored in an underlying
@@ -140,59 +64,7 @@ static constexpr auto kVersionV1 = "V1";
  * key="link:<username>", value="<rolename>"
  */
 
-namespace {
-void MigrateVersions(kvstore::KVStore &store) {
-  static constexpr auto kPasswordHashV0V1 = "password_hash";
-  auto version_str = store.Get(kVersion);
-
-  if (!version_str) {
-    using namespace std::string_literals;
-
-    // pre versioning, add version to the store
-    auto puts = std::map<std::string, std::string>{{kVersion, kVersionV1}};
-
-    // also add hash kind into durability
-
-    auto it = store.begin(kUserPrefix);
-    auto const e = store.end(kUserPrefix);
-
-    if (it != e) {
-      const auto hash_algo = CurrentHashAlgorithm();
-      spdlog::info("Updating auth durability, assuming previously stored as {}", AsString(hash_algo));
-
-      for (; it != e; ++it) {
-        auto const &[key, value] = *it;
-        try {
-          auto user_data = nlohmann::json::parse(value);
-
-          auto password_hash = user_data[kPasswordHashV0V1];
-          if (!password_hash.is_string()) {
-            throw AuthException("Couldn't load user data!");
-          }
-          // upgrade the password_hash to include the hash algortihm
-          if (password_hash.empty()) {
-            user_data[kPasswordHashV0V1] = nullptr;
-          } else {
-            user_data[kPasswordHashV0V1] = HashedPassword{hash_algo, password_hash};
-          }
-          puts.emplace(key, user_data.dump());
-        } catch (const nlohmann::json::parse_error &e) {
-          throw AuthException("Couldn't load user data!");
-        }
-      }
-    }
-
-    // Perform migration to V1
-    store.PutMultiple(puts);
-    version_str = kVersionV1;
-  }
-}
-};  // namespace
-
-Auth::Auth(std::string storage_directory, Config config)
-    : storage_(std::move(storage_directory)), module_(FLAGS_auth_module_executable), config_{std::move(config)} {
-  MigrateVersions(storage_);
-}
+Auth::Auth(const std::string &storage_directory) : storage_(storage_directory), module_(FLAGS_auth_module_executable) {}
 
 std::optional<User> Auth::Authenticate(const std::string &username, const std::string &password) {
   if (module_.IsUsed()) {
@@ -223,12 +95,6 @@ std::optional<User> Auth::Authenticate(const std::string &username, const std::s
     // Authenticate the user.
     if (!is_authenticated) return std::nullopt;
 
-    /**
-     * TODO
-     * The auth module should not update auth data.
-     * There is now way to replicate it and we should not be storing sensitive data if we don't have to.
-     */
-
     // Find or create the user and return it.
     auto user = GetUser(username);
     if (!user) {
@@ -247,7 +113,7 @@ std::optional<User> Auth::Authenticate(const std::string &username, const std::s
         return std::nullopt;
       }
     } else {
-      UpdatePassword(*user, password);
+      user->UpdatePassword(password);
     }
     if (FLAGS_auth_module_manage_roles) {
       if (!rolename.empty()) {
@@ -289,10 +155,6 @@ std::optional<User> Auth::Authenticate(const std::string &username, const std::s
                                           username, "https://memgr.ph/auth"));
       return std::nullopt;
     }
-    if (user->UpgradeHash(password)) {
-      SaveUser(*user);
-    }
-
     return user;
   }
 }
@@ -321,7 +183,7 @@ std::optional<User> Auth::GetUser(const std::string &username_orig) const {
   return user;
 }
 
-void Auth::SaveUser(const User &user, system::Transaction *system_tx) {
+void Auth::SaveUser(const User &user) {
   bool success = false;
   if (const auto *role = user.role(); role != nullptr) {
     success = storage_.PutMultiple(
@@ -333,72 +195,26 @@ void Auth::SaveUser(const User &user, system::Transaction *system_tx) {
   if (!success) {
     throw AuthException("Couldn't save user '{}'!", user.username());
   }
-  // All changes to the user end up calling this function, so no need to add a delta anywhere else
-  if (system_tx) {
-#ifdef MG_ENTERPRISE
-    system_tx->AddAction<UpdateAuthData>(user);
-#endif
-  }
 }
 
-void Auth::UpdatePassword(auth::User &user, const std::optional<std::string> &password) {
-  // Check if null
-  if (!password) {
-    if (!config_.password_permit_null) {
-      throw AuthException("Null passwords aren't permitted!");
-    }
-  } else {
-    // Check if compliant with our filter
-    if (config_.custom_password_regex) {
-      if (const auto license_check_result = license::global_license_checker.IsEnterpriseValid(utils::global_settings);
-          license_check_result.HasError()) {
-        throw AuthException(
-            "Custom password regex is a Memgraph Enterprise feature. Please set the config "
-            "(\"--auth-password-strength-regex\") to its default value (\"{}\") or remove the flag.\n{}",
-            glue::kDefaultPasswordRegex,
-            license::LicenseCheckErrorToString(license_check_result.GetError(), "password regex"));
-      }
-    }
-    if (!std::regex_match(*password, config_.password_regex)) {
-      throw AuthException(
-          "The user password doesn't conform to the required strength! Regex: "
-          "\"{}\"",
-          config_.password_regex_str);
-    }
-  }
-
-  // All checks passed; update
-  user.UpdatePassword(password);
-}
-
-std::optional<User> Auth::AddUser(const std::string &username, const std::optional<std::string> &password,
-                                  system::Transaction *system_tx) {
-  if (!NameRegexMatch(username)) {
-    throw AuthException("Invalid user name.");
-  }
+std::optional<User> Auth::AddUser(const std::string &username, const std::optional<std::string> &password) {
   auto existing_user = GetUser(username);
   if (existing_user) return std::nullopt;
   auto existing_role = GetRole(username);
   if (existing_role) return std::nullopt;
   auto new_user = User(username);
-  UpdatePassword(new_user, password);
-  SaveUser(new_user, system_tx);
+  new_user.UpdatePassword(password);
+  SaveUser(new_user);
   return new_user;
 }
 
-bool Auth::RemoveUser(const std::string &username_orig, system::Transaction *system_tx) {
+bool Auth::RemoveUser(const std::string &username_orig) {
   auto username = utils::ToLowerCase(username_orig);
   if (!storage_.Get(kUserPrefix + username)) return false;
   std::vector<std::string> keys({kLinkPrefix + username, kUserPrefix + username});
   if (!storage_.DeleteMultiple(keys)) {
     throw AuthException("Couldn't remove user '{}'!", username);
   }
-  // Handling drop user delta
-  if (system_tx) {
-#ifdef MG_ENTERPRISE
-    system_tx->AddAction<DropAuthData>(DropAuthData::AuthDataType::USER, username);
-#endif
-  }
   return true;
 }
 
@@ -415,19 +231,6 @@ std::vector<auth::User> Auth::AllUsers() const {
   return ret;
 }
 
-std::vector<std::string> Auth::AllUsernames() const {
-  std::vector<std::string> ret;
-  for (auto it = storage_.begin(kUserPrefix); it != storage_.end(kUserPrefix); ++it) {
-    auto username = it->first.substr(kUserPrefix.size());
-    if (username != utils::ToLowerCase(username)) continue;
-    auto user = GetUser(username);
-    if (user) {
-      ret.push_back(username);
-    }
-  }
-  return ret;
-}
-
 bool Auth::HasUsers() const { return storage_.begin(kUserPrefix) != storage_.end(kUserPrefix); }
 
 std::optional<Role> Auth::GetRole(const std::string &rolename_orig) const {
@@ -445,30 +248,23 @@ std::optional<Role> Auth::GetRole(const std::string &rolename_orig) const {
   return Role::Deserialize(data);
 }
 
-void Auth::SaveRole(const Role &role, system::Transaction *system_tx) {
+void Auth::SaveRole(const Role &role) {
   if (!storage_.Put(kRolePrefix + role.rolename(), role.Serialize().dump())) {
     throw AuthException("Couldn't save role '{}'!", role.rolename());
   }
-  // All changes to the role end up calling this function, so no need to add a delta anywhere else
-  if (system_tx) {
-#ifdef MG_ENTERPRISE
-    system_tx->AddAction<UpdateAuthData>(role);
-#endif
-  }
 }
 
-std::optional<Role> Auth::AddRole(const std::string &rolename, system::Transaction *system_tx) {
-  if (!NameRegexMatch(rolename)) {
-    throw AuthException("Invalid role name.");
-  }
-  if (auto existing_role = GetRole(rolename)) return std::nullopt;
-  if (auto existing_user = GetUser(rolename)) return std::nullopt;
+std::optional<Role> Auth::AddRole(const std::string &rolename) {
+  auto existing_role = GetRole(rolename);
+  if (existing_role) return std::nullopt;
+  auto existing_user = GetUser(rolename);
+  if (existing_user) return std::nullopt;
   auto new_role = Role(rolename);
-  SaveRole(new_role, system_tx);
+  SaveRole(new_role);
   return new_role;
 }
 
-bool Auth::RemoveRole(const std::string &rolename_orig, system::Transaction *system_tx) {
+bool Auth::RemoveRole(const std::string &rolename_orig) {
   auto rolename = utils::ToLowerCase(rolename_orig);
   if (!storage_.Get(kRolePrefix + rolename)) return false;
   std::vector<std::string> keys;
@@ -481,12 +277,6 @@ bool Auth::RemoveRole(const std::string &rolename_orig, system::Transaction *sys
   if (!storage_.DeleteMultiple(keys)) {
     throw AuthException("Couldn't remove role '{}'!", rolename);
   }
-  // Handling drop role delta
-  if (system_tx) {
-#ifdef MG_ENTERPRISE
-    system_tx->AddAction<DropAuthData>(DropAuthData::AuthDataType::ROLE, rolename);
-#endif
-  }
   return true;
 }
 
@@ -495,7 +285,8 @@ std::vector<auth::Role> Auth::AllRoles() const {
   for (auto it = storage_.begin(kRolePrefix); it != storage_.end(kRolePrefix); ++it) {
     auto rolename = it->first.substr(kRolePrefix.size());
     if (rolename != utils::ToLowerCase(rolename)) continue;
-    if (auto role = GetRole(rolename)) {
+    auto role = GetRole(rolename);
+    if (role) {
       ret.push_back(*role);
     } else {
       throw AuthException("Couldn't load role '{}'!", rolename);
@@ -504,27 +295,16 @@ std::vector<auth::Role> Auth::AllRoles() const {
   return ret;
 }
 
-std::vector<std::string> Auth::AllRolenames() const {
-  std::vector<std::string> ret;
-  for (auto it = storage_.begin(kRolePrefix); it != storage_.end(kRolePrefix); ++it) {
-    auto rolename = it->first.substr(kRolePrefix.size());
-    if (rolename != utils::ToLowerCase(rolename)) continue;
-    if (auto role = GetRole(rolename)) {
-      ret.push_back(rolename);
-    }
-  }
-  return ret;
-}
-
 std::vector<auth::User> Auth::AllUsersForRole(const std::string &rolename_orig) const {
-  const auto rolename = utils::ToLowerCase(rolename_orig);
+  auto rolename = utils::ToLowerCase(rolename_orig);
   std::vector<auth::User> ret;
   for (auto it = storage_.begin(kLinkPrefix); it != storage_.end(kLinkPrefix); ++it) {
     auto username = it->first.substr(kLinkPrefix.size());
     if (username != utils::ToLowerCase(username)) continue;
     if (it->second != utils::ToLowerCase(it->second)) continue;
     if (it->second == rolename) {
-      if (auto user = GetUser(username)) {
+      auto user = GetUser(username);
+      if (user) {
         ret.push_back(std::move(*user));
       } else {
         throw AuthException("Couldn't load user '{}'!", username);
@@ -535,67 +315,56 @@ std::vector<auth::User> Auth::AllUsersForRole(const std::string &rolename_orig)
 }
 
 #ifdef MG_ENTERPRISE
-bool Auth::GrantDatabaseToUser(const std::string &db, const std::string &name, system::Transaction *system_tx) {
-  if (auto user = GetUser(name)) {
+bool Auth::GrantDatabaseToUser(const std::string &db, const std::string &name) {
+  auto user = GetUser(name);
+  if (user) {
     if (db == kAllDatabases) {
       user->db_access().GrantAll();
     } else {
       user->db_access().Add(db);
     }
-    SaveUser(*user, system_tx);
+    SaveUser(*user);
     return true;
   }
   return false;
 }
 
-bool Auth::RevokeDatabaseFromUser(const std::string &db, const std::string &name, system::Transaction *system_tx) {
-  if (auto user = GetUser(name)) {
+bool Auth::RevokeDatabaseFromUser(const std::string &db, const std::string &name) {
+  auto user = GetUser(name);
+  if (user) {
     if (db == kAllDatabases) {
       user->db_access().DenyAll();
     } else {
       user->db_access().Remove(db);
     }
-    SaveUser(*user, system_tx);
+    SaveUser(*user);
     return true;
   }
   return false;
 }
 
-void Auth::DeleteDatabase(const std::string &db, system::Transaction *system_tx) {
+void Auth::DeleteDatabase(const std::string &db) {
   for (auto it = storage_.begin(kUserPrefix); it != storage_.end(kUserPrefix); ++it) {
     auto username = it->first.substr(kUserPrefix.size());
-    if (auto user = GetUser(username)) {
+    auto user = GetUser(username);
+    if (user) {
       user->db_access().Delete(db);
-      SaveUser(*user, system_tx);
+      SaveUser(*user);
     }
   }
 }
 
-bool Auth::SetMainDatabase(std::string_view db, const std::string &name, system::Transaction *system_tx) {
-  if (auto user = GetUser(name)) {
+bool Auth::SetMainDatabase(const std::string &db, const std::string &name) {
+  auto user = GetUser(name);
+  if (user) {
     if (!user->db_access().SetDefault(db)) {
       throw AuthException("Couldn't set default database '{}' for user '{}'!", db, name);
     }
-    SaveUser(*user, system_tx);
+    SaveUser(*user);
     return true;
   }
   return false;
 }
 #endif
 
-bool Auth::NameRegexMatch(const std::string &user_or_role) const {
-  if (config_.custom_name_regex) {
-    if (const auto license_check_result =
-            memgraph::license::global_license_checker.IsEnterpriseValid(memgraph::utils::global_settings);
-        license_check_result.HasError()) {
-      throw memgraph::auth::AuthException(
-          "Custom user/role regex is a Memgraph Enterprise feature. Please set the config "
-          "(\"--auth-user-or-role-name-regex\") to its default value (\"{}\") or remove the flag.\n{}",
-          glue::kDefaultUserRoleRegex,
-          memgraph::license::LicenseCheckErrorToString(license_check_result.GetError(), "user/role regex"));
-    }
-  }
-  return std::regex_match(user_or_role, config_.name_regex);
-}
-
 }  // namespace memgraph::auth

src/auth/auth.hpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Licensed as a Memgraph Enterprise file under the Memgraph Enterprise
 // License (the "License"); by using this file, you agree to be bound by the terms of the License, and you may not use
@@ -10,23 +10,16 @@
 
 #include <mutex>
 #include <optional>
-#include <regex>
 #include <vector>
 
 #include "auth/exceptions.hpp"
 #include "auth/models.hpp"
 #include "auth/module.hpp"
-#include "glue/auth_global.hpp"
 #include "kvstore/kvstore.hpp"
-#include "system/action.hpp"
 #include "utils/settings.hpp"
-#include "utils/synchronized.hpp"
 
 namespace memgraph::auth {
 
-class Auth;
-using SynchedAuth = memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock>;
-
 static const constexpr char *const kAllDatabases = "*";
 
 /**
@@ -38,47 +31,7 @@ static const constexpr char *const kAllDatabases = "*";
  */
 class Auth final {
  public:
-  struct Config {
-    Config() {}
-    Config(std::string name_regex, std::string password_regex, bool password_permit_null)
-        : name_regex_str{std::move(name_regex)},
-          password_regex_str{std::move(password_regex)},
-          password_permit_null{password_permit_null},
-          custom_name_regex{name_regex_str != glue::kDefaultUserRoleRegex},
-          name_regex{name_regex_str},
-          custom_password_regex{password_regex_str != glue::kDefaultPasswordRegex},
-          password_regex{password_regex_str} {}
-
-    std::string name_regex_str{glue::kDefaultUserRoleRegex};
-    std::string password_regex_str{glue::kDefaultPasswordRegex};
-    bool password_permit_null{true};
-
-   private:
-    friend class Auth;
-    bool custom_name_regex{false};
-    std::regex name_regex{name_regex_str};
-    bool custom_password_regex{false};
-    std::regex password_regex{password_regex_str};
-  };
-
-  explicit Auth(std::string storage_directory, Config config);
-
-  /**
-   * @brief Set the Config object
-   *
-   * @param config
-   */
-  void SetConfig(Config config) {
-    // NOTE: The Auth class itself is not thread-safe, higher-level code needs to synchronize it when using it.
-    config_ = std::move(config);
-  }
-
-  /**
-   * @brief
-   *
-   * @return Config
-   */
-  Config GetConfig() const { return config_; }
+  explicit Auth(const std::string &storage_directory);
 
   /**
    * Authenticates a user using his username and password.
@@ -108,7 +61,7 @@ class Auth final {
    *
    * @throw AuthException if unable to save the user.
    */
-  void SaveUser(const User &user, system::Transaction *system_tx = nullptr);
+  void SaveUser(const User &user);
 
   /**
    * Creates a user if the user doesn't exist.
@@ -119,8 +72,7 @@ class Auth final {
    * @return a user when the user is created, nullopt if the user exists
    * @throw AuthException if unable to save the user.
    */
-  std::optional<User> AddUser(const std::string &username, const std::optional<std::string> &password = std::nullopt,
-                              system::Transaction *system_tx = nullptr);
+  std::optional<User> AddUser(const std::string &username, const std::optional<std::string> &password = std::nullopt);
 
   /**
    * Removes a user from the storage.
@@ -131,15 +83,7 @@ class Auth final {
    *         doesn't exist
    * @throw AuthException if unable to remove the user.
    */
-  bool RemoveUser(const std::string &username, system::Transaction *system_tx = nullptr);
-
-  /**
-   * @brief
-   *
-   * @param user
-   * @param password
-   */
-  void UpdatePassword(auth::User &user, const std::optional<std::string> &password);
+  bool RemoveUser(const std::string &username);
 
   /**
    * Gets all users from the storage.
@@ -149,13 +93,6 @@ class Auth final {
    */
   std::vector<User> AllUsers() const;
 
-  /**
-   * @brief
-   *
-   * @return std::vector<std::string>
-   */
-  std::vector<std::string> AllUsernames() const;
-
   /**
    * Returns whether there are users in the storage.
    *
@@ -180,7 +117,7 @@ class Auth final {
    *
    * @throw AuthException if unable to save the role.
    */
-  void SaveRole(const Role &role, system::Transaction *system_tx = nullptr);
+  void SaveRole(const Role &role);
 
   /**
    * Creates a role if the role doesn't exist.
@@ -190,7 +127,7 @@ class Auth final {
    * @return a role when the role is created, nullopt if the role exists
    * @throw AuthException if unable to save the role.
    */
-  std::optional<Role> AddRole(const std::string &rolename, system::Transaction *system_tx = nullptr);
+  std::optional<Role> AddRole(const std::string &rolename);
 
   /**
    * Removes a role from the storage.
@@ -201,7 +138,7 @@ class Auth final {
    *         doesn't exist
    * @throw AuthException if unable to remove the role.
    */
-  bool RemoveRole(const std::string &rolename, system::Transaction *system_tx = nullptr);
+  bool RemoveRole(const std::string &rolename);
 
   /**
    * Gets all roles from the storage.
@@ -211,13 +148,6 @@ class Auth final {
    */
   std::vector<Role> AllRoles() const;
 
-  /**
-   * @brief
-   *
-   * @return std::vector<std::string>
-   */
-  std::vector<std::string> AllRolenames() const;
-
   /**
    * Gets all users for a role from the storage.
    *
@@ -237,7 +167,7 @@ class Auth final {
    * @return true on success
    * @throw AuthException if unable to find or update the user
    */
-  bool RevokeDatabaseFromUser(const std::string &db, const std::string &name, system::Transaction *system_tx = nullptr);
+  bool RevokeDatabaseFromUser(const std::string &db, const std::string &name);
 
   /**
    * @brief Grant access to individual database for a user.
@@ -247,7 +177,7 @@ class Auth final {
    * @return true on success
    * @throw AuthException if unable to find or update the user
    */
-  bool GrantDatabaseToUser(const std::string &db, const std::string &name, system::Transaction *system_tx = nullptr);
+  bool GrantDatabaseToUser(const std::string &db, const std::string &name);
 
   /**
    * @brief Delete a database from all users.
@@ -255,7 +185,7 @@ class Auth final {
    * @param db name of the database to delete
    * @throw AuthException if unable to read data
    */
-  void DeleteDatabase(const std::string &db, system::Transaction *system_tx = nullptr);
+  void DeleteDatabase(const std::string &db);
 
   /**
    * @brief Set main database for an individual user.
@@ -265,24 +195,14 @@ class Auth final {
    * @return true on success
    * @throw AuthException if unable to find or update the user
    */
-  bool SetMainDatabase(std::string_view db, const std::string &name, system::Transaction *system_tx = nullptr);
+  bool SetMainDatabase(const std::string &db, const std::string &name);
 #endif
 
  private:
-  /**
-   * @brief
-   *
-   * @param user_or_role
-   * @return true
-   * @return false
-   */
-  bool NameRegexMatch(const std::string &user_or_role) const;
-
   // Even though the `kvstore::KVStore` class is guaranteed to be thread-safe,
   // Auth is not thread-safe because modifying users and roles might require
   // more than one operation on the storage.
   kvstore::KVStore storage_;
   auth::Module module_;
-  Config config_;
 };
 }  // namespace memgraph::auth

src/auth/crypto.cpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Licensed as a Memgraph Enterprise file under the Memgraph Enterprise
 // License (the "License"); by using this file, you agree to be bound by the terms of the License, and you may not use
@@ -22,14 +22,10 @@
 
 namespace {
 using namespace std::literals;
-
-constexpr auto kHashAlgo = "hash_algo";
-constexpr auto kPasswordHash = "password_hash";
-
-inline constexpr std::array password_hash_mappings{
-    std::pair{"bcrypt"sv, memgraph::auth::PasswordHashAlgorithm::BCRYPT},
-    std::pair{"sha256"sv, memgraph::auth::PasswordHashAlgorithm::SHA256},
-    std::pair{"sha256-multiple"sv, memgraph::auth::PasswordHashAlgorithm::SHA256_MULTIPLE}};
+inline constexpr std::array password_encryption_mappings{
+    std::pair{"bcrypt"sv, memgraph::auth::PasswordEncryptionAlgorithm::BCRYPT},
+    std::pair{"sha256"sv, memgraph::auth::PasswordEncryptionAlgorithm::SHA256},
+    std::pair{"sha256-multiple"sv, memgraph::auth::PasswordEncryptionAlgorithm::SHA256_MULTIPLE}};
 
 inline constexpr uint64_t ONE_SHA_ITERATION = 1;
 inline constexpr uint64_t MULTIPLE_SHA_ITERATIONS = 1024;
@@ -39,7 +35,7 @@ inline constexpr uint64_t MULTIPLE_SHA_ITERATIONS = 1024;
 DEFINE_VALIDATED_string(password_encryption_algorithm, "bcrypt",
                         "The password encryption algorithm used for authentication.", {
                           if (const auto result =
-                                  memgraph::utils::IsValidEnumValueString(value, password_hash_mappings);
+                                  memgraph::utils::IsValidEnumValueString(value, password_encryption_mappings);
                               result.HasError()) {
                             const auto error = result.GetError();
                             switch (error) {
@@ -49,7 +45,7 @@ DEFINE_VALIDATED_string(password_encryption_algorithm, "bcrypt",
                               }
                               case memgraph::utils::ValidationError::InvalidValue: {
                                 std::cout << "Invalid value for password encryption algorithm. Allowed values: "
-                                          << memgraph::utils::GetAllowedEnumValuesString(password_hash_mappings)
+                                          << memgraph::utils::GetAllowedEnumValuesString(password_encryption_mappings)
                                           << std::endl;
                                 break;
                               }
@@ -62,7 +58,7 @@ DEFINE_VALIDATED_string(password_encryption_algorithm, "bcrypt",
 
 namespace memgraph::auth {
 namespace BCrypt {
-std::string HashPassword(const std::string &password) {
+std::string EncryptPassword(const std::string &password) {
   char salt[BCRYPT_HASHSIZE];
   char hash[BCRYPT_HASHSIZE];
 
@@ -90,30 +86,16 @@ bool VerifyPassword(const std::string &password, const std::string &hash) {
 }  // namespace BCrypt
 
 namespace SHA {
-
-namespace {
-
-constexpr auto SHA_LENGTH = 64U;
-constexpr auto SALT_SIZE = 16U;
-constexpr auto SALT_SIZE_DURABLE = SALT_SIZE * 2;
-
 #if OPENSSL_VERSION_MAJOR >= 3
-std::string HashPasswordOpenSSL3(std::string_view password, const uint64_t number_of_iterations,
-                                 std::string_view salt) {
+std::string EncryptPasswordOpenSSL3(const std::string &password, const uint64_t number_of_iterations) {
   unsigned char hash[SHA256_DIGEST_LENGTH];
 
   EVP_MD_CTX *ctx = EVP_MD_CTX_new();
   EVP_MD *md = EVP_MD_fetch(nullptr, "SHA2-256", nullptr);
 
   EVP_DigestInit_ex(ctx, md, nullptr);
-
-  if (!salt.empty()) {
-    DMG_ASSERT(salt.size() == SALT_SIZE);
-    EVP_DigestUpdate(ctx, salt.data(), salt.size());
-  }
-
   for (auto i = 0; i < number_of_iterations; i++) {
-    EVP_DigestUpdate(ctx, password.data(), password.size());
+    EVP_DigestUpdate(ctx, password.c_str(), password.size());
   }
   EVP_DigestFinal_ex(ctx, hash, nullptr);
 
@@ -121,11 +103,6 @@ std::string HashPasswordOpenSSL3(std::string_view password, const uint64_t numbe
   EVP_MD_CTX_free(ctx);
 
   std::stringstream result_stream;
-
-  for (unsigned char salt_char : salt) {
-    result_stream << std::hex << std::setw(2) << std::setfill('0') << (((unsigned int)salt_char) & 0xFFU);
-  }
-
   for (auto hash_char : hash) {
     result_stream << std::hex << std::setw(2) << std::setfill('0') << (int)hash_char;
   }
@@ -133,27 +110,17 @@ std::string HashPasswordOpenSSL3(std::string_view password, const uint64_t numbe
   return result_stream.str();
 }
 #else
-std::string HashPasswordOpenSSL1_1(std::string_view password, const uint64_t number_of_iterations,
-                                   std::string_view salt) {
+std::string EncryptPasswordOpenSSL1_1(const std::string &password, const uint64_t number_of_iterations) {
   unsigned char hash[SHA256_DIGEST_LENGTH];
 
   SHA256_CTX sha256;
   SHA256_Init(&sha256);
-
-  if (!salt.empty()) {
-    DMG_ASSERT(salt.size() == SALT_SIZE);
-    SHA256_Update(&sha256, salt.data(), salt.size());
-  }
-
   for (auto i = 0; i < number_of_iterations; i++) {
-    SHA256_Update(&sha256, password.data(), password.size());
+    SHA256_Update(&sha256, password.c_str(), password.size());
   }
   SHA256_Final(hash, &sha256);
 
   std::stringstream ss;
-  for (unsigned char salt_char : salt) {
-    ss << std::hex << std::setw(2) << std::setfill('0') << (((unsigned int)salt_char) & 0xFFU);
-  }
   for (auto hash_char : hash) {
     ss << std::hex << std::setw(2) << std::setfill('0') << (int)hash_char;
   }
@@ -162,144 +129,55 @@ std::string HashPasswordOpenSSL1_1(std::string_view password, const uint64_t num
 }
 #endif
 
-std::string HashPassword(std::string_view password, const uint64_t number_of_iterations, std::string_view salt) {
+std::string EncryptPassword(const std::string &password, const uint64_t number_of_iterations) {
 #if OPENSSL_VERSION_MAJOR >= 3
-  return HashPasswordOpenSSL3(password, number_of_iterations, salt);
+  return EncryptPasswordOpenSSL3(password, number_of_iterations);
 #else
-  return HashPasswordOpenSSL1_1(password, number_of_iterations, salt);
+  return EncryptPasswordOpenSSL1_1(password, number_of_iterations);
 #endif
 }
 
-auto ExtractSalt(std::string_view salt_durable) -> std::array<char, SALT_SIZE> {
-  static_assert(SALT_SIZE_DURABLE % 2 == 0);
-  static_assert(SALT_SIZE_DURABLE / 2 == SALT_SIZE);
-
-  MG_ASSERT(salt_durable.size() == SALT_SIZE_DURABLE);
-  auto const *b = salt_durable.cbegin();
-  auto const *const e = salt_durable.cend();
-
-  auto salt = std::array<char, SALT_SIZE>{};
-  auto *inserter = salt.begin();
-
-  auto const toval = [](char a) -> uint8_t {
-    if ('0' <= a && a <= '9') {
-      return a - '0';
-    }
-    if ('a' <= a && a <= 'f') {
-      return 10 + (a - 'a');
-    }
-    MG_ASSERT(false, "Currupt hash, can't extract salt");
-    __builtin_unreachable();
-  };
-
-  for (; b != e; b += 2, ++inserter) {
-    *inserter = static_cast<char>(static_cast<uint8_t>(toval(b[0]) << 4U) | toval(b[1]));
-  }
-  return salt;
-}
-
-bool IsSalted(std::string_view hash) { return hash.size() == SHA_LENGTH + SALT_SIZE_DURABLE; }
-
-bool VerifyPassword(std::string_view password, std::string_view hash, const uint64_t number_of_iterations) {
-  auto password_hash = std::invoke([&] {
-    if (hash.size() == SHA_LENGTH) [[unlikely]] {
-      // Just SHA256
-      return HashPassword(password, number_of_iterations, {});
-    } else {
-      // SHA256 + SALT
-      MG_ASSERT(IsSalted(hash));
-      auto const salt_durable = std::string_view{hash.data(), SALT_SIZE_DURABLE};
-      std::array<char, SALT_SIZE> salt = ExtractSalt(salt_durable);
-      return HashPassword(password, number_of_iterations, {salt.data(), salt.size()});
-    }
-  });
+bool VerifyPassword(const std::string &password, const std::string &hash, const uint64_t number_of_iterations) {
+  auto password_hash = EncryptPassword(password, number_of_iterations);
   return password_hash == hash;
 }
-
-}  // namespace
-
 }  // namespace SHA
 
-HashedPassword HashPassword(const std::string &password, std::optional<PasswordHashAlgorithm> override_algo) {
-  auto const hash_algo = override_algo.value_or(CurrentHashAlgorithm());
-  auto password_hash = std::invoke([&] {
-    switch (hash_algo) {
-      case PasswordHashAlgorithm::BCRYPT: {
-        return BCrypt::HashPassword(password);
-      }
-      case PasswordHashAlgorithm::SHA256:
-      case PasswordHashAlgorithm::SHA256_MULTIPLE: {
-        auto gen = std::mt19937(std::random_device{}());
-        auto salt = std::array<char, SHA::SALT_SIZE>{};
-        auto dis = std::uniform_int_distribution<unsigned char>(0, 255);
-        std::generate(salt.begin(), salt.end(), [&]() { return dis(gen); });
-        auto iterations = (hash_algo == PasswordHashAlgorithm::SHA256) ? ONE_SHA_ITERATION : MULTIPLE_SHA_ITERATIONS;
-        return SHA::HashPassword(password, iterations, {salt.data(), salt.size()});
-      }
-    }
-  });
-  return HashedPassword{hash_algo, std::move(password_hash)};
-};
+bool VerifyPassword(const std::string &password, const std::string &hash) {
+  const auto password_encryption_algorithm = utils::StringToEnum<PasswordEncryptionAlgorithm>(
+      FLAGS_password_encryption_algorithm, password_encryption_mappings);
 
-namespace {
-
-auto InternalParseHashAlgorithm(std::string_view algo) -> PasswordHashAlgorithm {
-  auto maybe_parsed = utils::StringToEnum<PasswordHashAlgorithm>(algo, password_hash_mappings);
-  if (!maybe_parsed) {
-    throw AuthException("Invalid password encryption '{}'!", algo);
+  if (!password_encryption_algorithm.has_value()) {
+    throw AuthException("Invalid password encryption flag '{}'!", FLAGS_password_encryption_algorithm);
   }
-  return *maybe_parsed;
-}
 
-PasswordHashAlgorithm &InternalCurrentHashAlgorithm() {
-  static auto current = PasswordHashAlgorithm::BCRYPT;
-  static std::once_flag flag;
-  std::call_once(flag, [] { current = InternalParseHashAlgorithm(FLAGS_password_encryption_algorithm); });
-  return current;
-}
-}  // namespace
-
-auto CurrentHashAlgorithm() -> PasswordHashAlgorithm { return InternalCurrentHashAlgorithm(); }
-
-void SetHashAlgorithm(std::string_view algo) {
-  auto &current = InternalCurrentHashAlgorithm();
-  current = InternalParseHashAlgorithm(algo);
-}
-
-auto AsString(PasswordHashAlgorithm hash_algo) -> std::string_view {
-  return *utils::EnumToString<PasswordHashAlgorithm>(hash_algo, password_hash_mappings);
-}
-
-bool HashedPassword::VerifyPassword(const std::string &password) {
-  switch (hash_algo) {
-    case PasswordHashAlgorithm::BCRYPT:
-      return BCrypt::VerifyPassword(password, password_hash);
-    case PasswordHashAlgorithm::SHA256:
-      return SHA::VerifyPassword(password, password_hash, ONE_SHA_ITERATION);
-    case PasswordHashAlgorithm::SHA256_MULTIPLE:
-      return SHA::VerifyPassword(password, password_hash, MULTIPLE_SHA_ITERATIONS);
+  switch (password_encryption_algorithm.value()) {
+    case PasswordEncryptionAlgorithm::BCRYPT:
+      return BCrypt::VerifyPassword(password, hash);
+    case PasswordEncryptionAlgorithm::SHA256:
+      return SHA::VerifyPassword(password, hash, ONE_SHA_ITERATION);
+    case PasswordEncryptionAlgorithm::SHA256_MULTIPLE:
+      return SHA::VerifyPassword(password, hash, MULTIPLE_SHA_ITERATIONS);
   }
+
+  throw AuthException("Invalid password encryption flag '{}'!", FLAGS_password_encryption_algorithm);
 }
 
-void to_json(nlohmann::json &j, const HashedPassword &p) {
-  j = nlohmann::json{{kHashAlgo, p.hash_algo}, {kPasswordHash, p.password_hash}};
-}
+std::string EncryptPassword(const std::string &password) {
+  const auto password_encryption_algorithm = utils::StringToEnum<PasswordEncryptionAlgorithm>(
+      FLAGS_password_encryption_algorithm, password_encryption_mappings);
 
-void from_json(const nlohmann::json &j, HashedPassword &p) {
-  // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
-  PasswordHashAlgorithm hash_algo;
-  j.at(kHashAlgo).get_to(hash_algo);
-  auto password_hash = j.value(kPasswordHash, std::string());
-  p = HashedPassword{hash_algo, std::move(password_hash)};
-}
+  if (!password_encryption_algorithm.has_value()) {
+    throw AuthException("Invalid password encryption flag '{}'!", FLAGS_password_encryption_algorithm);
+  }
 
-bool HashedPassword::IsSalted() const {
-  switch (hash_algo) {
-    case PasswordHashAlgorithm::BCRYPT:
-      return true;
-    case PasswordHashAlgorithm::SHA256:
-    case PasswordHashAlgorithm::SHA256_MULTIPLE:
-      return SHA::IsSalted(password_hash);
+  switch (password_encryption_algorithm.value()) {
+    case PasswordEncryptionAlgorithm::BCRYPT:
+      return BCrypt::EncryptPassword(password);
+    case PasswordEncryptionAlgorithm::SHA256:
+      return SHA::EncryptPassword(password, ONE_SHA_ITERATION);
+    case PasswordEncryptionAlgorithm::SHA256_MULTIPLE:
+      return SHA::EncryptPassword(password, MULTIPLE_SHA_ITERATIONS);
   }
 }
 

src/auth/crypto.hpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Licensed as a Memgraph Enterprise file under the Memgraph Enterprise
 // License (the "License"); by using this file, you agree to be bound by the terms of the License, and you may not use
@@ -8,45 +8,14 @@
 
 #pragma once
 
-#include <json/json.hpp>
-#include <optional>
 #include <string>
 
 namespace memgraph::auth {
-/// Need to be stable, auth durability depends on this
-enum class PasswordHashAlgorithm : uint8_t { BCRYPT = 0, SHA256 = 1, SHA256_MULTIPLE = 2 };
+enum class PasswordEncryptionAlgorithm : uint8_t { BCRYPT, SHA256, SHA256_MULTIPLE };
 
-void SetHashAlgorithm(std::string_view algo);
+/// @throw AuthException if unable to encrypt the password.
+std::string EncryptPassword(const std::string &password);
 
-auto CurrentHashAlgorithm() -> PasswordHashAlgorithm;
-
-auto AsString(PasswordHashAlgorithm hash_algo) -> std::string_view;
-
-struct HashedPassword {
-  HashedPassword() = default;
-  HashedPassword(PasswordHashAlgorithm hash_algo, std::string password_hash)
-      : hash_algo{hash_algo}, password_hash{std::move(password_hash)} {}
-  HashedPassword(HashedPassword const &) = default;
-  HashedPassword(HashedPassword &&) = default;
-  HashedPassword &operator=(HashedPassword const &) = default;
-  HashedPassword &operator=(HashedPassword &&) = default;
-
-  friend bool operator==(HashedPassword const &, HashedPassword const &) = default;
-
-  bool VerifyPassword(const std::string &password);
-
-  bool IsSalted() const;
-
-  auto HashAlgo() const -> PasswordHashAlgorithm { return hash_algo; }
-
-  friend void to_json(nlohmann::json &j, const HashedPassword &p);
-  friend void from_json(const nlohmann::json &j, HashedPassword &p);
-
- private:
-  PasswordHashAlgorithm hash_algo{PasswordHashAlgorithm::BCRYPT};
-  std::string password_hash{};
-};
-
-/// @throw AuthException if unable to hash the password.
-HashedPassword HashPassword(const std::string &password, std::optional<PasswordHashAlgorithm> override_algo = {});
+/// @throw AuthException if unable to verify the password.
+bool VerifyPassword(const std::string &password, const std::string &hash);
 }  // namespace memgraph::auth

src/auth/models.cpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Licensed as a Memgraph Enterprise file under the Memgraph Enterprise
 // License (the "License"); by using this file, you agree to be bound by the terms of the License, and you may not use
@@ -9,6 +9,7 @@
 #include "auth/models.hpp"
 
 #include <cstdint>
+#include <regex>
 #include <utility>
 
 #include <gflags/gflags.h>
@@ -20,26 +21,22 @@
 #include "query/constants.hpp"
 #include "spdlog/spdlog.h"
 #include "utils/cast.hpp"
+#include "utils/logging.hpp"
+#include "utils/settings.hpp"
 #include "utils/string.hpp"
 
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_bool(auth_password_permit_null, true, "Set to false to disable null passwords.");
+
+inline constexpr std::string_view default_password_regex = ".+";
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_string(auth_password_strength_regex, default_password_regex.data(),
+              "The regular expression that should be used to match the entire "
+              "entered password to ensure its strength.");
+
 namespace memgraph::auth {
 namespace {
 
-constexpr auto kRoleName = "rolename";
-constexpr auto kPermissions = "permissions";
-constexpr auto kGrants = "grants";
-constexpr auto kDenies = "denies";
-constexpr auto kUsername = "username";
-constexpr auto kPasswordHash = "password_hash";
-
-#ifdef MG_ENTERPRISE
-constexpr auto kGlobalPermission = "global_permission";
-constexpr auto kFineGrainedAccessHandler = "fine_grained_access_handler";
-constexpr auto kAllowAll = "allow_all";
-constexpr auto kDefault = "default";
-constexpr auto kDatabases = "databases";
-#endif
-
 // Constant list of all available permissions.
 const std::vector<Permission> kPermissionsAll = {Permission::MATCH,
                                                  Permission::CREATE,
@@ -65,8 +62,7 @@ const std::vector<Permission> kPermissionsAll = {Permission::MATCH,
                                                  Permission::TRANSACTION_MANAGEMENT,
                                                  Permission::STORAGE_MODE,
                                                  Permission::MULTI_DATABASE_EDIT,
-                                                 Permission::MULTI_DATABASE_USE,
-                                                 Permission::COORDINATOR};
+                                                 Permission::MULTI_DATABASE_USE};
 
 }  // namespace
 
@@ -122,8 +118,6 @@ std::string PermissionToString(Permission permission) {
       return "MULTI_DATABASE_EDIT";
     case Permission::MULTI_DATABASE_USE:
       return "MULTI_DATABASE_USE";
-    case Permission::COORDINATOR:
-      return "COORDINATOR";
   }
 }
 
@@ -248,9 +242,8 @@ std::vector<Permission> Permissions::GetDenies() const {
 
 nlohmann::json Permissions::Serialize() const {
   nlohmann::json data = nlohmann::json::object();
-
-  data[kGrants] = grants_;
-  data[kDenies] = denies_;
+  data["grants"] = grants_;
+  data["denies"] = denies_;
   return data;
 }
 
@@ -258,10 +251,10 @@ Permissions Permissions::Deserialize(const nlohmann::json &data) {
   if (!data.is_object()) {
     throw AuthException("Couldn't load permissions data!");
   }
-  if (!data[kGrants].is_number_unsigned() || !data[kDenies].is_number_unsigned()) {
+  if (!data["grants"].is_number_unsigned() || !data["denies"].is_number_unsigned()) {
     throw AuthException("Couldn't load permissions data!");
   }
-  return Permissions{data[kGrants], data[kDenies]};
+  return Permissions{data["grants"], data["denies"]};
 }
 
 uint64_t Permissions::grants() const { return grants_; }
@@ -323,8 +316,8 @@ nlohmann::json FineGrainedAccessPermissions::Serialize() const {
     return {};
   }
   nlohmann::json data = nlohmann::json::object();
-  data[kPermissions] = permissions_;
-  data[kGlobalPermission] = global_permission_.has_value() ? global_permission_.value() : -1;
+  data["permissions"] = permissions_;
+  data["global_permission"] = global_permission_.has_value() ? global_permission_.value() : -1;
   return data;
 }
 
@@ -337,13 +330,13 @@ FineGrainedAccessPermissions FineGrainedAccessPermissions::Deserialize(const nlo
   }
   std::optional<uint64_t> global_permission;
 
-  if (data[kGlobalPermission].empty() || data[kGlobalPermission] == -1) {
+  if (data["global_permission"].empty() || data["global_permission"] == -1) {
     global_permission = std::nullopt;
   } else {
-    global_permission = data[kGlobalPermission];
+    global_permission = data["global_permission"];
   }
 
-  return FineGrainedAccessPermissions(data[kPermissions], global_permission);
+  return FineGrainedAccessPermissions(data["permissions"], global_permission);
 }
 
 const std::unordered_map<std::string, uint64_t> &FineGrainedAccessPermissions::GetPermissions() const {
@@ -449,13 +442,13 @@ const FineGrainedAccessPermissions &Role::GetFineGrainedAccessEdgeTypePermission
 
 nlohmann::json Role::Serialize() const {
   nlohmann::json data = nlohmann::json::object();
-  data[kRoleName] = rolename_;
-  data[kPermissions] = permissions_.Serialize();
+  data["rolename"] = rolename_;
+  data["permissions"] = permissions_.Serialize();
 #ifdef MG_ENTERPRISE
   if (memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
-    data[kFineGrainedAccessHandler] = fine_grained_access_handler_.Serialize();
+    data["fine_grained_access_handler"] = fine_grained_access_handler_.Serialize();
   } else {
-    data[kFineGrainedAccessHandler] = {};
+    data["fine_grained_access_handler"] = {};
   }
 #endif
   return data;
@@ -465,21 +458,21 @@ Role Role::Deserialize(const nlohmann::json &data) {
   if (!data.is_object()) {
     throw AuthException("Couldn't load role data!");
   }
-  if (!data[kRoleName].is_string() || !data[kPermissions].is_object()) {
+  if (!data["rolename"].is_string() || !data["permissions"].is_object()) {
     throw AuthException("Couldn't load role data!");
   }
-  auto permissions = Permissions::Deserialize(data[kPermissions]);
+  auto permissions = Permissions::Deserialize(data["permissions"]);
 #ifdef MG_ENTERPRISE
   if (memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
     FineGrainedAccessHandler fine_grained_access_handler;
     // We can have an empty fine_grained if the user was created without a valid license
-    if (data[kFineGrainedAccessHandler].is_object()) {
-      fine_grained_access_handler = FineGrainedAccessHandler::Deserialize(data[kFineGrainedAccessHandler]);
+    if (data["fine_grained_access_handler"].is_object()) {
+      fine_grained_access_handler = FineGrainedAccessHandler::Deserialize(data["fine_grained_access_handler"]);
     }
-    return {data[kRoleName], permissions, std::move(fine_grained_access_handler)};
+    return {data["rolename"], permissions, std::move(fine_grained_access_handler)};
   }
 #endif
-  return {data[kRoleName], permissions};
+  return {data["rolename"], permissions};
 }
 
 bool operator==(const Role &first, const Role &second) {
@@ -493,13 +486,13 @@ bool operator==(const Role &first, const Role &second) {
 }
 
 #ifdef MG_ENTERPRISE
-void Databases::Add(std::string_view db) {
+void Databases::Add(const std::string &db) {
   if (allow_all_) {
     grants_dbs_.clear();
     allow_all_ = false;
   }
   grants_dbs_.emplace(db);
-  denies_dbs_.erase(std::string{db});  // TODO: C++23 use transparent key compare
+  denies_dbs_.erase(db);
 }
 
 void Databases::Remove(const std::string &db) {
@@ -530,13 +523,13 @@ void Databases::DenyAll() {
   denies_dbs_.clear();
 }
 
-bool Databases::SetDefault(std::string_view db) {
+bool Databases::SetDefault(const std::string &db) {
   if (!Contains(db)) return false;
   default_db_ = db;
   return true;
 }
 
-[[nodiscard]] bool Databases::Contains(std::string_view db) const {
+[[nodiscard]] bool Databases::Contains(const std::string &db) const {
   return !denies_dbs_.contains(db) && (allow_all_ || grants_dbs_.contains(db));
 }
 
@@ -549,10 +542,10 @@ const std::string &Databases::GetDefault() const {
 
 nlohmann::json Databases::Serialize() const {
   nlohmann::json data = nlohmann::json::object();
-  data[kGrants] = grants_dbs_;
-  data[kDenies] = denies_dbs_;
-  data[kAllowAll] = allow_all_;
-  data[kDefault] = default_db_;
+  data["grants"] = grants_dbs_;
+  data["denies"] = denies_dbs_;
+  data["allow_all"] = allow_all_;
+  data["default"] = default_db_;
   return data;
 }
 
@@ -560,22 +553,22 @@ Databases Databases::Deserialize(const nlohmann::json &data) {
   if (!data.is_object()) {
     throw AuthException("Couldn't load database data!");
   }
-  if (!data[kGrants].is_structured() || !data[kDenies].is_structured() || !data[kAllowAll].is_boolean() ||
-      !data[kDefault].is_string()) {
+  if (!data["grants"].is_structured() || !data["denies"].is_structured() || !data["allow_all"].is_boolean() ||
+      !data["default"].is_string()) {
     throw AuthException("Couldn't load database data!");
   }
-  return {data[kAllowAll], data[kGrants], data[kDenies], data[kDefault]};
+  return {data["allow_all"], data["grants"], data["denies"], data["default"]};
 }
 #endif
 
 User::User() = default;
 
 User::User(const std::string &username) : username_(utils::ToLowerCase(username)) {}
-User::User(const std::string &username, std::optional<HashedPassword> password_hash, const Permissions &permissions)
+User::User(const std::string &username, std::string password_hash, const Permissions &permissions)
     : username_(utils::ToLowerCase(username)), password_hash_(std::move(password_hash)), permissions_(permissions) {}
 
 #ifdef MG_ENTERPRISE
-User::User(const std::string &username, std::optional<HashedPassword> password_hash, const Permissions &permissions,
+User::User(const std::string &username, std::string password_hash, const Permissions &permissions,
            FineGrainedAccessHandler fine_grained_access_handler, Databases db_access)
     : username_(utils::ToLowerCase(username)),
       password_hash_(std::move(password_hash)),
@@ -585,16 +578,38 @@ User::User(const std::string &username, std::optional<HashedPassword> password_h
 #endif
 
 bool User::CheckPassword(const std::string &password) {
-  return password_hash_ ? password_hash_->VerifyPassword(password) : true;
+  if (password_hash_.empty()) return true;
+  return VerifyPassword(password, password_hash_);
 }
 
-void User::UpdatePassword(const std::optional<std::string> &password,
-                          std::optional<PasswordHashAlgorithm> algo_override) {
+void User::UpdatePassword(const std::optional<std::string> &password) {
   if (!password) {
-    password_hash_.reset();
+    if (!FLAGS_auth_password_permit_null) {
+      throw AuthException("Null passwords aren't permitted!");
+    }
+    password_hash_ = "";
     return;
   }
-  password_hash_ = HashPassword(*password, algo_override);
+
+  if (FLAGS_auth_password_strength_regex != default_password_regex) {
+    if (const auto license_check_result = license::global_license_checker.IsEnterpriseValid(utils::global_settings);
+        license_check_result.HasError()) {
+      throw AuthException(
+          "Custom password regex is a Memgraph Enterprise feature. Please set the config "
+          "(\"--auth-password-strength-regex\") to its default value (\"{}\") or remove the flag.\n{}",
+          default_password_regex,
+          license::LicenseCheckErrorToString(license_check_result.GetError(), "password regex"));
+    }
+  }
+  std::regex re(FLAGS_auth_password_strength_regex);
+  if (!std::regex_match(*password, re)) {
+    throw AuthException(
+        "The user password doesn't conform to the required strength! Regex: "
+        "\"{}\"",
+        FLAGS_auth_password_strength_regex);
+  }
+
+  password_hash_ = EncryptPassword(*password);
 }
 
 void User::SetRole(const Role &role) { role_.emplace(role); }
@@ -611,49 +626,27 @@ Permissions User::GetPermissions() const {
 
 #ifdef MG_ENTERPRISE
 FineGrainedAccessPermissions User::GetFineGrainedAccessLabelPermissions() const {
-  return Merge(GetUserFineGrainedAccessLabelPermissions(), GetRoleFineGrainedAccessLabelPermissions());
-}
-
-FineGrainedAccessPermissions User::GetFineGrainedAccessEdgeTypePermissions() const {
-  return Merge(GetUserFineGrainedAccessEdgeTypePermissions(), GetRoleFineGrainedAccessEdgeTypePermissions());
-}
-
-FineGrainedAccessPermissions User::GetUserFineGrainedAccessEdgeTypePermissions() const {
   if (!memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
     return FineGrainedAccessPermissions{};
   }
 
-  return fine_grained_access_handler_.edge_type_permissions();
-}
-
-FineGrainedAccessPermissions User::GetUserFineGrainedAccessLabelPermissions() const {
-  if (!memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
-    return FineGrainedAccessPermissions{};
+  if (role_) {
+    return Merge(role()->fine_grained_access_handler().label_permissions(),
+                 fine_grained_access_handler_.label_permissions());
   }
 
   return fine_grained_access_handler_.label_permissions();
 }
 
-FineGrainedAccessPermissions User::GetRoleFineGrainedAccessEdgeTypePermissions() const {
+FineGrainedAccessPermissions User::GetFineGrainedAccessEdgeTypePermissions() const {
   if (!memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
     return FineGrainedAccessPermissions{};
   }
-
   if (role_) {
-    return role()->fine_grained_access_handler().edge_type_permissions();
+    return Merge(role()->fine_grained_access_handler().edge_type_permissions(),
+                 fine_grained_access_handler_.edge_type_permissions());
   }
-  return FineGrainedAccessPermissions{};
-}
-
-FineGrainedAccessPermissions User::GetRoleFineGrainedAccessLabelPermissions() const {
-  if (!memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
-    return FineGrainedAccessPermissions{};
-  }
-
-  if (role_) {
-    return role()->fine_grained_access_handler().label_permissions();
-  }
-  return FineGrainedAccessPermissions{};
+  return fine_grained_access_handler_.edge_type_permissions();
 }
 #endif
 
@@ -675,20 +668,16 @@ const Role *User::role() const {
 
 nlohmann::json User::Serialize() const {
   nlohmann::json data = nlohmann::json::object();
-  data[kUsername] = username_;
-  if (password_hash_.has_value()) {
-    data[kPasswordHash] = *password_hash_;
-  } else {
-    data[kPasswordHash] = nullptr;
-  }
-  data[kPermissions] = permissions_.Serialize();
+  data["username"] = username_;
+  data["password_hash"] = password_hash_;
+  data["permissions"] = permissions_.Serialize();
 #ifdef MG_ENTERPRISE
   if (memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
-    data[kFineGrainedAccessHandler] = fine_grained_access_handler_.Serialize();
-    data[kDatabases] = database_access_.Serialize();
+    data["fine_grained_access_handler"] = fine_grained_access_handler_.Serialize();
+    data["databases"] = database_access_.Serialize();
   } else {
-    data[kFineGrainedAccessHandler] = {};
-    data[kDatabases] = {};
+    data["fine_grained_access_handler"] = {};
+    data["databases"] = {};
   }
 #endif
   // The role shouldn't be serialized here, it is stored as a foreign key.
@@ -699,23 +688,15 @@ User User::Deserialize(const nlohmann::json &data) {
   if (!data.is_object()) {
     throw AuthException("Couldn't load user data!");
   }
-  auto password_hash_json = data[kPasswordHash];
-  if (!data[kUsername].is_string() || !(password_hash_json.is_object() || password_hash_json.is_null()) ||
-      !data[kPermissions].is_object()) {
+  if (!data["username"].is_string() || !data["password_hash"].is_string() || !data["permissions"].is_object()) {
     throw AuthException("Couldn't load user data!");
   }
-
-  std::optional<HashedPassword> password_hash{};
-  if (password_hash_json.is_object()) {
-    password_hash = password_hash_json.get<HashedPassword>();
-  }
-
-  auto permissions = Permissions::Deserialize(data[kPermissions]);
+  auto permissions = Permissions::Deserialize(data["permissions"]);
 #ifdef MG_ENTERPRISE
   if (memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
     Databases db_access;
-    if (data[kDatabases].is_structured()) {
-      db_access = Databases::Deserialize(data[kDatabases]);
+    if (data["databases"].is_structured()) {
+      db_access = Databases::Deserialize(data["databases"]);
     } else {
       // Back-compatibility
       spdlog::warn("User without specified database access. Given access to the default database.");
@@ -724,13 +705,13 @@ User User::Deserialize(const nlohmann::json &data) {
     }
     FineGrainedAccessHandler fine_grained_access_handler;
     // We can have an empty fine_grained if the user was created without a valid license
-    if (data[kFineGrainedAccessHandler].is_object()) {
-      fine_grained_access_handler = FineGrainedAccessHandler::Deserialize(data[kFineGrainedAccessHandler]);
+    if (data["fine_grained_access_handler"].is_object()) {
+      fine_grained_access_handler = FineGrainedAccessHandler::Deserialize(data["fine_grained_access_handler"]);
     }
-    return {data[kUsername], std::move(password_hash), permissions, std::move(fine_grained_access_handler), db_access};
+    return {data["username"], data["password_hash"], permissions, std::move(fine_grained_access_handler), db_access};
   }
 #endif
-  return {data[kUsername], std::move(password_hash), permissions};
+  return {data["username"], data["password_hash"], permissions};
 }
 
 bool operator==(const User &first, const User &second) {

src/auth/models.hpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Licensed as a Memgraph Enterprise file under the Memgraph Enterprise
 // License (the "License"); by using this file, you agree to be bound by the terms of the License, and you may not use
@@ -15,7 +15,6 @@
 
 #include <json/json.hpp>
 #include <utility>
-#include "crypto.hpp"
 #include "dbms/constants.hpp"
 #include "utils/logging.hpp"
 
@@ -49,7 +48,6 @@ enum class Permission : uint64_t {
   STORAGE_MODE = 1U << 22U,
   MULTI_DATABASE_EDIT = 1U << 23U,
   MULTI_DATABASE_USE  = 1U << 24U,
-  COORDINATOR  = 1U << 25U,
 };
 // clang-format on
 
@@ -207,8 +205,6 @@ bool operator==(const FineGrainedAccessHandler &first, const FineGrainedAccessHa
 
 class Role final {
  public:
-  Role() = default;
-
   explicit Role(const std::string &rolename);
   Role(const std::string &rolename, const Permissions &permissions);
 #ifdef MG_ENTERPRISE
@@ -250,7 +246,7 @@ bool operator==(const Role &first, const Role &second);
 #ifdef MG_ENTERPRISE
 class Databases final {
  public:
-  Databases() : grants_dbs_{std::string{dbms::kDefaultDB}}, allow_all_(false), default_db_(dbms::kDefaultDB) {}
+  Databases() : grants_dbs_({dbms::kDefaultDB}), allow_all_(false), default_db_(dbms::kDefaultDB) {}
 
   Databases(const Databases &) = default;
   Databases &operator=(const Databases &) = default;
@@ -263,7 +259,7 @@ class Databases final {
    *
    * @param db name of the database to grant access to
    */
-  void Add(std::string_view db);
+  void Add(const std::string &db);
 
   /**
    * @brief Remove database to the list of granted access.
@@ -295,7 +291,7 @@ class Databases final {
   /**
    * @brief Set the default database.
    */
-  bool SetDefault(std::string_view db);
+  bool SetDefault(const std::string &db);
 
   /**
    * @brief Checks if access is grated to the database.
@@ -303,7 +299,7 @@ class Databases final {
    * @param db name of the database
    * @return true if allow_all and not denied or granted
    */
-  bool Contains(std::string_view db) const;
+  bool Contains(const std::string &db) const;
 
   bool GetAllowAll() const { return allow_all_; }
   const std::set<std::string, std::less<>> &GetGrants() const { return grants_dbs_; }
@@ -316,7 +312,7 @@ class Databases final {
 
  private:
   Databases(bool allow_all, std::set<std::string, std::less<>> grant, std::set<std::string, std::less<>> deny,
-            std::string default_db = std::string{dbms::kDefaultDB})
+            std::string default_db = dbms::kDefaultDB)
       : grants_dbs_(std::move(grant)),
         denies_dbs_(std::move(deny)),
         allow_all_(allow_all),
@@ -335,9 +331,9 @@ class User final {
   User();
 
   explicit User(const std::string &username);
-  User(const std::string &username, std::optional<HashedPassword> password_hash, const Permissions &permissions);
+  User(const std::string &username, std::string password_hash, const Permissions &permissions);
 #ifdef MG_ENTERPRISE
-  User(const std::string &username, std::optional<HashedPassword> password_hash, const Permissions &permissions,
+  User(const std::string &username, std::string password_hash, const Permissions &permissions,
        FineGrainedAccessHandler fine_grained_access_handler, Databases db_access = {});
 #endif
   User(const User &) = default;
@@ -349,18 +345,8 @@ class User final {
   /// @throw AuthException if unable to verify the password.
   bool CheckPassword(const std::string &password);
 
-  bool UpgradeHash(const std::string password) {
-    if (!password_hash_) return false;
-    if (password_hash_->IsSalted()) return false;
-
-    auto const algo = password_hash_->HashAlgo();
-    UpdatePassword(password, algo);
-    return true;
-  }
-
   /// @throw AuthException if unable to set the password.
-  void UpdatePassword(const std::optional<std::string> &password = {},
-                      std::optional<PasswordHashAlgorithm> algo_override = std::nullopt);
+  void UpdatePassword(const std::optional<std::string> &password = std::nullopt);
 
   void SetRole(const Role &role);
 
@@ -371,10 +357,6 @@ class User final {
 #ifdef MG_ENTERPRISE
   FineGrainedAccessPermissions GetFineGrainedAccessLabelPermissions() const;
   FineGrainedAccessPermissions GetFineGrainedAccessEdgeTypePermissions() const;
-  FineGrainedAccessPermissions GetUserFineGrainedAccessLabelPermissions() const;
-  FineGrainedAccessPermissions GetUserFineGrainedAccessEdgeTypePermissions() const;
-  FineGrainedAccessPermissions GetRoleFineGrainedAccessLabelPermissions() const;
-  FineGrainedAccessPermissions GetRoleFineGrainedAccessEdgeTypePermissions() const;
   const FineGrainedAccessHandler &fine_grained_access_handler() const;
   FineGrainedAccessHandler &fine_grained_access_handler();
 #endif
@@ -399,7 +381,7 @@ class User final {
 
  private:
   std::string username_;
-  std::optional<HashedPassword> password_hash_;
+  std::string password_hash_;
   Permissions permissions_;
 #ifdef MG_ENTERPRISE
   FineGrainedAccessHandler fine_grained_access_handler_;

src/auth/replication_handlers.cpp

@@ -1,170 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#include "auth/replication_handlers.hpp"
-
-#include "auth/auth.hpp"
-#include "auth/rpc.hpp"
-#include "license/license.hpp"
-
-namespace memgraph::auth {
-
-#ifdef MG_ENTERPRISE
-void UpdateAuthDataHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access, auth::SynchedAuth &auth,
-                           slk::Reader *req_reader, slk::Builder *res_builder) {
-  replication::UpdateAuthDataReq req;
-  memgraph::slk::Load(&req, req_reader);
-
-  using memgraph::replication::UpdateAuthDataRes;
-  UpdateAuthDataRes res(false);
-
-  // Note: No need to check epoch, recovery mechanism is done by a full uptodate snapshot
-  //       of the set of databases. Hence no history exists to maintain regarding epoch change.
-  //       If MAIN has changed we need to check this new group_timestamp is consistent with
-  //       what we have so far.
-
-  if (req.expected_group_timestamp != system_state_access.LastCommitedTS()) {
-    spdlog::debug("UpdateAuthDataHandler: bad expected timestamp {},{}", req.expected_group_timestamp,
-                  system_state_access.LastCommitedTS());
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
-  try {
-    // Update
-    if (req.user) auth->SaveUser(*req.user);
-    if (req.role) auth->SaveRole(*req.role);
-    // Success
-    system_state_access.SetLastCommitedTS(req.new_group_timestamp);
-    res = UpdateAuthDataRes(true);
-    spdlog::debug("UpdateAuthDataHandler: SUCCESS updated LCTS to {}", req.new_group_timestamp);
-  } catch (const auth::AuthException & /* not used */) {
-    // Failure
-  }
-
-  memgraph::slk::Save(res, res_builder);
-}
-
-void DropAuthDataHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access, auth::SynchedAuth &auth,
-                         slk::Reader *req_reader, slk::Builder *res_builder) {
-  replication::DropAuthDataReq req;
-  memgraph::slk::Load(&req, req_reader);
-
-  using memgraph::replication::DropAuthDataRes;
-  DropAuthDataRes res(false);
-
-  // Note: No need to check epoch, recovery mechanism is done by a full uptodate snapshot
-  //       of the set of databases. Hence no history exists to maintain regarding epoch change.
-  //       If MAIN has changed we need to check this new group_timestamp is consistent with
-  //       what we have so far.
-
-  if (req.expected_group_timestamp != system_state_access.LastCommitedTS()) {
-    spdlog::debug("DropAuthDataHandler: bad expected timestamp {},{}", req.expected_group_timestamp,
-                  system_state_access.LastCommitedTS());
-    memgraph::slk::Save(res, res_builder);
-    return;
-  }
-
-  try {
-    // Remove
-    switch (req.type) {
-      case replication::DropAuthDataReq::DataType::USER:
-        auth->RemoveUser(req.name);
-        break;
-      case replication::DropAuthDataReq::DataType::ROLE:
-        auth->RemoveRole(req.name);
-        break;
-    }
-    // Success
-    system_state_access.SetLastCommitedTS(req.new_group_timestamp);
-    res = DropAuthDataRes(true);
-    spdlog::debug("DropAuthDataHandler: SUCCESS updated LCTS to {}", req.new_group_timestamp);
-  } catch (const auth::AuthException & /* not used */) {
-    // Failure
-  }
-
-  memgraph::slk::Save(res, res_builder);
-}
-
-bool SystemRecoveryHandler(auth::SynchedAuth &auth, auth::Auth::Config auth_config,
-                           const std::vector<auth::User> &users, const std::vector<auth::Role> &roles) {
-  return auth.WithLock([&](auto &locked_auth) {
-    // Update config
-    locked_auth.SetConfig(std::move(auth_config));
-    // Get all current users
-    auto old_users = locked_auth.AllUsernames();
-    // Save incoming users
-    for (const auto &user : users) {
-      // Missing users
-      try {
-        locked_auth.SaveUser(user);
-      } catch (const auth::AuthException &) {
-        spdlog::debug("SystemRecoveryHandler: Failed to save user");
-        return false;
-      }
-      const auto it = std::find(old_users.begin(), old_users.end(), user.username());
-      if (it != old_users.end()) old_users.erase(it);
-    }
-    // Delete all the leftover users
-    for (const auto &user : old_users) {
-      if (!locked_auth.RemoveUser(user)) {
-        spdlog::debug("SystemRecoveryHandler: Failed to remove user \"{}\".", user);
-        return false;
-      }
-    }
-
-    // Roles are only supported with a license
-    if (license::global_license_checker.IsEnterpriseValidFast()) {
-      // Get all current roles
-      auto old_roles = locked_auth.AllRolenames();
-      // Save incoming users
-      for (const auto &role : roles) {
-        // Missing users
-        try {
-          locked_auth.SaveRole(role);
-        } catch (const auth::AuthException &) {
-          spdlog::debug("SystemRecoveryHandler: Failed to save user");
-          return false;
-        }
-        const auto it = std::find(old_roles.begin(), old_roles.end(), role.rolename());
-        if (it != old_roles.end()) old_roles.erase(it);
-      }
-      // Delete all the leftover users
-      for (const auto &role : old_roles) {
-        if (!locked_auth.RemoveRole(role)) {
-          spdlog::debug("SystemRecoveryHandler: Failed to remove user \"{}\".", role);
-          return false;
-        }
-      }
-    }
-
-    // Success
-    return true;
-  });
-}
-
-void Register(replication::RoleReplicaData const &data, system::ReplicaHandlerAccessToState &system_state_access,
-              auth::SynchedAuth &auth) {
-  // NOTE: Register even without license as the user could add a license at run-time
-  data.server->rpc_server_.Register<replication::UpdateAuthDataRpc>(
-      [system_state_access, &auth](auto *req_reader, auto *res_builder) mutable {
-        spdlog::debug("Received UpdateAuthDataRpc");
-        UpdateAuthDataHandler(system_state_access, auth, req_reader, res_builder);
-      });
-  data.server->rpc_server_.Register<replication::DropAuthDataRpc>(
-      [system_state_access, &auth](auto *req_reader, auto *res_builder) mutable {
-        spdlog::debug("Received DropAuthDataRpc");
-        DropAuthDataHandler(system_state_access, auth, req_reader, res_builder);
-      });
-}
-#endif
-
-}  // namespace memgraph::auth

src/auth/replication_handlers.hpp

@@ -1,31 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include "auth/auth.hpp"
-#include "replication/state.hpp"
-#include "slk/streams.hpp"
-#include "system/state.hpp"
-
-namespace memgraph::auth {
-#ifdef MG_ENTERPRISE
-void UpdateAuthDataHandler(system::ReplicaHandlerAccessToState &system_state_access, auth::SynchedAuth &auth,
-                           slk::Reader *req_reader, slk::Builder *res_builder);
-void DropAuthDataHandler(system::ReplicaHandlerAccessToState &system_state_access, auth::SynchedAuth &auth,
-                         slk::Reader *req_reader, slk::Builder *res_builder);
-
-bool SystemRecoveryHandler(auth::SynchedAuth &auth, auth::Auth::Config auth_config,
-                           const std::vector<auth::User> &users, const std::vector<auth::Role> &roles);
-void Register(replication::RoleReplicaData const &data, system::ReplicaHandlerAccessToState &system_state_access,
-              auth::SynchedAuth &auth);
-#endif
-}  // namespace memgraph::auth

src/auth/rpc.cpp

@@ -1,178 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#include "auth/rpc.hpp"
-
-#include <json/json.hpp>
-#include "auth/auth.hpp"
-#include "slk/serialization.hpp"
-#include "slk/streams.hpp"
-#include "utils/enum.hpp"
-
-namespace memgraph::slk {
-
-// Serialize code for auth::Role
-void Save(const auth::Role &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.Serialize().dump(), builder);
-}
-namespace {
-auth::Role LoadAuthRole(memgraph::slk::Reader *reader) {
-  std::string tmp;
-  memgraph::slk::Load(&tmp, reader);
-  const auto json = nlohmann::json::parse(tmp);
-  return memgraph::auth::Role::Deserialize(json);
-}
-}  // namespace
-// Deserialize code for auth::Role
-void Load(auth::Role *self, memgraph::slk::Reader *reader) { *self = LoadAuthRole(reader); }
-// Special case for optional<Role>
-template <>
-inline void Load<auth::Role>(std::optional<auth::Role> *obj, Reader *reader) {
-  bool exists = false;
-  Load(&exists, reader);
-  if (exists) {
-    obj->emplace(LoadAuthRole(reader));
-  } else {
-    *obj = std::nullopt;
-  }
-}
-
-// Serialize code for auth::User
-void Save(const auth::User &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.Serialize().dump(), builder);
-  std::optional<auth::Role> role{};
-  if (const auto *role_ptr = self.role(); role_ptr) {
-    role.emplace(*role_ptr);
-  }
-  memgraph::slk::Save(role, builder);
-}
-// Deserialize code for auth::User
-void Load(auth::User *self, memgraph::slk::Reader *reader) {
-  std::string tmp;
-  memgraph::slk::Load(&tmp, reader);
-  const auto json = nlohmann::json::parse(tmp);
-  *self = memgraph::auth::User::Deserialize(json);
-  std::optional<auth::Role> role{};
-  memgraph::slk::Load(&role, reader);
-  if (role)
-    self->SetRole(*role);
-  else
-    self->ClearRole();
-}
-
-// Serialize code for auth::Auth::Config
-void Save(const auth::Auth::Config &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.name_regex_str, builder);
-  memgraph::slk::Save(self.password_regex_str, builder);
-  memgraph::slk::Save(self.password_permit_null, builder);
-}
-// Deserialize code for auth::Auth::Config
-void Load(auth::Auth::Config *self, memgraph::slk::Reader *reader) {
-  std::string name_regex_str{};
-  std::string password_regex_str{};
-  bool password_permit_null{};
-
-  memgraph::slk::Load(&name_regex_str, reader);
-  memgraph::slk::Load(&password_regex_str, reader);
-  memgraph::slk::Load(&password_permit_null, reader);
-
-  *self = auth::Auth::Config{std::move(name_regex_str), std::move(password_regex_str), password_permit_null};
-}
-
-// Serialize code for UpdateAuthDataReq
-void Save(const memgraph::replication::UpdateAuthDataReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.epoch_id, builder);
-  memgraph::slk::Save(self.expected_group_timestamp, builder);
-  memgraph::slk::Save(self.new_group_timestamp, builder);
-  memgraph::slk::Save(self.user, builder);
-  memgraph::slk::Save(self.role, builder);
-}
-void Load(memgraph::replication::UpdateAuthDataReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->epoch_id, reader);
-  memgraph::slk::Load(&self->expected_group_timestamp, reader);
-  memgraph::slk::Load(&self->new_group_timestamp, reader);
-  memgraph::slk::Load(&self->user, reader);
-  memgraph::slk::Load(&self->role, reader);
-}
-
-// Serialize code for UpdateAuthDataRes
-void Save(const memgraph::replication::UpdateAuthDataRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.success, builder);
-}
-void Load(memgraph::replication::UpdateAuthDataRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->success, reader);
-}
-
-// Serialize code for DropAuthDataReq
-void Save(const memgraph::replication::DropAuthDataReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.epoch_id, builder);
-  memgraph::slk::Save(self.expected_group_timestamp, builder);
-  memgraph::slk::Save(self.new_group_timestamp, builder);
-  memgraph::slk::Save(utils::EnumToNum<2, uint8_t>(self.type), builder);
-  memgraph::slk::Save(self.name, builder);
-}
-void Load(memgraph::replication::DropAuthDataReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->epoch_id, reader);
-  memgraph::slk::Load(&self->expected_group_timestamp, reader);
-  memgraph::slk::Load(&self->new_group_timestamp, reader);
-  uint8_t type_tmp = 0;
-  memgraph::slk::Load(&type_tmp, reader);
-  if (!utils::NumToEnum<2>(type_tmp, self->type)) {
-    throw SlkReaderException("Unexpected result line:{}!", __LINE__);
-  }
-  memgraph::slk::Load(&self->name, reader);
-}
-
-// Serialize code for DropAuthDataRes
-void Save(const memgraph::replication::DropAuthDataRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.success, builder);
-}
-void Load(memgraph::replication::DropAuthDataRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->success, reader);
-}
-
-}  // namespace memgraph::slk
-
-namespace memgraph::replication {
-
-constexpr utils::TypeInfo UpdateAuthDataReq::kType{utils::TypeId::REP_UPDATE_AUTH_DATA_REQ, "UpdateAuthDataReq",
-                                                   nullptr};
-
-constexpr utils::TypeInfo UpdateAuthDataRes::kType{utils::TypeId::REP_UPDATE_AUTH_DATA_RES, "UpdateAuthDataRes",
-                                                   nullptr};
-
-constexpr utils::TypeInfo DropAuthDataReq::kType{utils::TypeId::REP_DROP_AUTH_DATA_REQ, "DropAuthDataReq", nullptr};
-
-constexpr utils::TypeInfo DropAuthDataRes::kType{utils::TypeId::REP_DROP_AUTH_DATA_RES, "DropAuthDataRes", nullptr};
-
-void UpdateAuthDataReq::Save(const UpdateAuthDataReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void UpdateAuthDataReq::Load(UpdateAuthDataReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-void UpdateAuthDataRes::Save(const UpdateAuthDataRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void UpdateAuthDataRes::Load(UpdateAuthDataRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-
-void DropAuthDataReq::Save(const DropAuthDataReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void DropAuthDataReq::Load(DropAuthDataReq *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
-void DropAuthDataRes::Save(const DropAuthDataRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void DropAuthDataRes::Load(DropAuthDataRes *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
-
-}  // namespace memgraph::replication

src/auth/rpc.hpp

@@ -1,119 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include <optional>
-
-#include "auth/auth.hpp"
-#include "auth/models.hpp"
-#include "rpc/messages.hpp"
-#include "slk/streams.hpp"
-
-namespace memgraph::replication {
-
-struct UpdateAuthDataReq {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(UpdateAuthDataReq *self, memgraph::slk::Reader *reader);
-  static void Save(const UpdateAuthDataReq &self, memgraph::slk::Builder *builder);
-  UpdateAuthDataReq() = default;
-  UpdateAuthDataReq(std::string epoch_id, uint64_t expected_ts, uint64_t new_ts, auth::User user)
-      : epoch_id{std::move(epoch_id)},
-        expected_group_timestamp{expected_ts},
-        new_group_timestamp{new_ts},
-        user{std::move(user)} {}
-  UpdateAuthDataReq(std::string epoch_id, uint64_t expected_ts, uint64_t new_ts, auth::Role role)
-      : epoch_id{std::move(epoch_id)},
-        expected_group_timestamp{expected_ts},
-        new_group_timestamp{new_ts},
-        role{std::move(role)} {}
-
-  std::string epoch_id;
-  uint64_t expected_group_timestamp;
-  uint64_t new_group_timestamp;
-  std::optional<auth::User> user;
-  std::optional<auth::Role> role;
-};
-
-struct UpdateAuthDataRes {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(UpdateAuthDataRes *self, memgraph::slk::Reader *reader);
-  static void Save(const UpdateAuthDataRes &self, memgraph::slk::Builder *builder);
-  UpdateAuthDataRes() = default;
-  explicit UpdateAuthDataRes(bool success) : success{success} {}
-
-  bool success;
-};
-
-using UpdateAuthDataRpc = rpc::RequestResponse<UpdateAuthDataReq, UpdateAuthDataRes>;
-
-struct DropAuthDataReq {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(DropAuthDataReq *self, memgraph::slk::Reader *reader);
-  static void Save(const DropAuthDataReq &self, memgraph::slk::Builder *builder);
-  DropAuthDataReq() = default;
-
-  enum class DataType { USER, ROLE };
-
-  DropAuthDataReq(std::string epoch_id, uint64_t expected_ts, uint64_t new_ts, DataType type, std::string_view name)
-      : epoch_id{std::move(epoch_id)},
-        expected_group_timestamp{expected_ts},
-        new_group_timestamp{new_ts},
-        type{type},
-        name{name} {}
-
-  std::string epoch_id;
-  uint64_t expected_group_timestamp;
-  uint64_t new_group_timestamp;
-  DataType type;
-  std::string name;
-};
-
-struct DropAuthDataRes {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(DropAuthDataRes *self, memgraph::slk::Reader *reader);
-  static void Save(const DropAuthDataRes &self, memgraph::slk::Builder *builder);
-  DropAuthDataRes() = default;
-  explicit DropAuthDataRes(bool success) : success{success} {}
-
-  bool success;
-};
-
-using DropAuthDataRpc = rpc::RequestResponse<DropAuthDataReq, DropAuthDataRes>;
-
-}  // namespace memgraph::replication
-
-namespace memgraph::slk {
-
-void Save(const auth::Role &self, memgraph::slk::Builder *builder);
-void Load(auth::Role *self, memgraph::slk::Reader *reader);
-void Save(const auth::User &self, memgraph::slk::Builder *builder);
-void Load(auth::User *self, memgraph::slk::Reader *reader);
-void Save(const auth::Auth::Config &self, memgraph::slk::Builder *builder);
-void Load(auth::Auth::Config *self, memgraph::slk::Reader *reader);
-
-void Save(const memgraph::replication::UpdateAuthDataRes &self, memgraph::slk::Builder *builder);
-void Load(memgraph::replication::UpdateAuthDataRes *self, memgraph::slk::Reader *reader);
-void Save(const memgraph::replication::UpdateAuthDataReq & /*self*/, memgraph::slk::Builder * /*builder*/);
-void Load(memgraph::replication::UpdateAuthDataReq * /*self*/, memgraph::slk::Reader * /*reader*/);
-void Save(const memgraph::replication::DropAuthDataRes &self, memgraph::slk::Builder *builder);
-void Load(memgraph::replication::DropAuthDataRes *self, memgraph::slk::Reader *reader);
-void Save(const memgraph::replication::DropAuthDataReq & /*self*/, memgraph::slk::Builder * /*builder*/);
-void Load(memgraph::replication::DropAuthDataReq * /*self*/, memgraph::slk::Reader * /*reader*/);
-}  // namespace memgraph::slk

src/communication/bolt/v1/states/handlers.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
@@ -170,7 +170,6 @@ inline State HandleFailure(TSession &session, const std::exception &e) {
     spdlog::trace("Error trace: {}", p->trace());
   }
   session.encoder_buffer_.Clear();
-
   auto code_message = ExceptionToErrorMessage(e);
   bool fail_sent = session.encoder_.MessageFailure({{"code", code_message.first}, {"message", code_message.second}});
   if (!fail_sent) {

src/communication/client.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
@@ -12,7 +12,6 @@
 #include "communication/client.hpp"
 
 #include "communication/helpers.hpp"
-#include "io/network/network_error.hpp"
 #include "utils/logging.hpp"
 
 namespace memgraph::communication {
@@ -26,9 +25,7 @@ Client::~Client() {
 
 bool Client::Connect(const io::network::Endpoint &endpoint) {
   // Try to establish a socket connection.
-  if (!socket_.Connect(endpoint)) {
-    return false;
-  }
+  if (!socket_.Connect(endpoint)) return false;
 
   // Enable TCP keep alive for all connections.
   // Because we manually always set the `have_more` flag to the socket

src/communication/http/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
@@ -107,7 +107,7 @@ class Session : public std::enable_shared_from_this<Session<TRequestHandler, TSe
   void DoRead() {
     req_ = {};
 
-    ExecuteForStream([this](auto &stream) {
+    ExecuteForStream([this](auto &&stream) {
       boost::beast::get_lowest_layer(stream).expires_after(std::chrono::seconds(kSSLExpirySeconds));
 
       boost::beast::http::async_read(
@@ -129,7 +129,7 @@ class Session : public std::enable_shared_from_this<Session<TRequestHandler, TSe
     }
 
     auto async_write = [this](boost::beast::http::response<boost::beast::http::string_body> msg) {
-      ExecuteForStream([this, &msg](auto &stream) {
+      ExecuteForStream([this, &msg](auto &&stream) {
         // The lifetime of the message has to extend
         // for the duration of the async operation so
         // we use a shared_ptr to manage it.
@@ -171,7 +171,7 @@ class Session : public std::enable_shared_from_this<Session<TRequestHandler, TSe
   }
 
   auto GetExecutor() {
-    return std::visit(utils::Overloaded{[](auto &stream) { return stream.get_executor(); }}, stream_);
+    return std::visit(utils::Overloaded{[](auto &&stream) { return stream.get_executor(); }}, stream_);
   }
 
   template <typename F>

src/communication/result_stream_faker.hpp

@@ -44,7 +44,7 @@ class ResultStreamFaker {
     std::vector<memgraph::communication::bolt::Value> bvalues;
     bvalues.reserve(values.size());
     for (const auto &value : values) {
-      auto maybe_value = memgraph::glue::ToBoltValue(value, store_, memgraph::storage::View::NEW);
+      auto maybe_value = memgraph::glue::ToBoltValue(value, *store_, memgraph::storage::View::NEW);
       MG_ASSERT(maybe_value.HasValue());
       bvalues.push_back(std::move(*maybe_value));
     }
@@ -56,7 +56,7 @@ class ResultStreamFaker {
   void Summary(const std::map<std::string, memgraph::query::TypedValue> &summary) {
     std::map<std::string, memgraph::communication::bolt::Value> bsummary;
     for (const auto &item : summary) {
-      auto maybe_value = memgraph::glue::ToBoltValue(item.second, store_, memgraph::storage::View::NEW);
+      auto maybe_value = memgraph::glue::ToBoltValue(item.second, *store_, memgraph::storage::View::NEW);
       MG_ASSERT(maybe_value.HasValue());
       bsummary.insert({item.first, std::move(*maybe_value)});
     }

src/communication/websocket/auth.hpp

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

src/coordination/CMakeLists.txt

@@ -1,31 +0,0 @@
-add_library(mg-coordination STATIC)
-add_library(mg::coordination ALIAS mg-coordination)
-target_sources(mg-coordination
-        PUBLIC
-        include/coordination/coordinator_client.hpp
-        include/coordination/coordinator_state.hpp
-        include/coordination/coordinator_rpc.hpp
-        include/coordination/coordinator_server.hpp
-        include/coordination/coordinator_config.hpp
-        include/coordination/coordinator_exceptions.hpp
-        include/coordination/coordinator_instance.hpp
-        include/coordination/coordinator_slk.hpp
-        include/coordination/coordinator_data.hpp
-        include/coordination/constants.hpp
-        include/coordination/coordinator_cluster_config.hpp
-        include/coordination/coordinator_handlers.hpp
-
-        PRIVATE
-        coordinator_client.cpp
-        coordinator_state.cpp
-        coordinator_rpc.cpp
-        coordinator_server.cpp
-        coordinator_data.cpp
-        coordinator_instance.cpp
-        coordinator_handlers.cpp
-)
-target_include_directories(mg-coordination PUBLIC include)
-
-target_link_libraries(mg-coordination
-    PUBLIC mg::utils mg::rpc mg::slk mg::io mg::repl_coord_glue lib::rangev3 nuraft mg-replication_handler
-)

src/coordination/coordinator_client.cpp

@@ -1,105 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#ifdef MG_ENTERPRISE
-
-#include "coordination/coordinator_client.hpp"
-
-#include "coordination/coordinator_config.hpp"
-#include "coordination/coordinator_rpc.hpp"
-#include "replication_coordination_glue/messages.hpp"
-
-namespace memgraph::coordination {
-
-namespace {
-auto CreateClientContext(memgraph::coordination::CoordinatorClientConfig const &config)
-    -> communication::ClientContext {
-  return (config.ssl) ? communication::ClientContext{config.ssl->key_file, config.ssl->cert_file}
-                      : communication::ClientContext{};
-}
-}  // namespace
-
-CoordinatorClient::CoordinatorClient(CoordinatorData *coord_data, CoordinatorClientConfig config,
-                                     HealthCheckCallback succ_cb, HealthCheckCallback fail_cb)
-    : rpc_context_{CreateClientContext(config)},
-      rpc_client_{io::network::Endpoint(io::network::Endpoint::needs_resolving, config.ip_address, config.port),
-                  &rpc_context_},
-      config_{std::move(config)},
-      coord_data_{coord_data},
-      succ_cb_{std::move(succ_cb)},
-      fail_cb_{std::move(fail_cb)} {}
-
-auto CoordinatorClient::InstanceName() const -> std::string { return config_.instance_name; }
-auto CoordinatorClient::SocketAddress() const -> std::string { return rpc_client_.Endpoint().SocketAddress(); }
-
-void CoordinatorClient::StartFrequentCheck() {
-  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_.health_check_frequency_sec, [this, instance_name = config_.instance_name] {
-        try {
-          spdlog::trace("Sending frequent heartbeat to machine {} on {}", instance_name,
-                        rpc_client_.Endpoint().SocketAddress());
-          {  // NOTE: This is intentionally scoped so that stream lock could get released.
-            auto stream{rpc_client_.Stream<memgraph::replication_coordination_glue::FrequentHeartbeatRpc>()};
-            stream.AwaitResponse();
-          }
-          succ_cb_(coord_data_, instance_name);
-        } catch (rpc::RpcFailedException const &) {
-          fail_cb_(coord_data_, instance_name);
-        }
-      });
-}
-
-void CoordinatorClient::StopFrequentCheck() { instance_checker_.Stop(); }
-void CoordinatorClient::PauseFrequentCheck() { instance_checker_.Pause(); }
-void CoordinatorClient::ResumeFrequentCheck() { instance_checker_.Resume(); }
-
-auto CoordinatorClient::SetCallbacks(HealthCheckCallback succ_cb, HealthCheckCallback fail_cb) -> void {
-  succ_cb_ = std::move(succ_cb);
-  fail_cb_ = std::move(fail_cb);
-}
-
-auto CoordinatorClient::ReplicationClientInfo() const -> ReplClientInfo { return config_.replication_client_info; }
-
-auto CoordinatorClient::SendPromoteReplicaToMainRpc(ReplicationClientsInfo replication_clients_info) const -> bool {
-  try {
-    auto stream{rpc_client_.Stream<PromoteReplicaToMainRpc>(std::move(replication_clients_info))};
-    if (!stream.AwaitResponse().success) {
-      spdlog::error("Failed to receive successful RPC failover response!");
-      return false;
-    }
-    return true;
-  } catch (rpc::RpcFailedException const &) {
-    spdlog::error("RPC error occurred while sending failover RPC!");
-  }
-  return false;
-}
-
-auto CoordinatorClient::DemoteToReplica() const -> bool {
-  auto const &instance_name = config_.instance_name;
-  try {
-    auto stream{rpc_client_.Stream<DemoteMainToReplicaRpc>(config_.replication_client_info)};
-    if (!stream.AwaitResponse().success) {
-      spdlog::error("Failed to receive successful RPC response for setting instance {} to replica!", instance_name);
-      return false;
-    }
-    spdlog::info("Sent request RPC from coordinator to instance to set it as replica!");
-    return true;
-  } catch (rpc::RpcFailedException const &) {
-    spdlog::error("Failed to set instance {} to replica!", instance_name);
-  }
-  return false;
-}
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/coordinator_data.cpp

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

src/coordination/coordinator_handlers.cpp

@@ -1,123 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#ifdef MG_ENTERPRISE
-#include "coordination/coordinator_handlers.hpp"
-
-#include <range/v3/view.hpp>
-
-#include "coordination/coordinator_rpc.hpp"
-#include "coordination/include/coordination/coordinator_server.hpp"
-
-namespace memgraph::dbms {
-
-void CoordinatorHandlers::Register(memgraph::coordination::CoordinatorServer &server,
-                                   replication::ReplicationHandler &replication_handler) {
-  server.Register<coordination::PromoteReplicaToMainRpc>(
-      [&](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
-        spdlog::info("Received PromoteReplicaToMainRpc");
-        CoordinatorHandlers::PromoteReplicaToMainHandler(replication_handler, req_reader, res_builder);
-      });
-
-  server.Register<coordination::DemoteMainToReplicaRpc>(
-      [&replication_handler](slk::Reader *req_reader, slk::Builder *res_builder) -> void {
-        spdlog::info("Received DemoteMainToReplicaRpc from coordinator server");
-        CoordinatorHandlers::DemoteMainToReplicaHandler(replication_handler, req_reader, res_builder);
-      });
-}
-
-void CoordinatorHandlers::DemoteMainToReplicaHandler(replication::ReplicationHandler &replication_handler,
-                                                     slk::Reader *req_reader, slk::Builder *res_builder) {
-  spdlog::info("Executing DemoteMainToReplicaHandler");
-
-  if (!replication_handler.IsMain()) {
-    spdlog::error("Setting to replica must be performed on main.");
-    slk::Save(coordination::DemoteMainToReplicaRes{false}, res_builder);
-    return;
-  }
-
-  coordination::DemoteMainToReplicaReq req;
-  slk::Load(&req, req_reader);
-
-  const replication::ReplicationServerConfig clients_config{
-      .ip_address = req.replication_client_info.replication_ip_address,
-      .port = req.replication_client_info.replication_port};
-
-  if (!replication_handler.SetReplicationRoleReplica(clients_config)) {
-    spdlog::error("Demoting main to replica failed!");
-    slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
-    return;
-  }
-
-  slk::Save(coordination::PromoteReplicaToMainRes{true}, res_builder);
-}
-
-void CoordinatorHandlers::PromoteReplicaToMainHandler(replication::ReplicationHandler &replication_handler,
-                                                      slk::Reader *req_reader, slk::Builder *res_builder) {
-  if (!replication_handler.IsReplica()) {
-    spdlog::error("Failover must be performed on replica!");
-    slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
-    return;
-  }
-
-  // This can fail because of disk. If it does, the cluster state could get inconsistent.
-  // We don't handle disk issues.
-  if (!replication_handler.DoReplicaToMainPromotion()) {
-    spdlog::error("Promoting replica to main failed!");
-    slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
-    return;
-  }
-
-  coordination::PromoteReplicaToMainReq req;
-  slk::Load(&req, req_reader);
-
-  auto const converter = [](const auto &repl_info_config) {
-    return replication::ReplicationClientConfig{
-        .name = repl_info_config.instance_name,
-        .mode = repl_info_config.replication_mode,
-        .ip_address = repl_info_config.replication_ip_address,
-        .port = repl_info_config.replication_port,
-    };
-  };
-
-  // registering replicas
-  for (auto const &config : req.replication_clients_info | ranges::views::transform(converter)) {
-    auto instance_client = replication_handler.RegisterReplica(config);
-    if (instance_client.HasError()) {
-      using enum memgraph::replication::RegisterReplicaError;
-      switch (instance_client.GetError()) {
-        // Can't happen, checked on the coordinator side
-        case memgraph::query::RegisterReplicaError::NAME_EXISTS:
-          spdlog::error("Replica with the same name already exists!");
-          slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
-          return;
-        // Can't happen, checked on the coordinator side
-        case memgraph::query::RegisterReplicaError::ENDPOINT_EXISTS:
-          spdlog::error("Replica with the same endpoint already exists!");
-          slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
-          return;
-        // We don't handle disk issues
-        case memgraph::query::RegisterReplicaError::COULD_NOT_BE_PERSISTED:
-          spdlog::error("Registered replica could not be persisted!");
-          slk::Save(coordination::PromoteReplicaToMainRes{false}, res_builder);
-          return;
-        case memgraph::query::RegisterReplicaError::CONNECTION_FAILED:
-          // Connection failure is not a fatal error
-          break;
-      }
-    }
-  }
-
-  slk::Save(coordination::PromoteReplicaToMainRes{true}, res_builder);
-}
-
-}  // namespace memgraph::dbms
-#endif

src/coordination/coordinator_instance.cpp

@@ -1,84 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#ifdef MG_ENTERPRISE
-
-#include "coordination/coordinator_instance.hpp"
-
-namespace memgraph::coordination {
-
-CoordinatorInstance::CoordinatorInstance(CoordinatorData *data, CoordinatorClientConfig config,
-                                         HealthCheckCallback succ_cb, HealthCheckCallback fail_cb)
-    : client_(data, std::move(config), std::move(succ_cb), std::move(fail_cb)),
-      replication_role_(replication_coordination_glue::ReplicationRole::REPLICA),
-      is_alive_(true) {
-  if (!client_.DemoteToReplica()) {
-    throw CoordinatorRegisterInstanceException("Failed to demote instance {} to replica", client_.InstanceName());
-  }
-  client_.StartFrequentCheck();
-}
-
-auto CoordinatorInstance::OnSuccessPing() -> void {
-  last_response_time_ = std::chrono::system_clock::now();
-  is_alive_ = true;
-}
-
-auto CoordinatorInstance::OnFailPing() -> bool {
-  is_alive_ =
-      std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - last_response_time_).count() <
-      CoordinatorClusterConfig::alive_response_time_difference_sec_;
-  return is_alive_;
-}
-
-auto CoordinatorInstance::InstanceName() const -> std::string { return client_.InstanceName(); }
-auto CoordinatorInstance::SocketAddress() const -> std::string { return client_.SocketAddress(); }
-auto CoordinatorInstance::IsAlive() const -> bool { return is_alive_; }
-
-auto CoordinatorInstance::IsReplica() const -> bool {
-  return replication_role_ == replication_coordination_glue::ReplicationRole::REPLICA;
-}
-auto CoordinatorInstance::IsMain() const -> bool {
-  return replication_role_ == replication_coordination_glue::ReplicationRole::MAIN;
-}
-
-auto CoordinatorInstance::PromoteToMain(ReplicationClientsInfo repl_clients_info, HealthCheckCallback main_succ_cb,
-                                        HealthCheckCallback main_fail_cb) -> bool {
-  if (!client_.SendPromoteReplicaToMainRpc(std::move(repl_clients_info))) {
-    return false;
-  }
-
-  replication_role_ = replication_coordination_glue::ReplicationRole::MAIN;
-  client_.SetCallbacks(std::move(main_succ_cb), std::move(main_fail_cb));
-
-  return true;
-}
-
-auto CoordinatorInstance::DemoteToReplica(HealthCheckCallback replica_succ_cb, HealthCheckCallback replica_fail_cb)
-    -> bool {
-  if (!client_.DemoteToReplica()) {
-    return false;
-  }
-
-  replication_role_ = replication_coordination_glue::ReplicationRole::REPLICA;
-  client_.SetCallbacks(std::move(replica_succ_cb), std::move(replica_fail_cb));
-
-  return true;
-}
-
-auto CoordinatorInstance::PauseFrequentCheck() -> void { client_.PauseFrequentCheck(); }
-auto CoordinatorInstance::ResumeFrequentCheck() -> void { client_.ResumeFrequentCheck(); }
-
-auto CoordinatorInstance::ReplicationClientInfo() const -> CoordinatorClientConfig::ReplicationClientInfo {
-  return client_.ReplicationClientInfo();
-}
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/coordinator_rpc.cpp

@@ -1,107 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#ifdef MG_ENTERPRISE
-
-#include "coordination/coordinator_rpc.hpp"
-
-#include "coordination/coordinator_slk.hpp"
-#include "slk/serialization.hpp"
-
-namespace memgraph {
-
-namespace coordination {
-
-void PromoteReplicaToMainReq::Save(const PromoteReplicaToMainReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-
-void PromoteReplicaToMainReq::Load(PromoteReplicaToMainReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-
-void PromoteReplicaToMainRes::Save(const PromoteReplicaToMainRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-
-void PromoteReplicaToMainRes::Load(PromoteReplicaToMainRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-
-void DemoteMainToReplicaReq::Save(const DemoteMainToReplicaReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-
-void DemoteMainToReplicaReq::Load(DemoteMainToReplicaReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-
-void DemoteMainToReplicaRes::Save(const DemoteMainToReplicaRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-
-void DemoteMainToReplicaRes::Load(DemoteMainToReplicaRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-
-}  // namespace coordination
-
-constexpr utils::TypeInfo coordination::PromoteReplicaToMainReq::kType{utils::TypeId::COORD_FAILOVER_REQ,
-                                                                       "CoordPromoteReplicaToMainReq", nullptr};
-
-constexpr utils::TypeInfo coordination::PromoteReplicaToMainRes::kType{utils::TypeId::COORD_FAILOVER_RES,
-                                                                       "CoordPromoteReplicaToMainRes", nullptr};
-
-constexpr utils::TypeInfo coordination::DemoteMainToReplicaReq::kType{utils::TypeId::COORD_SET_REPL_MAIN_REQ,
-                                                                      "CoordDemoteToReplicaReq", nullptr};
-
-constexpr utils::TypeInfo coordination::DemoteMainToReplicaRes::kType{utils::TypeId::COORD_SET_REPL_MAIN_RES,
-                                                                      "CoordDemoteToReplicaRes", nullptr};
-
-namespace slk {
-
-void Save(const memgraph::coordination::PromoteReplicaToMainRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.success, builder);
-}
-
-void Load(memgraph::coordination::PromoteReplicaToMainRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->success, reader);
-}
-
-void Save(const memgraph::coordination::PromoteReplicaToMainReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.replication_clients_info, builder);
-}
-
-void Load(memgraph::coordination::PromoteReplicaToMainReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->replication_clients_info, reader);
-}
-
-void Save(const memgraph::coordination::DemoteMainToReplicaReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.replication_client_info, builder);
-}
-
-void Load(memgraph::coordination::DemoteMainToReplicaReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->replication_client_info, reader);
-}
-
-void Save(const memgraph::coordination::DemoteMainToReplicaRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.success, builder);
-}
-
-void Load(memgraph::coordination::DemoteMainToReplicaRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->success, reader);
-}
-
-}  // namespace slk
-
-}  // namespace memgraph
-
-#endif

src/coordination/coordinator_server.cpp

@@ -1,57 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#ifdef MG_ENTERPRISE
-
-#include "coordination/coordinator_server.hpp"
-#include "replication_coordination_glue/messages.hpp"
-
-namespace memgraph::coordination {
-
-namespace {
-
-auto CreateServerContext(const memgraph::coordination::CoordinatorServerConfig &config)
-    -> communication::ServerContext {
-  return (config.ssl) ? communication::ServerContext{config.ssl->key_file, config.ssl->cert_file, config.ssl->ca_file,
-                                                     config.ssl->verify_peer}
-                      : communication::ServerContext{};
-}
-
-// NOTE: The coordinator server doesn't more than 1 processing thread - each replica can
-// have only a single coordinator server. Also, the single-threaded guarantee
-// simplifies the rest of the implementation.
-constexpr auto kCoordinatorServerThreads = 1;
-
-}  // namespace
-
-CoordinatorServer::CoordinatorServer(const CoordinatorServerConfig &config)
-    : rpc_server_context_{CreateServerContext(config)},
-      rpc_server_{io::network::Endpoint{config.ip_address, config.port}, &rpc_server_context_,
-                  kCoordinatorServerThreads} {
-  rpc_server_.Register<replication_coordination_glue::FrequentHeartbeatRpc>([](auto *req_reader, auto *res_builder) {
-    spdlog::debug("Received FrequentHeartbeatRpc on coordinator server");
-    replication_coordination_glue::FrequentHeartbeatHandler(req_reader, res_builder);
-  });
-}
-
-CoordinatorServer::~CoordinatorServer() {
-  if (rpc_server_.IsRunning()) {
-    auto const &endpoint = rpc_server_.endpoint();
-    spdlog::trace("Closing coordinator server on {}:{}", endpoint.address, endpoint.port);
-    rpc_server_.Shutdown();
-  }
-  rpc_server_.AwaitShutdown();
-}
-
-bool CoordinatorServer::Start() { return rpc_server_.Start(); }
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/coordinator_state.cpp

@@ -1,83 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#ifdef MG_ENTERPRISE
-
-#include "coordination/coordinator_state.hpp"
-
-#include "coordination/coordinator_config.hpp"
-#include "coordination/register_main_replica_coordinator_status.hpp"
-#include "flags/replication.hpp"
-#include "spdlog/spdlog.h"
-#include "utils/logging.hpp"
-#include "utils/variant_helpers.hpp"
-
-#include <algorithm>
-
-namespace memgraph::coordination {
-
-CoordinatorState::CoordinatorState() {
-  MG_ASSERT(!(FLAGS_coordinator && FLAGS_coordinator_server_port),
-            "Instance cannot be a coordinator and have registered coordinator server.");
-
-  spdlog::info("Executing coordinator constructor");
-  if (FLAGS_coordinator_server_port) {
-    spdlog::info("Coordinator server port set");
-    auto const config = CoordinatorServerConfig{
-        .ip_address = kDefaultReplicationServerIp,
-        .port = static_cast<uint16_t>(FLAGS_coordinator_server_port),
-    };
-    spdlog::info("Executing coordinator constructor main replica");
-
-    data_ = CoordinatorMainReplicaData{.coordinator_server_ = std::make_unique<CoordinatorServer>(config)};
-  }
-}
-
-auto CoordinatorState::RegisterInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus {
-  MG_ASSERT(std::holds_alternative<CoordinatorData>(data_),
-            "Coordinator cannot register replica since variant holds wrong alternative");
-
-  return std::visit(
-      memgraph::utils::Overloaded{
-          [](const CoordinatorMainReplicaData & /*coordinator_main_replica_data*/) {
-            return RegisterInstanceCoordinatorStatus::NOT_COORDINATOR;
-          },
-          [config](CoordinatorData &coordinator_data) { return coordinator_data.RegisterInstance(config); }},
-      data_);
-}
-
-auto CoordinatorState::SetInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus {
-  MG_ASSERT(std::holds_alternative<CoordinatorData>(data_),
-            "Coordinator cannot register replica since variant holds wrong alternative");
-
-  return std::visit(
-      memgraph::utils::Overloaded{[](const CoordinatorMainReplicaData & /*coordinator_main_replica_data*/) {
-                                    return SetInstanceToMainCoordinatorStatus::NOT_COORDINATOR;
-                                  },
-                                  [&instance_name](CoordinatorData &coordinator_data) {
-                                    return coordinator_data.SetInstanceToMain(instance_name);
-                                  }},
-      data_);
-}
-
-auto CoordinatorState::ShowInstances() const -> std::vector<CoordinatorInstanceStatus> {
-  MG_ASSERT(std::holds_alternative<CoordinatorData>(data_),
-            "Can't call show instances on data_, as variant holds wrong alternative");
-  return std::get<CoordinatorData>(data_).ShowInstances();
-}
-
-auto CoordinatorState::GetCoordinatorServer() const -> CoordinatorServer & {
-  MG_ASSERT(std::holds_alternative<CoordinatorMainReplicaData>(data_),
-            "Cannot get coordinator server since variant holds wrong alternative");
-  return *std::get<CoordinatorMainReplicaData>(data_).coordinator_server_;
-}
-}  // namespace memgraph::coordination
-#endif

src/coordination/include/coordination/constants.hpp

@@ -1,22 +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
-
-namespace memgraph::coordination {
-
-#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

@@ -1,72 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include "coordination/coordinator_config.hpp"
-#include "rpc/client.hpp"
-#include "utils/scheduler.hpp"
-
-namespace memgraph::coordination {
-
-class CoordinatorData;
-using HealthCheckCallback = std::function<void(CoordinatorData *, std::string_view)>;
-using ReplicationClientsInfo = std::vector<ReplClientInfo>;
-
-class CoordinatorClient {
- public:
-  explicit CoordinatorClient(CoordinatorData *coord_data_, CoordinatorClientConfig config, HealthCheckCallback succ_cb,
-                             HealthCheckCallback fail_cb);
-
-  ~CoordinatorClient() = default;
-
-  CoordinatorClient(CoordinatorClient &) = delete;
-  CoordinatorClient &operator=(CoordinatorClient const &) = delete;
-
-  CoordinatorClient(CoordinatorClient &&) noexcept = delete;
-  CoordinatorClient &operator=(CoordinatorClient &&) noexcept = delete;
-
-  void StartFrequentCheck();
-  void StopFrequentCheck();
-  void PauseFrequentCheck();
-  void ResumeFrequentCheck();
-
-  auto InstanceName() const -> std::string;
-  auto SocketAddress() const -> std::string;
-
-  [[nodiscard]] auto SendPromoteReplicaToMainRpc(ReplicationClientsInfo replication_clients_info) const -> bool;
-  [[nodiscard]] auto DemoteToReplica() const -> bool;
-
-  auto ReplicationClientInfo() const -> ReplClientInfo;
-
-  auto SetCallbacks(HealthCheckCallback succ_cb, HealthCheckCallback fail_cb) -> void;
-
-  friend bool operator==(CoordinatorClient const &first, CoordinatorClient const &second) {
-    return first.config_ == second.config_;
-  }
-
- private:
-  utils::Scheduler instance_checker_;
-
-  // TODO: (andi) Pimpl?
-  communication::ClientContext rpc_context_;
-  mutable rpc::Client rpc_client_;
-
-  CoordinatorClientConfig config_;
-  CoordinatorData *coord_data_;
-  HealthCheckCallback succ_cb_;
-  HealthCheckCallback fail_cb_;
-};
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/include/coordination/coordinator_config.hpp

@@ -1,77 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include "replication_coordination_glue/mode.hpp"
-
-#include <chrono>
-#include <cstdint>
-#include <optional>
-#include <string>
-
-namespace memgraph::coordination {
-
-inline constexpr auto *kDefaultReplicationServerIp = "0.0.0.0";
-
-struct CoordinatorClientConfig {
-  std::string instance_name;
-  std::string ip_address;
-  uint16_t port{};
-  std::chrono::seconds health_check_frequency_sec{1};
-
-  auto SocketAddress() const -> std::string { return ip_address + ":" + std::to_string(port); }
-
-  struct ReplicationClientInfo {
-    std::string instance_name;
-    replication_coordination_glue::ReplicationMode replication_mode{};
-    std::string replication_ip_address;
-    uint16_t replication_port{};
-
-    friend bool operator==(ReplicationClientInfo const &, ReplicationClientInfo const &) = default;
-  };
-
-  ReplicationClientInfo replication_client_info;
-
-  struct SSL {
-    std::string key_file;
-    std::string cert_file;
-
-    friend bool operator==(const SSL &, const SSL &) = default;
-  };
-
-  std::optional<SSL> ssl;
-
-  friend bool operator==(CoordinatorClientConfig const &, CoordinatorClientConfig const &) = default;
-};
-
-using ReplClientInfo = CoordinatorClientConfig::ReplicationClientInfo;
-
-struct CoordinatorServerConfig {
-  std::string ip_address;
-  uint16_t port{};
-  struct SSL {
-    std::string key_file;
-    std::string cert_file;
-    std::string ca_file;
-    bool verify_peer{};
-    friend bool operator==(SSL const &, SSL const &) = default;
-  };
-
-  std::optional<SSL> ssl;
-
-  friend bool operator==(CoordinatorServerConfig const &, CoordinatorServerConfig const &) = default;
-};
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/include/coordination/coordinator_data.hpp

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

src/coordination/include/coordination/coordinator_exceptions.hpp

@@ -1,32 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include "utils/exceptions.hpp"
-
-namespace memgraph::coordination {
-class CoordinatorRegisterInstanceException final : public utils::BasicException {
- public:
-  explicit CoordinatorRegisterInstanceException(const std::string_view what) noexcept
-      : BasicException("Failed to create instance: " + std::string(what)) {}
-
-  template <class... Args>
-  explicit CoordinatorRegisterInstanceException(fmt::format_string<Args...> fmt, Args &&...args) noexcept
-      : CoordinatorRegisterInstanceException(fmt::format(fmt, std::forward<Args>(args)...)) {}
-
-  SPECIALIZE_GET_EXCEPTION_NAME(CoordinatorRegisterInstanceException)
-};
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/include/coordination/coordinator_handlers.hpp

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

src/coordination/include/coordination/coordinator_instance.hpp

@@ -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.
-
-#pragma once
-
-#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"
-
-namespace memgraph::coordination {
-
-class CoordinatorData;
-
-class CoordinatorInstance {
- public:
-  CoordinatorInstance(CoordinatorData *data, CoordinatorClientConfig config, HealthCheckCallback succ_cb,
-                      HealthCheckCallback fail_cb);
-
-  CoordinatorInstance(CoordinatorInstance const &other) = delete;
-  CoordinatorInstance &operator=(CoordinatorInstance const &other) = delete;
-  CoordinatorInstance(CoordinatorInstance &&other) noexcept = delete;
-  CoordinatorInstance &operator=(CoordinatorInstance &&other) noexcept = delete;
-  ~CoordinatorInstance() = default;
-
-  auto OnSuccessPing() -> void;
-  auto OnFailPing() -> bool;
-
-  auto IsAlive() const -> bool;
-
-  auto InstanceName() const -> std::string;
-  auto SocketAddress() const -> std::string;
-
-  auto IsReplica() const -> bool;
-  auto IsMain() const -> bool;
-
-  auto PromoteToMain(ReplicationClientsInfo repl_clients_info, HealthCheckCallback main_succ_cb,
-                     HealthCheckCallback main_fail_cb) -> bool;
-  auto DemoteToReplica(HealthCheckCallback replica_succ_cb, HealthCheckCallback replica_fail_cb) -> bool;
-
-  auto PauseFrequentCheck() -> void;
-  auto ResumeFrequentCheck() -> void;
-
-  auto ReplicationClientInfo() const -> ReplClientInfo;
-
- private:
-  CoordinatorClient client_;
-  replication_coordination_glue::ReplicationRole replication_role_;
-  std::chrono::system_clock::time_point last_response_time_{};
-  bool is_alive_{false};
-
-  friend bool operator==(CoordinatorInstance const &first, CoordinatorInstance const &second) {
-    return first.client_ == second.client_ && first.replication_role_ == second.replication_role_;
-  }
-};
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/include/coordination/coordinator_instance_status.hpp

@@ -1,31 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include "io/network/endpoint.hpp"
-
-#include <string_view>
-
-namespace memgraph::coordination {
-
-struct CoordinatorInstanceStatus {
-  std::string instance_name;
-  std::string socket_address;
-  std::string replication_role;
-  bool is_alive;
-};
-
-}  // namespace memgraph::coordination
-
-#endif

src/coordination/include/coordination/coordinator_rpc.hpp

@@ -1,104 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include "coordination/coordinator_config.hpp"
-#include "rpc/messages.hpp"
-#include "slk/serialization.hpp"
-
-namespace memgraph::coordination {
-
-struct PromoteReplicaToMainReq {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(PromoteReplicaToMainReq *self, memgraph::slk::Reader *reader);
-  static void Save(const PromoteReplicaToMainReq &self, memgraph::slk::Builder *builder);
-
-  explicit PromoteReplicaToMainReq(std::vector<CoordinatorClientConfig::ReplicationClientInfo> replication_clients_info)
-      : replication_clients_info(std::move(replication_clients_info)) {}
-  PromoteReplicaToMainReq() = default;
-
-  std::vector<CoordinatorClientConfig::ReplicationClientInfo> replication_clients_info;
-};
-
-struct PromoteReplicaToMainRes {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(PromoteReplicaToMainRes *self, memgraph::slk::Reader *reader);
-  static void Save(const PromoteReplicaToMainRes &self, memgraph::slk::Builder *builder);
-
-  explicit PromoteReplicaToMainRes(bool success) : success(success) {}
-  PromoteReplicaToMainRes() = default;
-
-  bool success;
-};
-
-using PromoteReplicaToMainRpc = rpc::RequestResponse<PromoteReplicaToMainReq, PromoteReplicaToMainRes>;
-
-struct DemoteMainToReplicaReq {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(DemoteMainToReplicaReq *self, memgraph::slk::Reader *reader);
-  static void Save(const DemoteMainToReplicaReq &self, memgraph::slk::Builder *builder);
-
-  explicit DemoteMainToReplicaReq(CoordinatorClientConfig::ReplicationClientInfo replication_client_info)
-      : replication_client_info(std::move(replication_client_info)) {}
-
-  DemoteMainToReplicaReq() = default;
-
-  CoordinatorClientConfig::ReplicationClientInfo replication_client_info;
-};
-
-struct DemoteMainToReplicaRes {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(DemoteMainToReplicaRes *self, memgraph::slk::Reader *reader);
-  static void Save(const DemoteMainToReplicaRes &self, memgraph::slk::Builder *builder);
-
-  explicit DemoteMainToReplicaRes(bool success) : success(success) {}
-  DemoteMainToReplicaRes() = default;
-
-  bool success;
-};
-
-using DemoteMainToReplicaRpc = rpc::RequestResponse<DemoteMainToReplicaReq, DemoteMainToReplicaRes>;
-
-}  // namespace memgraph::coordination
-
-// SLK serialization declarations
-namespace memgraph::slk {
-
-void Save(const memgraph::coordination::PromoteReplicaToMainRes &self, memgraph::slk::Builder *builder);
-
-void Load(memgraph::coordination::PromoteReplicaToMainRes *self, memgraph::slk::Reader *reader);
-
-void Save(const memgraph::coordination::PromoteReplicaToMainReq &self, memgraph::slk::Builder *builder);
-
-void Load(memgraph::coordination::PromoteReplicaToMainReq *self, memgraph::slk::Reader *reader);
-
-void Save(const memgraph::coordination::DemoteMainToReplicaRes &self, memgraph::slk::Builder *builder);
-
-void Load(memgraph::coordination::DemoteMainToReplicaRes *self, memgraph::slk::Reader *reader);
-
-void Save(const memgraph::coordination::DemoteMainToReplicaReq &self, memgraph::slk::Builder *builder);
-
-void Load(memgraph::coordination::DemoteMainToReplicaReq *self, memgraph::slk::Reader *reader);
-
-}  // namespace memgraph::slk
-
-#endif

src/coordination/include/coordination/coordinator_server.hpp

@@ -1,44 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include "coordination/coordinator_config.hpp"
-#include "rpc/server.hpp"
-
-namespace memgraph::coordination {
-
-class CoordinatorServer {
- public:
-  explicit CoordinatorServer(const CoordinatorServerConfig &config);
-  CoordinatorServer(const CoordinatorServer &) = delete;
-  CoordinatorServer(CoordinatorServer &&) = delete;
-  CoordinatorServer &operator=(const CoordinatorServer &) = delete;
-  CoordinatorServer &operator=(CoordinatorServer &&) = delete;
-
-  virtual ~CoordinatorServer();
-
-  bool Start();
-
-  template <typename TRequestResponse, typename F>
-  void Register(F &&callback) {
-    rpc_server_.Register<TRequestResponse>(std::forward<F>(callback));
-  }
-
- private:
-  communication::ServerContext rpc_server_context_;
-  rpc::Server rpc_server_;
-};
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/include/coordination/coordinator_slk.hpp

@@ -1,38 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include "coordination/coordinator_config.hpp"
-#include "slk/serialization.hpp"
-#include "slk/streams.hpp"
-
-namespace memgraph::slk {
-
-using ReplicationClientInfo = coordination::CoordinatorClientConfig::ReplicationClientInfo;
-
-inline void Save(const ReplicationClientInfo &obj, Builder *builder) {
-  Save(obj.instance_name, builder);
-  Save(obj.replication_mode, builder);
-  Save(obj.replication_ip_address, builder);
-  Save(obj.replication_port, builder);
-}
-
-inline void Load(ReplicationClientInfo *obj, Reader *reader) {
-  Load(&obj->instance_name, reader);
-  Load(&obj->replication_mode, reader);
-  Load(&obj->replication_ip_address, reader);
-  Load(&obj->replication_port, reader);
-}
-}  // namespace memgraph::slk
-#endif

src/coordination/include/coordination/coordinator_state.hpp

@@ -1,50 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include "coordination/coordinator_data.hpp"
-#include "coordination/coordinator_instance_status.hpp"
-#include "coordination/coordinator_server.hpp"
-#include "coordination/register_main_replica_coordinator_status.hpp"
-
-#include <variant>
-
-namespace memgraph::coordination {
-
-class CoordinatorState {
- public:
-  CoordinatorState();
-  ~CoordinatorState() = default;
-
-  CoordinatorState(CoordinatorState const &) = delete;
-  CoordinatorState &operator=(CoordinatorState const &) = delete;
-
-  CoordinatorState(CoordinatorState &&) noexcept = delete;
-  CoordinatorState &operator=(CoordinatorState &&) noexcept = delete;
-
-  [[nodiscard]] auto RegisterInstance(CoordinatorClientConfig config) -> RegisterInstanceCoordinatorStatus;
-
-  [[nodiscard]] auto SetInstanceToMain(std::string instance_name) -> SetInstanceToMainCoordinatorStatus;
-
-  auto ShowInstances() const -> std::vector<CoordinatorInstanceStatus>;
-
-  // The client code must check that the server exists before calling this method.
-  auto GetCoordinatorServer() const -> CoordinatorServer &;
-
- private:
-  std::variant<CoordinatorData, CoordinatorMainReplicaData> data_;
-};
-
-}  // namespace memgraph::coordination
-#endif

src/coordination/include/coordination/register_main_replica_coordinator_status.hpp

@@ -1,36 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include <cstdint>
-
-namespace memgraph::coordination {
-
-enum class RegisterInstanceCoordinatorStatus : uint8_t {
-  NAME_EXISTS,
-  ENDPOINT_EXISTS,
-  NOT_COORDINATOR,
-  RPC_FAILED,
-  SUCCESS
-};
-
-enum class SetInstanceToMainCoordinatorStatus : uint8_t {
-  NO_INSTANCE_WITH_NAME,
-  NOT_COORDINATOR,
-  SUCCESS,
-  COULD_NOT_PROMOTE_TO_MAIN,
-};
-
-}  // namespace memgraph::coordination
-#endif

src/dbms/CMakeLists.txt

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

src/dbms/constants.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
@@ -13,8 +13,7 @@
 
 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
+constexpr static const char *kDefaultDB = "memgraph";  //!< Name of the default database
 
 #ifdef MG_EXPERIMENTAL_REPLICATION_MULTITENANCY
 constexpr bool allow_mt_repl = true;

src/dbms/coordinator_handler.cpp

@@ -1,39 +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 "coordination/register_main_replica_coordinator_status.hpp"
-#ifdef MG_ENTERPRISE
-
-#include "dbms/coordinator_handler.hpp"
-
-#include "dbms/dbms_handler.hpp"
-
-namespace memgraph::dbms {
-
-CoordinatorHandler::CoordinatorHandler(coordination::CoordinatorState &coordinator_state)
-    : coordinator_state_(coordinator_state) {}
-
-auto CoordinatorHandler::RegisterInstance(memgraph::coordination::CoordinatorClientConfig config)
-    -> coordination::RegisterInstanceCoordinatorStatus {
-  return coordinator_state_.RegisterInstance(config);
-}
-
-auto CoordinatorHandler::SetInstanceToMain(std::string instance_name)
-    -> coordination::SetInstanceToMainCoordinatorStatus {
-  return coordinator_state_.SetInstanceToMain(std::move(instance_name));
-}
-
-auto CoordinatorHandler::ShowInstances() const -> std::vector<coordination::CoordinatorInstanceStatus> {
-  return coordinator_state_.ShowInstances();
-}
-}  // namespace memgraph::dbms
-
-#endif

src/dbms/coordinator_handler.hpp

@@ -1,43 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#ifdef MG_ENTERPRISE
-
-#include "coordination/coordinator_config.hpp"
-#include "coordination/coordinator_instance_status.hpp"
-#include "coordination/coordinator_state.hpp"
-#include "coordination/register_main_replica_coordinator_status.hpp"
-
-#include <vector>
-
-namespace memgraph::dbms {
-
-class DbmsHandler;
-
-class CoordinatorHandler {
- public:
-  explicit CoordinatorHandler(coordination::CoordinatorState &coordinator_state);
-
-  auto RegisterInstance(coordination::CoordinatorClientConfig config)
-      -> coordination::RegisterInstanceCoordinatorStatus;
-
-  auto SetInstanceToMain(std::string instance_name) -> coordination::SetInstanceToMainCoordinatorStatus;
-
-  auto ShowInstances() const -> std::vector<coordination::CoordinatorInstanceStatus>;
-
- private:
-  coordination::CoordinatorState &coordinator_state_;
-};
-
-}  // namespace memgraph::dbms
-#endif

src/dbms/database.cpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -11,7 +11,10 @@
 
 #include "dbms/database.hpp"
 #include "dbms/inmemory/storage_helper.hpp"
+#include "dbms/replication_handler.hpp"
+#include "flags/storage_mode.hpp"
 #include "storage/v2/disk/storage.hpp"
+#include "storage/v2/inmemory/storage.hpp"
 #include "storage/v2/storage_mode.hpp"
 
 template struct memgraph::utils::Gatekeeper<memgraph::dbms::Database>;
@@ -23,7 +26,7 @@ Database::Database(storage::Config config, replication::ReplicationState &repl_s
       streams_{config.durability.storage_directory / "streams"},
       plan_cache_{FLAGS_query_plan_cache_max_size},
       repl_state_(&repl_state) {
-  if (config.salient.storage_mode == memgraph::storage::StorageMode::ON_DISK_TRANSACTIONAL || config.force_on_disk ||
+  if (config.storage_mode == memgraph::storage::StorageMode::ON_DISK_TRANSACTIONAL || config.force_on_disk ||
       utils::DirExists(config.disk.main_storage_directory)) {
     storage_ = std::make_unique<storage::DiskStorage>(std::move(config));
   } else {

src/dbms/database.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
@@ -68,12 +68,12 @@ class Database {
    */
   std::unique_ptr<storage::Storage::Accessor> Access(
       std::optional<storage::IsolationLevel> override_isolation_level = {}) {
-    return storage_->Access(repl_state_->GetRole(), override_isolation_level);
+    return storage_->Access(override_isolation_level, repl_state_->IsMain());
   }
 
   std::unique_ptr<storage::Storage::Accessor> UniqueAccess(
       std::optional<storage::IsolationLevel> override_isolation_level = {}) {
-    return storage_->UniqueAccess(repl_state_->GetRole(), override_isolation_level);
+    return storage_->UniqueAccess(override_isolation_level, repl_state_->IsMain());
   }
 
   /**
@@ -81,14 +81,7 @@ class Database {
    *
    * @return const std::string&
    */
-  const std::string &name() const { return storage_->name(); }
-
-  /**
-   * @brief Unique storage identified (uuid)
-   *
-   * @return const utils::UUID&
-   */
-  const utils::UUID &uuid() const { return storage_->uuid(); }
+  const std::string &id() const { return storage_->id(); }
 
   /**
    * @brief Returns the storage configuration
@@ -110,9 +103,9 @@ class Database {
    * @param force_directory Use the configured directory, do not try to decipher the multi-db version
    * @return DatabaseInfo
    */
-  DatabaseInfo GetInfo(bool force_directory, replication_coordination_glue::ReplicationRole replication_role) const {
+  DatabaseInfo GetInfo(bool force_directory = false) const {
     DatabaseInfo info;
-    info.storage_info = storage_->GetInfo(force_directory, replication_role);
+    info.storage_info = storage_->GetInfo(force_directory);
     info.triggers = trigger_store_.GetTriggerInfo().size();
     info.streams = streams_.GetStreamInfo().size();
     return info;

src/dbms/database_handler.hpp

@@ -51,7 +51,7 @@ class DatabaseHandler : public Handler<Database> {
    * @param config Storage configuration
    * @return HandlerT::NewResult
    */
-  HandlerT::NewResult New(storage::Config config, replication::ReplicationState &repl_state) {
+  HandlerT::NewResult New(std::string_view name, storage::Config config, replication::ReplicationState &repl_state) {
     // Control that no one is using the same data directory
     if (std::any_of(begin(), end(), [&](auto &elem) {
           auto db_acc = elem.second.access();
@@ -61,7 +61,8 @@ class DatabaseHandler : public Handler<Database> {
       spdlog::info("Tried to generate new storage using a claimed directory.");
       return NewError::EXISTS;
     }
-    return HandlerT::New(std::piecewise_construct, config.salient.name, config, repl_state);
+    config.name = name;  // Set storage id via config
+    return HandlerT::New(std::piecewise_construct, name, config, repl_state);
   }
 
   /**

src/dbms/dbms_handler.cpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -11,415 +11,65 @@
 
 #include "dbms/dbms_handler.hpp"
 
-#include <cstdint>
-#include <filesystem>
-
-#include "dbms/constants.hpp"
-#include "dbms/global.hpp"
-#include "spdlog/spdlog.h"
-#include "system/include/system/system.hpp"
-#include "utils/exceptions.hpp"
-#include "utils/logging.hpp"
-#include "utils/uuid.hpp"
-
 namespace memgraph::dbms {
-
-namespace {
-constexpr std::string_view kDBPrefix = "database:";  // Key prefix for database durability
-
-std::string RegisterReplicaErrorToString(query::RegisterReplicaError error) {
-  switch (error) {
-    using enum query::RegisterReplicaError;
-    case NAME_EXISTS:
-      return "NAME_EXISTS";
-    case ENDPOINT_EXISTS:
-      return "ENDPOINT_EXISTS";
-    case CONNECTION_FAILED:
-      return "CONNECTION_FAILED";
-    case COULD_NOT_BE_PERSISTED:
-      return "COULD_NOT_BE_PERSISTED";
-  }
-}
-
-// Per storage
-// NOTE Storage will connect to all replicas. Future work might change this
-void RestoreReplication(replication::RoleMainData &mainData, DatabaseAccess db_acc) {
-  spdlog::info("Restoring replication role.");
-
-  // Each individual client has already been restored and started. Here we just go through each database and start its
-  // client
-  for (auto &instance_client : mainData.registered_replicas_) {
-    spdlog::info("Replica {} restoration started for {}.", instance_client.name_, db_acc->name());
-    const auto &ret = db_acc->storage()->repl_storage_state_.replication_clients_.WithLock(
-        [&, db_acc](auto &storage_clients) mutable -> utils::BasicResult<query::RegisterReplicaError> {
-          auto client = std::make_unique<storage::ReplicationStorageClient>(instance_client);
-          auto *storage = db_acc->storage();
-          client->Start(storage, std::move(db_acc));
-          // After start the storage <-> replica state should be READY or RECOVERING (if correctly started)
-          // MAYBE_BEHIND isn't a statement of the current state, this is the default value
-          // Failed to start due to branching of MAIN and REPLICA
-          if (client->State() == storage::replication::ReplicaState::MAYBE_BEHIND) {
-            spdlog::warn("Connection failed when registering replica {}. Replica will still be registered.",
-                         instance_client.name_);
-          }
-          storage_clients.push_back(std::move(client));
-          return {};
-        });
-
-    if (ret.HasError()) {
-      MG_ASSERT(query::RegisterReplicaError::CONNECTION_FAILED != ret.GetError());
-      LOG_FATAL("Failure when restoring replica {}: {}.", instance_client.name_,
-                RegisterReplicaErrorToString(ret.GetError()));
-    }
-    spdlog::info("Replica {} restored for {}.", instance_client.name_, db_acc->name());
-  }
-  spdlog::info("Replication role restored to MAIN.");
-}
-}  // namespace
-
 #ifdef MG_ENTERPRISE
-struct Durability {
-  enum class DurabilityVersion : uint8_t {
-    V0 = 0,
-    V1,
-  };
-
-  struct VersionException : public utils::BasicException {
-    VersionException() : utils::BasicException("Unsupported durability version!") {}
-  };
-
-  struct UnknownVersionException : public utils::BasicException {
-    UnknownVersionException() : utils::BasicException("Unable to parse the durability version!") {}
-  };
-
-  struct MigrationException : public utils::BasicException {
-    MigrationException() : utils::BasicException("Failed to migrate to the current durability version!") {}
-  };
-
-  static DurabilityVersion VersionCheck(std::optional<std::string_view> val) {
-    if (!val) {
-      return DurabilityVersion::V0;
-    }
-    if (val == "V1") {
-      return DurabilityVersion::V1;
-    }
-    throw UnknownVersionException();
-  };
-
-  static auto GenKey(std::string_view name) -> std::string { return fmt::format("{}{}", kDBPrefix, name); }
-
-  static auto GenVal(utils::UUID uuid, std::filesystem::path rel_dir) {
-    nlohmann::json json;
-    json["uuid"] = uuid;
-    json["rel_dir"] = rel_dir;
-    // TODO: Serialize the configuration
-    return json.dump();
-  }
-
-  static void Migrate(kvstore::KVStore *durability, const std::filesystem::path &root) {
-    const auto ver_val = durability->Get("version");
-    const auto ver = VersionCheck(ver_val);
-
-    std::map<std::string, std::string> to_put;
-    std::vector<std::string> to_delete;
-
-    // Update from V0 to V1
-    if (ver == DurabilityVersion::V0) {
-      for (const auto &[key, val] : *durability) {
-        if (key == "version") continue;  // Reserved key
-        // Generate a UUID
-        auto const uuid = utils::UUID();
-        // New json values
-        auto new_key = GenKey(key);
-        auto path = root;
-        if (key != kDefaultDB) {  // Special case for non-default DBs
-          // Move directory to new UUID dir
-          path = root / kMultiTenantDir / std::string{uuid};
-          std::filesystem::path old_dir(root / kMultiTenantDir / key);
-          std::error_code ec;
-          std::filesystem::rename(old_dir, path, ec);
-          MG_ASSERT(!ec, "Failed to upgrade durability: cannot move default directory.");
-        }
-        // Generate json and update value
-        auto new_data = GenVal(uuid, std::filesystem::relative(path, root));
-        to_put.emplace(std::move(new_key), std::move(new_data));
-        to_delete.emplace_back(key);
-      }
-    }
-
-    // Set version
-    durability->Put("version", "V1");
-    // Update to the new key-value pairs
-    if (!durability->PutAndDeleteMultiple(to_put, to_delete)) {
-      throw MigrationException();
-    }
-  }
-};
-
-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} {
+DbmsHandler::DbmsHandler(
+    storage::Config config,
+    memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth,
+    bool recovery_on_startup, bool delete_on_drop)
+    : default_config_{std::move(config)},
+      delete_on_drop_(delete_on_drop),
+      repl_state_{ReplicationStateRootPath(default_config_)} {
   // TODO: Decouple storage config from dbms config
   // TODO: Save individual db configs inside the kvstore and restore from there
-
-  /*
-   * FILESYSTEM MANIPULATION
-   */
-  const auto &root = default_config_.durability.storage_directory;
-  storage::UpdatePaths(default_config_, root);
-  const auto &db_dir = default_config_.durability.storage_directory / kMultiTenantDir;
-  // TODO: Unify durability and wal
+  storage::UpdatePaths(default_config_, default_config_.durability.storage_directory / "databases");
+  const auto &db_dir = default_config_.durability.storage_directory;
   const auto durability_dir = db_dir / ".durability";
   utils::EnsureDirOrDie(db_dir);
   utils::EnsureDirOrDie(durability_dir);
   durability_ = std::make_unique<kvstore::KVStore>(durability_dir);
 
-  /*
-   * DURABILITY
-   */
-  // Migrate durability
-  Durability::Migrate(durability_.get(), root);
-  auto directories = std::set{std::string{kDefaultDB}};
+  // Generate the default database
+  MG_ASSERT(!NewDefault_().HasError(), "Failed while creating the default DB.");
 
   // Recover previous databases
   if (recovery_on_startup) {
-    auto it = durability_->begin(std::string(kDBPrefix));
-    auto end = durability_->end(std::string(kDBPrefix));
-    for (; it != end; ++it) {
-      const auto &[key, config_json] = *it;
-      const auto name = key.substr(kDBPrefix.size());
-      auto json = nlohmann::json::parse(config_json);
-      const auto uuid = json.at("uuid").get<utils::UUID>();
-      const auto rel_dir = json.at("rel_dir").get<std::filesystem::path>();
-      spdlog::info("Restoring database {} at {}.", name, rel_dir);
-      auto new_db = New_(name, uuid, nullptr, rel_dir);
-      MG_ASSERT(!new_db.HasError(), "Failed while creating database {}.", name);
-      directories.emplace(rel_dir.filename());
+    for (const auto &[name, _] : *durability_) {
+      if (name == kDefaultDB) continue;  // Already set
+      spdlog::info("Restoring database {}.", name);
+      MG_ASSERT(!New_(name).HasError(), "Failed while creating database {}.", name);
       spdlog::info("Database {} restored.", name);
     }
   } else {  // Clear databases from the durability list and auth
-    auto locked_auth = auth_.Lock();
-    auto it = durability_->begin(std::string{kDBPrefix});
-    auto end = durability_->end(std::string{kDBPrefix});
-    for (; it != end; ++it) {
-      const auto &[key, _] = *it;
-      const auto name = key.substr(kDBPrefix.size());
+    auto locked_auth = auth->Lock();
+    for (const auto &[name, _] : *durability_) {
       if (name == kDefaultDB) continue;
       locked_auth->DeleteDatabase(name);
-      durability_->Delete(key);
+      durability_->Delete(name);
     }
   }
 
-  /*
-   * DATABASES CLEAN UP
-   */
-  // Clean the unused directories
-  for (const auto &entry : std::filesystem::directory_iterator(db_dir)) {
-    const auto &name = entry.path().filename().string();
-    if (entry.is_directory() && !name.empty() && name.front() != '.') {
-      auto itr = directories.find(name);
-      if (itr == directories.end()) {
-        std::error_code dummy;
-        std::filesystem::remove_all(entry, dummy);
-      } else {
-        directories.erase(itr);
-      }
+  // Startup replication state (if recovered at startup)
+  auto replica = [this](replication::RoleReplicaData const &data) {
+    // Register handlers
+    InMemoryReplicationHandlers::Register(this, *data.server);
+    if (!data.server->Start()) {
+      spdlog::error("Unable to start the replication server.");
+      return false;
     }
-  }
-
-  /*
-   * DEFAULT DB SETUP
-   */
-  // Setup the default DB
-  SetupDefault_();
-}
-
-struct DropDatabase : memgraph::system::ISystemAction {
-  explicit DropDatabase(utils::UUID uuid) : uuid_{uuid} {}
-  void DoDurability() override { /* Done during DBMS execution */
-  }
-
-  bool DoReplication(replication::ReplicationClient &client, replication::ReplicationEpoch const &epoch,
-                     memgraph::system::Transaction const &txn) const override {
-    auto check_response = [](const storage::replication::DropDatabaseRes &response) {
-      return response.result != storage::replication::DropDatabaseRes::Result::FAILURE;
-    };
-
-    return client.SteamAndFinalizeDelta<storage::replication::DropDatabaseRpc>(
-        check_response, epoch.id(), txn.last_committed_system_timestamp(), txn.timestamp(), uuid_);
-  }
-  void PostReplication(replication::RoleMainData &mainData) const override {}
-
- private:
-  utils::UUID uuid_;
-};
-
-DbmsHandler::DeleteResult DbmsHandler::TryDelete(std::string_view db_name, system::Transaction *transaction) {
-  std::lock_guard<LockT> wr(lock_);
-  if (db_name == kDefaultDB) {
-    // MSG cannot delete the default db
-    return DeleteError::DEFAULT_DB;
-  }
-
-  // Get DB config for the UUID and disk clean up
-  const auto conf = db_handler_.GetConfig(db_name);
-  if (!conf) {
-    return DeleteError::NON_EXISTENT;
-  }
-  const auto &storage_path = conf->durability.storage_directory;
-  const auto &uuid = conf->salient.uuid;
-
-  // Check if db exists
-  try {
-    // Low level handlers
-    if (!db_handler_.TryDelete(db_name)) {
-      return DeleteError::USING;
+    return true;
+  };
+  // Replication frequent check start
+  auto main = [this](replication::RoleMainData &data) {
+    for (auto &client : data.registered_replicas_) {
+      StartReplicaClient(*this, client);
     }
-  } catch (utils::BasicException &) {
-    return DeleteError::NON_EXISTENT;
-  }
-
-  // Remove from durability list
-  if (durability_) durability_->Delete(Durability::GenKey(db_name));
-
-  // Delete disk storage
-  std::error_code ec;
-  (void)std::filesystem::remove_all(storage_path, ec);
-  if (ec) {
-    spdlog::error(R"(Failed to clean disk while deleting database "{}" stored in {})", db_name, storage_path);
-  }
-
-  // Success
-  // Save delta
-  if (transaction) {
-    transaction->AddAction<DropDatabase>(uuid);
-  }
-
-  return {};
+    return true;
+  };
+  // Startup proccess for main/replica
+  MG_ASSERT(std::visit(memgraph::utils::Overloaded{replica, main}, repl_state_.ReplicationData()),
+            "Replica recovery failure!");
 }
-
-DbmsHandler::DeleteResult DbmsHandler::Delete(std::string_view db_name) {
-  auto wr = std::lock_guard(lock_);
-  return Delete_(db_name);
-}
-
-DbmsHandler::DeleteResult DbmsHandler::Delete(utils::UUID uuid) {
-  auto wr = std::lock_guard(lock_);
-  std::string db_name;
-  try {
-    const auto db = Get_(uuid);
-    db_name = db->name();
-  } catch (const UnknownDatabaseException &) {
-    return DeleteError::NON_EXISTENT;
-  }
-  return Delete_(db_name);
-}
-
-struct CreateDatabase : memgraph::system::ISystemAction {
-  explicit CreateDatabase(storage::SalientConfig config, DatabaseAccess db_acc)
-      : config_{std::move(config)}, db_acc(db_acc) {}
-
-  void DoDurability() override {
-    // Done during dbms execution
-  }
-
-  bool DoReplication(replication::ReplicationClient &client, replication::ReplicationEpoch const &epoch,
-                     memgraph::system::Transaction const &txn) const override {
-    auto check_response = [](const storage::replication::CreateDatabaseRes &response) {
-      return response.result != storage::replication::CreateDatabaseRes::Result::FAILURE;
-    };
-
-    return client.SteamAndFinalizeDelta<storage::replication::CreateDatabaseRpc>(
-        check_response, epoch.id(), txn.last_committed_system_timestamp(), txn.timestamp(), config_);
-  }
-
-  void PostReplication(replication::RoleMainData &mainData) const override {
-    // Sync database with REPLICAs
-    // NOTE: The function bellow is used to create ReplicationStorageClient, so it must be called on a new storage
-    // We don't need to have it here, since the function won't fail even if the replication client fails to
-    // connect We will just have everything ready, for recovery at some point.
-    dbms::DbmsHandler::RecoverStorageReplication(db_acc, mainData);
-  }
-
- private:
-  storage::SalientConfig config_;
-  DatabaseAccess db_acc;
-};
-
-DbmsHandler::NewResultT DbmsHandler::New_(storage::Config storage_config, system::Transaction *txn) {
-  auto new_db = db_handler_.New(storage_config, repl_state_);
-
-  if (new_db.HasValue()) {  // Success
-                            // Save delta
-    UpdateDurability(storage_config);
-    if (txn) {
-      txn->AddAction<CreateDatabase>(storage_config.salient, new_db.GetValue());
-    }
-  }
-  return new_db;
-}
-
-DbmsHandler::DeleteResult DbmsHandler::Delete_(std::string_view db_name) {
-  if (db_name == kDefaultDB) {
-    // MSG cannot delete the default db
-    return DeleteError::DEFAULT_DB;
-  }
-
-  const auto storage_path = StorageDir_(db_name);
-  if (!storage_path) return DeleteError::NON_EXISTENT;
-
-  {
-    auto db = db_handler_.Get(db_name);
-    if (!db) return DeleteError::NON_EXISTENT;
-    // TODO: ATM we assume REPLICA won't have streams,
-    //       this is a best effort approach just in case they do
-    //       there is still subtle data race we stream manipulation
-    //       can occur while we are dropping the database
-    db->prepare_for_deletion();
-    auto &database = *db->get();
-    database.streams()->StopAll();
-    database.streams()->DropAll();
-    database.thread_pool()->Shutdown();
-  }
-
-  // Remove from durability list
-  if (durability_) durability_->Delete(Durability::GenKey(db_name));
-
-  // Check if db exists
-  // Low level handlers
-  db_handler_.DeferDelete(db_name, [storage_path = *storage_path, db_name = std::string{db_name}]() {
-    // Delete disk storage
-    std::error_code ec;
-    (void)std::filesystem::remove_all(storage_path, ec);
-    if (ec) {
-      spdlog::error(R"(Failed to clean disk while deleting database "{}" stored in {})", db_name, storage_path);
-    }
-  });
-
-  return {};  // Success
-}
-
-void DbmsHandler::UpdateDurability(const storage::Config &config, std::optional<std::filesystem::path> rel_dir) {
-  if (!durability_) return;
-  // Save database in a list of active databases
-  const auto &key = Durability::GenKey(config.salient.name);
-  if (rel_dir == std::nullopt)
-    rel_dir =
-        std::filesystem::relative(config.durability.storage_directory, default_config_.durability.storage_directory);
-  const auto &val = Durability::GenVal(config.salient.uuid, *rel_dir);
-  durability_->Put(key, val);
-}
-
 #endif
 
-void DbmsHandler::RecoverStorageReplication(DatabaseAccess db_acc, replication::RoleMainData &role_main_data) {
-  if (allow_mt_repl || db_acc->name() == dbms::kDefaultDB) {
-    // Handle global replication state
-    spdlog::info("Replication configuration will be stored and will be automatically restored in case of a crash.");
-    // RECOVER REPLICA CONNECTIONS
-    memgraph::dbms::RestoreReplication(role_main_data, db_acc);
-  } else if (!role_main_data.registered_replicas_.empty()) {
-    spdlog::warn("Multi-tenant replication is currently not supported!");
-  }
-}
 }  // namespace memgraph::dbms

src/dbms/dbms_handler.hpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -12,37 +12,34 @@
 #pragma once
 
 #include <algorithm>
-#include <atomic>
+#include <concepts>
 #include <cstdint>
 #include <filesystem>
 #include <memory>
 #include <mutex>
 #include <optional>
+#include <ostream>
+#include <stdexcept>
 #include <system_error>
-#include <utility>
+#include <unordered_map>
 
 #include "auth/auth.hpp"
 #include "constants.hpp"
 #include "dbms/database.hpp"
 #include "dbms/inmemory/replication_handlers.hpp"
-#include "dbms/rpc.hpp"
-#include "kvstore/kvstore.hpp"
-#include "license/license.hpp"
-#include "replication/replication_client.hpp"
-#include "storage/v2/config.hpp"
-#include "storage/v2/transaction.hpp"
-#include "system/system.hpp"
-#include "utils/thread_pool.hpp"
 #ifdef MG_ENTERPRISE
-#include "coordination/coordinator_state.hpp"
 #include "dbms/database_handler.hpp"
 #endif
+#include "dbms/replication_client.hpp"
 #include "global.hpp"
 #include "query/config.hpp"
 #include "query/interpreter_context.hpp"
 #include "spdlog/spdlog.h"
+#include "storage/v2/durability/durability.hpp"
+#include "storage/v2/durability/paths.hpp"
 #include "storage/v2/isolation_level.hpp"
-#include "system/system.hpp"
+#include "utils/exceptions.hpp"
+#include "utils/file.hpp"
 #include "utils/logging.hpp"
 #include "utils/result.hpp"
 #include "utils/rw_lock.hpp"
@@ -105,21 +102,21 @@ class DbmsHandler {
    * @param configs storage configuration
    * @param auth pointer to the global authenticator
    * @param recovery_on_startup restore databases (and its content) and authentication data
+   * @param delete_on_drop when dropping delete any associated directories on disk
    */
-  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
+  DbmsHandler(storage::Config config,
+              memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth,
+              bool recovery_on_startup, bool delete_on_drop);  // TODO If more arguments are added use a config strut
 #else
   /**
    * @brief Initialize the handler. A single database is supported in community edition.
    *
    * @param configs storage configuration
    */
-  DbmsHandler(storage::Config config, memgraph::system::System &system, replication::ReplicationState &repl_state)
-      : repl_state_{repl_state},
-        system_{&system},
+  DbmsHandler(storage::Config config)
+      : repl_state_{ReplicationStateRootPath(config)},
         db_gatekeeper_{[&] {
-                         config.salient.name = kDefaultDB;
+                         config.name = kDefaultDB;
                          return std::move(config);
                        }(),
                        repl_state_} {}
@@ -132,58 +129,11 @@ class DbmsHandler {
    * @param name name of the database
    * @return NewResultT context on success, error on failure
    */
-  NewResultT New(const std::string &name, system::Transaction *txn = nullptr) {
+  NewResultT New(const std::string &name) {
     std::lock_guard<LockT> wr(lock_);
-    const auto uuid = utils::UUID{};
-    return New_(name, uuid, txn);
+    return New_(name, name);
   }
 
-  /**
-   * @brief Create new if name/uuid do not match any database. Drop and recreate if database already present.
-   * @note Default database is not dropped, only its UUID is updated and only if the database is clean.
-   *
-   * @param config desired salient config
-   * @return NewResultT context on success, error on failure
-   */
-  NewResultT Update(const storage::SalientConfig &config) {
-    std::lock_guard<LockT> wr(lock_);
-    auto new_db = New_(config);
-    if (new_db.HasValue() || new_db.GetError() != NewError::EXISTS) {
-      // NOTE: If db already exists we retry below
-      return new_db;
-    }
-
-    spdlog::debug("Trying to create db '{}' on replica which already exists.", config.name);
-
-    auto db = Get_(config.name);
-    if (db->uuid() == config.uuid) {  // Same db
-      return db;
-    }
-
-    spdlog::debug("Different UUIDs");
-
-    // TODO: Fix this hack
-    if (config.name == kDefaultDB) {
-      if (db->storage()->repl_storage_state_.last_commit_timestamp_ != storage::kTimestampInitialId) {
-        spdlog::debug("Default storage is not clean, cannot update UUID...");
-        return NewError::GENERIC;  // Update error
-      }
-      spdlog::debug("Update default db's UUID");
-      // Default db cannot be deleted and remade, have to just update the UUID
-      db->storage()->config_.salient.uuid = config.uuid;
-      UpdateDurability(db->storage()->config_, ".");
-      return db;
-    }
-
-    spdlog::debug("Drop database and recreate with the correct UUID");
-    // Defer drop
-    (void)Delete_(db->name());
-    // Second attempt
-    return New_(config);
-  }
-
-  void UpdateDurability(const storage::Config &config, std::optional<std::filesystem::path> rel_dir = {});
-
   /**
    * @brief Get the context associated with the "name" database
    *
@@ -195,19 +145,6 @@ class DbmsHandler {
     std::shared_lock<LockT> rd(lock_);
     return Get_(name);
   }
-
-  /**
-   * @brief Get the context associated with the UUID database
-   *
-   * @param uuid
-   * @return DatabaseAccess
-   * @throw UnknownDatabaseException if database not found
-   */
-  DatabaseAccess Get(const utils::UUID &uuid) {
-    std::shared_lock<LockT> rd(lock_);
-    return Get_(uuid);
-  }
-
 #else
   /**
    * @brief Get the context associated with the default database
@@ -223,28 +160,50 @@ class DbmsHandler {
 
 #ifdef MG_ENTERPRISE
   /**
-   * @brief Attempt to delete database.
+   * @brief Delete database.
    *
    * @param db_name database name
    * @return DeleteResult error on failure
    */
-  DeleteResult TryDelete(std::string_view db_name, system::Transaction *transaction = nullptr);
+  DeleteResult Delete(const std::string &db_name) {
+    std::lock_guard<LockT> wr(lock_);
+    if (db_name == kDefaultDB) {
+      // MSG cannot delete the default db
+      return DeleteError::DEFAULT_DB;
+    }
 
-  /**
-   * @brief Delete or defer deletion of database.
-   *
-   * @param db_name database name
-   * @return DeleteResult error on failure
-   */
-  DeleteResult Delete(std::string_view db_name);
+    const auto storage_path = StorageDir_(db_name);
+    if (!storage_path) return DeleteError::NON_EXISTENT;
 
-  /**
-   * @brief Delete or defer deletion of database.
-   *
-   * @param uuid database UUID
-   * @return DeleteResult error on failure
-   */
-  DeleteResult Delete(utils::UUID uuid);
+    // Check if db exists
+    try {
+      // Low level handlers
+      if (!db_handler_.Delete(db_name)) {
+        return DeleteError::USING;
+      }
+    } catch (utils::BasicException &) {
+      return DeleteError::NON_EXISTENT;
+    }
+
+    // Remove from durability list
+    if (durability_) durability_->Delete(db_name);
+
+    // Delete disk storage
+    if (delete_on_drop_) {
+      std::error_code ec;
+      (void)std::filesystem::remove_all(*storage_path, ec);
+      if (ec) {
+        spdlog::error("Failed to clean disk while deleting database \"{}\".", db_name);
+        defunct_dbs_.emplace(db_name);
+        return DeleteError::DISK_FAIL;
+      }
+    }
+
+    // Delete from defunct_dbs_ (in case a second delete call was successful)
+    defunct_dbs_.erase(db_name);
+
+    return {};  // Success
+  }
 #endif
 
   /**
@@ -257,16 +216,22 @@ class DbmsHandler {
     std::shared_lock<LockT> rd(lock_);
     return db_handler_.All();
 #else
-    return {db_gatekeeper_.access()->get()->name()};
+    return {db_gatekeeper_.access()->get()->id()};
 #endif
   }
 
+  replication::ReplicationState &ReplicationState() { return repl_state_; }
+  replication::ReplicationState const &ReplicationState() const { return repl_state_; }
+
+  bool IsMain() const { return repl_state_.IsMain(); }
+  bool IsReplica() const { return repl_state_.IsReplica(); }
+
   /**
    * @brief Return the statistics all databases.
    *
    * @return Statistics
    */
-  Statistics Stats(memgraph::replication_coordination_glue::ReplicationRole replication_role) {
+  Statistics Stats() {
     Statistics stats{};
     // TODO: Handle overflow?
 #ifdef MG_ENTERPRISE
@@ -279,7 +244,7 @@ class DbmsHandler {
       auto db_acc_opt = db_gk.access();
       if (db_acc_opt) {
         auto &db_acc = *db_acc_opt;
-        const auto &info = db_acc->GetInfo(false, replication_role);
+        const auto &info = db_acc->GetInfo();
         const auto &storage_info = info.storage_info;
         stats.num_vertex += storage_info.vertex_count;
         stats.num_edges += storage_info.edge_count;
@@ -302,7 +267,7 @@ class DbmsHandler {
    *
    * @return std::vector<DatabaseInfo>
    */
-  std::vector<DatabaseInfo> Info(memgraph::replication_coordination_glue::ReplicationRole replication_role) {
+  std::vector<DatabaseInfo> Info() {
     std::vector<DatabaseInfo> res;
 #ifdef MG_ENTERPRISE
     std::shared_lock<LockT> rd(lock_);
@@ -315,7 +280,7 @@ class DbmsHandler {
       auto db_acc_opt = db_gk.access();
       if (db_acc_opt) {
         auto &db_acc = *db_acc_opt;
-        res.push_back(db_acc->GetInfo(false, replication_role));
+        res.push_back(db_acc->GetInfo());
       }
     }
     return res;
@@ -338,7 +303,7 @@ class DbmsHandler {
       auto db_acc_opt = db_gk.access();
       if (db_acc_opt) {
         auto &db_acc = *db_acc_opt;
-        spdlog::debug("Restoring trigger for database \"{}\"", db_acc->name());
+        spdlog::debug("Restoring trigger for database \"{}\"", db_acc->id());
         auto storage_accessor = db_acc->Access();
         auto dba = memgraph::query::DbAccessor{storage_accessor.get()};
         db_acc->trigger_store()->RestoreTriggers(&ic->ast_cache, &dba, ic->config.query, ic->auth_checker);
@@ -363,7 +328,7 @@ class DbmsHandler {
       auto db_acc = db_gk.access();
       if (db_acc) {
         auto *db = db_acc->get();
-        spdlog::debug("Restoring streams for database \"{}\"", db->name());
+        spdlog::debug("Restoring streams for database \"{}\"", db->id());
         db->streams()->RestoreStreams(*db_acc, ic);
       }
     }
@@ -374,7 +339,7 @@ class DbmsHandler {
    *
    * @param f
    */
-  void ForEach(std::invocable<DatabaseAccess> auto f) {
+  void ForEach(auto f) {
 #ifdef MG_ENTERPRISE
     std::shared_lock<LockT> rd(lock_);
     for (auto &[_, db_gk] : db_handler_) {
@@ -384,20 +349,31 @@ class DbmsHandler {
 #endif
       auto db_acc = db_gk.access();
       if (db_acc) {  // This isn't an error, just a defunct db
-        f(*db_acc);
+        f(db_acc->get());
       }
     }
   }
 
-  static void RecoverStorageReplication(DatabaseAccess db_acc, replication::RoleMainData &role_main_data);
-
-  auto default_config() const -> storage::Config const & {
+  /**
+   * @brief todo
+   *
+   * @param f
+   */
+  void ForOne(auto f) {
 #ifdef MG_ENTERPRISE
-    return default_config_;
+    std::shared_lock<LockT> rd(lock_);
+    for (auto &[_, db_gk] : db_handler_) {
+      auto db_acc = db_gk.access();
+      if (db_acc) {                   // This isn't an error, just a defunct db
+        if (f(db_acc->get())) break;  // Run until the first successful one
+      }
+    }
 #else
-    const auto acc = db_gatekeeper_.access();
-    MG_ASSERT(acc, "Failed to get default database!");
-    return acc->get()->config();
+    {
+      auto db_acc = db_gatekeeper_.access();
+      MG_ASSERT(db_acc, "Should always have the database");
+      f(db_acc->get());
+    }
 #endif
   }
 
@@ -409,7 +385,7 @@ class DbmsHandler {
    * @param name Database name
    * @return std::optional<std::filesystem::path>
    */
-  std::optional<std::filesystem::path> StorageDir_(std::string_view name) {
+  std::optional<std::filesystem::path> StorageDir_(const std::string &name) {
     const auto conf = db_handler_.GetConfig(name);
     if (conf) {
       return conf->durability.storage_directory;
@@ -422,110 +398,105 @@ class DbmsHandler {
    * @brief Create a new Database associated with the "name" database
    *
    * @param name name of the database
-   * @param uuid undelying RocksDB directory
    * @return NewResultT context on success, error on failure
    */
-  NewResultT New_(std::string_view name, utils::UUID uuid, system::Transaction *txn = nullptr,
-                  std::optional<std::filesystem::path> rel_dir = {}) {
-    auto config_copy = default_config_;
-    config_copy.salient.name = name;
-    config_copy.salient.uuid = uuid;
-    spdlog::debug("Creating database '{}' - '{}'", name, std::string{uuid});
-    if (rel_dir) {
-      storage::UpdatePaths(config_copy, default_config_.durability.storage_directory / *rel_dir);
-    } else {
-      storage::UpdatePaths(config_copy,
-                           default_config_.durability.storage_directory / kMultiTenantDir / std::string{uuid});
-    }
-    return New_(std::move(config_copy), txn);
-  }
+  NewResultT New_(const std::string &name) { return New_(name, name); }
 
   /**
-   * @brief Create a new Database using the passed configuration
+   * @brief Create a new Database associated with the "name" database
    *
-   * @param config configuration to be used
+   * @param name name of the database
+   * @param storage_subdir undelying RocksDB directory
    * @return NewResultT context on success, error on failure
    */
-  NewResultT New_(const storage::SalientConfig &config, system::Transaction *txn = nullptr) {
+  NewResultT New_(const std::string &name, std::filesystem::path storage_subdir) {
     auto config_copy = default_config_;
-    config_copy.salient = config;  // name, uuid, mode, etc
-    UpdatePaths(config_copy, config_copy.durability.storage_directory / kMultiTenantDir / std::string{config.uuid});
-    return New_(std::move(config_copy), txn);
+    storage::UpdatePaths(config_copy, default_config_.durability.storage_directory / storage_subdir);
+    return New_(name, config_copy);
   }
 
   /**
    * @brief Create a new Database associated with the "name" database
    *
+   * @param name name of the database
    * @param storage_config storage configuration
    * @return NewResultT context on success, error on failure
    */
-  DbmsHandler::NewResultT New_(storage::Config storage_config, system::Transaction *txn = nullptr);
+  NewResultT New_(const std::string &name, storage::Config &storage_config) {
+    if (defunct_dbs_.contains(name)) {
+      spdlog::warn("Failed to generate database due to the unknown state of the previously defunct database \"{}\".",
+                   name);
+      return NewError::DEFUNCT;
+    }
 
-  // TODO: new overload of Delete_ with DatabaseAccess
-  DeleteResult Delete_(std::string_view db_name);
+    auto new_db = db_handler_.New(name, storage_config, repl_state_);
+    if (new_db.HasValue()) {
+      // Success
+      if (durability_) durability_->Put(name, "ok");  // TODO: Serialize the configuration?
+      return new_db.GetValue();
+    }
+    return new_db.GetError();
+  }
 
   /**
    * @brief Create a new Database associated with the default database
    *
    * @return NewResultT context on success, error on failure
    */
-  void SetupDefault_() {
-    try {
-      Get(kDefaultDB);
-    } catch (const UnknownDatabaseException &) {
-      // No default DB restored, create it
-      MG_ASSERT(New_(kDefaultDB, {/* random UUID */}, nullptr, ".").HasValue(),
-                "Failed while creating the default database");
-    }
+  NewResultT NewDefault_() {
+    // Create the default DB in the root (this is how it was done pre multi-tenancy)
+    auto res = New_(kDefaultDB, "..");
+    if (res.HasValue()) {
+      // For back-compatibility...
+      // Recreate the dbms layout for the default db and symlink to the root
+      const auto dir = StorageDir_(kDefaultDB);
+      MG_ASSERT(dir, "Failed to find storage path.");
+      const auto main_dir = *dir / "databases" / kDefaultDB;
 
-    // For back-compatibility...
-    // Recreate the dbms layout for the default db and symlink to the root
-    const auto dir = StorageDir_(kDefaultDB);
-    MG_ASSERT(dir, "Failed to find storage path.");
-    const auto main_dir = *dir / kMultiTenantDir / kDefaultDB;
+      if (!std::filesystem::exists(main_dir)) {
+        std::filesystem::create_directory(main_dir);
+      }
 
-    if (!std::filesystem::exists(main_dir)) {
-      std::filesystem::create_directory(main_dir);
-    }
+      // Force link on-disk directories
+      const auto conf = db_handler_.GetConfig(kDefaultDB);
+      MG_ASSERT(conf, "No configuration for the default database.");
+      const auto &tmp_conf = conf->disk;
+      std::vector<std::filesystem::path> to_link{
+          tmp_conf.main_storage_directory,         tmp_conf.label_index_directory,
+          tmp_conf.label_property_index_directory, tmp_conf.unique_constraints_directory,
+          tmp_conf.name_id_mapper_directory,       tmp_conf.id_name_mapper_directory,
+          tmp_conf.durability_directory,           tmp_conf.wal_directory,
+      };
 
-    // Force link on-disk directories
-    const auto conf = db_handler_.GetConfig(kDefaultDB);
-    MG_ASSERT(conf, "No configuration for the default database.");
-    const auto &tmp_conf = conf->disk;
-    std::vector<std::filesystem::path> to_link{
-        tmp_conf.main_storage_directory,         tmp_conf.label_index_directory,
-        tmp_conf.label_property_index_directory, tmp_conf.unique_constraints_directory,
-        tmp_conf.name_id_mapper_directory,       tmp_conf.id_name_mapper_directory,
-        tmp_conf.durability_directory,           tmp_conf.wal_directory,
-    };
+      // Add in-memory paths
+      // Some directories are redundant (skip those)
+      const std::vector<std::string> skip{".lock", "audit_log", "auth", "databases", "internal_modules", "settings"};
+      for (auto const &item : std::filesystem::directory_iterator{*dir}) {
+        const auto dir_name = std::filesystem::relative(item.path(), item.path().parent_path());
+        if (std::find(skip.begin(), skip.end(), dir_name) != skip.end()) continue;
+        to_link.push_back(item.path());
+      }
 
-    // Add in-memory paths
-    // Some directories are redundant (skip those)
-    const std::vector<std::string> skip{".lock", "audit_log", "auth", "databases", "internal_modules", "settings"};
-    for (auto const &item : std::filesystem::directory_iterator{*dir}) {
-      const auto dir_name = std::filesystem::relative(item.path(), item.path().parent_path());
-      if (std::find(skip.begin(), skip.end(), dir_name) != skip.end()) continue;
-      to_link.push_back(item.path());
-    }
-
-    // Symlink to root dir
-    for (auto const &item : to_link) {
-      const auto dir_name = std::filesystem::relative(item, item.parent_path());
-      const auto link = main_dir / dir_name;
-      const auto to = std::filesystem::relative(item, main_dir);
-      if (!std::filesystem::is_symlink(link) && !std::filesystem::exists(link)) {
-        std::filesystem::create_directory_symlink(to, link);
-      } else {  // Check existing link
-        std::error_code ec;
-        const auto test_link = std::filesystem::read_symlink(link, ec);
-        if (ec || test_link != to) {
-          MG_ASSERT(false,
-                    "Memgraph storage directory incompatible with new version.\n"
-                    "Please use a clean directory or remove \"{}\" and try again.",
-                    link.string());
+      // Symlink to root dir
+      for (auto const &item : to_link) {
+        const auto dir_name = std::filesystem::relative(item, item.parent_path());
+        const auto link = main_dir / dir_name;
+        const auto to = std::filesystem::relative(item, main_dir);
+        if (!std::filesystem::is_symlink(link) && !std::filesystem::exists(link)) {
+          std::filesystem::create_directory_symlink(to, link);
+        } else {  // Check existing link
+          std::error_code ec;
+          const auto test_link = std::filesystem::read_symlink(link, ec);
+          if (ec || test_link != to) {
+            MG_ASSERT(false,
+                      "Memgraph storage directory incompatible with new version.\n"
+                      "Please use a clean directory or remove \"{}\" and try again.",
+                      link.string());
+          }
         }
       }
     }
+    return res;
   }
 
   /**
@@ -543,46 +514,17 @@ class DbmsHandler {
     throw UnknownDatabaseException("Tried to retrieve an unknown database \"{}\".", name);
   }
 
-  /**
-   * @brief Get the context associated with the UUID database
-   *
-   * @param uuid
-   * @return DatabaseAccess
-   * @throw UnknownDatabaseException if database not found
-   */
-  DatabaseAccess Get_(const utils::UUID &uuid) {
-    // TODO Speed up
-    for (auto &[_, db_gk] : db_handler_) {
-      auto acc = db_gk.access();
-      if (acc->get()->uuid() == uuid) {
-        return std::move(*acc);
-      }
-    }
-    throw UnknownDatabaseException("Tried to retrieve an unknown database with UUID \"{}\".", std::string{uuid});
-  }
-#endif
-
-#ifdef MG_ENTERPRISE
   mutable LockT lock_{utils::RWLock::Priority::READ};  //!< protective lock
   storage::Config default_config_;                     //!< Storage configuration used when creating new databases
   DatabaseHandler db_handler_;                         //!< multi-tenancy storage handler
-  // TODO: move to be common
-  std::unique_ptr<kvstore::KVStore> durability_;  //!< list of active dbs (pointer so we can postpone its creation)
-  auth::SynchedAuth &auth_;                       //!< Synchronized auth::Auth
+  std::unique_ptr<kvstore::KVStore> durability_;       //!< list of active dbs (pointer so we can postpone its creation)
+  bool delete_on_drop_;                                //!< Flag defining if dropping storage also deletes its directory
+  std::set<std::string> defunct_dbs_;  //!< Databases that are in an unknown state due to various failures
 #endif
- private:
-  // NOTE: atm the only reason this exists here, is because we pass it into the construction of New Database's
-  //       Database only uses it as a convience to make the correct Access without out needing to be told the
-  //       current replication role. TODO: make Database Access explicit about the role and remove this from
-  //       dbms stuff
-  replication::ReplicationState &repl_state_;  //!< Ref to global replication state
- public:
-  // TODO fix to be non public/remove from dbms....maybe
-  system::System *system_;
-
+  replication::ReplicationState repl_state_;  //!< Global replication state
 #ifndef MG_ENTERPRISE
   mutable utils::Gatekeeper<Database> db_gatekeeper_;  //!< Single databases gatekeeper
 #endif
-};  // namespace memgraph::dbms
+};
 
 }  // namespace memgraph::dbms

src/dbms/handler.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 "utils/exceptions.hpp"
 #include "utils/gatekeeper.hpp"
 #include "utils/result.hpp"
-#include "utils/thread_pool.hpp"
 
 namespace memgraph::dbms {
 
@@ -83,7 +82,7 @@ class Handler {
    * @return true on success
    * @throw BasicException
    */
-  bool TryDelete(std::string_view name) {
+  bool Delete(const std::string &name) {
     if (auto itr = items_.find(name); itr != items_.end()) {
       auto db_acc = itr->second.access();
       if (db_acc && db_acc->try_delete()) {
@@ -93,42 +92,9 @@ class Handler {
       }
       return false;
     }
-    // TODO: Change to return enum
     throw utils::BasicException("Unknown item \"{}\".", name);
   }
 
-  /**
-   * @brief Delete or defunct the context associated with the name.
-   *
-   * @param name Name associated with the context to delete
-   * @param post_delete_func What to do after deletion has happened
-   */
-  template <typename Func>
-  void DeferDelete(std::string_view name, Func &&post_delete_func) {
-    auto itr = items_.find(name);
-    if (itr == items_.end()) return;
-
-    auto db_acc = itr->second.access();
-    if (!db_acc) return;
-
-    if (db_acc->try_delete()) {
-      // Delete the database now
-      db_acc->reset();
-      post_delete_func();
-    } else {
-      // Defer deletion
-      db_acc->reset();
-      // TODO: Make sure this shuts down correctly
-      auto task = [gk = std::move(itr->second), post_delete_func = std::forward<Func>(post_delete_func)]() mutable {
-        gk.~Gatekeeper<T>();
-        post_delete_func();
-      };
-      defer_pool_.AddTask(utils::CopyMovableFunctionWrapper{std::move(task)});
-    }
-    // In any case remove from handled map
-    items_.erase(itr);
-  }
-
   /**
    * @brief Check if a name is already used.
    *
@@ -154,7 +120,6 @@ class Handler {
  private:
   std::unordered_map<std::string, utils::Gatekeeper<T>, string_hash, std::equal_to<>>
       items_;  //!< map to all active items
-  utils::ThreadPool defer_pool_{1};
 };
 
 }  // namespace memgraph::dbms

src/dbms/inmemory/replication_handlers.cpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -10,7 +10,6 @@
 // licenses/APL.txt.
 
 #include "dbms/inmemory/replication_handlers.hpp"
-#include <chrono>
 #include <optional>
 #include "dbms/constants.hpp"
 #include "dbms/dbms_handler.hpp"
@@ -23,7 +22,6 @@
 #include "storage/v2/inmemory/storage.hpp"
 #include "storage/v2/inmemory/unique_constraints.hpp"
 
-using memgraph::replication_coordination_glue::ReplicationRole;
 using memgraph::storage::Delta;
 using memgraph::storage::EdgeAccessor;
 using memgraph::storage::EdgeRef;
@@ -50,29 +48,29 @@ std::pair<uint64_t, WalDeltaData> ReadDelta(storage::durability::BaseDecoder *de
   }
 };
 
-std::optional<DatabaseAccess> GetDatabaseAccessor(dbms::DbmsHandler *dbms_handler, const utils::UUID &uuid) {
+std::optional<DatabaseAccess> GetDatabaseAccessor(dbms::DbmsHandler *dbms_handler, std::string_view db_name) {
   try {
 #ifdef MG_ENTERPRISE
-    auto acc = dbms_handler->Get(uuid);
-    if (!acc) {
-      spdlog::error("Failed to get access to UUID ", std::string{uuid});
-      return std::nullopt;
-    }
+    auto acc = dbms_handler->Get(db_name);
 #else
-    auto acc = dbms_handler->Get();
-    if (!acc) {
-      spdlog::warn("Failed to get access to the default db.");
+    if (db_name != dbms::kDefaultDB) {
+      spdlog::warn("Trying to replicate a non-default database on a community replica.");
       return std::nullopt;
     }
+    auto acc = dbms_handler->Get();
 #endif
+    if (!acc) {
+      spdlog::error("Failed to get access to ", db_name);
+      return std::nullopt;
+    }
     auto *inmem_storage = dynamic_cast<storage::InMemoryStorage *>(acc.get()->storage());
     if (!inmem_storage || inmem_storage->storage_mode_ != storage::StorageMode::IN_MEMORY_TRANSACTIONAL) {
-      spdlog::error("Database is not IN_MEMORY_TRANSACTIONAL.");
+      spdlog::error("Database \"{}\" is not IN_MEMORY_TRANSACTIONAL.", db_name);
       return std::nullopt;
     }
     return std::optional{std::move(acc)};
   } catch (const dbms::UnknownDatabaseException &e) {
-    spdlog::warn("No database with UUID \"{}\" on replica!", std::string{uuid});
+    spdlog::warn("No database \"{}\" on replica!", db_name);
     return std::nullopt;
   }
 }
@@ -110,16 +108,13 @@ void InMemoryReplicationHandlers::HeartbeatHandler(dbms::DbmsHandler *dbms_handl
                                                    slk::Builder *res_builder) {
   storage::replication::HeartbeatReq req;
   slk::Load(&req, req_reader);
-  auto const db_acc = GetDatabaseAccessor(dbms_handler, req.uuid);
-  if (!db_acc) {
-    storage::replication::HeartbeatRes res{false, 0, ""};
-    slk::Save(res, res_builder);
-    return;
-  }
+  auto const db_acc = GetDatabaseAccessor(dbms_handler, req.db_name);
+  if (!db_acc) return;
 
   // TODO: this handler is agnostic of InMemory, move to be reused by on-disk
   auto const *storage = db_acc->get()->storage();
-  storage::replication::HeartbeatRes res{true, storage->repl_storage_state_.last_commit_timestamp_.load(),
+  storage::replication::HeartbeatRes res{storage->id(), true,
+                                         storage->repl_storage_state_.last_commit_timestamp_.load(),
                                          std::string{storage->repl_storage_state_.epoch_.id()}};
   slk::Save(res, res_builder);
 }
@@ -128,12 +123,8 @@ void InMemoryReplicationHandlers::AppendDeltasHandler(dbms::DbmsHandler *dbms_ha
                                                       slk::Builder *res_builder) {
   storage::replication::AppendDeltasReq req;
   slk::Load(&req, req_reader);
-  auto db_acc = GetDatabaseAccessor(dbms_handler, req.uuid);
-  if (!db_acc) {
-    storage::replication::AppendDeltasRes res{false, 0};
-    slk::Save(res, res_builder);
-    return;
-  }
+  auto db_acc = GetDatabaseAccessor(dbms_handler, req.db_name);
+  if (!db_acc) return;
 
   storage::replication::Decoder decoder(req_reader);
 
@@ -173,7 +164,7 @@ void InMemoryReplicationHandlers::AppendDeltasHandler(dbms::DbmsHandler *dbms_ha
           storage::durability::kVersion);  // TODO: Check if we are always using the latest version when replicating
     }
 
-    storage::replication::AppendDeltasRes res{false, repl_storage_state.last_commit_timestamp_.load()};
+    storage::replication::AppendDeltasRes res{storage->id(), false, repl_storage_state.last_commit_timestamp_.load()};
     slk::Save(res, res_builder);
     return;
   }
@@ -182,7 +173,7 @@ void InMemoryReplicationHandlers::AppendDeltasHandler(dbms::DbmsHandler *dbms_ha
       storage, &decoder,
       storage::durability::kVersion);  // TODO: Check if we are always using the latest version when replicating
 
-  storage::replication::AppendDeltasRes res{true, repl_storage_state.last_commit_timestamp_.load()};
+  storage::replication::AppendDeltasRes res{storage->id(), true, repl_storage_state.last_commit_timestamp_.load()};
   slk::Save(res, res_builder);
   spdlog::debug("Replication recovery from append deltas finished, replica is now up to date!");
 }
@@ -191,12 +182,8 @@ void InMemoryReplicationHandlers::SnapshotHandler(dbms::DbmsHandler *dbms_handle
                                                   slk::Builder *res_builder) {
   storage::replication::SnapshotReq req;
   slk::Load(&req, req_reader);
-  auto db_acc = GetDatabaseAccessor(dbms_handler, req.uuid);
-  if (!db_acc) {
-    storage::replication::SnapshotRes res{false, 0};
-    slk::Save(res, res_builder);
-    return;
-  }
+  auto db_acc = GetDatabaseAccessor(dbms_handler, req.db_name);
+  if (!db_acc) return;
 
   storage::replication::Decoder decoder(req_reader);
 
@@ -244,7 +231,8 @@ void InMemoryReplicationHandlers::SnapshotHandler(dbms::DbmsHandler *dbms_handle
   }
   storage_guard.unlock();
 
-  storage::replication::SnapshotRes res{true, storage->repl_storage_state_.last_commit_timestamp_.load()};
+  storage::replication::SnapshotRes res{storage->id(), true,
+                                        storage->repl_storage_state_.last_commit_timestamp_.load()};
   slk::Save(res, res_builder);
 
   spdlog::trace("Deleting old snapshot files due to snapshot recovery.");
@@ -274,12 +262,8 @@ void InMemoryReplicationHandlers::WalFilesHandler(dbms::DbmsHandler *dbms_handle
                                                   slk::Builder *res_builder) {
   storage::replication::WalFilesReq req;
   slk::Load(&req, req_reader);
-  auto db_acc = GetDatabaseAccessor(dbms_handler, req.uuid);
-  if (!db_acc) {
-    storage::replication::WalFilesRes res{false, 0};
-    slk::Save(res, res_builder);
-    return;
-  }
+  auto db_acc = GetDatabaseAccessor(dbms_handler, req.db_name);
+  if (!db_acc) return;
 
   const auto wal_file_number = req.file_number;
   spdlog::debug("Received WAL files: {}", wal_file_number);
@@ -293,7 +277,8 @@ void InMemoryReplicationHandlers::WalFilesHandler(dbms::DbmsHandler *dbms_handle
     LoadWal(storage, &decoder);
   }
 
-  storage::replication::WalFilesRes res{true, storage->repl_storage_state_.last_commit_timestamp_.load()};
+  storage::replication::WalFilesRes res{storage->id(), true,
+                                        storage->repl_storage_state_.last_commit_timestamp_.load()};
   slk::Save(res, res_builder);
   spdlog::debug("Replication recovery from WAL files ended successfully, replica is now up to date!");
 }
@@ -302,12 +287,8 @@ void InMemoryReplicationHandlers::CurrentWalHandler(dbms::DbmsHandler *dbms_hand
                                                     slk::Builder *res_builder) {
   storage::replication::CurrentWalReq req;
   slk::Load(&req, req_reader);
-  auto db_acc = GetDatabaseAccessor(dbms_handler, req.uuid);
-  if (!db_acc) {
-    storage::replication::CurrentWalRes res{false, 0};
-    slk::Save(res, res_builder);
-    return;
-  }
+  auto db_acc = GetDatabaseAccessor(dbms_handler, req.db_name);
+  if (!db_acc) return;
 
   storage::replication::Decoder decoder(req_reader);
 
@@ -316,7 +297,8 @@ void InMemoryReplicationHandlers::CurrentWalHandler(dbms::DbmsHandler *dbms_hand
 
   LoadWal(storage, &decoder);
 
-  storage::replication::CurrentWalRes res{true, storage->repl_storage_state_.last_commit_timestamp_.load()};
+  storage::replication::CurrentWalRes res{storage->id(), true,
+                                          storage->repl_storage_state_.last_commit_timestamp_.load()};
   slk::Save(res, res_builder);
   spdlog::debug("Replication recovery from current WAL ended successfully, replica is now up to date!");
 }
@@ -335,8 +317,6 @@ void InMemoryReplicationHandlers::LoadWal(storage::InMemoryStorage *storage, sto
     }
     auto &replica_epoch = storage->repl_storage_state_.epoch_;
     if (wal_info.epoch_id != replica_epoch.id()) {
-      // questionable behaviour, we trust that any change in epoch implies change in who is MAIN
-      // when we use high availability, this assumption need to be checked.
       auto prev_epoch = replica_epoch.SetEpoch(wal_info.epoch_id);
       storage->repl_storage_state_.AddEpochToHistoryForce(prev_epoch);
     }
@@ -374,16 +354,13 @@ void InMemoryReplicationHandlers::TimestampHandler(dbms::DbmsHandler *dbms_handl
                                                    slk::Builder *res_builder) {
   storage::replication::TimestampReq req;
   slk::Load(&req, req_reader);
-  auto const db_acc = GetDatabaseAccessor(dbms_handler, req.uuid);
-  if (!db_acc) {
-    storage::replication::TimestampRes res{false, 0};
-    slk::Save(res, res_builder);
-    return;
-  }
+  auto const db_acc = GetDatabaseAccessor(dbms_handler, req.db_name);
+  if (!db_acc) return;
 
   // TODO: this handler is agnostic of InMemory, move to be reused by on-disk
   auto const *storage = db_acc->get()->storage();
-  storage::replication::TimestampRes res{true, storage->repl_storage_state_.last_commit_timestamp_.load()};
+  storage::replication::TimestampRes res{storage->id(), true,
+                                         storage->repl_storage_state_.last_commit_timestamp_.load()};
   slk::Save(res, res_builder);
 }
 
@@ -403,9 +380,9 @@ uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage
     if (!commit_timestamp_and_accessor) {
       std::unique_ptr<storage::Storage::Accessor> acc = nullptr;
       if (unique) {
-        acc = storage->UniqueAccess(ReplicationRole::REPLICA);
+        acc = storage->UniqueAccess(std::nullopt, false /*not main*/);
       } else {
-        acc = storage->Access(ReplicationRole::REPLICA);
+        acc = storage->Access(std::nullopt, false /*not main*/);
       }
       auto inmem_acc = std::unique_ptr<storage::InMemoryStorage::InMemoryAccessor>(
           static_cast<storage::InMemoryStorage::InMemoryAccessor *>(acc.release()));
@@ -527,7 +504,7 @@ uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage
       case WalDeltaData::Type::EDGE_SET_PROPERTY: {
         spdlog::trace("       Edge {} set property {} to {}", delta.vertex_edge_set_property.gid.AsUint(),
                       delta.vertex_edge_set_property.property, delta.vertex_edge_set_property.value);
-        if (!storage->config_.salient.items.properties_on_edges)
+        if (!storage->config_.items.properties_on_edges)
           throw utils::BasicException(
               "Can't set properties on edges because properties on edges "
               "are disabled!");
@@ -594,8 +571,8 @@ uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage
         spdlog::trace("       Transaction end");
         if (!commit_timestamp_and_accessor || commit_timestamp_and_accessor->first != timestamp)
           throw utils::BasicException("Invalid commit data!");
-        auto ret = commit_timestamp_and_accessor->second.Commit(
-            {.desired_commit_timestamp = commit_timestamp_and_accessor->first, .is_main = false});
+        auto ret =
+            commit_timestamp_and_accessor->second.Commit(commit_timestamp_and_accessor->first, false /* not main */);
         if (ret.HasError())
           throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
         commit_timestamp_and_accessor = std::nullopt;

src/dbms/inmemory/replication_handlers.hpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -12,6 +12,7 @@
 #pragma once
 
 #include "replication/replication_server.hpp"
+#include "replication/state.hpp"
 #include "storage/v2/replication/serialization.hpp"
 
 namespace memgraph::storage {

src/dbms/inmemory/storage_helper.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
@@ -11,6 +11,10 @@
 
 #pragma once
 
+#include <variant>
+
+#include "dbms/constants.hpp"
+#include "dbms/replication_handler.hpp"
 #include "replication/state.hpp"
 #include "storage/v2/config.hpp"
 #include "storage/v2/inmemory/storage.hpp"
@@ -20,15 +24,37 @@ namespace memgraph::dbms {
 
 inline std::unique_ptr<storage::Storage> CreateInMemoryStorage(storage::Config config,
                                                                ::memgraph::replication::ReplicationState &repl_state) {
-  const auto name = config.salient.name;
+  const auto wal_mode = config.durability.snapshot_wal_mode;
+  const auto name = config.name;
   auto storage = std::make_unique<storage::InMemoryStorage>(std::move(config));
 
   // Connect replication state and storage
   storage->CreateSnapshotHandler(
       [storage = storage.get(), &repl_state]() -> utils::BasicResult<storage::InMemoryStorage::CreateSnapshotError> {
-        return storage->CreateSnapshot(repl_state.GetRole());
+        if (repl_state.IsReplica()) {
+          return storage::InMemoryStorage::CreateSnapshotError::DisabledForReplica;
+        }
+        return storage->CreateSnapshot();
       });
 
+  if (allow_mt_repl || name == dbms::kDefaultDB) {
+    // Handle global replication state
+    spdlog::info("Replication configuration will be stored and will be automatically restored in case of a crash.");
+    // RECOVER REPLICA CONNECTIONS
+    memgraph::dbms::RestoreReplication(repl_state, *storage);
+  } else if (const ::memgraph::replication::RoleMainData *data =
+                 std::get_if<::memgraph::replication::RoleMainData>(&repl_state.ReplicationData());
+             data && !data->registered_replicas_.empty()) {
+    spdlog::warn("Multi-tenant replication is currently not supported!");
+  }
+
+  if (wal_mode == storage::Config::Durability::SnapshotWalMode::DISABLED && repl_state.IsMain()) {
+    spdlog::warn(
+        "The instance has the MAIN replication role, but durability logs and snapshots are disabled. Please consider "
+        "enabling durability by using --storage-snapshot-interval-sec and --storage-wal-enabled flags because "
+        "without write-ahead logs this instance is not replicating any data.");
+  }
+
   return std::move(storage);
 }
 

src/dbms/replication_client.cpp

@@ -0,0 +1,34 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#include "dbms/replication_client.hpp"
+
+namespace memgraph::dbms {
+
+void StartReplicaClient(DbmsHandler &dbms_handler, replication::ReplicationClient &client) {
+  // No client error, start instance level client
+  auto const &endpoint = client.rpc_client_.Endpoint();
+  spdlog::trace("Replication client started at: {}:{}", endpoint.address, endpoint.port);
+  client.StartFrequentCheck([&dbms_handler](std::string_view name) {
+    // Working connection, check if any database has been left behind
+    dbms_handler.ForEach([name](dbms::Database *db) {
+      // Specific database <-> replica client
+      db->storage()->repl_storage_state_.WithClient(name, [&](storage::ReplicationStorageClient *client) {
+        if (client->State() == storage::replication::ReplicaState::MAYBE_BEHIND) {
+          // Database <-> replica might be behind, check and recover
+          client->TryCheckReplicaStateAsync(db->storage());
+        }
+      });
+    });
+  });
+}
+
+}  // namespace memgraph::dbms

src/dbms/replication_client.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
@@ -11,12 +11,11 @@
 
 #pragma once
 
-#ifdef MG_ENTERPRISE
-namespace memgraph::coordination {
+#include "dbms/dbms_handler.hpp"
+#include "replication/replication_client.hpp"
 
-struct CoordinatorClusterConfig {
-  static constexpr int alive_response_time_difference_sec_{5};
-};
+namespace memgraph::dbms {
 
-}  // namespace memgraph::coordination
-#endif
+void StartReplicaClient(DbmsHandler &dbms_handler, replication::ReplicationClient &client);
+
+}  // namespace memgraph::dbms

src/dbms/replication_handler.cpp

@@ -0,0 +1,262 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#include "dbms/replication_handler.hpp"
+
+#include "dbms/constants.hpp"
+#include "dbms/dbms_handler.hpp"
+#include "dbms/inmemory/replication_handlers.hpp"
+#include "dbms/inmemory/storage_helper.hpp"
+#include "dbms/replication_client.hpp"
+#include "replication/state.hpp"
+
+using memgraph::replication::ReplicationClientConfig;
+using memgraph::replication::ReplicationState;
+using memgraph::replication::RoleMainData;
+using memgraph::replication::RoleReplicaData;
+
+namespace memgraph::dbms {
+
+namespace {
+
+std::string RegisterReplicaErrorToString(RegisterReplicaError error) {
+  switch (error) {
+    using enum RegisterReplicaError;
+    case NAME_EXISTS:
+      return "NAME_EXISTS";
+    case END_POINT_EXISTS:
+      return "END_POINT_EXISTS";
+    case CONNECTION_FAILED:
+      return "CONNECTION_FAILED";
+    case COULD_NOT_BE_PERSISTED:
+      return "COULD_NOT_BE_PERSISTED";
+  }
+}
+}  // namespace
+
+ReplicationHandler::ReplicationHandler(DbmsHandler &dbms_handler) : dbms_handler_(dbms_handler) {}
+
+bool ReplicationHandler::SetReplicationRoleMain() {
+  auto const main_handler = [](RoleMainData const &) {
+    // If we are already MAIN, we don't want to change anything
+    return false;
+  };
+  auto const replica_handler = [this](RoleReplicaData const &) {
+    // STEP 1) bring down all REPLICA servers
+    dbms_handler_.ForEach([](Database *db) {
+      auto *storage = db->storage();
+      // Remember old epoch + storage timestamp association
+      storage->PrepareForNewEpoch();
+    });
+
+    // STEP 2) Change to MAIN
+    // TODO: restore replication servers if false?
+    if (!dbms_handler_.ReplicationState().SetReplicationRoleMain()) {
+      // TODO: Handle recovery on failure???
+      return false;
+    }
+
+    // STEP 3) We are now MAIN, update storage local epoch
+    const auto &epoch =
+        std::get<RoleMainData>(std::as_const(dbms_handler_.ReplicationState()).ReplicationData()).epoch_;
+    dbms_handler_.ForEach([&](Database *db) {
+      auto *storage = db->storage();
+      storage->repl_storage_state_.epoch_ = epoch;
+    });
+
+    return true;
+  };
+
+  // TODO: under lock
+  return std::visit(utils::Overloaded{main_handler, replica_handler},
+                    dbms_handler_.ReplicationState().ReplicationData());
+}
+
+bool ReplicationHandler::SetReplicationRoleReplica(const memgraph::replication::ReplicationServerConfig &config) {
+  // We don't want to restart the server if we're already a REPLICA
+  if (dbms_handler_.ReplicationState().IsReplica()) {
+    return false;
+  }
+
+  // TODO StorageState needs to be synched. Could have a dangling reference if someone adds a database as we are
+  //      deleting the replica.
+  // Remove database specific clients
+  dbms_handler_.ForEach([&](Database *db) {
+    auto *storage = db->storage();
+    storage->repl_storage_state_.replication_clients_.WithLock([](auto &clients) { clients.clear(); });
+  });
+  // Remove instance level clients
+  std::get<RoleMainData>(dbms_handler_.ReplicationState().ReplicationData()).registered_replicas_.clear();
+
+  // Creates the server
+  dbms_handler_.ReplicationState().SetReplicationRoleReplica(config);
+
+  // Start
+  const auto success =
+      std::visit(utils::Overloaded{[](RoleMainData const &) {
+                                     // ASSERT
+                                     return false;
+                                   },
+                                   [this](RoleReplicaData const &data) {
+                                     // Register handlers
+                                     InMemoryReplicationHandlers::Register(&dbms_handler_, *data.server);
+                                     if (!data.server->Start()) {
+                                       spdlog::error("Unable to start the replication server.");
+                                       return false;
+                                     }
+                                     return true;
+                                   }},
+                 dbms_handler_.ReplicationState().ReplicationData());
+  // TODO Handle error (restore to main?)
+  return success;
+}
+
+auto ReplicationHandler::RegisterReplica(const memgraph::replication::ReplicationClientConfig &config)
+    -> memgraph::utils::BasicResult<RegisterReplicaError> {
+  MG_ASSERT(dbms_handler_.ReplicationState().IsMain(), "Only main instance can register a replica!");
+
+  auto instance_client = dbms_handler_.ReplicationState().RegisterReplica(config);
+  if (instance_client.HasError()) switch (instance_client.GetError()) {
+      case memgraph::replication::RegisterReplicaError::NOT_MAIN:
+        MG_ASSERT(false, "Only main instance can register a replica!");
+        return {};
+      case memgraph::replication::RegisterReplicaError::NAME_EXISTS:
+        return memgraph::dbms::RegisterReplicaError::NAME_EXISTS;
+      case memgraph::replication::RegisterReplicaError::END_POINT_EXISTS:
+        return memgraph::dbms::RegisterReplicaError::END_POINT_EXISTS;
+      case memgraph::replication::RegisterReplicaError::COULD_NOT_BE_PERSISTED:
+        return memgraph::dbms::RegisterReplicaError::COULD_NOT_BE_PERSISTED;
+      case memgraph::replication::RegisterReplicaError::SUCCESS:
+        break;
+    }
+
+  if (!allow_mt_repl && dbms_handler_.All().size() > 1) {
+    spdlog::warn("Multi-tenant replication is currently not supported!");
+  }
+
+  bool all_clients_good = true;
+
+  // Add database specific clients (NOTE Currently all databases are connected to each replica)
+  dbms_handler_.ForEach([&](Database *db) {
+    auto *storage = db->storage();
+    if (!allow_mt_repl && storage->id() != kDefaultDB) {
+      return;
+    }
+    // TODO: ATM only IN_MEMORY_TRANSACTIONAL, fix other modes
+    if (storage->storage_mode_ != storage::StorageMode::IN_MEMORY_TRANSACTIONAL) return;
+
+    all_clients_good &=
+        storage->repl_storage_state_.replication_clients_.WithLock([storage, &instance_client](auto &storage_clients) {
+          auto client = std::make_unique<storage::ReplicationStorageClient>(*instance_client.GetValue());
+          client->Start(storage);
+          // After start the storage <-> replica state should be READY or RECOVERING (if correctly started)
+          // MAYBE_BEHIND isn't a statement of the current state, this is the default value
+          // Failed to start due to branching of MAIN and REPLICA
+          if (client->State() == storage::replication::ReplicaState::MAYBE_BEHIND) {
+            return false;
+          }
+          storage_clients.push_back(std::move(client));
+          return true;
+        });
+  });
+
+  // NOTE Currently if any databases fails, we revert back
+  if (!all_clients_good) {
+    spdlog::error("Failed to register all databases to the REPLICA \"{}\"", config.name);
+    UnregisterReplica(config.name);
+    return RegisterReplicaError::CONNECTION_FAILED;
+  }
+
+  // No client error, start instance level client
+  StartReplicaClient(dbms_handler_, *instance_client.GetValue());
+  return {};
+}
+
+auto ReplicationHandler::UnregisterReplica(std::string_view name) -> UnregisterReplicaResult {
+  auto const replica_handler = [](RoleReplicaData const &) -> UnregisterReplicaResult {
+    return UnregisterReplicaResult::NOT_MAIN;
+  };
+  auto const main_handler = [this, name](RoleMainData &mainData) -> UnregisterReplicaResult {
+    if (!dbms_handler_.ReplicationState().TryPersistUnregisterReplica(name)) {
+      return UnregisterReplicaResult::COULD_NOT_BE_PERSISTED;
+    }
+    // Remove database specific clients
+    dbms_handler_.ForEach([name](Database *db) {
+      db->storage()->repl_storage_state_.replication_clients_.WithLock([&name](auto &clients) {
+        std::erase_if(clients, [name](const auto &client) { return client->Name() == name; });
+      });
+    });
+    // Remove instance level clients
+    auto const n_unregistered =
+        std::erase_if(mainData.registered_replicas_, [name](auto const &client) { return client.name_ == name; });
+    return n_unregistered != 0 ? UnregisterReplicaResult::SUCCESS : UnregisterReplicaResult::CAN_NOT_UNREGISTER;
+  };
+
+  return std::visit(utils::Overloaded{main_handler, replica_handler},
+                    dbms_handler_.ReplicationState().ReplicationData());
+}
+
+auto ReplicationHandler::GetRole() const -> memgraph::replication::ReplicationRole {
+  return dbms_handler_.ReplicationState().GetRole();
+}
+
+bool ReplicationHandler::IsMain() const { return dbms_handler_.ReplicationState().IsMain(); }
+
+bool ReplicationHandler::IsReplica() const { return dbms_handler_.ReplicationState().IsReplica(); }
+
+// Per storage
+// NOTE Storage will connect to all replicas. Future work might change this
+void RestoreReplication(replication::ReplicationState &repl_state, storage::Storage &storage) {
+  spdlog::info("Restoring replication role.");
+
+  /// MAIN
+  auto const recover_main = [&storage](RoleMainData &mainData) {
+    // Each individual client has already been restored and started. Here we just go through each database and start its
+    // client
+    for (auto &instance_client : mainData.registered_replicas_) {
+      spdlog::info("Replica {} restoration started for {}.", instance_client.name_, storage.id());
+
+      const auto &ret = storage.repl_storage_state_.replication_clients_.WithLock(
+          [&](auto &storage_clients) -> utils::BasicResult<RegisterReplicaError> {
+            auto client = std::make_unique<storage::ReplicationStorageClient>(instance_client);
+            client->Start(&storage);
+            // After start the storage <-> replica state should be READY or RECOVERING (if correctly started)
+            // MAYBE_BEHIND isn't a statement of the current state, this is the default value
+            // Failed to start due to branching of MAIN and REPLICA
+            if (client->State() == storage::replication::ReplicaState::MAYBE_BEHIND) {
+              spdlog::warn("Connection failed when registering replica {}. Replica will still be registered.",
+                           instance_client.name_);
+            }
+            storage_clients.push_back(std::move(client));
+            return {};
+          });
+
+      if (ret.HasError()) {
+        MG_ASSERT(RegisterReplicaError::CONNECTION_FAILED != ret.GetError());
+        LOG_FATAL("Failure when restoring replica {}: {}.", instance_client.name_,
+                  RegisterReplicaErrorToString(ret.GetError()));
+      }
+      spdlog::info("Replica {} restored for {}.", instance_client.name_, storage.id());
+    }
+    spdlog::info("Replication role restored to MAIN.");
+  };
+
+  /// REPLICA
+  auto const recover_replica = [](RoleReplicaData const &data) { /*nothing to do*/ };
+
+  std::visit(
+      utils::Overloaded{
+          recover_main,
+          recover_replica,
+      },
+      repl_state.ReplicationData());
+}
+}  // namespace memgraph::dbms

src/dbms/replication_handler.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
@@ -11,7 +11,8 @@
 
 #pragma once
 
-#include "replication_coordination_glue/role.hpp"
+#include "replication/role.hpp"
+#include "storage/v2/storage.hpp"
 #include "utils/result.hpp"
 
 // BEGIN fwd declares
@@ -21,9 +22,10 @@ struct ReplicationServerConfig;
 struct ReplicationClientConfig;
 }  // namespace memgraph::replication
 
-namespace memgraph::query {
+namespace memgraph::dbms {
+class DbmsHandler;
 
-enum class RegisterReplicaError : uint8_t { NAME_EXISTS, ENDPOINT_EXISTS, CONNECTION_FAILED, COULD_NOT_BE_PERSISTED };
+enum class RegisterReplicaError : uint8_t { NAME_EXISTS, END_POINT_EXISTS, CONNECTION_FAILED, COULD_NOT_BE_PERSISTED };
 enum class UnregisterReplicaResult : uint8_t {
   NOT_MAIN,
   COULD_NOT_BE_PERSISTED,
@@ -32,29 +34,34 @@ enum class UnregisterReplicaResult : uint8_t {
 };
 
 /// A handler type that keep in sync current ReplicationState and the MAIN/REPLICA-ness of Storage
-struct ReplicationQueryHandler {
-  virtual ~ReplicationQueryHandler() = default;
+/// TODO: extend to do multiple storages
+struct ReplicationHandler {
+  explicit ReplicationHandler(DbmsHandler &dbms_handler);
 
   // as REPLICA, become MAIN
-  virtual bool SetReplicationRoleMain() = 0;
+  bool SetReplicationRoleMain();
 
   // as MAIN, become REPLICA
-  virtual bool SetReplicationRoleReplica(const memgraph::replication::ReplicationServerConfig &config) = 0;
+  bool SetReplicationRoleReplica(const memgraph::replication::ReplicationServerConfig &config);
 
   // as MAIN, define and connect to REPLICAs
-  virtual auto TryRegisterReplica(const memgraph::replication::ReplicationClientConfig &config)
-      -> utils::BasicResult<RegisterReplicaError> = 0;
-
-  virtual auto RegisterReplica(const memgraph::replication::ReplicationClientConfig &config)
-      -> utils::BasicResult<RegisterReplicaError> = 0;
+  auto RegisterReplica(const memgraph::replication::ReplicationClientConfig &config)
+      -> utils::BasicResult<RegisterReplicaError>;
 
   // as MAIN, remove a REPLICA connection
-  virtual auto UnregisterReplica(std::string_view name) -> UnregisterReplicaResult = 0;
+  auto UnregisterReplica(std::string_view name) -> UnregisterReplicaResult;
 
   // Helper pass-through (TODO: remove)
-  virtual auto GetRole() const -> memgraph::replication_coordination_glue::ReplicationRole = 0;
-  virtual bool IsMain() const = 0;
-  virtual bool IsReplica() const = 0;
+  auto GetRole() const -> memgraph::replication::ReplicationRole;
+  bool IsMain() const;
+  bool IsReplica() const;
+
+ private:
+  DbmsHandler &dbms_handler_;
 };
 
-}  // namespace memgraph::query
+/// A handler type that keep in sync current ReplicationState and the MAIN/REPLICA-ness of Storage
+/// TODO: extend to do multiple storages
+void RestoreReplication(replication::ReplicationState &repl_state, storage::Storage &storage);
+
+}  // namespace memgraph::dbms

src/dbms/replication_handlers.cpp

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

src/dbms/replication_handlers.hpp

@@ -1,32 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include "dbms/dbms_handler.hpp"
-#include "replication/state.hpp"
-#include "slk/streams.hpp"
-#include "system/state.hpp"
-
-namespace memgraph::dbms {
-#ifdef MG_ENTERPRISE
-// RPC handlers
-void CreateDatabaseHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access,
-                           DbmsHandler &dbms_handler, slk::Reader *req_reader, slk::Builder *res_builder);
-void DropDatabaseHandler(memgraph::system::ReplicaHandlerAccessToState &system_state_access, DbmsHandler &dbms_handler,
-                         slk::Reader *req_reader, slk::Builder *res_builder);
-bool SystemRecoveryHandler(DbmsHandler &dbms_handler, const std::vector<storage::SalientConfig> &database_configs);
-
-// RPC registration
-void Register(replication::RoleReplicaData const &data, system::ReplicaHandlerAccessToState &system_state_access,
-              dbms::DbmsHandler &dbms_handler);
-#endif
-}  // namespace memgraph::dbms

src/dbms/rpc.cpp

@@ -1,118 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#include "dbms/rpc.hpp"
-
-#include "slk/streams.hpp"
-#include "storage/v2/replication/rpc.hpp"
-#include "utils/enum.hpp"
-#include "utils/typeinfo.hpp"
-
-namespace memgraph {
-
-namespace storage::replication {
-
-void CreateDatabaseReq::Save(const CreateDatabaseReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void CreateDatabaseReq::Load(CreateDatabaseReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-void CreateDatabaseRes::Save(const CreateDatabaseRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void CreateDatabaseRes::Load(CreateDatabaseRes *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(self, reader);
-}
-void DropDatabaseReq::Save(const DropDatabaseReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void DropDatabaseReq::Load(DropDatabaseReq *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
-void DropDatabaseRes::Save(const DropDatabaseRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self, builder);
-}
-void DropDatabaseRes::Load(DropDatabaseRes *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
-
-const utils::TypeInfo CreateDatabaseReq::kType{utils::TypeId::REP_CREATE_DATABASE_REQ, "CreateDatabaseReq", nullptr};
-
-const utils::TypeInfo CreateDatabaseRes::kType{utils::TypeId::REP_CREATE_DATABASE_RES, "CreateDatabaseRes", nullptr};
-
-const utils::TypeInfo DropDatabaseReq::kType{utils::TypeId::REP_DROP_DATABASE_REQ, "DropDatabaseReq", nullptr};
-
-const utils::TypeInfo DropDatabaseRes::kType{utils::TypeId::REP_DROP_DATABASE_RES, "DropDatabaseRes", nullptr};
-
-}  // namespace storage::replication
-
-// Autogenerated SLK serialization code
-namespace slk {
-
-// Serialize code for CreateDatabaseReq
-
-void Save(const memgraph::storage::replication::CreateDatabaseReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.epoch_id, builder);
-  memgraph::slk::Save(self.expected_group_timestamp, builder);
-  memgraph::slk::Save(self.new_group_timestamp, builder);
-  memgraph::slk::Save(self.config, builder);
-}
-
-void Load(memgraph::storage::replication::CreateDatabaseReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->epoch_id, reader);
-  memgraph::slk::Load(&self->expected_group_timestamp, reader);
-  memgraph::slk::Load(&self->new_group_timestamp, reader);
-  memgraph::slk::Load(&self->config, reader);
-}
-
-// Serialize code for CreateDatabaseRes
-
-void Save(const memgraph::storage::replication::CreateDatabaseRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(utils::EnumToNum<uint8_t>(self.result), builder);
-}
-
-void Load(memgraph::storage::replication::CreateDatabaseRes *self, memgraph::slk::Reader *reader) {
-  uint8_t res = 0;
-  memgraph::slk::Load(&res, reader);
-  if (!utils::NumToEnum(res, self->result)) {
-    throw SlkReaderException("Unexpected result line:{}!", __LINE__);
-  }
-}
-
-// Serialize code for DropDatabaseReq
-
-void Save(const memgraph::storage::replication::DropDatabaseReq &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(self.epoch_id, builder);
-  memgraph::slk::Save(self.expected_group_timestamp, builder);
-  memgraph::slk::Save(self.new_group_timestamp, builder);
-  memgraph::slk::Save(self.uuid, builder);
-}
-
-void Load(memgraph::storage::replication::DropDatabaseReq *self, memgraph::slk::Reader *reader) {
-  memgraph::slk::Load(&self->epoch_id, reader);
-  memgraph::slk::Load(&self->expected_group_timestamp, reader);
-  memgraph::slk::Load(&self->new_group_timestamp, reader);
-  memgraph::slk::Load(&self->uuid, reader);
-}
-
-// Serialize code for DropDatabaseRes
-
-void Save(const memgraph::storage::replication::DropDatabaseRes &self, memgraph::slk::Builder *builder) {
-  memgraph::slk::Save(utils::EnumToNum<uint8_t>(self.result), builder);
-}
-
-void Load(memgraph::storage::replication::DropDatabaseRes *self, memgraph::slk::Reader *reader) {
-  uint8_t res = 0;
-  memgraph::slk::Load(&res, reader);
-  if (!utils::NumToEnum(res, self->result)) {
-    throw SlkReaderException("Unexpected result line:{}!", __LINE__);
-  }
-}
-
-}  // namespace slk
-}  // namespace memgraph

src/dbms/rpc.hpp

@@ -1,118 +0,0 @@
-// Copyright 2024 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include <cstdint>
-#include <string>
-#include <utility>
-
-#include "rpc/messages.hpp"
-#include "slk/streams.hpp"
-#include "storage/v2/config.hpp"
-#include "utils/uuid.hpp"
-
-namespace memgraph::storage::replication {
-
-struct CreateDatabaseReq {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(CreateDatabaseReq *self, memgraph::slk::Reader *reader);
-  static void Save(const CreateDatabaseReq &self, memgraph::slk::Builder *builder);
-  CreateDatabaseReq() = default;
-  CreateDatabaseReq(std::string_view epoch_id, uint64_t expected_group_timestamp, uint64_t new_group_timestamp,
-                    storage::SalientConfig config)
-      : epoch_id(std::string(epoch_id)),
-        expected_group_timestamp{expected_group_timestamp},
-        new_group_timestamp(new_group_timestamp),
-        config(std::move(config)) {}
-
-  std::string epoch_id;
-  uint64_t expected_group_timestamp;
-  uint64_t new_group_timestamp;
-  storage::SalientConfig config;
-};
-
-struct CreateDatabaseRes {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  enum class Result : uint8_t { SUCCESS, NO_NEED, FAILURE, /* Leave at end */ N };
-
-  static void Load(CreateDatabaseRes *self, memgraph::slk::Reader *reader);
-  static void Save(const CreateDatabaseRes &self, memgraph::slk::Builder *builder);
-  CreateDatabaseRes() = default;
-  explicit CreateDatabaseRes(Result res) : result(res) {}
-
-  Result result;
-};
-
-using CreateDatabaseRpc = rpc::RequestResponse<CreateDatabaseReq, CreateDatabaseRes>;
-
-struct DropDatabaseReq {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  static void Load(DropDatabaseReq *self, memgraph::slk::Reader *reader);
-  static void Save(const DropDatabaseReq &self, memgraph::slk::Builder *builder);
-  DropDatabaseReq() = default;
-  DropDatabaseReq(std::string_view epoch_id, uint64_t expected_group_timestamp, uint64_t new_group_timestamp,
-                  const utils::UUID &uuid)
-      : epoch_id(std::string(epoch_id)),
-        expected_group_timestamp{expected_group_timestamp},
-        new_group_timestamp(new_group_timestamp),
-        uuid(uuid) {}
-
-  std::string epoch_id;
-  uint64_t expected_group_timestamp;
-  uint64_t new_group_timestamp;
-  utils::UUID uuid;
-};
-
-struct DropDatabaseRes {
-  static const utils::TypeInfo kType;
-  static const utils::TypeInfo &GetTypeInfo() { return kType; }
-
-  enum class Result : uint8_t { SUCCESS, NO_NEED, FAILURE, /* Leave at end */ N };
-
-  static void Load(DropDatabaseRes *self, memgraph::slk::Reader *reader);
-  static void Save(const DropDatabaseRes &self, memgraph::slk::Builder *builder);
-  DropDatabaseRes() = default;
-  explicit DropDatabaseRes(Result res) : result(res) {}
-
-  Result result;
-};
-
-using DropDatabaseRpc = rpc::RequestResponse<DropDatabaseReq, DropDatabaseRes>;
-
-}  // namespace memgraph::storage::replication
-
-// SLK serialization declarations
-namespace memgraph::slk {
-
-void Save(const memgraph::storage::replication::CreateDatabaseReq &self, memgraph::slk::Builder *builder);
-
-void Load(memgraph::storage::replication::CreateDatabaseReq *self, memgraph::slk::Reader *reader);
-
-void Save(const memgraph::storage::replication::CreateDatabaseRes &self, memgraph::slk::Builder *builder);
-
-void Load(memgraph::storage::replication::CreateDatabaseRes *self, memgraph::slk::Reader *reader);
-
-void Save(const memgraph::storage::replication::DropDatabaseReq &self, memgraph::slk::Builder *builder);
-
-void Load(memgraph::storage::replication::DropDatabaseReq *self, memgraph::slk::Reader *reader);
-
-void Save(const memgraph::storage::replication::DropDatabaseRes &self, memgraph::slk::Builder *builder);
-
-void Load(memgraph::storage::replication::DropDatabaseRes *self, memgraph::slk::Reader *reader);
-
-}  // namespace memgraph::slk

src/dbms/transaction.hpp

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

src/flags/CMakeLists.txt

@@ -6,7 +6,6 @@ add_library(mg-flags STATIC audit.cpp
                             memory_limit.cpp
                             run_time_configurable.cpp
                             storage_mode.cpp
-                            query.cpp
-                            replication.cpp)
+                            query.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

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -17,6 +17,5 @@
 #include "flags/log_level.hpp"
 #include "flags/memory_limit.hpp"
 #include "flags/query.hpp"
-#include "flags/replication.hpp"
 #include "flags/run_time_configurable.hpp"
 #include "flags/storage_mode.hpp"

src/flags/general.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
@@ -131,6 +131,12 @@ DEFINE_uint64(storage_recovery_thread_count,
 DEFINE_bool(storage_enable_schema_metadata, false,
             "Controls whether metadata should be collected about the resident labels and edge types.");
 
+#ifdef MG_ENTERPRISE
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_bool(storage_delete_on_drop, true,
+            "If set to true the query 'DROP DATABASE x' will delete the underlying storage as well.");
+#endif
+
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_bool(telemetry_enabled, false,
             "Set to true to enable telemetry. We collect information about the "
@@ -156,6 +162,13 @@ DEFINE_string(pulsar_service_url, "", "Default URL used while connecting to Puls
 
 // Query flags.
 
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_uint64(replication_replica_check_frequency_sec, 1,
+              "The time duration between two replica checks/pings. If < 1, replicas will NOT be checked at all. NOTE: "
+              "The MAIN instance allocates a new thread for each REPLICA.");
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_bool(replication_restore_state_on_startup, false, "Restore replication state on startup, e.g. recover replica");
+
 DEFINE_VALIDATED_string(query_modules_directory, "",
                         "Directory where modules with custom query procedures are stored. "
                         "NOTE: Multiple comma-separated directories can be defined.",
@@ -195,9 +208,3 @@ DEFINE_HIDDEN_string(organization_name, "", "Organization name.");
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_string(auth_user_or_role_name_regex, memgraph::glue::kDefaultUserRoleRegex.data(),
               "Set to the regular expression that each user or role name must fulfill.");
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_bool(auth_password_permit_null, true, "Set to false to disable null passwords.");
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_string(auth_password_strength_regex, memgraph::glue::kDefaultPasswordRegex.data(),
-              "The regular expression that should be used to match the entire "
-              "entered password to ensure its strength.");

src/flags/general.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
@@ -84,6 +84,10 @@ DECLARE_bool(storage_parallel_schema_recovery);
 DECLARE_uint64(storage_recovery_thread_count);
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DECLARE_bool(storage_enable_schema_metadata);
+#ifdef MG_ENTERPRISE
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_bool(storage_delete_on_drop);
+#endif
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DECLARE_bool(telemetry_enabled);
@@ -112,13 +116,14 @@ namespace memgraph::flags {
 auto ParseQueryModulesDirectory() -> std::vector<std::filesystem::path>;
 }  // namespace memgraph::flags
 
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_uint64(replication_replica_check_frequency_sec);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_bool(replication_restore_state_on_startup);
+
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DECLARE_string(license_key);
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DECLARE_string(organization_name);
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DECLARE_string(auth_user_or_role_name_regex);
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_bool(auth_password_permit_null);
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_string(auth_password_strength_regex);

src/flags/replication.cpp

@@ -1,26 +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 "replication.hpp"
-
-#ifdef MG_ENTERPRISE
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_bool(coordinator, false, "Controls whether the instance is a replication coordinator.");
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_uint32(coordinator_server_port, 0, "Port on which coordinator servers will be started.");
-#endif
-
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_uint64(replication_replica_check_frequency_sec, 1,
-              "The time duration between two replica checks/pings. If < 1, replicas will NOT be checked at all. NOTE: "
-              "The MAIN instance allocates a new thread for each REPLICA.");
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_bool(replication_restore_state_on_startup, false, "Restore replication state on startup, e.g. recover replica");

src/flags/replication.hpp

@@ -1,26 +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"
-
-#ifdef MG_ENTERPRISE
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_bool(coordinator);
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_uint32(coordinator_server_port);
-#endif
-
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_uint64(replication_replica_check_frequency_sec);
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_bool(replication_restore_state_on_startup);

src/flags/storage_mode.cpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -17,14 +17,20 @@
 
 #include "gflags/gflags.h"
 
+#include <array>
+
+inline constexpr std::array storage_mode_mappings{
+    std::pair{std::string_view{"IN_MEMORY_TRANSACTIONAL"}, memgraph::storage::StorageMode::IN_MEMORY_TRANSACTIONAL},
+    std::pair{std::string_view{"IN_MEMORY_ANALYTICAL"}, memgraph::storage::StorageMode::IN_MEMORY_ANALYTICAL},
+    std::pair{std::string_view{"ON_DISK_TRANSACTIONAL"}, memgraph::storage::StorageMode::ON_DISK_TRANSACTIONAL}};
+
 const std::string storage_mode_help_string =
     fmt::format("Default storage mode Memgraph uses. Allowed values: {}",
-                memgraph::utils::GetAllowedEnumValuesString(memgraph::storage::storage_mode_mappings));
+                memgraph::utils::GetAllowedEnumValuesString(storage_mode_mappings));
 
 // NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_VALIDATED_string(storage_mode, "IN_MEMORY_TRANSACTIONAL", storage_mode_help_string.c_str(), {
-  if (const auto result = memgraph::utils::IsValidEnumValueString(value, memgraph::storage::storage_mode_mappings);
-      result.HasError()) {
+  if (const auto result = memgraph::utils::IsValidEnumValueString(value, storage_mode_mappings); result.HasError()) {
     switch (result.GetError()) {
       case memgraph::utils::ValidationError::EmptyValue: {
         std::cout << "Storage mode cannot be empty." << std::endl;
@@ -32,7 +38,7 @@ DEFINE_VALIDATED_string(storage_mode, "IN_MEMORY_TRANSACTIONAL", storage_mode_he
       }
       case memgraph::utils::ValidationError::InvalidValue: {
         std::cout << "Invalid value for storage mode. Allowed values: "
-                  << memgraph::utils::GetAllowedEnumValuesString(memgraph::storage::storage_mode_mappings) << std::endl;
+                  << memgraph::utils::GetAllowedEnumValuesString(storage_mode_mappings) << std::endl;
         break;
       }
     }
@@ -42,8 +48,8 @@ DEFINE_VALIDATED_string(storage_mode, "IN_MEMORY_TRANSACTIONAL", storage_mode_he
 });
 
 memgraph::storage::StorageMode memgraph::flags::ParseStorageMode() {
-  const auto storage_mode = memgraph::utils::StringToEnum<memgraph::storage::StorageMode>(
-      FLAGS_storage_mode, memgraph::storage::storage_mode_mappings);
+  const auto storage_mode =
+      memgraph::utils::StringToEnum<memgraph::storage::StorageMode>(FLAGS_storage_mode, storage_mode_mappings);
   MG_ASSERT(storage_mode, "Invalid storage mode");
   return *storage_mode;
 }

src/glue/ServerT.hpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -33,7 +33,7 @@ class WritePrioritizedRWLock;
 
 struct Context {
   memgraph::query::InterpreterContext *ic;
-  memgraph::auth::SynchedAuth *auth;
+  memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth;
 #if MG_ENTERPRISE
   memgraph::audit::Log *audit_log;
 #endif

src/glue/SessionHL.cpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -80,7 +80,7 @@ std::vector<memgraph::communication::bolt::Value> TypedValueResultStreamBase::De
   std::vector<memgraph::communication::bolt::Value> decoded_values;
   decoded_values.reserve(values.size());
   for (const auto &v : values) {
-    auto maybe_value = memgraph::glue::ToBoltValue(v, storage_, memgraph::storage::View::NEW);
+    auto maybe_value = memgraph::glue::ToBoltValue(v, *storage_, memgraph::storage::View::NEW);
     if (maybe_value.HasError()) {
       switch (maybe_value.GetError()) {
         case memgraph::storage::Error::DELETED_OBJECT:
@@ -112,14 +112,14 @@ std::string SessionHL::GetDefaultDB() {
   if (user_.has_value()) {
     return user_->db_access().GetDefault();
   }
-  return std::string{memgraph::dbms::kDefaultDB};
+  return memgraph::dbms::kDefaultDB;
 }
 #endif
 
 std::string SessionHL::GetCurrentDB() const {
   if (!interpreter_.current_db_.db_acc_) return "";
   const auto *db = interpreter_.current_db_.db_acc_->get();
-  return db->name();
+  return db->id();
 }
 
 std::optional<std::string> SessionHL::GetServerNameForInit() {
@@ -167,10 +167,10 @@ std::map<std::string, memgraph::communication::bolt::Value> SessionHL::Discard(s
 std::map<std::string, memgraph::communication::bolt::Value> SessionHL::Pull(SessionHL::TEncoder *encoder,
                                                                             std::optional<int> n,
                                                                             std::optional<int> qid) {
+  // TODO: Update once interpreter can handle non-database queries (db_acc will be nullopt)
+  auto *db = interpreter_.current_db_.db_acc_->get();
   try {
-    auto &db = interpreter_.current_db_.db_acc_;
-    auto *storage = db ? db->get()->storage() : nullptr;
-    TypedValueResultStream<TEncoder> stream(encoder, storage);
+    TypedValueResultStream<TEncoder> stream(encoder, db->storage());
     return DecodeSummary(interpreter_.Pull(&stream, n, qid));
   } catch (const memgraph::query::QueryException &e) {
     // Count the number of specific exceptions thrown
@@ -193,17 +193,17 @@ std::pair<std::vector<std::string>, std::optional<int>> SessionHL::Interpret(
   for (const auto &[key, bolt_param] : params) {
     params_pv.emplace(key, ToPropertyValue(bolt_param));
   }
-
-#ifdef MG_ENTERPRISE
   const std::string *username{nullptr};
   if (user_) {
     username = &user_->username();
   }
 
+#ifdef MG_ENTERPRISE
+  // TODO: Update once interpreter can handle non-database queries (db_acc will be nullopt)
+  auto *db = interpreter_.current_db_.db_acc_->get();
   if (memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
-    auto &db = interpreter_.current_db_.db_acc_;
     audit_log_->Record(endpoint_.address().to_string(), user_ ? *username : "", query,
-                       memgraph::storage::PropertyValue(params_pv), db ? db->get()->name() : "no known database");
+                       memgraph::storage::PropertyValue(params_pv), db->id());
   }
 #endif
   try {
@@ -319,7 +319,8 @@ void SessionHL::Configure(const std::map<std::string, memgraph::communication::b
 SessionHL::SessionHL(memgraph::query::InterpreterContext *interpreter_context,
                      memgraph::communication::v2::ServerEndpoint endpoint,
                      memgraph::communication::v2::InputStream *input_stream,
-                     memgraph::communication::v2::OutputStream *output_stream, memgraph::auth::SynchedAuth *auth
+                     memgraph::communication::v2::OutputStream *output_stream,
+                     memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth
 #ifdef MG_ENTERPRISE
                      ,
                      memgraph::audit::Log *audit_log
@@ -350,11 +351,11 @@ SessionHL::~SessionHL() {
 
 std::map<std::string, memgraph::communication::bolt::Value> SessionHL::DecodeSummary(
     const std::map<std::string, memgraph::query::TypedValue> &summary) {
-  auto &db_acc = interpreter_.current_db_.db_acc_;
-  auto *storage = db_acc ? db_acc->get()->storage() : nullptr;
+  // TODO: Update once interpreter can handle non-database queries (db_acc will be nullopt)
+  auto *db = interpreter_.current_db_.db_acc_->get();
   std::map<std::string, memgraph::communication::bolt::Value> decoded_summary;
   for (const auto &kv : summary) {
-    auto maybe_value = ToBoltValue(kv.second, storage, memgraph::storage::View::NEW);
+    auto maybe_value = ToBoltValue(kv.second, *db->storage(), memgraph::storage::View::NEW);
     if (maybe_value.HasError()) {
       switch (maybe_value.GetError()) {
         case memgraph::storage::Error::DELETED_OBJECT:

src/glue/SessionHL.hpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -25,7 +25,8 @@ class SessionHL final : public memgraph::communication::bolt::Session<memgraph::
   SessionHL(memgraph::query::InterpreterContext *interpreter_context,
             memgraph::communication::v2::ServerEndpoint endpoint,
             memgraph::communication::v2::InputStream *input_stream,
-            memgraph::communication::v2::OutputStream *output_stream, memgraph::auth::SynchedAuth *auth
+            memgraph::communication::v2::OutputStream *output_stream,
+            memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth
 #ifdef MG_ENTERPRISE
             ,
             memgraph::audit::Log *audit_log
@@ -87,7 +88,7 @@ class SessionHL final : public memgraph::communication::bolt::Session<memgraph::
   memgraph::audit::Log *audit_log_;
   bool in_explicit_db_{false};  //!< If true, the user has defined the database to use via metadata
 #endif
-  memgraph::auth::SynchedAuth *auth_;
+  memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth_;
   memgraph::communication::v2::ServerEndpoint endpoint_;
   std::optional<std::string> implicit_db_;
 };

src/glue/auth.cpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -66,8 +66,6 @@ auth::Permission PrivilegeToPermission(query::AuthQuery::Privilege privilege) {
       return auth::Permission::MULTI_DATABASE_EDIT;
     case query::AuthQuery::Privilege::MULTI_DATABASE_USE:
       return auth::Permission::MULTI_DATABASE_USE;
-    case query::AuthQuery::Privilege::COORDINATOR:
-      return auth::Permission::COORDINATOR;
   }
 }
 

src/glue/auth_checker.cpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -66,7 +66,9 @@ bool IsUserAuthorizedEdgeType(const memgraph::auth::User &user, const memgraph::
 #endif
 namespace memgraph::glue {
 
-AuthChecker::AuthChecker(memgraph::auth::SynchedAuth *auth) : auth_(auth) {}
+AuthChecker::AuthChecker(
+    memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth)
+    : auth_(auth) {}
 
 bool AuthChecker::IsUserAuthorized(const std::optional<std::string> &username,
                                    const std::vector<memgraph::query::AuthQuery::Privilege> &privileges,

src/glue/auth_checker.hpp

@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -22,7 +22,8 @@ namespace memgraph::glue {
 
 class AuthChecker : public query::AuthChecker {
  public:
-  explicit AuthChecker(memgraph::auth::SynchedAuth *auth);
+  explicit AuthChecker(
+      memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth);
 
   bool IsUserAuthorized(const std::optional<std::string> &username,
                         const std::vector<query::AuthQuery::Privilege> &privileges,
@@ -40,7 +41,7 @@ class AuthChecker : public query::AuthChecker {
                                              const std::string &db_name = "");
 
  private:
-  memgraph::auth::SynchedAuth *auth_;
+  memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth_;
   mutable memgraph::utils::Synchronized<auth::User, memgraph::utils::SpinLock> user_;  // cached user
 };
 #ifdef MG_ENTERPRISE

src/glue/auth_global.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
@@ -13,5 +13,4 @@
 
 namespace memgraph::glue {
 inline constexpr std::string_view kDefaultUserRoleRegex = "[a-zA-Z0-9_.+-@]+";
-static constexpr std::string_view kDefaultPasswordRegex = ".+";
 }  // namespace memgraph::glue

src/glue/auth_handler.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
@@ -210,25 +210,16 @@ std::vector<std::vector<memgraph::query::TypedValue>> ShowFineGrainedUserPrivile
   if (!memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
     return {};
   }
+  const auto &label_permissions = user->GetFineGrainedAccessLabelPermissions();
+  const auto &edge_type_permissions = user->GetFineGrainedAccessEdgeTypePermissions();
 
-  auto all_fine_grained_permissions = GetFineGrainedPermissionForPrivilegeForUserOrRole(
-      user->GetUserFineGrainedAccessLabelPermissions(), "LABEL", "USER");
-  auto all_role_fine_grained_permissions = GetFineGrainedPermissionForPrivilegeForUserOrRole(
-      user->GetRoleFineGrainedAccessLabelPermissions(), "LABEL", "ROLE");
-  all_fine_grained_permissions.insert(all_fine_grained_permissions.end(),
-                                      std::make_move_iterator(all_role_fine_grained_permissions.begin()),
-                                      std::make_move_iterator(all_role_fine_grained_permissions.end()));
+  auto all_fine_grained_permissions =
+      GetFineGrainedPermissionForPrivilegeForUserOrRole(label_permissions, "LABEL", "USER");
+  auto edge_type_fine_grained_permissions =
+      GetFineGrainedPermissionForPrivilegeForUserOrRole(edge_type_permissions, "EDGE_TYPE", "USER");
 
-  auto edge_type_fine_grained_permissions = GetFineGrainedPermissionForPrivilegeForUserOrRole(
-      user->GetUserFineGrainedAccessEdgeTypePermissions(), "EDGE_TYPE", "USER");
-  auto role_edge_type_fine_grained_permissions = GetFineGrainedPermissionForPrivilegeForUserOrRole(
-      user->GetRoleFineGrainedAccessEdgeTypePermissions(), "EDGE_TYPE", "ROLE");
-  all_fine_grained_permissions.insert(all_fine_grained_permissions.end(),
-                                      std::make_move_iterator(edge_type_fine_grained_permissions.begin()),
-                                      std::make_move_iterator(edge_type_fine_grained_permissions.end()));
-  all_fine_grained_permissions.insert(all_fine_grained_permissions.end(),
-                                      std::make_move_iterator(role_edge_type_fine_grained_permissions.begin()),
-                                      std::make_move_iterator(role_edge_type_fine_grained_permissions.end()));
+  all_fine_grained_permissions.insert(all_fine_grained_permissions.end(), edge_type_fine_grained_permissions.begin(),
+                                      edge_type_fine_grained_permissions.end());
 
   return ConstructFineGrainedPrivilegesResult(all_fine_grained_permissions);
 }
@@ -242,9 +233,9 @@ std::vector<std::vector<memgraph::query::TypedValue>> ShowFineGrainedRolePrivile
   const auto &edge_type_permissions = role->GetFineGrainedAccessEdgeTypePermissions();
 
   auto all_fine_grained_permissions =
-      GetFineGrainedPermissionForPrivilegeForUserOrRole(label_permissions, "LABEL", "ROLE");
+      GetFineGrainedPermissionForPrivilegeForUserOrRole(label_permissions, "LABEL", "USER");
   auto edge_type_fine_grained_permissions =
-      GetFineGrainedPermissionForPrivilegeForUserOrRole(edge_type_permissions, "EDGE_TYPE", "ROLE");
+      GetFineGrainedPermissionForPrivilegeForUserOrRole(edge_type_permissions, "EDGE_TYPE", "USER");
 
   all_fine_grained_permissions.insert(all_fine_grained_permissions.end(), edge_type_fine_grained_permissions.begin(),
                                       edge_type_fine_grained_permissions.end());
@@ -257,15 +248,31 @@ std::vector<std::vector<memgraph::query::TypedValue>> ShowFineGrainedRolePrivile
 
 namespace memgraph::glue {
 
-AuthQueryHandler::AuthQueryHandler(memgraph::auth::SynchedAuth *auth) : auth_(auth) {}
+AuthQueryHandler::AuthQueryHandler(
+    memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth,
+    std::string name_regex_string)
+    : auth_(auth), name_regex_string_(std::move(name_regex_string)), name_regex_(name_regex_string_) {}
 
-bool AuthQueryHandler::CreateUser(const std::string &username, const std::optional<std::string> &password,
-                                  system::Transaction *system_tx) {
+bool AuthQueryHandler::CreateUser(const std::string &username, const std::optional<std::string> &password) {
+  if (name_regex_string_ != kDefaultUserRoleRegex) {
+    if (const auto license_check_result =
+            memgraph::license::global_license_checker.IsEnterpriseValid(memgraph::utils::global_settings);
+        license_check_result.HasError()) {
+      throw memgraph::auth::AuthException(
+          "Custom user/role regex is a Memgraph Enterprise feature. Please set the config "
+          "(\"--auth-user-or-role-name-regex\") to its default value (\"{}\") or remove the flag.\n{}",
+          kDefaultUserRoleRegex,
+          memgraph::license::LicenseCheckErrorToString(license_check_result.GetError(), "user/role regex"));
+    }
+  }
+  if (!std::regex_match(username, name_regex_)) {
+    throw query::QueryRuntimeException("Invalid user name.");
+  }
   try {
     const auto [first_user, user_added] = std::invoke([&, this] {
       auto locked_auth = auth_->Lock();
       const auto first_user = !locked_auth->HasUsers();
-      const auto user_added = locked_auth->AddUser(username, password, system_tx).has_value();
+      const auto user_added = locked_auth->AddUser(username, password).has_value();
       return std::make_pair(first_user, user_added);
     });
 
@@ -284,11 +291,10 @@ bool AuthQueryHandler::CreateUser(const std::string &username, const std::option
             }
           }
 #endif
-          ,
-          system_tx);
+      );
 #ifdef MG_ENTERPRISE
-      GrantDatabaseToUser(auth::kAllDatabases, username, system_tx);
-      SetMainDatabase(dbms::kDefaultDB, username, system_tx);
+      GrantDatabaseToUser(auth::kAllDatabases, username);
+      SetMainDatabase(username, dbms::kDefaultDB);
 #endif
     }
 
@@ -298,61 +304,73 @@ bool AuthQueryHandler::CreateUser(const std::string &username, const std::option
   }
 }
 
-bool AuthQueryHandler::DropUser(const std::string &username, system::Transaction *system_tx) {
+bool AuthQueryHandler::DropUser(const std::string &username) {
+  if (!std::regex_match(username, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid user name.");
+  }
   try {
     auto locked_auth = auth_->Lock();
     auto user = locked_auth->GetUser(username);
     if (!user) return false;
-    return locked_auth->RemoveUser(username, system_tx);
+    return locked_auth->RemoveUser(username);
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());
   }
 }
 
-void AuthQueryHandler::SetPassword(const std::string &username, const std::optional<std::string> &password,
-                                   system::Transaction *system_tx) {
+void AuthQueryHandler::SetPassword(const std::string &username, const std::optional<std::string> &password) {
+  if (!std::regex_match(username, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid user name.");
+  }
   try {
     auto locked_auth = auth_->Lock();
     auto user = locked_auth->GetUser(username);
     if (!user) {
       throw memgraph::query::QueryRuntimeException("User '{}' doesn't exist.", username);
     }
-    locked_auth->UpdatePassword(*user, password);
-    locked_auth->SaveUser(*user, system_tx);
+    user->UpdatePassword(password);
+    locked_auth->SaveUser(*user);
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());
   }
 }
 
-bool AuthQueryHandler::CreateRole(const std::string &rolename, system::Transaction *system_tx) {
+bool AuthQueryHandler::CreateRole(const std::string &rolename) {
+  if (!std::regex_match(rolename, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid role name.");
+  }
   try {
     auto locked_auth = auth_->Lock();
-    return locked_auth->AddRole(rolename, system_tx).has_value();
+    return locked_auth->AddRole(rolename).has_value();
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());
   }
 }
 
 #ifdef MG_ENTERPRISE
-bool AuthQueryHandler::RevokeDatabaseFromUser(const std::string &db_name, const std::string &username,
-                                              system::Transaction *system_tx) {
+bool AuthQueryHandler::RevokeDatabaseFromUser(const std::string &db, const std::string &username) {
+  if (!std::regex_match(username, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid user name.");
+  }
   try {
     auto locked_auth = auth_->Lock();
     auto user = locked_auth->GetUser(username);
     if (!user) return false;
-    return locked_auth->RevokeDatabaseFromUser(db_name, username, system_tx);
+    return locked_auth->RevokeDatabaseFromUser(db, username);
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());
   }
 }
 
-bool AuthQueryHandler::GrantDatabaseToUser(const std::string &db_name, const std::string &username,
-                                           system::Transaction *system_tx) {
+bool AuthQueryHandler::GrantDatabaseToUser(const std::string &db, const std::string &username) {
+  if (!std::regex_match(username, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid user name.");
+  }
   try {
     auto locked_auth = auth_->Lock();
     auto user = locked_auth->GetUser(username);
     if (!user) return false;
-    return locked_auth->GrantDatabaseToUser(db_name, username, system_tx);
+    return locked_auth->GrantDatabaseToUser(db, username);
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());
   }
@@ -360,6 +378,9 @@ bool AuthQueryHandler::GrantDatabaseToUser(const std::string &db_name, const std
 
 std::vector<std::vector<memgraph::query::TypedValue>> AuthQueryHandler::GetDatabasePrivileges(
     const std::string &username) {
+  if (!std::regex_match(username, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid user or role name.");
+  }
   try {
     auto locked_auth = auth_->ReadLock();
     auto user = locked_auth->GetUser(username);
@@ -372,28 +393,33 @@ std::vector<std::vector<memgraph::query::TypedValue>> AuthQueryHandler::GetDatab
   }
 }
 
-bool AuthQueryHandler::SetMainDatabase(std::string_view db_name, const std::string &username,
-                                       system::Transaction *system_tx) {
+bool AuthQueryHandler::SetMainDatabase(const std::string &db, const std::string &username) {
+  if (!std::regex_match(username, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid user name.");
+  }
   try {
     auto locked_auth = auth_->Lock();
     auto user = locked_auth->GetUser(username);
     if (!user) return false;
-    return locked_auth->SetMainDatabase(db_name, username, system_tx);
+    return locked_auth->SetMainDatabase(db, username);
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());
   }
 }
 
-void AuthQueryHandler::DeleteDatabase(std::string_view db_name, system::Transaction *system_tx) {
+void AuthQueryHandler::DeleteDatabase(std::string_view db) {
   try {
-    auth_->Lock()->DeleteDatabase(std::string(db_name), system_tx);
+    auth_->Lock()->DeleteDatabase(std::string(db));
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());
   }
 }
 #endif
 
-bool AuthQueryHandler::DropRole(const std::string &rolename, system::Transaction *system_tx) {
+bool AuthQueryHandler::DropRole(const std::string &rolename) {
+  if (!std::regex_match(rolename, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid role name.");
+  }
   try {
     auto locked_auth = auth_->Lock();
     auto role = locked_auth->GetRole(rolename);
@@ -402,7 +428,7 @@ bool AuthQueryHandler::DropRole(const std::string &rolename, system::Transaction
       return false;
     };
 
-    return locked_auth->RemoveRole(rolename, system_tx);
+    return locked_auth->RemoveRole(rolename);
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());
   }
@@ -439,6 +465,9 @@ std::vector<memgraph::query::TypedValue> AuthQueryHandler::GetRolenames() {
 }
 
 std::optional<std::string> AuthQueryHandler::GetRolenameForUser(const std::string &username) {
+  if (!std::regex_match(username, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid user name.");
+  }
   try {
     auto locked_auth = auth_->ReadLock();
     auto user = locked_auth->GetUser(username);
@@ -456,6 +485,9 @@ std::optional<std::string> AuthQueryHandler::GetRolenameForUser(const std::strin
 }
 
 std::vector<memgraph::query::TypedValue> AuthQueryHandler::GetUsernamesForRole(const std::string &rolename) {
+  if (!std::regex_match(rolename, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid role name.");
+  }
   try {
     auto locked_auth = auth_->ReadLock();
     auto role = locked_auth->GetRole(rolename);
@@ -474,8 +506,13 @@ std::vector<memgraph::query::TypedValue> AuthQueryHandler::GetUsernamesForRole(c
   }
 }
 
-void AuthQueryHandler::SetRole(const std::string &username, const std::string &rolename,
-                               system::Transaction *system_tx) {
+void AuthQueryHandler::SetRole(const std::string &username, const std::string &rolename) {
+  if (!std::regex_match(username, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid user name.");
+  }
+  if (!std::regex_match(rolename, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid role name.");
+  }
   try {
     auto locked_auth = auth_->Lock();
     auto user = locked_auth->GetUser(username);
@@ -491,13 +528,16 @@ void AuthQueryHandler::SetRole(const std::string &username, const std::string &r
                                                    current_role->rolename());
     }
     user->SetRole(*role);
-    locked_auth->SaveUser(*user, system_tx);
+    locked_auth->SaveUser(*user);
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());
   }
 }
 
-void AuthQueryHandler::ClearRole(const std::string &username, system::Transaction *system_tx) {
+void AuthQueryHandler::ClearRole(const std::string &username) {
+  if (!std::regex_match(username, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid user name.");
+  }
   try {
     auto locked_auth = auth_->Lock();
     auto user = locked_auth->GetUser(username);
@@ -505,13 +545,16 @@ void AuthQueryHandler::ClearRole(const std::string &username, system::Transactio
       throw memgraph::query::QueryRuntimeException("User '{}' doesn't exist .", username);
     }
     user->ClearRole();
-    locked_auth->SaveUser(*user, system_tx);
+    locked_auth->SaveUser(*user);
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());
   }
 }
 
 std::vector<std::vector<memgraph::query::TypedValue>> AuthQueryHandler::GetPrivileges(const std::string &user_or_role) {
+  if (!std::regex_match(user_or_role, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid user or role name.");
+  }
   try {
     auto locked_auth = auth_->ReadLock();
     std::vector<std::vector<memgraph::query::TypedValue>> grants;
@@ -559,8 +602,7 @@ void AuthQueryHandler::GrantPrivilege(
     const std::vector<std::unordered_map<memgraph::query::AuthQuery::FineGrainedPrivilege, std::vector<std::string>>>
         &edge_type_privileges
 #endif
-    ,
-    system::Transaction *system_tx) {
+) {
   EditPermissions(
       user_or_role, privileges,
 #ifdef MG_ENTERPRISE
@@ -583,13 +625,11 @@ void AuthQueryHandler::GrantPrivilege(
         }
       }
 #endif
-      ,
-      system_tx);
+  );
 }  // namespace memgraph::glue
 
 void AuthQueryHandler::DenyPrivilege(const std::string &user_or_role,
-                                     const std::vector<memgraph::query::AuthQuery::Privilege> &privileges,
-                                     system::Transaction *system_tx) {
+                                     const std::vector<memgraph::query::AuthQuery::Privilege> &privileges) {
   EditPermissions(
       user_or_role, privileges,
 #ifdef MG_ENTERPRISE
@@ -605,8 +645,7 @@ void AuthQueryHandler::DenyPrivilege(const std::string &user_or_role,
       ,
       [](auto &fine_grained_permissions, const auto &privilege_collection) {}
 #endif
-      ,
-      system_tx);
+  );
 }
 
 void AuthQueryHandler::RevokePrivilege(
@@ -618,8 +657,7 @@ void AuthQueryHandler::RevokePrivilege(
     const std::vector<std::unordered_map<memgraph::query::AuthQuery::FineGrainedPrivilege, std::vector<std::string>>>
         &edge_type_privileges
 #endif
-    ,
-    system::Transaction *system_tx) {
+) {
   EditPermissions(
       user_or_role, privileges,
 #ifdef MG_ENTERPRISE
@@ -641,8 +679,7 @@ void AuthQueryHandler::RevokePrivilege(
         }
       }
 #endif
-      ,
-      system_tx);
+  );
 }  // namespace memgraph::glue
 
 template <class TEditPermissionsFun
@@ -666,8 +703,10 @@ void AuthQueryHandler::EditPermissions(
     ,
     const TEditFineGrainedPermissionsFun &edit_fine_grained_permissions_fun
 #endif
-    ,
-    system::Transaction *system_tx) {
+) {
+  if (!std::regex_match(user_or_role, name_regex_)) {
+    throw memgraph::query::QueryRuntimeException("Invalid user or role name.");
+  }
   try {
     std::vector<memgraph::auth::Permission> permissions;
     permissions.reserve(privileges.size());
@@ -696,7 +735,7 @@ void AuthQueryHandler::EditPermissions(
         }
       }
 #endif
-      locked_auth->SaveUser(*user, system_tx);
+      locked_auth->SaveUser(*user);
     } else {
       for (const auto &permission : permissions) {
         edit_permissions_fun(role->permissions(), permission);
@@ -712,7 +751,7 @@ void AuthQueryHandler::EditPermissions(
         }
       }
 #endif
-      locked_auth->SaveRole(*role, system_tx);
+      locked_auth->SaveRole(*role);
     }
   } catch (const memgraph::auth::AuthException &e) {
     throw memgraph::query::QueryRuntimeException(e.what());

src/glue/auth_handler.hpp

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

src/glue/communication.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
@@ -73,14 +73,8 @@ storage::Result<communication::bolt::Edge> ToBoltEdge(const query::EdgeAccessor
   return ToBoltEdge(edge.impl_, db, view);
 }
 
-storage::Result<Value> ToBoltValue(const query::TypedValue &value, const storage::Storage *db, storage::View view) {
-  auto check_db = [db]() {
-    if (db == nullptr) [[unlikely]]
-      throw communication::bolt::ValueException("Database needed for TypeValue conversion.");
-  };
-
+storage::Result<Value> ToBoltValue(const query::TypedValue &value, const storage::Storage &db, storage::View view) {
   switch (value.type()) {
-    // No database needed
     case query::TypedValue::Type::Null:
       return Value();
     case query::TypedValue::Type::Bool:
@@ -91,29 +85,7 @@ storage::Result<Value> ToBoltValue(const query::TypedValue &value, const storage
       return Value(value.ValueDouble());
     case query::TypedValue::Type::String:
       return Value(std::string(value.ValueString()));
-    case query::TypedValue::Type::Date:
-      return Value(value.ValueDate());
-    case query::TypedValue::Type::LocalTime:
-      return Value(value.ValueLocalTime());
-    case query::TypedValue::Type::LocalDateTime:
-      return Value(value.ValueLocalDateTime());
-    case query::TypedValue::Type::Duration:
-      return Value(value.ValueDuration());
-
-    // Database potentially not required
-    case query::TypedValue::Type::Map: {
-      std::map<std::string, Value> map;
-      for (const auto &kv : value.ValueMap()) {
-        auto maybe_value = ToBoltValue(kv.second, db, view);
-        if (maybe_value.HasError()) return maybe_value.GetError();
-        map.emplace(kv.first, std::move(*maybe_value));
-      }
-      return Value(std::move(map));
-    }
-
-    // Database is required
     case query::TypedValue::Type::List: {
-      check_db();
       std::vector<Value> values;
       values.reserve(value.ValueList().size());
       for (const auto &v : value.ValueList()) {
@@ -123,35 +95,44 @@ storage::Result<Value> ToBoltValue(const query::TypedValue &value, const storage
       }
       return Value(std::move(values));
     }
+    case query::TypedValue::Type::Map: {
+      std::map<std::string, Value> map;
+      for (const auto &kv : value.ValueMap()) {
+        auto maybe_value = ToBoltValue(kv.second, db, view);
+        if (maybe_value.HasError()) return maybe_value.GetError();
+        map.emplace(kv.first, std::move(*maybe_value));
+      }
+      return Value(std::move(map));
+    }
     case query::TypedValue::Type::Vertex: {
-      check_db();
-      auto maybe_vertex = ToBoltVertex(value.ValueVertex(), *db, view);
+      auto maybe_vertex = ToBoltVertex(value.ValueVertex(), db, view);
       if (maybe_vertex.HasError()) return maybe_vertex.GetError();
       return Value(std::move(*maybe_vertex));
     }
     case query::TypedValue::Type::Edge: {
-      check_db();
-      auto maybe_edge = ToBoltEdge(value.ValueEdge(), *db, view);
+      auto maybe_edge = ToBoltEdge(value.ValueEdge(), db, view);
       if (maybe_edge.HasError()) return maybe_edge.GetError();
       return Value(std::move(*maybe_edge));
     }
     case query::TypedValue::Type::Path: {
-      check_db();
-      auto maybe_path = ToBoltPath(value.ValuePath(), *db, view);
+      auto maybe_path = ToBoltPath(value.ValuePath(), db, view);
       if (maybe_path.HasError()) return maybe_path.GetError();
       return Value(std::move(*maybe_path));
     }
-    case query::TypedValue::Type::Graph: {
-      check_db();
-      auto maybe_graph = ToBoltGraph(value.ValueGraph(), *db, view);
+    case query::TypedValue::Type::Date:
+      return Value(value.ValueDate());
+    case query::TypedValue::Type::LocalTime:
+      return Value(value.ValueLocalTime());
+    case query::TypedValue::Type::LocalDateTime:
+      return Value(value.ValueLocalDateTime());
+    case query::TypedValue::Type::Duration:
+      return Value(value.ValueDuration());
+    case query::TypedValue::Type::Function:
+      throw communication::bolt::ValueException("Unsupported conversion from TypedValue::Function to Value");
+    case query::TypedValue::Type::Graph:
+      auto maybe_graph = ToBoltGraph(value.ValueGraph(), db, view);
       if (maybe_graph.HasError()) return maybe_graph.GetError();
       return Value(std::move(*maybe_graph));
-    }
-
-    // Unsupported conversions
-    case query::TypedValue::Type::Function: {
-      throw communication::bolt::ValueException("Unsupported conversion from TypedValue::Function to Value");
-    }
   }
 }
 

src/glue/communication.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
@@ -65,7 +65,7 @@ storage::Result<std::map<std::string, communication::bolt::Value>> ToBoltGraph(c
 /// @param storage::View for ToBoltVertex and ToBoltEdge.
 ///
 /// @throw std::bad_alloc
-storage::Result<communication::bolt::Value> ToBoltValue(const query::TypedValue &value, const storage::Storage *db,
+storage::Result<communication::bolt::Value> ToBoltValue(const query::TypedValue &value, const storage::Storage &db,
                                                         storage::View view);
 
 query::TypedValue ToTypedValue(const communication::bolt::Value &value);

src/io/CMakeLists.txt

@@ -8,5 +8,4 @@ find_package(fmt REQUIRED)
 find_package(Threads REQUIRED)
 
 add_library(mg-io STATIC ${io_src_files})
-add_library(mg::io ALIAS mg-io)
 target_link_libraries(mg-io stdc++fs Threads::Threads fmt::fmt mg-utils)

src/io/network/endpoint.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
@@ -139,13 +139,18 @@ Endpoint::Endpoint(std::string ip_address, uint16_t port) : address(std::move(ip
 }
 
 // NOLINTNEXTLINE
-Endpoint::Endpoint(needs_resolving_t, std::string hostname, uint16_t port)
-    : address(std::move(hostname)), port(port), family{GetIpFamily(address)} {}
+Endpoint::Endpoint(needs_resolving_t, std::string hostname, uint16_t port) : port(port) {
+  address = ResolveHostnameIntoIpAddress(hostname, port);
+  IpFamily ip_family = GetIpFamily(address);
+  if (ip_family == IpFamily::NONE) {
+    throw NetworkError("Not a valid IPv4 or IPv6 address: {}", address);
+  }
+  family = ip_family;
+}
 
 std::ostream &operator<<(std::ostream &os, const Endpoint &endpoint) {
   // no need to cover the IpFamily::NONE case, as you can't even construct an
   // Endpoint object if the IpFamily is NONE (i.e. the IP address is invalid)
-  // unless you use DNS hostname
   if (endpoint.family == Endpoint::IpFamily::IP6) {
     return os << "[" << endpoint.address << "]"
               << ":" << endpoint.port;
@@ -161,12 +166,12 @@ bool Endpoint::IsResolvableAddress(const std::string &address, uint16_t port) {
   };
   addrinfo *info = nullptr;
   auto status = getaddrinfo(address.c_str(), std::to_string(port).c_str(), &hints, &info);
-  if (info) freeaddrinfo(info);
+  freeaddrinfo(info);
   return status == 0;
 }
 
 std::optional<std::pair<std::string, uint16_t>> Endpoint::ParseSocketOrAddress(
-    const std::string &address, const std::optional<uint16_t> default_port) {
+    const std::string &address, const std::optional<uint16_t> default_port = {}) {
   const std::string delimiter = ":";
   std::vector<std::string> parts = utils::Split(address, delimiter);
   if (parts.size() == 1) {
@@ -184,4 +189,34 @@ std::optional<std::pair<std::string, uint16_t>> Endpoint::ParseSocketOrAddress(
   return std::nullopt;
 }
 
+std::string Endpoint::ResolveHostnameIntoIpAddress(const std::string &address, uint16_t port) {
+  addrinfo hints{
+      .ai_flags = AI_PASSIVE,
+      .ai_family = AF_UNSPEC,     // IPv4 and IPv6
+      .ai_socktype = SOCK_STREAM  // TCP socket
+  };
+  addrinfo *info = nullptr;
+  auto status = getaddrinfo(address.c_str(), std::to_string(port).c_str(), &hints, &info);
+  if (status != 0) throw NetworkError(gai_strerror(status));
+
+  for (auto *result = info; result != nullptr; result = result->ai_next) {
+    if (result->ai_family == AF_INET) {
+      char ipstr[INET_ADDRSTRLEN];
+      auto *ipv4 = reinterpret_cast<struct sockaddr_in *>(result->ai_addr);
+      inet_ntop(AF_INET, &(ipv4->sin_addr), ipstr, sizeof(ipstr));
+      freeaddrinfo(info);
+      return ipstr;
+    }
+    if (result->ai_family == AF_INET6) {
+      char ipstr[INET6_ADDRSTRLEN];
+      auto *ipv6 = reinterpret_cast<struct sockaddr_in6 *>(result->ai_addr);
+      inet_ntop(AF_INET6, &(ipv6->sin6_addr), ipstr, sizeof(ipstr));
+      freeaddrinfo(info);
+      return ipstr;
+    }
+  }
+  freeaddrinfo(info);
+  throw NetworkError("Not a valid address: {}", address);
+}
+
 }  // namespace memgraph::io::network