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

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