ci.yml

name: CI

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]
  workflow_dispatch:

jobs:
  build:
    name: ${{ matrix.os }} / ${{ matrix.compiler }}
    runs-on: ${{ matrix.os }}
    timeout-minutes: 60

    env:
      BUILD_TYPE: Debug
      VCPKG_BINARY_SOURCES: "clear;x-gha,readwrite"
      VCPKG_FEATURE_FLAGS: "manifests,registries,versions,binarycaching"

    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-24.04
            compiler: gcc
            triplet: x64-linux
          # Note: Ubuntu clang removed due to incomplete std::format support
          # when using libstdc++ (default on Ubuntu). C++20 std::format requires
          # either GCC 13+, MSVC, or Clang with libc++.
          - os: macos-14
            compiler: clang
            triplet: arm64-osx
          - os: windows-2022
            compiler: msvc
            triplet: x64-windows

    steps:
    - name: Checkout code
      uses: actions/checkout@v4
      with:
        submodules: recursive
        persist-credentials: true
        clean: true
        fetch-depth: 1
        token: ${{ secrets.GITHUB_TOKEN }}

    # Dependencies are cloned from HEAD of each repo's default branch.
    # If a dependency has test failures, they must be fixed upstream first.
    # To debug: check the "Log dependency versions" step for exact commits used.
    - name: Checkout dependencies (Unix)
      if: runner.os != 'Windows'
      run: |
        cd ..
        git clone --depth 1 https://github.com/kcenon/common_system.git
        git clone --depth 1 https://github.com/kcenon/thread_system.git
        git clone --depth 1 https://github.com/kcenon/logger_system.git
        git clone --depth 1 https://github.com/kcenon/container_system.git
        git clone --depth 1 https://github.com/kcenon/network_system.git
        git clone --depth 1 https://github.com/kcenon/monitoring_system.git

    - name: Checkout dependencies (Windows)
      if: runner.os == 'Windows'
      shell: pwsh
      run: |
        cd ..
        git clone --depth 1 https://github.com/kcenon/common_system.git
        git clone --depth 1 https://github.com/kcenon/thread_system.git
        git clone --depth 1 https://github.com/kcenon/logger_system.git
        git clone --depth 1 https://github.com/kcenon/container_system.git
        git clone --depth 1 https://github.com/kcenon/network_system.git
        git clone --depth 1 https://github.com/kcenon/monitoring_system.git

    - name: Log dependency versions (Unix)
      if: runner.os != 'Windows'
      run: |
        echo "=== Dependency commits cloned for this CI run ==="
        for dep in common_system thread_system logger_system container_system network_system monitoring_system; do
          commit=$(git -C "../$dep" rev-parse HEAD)
          echo "$dep: $commit"
        done

    - name: Log dependency versions (Windows)
      if: runner.os == 'Windows'
      shell: pwsh
      run: |
        Write-Host "=== Dependency commits cloned for this CI run ==="
        foreach ($dep in @("common_system","thread_system","logger_system","container_system","network_system","monitoring_system")) {
          $commit = git -C "../$dep" rev-parse HEAD
          Write-Host "${dep}: $commit"
        }

    - name: Install dependencies (Ubuntu)
      if: runner.os == 'Linux'
      run: |
        sudo apt update
        sudo apt install -y cmake build-essential gdb pkg-config curl zip unzip tar autoconf automake autoconf-archive ninja-build
        sudo apt install -y clang lld
        sudo apt install -y libgtest-dev libgmock-dev libyaml-cpp-dev

    - name: Install dependencies (macOS)
      if: runner.os == 'macOS'
      run: |
        brew install ninja pkg-config curl zip unzip autoconf automake autoconf-archive yaml-cpp googletest

    - name: Setup Visual Studio (Windows)
      if: runner.os == 'Windows'
      uses: microsoft/setup-msbuild@v2

    - name: Setup Visual Studio environment (Windows)
      if: runner.os == 'Windows'
      uses: ilammy/msvc-dev-cmd@v1
      with:
        arch: x64

    - name: Check architecture (Linux)
      if: runner.os == 'Linux'
      run: |
        if [ "$(uname -m)" = "aarch64" ]; then
          echo "VCPKG_FORCE_SYSTEM_BINARIES=arm" >> $GITHUB_ENV
        fi

    - name: Cache vcpkg
      uses: actions/cache@v4
      id: vcpkg-cache
      with:
        path: |
          ${{ github.workspace }}/vcpkg
          !${{ github.workspace }}/vcpkg/buildtrees
          !${{ github.workspace }}/vcpkg/packages
          !${{ github.workspace }}/vcpkg/downloads
        key: ${{ runner.os }}-${{ matrix.compiler }}-vcpkg-tool-${{ hashFiles('vcpkg.json') }}
        restore-keys: |
          ${{ runner.os }}-${{ matrix.compiler }}-vcpkg-tool-

    - name: Set up vcpkg (Unix)
      if: runner.os != 'Windows'
      run: |
        if [ ! -d "vcpkg" ]; then
          git clone https://github.com/Microsoft/vcpkg.git
        fi
        cd vcpkg
        if [ "${{ steps.vcpkg-cache.outputs.cache-hit }}" != "true" ]; then
          git pull
          ./bootstrap-vcpkg.sh
        fi
        cd ..

    - name: Set up vcpkg (Windows)
      if: runner.os == 'Windows'
      shell: pwsh
      run: |
        if (!(Test-Path "vcpkg")) {
          git clone https://github.com/Microsoft/vcpkg.git
        }
        cd vcpkg
        if ("${{ steps.vcpkg-cache.outputs.cache-hit }}" -ne "true") {
          git pull
          .\bootstrap-vcpkg.bat
        }
        cd ..

    - name: Determine vcpkg commit (Unix)
      if: runner.os != 'Windows'
      id: vcpkg-commit-unix
      run: echo "commit=$(git -C vcpkg rev-parse HEAD)" >> $GITHUB_OUTPUT

    - name: Determine vcpkg commit (Windows)
      if: runner.os == 'Windows'
      id: vcpkg-commit-windows
      shell: pwsh
      run: |
        $commit = git -C vcpkg rev-parse HEAD
        "commit=$commit" >> $env:GITHUB_OUTPUT

    # Cache vcpkg_installed for Unix only (Windows uses vcpkg binary caching via x-gha)
    - name: Cache vcpkg installed (Unix)
      if: runner.os != 'Windows'
      uses: actions/cache@v4
      id: vcpkg-installed
      with:
        path: ${{ github.workspace }}/vcpkg_installed
        key: ${{ runner.os }}-${{ matrix.compiler }}-vcpkg-installed-${{ matrix.triplet }}-testing-${{ hashFiles('vcpkg.json', 'vcpkg-configuration.json') }}-${{ steps.vcpkg-commit-unix.outputs.commit }}
        restore-keys: |
          ${{ runner.os }}-${{ matrix.compiler }}-vcpkg-installed-${{ matrix.triplet }}-testing-

    - name: Install dependencies with vcpkg (Unix)
      if: runner.os != 'Windows' && steps.vcpkg-installed.outputs.cache-hit != 'true'
      run: |
        ./vcpkg/vcpkg install --x-manifest-root=. --x-install-root=${{ github.workspace }}/vcpkg_installed --triplet ${{ matrix.triplet }} --x-feature=testing || echo "vcpkg install failed, will use system libraries"

    # Windows: vcpkg toolchain handles installation in manifest mode
    # Uses binary caching (VCPKG_BINARY_SOURCES) for build speed

    - name: Prepare build directory
      if: runner.os != 'Windows'
      run: |
        rm -rf build
        mkdir -p build

    - name: Prepare build directory (Windows)
      if: runner.os == 'Windows'
      shell: pwsh
      run: |
        if (Test-Path build) { Remove-Item -Recurse -Force build }
        New-Item -ItemType Directory -Path build

    - name: Configure CMake (Unix)
      if: runner.os != 'Windows'
      run: |
        cd build
        cmake .. \
          -G Ninja \
          -DMESSAGING_BUILD_TESTS=ON \
          -DMESSAGING_BUILD_EXAMPLES=OFF \
          -DMESSAGING_USE_LOCAL_SYSTEMS=ON \
          -DCMAKE_BUILD_TYPE=$BUILD_TYPE \
          -DCMAKE_C_COMPILER=${{ matrix.compiler == 'gcc' && 'gcc' || 'clang' }} \
          -DCMAKE_CXX_COMPILER=${{ matrix.compiler == 'gcc' && 'g++' || 'clang++' }}

    - name: Configure CMake (Windows)
      if: runner.os == 'Windows'
      shell: pwsh
      run: |
        cd build
        cmake .. `
          -G "Visual Studio 17 2022" `
          -A x64 `
          -DMESSAGING_BUILD_TESTS=ON `
          -DMESSAGING_BUILD_INTEGRATION_TESTS=OFF `
          -DMESSAGING_BUILD_EXAMPLES=OFF `
          -DMESSAGING_USE_LOCAL_SYSTEMS=ON `
          -DCMAKE_BUILD_TYPE=$env:BUILD_TYPE `
          -DCMAKE_TOOLCHAIN_FILE=${{ github.workspace }}\vcpkg\scripts\buildsystems\vcpkg.cmake `
          -DVCPKG_TARGET_TRIPLET=${{ matrix.triplet }} `
          -DVCPKG_MANIFEST_FEATURES=testing

    - name: Build (Unix)
      if: runner.os != 'Windows'
      run: |
        cd build
        cmake --build . --parallel

    - name: Build (Windows)
      if: runner.os == 'Windows'
      shell: pwsh
      run: |
        cd build
        # Use maximum available CPU cores for faster build
        $cores = (Get-CimInstance Win32_ComputerSystem).NumberOfLogicalProcessors
        Write-Host "Building with $cores parallel jobs"
        cmake --build . --config $env:BUILD_TYPE --parallel $cores

    - name: Run tests (Unix)
      if: runner.os != 'Windows'
      run: |
        cd build
        # On Linux, exclude task integration tests due to known threading issues
        # These tests pass on macOS and Windows but have issues on Linux
        if [ "$RUNNER_OS" = "Linux" ]; then
          ctest --output-on-failure --timeout 120 \
            -E "TaskLifecycleTest|WorkerScenariosTest|FailureRecoveryTest|SchedulingTest|ConcurrentLoadTest"
        else
          ctest --output-on-failure --timeout 120
        fi

    - name: Run tests (Windows)
      if: runner.os == 'Windows'
      shell: pwsh
      run: |
        cd build
        # Exclude test_request_reply due to known flaky behavior on Windows
        ctest -C $env:BUILD_TYPE --output-on-failure --timeout 120 --parallel 4 -E "test_request_reply"
        if ($LASTEXITCODE -ne 0) {
          Write-Host "::error::Some tests failed on Windows"
          exit $LASTEXITCODE
        }

    - name: Upload test results
      if: always()
      uses: actions/upload-artifact@v4
      with:
        name: test-results-${{ matrix.os }}-${{ matrix.compiler }}
        path: |
          build/Testing/
          build/**/*.log
        retention-days: 7
        if-no-files-found: ignore

    - name: Upload build artifacts on failure
      if: failure()
      uses: actions/upload-artifact@v4
      with:
        name: build-failure-${{ matrix.os }}-${{ matrix.compiler }}
        path: |
          build/CMakeFiles/CMakeOutput.log
          build/CMakeFiles/CMakeError.log
          build/**/*.log
        retention-days: 7
        if-no-files-found: ignore

  # Build without network_system (stub mode)
  build-without-network:
    name: Build without network_system
    runs-on: ubuntu-24.04
    timeout-minutes: 30

    env:
      BUILD_TYPE: Debug

    steps:
    - name: Checkout code
      uses: actions/checkout@v4
      with:
        submodules: recursive
        persist-credentials: true
        clean: true
        fetch-depth: 1
        token: ${{ secrets.GITHUB_TOKEN }}

    - name: Checkout dependencies (without network_system)
      run: |
        cd ..
        git clone --depth 1 https://github.com/kcenon/common_system.git
        git clone --depth 1 https://github.com/kcenon/thread_system.git
        git clone --depth 1 https://github.com/kcenon/logger_system.git
        git clone --depth 1 https://github.com/kcenon/container_system.git
        git clone --depth 1 https://github.com/kcenon/monitoring_system.git
        # Note: network_system is intentionally not cloned

    - name: Install dependencies
      run: |
        sudo apt update
        sudo apt install -y cmake build-essential ninja-build
        sudo apt install -y libgtest-dev libgmock-dev libyaml-cpp-dev

    - name: Prepare build directory
      run: |
        rm -rf build
        mkdir -p build

    - name: Configure CMake (without network_system)
      run: |
        cd build
        cmake .. \
          -G Ninja \
          -DMESSAGING_BUILD_TESTS=ON \
          -DMESSAGING_BUILD_EXAMPLES=OFF \
          -DMESSAGING_USE_LOCAL_SYSTEMS=ON \
          -DKCENON_WITH_NETWORK_SYSTEM=OFF \
          -DCMAKE_BUILD_TYPE=$BUILD_TYPE \
          -DCMAKE_C_COMPILER=gcc \
          -DCMAKE_CXX_COMPILER=g++

    - name: Build
      run: |
        cd build
        cmake --build . --parallel

    - name: Run tests
      run: |
        cd build
        ctest --output-on-failure --timeout 120 \
          -E "TaskLifecycleTest|WorkerScenariosTest|FailureRecoveryTest|SchedulingTest|ConcurrentLoadTest"

  # Sanitizer testing disabled temporarily due to fmt dependency issues
  # Will be re-enabled once thread_system fmt dependency is resolved