Windows CI for Java

.github/json_matrices/build-matrix.json

@@ -81,5 +81,15 @@
         "IMAGE": "amazonlinux:latest",
         "PACKAGE_MANAGERS": [],
         "languages": ["python", "node", "java", "go"]
+    },
+    {
+        "OS": "windows",
+        "NAMED_OS": "windows",
+        "RUNNER": "windows-latest",
+        "ARCH": "x64",
+        "TARGET": "x86_64-pc-windows-msvc",
+        "PACKAGE_MANAGERS": ["maven"],
+        "languages": ["java"],
+        "run": "always"
     }
 ]

.github/workflows/create-test-matrices/action.yml

@@ -78,8 +78,8 @@ runs:
               echo 'Select runners (VMs) to run tests on'
 
               if [[ "$EVENT_NAME" == "pull_request" || "$EVENT_NAME" == "push" || "$RUN_FULL_MATRIX" == "false" ]]; then
-                echo 'Getting "always run" runners'
-                BASE_MATRIX=$(jq -c '[.[] | select(.run == "always")]' < .github/json_matrices/build-matrix.json)
+                echo 'Getting "always run" runners for this language'
+                BASE_MATRIX=$(jq --arg lang "$LANGUAGE_NAME" -c '[.[] | select(.run == "always" and .languages? and any(.languages[] == $lang; .) and '"$CONDITION"')]' < .github/json_matrices/build-matrix.json)
               else
                 echo 'Getting full matrix for language excluding macOS'
                 BASE_MATRIX=$(jq --arg lang "$LANGUAGE_NAME" -c '[.[] | select(.languages? and any(.languages[] == $lang; .) and '"$CONDITION"' and .TARGET != "aarch64-apple-darwin")]' < .github/json_matrices/build-matrix.json)

.github/workflows/go.yml

@@ -152,8 +152,10 @@ jobs:
 
             - name: Install & build & test
               working-directory: go
+              shell: bash
               env:
                   RC_VERSION: ${{ github.event.inputs.rc-version }}
+                  CARGO_BUILD_JOBS: 1
               run: |
                   if [[ -n "$RC_VERSION" ]]; then
                     make install-tools
@@ -223,6 +225,8 @@ jobs:
 
             - name: Install and run linters
               working-directory: go
+              env:
+                  CARGO_BUILD_JOBS: 1
               run: |
                   make install-dev-tools install-build-tools gen-c-bindings generate-protobuf lint-ci
 
@@ -384,6 +388,7 @@ jobs:
 
             - name: Build and test
               working-directory: ./go
+              shell: bash
               env:
                   RC_VERSION: ${{ github.event.inputs.rc-version }}
               run: |
@@ -457,6 +462,7 @@ jobs:
 
             - name: Install & build & test
               working-directory: go
+              shell: bash
               env:
                   RC_VERSION: ${{ github.event.inputs.rc-version }}
               run: |

.github/workflows/install-rust-and-protoc/action.yml

@@ -11,6 +11,7 @@ inputs:
             - aarch64-unknown-linux-gnu
             - x86_64-apple-darwin
             - aarch64-apple-darwin
+            - x86_64-pc-windows-msvc
     github-token:
         description: "GitHub token"
         type: string

.github/workflows/install-shared-dependencies/action.yml

@@ -9,6 +9,7 @@ inputs:
             - amazon-linux
             - macos
             - ubuntu
+            - windows
     target:
         description: "Specified target for rust toolchain, ex. x86_64-apple-darwin"
         type: string
@@ -21,10 +22,15 @@ inputs:
             - aarch64-apple-darwin
             - aarch64-unknown-linux-musl
             - x86_64-unknown-linux-musl
+            - x86_64-pc-windows-msvc
     engine-version:
         description: "Engine version to install"
         required: false
         type: string
+    language:
+        description: "The language being built (optional, for language-specific setup)"
+        required: false
+        type: string
     github-token:
         description: "GITHUB_TOKEN, GitHub App installation access token"
         required: true
@@ -62,19 +68,140 @@ runs:
           run: |
               yum install -y gcc pkgconfig openssl openssl-devel which curl gettext libasan tar --allowerasing
 
-        - name: Install Rust toolchain and protoc
-          if: "${{ !contains(inputs.target, 'musl') }}"
-          uses: ./.github/workflows/install-rust-and-protoc
+        - name: Install software dependencies for Windows
+          shell: pwsh
+          if: "${{ inputs.os == 'windows' }}"
+          run: |
+              # Verify Rust toolchain is available
+              rustc --version
+              cargo --version
+
+        - name: Setup Python for Windows
+          if: "${{ inputs.os == 'windows' }}"
+          uses: actions/setup-python@v5
           with:
-              target: ${{ inputs.target }}
-              github-token: ${{ inputs.github-token }}
+              python-version: "3.x"
+
+        - name: Setup WSL (Windows only)
+          if: "${{ inputs.os == 'windows' && inputs.engine-version }}"
+          uses: Vampire/setup-wsl@v6
+          with:
+              distribution: Ubuntu-22.04
+              use-cache: true
+              update: true
+              additional-packages: build-essential git pkg-config libssl-dev python3 python3-pip
+
+        - name: Optimize WSL for better performance (Windows)
+          if: "${{ inputs.os == 'windows' && inputs.engine-version }}"
+          shell: pwsh
+          run: |
+              # Optimize WSL for better performance before engine installation
+              Write-Host "Optimizing WSL configuration for engine build..."
+
+              # Create WSL config for better performance
+              $wslConfig = @"
+              [wsl2]
+              memory=6GB
+              processors=4
+              swap=2GB
+              localhostForwarding=true
+              "@
+              $wslConfig | Out-File -FilePath "$env:USERPROFILE\.wslconfig" -Encoding utf8
+
+              # Restart WSL to apply config
+              wsl --shutdown
+              Start-Sleep -Seconds 3
+
+              Write-Host "WSL optimization complete - ready for engine build"
+
+        - name: Cache Valkey build
+          if: "${{ inputs.engine-version }}"
+          uses: actions/cache@v4
+          id: cache-valkey
+          with:
+              path: |
+                  valkey-cache/valkey-server
+                  valkey-cache/valkey-cli
+                  valkey-cache/valkey-benchmark
+              key: valkey-${{ inputs.engine-version }}-${{ inputs.os }}-${{ inputs.target }}-${{ github.sha }}
+              restore-keys: |
+                  valkey-${{ inputs.engine-version }}-${{ inputs.os }}-${{ inputs.target }}-
 
         - name: Install engine
+          shell: ${{ inputs.os == 'windows' && 'wsl-bash {0}' || 'bash' }}
+          if: "${{ inputs.engine-version && steps.cache-valkey.outputs.cache-hit == 'true' }}"
+          env:
+              ENGINE_VERSION: ${{ inputs.engine-version }}
+              OS_TYPE: ${{ inputs.os }}
+              WSLENV: ENGINE_VERSION:OS_TYPE
+          run: |
+              echo "Using cached Valkey binaries"
+              echo "OS_TYPE: '$OS_TYPE'"
+              echo "ENGINE_VERSION: '$ENGINE_VERSION'"
+              # Clone repo fresh
+              git clone https://github.com/valkey-io/valkey.git
+              cd valkey && git checkout "$ENGINE_VERSION"
+              # Move cached binaries to correct location (force overwrite)
+              mkdir -p src
+              cp -f ../valkey-cache/* src/ 2>/dev/null || true
+              # Install the cached binaries
+              sudo make install
+
+        - name: Build engine from source
+          shell: ${{ inputs.os == 'windows' && 'wsl-bash {0}' || 'bash' }}
+          if: "${{ inputs.engine-version && steps.cache-valkey.outputs.cache-hit != 'true' }}"
+          env:
+              ENGINE_VERSION: ${{ inputs.engine-version }}
+              OS_TYPE: ${{ inputs.os }}
+              WSLENV: ENGINE_VERSION:OS_TYPE
+          run: |
+              echo "Building Valkey from source"
+              echo "OS_TYPE: '$OS_TYPE'"
+              echo "ENGINE_VERSION: '$ENGINE_VERSION'"
+              # Install dependencies (only needed on Linux, Windows handled by Vampire)
+              if [ "$OS_TYPE" != "windows" ]; then
+                  sudo apt install -y build-essential git pkg-config libssl-dev
+              fi
+              git clone https://github.com/valkey-io/valkey.git
+              cd valkey && git checkout "$ENGINE_VERSION" && make -j$(nproc) BUILD_TLS=yes
+              # Cache the built binaries - detect which naming convention is used
+              mkdir -p ../valkey-cache
+              if [ -f "src/valkey-server" ]; then
+                  echo "Found Valkey binaries"
+                  cp -f src/valkey-server src/valkey-cli src/valkey-benchmark ../valkey-cache/ 2>/dev/null || true
+              elif [ -f "src/redis-server" ]; then
+                  echo "Found Redis binaries"
+                  cp -f src/redis-server src/redis-cli src/redis-benchmark ../valkey-cache/ 2>/dev/null || true
+              else
+                  echo "Warning: No server binaries found to cache"
+              fi
+              # Install the binaries
+              sudo make install
+
+        - name: Start engine server
+          shell: ${{ inputs.os == 'windows' && 'wsl-bash {0}' || 'bash' }}
           if: "${{ inputs.engine-version }}"
-          uses: ./.github/workflows/install-engine
+          env:
+              OS_TYPE: ${{ inputs.os }}
+              WSLENV: OS_TYPE
+          run: |
+              echo "Starting Valkey server"
+              echo "OS_TYPE: '$OS_TYPE'"
+
+              # Start Valkey server in background
+              redis-server --daemonize yes --bind 0.0.0.0 --port 6379
+
+              # For Windows, write IP to a file that PowerShell can read
+              if [ "$OS_TYPE" = "windows" ]; then
+                  hostname -I | awk '{print $1}' > /tmp/wsl_ip.txt
+              fi
+
+        - name: Install Rust toolchain and protoc
+          if: "${{ !contains(inputs.target, 'musl') }}"
+          uses: ./.github/workflows/install-rust-and-protoc
           with:
-              engine-version: ${{ inputs.engine-version }}
               target: ${{ inputs.target }}
+              github-token: ${{ inputs.github-token }}
 
         - name: Install zig
           if: ${{ contains(inputs.target, 'linux-gnu') }}

.github/workflows/java.yml

@@ -94,7 +94,7 @@ jobs:
     test-java:
         name: Java Tests - ${{ matrix.java }}, EngineVersion - ${{ matrix.engine.version }}, Target - ${{ matrix.host.TARGET }}
         needs: get-matrices
-        timeout-minutes: 35
+        timeout-minutes: ${{ matrix.host.OS == 'windows' && 60 || 35 }}
         strategy:
             fail-fast: false
             matrix:
@@ -126,6 +126,7 @@ jobs:
                   target: ${{ matrix.host.TARGET }}
                   github-token: ${{ secrets.GITHUB_TOKEN }}
                   engine-version: ${{ matrix.engine.version }}
+                  language: java
 
             - name: Install protoc (protobuf)
               uses: arduino/setup-protoc@v3
@@ -153,13 +154,34 @@ jobs:
                   restore-keys: |
                       ${{ runner.os }}-gradle-
 
+            - name: Setup Python3 for Windows
+              if: ${{ matrix.host.OS == 'windows' }}
+              shell: bash
+              run: |
+                  # Create python3 symlink for Windows
+                  ln -sf $(which python) /usr/bin/python3
+
             - name: Build java client
               working-directory: java
-              run: ./gradlew --build-cache --continue build -x javadoc
+              env:
+                  CARGO_BUILD_JOBS: ${{ github.runner_cores || '2' }}
+              shell: bash
+              run: |
+                  if [[ "${{ matrix.host.OS }}" == "windows" ]]; then
+                      ./gradlew.bat --build-cache --continue build -x javadoc
+                  else
+                      ./gradlew --build-cache --continue build -x javadoc
+                  fi
 
             - name: Ensure no skipped files by linter
               working-directory: java
-              run: ./gradlew --build-cache spotlessDiagnose | grep 'All formatters are well behaved for all files'
+              shell: bash
+              run: |
+                  if [[ "${{ matrix.host.OS }}" == "windows" ]]; then
+                      ./gradlew.bat --build-cache spotlessDiagnose | grep 'All formatters are well behaved for all files'
+                  else
+                      ./gradlew --build-cache spotlessDiagnose | grep 'All formatters are well behaved for all files'
+                  fi
 
             - uses: ./.github/workflows/test-benchmark
               if: ${{ matrix.engine.version == '8.0' && matrix.host.RUNNER == 'ubuntu-latest' && matrix.java == '17' }}
@@ -182,7 +204,7 @@ jobs:
     test-pubsub:
         name: Java PubSubTests - ${{ matrix.java }}, EngineVersion - ${{ matrix.engine.version }}, Target - ${{ matrix.host.TARGET }}
         needs: get-matrices
-        timeout-minutes: 35
+        timeout-minutes: ${{ matrix.host.OS == 'windows' && 60 || 35 }}
         strategy:
             fail-fast: false
             matrix:
@@ -212,6 +234,7 @@ jobs:
                   target: ${{ matrix.host.TARGET }}
                   github-token: ${{ secrets.GITHUB_TOKEN }}
                   engine-version: ${{ matrix.engine.version }}
+                  language: java
 
             - name: Install protoc (protobuf)
               uses: arduino/setup-protoc@v3
@@ -239,9 +262,38 @@ jobs:
                   restore-keys: |
                       ${{ runner.os }}-gradle-
 
+            - name: Setup networking and verify Valkey for PubSub (Windows)
+              if: ${{ matrix.host.OS == 'windows' }}
+              shell: pwsh
+              run: |
+                  # Optimize WSL for better performance (PubSub tests)
+                  Write-Host "Optimizing WSL configuration for PubSub tests..."
+
+                  # Create WSL config for better performance
+                  $wslConfig = @"
+                  [wsl2]
+                  memory=6GB
+                  processors=4
+                  swap=2GB
+                  localhostForwarding=true
+                  "@
+                  $wslConfig | Out-File -FilePath "$env:USERPROFILE\.wslconfig" -Encoding utf8
+
+                  # Restart WSL to apply config
+                  wsl --shutdown
+                  Start-Sleep -Seconds 3
+
+                  Write-Host "WSL optimization complete"
+
             - name: Test pubsub
               working-directory: java
-              run: ./gradlew --build-cache :integTest:pubsubTest
+              shell: bash
+              run: |
+                  if [[ "${{ matrix.host.OS }}" == "windows" ]]; then
+                      ./gradlew.bat --build-cache :integTest:pubsubTest
+                  else
+                      ./gradlew --build-cache :integTest:pubsubTest
+                  fi
 
             - name: Upload test & spotbugs reports
               if: always()
@@ -319,6 +371,7 @@ jobs:
                   os: ${{ matrix.host.OS }}
                   target: ${{ matrix.host.TARGET }}
                   github-token: ${{ secrets.GITHUB_TOKEN }}
+                  language: java
                   engine-version: ${{ matrix.engine.version }}
 
             - name: Install protoc (protobuf)
@@ -361,6 +414,7 @@ jobs:
               working-directory: java
               env:
                   GLIDE_CONTAINER_BUILD: true
+                  CARGO_BUILD_JOBS: ${{ github.runner_cores || '2' }}
               run: |
                   if [[ "${{ matrix.host.OS }}" == "amazon-linux" ]]; then
                       export JAVA_HOME=/usr/lib/jvm/java-${{matrix.java}}-amazon-corretto.x86_64