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