git.m6w6.name Git - awesomized/libmemcached/blob - .github/workflows/cmake-build-ci.yml

   1 # Generated file; do not edit!
   2 name: cmake-build-ci
   3 on:
   4   workflow_dispatch:
   5   release:
   6     types: [published]
   7   push:
   8     paths:
   9       - ".github/workflows/cmake-build-ci*"
  10       - "CMake*"
  11       - "CPack*"
  12       - "contrib/**"
  13       - "include/**"
  14       - "src/**"
  15       - "test/**"
  16     branches-ignore:
  17       - gh-pages
  18   pull_request:
  19     branches:
  20       - master
  21       - v1.x
  22 env:
  23   # defaults
  24   INSTALL_MEMCACHED:  memcached
  25   ENABLE_SASL:        "OFF" # ^ almost no memcached distribution package has built in sasl support
  26   ENABLE_HASH_HSIEH:  "ON"
  27   ENABLE_DTRACE:      "OFF"
  28   OS_VND:   Linux #
  29   OS_VER:   ubuntu-22.04 #
  30   CC_VND:   gnu #
  31   CC_VER:   cur
  32
  33 jobs:
  34
  35   # sanitizer
  36   debug-sanitizer:
  37     name: debug sanitizer
  38     runs-on: ubuntu-22.04 #
  39     strategy:
  40       matrix:
  41         sanitizer: ['address;undefined', 'thread']
  42     env:
  43       CMAKE_BUILD_TYPE:   "Debug"
  44       BUILD_TESTING:      "ON"
  45       VERBOSE:            "ON"
  46       ENABLE_SANITIZERS:  ${{ matrix.sanitizer }}
  47     steps:
  48       - uses: actions/checkout@v3
  49       - name: Prepare environment (for cur gnu on ubuntu-22.04)
  50         if: (env.OS_VER=='ubuntu-22.04') && (env.CC_VND=='gnu') && (env.CC_VER=='cur')
  51         run: |
  52           echo CC="gcc-11" >> ${GITHUB_ENV}
  53           echo CXX="g++-11" >> ${GITHUB_ENV}
  54       - name: Install dependencies (Linux)
  55         if: runner.os == 'Linux'
  56         run: |
  57           sudo apt-get update -y
  58           sudo apt-get install -my \
  59             libevent-dev \
  60             libsasl2-dev \
  61             libtbb-dev \
  62             python3-sphinx \
  63             ${INSTALL_MEMCACHED} \
  64             ${INSTALL_CC} ${INSTALL_CXX}
  65           sudo systemctl stop memcached || true
  66       - name: Build memcached
  67         if: runner.os != 'Windows'
  68         run: |
  69           if test -d memcached
  70           then
  71             cd memcached
  72             ./autogen.sh
  73             cp configure{,.old} && sed -e 's/-Werror//g' <configure.old >configure
  74             ./configure CFLAGS="-O2 -pipe -fcommon" \
  75               --prefix=${MEMCACHED_PREFIX} \
  76               --enable-sasl \
  77               --enable-sasl-pwdb \
  78               --disable-coverage \
  79               --disable-dependency-tracking \
  80               --disable-docs \
  81               --disable-extstore \
  82               --disable-option-checking \
  83               ;
  84             make -j2
  85             make install
  86             cd ..
  87             echo MEMCACHED_BINARY="${MEMCACHED_PREFIX}/bin/memcached" >> ${GITHUB_ENV}
  88           fi
  89       - name: Generate build tree (${{ env.CMAKE_BUILD_TYPE }})
  90         run: cmake -DCMAKE_BUILD_TYPE=${{ env.CMAKE_BUILD_TYPE }} -S . -B build
  91       - name: Build all with ${{ env.CXX }} ${{ env.CXXFLAGS }}
  92         run: cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2
  93       - name: Test
  94         if: env.BUILD_TESTING == 'ON'
  95         run: cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target test
  96       - name: Install
  97         if: env.BUILD_TESTING == 'ON'
  98         run: cmake --install build --config ${{ env.CMAKE_BUILD_TYPE }} --prefix /tmp
  99       - name: Failed tests log
 100         if: ${{ env.BUILD_TESTING == 'ON' && failure() }}
 101         run: cat build/Testing/Temporary/LastTest.log || true
 102       - name: Package
 103         env:
 104           PUSH_ARTIFACTS_ID: ${{ secrets.PUSH_ARTIFACTS_ID }}
 105         if: env.PUSH_ARTIFACTS_ID != '' && env.CMAKE_BUILD_TYPE == 'Release'
 106         run: |
 107           cmake -DCMAKE_BUILD_TYPE=${{ env.CMAKE_BUILD_TYPE }} -S . -B build
 108           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target package
 109           cmake -DCPACK_COMPONENT_INSTALL=ON build
 110           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target package
 111           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target push-artifacts
 112       - name: Notify Gitter
 113         env:
 114           GITTER: ${{ secrets.GITTER }}
 115         if: (success() || failure()) && env.GITTER != ''
 116         run: bash .github/notify-gitter.sh ${{ job.status }}
 117
 118 # memcached
 119   debug-memcached:
 120     name: debug memcached
 121     runs-on: ubuntu-22.04 #
 122     continue-on-error: true
 123     strategy:
 124       matrix:
 125         memcached: ['master', '1.6.17', '1.6.9', '1.5.22', '1.5.6']
 126     env:
 127       CMAKE_BUILD_TYPE:   "Debug"
 128       BUILD_TESTING:      "ON"
 129       VERBOSE:            "ON"
 130       INSTALL_MEMCACHED:  ""
 131       MEMCACHED_PREFIX:   "/tmp"
 132       ENABLE_SASL:        "ON"
 133     steps:
 134       - uses: actions/checkout@v3
 135       - uses: actions/checkout@v3
 136         with:
 137           repository: memcached/memcached
 138           path: memcached
 139           ref: ${{ matrix.memcached }}
 140       - name: Prepare environment (for cur gnu on ubuntu-22.04)
 141         if: (env.OS_VER=='ubuntu-22.04') && (env.CC_VND=='gnu') && (env.CC_VER=='cur')
 142         run: |
 143           echo CC="gcc-11" >> ${GITHUB_ENV}
 144           echo CXX="g++-11" >> ${GITHUB_ENV}
 145       - name: Install dependencies (Linux)
 146         if: runner.os == 'Linux'
 147         run: |
 148           sudo apt-get update -y
 149           sudo apt-get install -my \
 150             libevent-dev \
 151             libsasl2-dev \
 152             libtbb-dev \
 153             python3-sphinx \
 154             ${INSTALL_MEMCACHED} \
 155             ${INSTALL_CC} ${INSTALL_CXX}
 156           sudo systemctl stop memcached || true
 157       - name: Build memcached
 158         if: runner.os != 'Windows'
 159         run: |
 160           if test -d memcached
 161           then
 162             cd memcached
 163             ./autogen.sh
 164             cp configure{,.old} && sed -e 's/-Werror//g' <configure.old >configure
 165             ./configure CFLAGS="-O2 -pipe -fcommon" \
 166               --prefix=${MEMCACHED_PREFIX} \
 167               --enable-sasl \
 168               --enable-sasl-pwdb \
 169               --disable-coverage \
 170               --disable-dependency-tracking \
 171               --disable-docs \
 172               --disable-extstore \
 173               --disable-option-checking \
 174               ;
 175             make -j2
 176             make install
 177             cd ..
 178             echo MEMCACHED_BINARY="${MEMCACHED_PREFIX}/bin/memcached" >> ${GITHUB_ENV}
 179           fi
 180       - name: Generate build tree (${{ env.CMAKE_BUILD_TYPE }})
 181         run: cmake -DCMAKE_BUILD_TYPE=${{ env.CMAKE_BUILD_TYPE }} -S . -B build
 182       - name: Build all with ${{ env.CXX }} ${{ env.CXXFLAGS }}
 183         run: cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2
 184       - name: Test
 185         if: env.BUILD_TESTING == 'ON'
 186         run: cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target test
 187       - name: Install
 188         if: env.BUILD_TESTING == 'ON'
 189         run: cmake --install build --config ${{ env.CMAKE_BUILD_TYPE }} --prefix /tmp
 190       - name: Failed tests log
 191         if: ${{ env.BUILD_TESTING == 'ON' && failure() }}
 192         run: cat build/Testing/Temporary/LastTest.log || true
 193       - name: Package
 194         env:
 195           PUSH_ARTIFACTS_ID: ${{ secrets.PUSH_ARTIFACTS_ID }}
 196         if: env.PUSH_ARTIFACTS_ID != '' && env.CMAKE_BUILD_TYPE == 'Release'
 197         run: |
 198           cmake -DCMAKE_BUILD_TYPE=${{ env.CMAKE_BUILD_TYPE }} -S . -B build
 199           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target package
 200           cmake -DCPACK_COMPONENT_INSTALL=ON build
 201           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target package
 202           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target push-artifacts
 203       - name: Notify Gitter
 204         env:
 205           GITTER: ${{ secrets.GITTER }}
 206         if: (success() || failure()) && env.GITTER != ''
 207         run: bash .github/notify-gitter.sh ${{ job.status }}
 208
 209 # coverage linux
 210   debug-coverage-linux:
 211     name: debug coverage (ubuntu-22.04, gnu)
 212     runs-on: ubuntu-22.04 #
 213     env:
 214       CMAKE_BUILD_TYPE:   "Debug"
 215       BUILD_TESTING:      "ON"
 216       VERBOSE:            "ON"
 217       CFLAGS:             "-O0 --coverage"
 218       CXXFLAGS:           "-O0 --coverage"
 219       INSTALL_MEMCACHED:  ""
 220       MEMCACHED_PREFIX:   "/tmp"
 221       ENABLE_SASL:        "ON"
 222     steps:
 223       - uses: actions/checkout@v3
 224       - uses: actions/checkout@v3
 225         with:
 226           repository: memcached/memcached
 227           path: memcached
 228           ref: 1.6.7
 229       - name: Prepare environment (for cur gnu on ubuntu-22.04)
 230         if: (env.OS_VER=='ubuntu-22.04') && (env.CC_VND=='gnu') && (env.CC_VER=='cur')
 231         run: |
 232           echo CC="gcc-11" >> ${GITHUB_ENV}
 233           echo CXX="g++-11" >> ${GITHUB_ENV}
 234       - name: Install dependencies (Linux)
 235         if: runner.os == 'Linux'
 236         run: |
 237           sudo apt-get update -y
 238           sudo apt-get install -my \
 239             libevent-dev \
 240             libsasl2-dev \
 241             libtbb-dev \
 242             python3-sphinx \
 243             ${INSTALL_MEMCACHED} \
 244             ${INSTALL_CC} ${INSTALL_CXX}
 245           sudo systemctl stop memcached || true
 246       - name: Build memcached
 247         if: runner.os != 'Windows'
 248         run: |
 249           if test -d memcached
 250           then
 251             cd memcached
 252             ./autogen.sh
 253             cp configure{,.old} && sed -e 's/-Werror//g' <configure.old >configure
 254             ./configure CFLAGS="-O2 -pipe -fcommon" \
 255               --prefix=${MEMCACHED_PREFIX} \
 256               --enable-sasl \
 257               --enable-sasl-pwdb \
 258               --disable-coverage \
 259               --disable-dependency-tracking \
 260               --disable-docs \
 261               --disable-extstore \
 262               --disable-option-checking \
 263               ;
 264             make -j2
 265             make install
 266             cd ..
 267             echo MEMCACHED_BINARY="${MEMCACHED_PREFIX}/bin/memcached" >> ${GITHUB_ENV}
 268           fi
 269       - name: Generate build tree (${{ env.CMAKE_BUILD_TYPE }})
 270         run: cmake -DCMAKE_BUILD_TYPE=${{ env.CMAKE_BUILD_TYPE }} -S . -B build
 271       - name: Build all with ${{ env.CXX }} ${{ env.CXXFLAGS }}
 272         run: cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2
 273       - name: Test
 274         if: env.BUILD_TESTING == 'ON'
 275         run: cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target test
 276       - name: Install
 277         if: env.BUILD_TESTING == 'ON'
 278         run: cmake --install build --config ${{ env.CMAKE_BUILD_TYPE }} --prefix /tmp
 279       - name: Failed tests log
 280         if: ${{ env.BUILD_TESTING == 'ON' && failure() }}
 281         run: cat build/Testing/Temporary/LastTest.log || true
 282       - name: Package
 283         env:
 284           PUSH_ARTIFACTS_ID: ${{ secrets.PUSH_ARTIFACTS_ID }}
 285         if: env.PUSH_ARTIFACTS_ID != '' && env.CMAKE_BUILD_TYPE == 'Release'
 286         run: |
 287           cmake -DCMAKE_BUILD_TYPE=${{ env.CMAKE_BUILD_TYPE }} -S . -B build
 288           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target package
 289           cmake -DCPACK_COMPONENT_INSTALL=ON build
 290           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target package
 291           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target push-artifacts
 292       - name: Notify Gitter
 293         env:
 294           GITTER: ${{ secrets.GITTER }}
 295         if: (success() || failure()) && env.GITTER != ''
 296         run: bash .github/notify-gitter.sh ${{ job.status }}
 297       - uses: codecov/codecov-action@v3
 298
 299
 300   # coverage mac
 301   debug-coverage-mac:
 302     name: debug coverage (macos-12, clang)
 303     runs-on: macos-12 #
 304     env:
 305       CMAKE_BUILD_TYPE:   "Debug"
 306       BUILD_TESTING:      "ON"
 307       VERBOSE:            "ON"
 308       CFLAGS:             "-O0 --coverage"
 309       CXXFLAGS:           "-O0 --coverage"
 310       OS_VND:   macOS #
 311       OS_VER:   macos-12 #
 312       CC_VND:   clang #
 313       CC_VER:   cur
 314     continue-on-error: true
 315     steps:
 316       - uses: actions/checkout@v3
 317       - name: Install dependencies (macOS)
 318         if: runner.os == 'macOS'
 319         run: |
 320           brew install bison flex libevent pkg-config sphinx-doc ${INSTALL_MEMCACHED}
 321           brew services stop memcached || true
 322           echo MEMCACHED_BINARY="/usr/local/bin/memcached" >> ${GITHUB_ENV}
 323       - name: Build memcached
 324         if: runner.os != 'Windows'
 325         run: |
 326           if test -d memcached
 327           then
 328             cd memcached
 329             ./autogen.sh
 330             cp configure{,.old} && sed -e 's/-Werror//g' <configure.old >configure
 331             ./configure CFLAGS="-O2 -pipe -fcommon" \
 332               --prefix=${MEMCACHED_PREFIX} \
 333               --enable-sasl \
 334               --enable-sasl-pwdb \
 335               --disable-coverage \
 336               --disable-dependency-tracking \
 337               --disable-docs \
 338               --disable-extstore \
 339               --disable-option-checking \
 340               ;
 341             make -j2
 342             make install
 343             cd ..
 344             echo MEMCACHED_BINARY="${MEMCACHED_PREFIX}/bin/memcached" >> ${GITHUB_ENV}
 345           fi
 346       - name: Generate build tree (${{ env.CMAKE_BUILD_TYPE }})
 347         run: cmake -DCMAKE_BUILD_TYPE=${{ env.CMAKE_BUILD_TYPE }} -S . -B build
 348       - name: Build all with ${{ env.CXX }} ${{ env.CXXFLAGS }}
 349         run: cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2
 350       - name: Test
 351         if: env.BUILD_TESTING == 'ON'
 352         run: cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target test
 353       - name: Install
 354         if: env.BUILD_TESTING == 'ON'
 355         run: cmake --install build --config ${{ env.CMAKE_BUILD_TYPE }} --prefix /tmp
 356       - name: Failed tests log
 357         if: ${{ env.BUILD_TESTING == 'ON' && failure() }}
 358         run: cat build/Testing/Temporary/LastTest.log || true
 359       - name: Package
 360         env:
 361           PUSH_ARTIFACTS_ID: ${{ secrets.PUSH_ARTIFACTS_ID }}
 362         if: env.PUSH_ARTIFACTS_ID != '' && env.CMAKE_BUILD_TYPE == 'Release'
 363         run: |
 364           cmake -DCMAKE_BUILD_TYPE=${{ env.CMAKE_BUILD_TYPE }} -S . -B build
 365           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target package
 366           cmake -DCPACK_COMPONENT_INSTALL=ON build
 367           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target package
 368           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target push-artifacts
 369       - name: Notify Gitter
 370         env:
 371           GITTER: ${{ secrets.GITTER }}
 372         if: (success() || failure()) && env.GITTER != ''
 373         run: bash .github/notify-gitter.sh ${{ job.status }}
 374       - uses: codecov/codecov-action@v3
 375
 376   # mac release builds
 377   mac:
 378     name: release
 379     strategy:
 380       fail-fast: false
 381       matrix:
 382         os_ver: [macos-12, macos-11, macos-10.15]
 383     runs-on: ${{ matrix.os_ver }}
 384     env:
 385       CMAKE_BUILD_TYPE:   "Release"
 386       BUILD_DOCS_MANGZ:   "ON"
 387       OS_VND:   macOS #
 388       OS_VER:   macos-12 #
 389       CC_VND:   clang #
 390       CC_VER:   cur
 391     continue-on-error: true
 392     steps:
 393       - uses: actions/checkout@v3
 394         with:
 395           fetch-depth: 0
 396       - name: Install dependencies (macOS)
 397         if: runner.os == 'macOS'
 398         run: |
 399           brew install bison flex libevent pkg-config sphinx-doc ${INSTALL_MEMCACHED}
 400           brew services stop memcached || true
 401           echo MEMCACHED_BINARY="/usr/local/bin/memcached" >> ${GITHUB_ENV}
 402       - name: Build memcached
 403         if: runner.os != 'Windows'
 404         run: |
 405           if test -d memcached
 406           then
 407             cd memcached
 408             ./autogen.sh
 409             cp configure{,.old} && sed -e 's/-Werror//g' <configure.old >configure
 410             ./configure CFLAGS="-O2 -pipe -fcommon" \
 411               --prefix=${MEMCACHED_PREFIX} \
 412               --enable-sasl \
 413               --enable-sasl-pwdb \
 414               --disable-coverage \
 415               --disable-dependency-tracking \
 416               --disable-docs \
 417               --disable-extstore \
 418               --disable-option-checking \
 419               ;
 420             make -j2
 421             make install
 422             cd ..
 423             echo MEMCACHED_BINARY="${MEMCACHED_PREFIX}/bin/memcached" >> ${GITHUB_ENV}
 424           fi
 425       - name: Generate build tree (${{ env.CMAKE_BUILD_TYPE }})
 426         run: cmake -DCMAKE_BUILD_TYPE=${{ env.CMAKE_BUILD_TYPE }} -S . -B build
 427       - name: Build all with ${{ env.CXX }} ${{ env.CXXFLAGS }}
 428         run: cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2
 429       - name: Test
 430         if: env.BUILD_TESTING == 'ON'
 431         run: cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target test
 432       - name: Install
 433         if: env.BUILD_TESTING == 'ON'
 434         run: cmake --install build --config ${{ env.CMAKE_BUILD_TYPE }} --prefix /tmp
 435       - name: Failed tests log
 436         if: ${{ env.BUILD_TESTING == 'ON' && failure() }}
 437         run: cat build/Testing/Temporary/LastTest.log || true
 438       - name: Package
 439         env:
 440           PUSH_ARTIFACTS_ID: ${{ secrets.PUSH_ARTIFACTS_ID }}
 441         if: env.PUSH_ARTIFACTS_ID != '' && env.CMAKE_BUILD_TYPE == 'Release'
 442         run: |
 443           cmake -DCMAKE_BUILD_TYPE=${{ env.CMAKE_BUILD_TYPE }} -S . -B build
 444           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target package
 445           cmake -DCPACK_COMPONENT_INSTALL=ON build
 446           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target package
 447           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target push-artifacts
 448       - name: Notify Gitter
 449         env:
 450           GITTER: ${{ secrets.GITTER }}
 451         if: (success() || failure()) && env.GITTER != ''
 452         run: bash .github/notify-gitter.sh ${{ job.status }}
 453
 454   # windows release builds
 455   windows:
 456     name: release
 457     strategy:
 458       fail-fast: false
 459       matrix:
 460         os_ver: [windows-2022, windows-2019]
 461         cc_vnd: [msvc, mingw]
 462         cc_ver: [cur]
 463     runs-on: ${{ matrix.os_ver }}
 464     continue-on-error: true
 465     env:
 466       CMAKE_BUILD_TYPE: "Release"
 467       OS_VND: Windows
 468       OS_VER: ${{ matrix.os_ver }}
 469       CC_VND: ${{ matrix.cc_vnd }}
 470       CC_VER: ${{ matrix.cc_ver }}
 471     steps:
 472       - uses: actions/checkout@v3
 473         with:
 474           fetch-depth: 0
 475       - name: Prepare environment (Windows)
 476         run: |
 477           echo "c:\msys64\usr\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
 478           echo "c:\msys64\mingw64\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
 479       - name: Prepare environment (for cur msvc on windows-2022)
 480         if: (env.OS_VER=='windows-2022') && (env.CC_VND=='msvc') && (env.CC_VER=='cur')
 481         run: |
 482           echo 'CMAKE_GENERATOR=Visual Studio 17 2022' | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
 483       - name: Prepare environment (for cur mingw on windows-2022)
 484         if: (env.OS_VER=='windows-2022') && (env.CC_VND=='mingw') && (env.CC_VER=='cur')
 485         run: |
 486           echo 'CMAKE_GENERATOR=MinGW Makefiles' | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
 487       - name: Prepare environment (for cur msvc on windows-2019)
 488         if: (env.OS_VER=='windows-2019') && (env.CC_VND=='msvc') && (env.CC_VER=='cur')
 489         run: |
 490           echo 'CMAKE_GENERATOR=Visual Studio 16 2019' | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
 491       - name: Prepare environment (for cur mingw on windows-2019)
 492         if: (env.OS_VER=='windows-2019') && (env.CC_VND=='mingw') && (env.CC_VER=='cur')
 493         run: |
 494           echo 'CMAKE_GENERATOR=MinGW Makefiles' | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
 495       - name: Install dependencies (Windows)
 496         if: runner.os == 'Windows'
 497         uses: msys2/setup-msys2@v2
 498         with:
 499           release: false
 500           path-type: inherit
 501           install: >-
 502             bison
 503             flex
 504             rsync
 505             openssh
 506       - name: Generate build tree (${{ env.CMAKE_BUILD_TYPE }})
 507         run: cmake -DCMAKE_BUILD_TYPE=${{ env.CMAKE_BUILD_TYPE }} -S . -B build
 508       - name: Build all with ${{ env.CXX }} ${{ env.CXXFLAGS }}
 509         run: cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2
 510       - name: Test
 511         if: env.BUILD_TESTING == 'ON'
 512         run: cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target test
 513       - name: Install
 514         if: env.BUILD_TESTING == 'ON'
 515         run: cmake --install build --config ${{ env.CMAKE_BUILD_TYPE }} --prefix /tmp
 516       - name: Failed tests log
 517         if: ${{ env.BUILD_TESTING == 'ON' && failure() }}
 518         run: cat build/Testing/Temporary/LastTest.log || true
 519       - name: Package
 520         env:
 521           PUSH_ARTIFACTS_ID: ${{ secrets.PUSH_ARTIFACTS_ID }}
 522         if: env.PUSH_ARTIFACTS_ID != '' && env.CMAKE_BUILD_TYPE == 'Release'
 523         run: |
 524           cmake -DCMAKE_BUILD_TYPE=${{ env.CMAKE_BUILD_TYPE }} -S . -B build
 525           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target package
 526           cmake -DCPACK_COMPONENT_INSTALL=ON build
 527           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target package
 528           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target push-artifacts
 529       - name: Notify Gitter
 530         env:
 531           GITTER: ${{ secrets.GITTER }}
 532         if: (success() || failure()) && env.GITTER != ''
 533         run: bash .github/notify-gitter.sh ${{ job.status }}
 534
 535   # linux release builds
 536   release:
 537     strategy:
 538       fail-fast: false
 539       matrix:
 540         os_ver: [ubuntu-22.04, ubuntu-20.04]
 541         cc_vnd: [gnu, clang]
 542         cc_ver: [new, cur, old]
 543     runs-on: ${{ matrix.os_ver }}
 544     continue-on-error: ${{ matrix.cc_vnd == 'clang' }}
 545     env:
 546       CMAKE_BUILD_TYPE: "Release"
 547       BUILD_DOCS_MANGZ: "ON"
 548       OS_VND: Linux
 549       OS_VER: ${{ matrix.os_ver }}
 550       CC_VND: ${{ matrix.cc_vnd }}
 551       CC_VER: ${{ matrix.cc_ver }}
 552     steps:
 553       - uses: actions/checkout@v3
 554         with:
 555           fetch-depth: 0
 556       - name: Prepare environment (for new gnu on ubuntu-22.04)
 557         if: (env.OS_VER=='ubuntu-22.04') && (env.CC_VND=='gnu') && (env.CC_VER=='new')
 558         run: |
 559           echo CC="gcc-12" >> ${GITHUB_ENV}
 560           echo CXX="g++-12" >> ${GITHUB_ENV}
 561       - name: Prepare environment (for cur gnu on ubuntu-22.04)
 562         if: (env.OS_VER=='ubuntu-22.04') && (env.CC_VND=='gnu') && (env.CC_VER=='cur')
 563         run: |
 564           echo CC="gcc-11" >> ${GITHUB_ENV}
 565           echo CXX="g++-11" >> ${GITHUB_ENV}
 566       - name: Prepare environment (for old gnu on ubuntu-22.04)
 567         if: (env.OS_VER=='ubuntu-22.04') && (env.CC_VND=='gnu') && (env.CC_VER=='old')
 568         run: |
 569           echo CC="gcc-10" >> ${GITHUB_ENV}
 570           echo CXX="g++-10" >> ${GITHUB_ENV}
 571       - name: Prepare environment (for new clang on ubuntu-22.04)
 572         if: (env.OS_VER=='ubuntu-22.04') && (env.CC_VND=='clang') && (env.CC_VER=='new')
 573         run: |
 574           echo CC="clang-14" >> ${GITHUB_ENV}
 575           echo CXX="clang++-14" >> ${GITHUB_ENV}
 576           echo CXXFLAGS="-stdlib=libc++" >> ${GITHUB_ENV}
 577           echo INSTALL_CXX="libc++-14-dev libc++abi-14-dev" >> ${GITHUB_ENV}
 578       - name: Prepare environment (for cur clang on ubuntu-22.04)
 579         if: (env.OS_VER=='ubuntu-22.04') && (env.CC_VND=='clang') && (env.CC_VER=='cur')
 580         run: |
 581           echo CC="clang-13" >> ${GITHUB_ENV}
 582           echo CXX="clang++-13" >> ${GITHUB_ENV}
 583           echo CXXFLAGS="-stdlib=libc++" >> ${GITHUB_ENV}
 584           echo INSTALL_CXX="libc++-13-dev libc++abi-13-dev" >> ${GITHUB_ENV}
 585       - name: Prepare environment (for new gnu on ubuntu-20.04)
 586         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='gnu') && (env.CC_VER=='new')
 587         run: |
 588           echo CC="gcc-10" >> ${GITHUB_ENV}
 589           echo CXX="g++-10" >> ${GITHUB_ENV}
 590       - name: Prepare environment (for cur gnu on ubuntu-20.04)
 591         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='gnu') && (env.CC_VER=='cur')
 592         run: |
 593           echo CC="gcc-9" >> ${GITHUB_ENV}
 594           echo CXX="g++-9" >> ${GITHUB_ENV}
 595       - name: Prepare environment (for new clang on ubuntu-20.04)
 596         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='clang') && (env.CC_VER=='new')
 597         run: |
 598           echo CC="clang-12" >> ${GITHUB_ENV}
 599           echo CXX="clang++-12" >> ${GITHUB_ENV}
 600           echo CXXFLAGS="-stdlib=libc++" >> ${GITHUB_ENV}
 601           echo INSTALL_CXX="libc++-12-dev libc++abi-12-dev" >> ${GITHUB_ENV}
 602       - name: Prepare environment (for cur clang on ubuntu-20.04)
 603         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='clang') && (env.CC_VER=='cur')
 604         run: |
 605           echo CC="clang-11" >> ${GITHUB_ENV}
 606           echo CXX="clang++-11" >> ${GITHUB_ENV}
 607           echo CXXFLAGS="-stdlib=libc++" >> ${GITHUB_ENV}
 608           echo INSTALL_CXX="libc++-11-dev libc++abi-11-dev" >> ${GITHUB_ENV}
 609       - name: Prepare environment (for old clang on ubuntu-20.04)
 610         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='clang') && (env.CC_VER=='old')
 611         run: |
 612           echo CC="clang-10" >> ${GITHUB_ENV}
 613           echo CXX="clang++-10" >> ${GITHUB_ENV}
 614           echo CXXFLAGS="-stdlib=libc++" >> ${GITHUB_ENV}
 615           echo INSTALL_CXX="libc++-10-dev libc++abi-10-dev" >> ${GITHUB_ENV}
 616       - name: Install dependencies (Linux)
 617         if: runner.os == 'Linux'
 618         run: |
 619           sudo apt-get update -y
 620           sudo apt-get install -my \
 621             libevent-dev \
 622             libsasl2-dev \
 623             libtbb-dev \
 624             python3-sphinx \
 625             ${INSTALL_MEMCACHED} \
 626             ${INSTALL_CC} ${INSTALL_CXX}
 627           sudo systemctl stop memcached || true
 628       - name: Build memcached
 629         if: runner.os != 'Windows'
 630         run: |
 631           if test -d memcached
 632           then
 633             cd memcached
 634             ./autogen.sh
 635             cp configure{,.old} && sed -e 's/-Werror//g' <configure.old >configure
 636             ./configure CFLAGS="-O2 -pipe -fcommon" \
 637               --prefix=${MEMCACHED_PREFIX} \
 638               --enable-sasl \
 639               --enable-sasl-pwdb \
 640               --disable-coverage \
 641               --disable-dependency-tracking \
 642               --disable-docs \
 643               --disable-extstore \
 644               --disable-option-checking \
 645               ;
 646             make -j2
 647             make install
 648             cd ..
 649             echo MEMCACHED_BINARY="${MEMCACHED_PREFIX}/bin/memcached" >> ${GITHUB_ENV}
 650           fi
 651       - name: Generate build tree (${{ env.CMAKE_BUILD_TYPE }})
 652         run: cmake -DCMAKE_BUILD_TYPE=${{ env.CMAKE_BUILD_TYPE }} -S . -B build
 653       - name: Build all with ${{ env.CXX }} ${{ env.CXXFLAGS }}
 654         run: cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2
 655       - name: Test
 656         if: env.BUILD_TESTING == 'ON'
 657         run: cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target test
 658       - name: Install
 659         if: env.BUILD_TESTING == 'ON'
 660         run: cmake --install build --config ${{ env.CMAKE_BUILD_TYPE }} --prefix /tmp
 661       - name: Failed tests log
 662         if: ${{ env.BUILD_TESTING == 'ON' && failure() }}
 663         run: cat build/Testing/Temporary/LastTest.log || true
 664       - name: Package
 665         env:
 666           PUSH_ARTIFACTS_ID: ${{ secrets.PUSH_ARTIFACTS_ID }}
 667         if: env.PUSH_ARTIFACTS_ID != '' && env.CMAKE_BUILD_TYPE == 'Release'
 668         run: |
 669           cmake -DCMAKE_BUILD_TYPE=${{ env.CMAKE_BUILD_TYPE }} -S . -B build
 670           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target package
 671           cmake -DCPACK_COMPONENT_INSTALL=ON build
 672           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target package
 673           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target push-artifacts
 674       - name: Notify Gitter
 675         env:
 676           GITTER: ${{ secrets.GITTER }}
 677         if: (success() || failure()) && env.GITTER != ''
 678         run: bash .github/notify-gitter.sh ${{ job.status }}