Check for duplicate nodeids when loading nodes.conf (#2852)

For corrupted (human-made) or program-error-recovered nodes.conf files,
check for duplicate nodeids when loading nodes.conf. If a duplicate is
found, panic is triggered to prevent nodes from starting up
unexpectedly.

The node ID is used to identify every node across the whole cluster,
we do not expect to find duplicate nodeids in nodes.conf.

Signed-off-by: Binbin <binloveplay1314@qq.com>

.github/ISSUE_TEMPLATE/bug_report.md

@@ -2,7 +2,7 @@
 name: Bug report
 about: Help us improve by reporting a bug
 title: '[BUG]'
-labels: ''
+labels: ['bug']
 assignees: ''
 
 ---

.github/ISSUE_TEMPLATE/crash_report.yml

@@ -1,6 +1,7 @@
 name: Crash report
 description: Submit a crash report
 title: '[CRASH] <short description>'
+labels: ['bug']
 body:
   - type: markdown
     attributes:

.github/ISSUE_TEMPLATE/feature_request.md

@@ -2,7 +2,7 @@
 name: Feature request
 about: Suggest a feature
 title: '[NEW]'
-labels: ''
+labels: ['enhancement']
 assignees: ''
 
 ---

.github/ISSUE_TEMPLATE/test-failure.md

@@ -0,0 +1,24 @@
+---
+name: Test failure
+about: Report a failing or a flaky test
+title: '[TEST-FAILURE] <short description>'
+labels: ['test-failure']
+assignees: ''
+---
+
+<!--Before submitting a test failure report, please check open issues to ensure this failure has not already been reported. -->
+
+**Summary**
+
+A short description of the failure.
+
+**Failing test(s)**
+
+- Test name:
+- CI link(s):
+
+**Error stack trace**
+
+A relevant stack trace for the test failure.
+
+> **Tip:** Copy and paste the full stack trace from the CI output into your issue, as CI links may expire over time.

.github/actions/rpm-distros-tcl8/action.yml

@@ -1,31 +0,0 @@
-name: 'Install TCL8'
-description: 'Installs tcl8 and tcltls from source on Fedora-based or uses the system package on others.'
-
-inputs:
-  matrix_name:
-    description: 'The name of the matrix to check for fedora'
-    required: true
-
-runs:
-  using: "composite"
-  steps:
-    # Fedora 42 comes with Tcl 9 by default, but tcltls is currently incompatible with Tcl 9.
-    # As a workaround, we install Tcl 8 and manually build tcltls 1.7.22 from source.
-    # Once tcltls adds support for Tcl 9, this logic can be removed and system packages used instead.
-    - run: |
-        if [[ "${{ inputs.matrix_name }}" =~ "fedora" ]]; then
-          dnf -y install tcl8 tcl8-devel gcc make awk openssl openssl-devel
-          ln -s /usr/bin/tclsh8.6 /usr/bin/tclsh
-          curl -LO https://core.tcl-lang.org/tcltls/uv/tcltls-1.7.22.tar.gz
-          tar -xzf tcltls-1.7.22.tar.gz
-          pushd tcltls-1.7.22
-          ./configure --with-tcl=/usr/lib64/tcl8.6
-          make
-          mkdir -p /usr/lib64/tcl8.6/tls1.7.22
-          cp tcltls.so pkgIndex.tcl /usr/lib64/tcl8.6/tls1.7.22/
-          popd
-        else
-            dnf -y install tcl tcltls
-        fi
-        ./utils/gen-test-certs.sh
-      shell: bash

.github/benchmark_configs/benchmark-config-arm.json

@@ -0,0 +1,20 @@
+[
+  {
+    "duration": 180,
+    "keyspacelen": [3000000],
+    "data_sizes": [16,96],
+    "pipelines": [1, 10],
+    "clients": [1600],
+    "commands": [
+      "SET",
+      "GET"
+    ],
+    "cluster_mode": false,
+    "tls_mode": false,
+    "warmup": 30,
+    "io-threads": [1,9],
+    "benchmark-threads": 90,
+    "server_cpu_range": "0-8",
+    "client_cpu_range": "96-191"
+  }
+]

.github/benchmark_configs/benchmark-config-x86.json

@@ -0,0 +1,20 @@
+[
+  {
+    "duration": 180,
+    "keyspacelen": [3000000],
+    "data_sizes": [16,96],
+    "pipelines": [1, 10],
+    "clients": [1600],
+    "commands": [
+      "SET",
+      "GET"
+    ],
+    "cluster_mode": false,
+    "tls_mode": false,
+    "warmup": 30,
+    "io-threads": [1,9],
+    "benchmark-threads": 90,
+    "server_cpu_range": "0-8",
+    "client_cpu_range": "144-191,48-95"
+  }
+]

.github/workflows/auto-author-assign.yml

@@ -0,0 +1,14 @@
+name: Auto Author Assign
+
+on:
+  pull_request_target:
+    types: [opened, reopened]
+
+permissions:
+  pull-requests: write
+
+jobs:
+  assign-author:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: toshimaru/auto-author-assign@16f0022cf3d7970c106d8d1105f75a1165edb516 # v2.1.1

.github/workflows/benchmark-on-label.yml

@@ -0,0 +1,173 @@
+name: On-Demand Labeled Benchmark
+
+on:
+  pull_request_target:
+    types: [labeled]
+
+concurrency:
+  group: ec2-al-2023-pr-benchmarking-arm64
+  cancel-in-progress: false
+
+defaults:
+  run:
+    shell: "bash -Eeuo pipefail -x {0}"
+
+permissions:
+  contents: read
+  pull-requests: write
+  issues: write
+
+jobs:
+  benchmark:
+    if: |
+      github.event.action == 'labeled' && github.event.label.name == 'run-benchmark' &&
+      github.repository == 'valkey-io/valkey'
+
+    runs-on: ["self-hosted", "ec2-al-2023-pr-benchmarking-arm64"]
+    timeout-minutes: 7200
+    steps:
+      - name: Checkout valkey
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        with:
+          path: valkey
+          fetch-depth: 0
+          ref: ${{ github.event.pull_request.merge_commit_sha }}
+          persist-credentials: false
+
+      - name: Checkout valkey-perf-benchmark
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        with:
+          repository: ${{ github.repository_owner }}/valkey-perf-benchmark
+          path: valkey-perf-benchmark
+          fetch-depth: 1
+          persist-credentials: false
+
+      - name: Checkout valkey for latest benchmark.
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        with:
+          repository: valkey-io/valkey
+          ref: "unstable"
+          path: valkey_latest
+          fetch-depth: 0
+          persist-credentials: false
+
+      - name: Set up Python
+        uses: kishaningithub/setup-python-amazon-linux@63dc7bd642c6a564d0a93dd4b1cbe3e448ce3621 # v1.0.18
+        with:
+          python-version: "3.10"
+          cache: "pip"
+
+      - name: Install dependencies
+        working-directory: valkey-perf-benchmark
+        run: |
+          sudo dnf groupinstall "Development Tools" -y
+          sudo dnf install -y gcc gcc-c++ make \
+              python3-devel \
+              openssl-devel \
+              bzip2-devel \
+              libffi-devel
+          pip install -r requirements.txt
+
+      - name: Build latest valkey_latest
+        working-directory: valkey_latest
+        run: |
+          echo "Building latest valkey-benchmark for latest benchmark executable..."
+          make distclean || true
+          make -j
+          if [[ -f "src/valkey-benchmark" ]]; then
+            echo "Successfully built latest valkey-benchmark"
+            ls -la src/valkey-benchmark
+            ./src/valkey-benchmark --version || echo "Version check completed"
+          else
+            echo "Failed to build valkey-benchmark"
+            exit 1
+          fi
+          VALKEY_BENCHMARK_PATH="$(pwd)/src/valkey-benchmark"
+          echo "VALKEY_BENCHMARK_PATH=$VALKEY_BENCHMARK_PATH" >> $GITHUB_ENV
+          echo "Latest valkey-benchmark path: $VALKEY_BENCHMARK_PATH"
+
+      - name: Run benchmarks
+        working-directory: valkey-perf-benchmark
+        run: |
+          CONFIG_FILE="../valkey/.github/benchmark_configs/benchmark-config-arm.json"
+
+          # Base benchmark arguments
+          BENCHMARK_ARGS=(
+            --config "$CONFIG_FILE"
+            --commits "${{ github.event.pull_request.merge_commit_sha }}"
+            --baseline "${{ github.event.pull_request.base.ref }}"
+            --valkey-benchmark-path "$VALKEY_BENCHMARK_PATH"
+            --target-ip ${{ secrets.EC2_ARM64_IP }}
+            --valkey-path "../valkey"
+            --results-dir "results"
+            --runs 5
+          )
+
+          # Run benchmark
+          python ./benchmark.py "${BENCHMARK_ARGS[@]}"
+
+      - name: Compare results
+        working-directory: valkey-perf-benchmark
+        run: |
+          python ./utils/compare_benchmark_results.py \
+            --baseline ./results/${{ github.event.pull_request.base.ref }}/metrics.json \
+            --new ./results/${{ github.event.pull_request.merge_commit_sha }}/metrics.json \
+            --output ../comparison.md \
+            --metrics rps
+
+      - name: Upload artifacts
+        if: always()
+        continue-on-error: true
+        uses: actions/upload-artifact@6f51ac03b9356f520e9adb1b1b7802705f340c2b # v4.5.0
+        with:
+          name: benchmark-results
+          path: |
+            ./valkey-perf-benchmark/results/${{ github.event.pull_request.merge_commit_sha }}/metrics.json
+            ./valkey-perf-benchmark/results/${{ github.event.pull_request.base.ref }}/metrics.json
+            comparison.md
+
+      - name: Comment PR with results
+        uses: actions/github-script@5c56fde4671bc2d3592fb0f2c5b5bab9ddae03b1 # v7
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            const fs = require('fs');
+            const body = fs.readFileSync('comparison.md', 'utf8');
+            const {owner, repo} = context.repo;
+            const sha = '${{ github.event.pull_request.head.sha }}';
+            const short = sha.slice(0,7);
+            const link = `[\`${short}\`](https://github.com/${owner}/${repo}/commit/${sha})`
+            await github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner,
+              repo,
+              body: `**Benchmark ran on this commit:** ${link}\n\n${body}`
+            });
+
+      - name: Cleanup any running valkey processes
+        if: always()
+        continue-on-error: true
+        run: |
+          rm -rf comparison.md valkey*
+          pkill -f valkey
+          exit_code=$?
+          if [ $exit_code -eq 0 ]; then
+            echo "Killed running valkey processes"
+          elif [ $exit_code -eq 1 ]; then
+            echo "No valkey processes found to kill"
+          else
+            echo "Warning: pkill failed with exit code $exit_code"
+          fi
+
+      - name: Remove ${{ github.event.label.name }} label
+        if: always() && github.event.label.name == 'run-benchmark'
+        uses: actions/github-script@5c56fde4671bc2d3592fb0f2c5b5bab9ddae03b1 # v7
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            await github.rest.issues.removeLabel({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              name: '${{ github.event.label.name }}'
+            }).catch(err => console.log('label not present', err.message));

.github/workflows/benchmark-release.yml

@@ -0,0 +1,288 @@
+name: Compare Valkey Versions
+
+on:
+  workflow_dispatch:
+    inputs:
+      version1:
+        description: "First version to compare (commit SHA, branch, or tag)"
+        required: true
+        type: string
+      version2:
+        description: "Second version to compare (commit SHA, branch, or tag)"
+        required: true
+        type: string
+      issue_id:
+        description: "Issue ID to comment results on"
+        required: true
+        type: string
+      runs:
+        description: "Number of benchmark runs per configuration"
+        required: false
+        type: number
+        default: 1
+
+defaults:
+  run:
+    shell: "bash -Eeuo pipefail -x {0}"
+
+permissions:
+  contents: read
+  pull-requests: write
+  issues: write
+
+jobs:
+  benchmark:
+    if: github.repository == 'valkey-io/valkey'
+    strategy:
+      matrix:
+        include:
+          - arch: x86
+            machine: ec2-al-2023-pr-benchmarking-x86
+            config: benchmark-config-x86.json
+          - arch: arm64
+            machine: ec2-al-2023-pr-benchmarking-arm64
+            config: benchmark-config-arm.json
+    concurrency:
+      group: ${{ matrix.machine }}
+      cancel-in-progress: false
+    runs-on: ["self-hosted", "${{ matrix.machine }}"]
+    timeout-minutes: 7200
+    steps:
+      - name: Validate inputs
+        run: |
+          echo "Version 1: ${{ github.event.inputs.version1 }}"
+          echo "Version 2: ${{ github.event.inputs.version2 }}"
+          echo "Issue ID: ${{ github.event.inputs.issue_id }}"
+          echo "Architecture: ${{ matrix.arch }}"
+          echo "Config: ${{ matrix.config }}"
+          echo "Runs: ${{ github.event.inputs.runs }}"
+
+          # Validate issue ID is numeric
+          if ! [[ "${{ github.event.inputs.issue_id }}" =~ ^[0-9]+$ ]]; then
+            echo "Error: Issue ID must be a number"
+            exit 1
+          fi
+
+          # Validate runs is a positive number
+          if ! [[ "${{ github.event.inputs.runs }}" =~ ^[1-9][0-9]*$ ]]; then
+            echo "Error: Runs must be a positive number"
+            exit 1
+          fi
+
+      - name: Checkout valkey for latest benchmark.
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        with:
+          repository: valkey-io/valkey
+          ref: "unstable"
+          path: valkey_latest
+          fetch-depth: 0
+          persist-credentials: false
+
+      - name: Checkout valkey
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        with:
+          path: valkey
+
+      - name: Checkout valkey-perf-benchmark
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        with:
+          repository: ${{ github.repository_owner }}/valkey-perf-benchmark
+          path: valkey-perf-benchmark
+          fetch-depth: 1
+          persist-credentials: false
+
+      - name: Set up Python
+        uses: kishaningithub/setup-python-amazon-linux@63dc7bd642c6a564d0a93dd4b1cbe3e448ce3621 # v1.0.18
+        with:
+          python-version: "3.10"
+          cache: "pip"
+
+      - name: Install dependencies
+        working-directory: valkey-perf-benchmark
+        run: |
+          sudo dnf groupinstall "Development Tools" -y
+          sudo dnf install -y gcc gcc-c++ make \
+              python3-devel \
+              openssl-devel \
+              bzip2-devel \
+              libffi-devel
+          pip install -r requirements.txt
+
+      - name: Build latest valkey_latest
+        working-directory: valkey_latest
+        run: |
+          echo "Building latest valkey-benchmark for latest benchmark executable..."
+
+          # Clean any previous builds
+          make distclean || true
+
+          # Build valkey-benchmark with latest code
+          make -j$(nproc)
+
+          # Verify the binary was created
+          if [[ -f "src/valkey-benchmark" ]]; then
+            echo "✓ Successfully built latest valkey-benchmark"
+            ls -la src/valkey-benchmark
+
+            # Test the binary
+            echo "Testing valkey-benchmark binary..."
+            ./src/valkey-benchmark --version || echo "Version check completed"
+          else
+            echo "Failed to build valkey-benchmark"
+            exit 1
+          fi
+
+          # Store the absolute path for later use
+          VALKEY_BENCHMARK_PATH="$(pwd)/src/valkey-benchmark"
+          echo "VALKEY_BENCHMARK_PATH=$VALKEY_BENCHMARK_PATH" >> $GITHUB_ENV
+          echo "Latest valkey-benchmark path: $VALKEY_BENCHMARK_PATH"
+
+      - name: Run benchmarks
+        working-directory: valkey-perf-benchmark
+        env:
+          EC2_X86_IP: ${{ secrets.EC2_X86_IP }}
+          EC2_ARM64_IP: ${{ secrets.EC2_ARM64_IP }}
+        run: |
+          # Set the target IP based on the matrix architecture
+          if [[ "${{ matrix.arch }}" == "x86" ]]; then
+            TARGET_IP=$EC2_X86_IP
+            echo "Using x86 machine IP"
+          elif [[ "${{ matrix.arch }}" == "arm64" ]]; then
+            TARGET_IP=$EC2_ARM64_IP
+            echo "Using ARM64 machine IP"
+          else
+            echo "Error: Unknown architecture: ${{ matrix.arch }}"
+            exit 1
+          fi
+          CONFIG_FILE="../valkey/.github/benchmark_configs/${{ matrix.config }}"
+
+          # Verify our custom valkey-benchmark exists
+          if [[ ! -f "$VALKEY_BENCHMARK_PATH" ]]; then
+            echo "Custom valkey-benchmark not found at: $VALKEY_BENCHMARK_PATH"
+            exit 1
+          fi
+
+          echo "Using custom valkey-benchmark from: $VALKEY_BENCHMARK_PATH"
+
+          # Base benchmark arguments with custom valkey-benchmark path
+          BENCHMARK_ARGS=(
+            --config "$CONFIG_FILE"
+            --commits ${{ github.event.inputs.version1 }} ${{ github.event.inputs.version2 }}
+            --valkey-benchmark-path "$VALKEY_BENCHMARK_PATH"
+            --target-ip $TARGET_IP
+            --results-dir "results"
+            --runs ${{ github.event.inputs.runs }}
+          )
+
+          echo "Running benchmarks with the following setup:"
+          echo "- Version 1: ${{ github.event.inputs.version1 }}"
+          echo "- Version 2: ${{ github.event.inputs.version2 }}"
+          echo "- Architecture: ${{ matrix.arch }}"
+          echo "- Config: ${{ matrix.config }}"
+          echo "- Using latest valkey-benchmark: $VALKEY_BENCHMARK_PATH"
+          echo "- This ensures both versions use the same (latest) benchmark tool for consistent results"
+
+          # Run benchmark with custom valkey-benchmark executable
+          python ./benchmark.py "${BENCHMARK_ARGS[@]}"
+
+      - name: Compare results
+        working-directory: valkey-perf-benchmark
+        run: |
+          # Find the actual result directories (they might have different names than input)
+          VERSION1_DIR=$(find ./results -maxdepth 1 -type d -name "*${{ github.event.inputs.version1 }}*" | head -1)
+          VERSION2_DIR=$(find ./results -maxdepth 1 -type d -name "*${{ github.event.inputs.version2 }}*" | head -1)
+
+          if [[ -z "$VERSION1_DIR" ]]; then
+            echo "Could not find results for version1: ${{ github.event.inputs.version1 }}"
+            echo "Available result directories:"
+            ls -la ./results/
+            exit 1
+          fi
+
+          if [[ -z "$VERSION2_DIR" ]]; then
+            echo "Could not find results for version2: ${{ github.event.inputs.version2 }}"
+            echo "Available result directories:"
+            ls -la ./results/
+            exit 1
+          fi
+
+          echo "Comparing results:"
+          echo "Version 1 (${{ github.event.inputs.version1 }}): $VERSION1_DIR"
+          echo "Version 2 (${{ github.event.inputs.version2 }}): $VERSION2_DIR"
+
+          # Generate RPS-focused comparison and graphs for GitHub comments
+          python utils/compare_benchmark_results.py \
+            --baseline "$VERSION1_DIR/metrics.json" \
+            --new "$VERSION2_DIR/metrics.json" \
+            --output ../comparison.md \
+            --metrics rps
+
+      - name: Upload artifacts
+        if: always()
+        continue-on-error: true
+        uses: actions/upload-artifact@6f51ac03b9356f520e9adb1b1b7802705f340c2b # v4.5.0
+        with:
+          name: benchmark-results-${{ matrix.arch }}-${{ github.event.inputs.issue_id }}
+          path: |
+            ./valkey-perf-benchmark/results/*
+            comparison.md
+
+      - name: Cleanup any running valkey processes and files
+        if: always()
+        continue-on-error: true
+        run: |
+          pkill -f valkey || echo "No valkey processes found to kill"
+          rm -rf *
+
+  combine-results:
+    needs: benchmark
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: artifacts
+
+      - name: Combine results and create comprehensive report
+        run: |
+          echo "# Multi-Architecture Benchmark Comparison: ${{ github.event.inputs.version1 }} vs ${{ github.event.inputs.version2 }}" > combined_report.md
+          echo "" >> combined_report.md
+          echo "**Versions Compared:**" >> combined_report.md
+          echo "- Version 1: \`${{ github.event.inputs.version1 }}\`" >> combined_report.md
+          echo "- Version 2: \`${{ github.event.inputs.version2 }}\`" >> combined_report.md
+          echo "" >> combined_report.md
+          echo "**Runs:** ${{ github.event.inputs.runs }} per configuration" >> combined_report.md
+          echo "**Workflow Run:** [View Details](https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }})" >> combined_report.md
+          echo "" >> combined_report.md
+          echo "---" >> combined_report.md
+          echo "" >> combined_report.md
+
+          # Process each architecture's results
+          for arch in x86 arm64; do
+            artifact_dir="artifacts/benchmark-results-${arch}-${{ github.event.inputs.issue_id }}"
+            if [[ -d "$artifact_dir" && -f "$artifact_dir/comparison.md" ]]; then
+              echo "## ${arch^^} Architecture Results" >> combined_report.md
+              echo "" >> combined_report.md
+              cat "$artifact_dir/comparison.md" >> combined_report.md
+              echo "" >> combined_report.md
+              echo "---" >> combined_report.md
+              echo "" >> combined_report.md
+            fi
+          done
+
+      - name: Comment on issue with combined results
+        uses: actions/github-script@5c56fde4671bc2d3592fb0f2c5b5bab9ddae03b1 # v7
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            const fs = require('fs');
+
+            // Read the combined report
+            const body = fs.readFileSync('combined_report.md', 'utf8');
+
+            await github.rest.issues.createComment({
+              issue_number: ${{ github.event.inputs.issue_id }},
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: body
+            });

.github/workflows/ci.yml

@@ -28,17 +28,12 @@ jobs:
         # Fail build if there are warnings
         # build with TLS just for compilation coverage
         run: make -j4 all-with-unit-tests SERVER_CFLAGS='-Werror' BUILD_TLS=yes USE_FAST_FLOAT=yes
-      - name: install old server for compatibility testing
-        run: |
-          cd tests/tmp
-          wget https://download.valkey.io/releases/valkey-8.1.3-noble-x86_64.tar.gz
-          tar -xvf valkey-8.1.3-noble-x86_64.tar.gz
       - name: test
         run: |
           sudo apt-get install tcl8.6 tclx
-          ./runtest --verbose --tags -slow --dump-logs --other-server-path tests/tmp/valkey-8.1.3-noble-x86_64/bin/valkey-server
+          ./runtest --verbose --tags -slow --dump-logs
       - name: module api test
-        run: CFLAGS='-Werror' ./runtest-moduleapi --verbose --dump-logs --other-server-path tests/tmp/valkey-8.1.3-noble-x86_64/bin/valkey-server
+        run: CFLAGS='-Werror' ./runtest-moduleapi --verbose --dump-logs
       - name: validate commands.def up to date
         run: |
           touch src/commands/ping.json
@@ -49,6 +44,40 @@ jobs:
         run: |
           ./src/valkey-unit-tests
 
+  test-ubuntu-latest-compatibility:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        server:
+          - {version: "7.2.11", file: "valkey-7.2.11-noble-x86_64.tar.gz"}
+          - {version: "8.0.6", file: "valkey-8.0.6-noble-x86_64.tar.gz"}
+          - {version: "8.1.4", file: "valkey-8.1.4-noble-x86_64.tar.gz"}
+    steps:
+      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      - name: make
+        # Fail build if there are warnings
+        # build with TLS just for compilation coverage
+        run: make -j4 all-with-unit-tests SERVER_CFLAGS='-Werror' BUILD_TLS=yes USE_FAST_FLOAT=yes
+
+      - name: Install old server (${{ matrix.server.version }}) for compatibility testing
+        run: |
+          mkdir -p tests/tmp
+          cd tests/tmp
+          wget https://download.valkey.io/releases/${{ matrix.server.file }}
+          tar -xvf ${{ matrix.server.file }}
+
+      - name: Run compatibility tests against ${{ matrix.server.version }}
+        run: |
+          sudo apt-get install -y tcl8.6 tclx
+          ./runtest --verbose --tags "-slow needs:other-server" --dump-logs \
+            --other-server-path tests/tmp/valkey-${{ matrix.server.version }}-noble-x86_64/bin/valkey-server
+
+      - name: Module API tests against ${{ matrix.server.version }}
+        run: |
+          CFLAGS='-Werror' ./runtest-moduleapi --tags needs:other-server --verbose --dump-logs \
+            --other-server-path tests/tmp/valkey-${{ matrix.server.version }}-noble-x86_64/bin/valkey-server
+
   test-ubuntu-latest-cmake:
     runs-on: ubuntu-latest
     steps:

.github/workflows/codeql-analysis.yml

@@ -1,7 +1,16 @@
 name: "CodeQL"
 
 on:
+  push:
+    paths-ignore:
+      - '**/*.md'
+      - '**/00-RELEASENOTES'
+      - '**/COPYING'
   pull_request:
+    paths-ignore:
+      - '**/*.md'
+      - '**/00-RELEASENOTES'
+      - '**/COPYING'
   schedule:
     # run weekly new vulnerability was added to the database
     - cron: '0 3 * * 0'

.github/workflows/daily.yml

@@ -947,12 +947,10 @@ jobs:
         run: dnf -y install epel-release
       - name: make
         run: |
-          dnf -y install gcc make procps-ng openssl-devel openssl which /usr/bin/kill /usr/bin/awk
+          dnf -y install gcc make procps-ng which /usr/bin/kill /usr/bin/awk
           make -j SERVER_CFLAGS='-Werror'
       - name: testprep
-        uses: ./.github/actions/rpm-distros-tcl8
-        with:
-          matrix_name: ${{ matrix.name }}
+        run: dnf -y install tcl tcltls
       - name: test
         if: true && !contains(github.event.inputs.skiptests, 'valkey')
         run: ./runtest ${{ github.event_name != 'pull_request' && '--accurate' || '' }} --verbose --dump-logs ${{github.event.inputs.test_args}}
@@ -1018,9 +1016,9 @@ jobs:
           dnf -y install make gcc openssl-devel openssl procps-ng which /usr/bin/kill /usr/bin/awk
           make -j BUILD_TLS=module SERVER_CFLAGS='-Werror'
       - name: testprep
-        uses: ./.github/actions/rpm-distros-tcl8
-        with:
-          matrix_name: ${{ matrix.name }}
+        run: |
+          dnf -y install tcl tcltls
+          ./utils/gen-test-certs.sh
       - name: test
         if: true && !contains(github.event.inputs.skiptests, 'valkey')
         run: |
@@ -1090,9 +1088,9 @@ jobs:
           dnf -y install make gcc openssl-devel openssl procps-ng which /usr/bin/kill /usr/bin/awk
           make -j BUILD_TLS=module SERVER_CFLAGS='-Werror'
       - name: testprep
-        uses: ./.github/actions/rpm-distros-tcl8
-        with:
-          matrix_name: ${{ matrix.name }}
+        run: |
+          dnf -y install tcl tcltls
+          ./utils/gen-test-certs.sh
       - name: test
         if: true && !contains(github.event.inputs.skiptests, 'valkey')
         run: |
@@ -1201,7 +1199,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [macos-13, macos-14]
+        os: [macos-14]
     runs-on: ${{ matrix.os }}
     if: |
       (github.event_name == 'workflow_dispatch' ||
@@ -1230,7 +1228,7 @@ jobs:
         run: make SERVER_CFLAGS='-Werror'
 
   test-freebsd:
-    runs-on: macos-13
+    runs-on: ubuntu-latest
     if: |
       (github.event_name == 'workflow_dispatch' ||
         (github.event_name == 'schedule' && github.repository == 'valkey-io/valkey') ||
@@ -1248,14 +1246,14 @@ jobs:
           repository: ${{ env.GITHUB_REPOSITORY }}
           ref: ${{ env.GITHUB_HEAD_REF }}
       - name: test
-        uses: cross-platform-actions/action@5800fa0060a22edf69992a779adac3d2bb3a6f8a # v0.22.0
+        uses: cross-platform-actions/action@46e8d7fb25520a8d6c64fd2b7a1192611da98eda # v0.30.0
         with:
           operating_system: freebsd
           environment_variables: MAKE
           version: 13.2
           shell: bash
           run: |
-            sudo pkg install -y bash gmake lang/tcl86 lang/tclx
+            sudo pkg install -y bash gmake lang/tcl86 lang/tclX
             gmake
             ./runtest --single unit/keyspace --single unit/auth --single unit/networking --single unit/protocol
 

CMakeLists.txt

@@ -43,3 +43,34 @@ unset(BUILD_TEST_MODULES CACHE)
 unset(BUILD_EXAMPLE_MODULES CACHE)
 unset(USE_TLS CACHE)
 unset(DEBUG_FORCE_DEFRAG CACHE)
+
+# Helper to copy runtest scripts to allow running tests with CMake built binaries
+function(copy_runtest_script script_name)
+    set(src "${CMAKE_SOURCE_DIR}/${script_name}")
+    set(dst "${CMAKE_BINARY_DIR}/${script_name}")
+    file(READ "${src}" contents)
+
+    # Split at the first newline (after shebang #!/bin/sh)
+    string(FIND "${contents}" "\n" index_of_first_newline_char)
+    math(EXPR first_index_script_body "${index_of_first_newline_char} + 1")
+
+    string(SUBSTRING "${contents}" 0 ${first_index_script_body} shebang_line)
+    string(SUBSTRING "${contents}" ${first_index_script_body} -1 script_body)
+
+    # Insert our environment variable lines
+    set(insert_content
+"# Most tests assume running from the project root
+cd ${CMAKE_SOURCE_DIR}
+export VALKEY_BIN_DIR=\"${CMAKE_BINARY_DIR}/bin\"
+")
+    # Reconstruct the full script
+    set(new_contents "${shebang_line}${insert_content}${script_body}")
+    file(WRITE "${dst}" "${new_contents}")
+    file(CHMOD "${dst}" PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
+endfunction()
+
+copy_runtest_script("runtest")
+copy_runtest_script("runtest-cluster")
+copy_runtest_script("runtest-moduleapi")
+copy_runtest_script("runtest-rdma")
+copy_runtest_script("runtest-sentinel")

CONTRIBUTING.md

@@ -16,6 +16,7 @@ The Valkey project is led by a Technical Steering Committee, whose responsibilit
 * Found a bug? [Report it here](https://github.com/valkey-io/valkey/issues/new?template=bug_report.md&title=%5BBUG%5D)
 * Valkey crashed? [Submit a crash report here](https://github.com/valkey-io/valkey/issues/new?template=crash_report.md&title=%5BCRASH%5D+%3Cshort+description%3E)
 * Suggest a new feature? [Post your detailed feature request here](https://github.com/valkey-io/valkey/issues/new?template=feature_request.md&title=%5BNEW%5D)
+* Report a test failure? [Report it here](https://github.com/valkey-io/valkey/issues/new?template=test-failure.md)
 * Want to help with documentation? [Move on to valkey-doc](https://github.com/valkey-io/valkey-doc)
 * Report a vulnerability? See [SECURITY.md](SECURITY.md)
 

GOVERNANCE.md

@@ -4,7 +4,7 @@ The Valkey project is managed by a Technical Steering Committee (TSC) composed o
 The Valkey project includes all of the current and future repositories under the Valkey-io organization.
 Committers are defined as individuals with write access to the code within a repository.
 Maintainers are defined as individuals with full access to a repository and own its governance.
-Both maintainers and committers should be clearly listed in the MAINTAINERS.md file in a given projects repository.
+Both maintainers and committers shall be clearly listed in the MAINTAINERS.md file in a given project's repository.
 Maintainers of other repositories within the Valkey project are not members of the TSC unless explicitly added.
 
 ## Technical Steering Committee
@@ -12,10 +12,15 @@ Maintainers of other repositories within the Valkey project are not members of t
 The TSC is responsible for oversight of all technical, project, approval, and policy matters for Valkey.
 
 The TSC members are listed in the [MAINTAINERS.md](MAINTAINERS.md) file in the Valkey repository.
-Maintainers (and accordingly, TSC members) may be added or removed by no less than 2/3 affirmative vote of the current TSC.
+
+At any time, no more than one third (1/3) of the TSC members may be employees, contractors, or representatives of the same organization or affiliated organizations.
+For the purposes of this document, “organization” includes companies, corporations, universities, research institutes, non-profits, governmental institutions, and any of their subsidiaries or affiliates.
+If, at any time, the 1/3 organization limit is exceeded (for example, due to changes in employment, company acquisitions, or organizational affiliations), the TSC shall be notified as soon as possible.
+The TSC must promptly take action to restore compliance, which may include removing or reassigning members in accordance with the procedures outlined in the [Termination of Membership](#termination-of-membership) section.
+The TSC shall strive to resolve the situation within 30 days of notification, and document the steps taken to restore compliance.
+
 The TSC shall appoint a Chair responsible for organizing TSC meetings.
 If the TSC Chair is removed from the TSC (or the Chair steps down from that role), it is the responsibility of the TSC to appoint a new Chair.
-The TSC can amend this governance document by no less than a 2/3 affirmative vote.
 
 The TSC may, at its discretion, add or remove members who are not maintainers of the main Valkey repository.
 The TSC may, at its discretion, add or remove maintainers from other repositories within the Valkey project.
@@ -29,16 +34,33 @@ The TSC shall document evidence of consensus in accordance with these requiremen
 If consensus cannot be reached, the TSC shall make the decision by a vote.
 
 A vote shall also be called when an issue or pull request is marked as a major decision, which are decisions that have a significant impact on the Valkey architecture or design.
-Examples of major decisions:
-    * Fundamental changes to the Valkey core datastructures
-    * Adding a new data structure or API
-    * Changes that affect backward compatibility
-    * New user visible fields that need to be maintained
-    * Modifications to the TSC or other governance documents
-    * Adding members to other roles within the Valkey project
-    * Delegation of maintainership for projects to other groups or individuals
-    * Adding or removing a new external library such as a client
-    or module to the project.
+
+### Technical Major Decisions
+
+Technical major decisions include:
+* Fundamental changes to the Valkey core datastructures
+* Adding a new data structure or API
+* Changes that affect backward compatibility
+* New user visible fields that need to be maintained
+* Adding or removing a new external library such as a client or module to the project when it affects runtime behavior
+
+Technical major decisions shall be approved by a simple majority vote whenever one can be obtained.
+If a simple majority cannot be reached within a two-week voting period, and no TSC member has voted against, the decision may instead be approved through explicit “+2” support from at least two TSC members, recorded on the relevant issue or pull request.
+If the pull request author or issue proposer is a TSC member, their +1 counts toward the +2.
+If any TSC member casts a negative vote, the decision must follow the simple majority voting process and cannot be approved through +2.
+Once a technical major decision has been approved through the +2 mechanism, any subsequent concerns shall be raised through a new major decision process; +2 approvals are not retracted directly.
+
+### Governance Major Decisions
+
+Governance major decisions include:
+* Adding TSC members or involuntary removal of TSC members
+* Modifying this governance document
+* Delegation of maintainership for projects or governance authority
+* Creating, modifying, or removing roles within the Valkey project
+* Any change that alters voting rules, TSC responsibilities, or project oversight
+* Structural changes to the TSC, including composition limits
+
+Governance major decisions shall require approval by a super-majority vote of at least two thirds (2/3) of the entire TSC.
 
 Any member of the TSC can call a vote with reasonable notice to the TSC, setting out a discussion period and a separate voting period.
 Any discussion may be conducted in person or electronically by text, voice, or video.
@@ -46,23 +68,24 @@ The discussion shall be open to the public, with the notable exception of discus
 In any vote, each voting TSC member will have one vote.
 The TSC shall give at least two weeks for all members to submit their vote.
 Except as specifically noted elsewhere in this document, decisions by vote require a simple majority vote of all voting members.
-It is the responsibility of the TSC chair to help facilitate the voting process as needed to make sure it completes within the voting period.
+If a vote results in a tie, the status quo is preserved.
+It is the responsibility of the TSC Chair to help facilitate the voting process as needed to make sure it completes within the voting period.
 
 ## Termination of Membership
 
 A maintainer's access (and accordingly, their position on the TSC) will be removed if any of the following occur:
 
+* Involuntary Removal: Removal via the [Governance Major Decision](#governance-major-decisions) voting process.
 * Resignation: Written notice of resignation to the TSC.
-* TSC Vote: 2/3 affirmative vote of the TSC to remove a member
 * Unreachable Member: If a member is unresponsive for more than six months, the remaining active members of the TSC may vote to remove the unreachable member by a simple majority.
 
 ## Technical direction for other Valkey projects
 
 The TSC may delegate decision making for other projects within the Valkey organization to the maintainers responsible for those projects.
-Delegation of decision making for a project is considered a major decision, and shall happen with an explicit vote.
+Delegation of decision making for a project is considered a [Governance Major Decision](#governance-major-decisions).
 Projects within the Valkey organization must indicate the individuals with commit permissions by updating the MAINTAINERS.md within their repositories.
 
-The TSC may, at its discretion, overrule the decisions made by other projects within the Valkey organization, although they should show restraint in doing so.
+The TSC may, at its discretion, overrule the decisions made by other projects within the Valkey organization, although they shall show restraint in doing so.
 
 ## License of this document
 

MAINTAINERS.md

@@ -3,30 +3,36 @@
 This document contains a list of maintainers in this repo.
 See [GOVERNANCE.md](GOVERNANCE.md) that explains the function of this file.
 
+## Committee Chair
+
+- **Madelyn Olson**
+  Term: March 28, 2024 – Present
+
 ## Current Maintainers
 
 Maintainers listed in alphabetical order by their github ID.
 
-| Maintainer          | GitHub ID                                       | Affiliation |
-| ------------------- | ----------------------------------------------- | ----------- |
-| Zhu Binbin          | [enjoy-binbin](https://github.com/enjoy-binbin) | Tencent     |
-| Wen Hui             | [hwware](https://github.com/hwware)             | Huawei      |
-| Madelyn Olson       | [madolson](https://github.com/madolson)         | Amazon      |
-| Ping Xie            | [pingxie](https://github.com/pingxie)           | Google      |
-| Zhao Zhao           | [soloestoy](https://github.com/soloestoy)       | Alibaba     |
-| Viktor Söderqvist   | [zuiderkwast](https://github.com/zuiderkwast)   | Ericsson    |
+| Maintainer          | GitHub ID     | Affiliation |
+| ------------------- | ------------- | ----------- |
+| Binbin Zhu          | @enjoy-binbin | Tencent     |
+| Harkrishn Patro     | @hpatro       | Amazon      |
+| Lucas Yang          | @lucasyonge   | -           |
+| Madelyn Olson       | @madolson     | Amazon      |
+| Jacob Murphy        | @murphyjacob4 | Google      |
+| Ping Xie            | @pingxie      | Oracle      |
+| Ran Shidlansik      | @ranshid      | Amazon      |
+| Zhao Zhao           | @soloestoy    | Alibaba     |
+| Viktor Söderqvist   | @zuiderkwast  | Ericsson    |
 
 ## Current Committers
 
 Committers listed in alphabetical order by their github ID.
 
-| Committer           | GitHub ID                                       | Affiliation |
-| ------------------- | ----------------------------------------------- | ----------- |
-| Harkrishn Patro     | [hpatro](https://github.com/hpatro)             | Amazon      |
-| Ran Shidlansik      | [ranshid](https://github.com/ranshid)           | Amazon      |
-| Ricardo Dias        | [rjd15372](https://github.com/rjd15372)         | Percona     |
+| Committer           | GitHub ID     | Affiliation |
+| ------------------- | ------------- | ----------- |
+| Ricardo Dias        | @rjd15372     | Percona     |
 
-### Former Maintainers and Committers 
+## Former Maintainers and Committers 
 
-| Maintainer          | GitHub ID                                       | Affiliation |
-| ------------------- | ----------------------------------------------- | ----------- |
+| Name                | GitHub ID     | Role | Term | Affiliation |
+| ------------------- | ------------- | ---- | ---- | ----------- |

README.md

@@ -52,6 +52,13 @@ as libsystemd-dev on Debian/Ubuntu or systemd-devel on CentOS) and run:
 
     % make USE_SYSTEMD=yes
 
+Since Valkey version 8.1, `fast_float` has been introduced as an optional 
+dependency, which can speed up sorted sets and other commands that use 
+the double datatype. To build with `fast_float` support, you'll need a 
+C++ compiler and run:
+
+    % make USE_FAST_FLOAT=yes
+
 To append a suffix to Valkey program names, use:
 
     % make PROG_SUFFIX="-alt"
@@ -167,7 +174,8 @@ line, with exactly the same name.
 
 ## Running manually
 
-To manually run a Valkey server with TLS mode (assuming `./gen-test-certs.sh` was invoked so sample certificates/keys are available):
+To manually run a Valkey server with TLS mode (assuming `./utils/gen-test-certs.sh`
+was invoked so sample certificates/keys are available):
 
 * TLS built-in mode:
     ```
@@ -369,4 +377,4 @@ Wilmington, Delaware 19802-4447
 
 [1]: https://github.com/valkey-io/valkey/blob/unstable/COPYING
 [2]: https://github.com/valkey-io/valkey/blob/unstable/CONTRIBUTING.md
-[3]: https://github.com/valkey-io/valkey/blob/unstable/SECURITY.md
+[3]: https://github.com/valkey-io/valkey/blob/unstable/SECURITY.md

cmake/Modules/SourceFiles.cmake

@@ -72,6 +72,7 @@ set(VALKEY_SERVER_SRCS
     ${CMAKE_SOURCE_DIR}/src/geo.c
     ${CMAKE_SOURCE_DIR}/src/lazyfree.c
     ${CMAKE_SOURCE_DIR}/src/module.c
+    ${CMAKE_SOURCE_DIR}/src/lrulfu.c
     ${CMAKE_SOURCE_DIR}/src/evict.c
     ${CMAKE_SOURCE_DIR}/src/expire.c
     ${CMAKE_SOURCE_DIR}/src/geohash.c
@@ -87,6 +88,7 @@ set(VALKEY_SERVER_SRCS
     ${CMAKE_SOURCE_DIR}/src/lolwut.c
     ${CMAKE_SOURCE_DIR}/src/lolwut5.c
     ${CMAKE_SOURCE_DIR}/src/lolwut6.c
+    ${CMAKE_SOURCE_DIR}/src/lolwut9.c
     ${CMAKE_SOURCE_DIR}/src/acl.c
     ${CMAKE_SOURCE_DIR}/src/tracking.c
     ${CMAKE_SOURCE_DIR}/src/socket.c

cmake/Modules/ValkeySetup.cmake

@@ -50,13 +50,13 @@ endif ()
 
 # Helper function for creating symbolic link so that: link -> source
 macro (valkey_create_symlink source link)
-    install(
-        CODE "execute_process(                      \
-    COMMAND /bin/bash ${CMAKE_BINARY_DIR}/CreateSymlink.sh \
-    ${source} \
-    ${link}   \
-    )"
-        COMPONENT "valkey")
+  add_custom_command(
+    TARGET ${source} POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E create_symlink
+            "$<TARGET_FILE_NAME:${source}>"
+            "$<TARGET_FILE_DIR:${source}>/${link}"
+    VERBATIM
+  )
 endmacro ()
 
 # Install a binary
@@ -91,11 +91,7 @@ macro (valkey_build_and_install_bin target sources ld_flags libs link_name)
 
     if (USE_RDMA)
         # Add required libraries needed for RDMA
-        # Bug in libvalkey 0.1.0: The order is important and we need to link
-        # valkey::valkey after valkey::valkey_rdma. This will be fixed upstream.
-        # TODO: Next time we lift libvalkey, remove valkey::valkey from
-        # the next line.
-        target_link_libraries(${target} valkey::valkey_rdma valkey::valkey)
+        target_link_libraries(${target} valkey::valkey_rdma)
     endif ()
 
     if (IS_FREEBSD)

deps/libvalkey/.github/wordlist.txt

@@ -7,7 +7,7 @@ antirez
 api
 APIs
 ASYNC
-asyncronous
+asynchronous
 atomicity
 AUTOFREE
 autoload

deps/libvalkey/.github/workflows/build.yml

@@ -8,7 +8,7 @@ jobs:
     runs-on: ubuntu-latest
     container: almalinux:8
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - name: Install dependencies
         run: |
@@ -35,7 +35,7 @@ jobs:
     runs-on: ubuntu-latest
     container: rockylinux:8
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - name: Install dependencies
         run: |
@@ -64,10 +64,10 @@ jobs:
     runs-on: ubuntu-latest
     name:  FreeBSD
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - name: Build in FreeBSD
-        uses: vmactions/freebsd-vm@c3ae29a132c8ef1924775414107a97cac042aad5 # v1.2.0
+        uses: vmactions/freebsd-vm@05856381fab64eeee9b038a0818f6cec649ca17a # v1.2.3
         with:
           prepare: pkg install -y gmake cmake
           run: |
@@ -94,9 +94,9 @@ jobs:
           - {target: mipsel,   host: mipsel-linux-gnu,        qemu: mipsel,   gccver: 10 }
           - {target: mips64el, host: mips64el-linux-gnuabi64, qemu: mips64el, gccver: 10 }
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
       - name: Prepare
-        uses: awalsh128/cache-apt-pkgs-action@7ca5f46d061ad9aa95863cd9b214dd48edef361d # v1.5.0
+        uses: awalsh128/cache-apt-pkgs-action@2c09a5e66da6c8016428a2172bd76e5e4f14bb17 # v1.5.3
         with:
           packages: gcc-${{ matrix.config.gccver }}-${{ matrix.config.host }}
           version: ${{ matrix.config.target }}-1.0

deps/libvalkey/.github/workflows/ci.yml

@@ -10,51 +10,53 @@ jobs:
     name: Run static checkers
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+    - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
     - name: Run clang-format style check (.c and .h)
       uses: jidicula/clang-format-action@4726374d1aa3c6aecf132e5197e498979588ebc8 # v4.15.0
       with:
         clang-format-version: '18'
 
   ubuntu-cmake:
-    name: Build with CMake [${{ matrix.cmake-build-type }}, ${{ matrix.compiler }}, cmake-${{ matrix.cmake-version }}, sanitizer="${{ matrix.sanitizer }}"]
+    name: Build with CMake ${{ matrix.sanitizer && format('and {0}-sanitizer', matrix.sanitizer ) }} [${{ matrix.compiler }}, cmake-${{ matrix.cmake-version }}, ${{ matrix.cmake-build-type }}]
     runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
       matrix:
+        include:
+          # New compilers
+          - compiler: 'clang-20'
+            cmake-version: '4.0'
+            cmake-build-type: Release
+          - compiler: 'gcc-14'
+            cmake-version: '4.0'
+            cmake-build-type: Release
+          # Old compilers
+          - compiler: 'clang-14'
+            cmake-version: '3.13'
+            cmake-build-type: Release
+          - compiler: 'gcc-9'
+            cmake-version: '3.13'
+            cmake-build-type: Release
+        # Sanitizers enabled
         compiler: ['gcc-14', 'clang-20']
         cmake-version: ['4.0']
-        cmake-build-type: [Release]
-        sanitizer: ["", thread, undefined, leak, address]
-        include:
-          - compiler: clang-18
-            cmake-version: 3.29
-            cmake-build-type: Debug
-          - compiler: gcc-9
-            cmake-version: 3.13
-            cmake-build-type: Release
-          - compiler: clang-14
-            cmake-version: 3.13
-            cmake-build-type: Release
+        cmake-build-type: [RelWithDebInfo]
+        sanitizer: [thread, undefined, leak, address]
     steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+    - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
     - name: Prepare
-      uses: awalsh128/cache-apt-pkgs-action@7ca5f46d061ad9aa95863cd9b214dd48edef361d # v1.5.0
+      uses: awalsh128/cache-apt-pkgs-action@2c09a5e66da6c8016428a2172bd76e5e4f14bb17 # v1.5.3
       with:
-        packages: libevent-dev libuv1-dev libev-dev libglib2.0-dev
+        packages: libevent-dev libuv1-dev libev-dev libglib2.0-dev valkey-server
         version: 1.0
     - name: Setup compiler
-      uses: aminya/setup-cpp@6370aaa0252a93c71dcc4cf49397f46810eeda56 # v1.5.3
+      uses: aminya/setup-cpp@a276e6e3d1db9160db5edc458e99a30d3b109949 # v1.7.1
       with:
         compiler: ${{ matrix.compiler }}
     - name: Setup CMake
       uses: jwlawson/actions-setup-cmake@802fa1a2c4e212495c05bf94dba2704a92a472be # v2.0.2
       with:
         cmake-version: ${{ matrix.cmake-version }}
-    - name: Install Valkey for non-cluster tests
-      run: |
-        sudo apt update
-        sudo apt install valkey
     - name: Generate makefiles
       run: |
         if [ -n "${{ matrix.sanitizer }}" ]; then
@@ -82,16 +84,12 @@ jobs:
     name: Build with make
     runs-on: ubuntu-24.04
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
       - name: Prepare
-        uses: awalsh128/cache-apt-pkgs-action@7ca5f46d061ad9aa95863cd9b214dd48edef361d # v1.5.0
+        uses: awalsh128/cache-apt-pkgs-action@2c09a5e66da6c8016428a2172bd76e5e4f14bb17 # v1.5.3
         with:
-          packages: libevent-dev valgrind
+          packages: libevent-dev valgrind valkey-server
           version: 1.0
-      - name: Install Valkey
-        run: |
-          sudo apt update
-          sudo apt install valkey
       - name: Build
         run: USE_TLS=1 TEST_ASYNC=1 make
       - name: Run tests
@@ -112,16 +110,12 @@ jobs:
     name: Build for 32-bit
     runs-on: ubuntu-24.04
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
       - name: Prepare
-        uses: awalsh128/cache-apt-pkgs-action@7ca5f46d061ad9aa95863cd9b214dd48edef361d # v1.5.0
+        uses: awalsh128/cache-apt-pkgs-action@2c09a5e66da6c8016428a2172bd76e5e4f14bb17 # v1.5.3
         with:
-          packages: gcc-multilib
+          packages: gcc-multilib valkey-server
           version: 1.0
-      - name: Install Valkey
-        run: |
-          sudo apt update
-          sudo apt install valkey
       - name: Build
         run: |
           make 32bit
@@ -134,43 +128,55 @@ jobs:
     name: Installation tests
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+    - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
     - name: Prepare
-      uses: awalsh128/cache-apt-pkgs-action@7ca5f46d061ad9aa95863cd9b214dd48edef361d # v1.5.0
+      uses: awalsh128/cache-apt-pkgs-action@2c09a5e66da6c8016428a2172bd76e5e4f14bb17 # v1.5.3
       with:
         packages: libevent-dev libuv1-dev libev-dev libglib2.0-dev
         version: 1.0
-    - name: Install libvalkey using Makefile
+    - name: Install static and dynamic libraries using Makefile
       run: |
         make USE_TLS=1 DESTDIR=${{ github.workspace }}/make-install install
-    - name: Install libvalkey using CMake
+    - name: Install dynamic libraries using CMake
       run: |
-        mkdir build && cd build
+        mkdir build-dyn && cd build-dyn
         cmake -DDISABLE_TESTS=ON -DENABLE_TLS=ON ..
-        make DESTDIR=${{ github.workspace }}/cmake-install install
+        make DESTDIR=${{ github.workspace }}/dynamic-cmake-install install
+    - name: Install static libraries using CMake
+      run: |
+        mkdir build-static && cd build-static
+        cmake -DDISABLE_TESTS=ON -DENABLE_TLS=ON -DBUILD_SHARED_LIBS=OFF ..
+        make DESTDIR=${{ github.workspace }}/static-cmake-install install
     - name: Build examples with Makefile using a Makefile-installed libvalkey
       run: |
-        make CFLAGS="-I${{ github.workspace }}/make-install/usr/local/include" \
-             STLIBNAME="${{ github.workspace }}/make-install/usr/local/lib/libvalkey.a" \
+        make STLIBNAME="${{ github.workspace }}/make-install/usr/local/lib/libvalkey.a" \
+             TLS_STLIBNAME="${{ github.workspace }}/make-install/usr/local/lib/libvalkey_tls.a" \
+             INCLUDE_DIR="${{ github.workspace }}/make-install/usr/local/include" \
              USE_TLS=1 -C examples
     - name: Build examples with Makefile using a CMake-installed libvalkey
       run: |
-        make CFLAGS="-I${{ github.workspace }}/cmake-install/usr/local/include" \
-             STLIBNAME="${{ github.workspace }}/cmake-install/usr/local/lib/libvalkey.a" \
+        make STLIBNAME="${{ github.workspace }}/static-cmake-install/usr/local/lib/libvalkey.a" \
+             TLS_STLIBNAME="${{ github.workspace }}/static-cmake-install/usr/local/lib/libvalkey_tls.a" \
+             INCLUDE_DIR="${{ github.workspace }}/static-cmake-install/usr/local/include" \
              USE_TLS=1 -C examples
-    - name: Build examples with CMake using a CMake-installed libvalkey
+    - name: Build examples with CMake using CMake-installed dynamic libraries
       run: |
-        cd examples && mkdir build && cd build
-        cmake -DCMAKE_PREFIX_PATH=${{ github.workspace }}/cmake-install/usr/local -DENABLE_TLS=ON ..
+        cd examples && mkdir build-dyn && cd build-dyn
+        cmake -DCMAKE_PREFIX_PATH=${{ github.workspace }}/dynamic-cmake-install/usr/local -DENABLE_TLS=ON ..
+        make
+    - name: Build examples with CMake using CMake-installed static libraries
+      run: |
+        cd examples && mkdir build-static && cd build-static
+        cmake -DCMAKE_PREFIX_PATH=${{ github.workspace }}/static-cmake-install/usr/local -DENABLE_TLS=ON ..
         make
 
   rdma:
     name: RDMA support enabled
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
       - name: Prepare
-        uses: awalsh128/cache-apt-pkgs-action@7ca5f46d061ad9aa95863cd9b214dd48edef361d # v1.5.0
+        uses: awalsh128/cache-apt-pkgs-action@2c09a5e66da6c8016428a2172bd76e5e4f14bb17 # v1.5.3
         with:
           packages: librdmacm-dev libibverbs-dev
           version: 1.0
@@ -192,7 +198,7 @@ jobs:
     name: CMake 3.7.0 (min. required)
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
       - name: Setup CMake
         uses: jwlawson/actions-setup-cmake@802fa1a2c4e212495c05bf94dba2704a92a472be # v2.0.2
         with:
@@ -207,16 +213,16 @@ jobs:
     name: macOS
     runs-on: macos-latest
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
       - name: Install dependencies
         run: |
           brew update
           brew install valkey
-      - name: Build using CMake
+      - name: Build and install using CMake
         run: |
           mkdir build && cd build
           cmake .. -G Ninja -DCMAKE_BUILD_TYPE=Release -DENABLE_TLS=ON
-          ninja -v
+          sudo ninja -v install
       - name: Build using Makefile
         run: USE_TLS=1 make
       - name: Run tests
@@ -229,21 +235,25 @@ jobs:
     name: Windows
     runs-on: windows-latest
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
       - uses: ilammy/msvc-dev-cmd@0b201ec74fa43914dc39ae48a89fd1d8cb592756 # v1.13.0
-      - name: Install dependencies
+      - name: Remove installed OpenSSL 1.1.1 (has reached End of Life)
+        shell: bash
+        run: rm -rf 'C:/Program Files/OpenSSL/'
+      - name: Install dependencies (choco)
         run: |
           choco install -y memurai-developer
-          # Workaround for libevent that specify minimum CMake version 3.1 (incompatible with CMake >= 4.0).
-          sed -i '2i if(CMAKE_VERSION VERSION_GREATER_EQUAL "4.0")' ${env:VCPKG_INSTALLATION_ROOT}/scripts/ports.cmake
-          sed -i '3i   set(ENV{CMAKE_POLICY_VERSION_MINIMUM} 3.5)'  ${env:VCPKG_INSTALLATION_ROOT}/scripts/ports.cmake
-          sed -i '4i endif()'                                       ${env:VCPKG_INSTALLATION_ROOT}/scripts/ports.cmake
-          vcpkg install --triplet x64-windows pkgconf libevent
-      - name: Build
+      - name: Install dependencies (vcpkg)
+        uses: johnwason/vcpkg-action@caa1c94fbb94d8b023a0cc93edf10cd3791349a7 # v7.0.1
+        with:
+          pkgs: pkgconf libevent openssl
+          triplet: x64-windows
+          token: ${{ github.token }}
+      - name: Build and install
         run: |
           mkdir build && cd build
-          cmake .. -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_TOOLCHAIN_FILE=C:\vcpkg\scripts\buildsystems\vcpkg.cmake
-          ninja -v
+          cmake .. -G Ninja -DENABLE_TLS=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_TOOLCHAIN_FILE=${{ github.workspace }}\vcpkg\scripts\buildsystems\vcpkg.cmake
+          ninja -v install
       - name: Run tests
         working-directory: build
         run: .\tests\client_test.exe
@@ -256,9 +266,9 @@ jobs:
         run: |
           git config --global core.autocrlf input
           choco install -y memurai-developer
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
       - name: Install Cygwin
-        uses: cygwin/cygwin-install-action@f61179d72284ceddc397ed07ddb444d82bf9e559 # v5
+        uses: cygwin/cygwin-install-action@f2009323764960f80959895c7bc3bb30210afe4d # v6
         with:
           packages: make gcc-core cmake libssl-devel
       - name: Build with CMake using Cygwin
@@ -274,9 +284,9 @@ jobs:
     name: Windows (MinGW64)
     runs-on: windows-latest
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
       - name: Set up MinGW
-        uses: msys2/setup-msys2@61f9e5e925871ba6c9e3e8da24ede83ea27fa91f # v2.27.0
+        uses: msys2/setup-msys2@40677d36a502eb2cf0fb808cc9dec31bf6152638 # v2.28.0
         with:
           msystem: mingw64
           install: |
@@ -284,9 +294,9 @@ jobs:
             mingw-w64-x86_64-cmake
             mingw-w64-x86_64-ninja
             mingw-w64-x86_64-libevent
-      - name: Build
+      - name: Build and install
         shell: msys2 {0}
         run: |
           mkdir build && cd build
           cmake .. -G Ninja
-          cmake --build .
+          ninja -v install

deps/libvalkey/.github/workflows/coverity.yml

@@ -12,9 +12,9 @@ jobs:
     if: github.repository == 'valkey-io/libvalkey'
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+    - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
     - name: Install dependencies
-      uses: awalsh128/cache-apt-pkgs-action@7ca5f46d061ad9aa95863cd9b214dd48edef361d # v1.5.0
+      uses: awalsh128/cache-apt-pkgs-action@2c09a5e66da6c8016428a2172bd76e5e4f14bb17 # v1.5.3
       with:
         packages: libevent-dev
         version: 1.0

deps/libvalkey/.github/workflows/db-compatibility.yml

@@ -18,7 +18,7 @@ jobs:
           - valkey-version: '7.2.8'
     steps:
       - name: Prepare
-        uses: awalsh128/cache-apt-pkgs-action@7ca5f46d061ad9aa95863cd9b214dd48edef361d # v1.5.0
+        uses: awalsh128/cache-apt-pkgs-action@2c09a5e66da6c8016428a2172bd76e5e4f14bb17 # v1.5.3
         with:
           packages: libevent-dev
           version: 1.0
@@ -26,7 +26,7 @@ jobs:
         run: |
           git clone --depth 1 --branch ${{ matrix.valkey-version }} https://github.com/valkey-io/valkey.git
           cd valkey && BUILD_TLS=yes make install
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
       - name: Create build folder
         run: cmake -E make_directory build
       - name: Generate makefiles
@@ -66,7 +66,7 @@ jobs:
           - redis-version: '6.2.14'
     steps:
       - name: Prepare
-        uses: awalsh128/cache-apt-pkgs-action@7ca5f46d061ad9aa95863cd9b214dd48edef361d # v1.5.0
+        uses: awalsh128/cache-apt-pkgs-action@2c09a5e66da6c8016428a2172bd76e5e4f14bb17 # v1.5.3
         with:
           packages: libevent-dev
           version: 1.0
@@ -74,7 +74,7 @@ jobs:
         run: |
           git clone --depth 1 --branch ${{ matrix.redis-version }} https://github.com/redis/redis.git
           cd redis && BUILD_TLS=yes make install
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - name: Create build folder
         run: cmake -E make_directory build

deps/libvalkey/.github/workflows/spellcheck.yml

@@ -10,18 +10,18 @@ jobs:
   spellcheck:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
       - name: Run spellcheck
-        uses: rojopolis/spellcheck-github-actions@23dc186319866e1de224f94fe1d31b72797aeec7 # 0.48.0
+        uses: rojopolis/spellcheck-github-actions@35a02bae020e6999c5c37fabaf447f2eb8822ca7 # 0.51.0
         with:
           config_path: .github/spellcheck-settings.yml
           task_name: Markdown
   typos:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
       - name: Install typos
-        uses: taiki-e/install-action@ab3728c7ba6948b9b429627f4d55a68842b27f18 # v2.50.3
+        uses: taiki-e/install-action@ad95d4e02e061d4390c4b66ef5ed56c7fee3d2ce # v2.58.17
         with:
           tool: typos
       - name: Run typos

deps/libvalkey/CMakeLists.txt

@@ -64,13 +64,12 @@ endif()
 
 ADD_LIBRARY(valkey ${valkey_sources})
 ADD_LIBRARY(valkey::valkey ALIAS valkey)
-set(valkey_export_name valkey CACHE STRING "Name of the exported target")
-set_target_properties(valkey PROPERTIES EXPORT_NAME ${valkey_export_name})
+set_target_properties(valkey PROPERTIES
+  C_VISIBILITY_PRESET hidden
+  WINDOWS_EXPORT_ALL_SYMBOLS TRUE
+  SOVERSION "${VERSION_MAJOR}"
+  VERSION "${VERSION}")
 
-SET_TARGET_PROPERTIES(valkey
-    PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS TRUE
-    SOVERSION "${VERSION_MAJOR}"
-    VERSION "${VERSION}")
 IF(MSVC)
     SET_TARGET_PROPERTIES(valkey
         PROPERTIES COMPILE_FLAGS /Z7)
@@ -132,8 +131,11 @@ if (MSVC AND BUILD_SHARED_LIBS)
         CONFIGURATIONS Debug RelWithDebInfo)
 endif()
 
+# Install public headers
 install(DIRECTORY include/valkey
-        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+        PATTERN "tls.h" EXCLUDE
+        PATTERN "rdma.h" EXCLUDE)
 
 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/valkey.pc
     DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
@@ -189,11 +191,11 @@ IF(ENABLE_TLS)
         SET_PROPERTY(TARGET valkey_tls PROPERTY LINK_FLAGS "-Wl,-undefined -Wl,dynamic_lookup")
     ENDIF()
 
-    SET_TARGET_PROPERTIES(valkey_tls
-        PROPERTIES
-        WINDOWS_EXPORT_ALL_SYMBOLS TRUE
-        SOVERSION "${VERSION_MAJOR}"
-        VERSION "${VERSION}")
+    set_target_properties(valkey_tls PROPERTIES
+      C_VISIBILITY_PRESET hidden
+      WINDOWS_EXPORT_ALL_SYMBOLS TRUE
+      SOVERSION "${VERSION_MAJOR}"
+      VERSION "${VERSION}")
     IF(MSVC)
         SET_TARGET_PROPERTIES(valkey_tls
             PROPERTIES COMPILE_FLAGS /Z7)
@@ -210,6 +212,10 @@ IF(ENABLE_TLS)
         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
 
+    # Install public header
+    install(FILES include/valkey/tls.h
+            DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/valkey)
+
     if (MSVC AND BUILD_SHARED_LIBS)
         INSTALL(FILES $<TARGET_PDB_FILE:valkey_tls>
             DESTINATION ${CMAKE_INSTALL_BINDIR}
@@ -257,11 +263,11 @@ if(ENABLE_RDMA)
             $<BUILD_INTERFACE:${SDS_INCLUDE_DIR}>
     )
 
-    set_target_properties(valkey_rdma
-        PROPERTIES
-        WINDOWS_EXPORT_ALL_SYMBOLS TRUE
-        SOVERSION "${VERSION_MAJOR}"
-        VERSION "${VERSION}")
+    set_target_properties(valkey_rdma PROPERTIES
+      C_VISIBILITY_PRESET hidden
+      WINDOWS_EXPORT_ALL_SYMBOLS TRUE
+      SOVERSION "${VERSION_MAJOR}"
+      VERSION "${VERSION}")
     configure_file(valkey_rdma.pc.in valkey_rdma.pc @ONLY)
 
     install(TARGETS valkey_rdma
@@ -270,6 +276,10 @@ if(ENABLE_RDMA)
         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
 
+    # Install public header
+    install(FILES include/valkey/rdma.h
+            DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/valkey)
+
     install(FILES ${CMAKE_CURRENT_BINARY_DIR}/valkey_rdma.pc
         DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
 
@@ -293,6 +303,24 @@ endif()
 
 # Add tests
 if(NOT DISABLE_TESTS)
+  if(BUILD_SHARED_LIBS)
+    # Test using a static library since symbols are not hidden then.
+    # Use same source, include dirs and dependencies as the shared library.
+    add_library(valkey_unittest STATIC ${valkey_sources})
+    get_target_property(include_directories valkey::valkey INCLUDE_DIRECTORIES)
+    target_include_directories(valkey_unittest PUBLIC ${include_directories})
+    get_target_property(link_libraries valkey::valkey LINK_LIBRARIES)
+    if(link_libraries)
+      target_link_libraries(valkey_unittest PUBLIC ${link_libraries})
+    endif()
+    # Create libvalkey_unittest.a in the tests directory.
+    set_target_properties(valkey_unittest PROPERTIES
+      ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/tests")
+  else()
+    # Target is an alias for the static library.
+    add_library(valkey_unittest ALIAS valkey)
+  endif()
+
   # Make sure ctest prints the output when a test fails.
   # Must be set before including CTest.
   set(CMAKE_CTEST_ARGUMENTS "--output-on-failure")

deps/libvalkey/Makefile

@@ -76,7 +76,7 @@ ifeq ($(USE_WERROR),1)
   WARNINGS+=-Werror
 endif
 DEBUG_FLAGS?= -g -ggdb
-REAL_CFLAGS=$(OPTIMIZATION) -fPIC $(CPPFLAGS) $(CFLAGS) $(WARNINGS) $(DEBUG_FLAGS) $(PLATFORM_FLAGS)
+REAL_CFLAGS=$(OPTIMIZATION) -fPIC -fvisibility=hidden $(CPPFLAGS) $(CFLAGS) $(WARNINGS) $(DEBUG_FLAGS) $(PLATFORM_FLAGS)
 REAL_LDFLAGS=$(LDFLAGS)
 
 DYLIBSUFFIX=so

deps/libvalkey/examples/CMakeLists.txt

@@ -12,88 +12,85 @@ else()
   include_directories(${CMAKE_SOURCE_DIR}/include)
 endif()
 
-# Check for GLib
-find_package(PkgConfig QUIET)
-if(PkgConfig_FOUND)
-  pkg_check_modules(GLIB2 glib-2.0)
-  if(GLIB2_FOUND)
-    add_executable(example-async-glib async-glib.c)
-    target_include_directories(example-async-glib PUBLIC ${GLIB2_INCLUDE_DIRS})
-    target_link_libraries(example-async-glib valkey::valkey ${GLIB2_LIBRARIES})
-  endif()
-endif()
-
-find_path(LIBEV ev.h
-  HINTS /usr/local /usr/opt/local
-  ENV LIBEV_INCLUDE_DIR)
-if(LIBEV)
-  add_executable(example-async-libev async-libev.c)
-  target_link_libraries(example-async-libev valkey::valkey ev)
-endif()
-
-find_path(LIBEVENT event.h)
-if(LIBEVENT)
-  add_executable(example-async-libevent async-libevent.c)
-  target_link_libraries(example-async-libevent valkey::valkey event)
-
-  if(ENABLE_TLS)
-    add_executable(example-async-libevent-tls async-libevent-tls.c)
-    target_link_libraries(example-async-libevent-tls valkey::valkey valkey::valkey_tls event)
-  endif()
-endif()
-
-find_path(LIBHV hv/hv.h)
-if(LIBHV)
-  add_executable(example-async-libhv async-libhv.c)
-  target_link_libraries(example-async-libhv valkey::valkey hv)
-endif()
-
-find_path(LIBUV uv.h)
-if(LIBUV)
-  add_executable(example-async-libuv async-libuv.c)
-  target_link_libraries(example-async-libuv valkey::valkey uv)
-endif()
-
-find_path(LIBSDEVENT systemd/sd-event.h)
-if(LIBSDEVENT)
-  add_executable(example-async-libsdevent async-libsdevent.c)
-  target_link_libraries(example-async-libsdevent valkey::valkey systemd)
-endif()
-
-if(APPLE)
-  find_library(CF CoreFoundation)
-  add_executable(example-async-macosx async-macosx.c)
-  target_link_libraries(example-async-macosx valkey::valkey ${CF})
-endif()
-
-if(ENABLE_TLS)
-  add_executable(example-blocking-tls blocking-tls.c)
-  target_link_libraries(example-blocking-tls valkey::valkey valkey::valkey_tls)
-endif()
-
 add_executable(example-blocking blocking.c)
 target_link_libraries(example-blocking valkey::valkey)
 
 add_executable(example-blocking-push blocking-push.c)
 target_link_libraries(example-blocking-push valkey::valkey)
 
-if(LIBEVENT)
-  add_executable(example-cluster-async cluster-async.c)
-  target_link_libraries(example-cluster-async valkey::valkey event)
-
-  if(ENABLE_TLS)
-    add_executable(example-cluster-async-tls cluster-async-tls.c)
-    target_link_libraries(example-cluster-async-tls valkey::valkey valkey::valkey_tls event)
-  endif()
-
-  add_executable(example-cluster-clientside-caching-async cluster-clientside-caching-async.c)
-  target_link_libraries(example-cluster-clientside-caching-async valkey::valkey event)
-endif()
-
 add_executable(example-cluster-simple cluster-simple.c)
 target_link_libraries(example-cluster-simple valkey::valkey)
 
 if(ENABLE_TLS)
+  add_executable(example-blocking-tls blocking-tls.c)
+  target_link_libraries(example-blocking-tls valkey::valkey valkey::valkey_tls)
+
   add_executable(example-cluster-tls cluster-tls.c)
   target_link_libraries(example-cluster-tls valkey::valkey valkey::valkey_tls)
 endif()
+
+# Examples using GLib
+find_package(PkgConfig QUIET)
+if(PkgConfig_FOUND)
+  pkg_check_modules(GLIB2 IMPORTED_TARGET glib-2.0)
+  if(GLIB2_FOUND)
+    add_executable(example-async-glib async-glib.c)
+    target_link_libraries(example-async-glib valkey::valkey PkgConfig::GLIB2)
+  endif()
+endif()
+
+# Examples using libev
+find_path(LIBEV ev.h)
+if(LIBEV)
+  add_executable(example-async-libev async-libev.c)
+  target_link_libraries(example-async-libev valkey::valkey ev)
+endif()
+
+# Examples using libevent
+find_path(LIBEVENT event.h)
+if(LIBEVENT)
+  add_executable(example-async-libevent async-libevent.c)
+  target_link_libraries(example-async-libevent valkey::valkey event)
+
+  add_executable(example-cluster-async cluster-async.c)
+  target_link_libraries(example-cluster-async valkey::valkey event)
+
+  add_executable(example-cluster-clientside-caching-async cluster-clientside-caching-async.c)
+  target_link_libraries(example-cluster-clientside-caching-async valkey::valkey event)
+
+  if(ENABLE_TLS)
+    add_executable(example-async-libevent-tls async-libevent-tls.c)
+    target_link_libraries(example-async-libevent-tls valkey::valkey valkey::valkey_tls event)
+
+    add_executable(example-cluster-async-tls cluster-async-tls.c)
+    target_link_libraries(example-cluster-async-tls valkey::valkey valkey::valkey_tls event)
+  endif()
+endif()
+
+# Examples using libhv
+find_path(LIBHV hv/hv.h)
+if(LIBHV)
+  add_executable(example-async-libhv async-libhv.c)
+  target_link_libraries(example-async-libhv valkey::valkey hv)
+endif()
+
+# Examples using libuv
+find_path(LIBUV uv.h)
+if(LIBUV)
+  add_executable(example-async-libuv async-libuv.c)
+  target_link_libraries(example-async-libuv valkey::valkey uv)
+endif()
+
+# Examples using libsystemd
+find_path(LIBSDEVENT systemd/sd-event.h)
+if(LIBSDEVENT)
+  add_executable(example-async-libsdevent async-libsdevent.c)
+  target_link_libraries(example-async-libsdevent valkey::valkey systemd)
+endif()
+
+# Examples using the RunLoop in Apple's CoreFoundation
+if(APPLE)
+  find_library(CF CoreFoundation)
+  add_executable(example-async-macosx async-macosx.c)
+  target_link_libraries(example-async-macosx valkey::valkey ${CF})
+endif()

deps/libvalkey/examples/Makefile

@@ -1,9 +1,12 @@
 CC?=gcc
 CXX?=g++
 
-WARNINGS=-Wall -Wextra
-CFLAGS?=-fPIC -g -O2 $(WARNINGS) -I../include
 STLIBNAME?=../lib/libvalkey.a
+TLS_STLIBNAME?=../lib/libvalkey_tls.a
+INCLUDE_DIR?=../include
+
+WARNINGS=-Wall -Wextra
+CFLAGS?=-fPIC -g -O2 $(WARNINGS) -I $(INCLUDE_DIR)
 
 USE_WERROR?=1
 ifeq ($(USE_WERROR),1)
@@ -19,7 +22,6 @@ EXAMPLES=example-blocking example-blocking-push example-async-libevent \
 ifeq ($(USE_TLS),1)
   EXAMPLES+=example-blocking-tls example-async-libevent-tls \
 	    example-cluster-async-tls example-cluster-tls
-  TLS_STLIBNAME=../lib/libvalkey_tls.a
   TLS_LDFLAGS=-lssl -lcrypto
 endif
 

deps/libvalkey/examples/cluster-async-tls.c

@@ -51,10 +51,7 @@ void disconnectCallback(const valkeyAsyncContext *ac, int status) {
     printf("Disconnected from %s:%d\n", ac->c.tcp.host, ac->c.tcp.port);
 }
 
-int main(int argc, char **argv) {
-    UNUSED(argc);
-    UNUSED(argv);
-
+int main(void) {
     valkeyTLSContext *tls;
     valkeyTLSContextError tls_error;
 

deps/libvalkey/examples/cluster-async.c

@@ -46,9 +46,7 @@ void disconnectCallback(const valkeyAsyncContext *ac, int status) {
     printf("Disconnected from %s:%d\n", ac->c.tcp.host, ac->c.tcp.port);
 }
 
-int main(int argc, char **argv) {
-    (void)argc;
-    (void)argv;
+int main(void) {
     struct event_base *base = event_base_new();
 
     valkeyClusterOptions options = {0};

deps/libvalkey/examples/cluster-clientside-caching-async.c

@@ -139,9 +139,7 @@ void modifyKey(const char *key, const char *value) {
     valkeyClusterFree(cc);
 }
 
-int main(int argc, char **argv) {
-    (void)argc;
-    (void)argv;
+int main(void) {
     struct event_base *base = event_base_new();
 
     valkeyClusterOptions options = {0};

deps/libvalkey/examples/cluster-simple.c

@@ -3,9 +3,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-int main(int argc, char **argv) {
-    UNUSED(argc);
-    UNUSED(argv);
+int main(void) {
     struct timeval timeout = {1, 500000}; // 1.5s
 
     valkeyClusterOptions options = {0};

deps/libvalkey/examples/cluster-tls.c

@@ -6,10 +6,7 @@
 
 #define CLUSTER_NODE_TLS "127.0.0.1:7301"
 
-int main(int argc, char **argv) {
-    UNUSED(argc);
-    UNUSED(argv);
-
+int main(void) {
     valkeyTLSContext *tls;
     valkeyTLSContextError tls_error;
 

deps/libvalkey/include/valkey/adapters/libuv.h

@@ -142,7 +142,7 @@ static void valkeyLibuvTimeout(uv_timer_t *timer) {
 static void valkeyLibuvSetTimeout(void *privdata, struct timeval tv) {
     valkeyLibuvEvents *p = (valkeyLibuvEvents *)privdata;
 
-    uint64_t millsec = tv.tv_sec * 1000 + tv.tv_usec / 1000.0;
+    uint64_t millisec = tv.tv_sec * 1000 + tv.tv_usec / 1000.0;
     if (!p->timer.data) {
         // timer is uninitialized
         if (uv_timer_init(p->handle.loop, &p->timer) != 0) {
@@ -152,7 +152,7 @@ static void valkeyLibuvSetTimeout(void *privdata, struct timeval tv) {
     }
     // updates the timeout if the timer has already started
     // or start the timer
-    uv_timer_start(&p->timer, valkeyLibuvTimeout, millsec, 0);
+    uv_timer_start(&p->timer, valkeyLibuvTimeout, millisec, 0);
 }
 
 static void valkeyLibuvCleanup(void *privdata) {

deps/libvalkey/include/valkey/adapters/poll.h

@@ -100,7 +100,7 @@ static int valkeyPollTick(valkeyAsyncContext *ac, double timeout) {
          * handle it the same as writable. */
         if (writing && (pfd.revents & (POLLOUT | POLLERR))) {
             /* context Read callback may have caused context to be deleted, e.g.
-               by doing an valkeyAsyncDisconnect() */
+               by doing a valkeyAsyncDisconnect() */
             if (!e->deleted) {
                 valkeyAsyncHandleWrite(ac);
                 handled |= VALKEY_POLL_HANDLED_WRITE;

deps/libvalkey/include/valkey/alloc.h

@@ -30,6 +30,7 @@
 
 #ifndef VALKEY_ALLOC_H
 #define VALKEY_ALLOC_H
+#include "visibility.h"
 
 #include <stddef.h> /* for size_t */
 #include <stdint.h>
@@ -47,13 +48,13 @@ typedef struct valkeyAllocFuncs {
     void (*freeFn)(void *);
 } valkeyAllocFuncs;
 
-valkeyAllocFuncs valkeySetAllocators(valkeyAllocFuncs *fns);
-void valkeyResetAllocators(void);
+LIBVALKEY_API valkeyAllocFuncs valkeySetAllocators(valkeyAllocFuncs *fns);
+LIBVALKEY_API void valkeyResetAllocators(void);
 
 #ifndef _WIN32
 
 /* valkey' configured allocator function pointer struct */
-extern valkeyAllocFuncs valkeyAllocFns;
+LIBVALKEY_API extern valkeyAllocFuncs valkeyAllocFns;
 
 static inline void *vk_malloc(size_t size) {
     return valkeyAllocFns.mallocFn(size);
@@ -81,11 +82,11 @@ static inline void vk_free(void *ptr) {
 
 #else
 
-void *vk_malloc(size_t size);
-void *vk_calloc(size_t nmemb, size_t size);
-void *vk_realloc(void *ptr, size_t size);
-char *vk_strdup(const char *str);
-void vk_free(void *ptr);
+LIBVALKEY_API void *vk_malloc(size_t size);
+LIBVALKEY_API void *vk_calloc(size_t nmemb, size_t size);
+LIBVALKEY_API void *vk_realloc(void *ptr, size_t size);
+LIBVALKEY_API char *vk_strdup(const char *str);
+LIBVALKEY_API void vk_free(void *ptr);
 
 #endif
 

deps/libvalkey/include/valkey/async.h

@@ -32,6 +32,7 @@
 #ifndef VALKEY_ASYNC_H
 #define VALKEY_ASYNC_H
 #include "valkey.h"
+#include "visibility.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -122,34 +123,33 @@ typedef struct valkeyAsyncContext {
     valkeyAsyncPushFn *push_cb;
 } valkeyAsyncContext;
 
-/* Functions that proxy to libvalkey */
-valkeyAsyncContext *valkeyAsyncConnectWithOptions(const valkeyOptions *options);
-valkeyAsyncContext *valkeyAsyncConnect(const char *ip, int port);
-valkeyAsyncContext *valkeyAsyncConnectBind(const char *ip, int port, const char *source_addr);
-valkeyAsyncContext *valkeyAsyncConnectBindWithReuse(const char *ip, int port,
-                                                    const char *source_addr);
-valkeyAsyncContext *valkeyAsyncConnectUnix(const char *path);
-int valkeyAsyncSetConnectCallback(valkeyAsyncContext *ac, valkeyConnectCallback *fn);
-int valkeyAsyncSetDisconnectCallback(valkeyAsyncContext *ac, valkeyDisconnectCallback *fn);
+LIBVALKEY_API valkeyAsyncContext *valkeyAsyncConnectWithOptions(const valkeyOptions *options);
+LIBVALKEY_API valkeyAsyncContext *valkeyAsyncConnect(const char *ip, int port);
+LIBVALKEY_API valkeyAsyncContext *valkeyAsyncConnectBind(const char *ip, int port, const char *source_addr);
+LIBVALKEY_API valkeyAsyncContext *valkeyAsyncConnectBindWithReuse(const char *ip, int port,
+                                                                  const char *source_addr);
+LIBVALKEY_API valkeyAsyncContext *valkeyAsyncConnectUnix(const char *path);
+LIBVALKEY_API int valkeyAsyncSetConnectCallback(valkeyAsyncContext *ac, valkeyConnectCallback *fn);
+LIBVALKEY_API int valkeyAsyncSetDisconnectCallback(valkeyAsyncContext *ac, valkeyDisconnectCallback *fn);
 
-valkeyAsyncPushFn *valkeyAsyncSetPushCallback(valkeyAsyncContext *ac, valkeyAsyncPushFn *fn);
-int valkeyAsyncSetTimeout(valkeyAsyncContext *ac, struct timeval tv);
-void valkeyAsyncDisconnect(valkeyAsyncContext *ac);
-void valkeyAsyncFree(valkeyAsyncContext *ac);
+LIBVALKEY_API valkeyAsyncPushFn *valkeyAsyncSetPushCallback(valkeyAsyncContext *ac, valkeyAsyncPushFn *fn);
+LIBVALKEY_API int valkeyAsyncSetTimeout(valkeyAsyncContext *ac, struct timeval tv);
+LIBVALKEY_API void valkeyAsyncDisconnect(valkeyAsyncContext *ac);
+LIBVALKEY_API void valkeyAsyncFree(valkeyAsyncContext *ac);
 
 /* Handle read/write events */
-void valkeyAsyncHandleRead(valkeyAsyncContext *ac);
-void valkeyAsyncHandleWrite(valkeyAsyncContext *ac);
-void valkeyAsyncHandleTimeout(valkeyAsyncContext *ac);
-void valkeyAsyncRead(valkeyAsyncContext *ac);
-void valkeyAsyncWrite(valkeyAsyncContext *ac);
+LIBVALKEY_API void valkeyAsyncHandleRead(valkeyAsyncContext *ac);
+LIBVALKEY_API void valkeyAsyncHandleWrite(valkeyAsyncContext *ac);
+LIBVALKEY_API void valkeyAsyncHandleTimeout(valkeyAsyncContext *ac);
+LIBVALKEY_API void valkeyAsyncRead(valkeyAsyncContext *ac);
+LIBVALKEY_API void valkeyAsyncWrite(valkeyAsyncContext *ac);
 
 /* Command functions for an async context. Write the command to the
  * output buffer and register the provided callback. */
-int valkeyvAsyncCommand(valkeyAsyncContext *ac, valkeyCallbackFn *fn, void *privdata, const char *format, va_list ap);
-int valkeyAsyncCommand(valkeyAsyncContext *ac, valkeyCallbackFn *fn, void *privdata, const char *format, ...);
-int valkeyAsyncCommandArgv(valkeyAsyncContext *ac, valkeyCallbackFn *fn, void *privdata, int argc, const char **argv, const size_t *argvlen);
-int valkeyAsyncFormattedCommand(valkeyAsyncContext *ac, valkeyCallbackFn *fn, void *privdata, const char *cmd, size_t len);
+LIBVALKEY_API int valkeyvAsyncCommand(valkeyAsyncContext *ac, valkeyCallbackFn *fn, void *privdata, const char *format, va_list ap);
+LIBVALKEY_API int valkeyAsyncCommand(valkeyAsyncContext *ac, valkeyCallbackFn *fn, void *privdata, const char *format, ...);
+LIBVALKEY_API int valkeyAsyncCommandArgv(valkeyAsyncContext *ac, valkeyCallbackFn *fn, void *privdata, int argc, const char **argv, const size_t *argvlen);
+LIBVALKEY_API int valkeyAsyncFormattedCommand(valkeyAsyncContext *ac, valkeyCallbackFn *fn, void *privdata, const char *cmd, size_t len);
 
 #ifdef __cplusplus
 }

deps/libvalkey/include/valkey/cluster.h

@@ -35,8 +35,7 @@
 
 #include "async.h"
 #include "valkey.h"
-
-#define UNUSED(x) (void)(x)
+#include "visibility.h"
 
 #define VALKEYCLUSTER_SLOTS 16384
 
@@ -214,13 +213,13 @@ typedef struct {
 
 /* --- Synchronous API --- */
 
-valkeyClusterContext *valkeyClusterConnectWithOptions(const valkeyClusterOptions *options);
-valkeyClusterContext *valkeyClusterConnect(const char *addrs);
-valkeyClusterContext *valkeyClusterConnectWithTimeout(const char *addrs, const struct timeval tv);
-void valkeyClusterFree(valkeyClusterContext *cc);
+LIBVALKEY_API valkeyClusterContext *valkeyClusterConnectWithOptions(const valkeyClusterOptions *options);
+LIBVALKEY_API valkeyClusterContext *valkeyClusterConnect(const char *addrs);
+LIBVALKEY_API valkeyClusterContext *valkeyClusterConnectWithTimeout(const char *addrs, const struct timeval tv);
+LIBVALKEY_API void valkeyClusterFree(valkeyClusterContext *cc);
 
 /* Options configurable in runtime. */
-int valkeyClusterSetOptionTimeout(valkeyClusterContext *cc, const struct timeval tv);
+LIBVALKEY_API int valkeyClusterSetOptionTimeout(valkeyClusterContext *cc, const struct timeval tv);
 
 /* Blocking
  * The following functions will block for a reply, or return NULL if there was
@@ -228,22 +227,22 @@ int valkeyClusterSetOptionTimeout(valkeyClusterContext *cc, const struct timeval
  */
 
 /* Variadic commands (like printf) */
-void *valkeyClusterCommand(valkeyClusterContext *cc, const char *format, ...);
-void *valkeyClusterCommandToNode(valkeyClusterContext *cc,
-                                 valkeyClusterNode *node, const char *format,
-                                 ...);
+LIBVALKEY_API void *valkeyClusterCommand(valkeyClusterContext *cc, const char *format, ...);
+LIBVALKEY_API void *valkeyClusterCommandToNode(valkeyClusterContext *cc,
+                                               valkeyClusterNode *node, const char *format,
+                                               ...);
 /* Variadic using va_list */
-void *valkeyClustervCommand(valkeyClusterContext *cc, const char *format,
-                            va_list ap);
-void *valkeyClustervCommandToNode(valkeyClusterContext *cc,
-                                  valkeyClusterNode *node, const char *format,
-                                  va_list ap);
+LIBVALKEY_API void *valkeyClustervCommand(valkeyClusterContext *cc, const char *format,
+                                          va_list ap);
+LIBVALKEY_API void *valkeyClustervCommandToNode(valkeyClusterContext *cc,
+                                                valkeyClusterNode *node, const char *format,
+                                                va_list ap);
 /* Using argc and argv */
-void *valkeyClusterCommandArgv(valkeyClusterContext *cc, int argc,
-                               const char **argv, const size_t *argvlen);
+LIBVALKEY_API void *valkeyClusterCommandArgv(valkeyClusterContext *cc, int argc,
+                                             const char **argv, const size_t *argvlen);
 /* Send a Valkey protocol encoded string */
-void *valkeyClusterFormattedCommand(valkeyClusterContext *cc, char *cmd,
-                                    int len);
+LIBVALKEY_API void *valkeyClusterFormattedCommand(valkeyClusterContext *cc, char *cmd,
+                                                  int len);
 
 /* Pipelining
  * The following functions will write a command to the output buffer.
@@ -252,89 +251,89 @@ void *valkeyClusterFormattedCommand(valkeyClusterContext *cc, char *cmd,
  */
 
 /* Variadic commands (like printf) */
-int valkeyClusterAppendCommand(valkeyClusterContext *cc, const char *format,
-                               ...);
-int valkeyClusterAppendCommandToNode(valkeyClusterContext *cc,
-                                     valkeyClusterNode *node,
-                                     const char *format, ...);
+LIBVALKEY_API int valkeyClusterAppendCommand(valkeyClusterContext *cc, const char *format,
+                                             ...);
+LIBVALKEY_API int valkeyClusterAppendCommandToNode(valkeyClusterContext *cc,
+                                                   valkeyClusterNode *node,
+                                                   const char *format, ...);
 /* Variadic using va_list */
-int valkeyClustervAppendCommand(valkeyClusterContext *cc, const char *format,
-                                va_list ap);
-int valkeyClustervAppendCommandToNode(valkeyClusterContext *cc,
-                                      valkeyClusterNode *node,
-                                      const char *format, va_list ap);
+LIBVALKEY_API int valkeyClustervAppendCommand(valkeyClusterContext *cc, const char *format,
+                                              va_list ap);
+LIBVALKEY_API int valkeyClustervAppendCommandToNode(valkeyClusterContext *cc,
+                                                    valkeyClusterNode *node,
+                                                    const char *format, va_list ap);
 /* Using argc and argv */
-int valkeyClusterAppendCommandArgv(valkeyClusterContext *cc, int argc,
-                                   const char **argv, const size_t *argvlen);
+LIBVALKEY_API int valkeyClusterAppendCommandArgv(valkeyClusterContext *cc, int argc,
+                                                 const char **argv, const size_t *argvlen);
 /* Use a Valkey protocol encoded string as command */
-int valkeyClusterAppendFormattedCommand(valkeyClusterContext *cc, char *cmd,
-                                        int len);
+LIBVALKEY_API int valkeyClusterAppendFormattedCommand(valkeyClusterContext *cc, char *cmd,
+                                                      int len);
 /* Flush output buffer and return first reply */
-int valkeyClusterGetReply(valkeyClusterContext *cc, void **reply);
+LIBVALKEY_API int valkeyClusterGetReply(valkeyClusterContext *cc, void **reply);
 
 /* Reset context after a performed pipelining */
-void valkeyClusterReset(valkeyClusterContext *cc);
+LIBVALKEY_API void valkeyClusterReset(valkeyClusterContext *cc);
 
 /* Update the slotmap by querying any node. */
-int valkeyClusterUpdateSlotmap(valkeyClusterContext *cc);
+LIBVALKEY_API int valkeyClusterUpdateSlotmap(valkeyClusterContext *cc);
 
 /* Get the valkeyContext used for communication with a given node.
  * Connects or reconnects to the node if necessary. */
-valkeyContext *valkeyClusterGetValkeyContext(valkeyClusterContext *cc,
-                                             valkeyClusterNode *node);
+LIBVALKEY_API valkeyContext *valkeyClusterGetValkeyContext(valkeyClusterContext *cc,
+                                                           valkeyClusterNode *node);
 
 /* --- Asynchronous API --- */
 
-valkeyClusterAsyncContext *valkeyClusterAsyncConnectWithOptions(const valkeyClusterOptions *options);
-void valkeyClusterAsyncDisconnect(valkeyClusterAsyncContext *acc);
-void valkeyClusterAsyncFree(valkeyClusterAsyncContext *acc);
+LIBVALKEY_API valkeyClusterAsyncContext *valkeyClusterAsyncConnectWithOptions(const valkeyClusterOptions *options);
+LIBVALKEY_API void valkeyClusterAsyncDisconnect(valkeyClusterAsyncContext *acc);
+LIBVALKEY_API void valkeyClusterAsyncFree(valkeyClusterAsyncContext *acc);
 
 /* Commands */
-int valkeyClusterAsyncCommand(valkeyClusterAsyncContext *acc,
-                              valkeyClusterCallbackFn *fn, void *privdata,
-                              const char *format, ...);
-int valkeyClusterAsyncCommandToNode(valkeyClusterAsyncContext *acc,
-                                    valkeyClusterNode *node,
-                                    valkeyClusterCallbackFn *fn, void *privdata,
-                                    const char *format, ...);
-int valkeyClustervAsyncCommand(valkeyClusterAsyncContext *acc,
-                               valkeyClusterCallbackFn *fn, void *privdata,
-                               const char *format, va_list ap);
-int valkeyClusterAsyncCommandArgv(valkeyClusterAsyncContext *acc,
-                                  valkeyClusterCallbackFn *fn, void *privdata,
-                                  int argc, const char **argv,
-                                  const size_t *argvlen);
-int valkeyClusterAsyncCommandArgvToNode(valkeyClusterAsyncContext *acc,
-                                        valkeyClusterNode *node,
-                                        valkeyClusterCallbackFn *fn,
-                                        void *privdata, int argc,
-                                        const char **argv,
-                                        const size_t *argvlen);
+LIBVALKEY_API int valkeyClusterAsyncCommand(valkeyClusterAsyncContext *acc,
+                                            valkeyClusterCallbackFn *fn, void *privdata,
+                                            const char *format, ...);
+LIBVALKEY_API int valkeyClusterAsyncCommandToNode(valkeyClusterAsyncContext *acc,
+                                                  valkeyClusterNode *node,
+                                                  valkeyClusterCallbackFn *fn, void *privdata,
+                                                  const char *format, ...);
+LIBVALKEY_API int valkeyClustervAsyncCommand(valkeyClusterAsyncContext *acc,
+                                             valkeyClusterCallbackFn *fn, void *privdata,
+                                             const char *format, va_list ap);
+LIBVALKEY_API int valkeyClusterAsyncCommandArgv(valkeyClusterAsyncContext *acc,
+                                                valkeyClusterCallbackFn *fn, void *privdata,
+                                                int argc, const char **argv,
+                                                const size_t *argvlen);
+LIBVALKEY_API int valkeyClusterAsyncCommandArgvToNode(valkeyClusterAsyncContext *acc,
+                                                      valkeyClusterNode *node,
+                                                      valkeyClusterCallbackFn *fn,
+                                                      void *privdata, int argc,
+                                                      const char **argv,
+                                                      const size_t *argvlen);
 
 /* Use a Valkey protocol encoded string as command */
-int valkeyClusterAsyncFormattedCommand(valkeyClusterAsyncContext *acc,
-                                       valkeyClusterCallbackFn *fn,
-                                       void *privdata, char *cmd, int len);
-int valkeyClusterAsyncFormattedCommandToNode(valkeyClusterAsyncContext *acc,
-                                             valkeyClusterNode *node,
-                                             valkeyClusterCallbackFn *fn,
-                                             void *privdata, char *cmd,
-                                             int len);
+LIBVALKEY_API int valkeyClusterAsyncFormattedCommand(valkeyClusterAsyncContext *acc,
+                                                     valkeyClusterCallbackFn *fn,
+                                                     void *privdata, char *cmd, int len);
+LIBVALKEY_API int valkeyClusterAsyncFormattedCommandToNode(valkeyClusterAsyncContext *acc,
+                                                           valkeyClusterNode *node,
+                                                           valkeyClusterCallbackFn *fn,
+                                                           void *privdata, char *cmd,
+                                                           int len);
 
 /* Get the valkeyAsyncContext used for communication with a given node.
  * Connects or reconnects to the node if necessary. */
-valkeyAsyncContext *valkeyClusterGetValkeyAsyncContext(valkeyClusterAsyncContext *acc,
-                                                       valkeyClusterNode *node);
+LIBVALKEY_API valkeyAsyncContext *valkeyClusterGetValkeyAsyncContext(valkeyClusterAsyncContext *acc,
+                                                                     valkeyClusterNode *node);
 
 /* Cluster node iterator functions */
-void valkeyClusterInitNodeIterator(valkeyClusterNodeIterator *iter,
-                                   valkeyClusterContext *cc);
-valkeyClusterNode *valkeyClusterNodeNext(valkeyClusterNodeIterator *iter);
+LIBVALKEY_API void valkeyClusterInitNodeIterator(valkeyClusterNodeIterator *iter,
+                                                 valkeyClusterContext *cc);
+LIBVALKEY_API valkeyClusterNode *valkeyClusterNodeNext(valkeyClusterNodeIterator *iter);
 
 /* Helper functions */
-unsigned int valkeyClusterGetSlotByKey(char *key);
-valkeyClusterNode *valkeyClusterGetNodeByKey(valkeyClusterContext *cc,
-                                             char *key);
+LIBVALKEY_API unsigned int valkeyClusterGetSlotByKey(char *key);
+LIBVALKEY_API valkeyClusterNode *valkeyClusterGetNodeByKey(valkeyClusterContext *cc,
+                                                           char *key);
 
 #ifdef __cplusplus
 }

deps/libvalkey/include/valkey/net.h

@@ -36,17 +36,18 @@
 #define VALKEY_NET_H
 
 #include "valkey.h"
+#include "visibility.h"
 
-void valkeyNetClose(valkeyContext *c);
+LIBVALKEY_API void valkeyNetClose(valkeyContext *c);
 
-int valkeyHasMptcp(void);
-int valkeyCheckSocketError(valkeyContext *c);
-int valkeyTcpSetTimeout(valkeyContext *c, const struct timeval tv);
-int valkeyContextConnectTcp(valkeyContext *c, const valkeyOptions *options);
-int valkeyKeepAlive(valkeyContext *c, int interval);
-int valkeyCheckConnectDone(valkeyContext *c, int *completed);
+LIBVALKEY_API int valkeyHasMptcp(void);
+LIBVALKEY_API int valkeyCheckSocketError(valkeyContext *c);
+LIBVALKEY_API int valkeyTcpSetTimeout(valkeyContext *c, const struct timeval tv);
+LIBVALKEY_API int valkeyContextConnectTcp(valkeyContext *c, const valkeyOptions *options);
+LIBVALKEY_API int valkeyKeepAlive(valkeyContext *c, int interval);
+LIBVALKEY_API int valkeyCheckConnectDone(valkeyContext *c, int *completed);
 
-int valkeySetTcpNoDelay(valkeyContext *c);
-int valkeyContextSetTcpUserTimeout(valkeyContext *c, unsigned int timeout);
+LIBVALKEY_API int valkeySetTcpNoDelay(valkeyContext *c);
+LIBVALKEY_API int valkeyContextSetTcpUserTimeout(valkeyContext *c, unsigned int timeout);
 
 #endif /* VALKEY_NET_H */

deps/libvalkey/include/valkey/rdma.h

@@ -35,6 +35,8 @@
 #ifndef VALKEY_RDMA_H
 #define VALKEY_RDMA_H
 
+#include "visibility.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -58,7 +60,7 @@ extern "C" {
         (opts)->endpoint.tcp.source_addr = source_addr_;                         \
     } while (0)
 
-int valkeyInitiateRdma(void);
+LIBVALKEY_API int valkeyInitiateRdma(void);
 
 #ifdef __cplusplus
 }

deps/libvalkey/include/valkey/read.h

@@ -31,6 +31,8 @@
 
 #ifndef VALKEY_READ_H
 #define VALKEY_READ_H
+#include "visibility.h"
+
 #include <stdio.h> /* for size_t */
 
 #define VALKEY_ERR -1
@@ -112,10 +114,10 @@ typedef struct valkeyReader {
 } valkeyReader;
 
 /* Public API for the protocol parser. */
-valkeyReader *valkeyReaderCreateWithFunctions(valkeyReplyObjectFunctions *fn);
-void valkeyReaderFree(valkeyReader *r);
-int valkeyReaderFeed(valkeyReader *r, const char *buf, size_t len);
-int valkeyReaderGetReply(valkeyReader *r, void **reply);
+LIBVALKEY_API valkeyReader *valkeyReaderCreateWithFunctions(valkeyReplyObjectFunctions *fn);
+LIBVALKEY_API void valkeyReaderFree(valkeyReader *r);
+LIBVALKEY_API int valkeyReaderFeed(valkeyReader *r, const char *buf, size_t len);
+LIBVALKEY_API int valkeyReaderGetReply(valkeyReader *r, void **reply);
 
 #define valkeyReaderSetPrivdata(_r, _p) (int)(((valkeyReader *)(_r))->privdata = (_p))
 #define valkeyReaderGetObject(_r) (((valkeyReader *)(_r))->reply)

deps/libvalkey/include/valkey/tls.h

@@ -31,6 +31,8 @@
 #ifndef VALKEY_TLS_H
 #define VALKEY_TLS_H
 
+#include "visibility.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -87,7 +89,7 @@ typedef struct {
 /**
  * Return the error message corresponding with the specified error code.
  */
-const char *valkeyTLSContextGetError(valkeyTLSContextError error);
+LIBVALKEY_API const char *valkeyTLSContextGetError(valkeyTLSContextError error);
 
 /**
  * Helper function to initialize the OpenSSL library.
@@ -96,7 +98,7 @@ const char *valkeyTLSContextGetError(valkeyTLSContextError error);
  * call this function only once, and only if OpenSSL is not directly initialized
  * elsewhere.
  */
-int valkeyInitOpenSSL(void);
+LIBVALKEY_API int valkeyInitOpenSSL(void);
 
 /**
  * Helper function to initialize an OpenSSL context that can be used
@@ -118,9 +120,9 @@ int valkeyInitOpenSSL(void);
  * If error is non-null, it will be populated in case the context creation fails
  * (returning a NULL).
  */
-valkeyTLSContext *valkeyCreateTLSContext(const char *cacert_filename, const char *capath,
-                                         const char *cert_filename, const char *private_key_filename,
-                                         const char *server_name, valkeyTLSContextError *error);
+LIBVALKEY_API valkeyTLSContext *valkeyCreateTLSContext(const char *cacert_filename, const char *capath,
+                                                       const char *cert_filename, const char *private_key_filename,
+                                                       const char *server_name, valkeyTLSContextError *error);
 
 /**
   * Helper function to initialize an OpenSSL context that can be used
@@ -131,13 +133,13 @@ valkeyTLSContext *valkeyCreateTLSContext(const char *cacert_filename, const char
   * If error is non-null, it will be populated in case the context creation fails
   * (returning a NULL).
 */
-valkeyTLSContext *valkeyCreateTLSContextWithOptions(valkeyTLSOptions *options,
-                                                    valkeyTLSContextError *error);
+LIBVALKEY_API valkeyTLSContext *valkeyCreateTLSContextWithOptions(valkeyTLSOptions *options,
+                                                                  valkeyTLSContextError *error);
 
 /**
  * Free a previously created OpenSSL context.
  */
-void valkeyFreeTLSContext(valkeyTLSContext *valkey_tls_ctx);
+LIBVALKEY_API void valkeyFreeTLSContext(valkeyTLSContext *valkey_tls_ctx);
 
 /**
  * Initiate TLS on an existing valkeyContext.
@@ -146,12 +148,12 @@ void valkeyFreeTLSContext(valkeyTLSContext *valkey_tls_ctx);
  * to directly interact with OpenSSL, and instead uses a valkeyTLSContext
  * previously created using valkeyCreateTLSContext().
  */
-int valkeyInitiateTLSWithContext(struct valkeyContext *c, valkeyTLSContext *valkey_tls_ctx);
+LIBVALKEY_API int valkeyInitiateTLSWithContext(struct valkeyContext *c, valkeyTLSContext *valkey_tls_ctx);
 
 /**
  * Initiate TLS negotiation on a provided OpenSSL SSL object.
  */
-int valkeyInitiateTLS(struct valkeyContext *c, struct ssl_st *ssl);
+LIBVALKEY_API int valkeyInitiateTLS(struct valkeyContext *c, struct ssl_st *ssl);
 
 #ifdef __cplusplus
 }

deps/libvalkey/include/valkey/valkey.h

@@ -34,6 +34,7 @@
 #ifndef VALKEY_VALKEY_H
 #define VALKEY_VALKEY_H
 #include "read.h"
+#include "visibility.h"
 
 #include <stdarg.h> /* for va_list */
 #ifndef _MSC_VER
@@ -49,8 +50,8 @@ typedef SSIZE_T ssize_t;
 #include <stdint.h> /* uintXX_t, etc */
 
 #define LIBVALKEY_VERSION_MAJOR 0
-#define LIBVALKEY_VERSION_MINOR 1
-#define LIBVALKEY_VERSION_PATCH 0
+#define LIBVALKEY_VERSION_MINOR 2
+#define LIBVALKEY_VERSION_PATCH 1
 
 /* Connection type can be blocking or non-blocking and is set in the
  * least significant bit of the flags field in valkeyContext. */
@@ -138,16 +139,16 @@ typedef struct valkeyReply {
     struct valkeyReply **element; /* elements vector for VALKEY_REPLY_ARRAY */
 } valkeyReply;
 
-valkeyReader *valkeyReaderCreate(void);
+LIBVALKEY_API valkeyReader *valkeyReaderCreate(void);
 
 /* Function to free the reply objects hivalkey returns by default. */
-void freeReplyObject(void *reply);
+LIBVALKEY_API void freeReplyObject(void *reply);
 
 /* Functions to format a command according to the protocol. */
-int valkeyvFormatCommand(char **target, const char *format, va_list ap);
-int valkeyFormatCommand(char **target, const char *format, ...);
-long long valkeyFormatCommandArgv(char **target, int argc, const char **argv, const size_t *argvlen);
-void valkeyFreeCommand(char *cmd);
+LIBVALKEY_API int valkeyvFormatCommand(char **target, const char *format, va_list ap);
+LIBVALKEY_API int valkeyFormatCommand(char **target, const char *format, ...);
+LIBVALKEY_API long long valkeyFormatCommandArgv(char **target, int argc, const char **argv, const size_t *argvlen);
+LIBVALKEY_API void valkeyFreeCommand(char *cmd);
 
 enum valkeyConnectionType {
     VALKEY_CONN_TCP,
@@ -315,18 +316,18 @@ typedef struct valkeyContext {
     valkeyPushFn *push_cb;
 } valkeyContext;
 
-valkeyContext *valkeyConnectWithOptions(const valkeyOptions *options);
-valkeyContext *valkeyConnect(const char *ip, int port);
-valkeyContext *valkeyConnectWithTimeout(const char *ip, int port, const struct timeval tv);
-valkeyContext *valkeyConnectNonBlock(const char *ip, int port);
-valkeyContext *valkeyConnectBindNonBlock(const char *ip, int port,
-                                         const char *source_addr);
-valkeyContext *valkeyConnectBindNonBlockWithReuse(const char *ip, int port,
-                                                  const char *source_addr);
-valkeyContext *valkeyConnectUnix(const char *path);
-valkeyContext *valkeyConnectUnixWithTimeout(const char *path, const struct timeval tv);
-valkeyContext *valkeyConnectUnixNonBlock(const char *path);
-valkeyContext *valkeyConnectFd(valkeyFD fd);
+LIBVALKEY_API valkeyContext *valkeyConnectWithOptions(const valkeyOptions *options);
+LIBVALKEY_API valkeyContext *valkeyConnect(const char *ip, int port);
+LIBVALKEY_API valkeyContext *valkeyConnectWithTimeout(const char *ip, int port, const struct timeval tv);
+LIBVALKEY_API valkeyContext *valkeyConnectNonBlock(const char *ip, int port);
+LIBVALKEY_API valkeyContext *valkeyConnectBindNonBlock(const char *ip, int port,
+                                                       const char *source_addr);
+LIBVALKEY_API valkeyContext *valkeyConnectBindNonBlockWithReuse(const char *ip, int port,
+                                                                const char *source_addr);
+LIBVALKEY_API valkeyContext *valkeyConnectUnix(const char *path);
+LIBVALKEY_API valkeyContext *valkeyConnectUnixWithTimeout(const char *path, const struct timeval tv);
+LIBVALKEY_API valkeyContext *valkeyConnectUnixNonBlock(const char *path);
+LIBVALKEY_API valkeyContext *valkeyConnectFd(valkeyFD fd);
 
 /**
  * Reconnect the given context using the saved information.
@@ -337,47 +338,47 @@ valkeyContext *valkeyConnectFd(valkeyFD fd);
  *
  * Returns VALKEY_OK on successful connect or VALKEY_ERR otherwise.
  */
-int valkeyReconnect(valkeyContext *c);
+LIBVALKEY_API int valkeyReconnect(valkeyContext *c);
 
-valkeyPushFn *valkeySetPushCallback(valkeyContext *c, valkeyPushFn *fn);
-int valkeySetTimeout(valkeyContext *c, const struct timeval tv);
+LIBVALKEY_API valkeyPushFn *valkeySetPushCallback(valkeyContext *c, valkeyPushFn *fn);
+LIBVALKEY_API int valkeySetTimeout(valkeyContext *c, const struct timeval tv);
 
 /* Configurations using socket options. Applied directly to the underlying
  * socket and not automatically applied after a reconnect. */
-int valkeyEnableKeepAlive(valkeyContext *c);
-int valkeyEnableKeepAliveWithInterval(valkeyContext *c, int interval);
-int valkeySetTcpUserTimeout(valkeyContext *c, unsigned int timeout);
+LIBVALKEY_API int valkeyEnableKeepAlive(valkeyContext *c);
+LIBVALKEY_API int valkeyEnableKeepAliveWithInterval(valkeyContext *c, int interval);
+LIBVALKEY_API int valkeySetTcpUserTimeout(valkeyContext *c, unsigned int timeout);
 
-void valkeyFree(valkeyContext *c);
-valkeyFD valkeyFreeKeepFd(valkeyContext *c);
-int valkeyBufferRead(valkeyContext *c);
-int valkeyBufferWrite(valkeyContext *c, int *done);
+LIBVALKEY_API void valkeyFree(valkeyContext *c);
+LIBVALKEY_API valkeyFD valkeyFreeKeepFd(valkeyContext *c);
+LIBVALKEY_API int valkeyBufferRead(valkeyContext *c);
+LIBVALKEY_API int valkeyBufferWrite(valkeyContext *c, int *done);
 
 /* In a blocking context, this function first checks if there are unconsumed
  * replies to return and returns one if so. Otherwise, it flushes the output
  * buffer to the socket and reads until it has a reply. In a non-blocking
  * context, it will return unconsumed replies until there are no more. */
-int valkeyGetReply(valkeyContext *c, void **reply);
-int valkeyGetReplyFromReader(valkeyContext *c, void **reply);
+LIBVALKEY_API int valkeyGetReply(valkeyContext *c, void **reply);
+LIBVALKEY_API int valkeyGetReplyFromReader(valkeyContext *c, void **reply);
 
 /* Write a formatted command to the output buffer. Use these functions in blocking mode
  * to get a pipeline of commands. */
-int valkeyAppendFormattedCommand(valkeyContext *c, const char *cmd, size_t len);
+LIBVALKEY_API int valkeyAppendFormattedCommand(valkeyContext *c, const char *cmd, size_t len);
 
 /* Write a command to the output buffer. Use these functions in blocking mode
  * to get a pipeline of commands. */
-int valkeyvAppendCommand(valkeyContext *c, const char *format, va_list ap);
-int valkeyAppendCommand(valkeyContext *c, const char *format, ...);
-int valkeyAppendCommandArgv(valkeyContext *c, int argc, const char **argv, const size_t *argvlen);
+LIBVALKEY_API int valkeyvAppendCommand(valkeyContext *c, const char *format, va_list ap);
+LIBVALKEY_API int valkeyAppendCommand(valkeyContext *c, const char *format, ...);
+LIBVALKEY_API int valkeyAppendCommandArgv(valkeyContext *c, int argc, const char **argv, const size_t *argvlen);
 
 /* Issue a command to Valkey. In a blocking context, it is identical to calling
  * valkeyAppendCommand, followed by valkeyGetReply. The function will return
- * NULL if there was an error in performing the request, otherwise it will
+ * NULL if there was an error in performing the request; otherwise, it will
  * return the reply. In a non-blocking context, it is identical to calling
  * only valkeyAppendCommand and will always return NULL. */
-void *valkeyvCommand(valkeyContext *c, const char *format, va_list ap);
-void *valkeyCommand(valkeyContext *c, const char *format, ...);
-void *valkeyCommandArgv(valkeyContext *c, int argc, const char **argv, const size_t *argvlen);
+LIBVALKEY_API void *valkeyvCommand(valkeyContext *c, const char *format, va_list ap);
+LIBVALKEY_API void *valkeyCommand(valkeyContext *c, const char *format, ...);
+LIBVALKEY_API void *valkeyCommandArgv(valkeyContext *c, int argc, const char **argv, const size_t *argvlen);
 
 #ifdef __cplusplus
 }

deps/libvalkey/include/valkey/visibility.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2025-present, libvalkey contributors
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of the copyright holder nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef VALKEY_VISIBILITY_H
+#define VALKEY_VISIBILITY_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined __GNUC__
+#define LIBVALKEY_API __attribute__((visibility("default")))
+#elif defined(_MSC_VER)
+#define LIBVALKEY_API __declspec(dllexport)
+#else
+#define LIBVALKEY_API /* Unknown compiler */
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* VALKEY_VISIBILITY_H */

deps/libvalkey/scripts/gencommands.py

@@ -57,7 +57,7 @@ def any_argument_is_key(arguments):
 #                     keys (example EVAL)
 def firstkey(props):
     if not "key_specs" in props:
-        # Key specs missing. Best-effort fallback to "arguments".
+        # Key specs missing. Best-effort fall back to "arguments".
         if "arguments" in props:
             args = props["arguments"]
             for i in range(1, len(args)):
@@ -128,7 +128,7 @@ def extract_command_info(name, props):
         name = container.upper()
     else:
         # Ad-hoc handling of command and subcommand in the same string,
-        # sepatated by a space. This form is used in e.g. RediSearch's JSON file
+        # separated by a space. This form is used in e.g. RediSearch's JSON file
         # in commands like "FT.CONFIG GET".
         tokens = name.split(maxsplit=1)
         if len(tokens) > 1:

deps/libvalkey/src/adlist.c

@@ -38,7 +38,7 @@
  * AlFreeList(), but private value of every node need to be freed
  * by the user before to call AlFreeList().
  *
- * On error, NULL is returned. Otherwise the pointer to the new list. */
+ * On error, NULL is returned. Otherwise, the pointer to the new list. */
 hilist *listCreate(void) {
     struct hilist *list;
 
@@ -233,7 +233,7 @@ listNode *listNext(listIter *iter) {
  * On success a copy of the original list is returned.
  *
  * The 'Dup' method set with listSetDupMethod() function is used
- * to copy the node value. Otherwise the same pointer value of
+ * to copy the node value. Otherwise, the same pointer value of
  * the original node is used as value of the copied node.
  *
  * The original list both on success or error is never modified. */

deps/libvalkey/src/async.c

@@ -493,7 +493,7 @@ static int valkeyGetSubscribeCallback(valkeyAsyncContext *ac, valkeyReply *reply
             }
         }
 
-        /* If this is an subscribe reply decrease pending counter. */
+        /* If this is a subscribe reply decrease pending counter. */
         if (strcasecmp(stype + pvariant + svariant, "subscribe") == 0) {
             assert(cb != NULL);
             cb->pending_subs -= 1;

deps/libvalkey/src/async_private.h

@@ -31,6 +31,7 @@
 
 #ifndef VALKEY_ASYNC_PRIVATE_H
 #define VALKEY_ASYNC_PRIVATE_H
+#include "visibility.h"
 
 #define _EL_ADD_READ(ctx)                      \
     do {                                       \
@@ -77,7 +78,8 @@ static inline void refreshTimeout(valkeyAsyncContext *ctx) {
     }
 }
 
-void valkeyAsyncDisconnectInternal(valkeyAsyncContext *ac);
-void valkeyProcessCallbacks(valkeyAsyncContext *ac);
+/* Visible although private since required by libvalkey_tls.so */
+LIBVALKEY_API void valkeyAsyncDisconnectInternal(valkeyAsyncContext *ac);
+LIBVALKEY_API void valkeyProcessCallbacks(valkeyAsyncContext *ac);
 
 #endif /* VALKEY_ASYNC_PRIVATE_H */

deps/libvalkey/src/cluster.c

@@ -63,29 +63,13 @@ vk_static_assert(VALKEY_OPT_USE_CLUSTER_NODES > VALKEY_OPT_LAST_SA_OPTION);
 // standard Valkey errors
 #define VALKEY_ERR_CLUSTER_TOO_MANY_RETRIES 100
 
-#define VALKEY_ERROR_MOVED "MOVED"
-#define VALKEY_ERROR_ASK "ASK"
-#define VALKEY_ERROR_TRYAGAIN "TRYAGAIN"
-#define VALKEY_ERROR_CLUSTERDOWN "CLUSTERDOWN"
-
-#define VALKEY_STATUS_OK "OK"
-
 #define VALKEY_COMMAND_CLUSTER_NODES "CLUSTER NODES"
 #define VALKEY_COMMAND_CLUSTER_SLOTS "CLUSTER SLOTS"
 #define VALKEY_COMMAND_ASKING "ASKING"
 
-#define IP_PORT_SEPARATOR ':'
-
-#define PORT_CPORT_SEPARATOR '@'
-
-#define CLUSTER_ADDRESS_SEPARATOR ","
-
 #define CLUSTER_DEFAULT_MAX_RETRY_COUNT 5
 #define NO_RETRY -1
 
-#define CRLF "\x0d\x0a"
-#define CRLF_LEN (sizeof("\x0d\x0a") - 1)
-
 #define SLOTMAP_UPDATE_THROTTLE_USEC 1000000
 #define SLOTMAP_UPDATE_ONGOING INT64_MAX
 
@@ -97,14 +81,14 @@ typedef struct cluster_async_data {
     void *privdata;
 } cluster_async_data;
 
-typedef enum CLUSTER_ERR_TYPE {
-    CLUSTER_NOT_ERR = 0,
+typedef enum {
+    CLUSTER_NO_ERROR = 0,
     CLUSTER_ERR_MOVED,
     CLUSTER_ERR_ASK,
     CLUSTER_ERR_TRYAGAIN,
     CLUSTER_ERR_CLUSTERDOWN,
-    CLUSTER_ERR_SENTINEL
-} CLUSTER_ERR_TYPE;
+    CLUSTER_ERR_OTHER
+} replyErrorType;
 
 static void freeValkeyClusterNode(valkeyClusterNode *node);
 static void cluster_slot_destroy(cluster_slot *slot);
@@ -223,35 +207,20 @@ static inline void valkeyClusterClearError(valkeyClusterContext *cc) {
     cc->errstr[0] = '\0';
 }
 
-static int cluster_reply_error_type(valkeyReply *reply) {
+static replyErrorType getReplyErrorType(valkeyReply *reply) {
+    assert(reply);
 
-    if (reply == NULL) {
-        return VALKEY_ERR;
-    }
-
-    if (reply->type == VALKEY_REPLY_ERROR) {
-        if ((int)strlen(VALKEY_ERROR_MOVED) < reply->len &&
-            memcmp(reply->str, VALKEY_ERROR_MOVED,
-                   strlen(VALKEY_ERROR_MOVED)) == 0) {
-            return CLUSTER_ERR_MOVED;
-        } else if ((int)strlen(VALKEY_ERROR_ASK) < reply->len &&
-                   memcmp(reply->str, VALKEY_ERROR_ASK,
-                          strlen(VALKEY_ERROR_ASK)) == 0) {
-            return CLUSTER_ERR_ASK;
-        } else if ((int)strlen(VALKEY_ERROR_TRYAGAIN) < reply->len &&
-                   memcmp(reply->str, VALKEY_ERROR_TRYAGAIN,
-                          strlen(VALKEY_ERROR_TRYAGAIN)) == 0) {
-            return CLUSTER_ERR_TRYAGAIN;
-        } else if ((int)strlen(VALKEY_ERROR_CLUSTERDOWN) < reply->len &&
-                   memcmp(reply->str, VALKEY_ERROR_CLUSTERDOWN,
-                          strlen(VALKEY_ERROR_CLUSTERDOWN)) == 0) {
-            return CLUSTER_ERR_CLUSTERDOWN;
-        } else {
-            return CLUSTER_ERR_SENTINEL;
-        }
-    }
-
-    return CLUSTER_NOT_ERR;
+    if (reply->type != VALKEY_REPLY_ERROR)
+        return CLUSTER_NO_ERROR;
+    if (memcmp(reply->str, "MOVED", 5) == 0)
+        return CLUSTER_ERR_MOVED;
+    if (memcmp(reply->str, "ASK", 3) == 0)
+        return CLUSTER_ERR_ASK;
+    if (memcmp(reply->str, "TRYAGAIN", 8) == 0)
+        return CLUSTER_ERR_TRYAGAIN;
+    if (memcmp(reply->str, "CLUSTERDOWN", 11) == 0)
+        return CLUSTER_ERR_CLUSTERDOWN;
+    return CLUSTER_ERR_OTHER;
 }
 
 /* Create and initiate the cluster node structure */
@@ -561,7 +530,7 @@ static dict *parse_cluster_slots(valkeyClusterContext *cc, valkeyContext *c,
                     valkeyClusterSetError(
                         cc, VALKEY_ERR_OTHER,
                         "Command(cluster slots) reply error: "
-                        "nodes sub_reply is not an correct array.");
+                        "nodes sub_reply is not a correct array.");
                     goto error;
                 }
 
@@ -816,12 +785,12 @@ static int parse_cluster_nodes_line(valkeyClusterContext *cc, valkeyContext *c,
 
     /* Parse the address field: <ip:port@cport[,hostname]>
      * Remove @cport.. to get <ip>:<port> which is our dict key. */
-    if ((p = strchr(addr, PORT_CPORT_SEPARATOR)) != NULL) {
+    if ((p = strchr(addr, '@')) != NULL) {
         *p = '\0';
     }
 
     /* Find the required port separator. */
-    if ((p = strrchr(addr, IP_PORT_SEPARATOR)) == NULL) {
+    if ((p = strrchr(addr, ':')) == NULL) {
         valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "Invalid node address");
         freeValkeyClusterNode(node);
         return VALKEY_ERR;
@@ -1059,68 +1028,6 @@ static int clusterUpdateRouteHandleReply(valkeyClusterContext *cc,
     return updateNodesAndSlotmap(cc, nodes);
 }
 
-/**
- * Update route with the "cluster nodes" or "cluster slots" command reply.
- */
-static int cluster_update_route_by_addr(valkeyClusterContext *cc,
-                                        const char *ip, int port) {
-    valkeyContext *c = NULL;
-
-    if (cc == NULL) {
-        return VALKEY_ERR;
-    }
-
-    if (ip == NULL || port <= 0) {
-        valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "Ip or port error!");
-        goto error;
-    }
-
-    valkeyOptions options = {0};
-    VALKEY_OPTIONS_SET_TCP(&options, ip, port);
-    options.connect_timeout = cc->connect_timeout;
-    options.command_timeout = cc->command_timeout;
-    options.options = cc->options;
-
-    c = valkeyConnectWithOptions(&options);
-    if (c == NULL) {
-        valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
-        return VALKEY_ERR;
-    }
-
-    if (cc->on_connect) {
-        cc->on_connect(c, c->err ? VALKEY_ERR : VALKEY_OK);
-    }
-
-    if (c->err) {
-        valkeyClusterSetError(cc, c->err, c->errstr);
-        goto error;
-    }
-
-    if (cc->tls && cc->tls_init_fn(c, cc->tls) != VALKEY_OK) {
-        valkeyClusterSetError(cc, c->err, c->errstr);
-        goto error;
-    }
-
-    if (authenticate(cc, c) != VALKEY_OK) {
-        goto error;
-    }
-
-    if (clusterUpdateRouteSendCommand(cc, c) != VALKEY_OK) {
-        goto error;
-    }
-
-    if (clusterUpdateRouteHandleReply(cc, c) != VALKEY_OK) {
-        goto error;
-    }
-
-    valkeyFree(c);
-    return VALKEY_OK;
-
-error:
-    valkeyFree(c);
-    return VALKEY_ERR;
-}
-
 /* Update known cluster nodes with a new collection of valkeyClusterNodes.
  * Will also update the slot-to-node lookup table for the new nodes. */
 static int updateNodesAndSlotmap(valkeyClusterContext *cc, dict *nodes) {
@@ -1214,35 +1121,31 @@ error:
 }
 
 int valkeyClusterUpdateSlotmap(valkeyClusterContext *cc) {
-    int ret;
-    int flag_err_not_set = 1;
-    valkeyClusterNode *node;
-    dictEntry *de;
-
     if (cc == NULL) {
         return VALKEY_ERR;
     }
 
+    valkeyClusterNode *node;
+    dictEntry *de;
+
     dictIterator di;
     dictInitIterator(&di, cc->nodes);
 
     while ((de = dictNext(&di)) != NULL) {
         node = dictGetVal(de);
-        if (node == NULL || node->host == NULL) {
+
+        /* Use existing connection or (re)connect to the node. */
+        valkeyContext *c = valkeyClusterGetValkeyContext(cc, node);
+        if (c == NULL)
+            continue;
+        if (clusterUpdateRouteSendCommand(cc, c) != VALKEY_OK ||
+            clusterUpdateRouteHandleReply(cc, c) != VALKEY_OK) {
+            valkeyFree(node->con);
+            node->con = NULL;
             continue;
         }
-
-        ret = cluster_update_route_by_addr(cc, node->host, node->port);
-        if (ret == VALKEY_OK) {
-            valkeyClusterClearError(cc);
-            return VALKEY_OK;
-        }
-
-        flag_err_not_set = 0;
-    }
-
-    if (flag_err_not_set) {
-        valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "no valid server address");
+        valkeyClusterClearError(cc);
+        return VALKEY_OK;
     }
 
     return VALKEY_ERR;
@@ -1389,12 +1292,13 @@ static int valkeyClusterSetOptionAddNode(valkeyClusterContext *cc, const char *a
     node_entry = dictFind(cc->nodes, addr_sds);
     sdsfree(addr_sds);
     if (node_entry == NULL) {
-
         char *p;
-        if ((p = strrchr(addr, IP_PORT_SEPARATOR)) == NULL) {
-            valkeyClusterSetError(
-                cc, VALKEY_ERR_OTHER,
-                "server address is incorrect, port separator missing.");
+
+        /* Find the last occurrence of the port separator since
+         * IPv6 addresses can contain ':' */
+        if ((p = strrchr(addr, ':')) == NULL) {
+            valkeyClusterSetError(cc, VALKEY_ERR_OTHER,
+                                  "server address is incorrect, port separator missing.");
             return VALKEY_ERR;
         }
         // p includes separator
@@ -1476,8 +1380,8 @@ static int valkeyClusterSetOptionAddNodes(valkeyClusterContext *cc,
         return VALKEY_ERR;
     }
 
-    address = sdssplitlen(addrs, strlen(addrs), CLUSTER_ADDRESS_SEPARATOR,
-                          strlen(CLUSTER_ADDRESS_SEPARATOR), &address_count);
+    /* Split into individual addresses. */
+    address = sdssplitlen(addrs, strlen(addrs), ",", strlen(","), &address_count);
     if (address == NULL) {
         valkeyClusterSetError(cc, VALKEY_ERR_OOM, "Out of memory");
         return VALKEY_ERR;
@@ -1801,7 +1705,7 @@ static int valkeyClusterGetReplyFromNode(valkeyClusterContext *cc,
         return VALKEY_ERR;
     }
 
-    if (cluster_reply_error_type(*reply) == CLUSTER_ERR_MOVED)
+    if (getReplyErrorType(*reply) == CLUSTER_ERR_MOVED)
         cc->need_update_route = 1;
 
     return VALKEY_OK;
@@ -1845,7 +1749,7 @@ static valkeyClusterNode *getNodeFromRedirectReply(valkeyClusterContext *cc,
     }
     /* Find the last occurrence of the port separator since
      * IPv6 addresses can contain ':' */
-    if ((p = strrchr(addr, IP_PORT_SEPARATOR)) == NULL) {
+    if ((p = strrchr(addr, ':')) == NULL) {
         valkeyClusterSetError(cc, VALKEY_ERR_OTHER, "Invalid address in redirect");
         return NULL;
     }
@@ -1934,7 +1838,6 @@ static void *valkey_cluster_command_execute(valkeyClusterContext *cc,
     void *reply = NULL;
     valkeyClusterNode *node;
     valkeyContext *c = NULL;
-    int error_type;
     valkeyContext *c_updating_route = NULL;
 
 retry:
@@ -1999,8 +1902,8 @@ ask_retry:
         goto error;
     }
 
-    error_type = cluster_reply_error_type(reply);
-    if (error_type > CLUSTER_NOT_ERR && error_type < CLUSTER_ERR_SENTINEL) {
+    replyErrorType error_type = getReplyErrorType(reply);
+    if (error_type > CLUSTER_NO_ERROR && error_type < CLUSTER_ERR_OTHER) {
         cc->retry_count++;
         if (cc->retry_count > cc->max_retry_count) {
             valkeyClusterSetError(cc, VALKEY_ERR_CLUSTER_TOO_MANY_RETRIES,
@@ -2829,6 +2732,19 @@ static int valkeyClusterAsyncConnect(valkeyClusterAsyncContext *acc) {
             valkeyClusterAsyncSetError(acc, acc->cc.err, acc->cc.errstr);
             return VALKEY_ERR;
         }
+
+        /* Disconnect any non-async context used for the initial update. */
+        dictIterator di;
+        dictInitIterator(&di, acc->cc.nodes);
+        dictEntry *de;
+        while ((de = dictNext(&di)) != NULL) {
+            valkeyClusterNode *node = dictGetVal(de);
+            if (node->con) {
+                valkeyFree(node->con);
+                node->con = NULL;
+            }
+        }
+
         return VALKEY_OK;
     }
     /* Use non-blocking initial slotmap update. */
@@ -2985,7 +2901,6 @@ static void valkeyClusterAsyncCallback(valkeyAsyncContext *ac, void *r,
     valkeyClusterAsyncContext *acc;
     valkeyClusterContext *cc;
     valkeyAsyncContext *ac_retry = NULL;
-    int error_type;
     valkeyClusterNode *node;
     struct cmd *command;
 
@@ -3025,9 +2940,8 @@ static void valkeyClusterAsyncCallback(valkeyAsyncContext *ac, void *r,
     if (cad->retry_count == NO_RETRY || cc->flags & VALKEY_FLAG_DISCONNECTING)
         goto done;
 
-    error_type = cluster_reply_error_type(reply);
-
-    if (error_type > CLUSTER_NOT_ERR && error_type < CLUSTER_ERR_SENTINEL) {
+    replyErrorType error_type = getReplyErrorType(reply);
+    if (error_type > CLUSTER_NO_ERROR && error_type < CLUSTER_ERR_OTHER) {
         cad->retry_count++;
         if (cad->retry_count > cc->max_retry_count) {
             cad->retry_count = 0;

deps/libvalkey/src/command.h

@@ -75,7 +75,7 @@ struct cmd {
     /* Command destination */
     int slot_num;    /* Command should be sent to slot.
                       * Set to -1 if command is sent to a given node,
-                      * or if a slot can not be found or calculated. */
+                      * or if a slot cannot be found or calculated. */
     char *node_addr; /* Command sent to this node address */
 };
 

deps/libvalkey/src/dict.c

@@ -43,6 +43,8 @@
 #include <limits.h>
 #include <stdlib.h>
 
+#define UNUSED(x) (void)(x)
+
 /* -------------------------- types ----------------------------------------- */
 struct dictEntry {
     void *key;
@@ -71,7 +73,7 @@ uint64_t dictGenHashFunction(const unsigned char *buf, int len) {
 
 /* ----------------------------- API implementation ------------------------- */
 
-/* Reset an hashtable already initialized with ht_init().
+/* Reset a hashtable already initialized with ht_init().
  * NOTE: This function should only called by ht_destroy(). */
 static void _dictReset(dict *ht) {
     ht->table = NULL;
@@ -116,7 +118,7 @@ int dictExpand(dict *ht, unsigned long size) {
 
     /* Copy all the elements from the old to the new table:
      * note that if the old hash table is empty ht->size is zero,
-     * so dictExpand just creates an hash table. */
+     * so dictExpand just creates a hash table. */
     n.used = ht->used;
     for (i = 0; i < ht->size && ht->used > 0; i++) {
         dictEntry *he, *nextHe;
@@ -356,7 +358,7 @@ static unsigned long _dictNextPower(unsigned long size) {
 }
 
 /* Returns the index of a free slot that can be populated with
- * an hash entry for the given 'key'.
+ * a hash entry for the given 'key'.
  * If the key already exists, -1 is returned. */
 static int _dictKeyIndex(dict *ht, const void *key) {
     unsigned int h;

deps/libvalkey/src/net.c

@@ -397,6 +397,7 @@ int valkeyHasMptcp(void) {
 
 static int valkeyTcpGetProtocol(int is_mptcp_enabled) {
     assert(!is_mptcp_enabled);
+    (void)is_mptcp_enabled; /* Suppress unused warning when NDEBUG is defined. */
     return IPPROTO_TCP;
 }
 #endif /* IPPROTO_MPTCP */

deps/libvalkey/src/rdma.c

@@ -390,7 +390,12 @@ static int connRdmaHandleCq(valkeyContext *c) {
             valkeySetError(c, VALKEY_ERR_OTHER, "RDMA: get cq event failed");
             return VALKEY_ERR;
         }
-    } else if (ibv_req_notify_cq(ev_cq, 0)) {
+
+        return VALKEY_OK;
+    }
+
+    ibv_ack_cq_events(ctx->cq, 1);
+    if (ibv_req_notify_cq(ev_cq, 0)) {
         valkeySetError(c, VALKEY_ERR_OTHER, "RDMA: notify cq failed");
         return VALKEY_ERR;
     }
@@ -404,8 +409,6 @@ pollcq:
         return VALKEY_OK;
     }
 
-    ibv_ack_cq_events(ctx->cq, 1);
-
     if (wc.status != IBV_WC_SUCCESS) {
         valkeySetError(c, VALKEY_ERR_OTHER, "RDMA: send/recv failed");
         return VALKEY_ERR;
@@ -614,7 +617,7 @@ waitcq:
     }
 }
 
-/* RDMA has no POLLOUT event supported, so it could't work well with valkey async mechanism */
+/* RDMA has no POLLOUT event supported, so it couldn't work well with valkey async mechanism */
 static void valkeyRdmaAsyncRead(VALKEY_UNUSED valkeyAsyncContext *ac) {
     assert("valkey async mechanism can't work with RDMA" == NULL);
 }

deps/libvalkey/src/read.c

@@ -198,7 +198,7 @@ static int string2ll(const char *s, size_t slen, long long *value) {
             return VALKEY_ERR;
     }
 
-    /* First digit should be 1-9, otherwise the string should just be 0. */
+    /* First digit should be 1-9; otherwise, the string should just be 0. */
     if (p[0] >= '1' && p[0] <= '9') {
         v = p[0] - '0';
         p++;

deps/libvalkey/src/sds.c

@@ -444,81 +444,125 @@ sds sdscpy(sds s, const char *t) {
     return sdscpylen(s, t, strlen(t));
 }
 
-/* Helper for sdscatlonglong() doing the actual number -> string
- * conversion. 's' must point to a string with room for at least
- * SDS_LLSTR_SIZE bytes.
- *
- * The function returns the length of the null-terminated string
- * representation stored at 's'. */
-#define SDS_LLSTR_SIZE 21
-int sdsll2str(char *s, long long value) {
-    char *p, aux;
-    unsigned long long v;
-    size_t l;
-
-    /* Generate the string representation, this method produces
-     * an reversed string. */
-    v = (value < 0) ? -value : value;
-    p = s;
-    do {
-        *p++ = '0' + (v % 10);
-        v /= 10;
-    } while (v);
-    if (value < 0)
-        *p++ = '-';
-
-    /* Compute length and add null term. */
-    l = p - s;
-    *p = '\0';
-
-    /* Reverse the string. */
-    p--;
-    while (s < p) {
-        aux = *s;
-        *s = *p;
-        *p = aux;
-        s++;
-        p--;
+/* Return the number of digits of 'v' when converted to string in radix 10.
+ * See ll2string() for more information. */
+static uint32_t digits10(uint64_t v) {
+    if (v < 10)
+        return 1;
+    if (v < 100)
+        return 2;
+    if (v < 1000)
+        return 3;
+    if (v < 1000000000000UL) {
+        if (v < 100000000UL) {
+            if (v < 1000000) {
+                if (v < 10000)
+                    return 4;
+                return 5 + (v >= 100000);
+            }
+            return 7 + (v >= 10000000UL);
+        }
+        if (v < 10000000000UL) {
+            return 9 + (v >= 1000000000UL);
+        }
+        return 11 + (v >= 100000000000UL);
     }
-    return l;
+    return 12 + digits10(v / 1000000000000UL);
 }
 
-/* Identical sdsll2str(), but for unsigned long long type. */
-int sdsull2str(char *s, unsigned long long v) {
-    char *p, aux;
-    size_t l;
+/* Convert a unsigned long long into a string. Returns the number of
+ * characters needed to represent the number.
+ * If the buffer is not big enough to store the string, 0 is returned.
+ *
+ * Based on the following article (that apparently does not provide a
+ * novel approach but only publicizes an already used technique):
+ *
+ * https://www.facebook.com/notes/facebook-engineering/three-optimization-tips-for-c/10151361643253920 */
+static int ull2string(char *dst, size_t dstlen, unsigned long long value) {
+    static const char digits[201] = "0001020304050607080910111213141516171819"
+                                    "2021222324252627282930313233343536373839"
+                                    "4041424344454647484950515253545556575859"
+                                    "6061626364656667686970717273747576777879"
+                                    "8081828384858687888990919293949596979899";
 
-    /* Generate the string representation, this method produces
-     * an reversed string. */
-    p = s;
-    do {
-        *p++ = '0' + (v % 10);
-        v /= 10;
-    } while (v);
+    /* Check length. */
+    uint32_t length = digits10(value);
+    if (length >= dstlen)
+        goto err;
 
-    /* Compute length and add null term. */
-    l = p - s;
-    *p = '\0';
-
-    /* Reverse the string. */
-    p--;
-    while (s < p) {
-        aux = *s;
-        *s = *p;
-        *p = aux;
-        s++;
-        p--;
+    /* Null term. */
+    uint32_t next = length - 1;
+    dst[next + 1] = '\0';
+    while (value >= 100) {
+        int const i = (value % 100) * 2;
+        value /= 100;
+        dst[next] = digits[i + 1];
+        dst[next - 1] = digits[i];
+        next -= 2;
     }
-    return l;
+
+    /* Handle last 1-2 digits. */
+    if (value < 10) {
+        dst[next] = '0' + (uint32_t)value;
+    } else {
+        int i = (uint32_t)value * 2;
+        dst[next] = digits[i + 1];
+        dst[next - 1] = digits[i];
+    }
+    return length;
+err:
+    /* force add Null termination */
+    if (dstlen > 0)
+        dst[0] = '\0';
+    return 0;
+}
+
+/* Convert a long long into a string. Returns the number of
+ * characters needed to represent the number.
+ * If the buffer is not big enough to store the string, 0 is returned. */
+static int ll2string(char *dst, size_t dstlen, long long svalue) {
+    unsigned long long value;
+    int negative = 0;
+
+    /* The ull2string function with 64bit unsigned integers for simplicity, so
+     * we convert the number here and remember if it is negative. */
+    if (svalue < 0) {
+        if (svalue != LLONG_MIN) {
+            value = -svalue;
+        } else {
+            value = ((unsigned long long)LLONG_MAX) + 1;
+        }
+        if (dstlen < 2)
+            goto err;
+        negative = 1;
+        dst[0] = '-';
+        dst++;
+        dstlen--;
+    } else {
+        value = svalue;
+    }
+
+    /* Converts the unsigned long long value to string */
+    int length = ull2string(dst, dstlen, value);
+    if (length == 0)
+        return 0;
+    return length + negative;
+
+err:
+    /* force add Null termination */
+    if (dstlen > 0)
+        dst[0] = '\0';
+    return 0;
 }
 
 /* Create an sds string from a long long value. It is much faster than:
  *
  * sdscatprintf(sdsempty(),"%lld\n", value);
  */
+#define SDS_LLSTR_SIZE 21
 sds sdsfromlonglong(long long value) {
     char buf[SDS_LLSTR_SIZE];
-    int len = sdsll2str(buf, value);
+    int len = ll2string(buf, sizeof(buf), value);
 
     return sdsnewlen(buf, len);
 }
@@ -652,7 +696,7 @@ sds sdscatfmt(sds s, char const *fmt, ...) {
                     num = va_arg(ap, long long);
                 {
                     char buf[SDS_LLSTR_SIZE];
-                    l = sdsll2str(buf, num);
+                    l = ll2string(buf, sizeof(buf), num);
                     if (sdsavail(s) < l) {
                         s = sdsMakeRoomFor(s, l);
                         if (s == NULL)
@@ -671,7 +715,7 @@ sds sdscatfmt(sds s, char const *fmt, ...) {
                     unum = va_arg(ap, unsigned long long);
                 {
                     char buf[SDS_LLSTR_SIZE];
-                    l = sdsull2str(buf, unum);
+                    l = ull2string(buf, sizeof(buf), unum);
                     if (sdsavail(s) < l) {
                         s = sdsMakeRoomFor(s, l);
                         if (s == NULL)
@@ -707,7 +751,7 @@ fmt_error:
 }
 
 /* Remove the part of the string from left and from right composed just of
- * contiguous characters found in 'cset', that is a null terminted C string.
+ * contiguous characters found in 'cset', that is a null terminated C string.
  *
  * After the call, the modified sds string is no longer valid and all the
  * references must be substituted with the new pointer returned by the call.
@@ -1220,7 +1264,6 @@ void sds_free(void *ptr) { s_free(ptr); }
 
 #include <stdio.h>
 
-#define UNUSED(x) (void)(x)
 int sdsTest(void) {
     {
         sds x = sdsnew("foo"), y;

deps/libvalkey/src/tls.c

@@ -38,8 +38,11 @@
 #include <errno.h>
 #include <string.h>
 #ifdef _WIN32
-#include <wincrypt.h>
+/* clang-format off */
+// wincrypt.h need macro defined in windows.h
 #include <windows.h>
+#include <wincrypt.h>
+/* clang-format on */
 #ifdef OPENSSL_IS_BORINGSSL
 #undef X509_NAME
 #undef X509_EXTENSIONS

deps/libvalkey/src/valkey.c

@@ -218,7 +218,7 @@ static void *createIntegerObject(const valkeyReadTask *task, long long value) {
 static void *createDoubleObject(const valkeyReadTask *task, double value, char *str, size_t len) {
     valkeyReply *r, *parent;
 
-    if (len == SIZE_MAX) // Prevents vk_malloc(0) if len equals to SIZE_MAX
+    if (len == SIZE_MAX) // Prevents vk_malloc(0) if len equals SIZE_MAX
         return NULL;
 
     r = createReplyObject(VALKEY_REPLY_DOUBLE);
@@ -235,7 +235,7 @@ static void *createDoubleObject(const valkeyReadTask *task, double value, char *
     /* The double reply also has the original protocol string representing a
      * double as a null terminated string. This way the caller does not need
      * to format back for string conversion, especially since Valkey does efforts
-     * to make the string more human readable avoiding the calssical double
+     * to make the string more human readable avoiding the classical double
      * decimal string conversion artifacts. */
     memcpy(r->str, str, len);
     r->str[len] = '\0';

deps/libvalkey/src/valkey_private.h

@@ -34,13 +34,14 @@
 #include "win32.h"
 
 #include "valkey.h"
+#include "visibility.h"
 
 #include <sds.h>
 
 #include <limits.h>
 #include <string.h>
 
-void valkeySetError(valkeyContext *c, int type, const char *str);
+LIBVALKEY_API void valkeySetError(valkeyContext *c, int type, const char *str);
 
 /* Helper function. Convert struct timeval to millisecond. */
 static inline int valkeyContextTimeoutMsec(const struct timeval *timeout, long *result) {

deps/libvalkey/src/vkutil.c

@@ -28,16 +28,7 @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
-#include <stdio.h>
-#include <stdlib.h>
 
-#ifndef _WIN32
-#include <sys/time.h>
-#endif
-
-#include "win32.h"
-
-#include "alloc.h"
 #include "vkutil.h"
 
 int _vk_atoi(uint8_t *line, size_t n) {
@@ -61,32 +52,3 @@ int _vk_atoi(uint8_t *line, size_t n) {
 
     return value;
 }
-
-/*
- * Return the current time in microseconds since Epoch
- */
-int64_t vk_usec_now(void) {
-    int64_t usec;
-#ifdef _WIN32
-    LARGE_INTEGER counter, frequency;
-
-    if (!QueryPerformanceCounter(&counter) ||
-        !QueryPerformanceFrequency(&frequency)) {
-        return -1;
-    }
-
-    usec = counter.QuadPart * 1000000 / frequency.QuadPart;
-#else
-    struct timeval now;
-    int status;
-
-    status = gettimeofday(&now, NULL);
-    if (status < 0) {
-        return -1;
-    }
-
-    usec = (int64_t)now.tv_sec * 1000000LL + (int64_t)now.tv_usec;
-#endif
-
-    return usec;
-}

deps/libvalkey/src/vkutil.h

@@ -33,8 +33,14 @@
 #ifndef VALKEY_VKUTIL_H
 #define VALKEY_VKUTIL_H
 
+#include "win32.h"
+
+#include <stddef.h>
 #include <stdint.h>
-#include <sys/types.h>
+
+#ifndef _WIN32
+#include <sys/time.h>
+#endif
 
 /* Static assert macro for C99. */
 #define vk_static_assert(cond) extern char vk_static_assert[sizeof(char[(cond) ? 1 : -1])]
@@ -47,7 +53,25 @@
 
 int _vk_atoi(uint8_t *line, size_t n);
 
-int64_t vk_usec_now(void);
+/* Return the current time in microseconds since Epoch */
+static inline int64_t vk_usec_now(void) {
+    int64_t usec;
+#ifdef _WIN32
+    LARGE_INTEGER counter, frequency;
+    if (!QueryPerformanceCounter(&counter) ||
+        !QueryPerformanceFrequency(&frequency)) {
+        return -1;
+    }
+    usec = counter.QuadPart * 1000000 / frequency.QuadPart;
+#else
+    struct timeval now;
+    if (gettimeofday(&now, NULL) < 0) {
+        return -1;
+    }
+    usec = (int64_t)now.tv_sec * 1000000LL + (int64_t)now.tv_usec;
+#endif
+    return usec;
+}
 
 static inline int64_t vk_msec_now(void) {
     return vk_usec_now() / 1000;

deps/libvalkey/tests/CMakeLists.txt

@@ -58,8 +58,9 @@ endif()
 if(MSVC OR MINGW)
   find_library(LIBEVENT_LIBRARY Libevent)
 else()
-  # Use the Debug configuration when building tests (no -DNDEBUG)
-  set(CMAKE_BUILD_TYPE "Debug" CACHE STRING "" FORCE)
+  # Undefine any -DNDEBUG to make sure that tests can assert.
+  # CMake defines NDEBUG in Release and RelWithDebInfo.
+  add_compile_options("-UNDEBUG")
 endif()
 
 # Make sure ctest gives the output when tests fail
@@ -68,6 +69,7 @@ list(APPEND CMAKE_CTEST_ARGUMENTS "--output-on-failure")
 # Add non-cluster tests
 add_executable(client_test client_test.c)
 target_include_directories(client_test PRIVATE "${PROJECT_SOURCE_DIR}/src")
+target_link_libraries(client_test valkey_unittest)
 if(TLS_LIBRARY)
   target_compile_definitions(client_test PUBLIC VALKEY_TEST_TLS=1)
   target_link_libraries(client_test ${TLS_LIBRARY})
@@ -80,7 +82,6 @@ if(LIBEVENT_LIBRARY)
   target_compile_definitions(client_test PUBLIC VALKEY_TEST_ASYNC=1)
   target_link_libraries(client_test ${LIBEVENT_LIBRARY})
 endif()
-target_link_libraries(client_test valkey)
 
 add_test(NAME client_test COMMAND "${CMAKE_CURRENT_SOURCE_DIR}/test.sh")
 if(TEST_WITH_REDIS_VERSION)
@@ -99,12 +100,12 @@ endif()
 # Unit tests
 add_executable(ut_parse_cmd ut_parse_cmd.c test_utils.c)
 target_include_directories(ut_parse_cmd PRIVATE "${PROJECT_SOURCE_DIR}/src")
-target_link_libraries(ut_parse_cmd valkey)
+target_link_libraries(ut_parse_cmd valkey_unittest)
 add_test(NAME ut_parse_cmd COMMAND "$<TARGET_FILE:ut_parse_cmd>")
 
 add_executable(ut_slotmap_update ut_slotmap_update.c)
 target_include_directories(ut_slotmap_update PRIVATE "${PROJECT_SOURCE_DIR}/src")
-target_link_libraries(ut_slotmap_update valkey)
+target_link_libraries(ut_slotmap_update valkey_unittest)
 add_test(NAME ut_slotmap_update COMMAND "$<TARGET_FILE:ut_slotmap_update>")
 
 # Cluster tests

deps/libvalkey/tests/client_test.c

@@ -210,7 +210,7 @@ static valkeyContext *select_database(valkeyContext *c) {
         /* Awesome, DB 9 is empty and we can continue. */
         freeReplyObject(reply);
     } else {
-        printf("Database #9 is not empty, test can not continue\n");
+        printf("Database #9 is not empty, test cannot continue\n");
         exit(1);
     }
 
@@ -738,7 +738,7 @@ static void test_reply_reader(void) {
     freeReplyObject(reply);
     valkeyReaderFree(reader);
 
-    /* RESP3 push messages (Github issue #815) */
+    /* RESP3 push messages (GitHub issue #815) */
     test("Can parse RESP3 push messages: ");
     reader = valkeyReaderCreate();
     valkeyReaderFeed(reader, (char *)">2\r\n$6\r\nLOLWUT\r\n:42\r\n", 21);
@@ -1034,7 +1034,7 @@ static void test_allocator_injection(void) {
     valkeyResetAllocators();
 }
 
-#define VALKEY_BAD_DOMAIN "idontexist-noreally.com"
+#define VALKEY_BAD_DOMAIN "nonexistent.example.com"
 static void test_blocking_connection_errors(void) {
     struct addrinfo hints = {.ai_family = AF_INET};
     struct addrinfo *ai_tmp = NULL;
@@ -1091,7 +1091,7 @@ static void test_blocking_connection_errors(void) {
     valkeyFree(c);
 
     test("Returns error when the unix_sock socket path doesn't accept connections: ");
-    c = valkeyConnectUnix((char *)"/tmp/idontexist.sock");
+    c = valkeyConnectUnix((char *)"/tmp/nonexistent.sock");
     test_cond(c->err == VALKEY_ERR_IO); /* Don't care about the message... */
     valkeyFree(c);
 #endif
@@ -1787,7 +1787,7 @@ void ssubscribe_crossslot_error_cb(valkeyAsyncContext *ac, void *r, void *privda
 }
 
 /* Subscribe callback for test_sharded_pubsub_crossslot_handling:
- * - a published message triggers another ssubscribe to first channel and other slot chahhel
+ * - a published message triggers another ssubscribe to first channel and other slot channel
  * - after receiving CROSSLOT error send smessage to first channel
  * - a command is sent before the unsubscribe response is received. */
 void ssubscribe_crossslot_cb(valkeyAsyncContext *ac, void *r, void *privdata) {

deps/libvalkey/tests/clusterclient_async.c

@@ -57,7 +57,7 @@ int num_running = 0;
 int resend_failed_cmd = 0;
 int send_to_all = 0;
 int show_events = 0;
-int async_initial_update = 0;
+int blocking_initial_update = 0;
 
 void sendNextCommand(evutil_socket_t, short, void *);
 
@@ -80,7 +80,7 @@ void printReply(const valkeyReply *reply) {
 
 void replyCallback(valkeyClusterAsyncContext *acc, void *r, void *privdata) {
     valkeyReply *reply = (valkeyReply *)r;
-    intptr_t cmd_id = (intptr_t)privdata; /* Id to corresponding cmd */
+    intptr_t cmd_id = (intptr_t)privdata; /* ID for corresponding cmd */
 
     if (reply == NULL) {
         if (acc->err) {
@@ -251,8 +251,8 @@ int main(int argc, char **argv) {
             show_events = 1;
         } else if (strcmp(argv[optind], "--connection-events") == 0) {
             show_connection_events = 1;
-        } else if (strcmp(argv[optind], "--async-initial-update") == 0) {
-            async_initial_update = 1;
+        } else if (strcmp(argv[optind], "--blocking-initial-update") == 0) {
+            blocking_initial_update = 1;
         } else {
             fprintf(stderr, "Unknown argument: '%s'\n", argv[optind]);
         }
@@ -273,7 +273,7 @@ int main(int argc, char **argv) {
     options.command_timeout = &timeout;
     options.event_callback = eventCallback;
     options.max_retry = 1;
-    if (!async_initial_update) {
+    if (blocking_initial_update) {
         options.options = VALKEY_OPT_BLOCKING_INITIAL_UPDATE;
     }
     if (use_cluster_nodes) {

deps/libvalkey/tests/ct_connection.c

@@ -52,7 +52,8 @@ void test_password_ok(void) {
     ASSERT_MSG(cc && cc->err == 0, cc ? cc->errstr : "OOM");
     assert(connect_success_counter == 1); // for CLUSTER SLOTS
     load_valkey_version(cc);
-    assert(connect_success_counter == 2); // for checking valkey version
+    // Check that the initial slotmap update connection is reused.
+    assert(connect_success_counter == 1);
 
     // Test connection
     valkeyReply *reply;
@@ -62,7 +63,7 @@ void test_password_ok(void) {
     valkeyClusterFree(cc);
 
     // Check counters incremented by connect callback
-    assert(connect_success_counter == 3); // for SET (to a different node)
+    assert(connect_success_counter == 2); // for SET (to a different node)
     assert(connect_failure_counter == 0);
     reset_counters();
 }

deps/libvalkey/tests/ct_out_of_memory_handling.c

@@ -318,7 +318,7 @@ void test_alloc_failure_handling(void) {
         freeReplyObject(reply);
 
         /* Test ASK reply handling with OOM */
-        for (int i = 0; i < 30; ++i) {
+        for (int i = 0; i < 45; ++i) {
             prepare_allocation_test(cc, i);
             reply = valkeyClusterCommand(cc, "GET foo");
             assert(reply == NULL);
@@ -326,7 +326,7 @@ void test_alloc_failure_handling(void) {
         }
 
         /* Test ASK reply handling without OOM */
-        prepare_allocation_test(cc, 30);
+        prepare_allocation_test(cc, 45);
         reply = valkeyClusterCommand(cc, "GET foo");
         CHECK_REPLY_STR(cc, reply, "one");
         freeReplyObject(reply);
@@ -347,7 +347,7 @@ void test_alloc_failure_handling(void) {
         freeReplyObject(reply);
 
         /* Test MOVED reply handling with OOM */
-        for (int i = 0; i < 31; ++i) {
+        for (int i = 0; i < 32; ++i) {
             prepare_allocation_test(cc, i);
             reply = valkeyClusterCommand(cc, "GET foo");
             assert(reply == NULL);
@@ -355,7 +355,7 @@ void test_alloc_failure_handling(void) {
         }
 
         /* Test MOVED reply handling without OOM */
-        prepare_allocation_test(cc, 31);
+        prepare_allocation_test(cc, 32);
         reply = valkeyClusterCommand(cc, "GET foo");
         CHECK_REPLY_STR(cc, reply, "one");
         freeReplyObject(reply);

deps/libvalkey/tests/scripts/ask-redirect-connection-error-test.sh

@@ -20,9 +20,6 @@ timeout 5s ./simulated-valkey.pl -p 7401 -d --sigcont $syncpid1 <<'EOF' &
 EXPECT CONNECT
 EXPECT ["CLUSTER", "SLOTS"]
 SEND [[0, 16383, ["127.0.0.1", 7401, "nodeid123"]]]
-EXPECT CLOSE
-
-EXPECT CONNECT
 EXPECT ["SET", "foo", "initial"]
 SEND +OK
 
@@ -50,6 +47,7 @@ wait $syncpid1;
 # Run client
 timeout 4s "$clientprog" 127.0.0.1:7401 > "$testname.out" <<'EOF'
 SET foo initial
+!sleep
 
 !async
 SET foo timeout1

deps/libvalkey/tests/scripts/ask-redirect-test.sh

@@ -16,8 +16,6 @@ timeout 5s ./simulated-valkey.pl -p 7401 -d --sigcont $syncpid1 <<'EOF' &
 EXPECT CONNECT
 EXPECT ["CLUSTER", "SLOTS"]
 SEND [[0, 16383, ["127.0.0.1", 7401, "nodeid123"]]]
-EXPECT CLOSE
-EXPECT CONNECT
 EXPECT ["GET", "foo"]
 SEND -ASK 12182 127.0.0.1:7402
 # A second redirect is needed to test reuse of the new cluster node

deps/libvalkey/tests/scripts/ask-redirect-using-cluster-nodes-test.sh

@@ -48,7 +48,7 @@ server2=$!
 wait $syncpid1 $syncpid2;
 
 # Run client
-timeout 3s "$clientprog" --use-cluster-nodes 127.0.0.1:7400 > "$testname.out" <<'EOF'
+timeout 3s "$clientprog" --blocking-initial-update --use-cluster-nodes 127.0.0.1:7400 > "$testname.out" <<'EOF'
 GET foo
 GET foo
 EOF

deps/libvalkey/tests/scripts/client-disconnect-test.sh

@@ -35,7 +35,7 @@ server1=$!
 wait $syncpid1;
 
 # Run client
-timeout 4s "$clientprog" --connection-events 127.0.0.1:7401 > "$testname.out" <<'EOF'
+timeout 4s "$clientprog" --blocking-initial-update --connection-events 127.0.0.1:7401 > "$testname.out" <<'EOF'
 SET foo initial
 
 # Send a command that is expected to be redirected just before

deps/libvalkey/tests/scripts/client-disconnect-without-slotmap-update-test.sh

@@ -55,7 +55,7 @@ server2=$!
 wait $syncpid1 $syncpid2;
 
 # Run client
-timeout 4s "$clientprog" --connection-events 127.0.0.1:7401 > "$testname.out" <<'EOF'
+timeout 4s "$clientprog" --blocking-initial-update --connection-events 127.0.0.1:7401 > "$testname.out" <<'EOF'
 SET foo initial
 SET bar initial
 

deps/libvalkey/tests/scripts/cluster-down-test.sh

@@ -42,7 +42,7 @@ server2=$!
 wait $syncpid1 $syncpid2;
 
 # Run client
-timeout 4s "$clientprog" 127.0.0.1:7401 > "$testname.out" <<'EOF'
+timeout 4s "$clientprog" --blocking-initial-update 127.0.0.1:7401 > "$testname.out" <<'EOF'
 !async
 SET foo initial
 SET bar initial

deps/libvalkey/tests/scripts/cluster-scale-down-test.sh

@@ -36,22 +36,17 @@ timeout 5s ./simulated-valkey.pl -p 7401 -d --sigcont $syncpid1 <<'EOF' &
 EXPECT CONNECT
 EXPECT ["CLUSTER", "SLOTS"]
 SEND [[0, 5000, ["127.0.0.1", 7401, "nodeid1"]],[5001, 10000, ["127.0.0.1", 7402, "nodeid2"]],[10001, 16383, ["127.0.0.1", 7403, "nodeid3"]]]
-EXPECT CLOSE
 
 # The command "GET {foo}1" is first sent to the slot owner nodeid3, but since this
 # node does not exist the failed connection attempt will trigger a slotmap update.
-EXPECT CONNECT
 EXPECT ["CLUSTER", "SLOTS"]
 SEND [[0, 8000, ["127.0.0.1", 7401, "nodeid1"]],[8001, 16383, ["127.0.0.1", 7402, "nodeid2"]]]
-EXPECT CLOSE
 
 # The send failure of "GET {foo}2" schedules a slotmap update, which is
 # performed when (and just before) the next command "GET {foo}3" is sent.
-EXPECT CONNECT
 EXPECT ["CLUSTER", "SLOTS"]
 SEND [[0, 16383, ["127.0.0.1", 7401, "nodeid1"]]]
-EXPECT CLOSE
-EXPECT CONNECT
+
 EXPECT ["GET", "{foo}3"]
 SEND "bar3"
 EXPECT CLOSE

deps/libvalkey/tests/scripts/command-from-callback-test.sh

@@ -70,7 +70,7 @@ server3=$!
 wait $syncpid1 $syncpid2 $syncpid3;
 
 # Run client which resends failed commands in the reply callback
-timeout 4s "$clientprog" 127.0.0.1:7401 > "$testname.out" <<'EOF'
+timeout 4s "$clientprog" --blocking-initial-update 127.0.0.1:7401 > "$testname.out" <<'EOF'
 !resend
 !async
 GET foo

deps/libvalkey/tests/scripts/connect-during-cluster-startup-test.sh

@@ -4,7 +4,7 @@
 #
 # The first attempt to get the slotmap will receive a reply without any
 # slot information and this should result in a retry.
-# The following slotmap updates tests the handling of an nil/empty IP address.
+# The following slotmap updates tests the handling of a nil/empty IP address.
 #
 # The client is configured to use the CLUSTER SLOTS command.
 #
@@ -44,7 +44,7 @@ server=$!
 wait $syncpid;
 
 # Run client which will fetch the initial slotmap asynchronously.
-timeout 3s "$clientprog" --events --async-initial-update 127.0.0.1:7400 > "$testname.out" <<'EOF'
+timeout 3s "$clientprog" --events 127.0.0.1:7400 > "$testname.out" <<'EOF'
 # Slot not yet handled, will trigger a slotmap update which will be throttled.
 SET foo bar1
 

deps/libvalkey/tests/scripts/connect-during-cluster-startup-using-cluster-nodes-test.sh

@@ -37,7 +37,7 @@ server=$!
 wait $syncpid;
 
 # Run client which will fetch the initial slotmap asynchronously using CLUSTER NODES.
-timeout 3s "$clientprog" --events --use-cluster-nodes --async-initial-update 127.0.0.1:7400 > "$testname.out" <<'EOF'
+timeout 3s "$clientprog" --events --use-cluster-nodes 127.0.0.1:7400 > "$testname.out" <<'EOF'
 SET foo bar
 EOF
 clientexit=$?

deps/libvalkey/tests/scripts/connection-error-test.sh

@@ -44,7 +44,7 @@ server1=$!
 wait $syncpid1
 
 # Run client
-timeout 4s "$clientprog" 127.0.0.1:7401 > "$testname.out" <<'EOF'
+timeout 4s "$clientprog" --blocking-initial-update 127.0.0.1:7401 > "$testname.out" <<'EOF'
 SET bar initial
 
 # Send commands aimed for nodeid2

deps/libvalkey/tests/scripts/dbsize-to-all-nodes-during-scaledown-test-async.sh

@@ -53,7 +53,7 @@ server2=$!
 wait $syncpid1 $syncpid2;
 
 # Run client
-timeout 5s "$clientprog" 127.0.0.1:7401 > "$testname.out" <<'EOF'
+timeout 5s "$clientprog" --blocking-initial-update 127.0.0.1:7401 > "$testname.out" <<'EOF'
 !all
 DBSIZE
 DBSIZE

deps/libvalkey/tests/scripts/dbsize-to-all-nodes-during-scaledown-test.sh

@@ -25,8 +25,6 @@ timeout 5s ./simulated-valkey.pl -p 7401 -d --sigcont $syncpid1 <<'EOF' &
 EXPECT CONNECT
 EXPECT ["CLUSTER", "SLOTS"]
 SEND [[0, 8383, ["127.0.0.1", 7401, "nodeid7401"]], [8384, 16383, ["127.0.0.1", 7402, "nodeid7402"]]]
-EXPECT CLOSE
-EXPECT CONNECT
 EXPECT ["DBSIZE"]
 SEND 10
 EXPECT ["DBSIZE"]

deps/libvalkey/tests/scripts/dbsize-to-all-nodes-test.sh

@@ -16,8 +16,6 @@ timeout 5s ./simulated-valkey.pl -p 7403 -d --sigcont $syncpid1 <<'EOF' &
 EXPECT CONNECT
 EXPECT ["CLUSTER", "SLOTS"]
 SEND [[0, 8383, ["127.0.0.1", 7403, "nodeid7403"]], [8384, 16383, ["127.0.0.1", 7404, "nodeid7404"]]]
-EXPECT CLOSE
-EXPECT CONNECT
 EXPECT ["DBSIZE"]
 SEND 11
 EXPECT CLOSE

deps/libvalkey/tests/scripts/moved-redirect-test.sh

@@ -24,10 +24,10 @@ timeout 5s ./simulated-valkey.pl -p 7403 -d --sigcont $syncpid1 <<'EOF' &
 EXPECT CONNECT
 EXPECT ["CLUSTER", "SLOTS"]
 SEND [[0, 16383, ["127.0.0.1", 7403, "nodeid7403"]]]
-EXPECT CLOSE
+EXPECT ["GET", "foo"]
+SEND "bar"
 
 # Test 1: Handle MOVED redirect.
-EXPECT CONNECT
 EXPECT ["GET", "foo"]
 SEND -MOVED 12182 127.0.0.1:7404
 EXPECT ["CLUSTER", "SLOTS"]
@@ -54,6 +54,7 @@ EXPECT ["GET", "foo"]
 SEND -MOVED 9718 :7403
 EXPECT ["CLUSTER", "SLOTS"]
 SEND [[0, 16383, ["127.0.0.1", 7403, "nodeid7403"]]]
+
 EXPECT CLOSE
 EOF
 server2=$!
@@ -66,6 +67,8 @@ timeout 3s "$clientprog" --events 127.0.0.1:7403 > "$testname.out" <<'EOF'
 GET foo
 !sleep
 GET foo
+!sleep
+GET foo
 EOF
 clientexit=$?
 
@@ -90,6 +93,7 @@ fi
 # Check the output from clusterclient
 expected="Event: slotmap-updated
 Event: ready
+bar
 Event: slotmap-updated
 bar
 Event: slotmap-updated

deps/libvalkey/tests/scripts/moved-redirect-using-cluster-nodes-test.sh

@@ -42,7 +42,7 @@ server2=$!
 wait $syncpid1 $syncpid2;
 
 # Run client
-timeout 3s "$clientprog" --use-cluster-nodes 127.0.0.1:7400 > "$testname.out" <<'EOF'
+timeout 3s "$clientprog" --blocking-initial-update --use-cluster-nodes 127.0.0.1:7400 > "$testname.out" <<'EOF'
 GET foo
 EOF
 clientexit=$?

deps/libvalkey/tests/scripts/redirect-with-hostname-test.sh

@@ -28,10 +28,10 @@ timeout 5s ./simulated-valkey.pl -p 7401 -d --sigcont $syncpid1 <<'EOF' &
 EXPECT CONNECT
 EXPECT ["CLUSTER", "SLOTS"]
 SEND [[0, 16383, ["localhost", 7401, "nodeid1", ["ip", "192.168.254.254"]]]]
-EXPECT CLOSE
+EXPECT ["GET", "foo"]
+SEND "bar"
 
 # Verify ASK redirect
-EXPECT CONNECT
 EXPECT ["GET", "foo"]
 SEND -ASK 12182 localhost:7402
 
@@ -64,7 +64,12 @@ wait $syncpid1 $syncpid2;
 
 # Run client
 timeout 3s "$clientprog" localhost:7401 > "$testname.out" <<'EOF'
+# Trigger initial slotmap update
 GET foo
+!sleep
+# Verify ASK redirect
+GET foo
+# Verify MOVED redirect
 GET foo
 EOF
 clientexit=$?
@@ -88,7 +93,7 @@ if [ $clientexit -ne 0 ]; then
 fi
 
 # Check the output from clusterclient
-printf 'bar\nbar\n' | cmp "$testname.out" - || exit 99
+printf 'bar\nbar\nbar\n' | cmp "$testname.out" - || exit 99
 
 # Clean up
 rm "$testname.out"

deps/libvalkey/tests/scripts/redirect-with-ipv6-test.sh

@@ -19,10 +19,10 @@ timeout 5s ./simulated-valkey.pl -p 7401 --ipv6 -d --sigcont $syncpid1 <<'EOF' &
 EXPECT CONNECT
 EXPECT ["CLUSTER", "SLOTS"]
 SEND [[0, 16383, ["::1", 7401, "nodeid1"]]]
-EXPECT CLOSE
+EXPECT ["GET", "foo"]
+SEND "bar"
 
 # Verify ASK redirect
-EXPECT CONNECT
 EXPECT ["GET", "foo"]
 SEND -ASK 12182 ::1:7402
 
@@ -55,7 +55,12 @@ wait $syncpid1 $syncpid2;
 
 # Run client
 timeout 3s "$clientprog" ::1:7401 > "$testname.out" <<'EOF'
+# Trigger initial slotmap update
 GET foo
+!sleep
+# Verify ASK redirect
+GET foo
+# Verify MOVED redirect
 GET foo
 EOF
 clientexit=$?
@@ -79,7 +84,7 @@ if [ $clientexit -ne 0 ]; then
 fi
 
 # Check the output from clusterclient
-printf 'bar\nbar\n' | cmp "$testname.out" - || exit 99
+printf 'bar\nbar\nbar\n' | cmp "$testname.out" - || exit 99
 
 # Clean up
 rm "$testname.out"

deps/libvalkey/tests/scripts/set-get-test.sh

@@ -14,8 +14,6 @@ timeout 5s ./simulated-valkey.pl -p 7400 -d --sigcont $syncpid <<'EOF' &
 EXPECT CONNECT
 EXPECT ["CLUSTER", "SLOTS"]
 SEND [[0, 16383, ["127.0.0.1", 7400, "nodeid123"]]]
-EXPECT CLOSE
-EXPECT CONNECT
 EXPECT ["SET", "foo", "bar"]
 SEND +OK
 EXPECT ["GET", "foo"]

deps/libvalkey/tests/scripts/slots-not-served-test-async.sh

@@ -32,7 +32,7 @@ server1=$!
 wait $syncpid1;
 
 # Run client
-timeout 3s "$clientprog" --events 127.0.0.1:7401 > "$testname.out" <<'EOF'
+timeout 3s "$clientprog" --blocking-initial-update --events 127.0.0.1:7401 > "$testname.out" <<'EOF'
 GET foo
 # Allow slotmap update to finish.
 !sleep

deps/libvalkey/tests/scripts/slots-not-served-test.sh

@@ -15,23 +15,17 @@ timeout 5s ./simulated-valkey.pl -p 7401 -d --sigcont $syncpid1 <<'EOF' &
 EXPECT CONNECT
 EXPECT ["CLUSTER", "SLOTS"]
 SEND [[0, 1, ["127.0.0.1", 7401, "nodeid7401"]]]
-EXPECT CLOSE
 
 # Slotmap update due to the slot for `foo1` is not served.
 # The reply is still missing slots.
-EXPECT CONNECT
 EXPECT ["CLUSTER", "SLOTS"]
 SEND [[0, 1, ["127.0.0.1", 7401, "nodeid7401"]]]
-EXPECT CLOSE
 
 # Slotmap update due to the slot for `foo2` is not served.
 # The reply now has full slot coverage.
-EXPECT CONNECT
 EXPECT ["CLUSTER", "SLOTS"]
 SEND [[0, 16383, ["127.0.0.1", 7401, "nodeid7401"]]]
-EXPECT CLOSE
 
-EXPECT CONNECT
 EXPECT ["GET", "foo2"]
 SEND "bar2"
 EXPECT CLOSE

deps/libvalkey/tests/scripts/timeout-handling-test.sh

@@ -59,7 +59,7 @@ server2=$!
 wait $syncpid1 $syncpid2;
 
 # Run client
-timeout 4s "$clientprog" 127.0.0.1:7401 > "$testname.out" <<'EOF'
+timeout 4s "$clientprog" --blocking-initial-update 127.0.0.1:7401 > "$testname.out" <<'EOF'
 SET foo initial
 SET bar initial
 

deps/libvalkey/tests/test_utils.h

@@ -5,6 +5,8 @@
 #include <winsock2.h> /* For struct timeval */
 #endif
 
+#define UNUSED(x) (void)(x)
+
 #define ASSERT_MSG(_x, _msg)                            \
     if (!(_x)) {                                        \
         fprintf(stderr, "ERROR: %s (%s)\n", _msg, #_x); \

deps/linenoise/example.c

@@ -60,7 +60,7 @@ int main(int argc, char **argv) {
         /* Do something with the string. */
         if (line[0] != '\0' && line[0] != '/') {
             printf("echo: '%s'\n", line);
-            linenoiseHistoryAdd(line); /* Add to the history. */
+            linenoiseHistoryAdd(line, 0); /* Add to the history. */
             linenoiseHistorySave("history.txt"); /* Save the history on disk. */
         } else if (!strncmp(line,"/historylen",11)) {
             /* The "/historylen" command will change the history len. */

deps/linenoise/linenoise.c

@@ -708,6 +708,49 @@ void linenoiseEditMoveRight(struct linenoiseState *l) {
     }
 }
 
+/* People have different preferences on what is considered a word
+ * when editing commandline. For example, in command
+ * `set business:department:product value`,
+ * some might treat the entire long key as a word, while others
+ * treat it as 3 subwords and prefer granular word jumping navigation
+ * to make fixing a typo (e.g. "business:deaprtment:product") easier.
+ * In order to accommodate this, we treat escape sequences
+ * ESC b/f (usually Alt + ←/→ on MacOS, but you might get ESC[1;3D/C) and
+ * ESC[1;5D/C (usually Ctrl + ←/→) differently.
+ *
+ * Notice that the exact behavior of key mapping depends on your
+ * terminal/keyboard setup. To see how your environment maps keys
+ * to escape sequences, you can run command `cat -v` and then press
+ * arbitrary keys to see how they work.
+ */
+static int isSubWordDelimiter(const char c) {
+    return !isalnum(c);
+}
+static int isBigWordDelimiter(const char c) {
+    return isspace(c);
+}
+
+typedef int (*isDelimiterFunc)(char c);
+
+static void linenoiseEditMoveWordLeft(struct linenoiseState *l, const isDelimiterFunc isDelimiter) {
+    if (l->pos == 0) return;
+    /* Move cursor to the left over any delimiters */
+    while (l->pos > 0 && isDelimiter(l->buf[l->pos - 1])) l->pos--;
+    /* Then continue moving over a word */
+    while (l->pos > 0 && !isDelimiter(l->buf[l->pos - 1])) l->pos--;
+    refreshLine(l);
+}
+
+static void linenoiseEditMoveWordRight(struct linenoiseState *l, const isDelimiterFunc isDelimiter) {
+    if (l->pos == l->len) return;
+    /* Move cursor to the right over any delimiters */
+    while (l->pos < l->len && isDelimiter(l->buf[l->pos])) l->pos++;
+    /* Then continue moving over a word */
+    while (l->pos < l->len && !isDelimiter(l->buf[l->pos])) l->pos++;
+    refreshLine(l);
+}
+
+
 /* Move cursor to the start of the line. */
 void linenoiseEditMoveHome(struct linenoiseState *l) {
     if (l->pos != 0) {
@@ -901,20 +944,57 @@ static int linenoiseEdit(int stdin_fd, int stdout_fd, char *buf, size_t buflen,
              * Use two calls to handle slow terminals returning the two
              * chars at different times. */
             if (read(l.ifd,seq,1) == -1) break;
+
+            /* Handle Meta-b / Meta-f directly.
+             * Usually generated by Alt + ←/→ (but not always)
+             */
+            if (seq[0] == 'b') {                 /* ESC b → word left */
+                linenoiseEditMoveWordLeft(&l, isSubWordDelimiter);
+                break;
+            }
+            if (seq[0] == 'f') {                 /* ESC f → word right */
+                linenoiseEditMoveWordRight(&l, isSubWordDelimiter);
+                break;
+            }
+
             if (read(l.ifd,seq+1,1) == -1) break;
 
             /* ESC [ sequences. */
             if (seq[0] == '[') {
                 if (seq[1] >= '0' && seq[1] <= '9') {
-                    /* Extended escape, read additional byte. */
-                    if (read(l.ifd,seq+2,1) == -1) break;
-                    if (seq[2] == '~') {
-                        switch(seq[1]) {
-                        case '3': /* Delete key. */
-                            linenoiseEditDelete(&l);
+                    /* Extended escape, read additional bytes.
+                     * Examples: ESC [1;5C  ESC [3~ */
+                    const int seqBufferMaxLength = 8;
+                    char seqBuffer[seqBufferMaxLength];
+                    int i = 0;
+                    seqBuffer[i++] = seq[1];
+
+                    /* If first param is digit or ';', read more until we see a final in @~ */
+                    char additionalChar;
+                    while (i < seqBufferMaxLength-1 && read(l.ifd, &additionalChar, 1) != -1) {
+                        seqBuffer[i++] = additionalChar;
+                        if (additionalChar >= '@' && additionalChar <= '~') {    /* CSI final byte */
+                            seqBuffer[i] = '\0';
                             break;
                         }
                     }
+
+                    /* The exact key mapping behavior depends on your keyboard/terminal setup */
+                    /* Usually Alt/Ctrl + ← */
+                    if (!strcmp(seqBuffer, "1;5D") || !strcmp(seqBuffer, "1;3D")) {
+                        linenoiseEditMoveWordLeft(&l, isBigWordDelimiter);
+                        break;
+                    }
+                    /* Usually Alt/Ctrl + → */
+                    if (!strcmp(seqBuffer, "1;5C") || !strcmp(seqBuffer, "1;3C")) {
+                        linenoiseEditMoveWordRight(&l, isBigWordDelimiter);
+                        break;
+                    }
+                    /* Usually the `delete` key */
+                    if (!strcmp(seqBuffer, "3~")) {
+                        linenoiseEditDelete(&l);
+                        break;
+                    }
                 } else {
                     switch(seq[1]) {
                     case 'A': /* Up */

deps/lua/src/lbaselib.c

@@ -340,13 +340,14 @@ static int luaB_assert (lua_State *L) {
 
 
 static int luaB_unpack (lua_State *L) {
-  int i, e, n;
+  int i, e;
+  unsigned int n;
   luaL_checktype(L, 1, LUA_TTABLE);
   i = luaL_optint(L, 2, 1);
   e = luaL_opt(L, luaL_checkint, 3, luaL_getn(L, 1));
   if (i > e) return 0;  /* empty range */
-  n = e - i + 1;  /* number of elements */
-  if (n <= 0 || !lua_checkstack(L, n))  /* n <= 0 means arith. overflow */
+  n = (unsigned int)e - (unsigned int)i;  /* number of elements minus 1 */
+  if (n >= INT_MAX || !lua_checkstack(L, ++n))
     return luaL_error(L, "too many results to unpack");
   lua_rawgeti(L, 1, i);  /* push arg[i] (avoiding overflow problems) */
   while (i++ < e)  /* push arg[i + 1...e] */

deps/lua/src/llex.c

@@ -138,6 +138,7 @@ static void inclinenumber (LexState *ls) {
 
 
 void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source) {
+  ls->t.token = 0;
   ls->decpoint = '.';
   ls->L = L;
   ls->lookahead.token = TK_EOS;  /* no look-ahead token */
@@ -207,8 +208,13 @@ static void read_numeral (LexState *ls, SemInfo *seminfo) {
 }
 
 
-static int skip_sep (LexState *ls) {
-  int count = 0;
+/*
+** reads a sequence '[=*[' or ']=*]', leaving the last bracket.
+** If a sequence is well-formed, return its number of '='s + 2; otherwise,
+** return 1 if there is no '='s or 0 otherwise (an unfinished '[==...').
+*/
+static size_t skip_sep (LexState *ls) {
+  size_t count = 0;
   int s = ls->current;
   lua_assert(s == '[' || s == ']');
   save_and_next(ls);
@@ -216,11 +222,13 @@ static int skip_sep (LexState *ls) {
     save_and_next(ls);
     count++;
   }
-  return (ls->current == s) ? count : (-count) - 1;
+  return (ls->current == s) ? count + 2
+        : (count == 0) ? 1
+        : 0;
 }
 
 
-static void read_long_string (LexState *ls, SemInfo *seminfo, int sep) {
+static void read_long_string (LexState *ls, SemInfo *seminfo, size_t sep) {
   int cont = 0;
   (void)(cont);  /* avoid warnings when `cont' is not used */
   save_and_next(ls);  /* skip 2nd `[' */
@@ -270,8 +278,8 @@ static void read_long_string (LexState *ls, SemInfo *seminfo, int sep) {
     }
   } endloop:
   if (seminfo)
-    seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + (2 + sep),
-                                     luaZ_bufflen(ls->buff) - 2*(2 + sep));
+      seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + sep,
+                                    luaZ_bufflen(ls->buff) - 2 * sep);
 }
 
 
@@ -346,9 +354,9 @@ static int llex (LexState *ls, SemInfo *seminfo) {
         /* else is a comment */
         next(ls);
         if (ls->current == '[') {
-          int sep = skip_sep(ls);
+          size_t sep = skip_sep(ls);
           luaZ_resetbuffer(ls->buff);  /* `skip_sep' may dirty the buffer */
-          if (sep >= 0) {
+          if (sep >= 2) {
             read_long_string(ls, NULL, sep);  /* long comment */
             luaZ_resetbuffer(ls->buff);
             continue;
@@ -360,13 +368,14 @@ static int llex (LexState *ls, SemInfo *seminfo) {
         continue;
       }
       case '[': {
-        int sep = skip_sep(ls);
-        if (sep >= 0) {
+        size_t sep = skip_sep(ls);
+        if (sep >= 2) {
           read_long_string(ls, seminfo, sep);
           return TK_STRING;
         }
-        else if (sep == -1) return '[';
-        else luaX_lexerror(ls, "invalid long string delimiter", TK_STRING);
+        else if (sep == 0)  /* '[=...' missing second bracket */
+          luaX_lexerror(ls, "invalid long string delimiter", TK_STRING);
+        return '[';
       }
       case '=': {
         next(ls);

deps/lua/src/lparser.c

@@ -384,13 +384,17 @@ Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {
   struct LexState lexstate;
   struct FuncState funcstate;
   lexstate.buff = buff;
-  luaX_setinput(L, &lexstate, z, luaS_new(L, name));
+  TString *tname = luaS_new(L, name);
+  setsvalue2s(L, L->top, tname);
+  incr_top(L);
+  luaX_setinput(L, &lexstate, z, tname);
   open_func(&lexstate, &funcstate);
   funcstate.f->is_vararg = VARARG_ISVARARG;  /* main func. is always vararg */
   luaX_next(&lexstate);  /* read first token */
   chunk(&lexstate);
   check(&lexstate, TK_EOS);
   close_func(&lexstate);
+  --L->top;
   lua_assert(funcstate.prev == NULL);
   lua_assert(funcstate.f->nups == 0);
   lua_assert(lexstate.fs == NULL);

deps/lua/src/ltable.c

@@ -434,8 +434,7 @@ static TValue *newkey (lua_State *L, Table *t, const TValue *key) {
 ** search function for integers
 */
 const TValue *luaH_getnum (Table *t, int key) {
-  /* (1 <= key && key <= t->sizearray) */
-  if (cast(unsigned int, key-1) < cast(unsigned int, t->sizearray))
+  if (1 <= key && key <= t->sizearray)
     return &t->array[key-1];
   else {
     lua_Number nk = cast_num(key);

runtest

@@ -1,5 +1,5 @@
 #!/bin/sh
-TCL_VERSIONS="8.5 8.6 8.7"
+TCL_VERSIONS="8.5 8.6 9.0"
 TCLSH=""
 
 for VERSION in $TCL_VERSIONS; do

runtest-cluster

@@ -1,5 +1,5 @@
 #!/bin/sh
-TCL_VERSIONS="8.5 8.6 8.7"
+TCL_VERSIONS="8.5 8.6 9.0"
 TCLSH=""
 
 for VERSION in $TCL_VERSIONS; do

runtest-moduleapi

@@ -1,5 +1,5 @@
 #!/bin/sh
-TCL_VERSIONS="8.5 8.6 8.7"
+TCL_VERSIONS="8.5 8.6 9.0"
 TCLSH=""
 [ -z "$MAKE" ] && MAKE=make
 

runtest-sentinel

@@ -1,5 +1,5 @@
 #!/bin/sh
-TCL_VERSIONS="8.5 8.6 8.7"
+TCL_VERSIONS="8.5 8.6 9.0"
 TCLSH=""
 
 for VERSION in $TCL_VERSIONS; do