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@v1.0.13
 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: dbg-mac (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@v2
 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@v1.0.13
 372
 373   # mac release
 374   rel-mac:
 375     name: rel-mac (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     strategy:
 450       fail-fast: false
 451       matrix:
 452         os_ver: [windows-2019]
 453         cc_vnd: [msvc, mingw]
 454         cc_ver: [cur]
 455     runs-on: ${{ matrix.os_ver }}
 456     continue-on-error: true
 457     env:
 458       CMAKE_BUILD_TYPE: "Release"
 459       OS_VND: Windows
 460       OS_VER: ${{ matrix.os_ver }}
 461       CC_VND: ${{ matrix.cc_vnd }}
 462       CC_VER: ${{ matrix.cc_ver }}
 463     steps:
 464       - uses: actions/checkout@v2
 465         with:
 466           fetch-depth: 0
 467       - name: Prepare environment (Windows)
 468         run: |
 469           echo "c:\msys64\usr\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
 470           echo "c:\msys64\mingw64\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
 471           echo 'CMAKE_GENERATOR=Visual Studio 16 2019' | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
 472       - name: Prepare environment (MinGW)
 473         if: env.CC_VND == 'mingw'
 474         run: |
 475           echo 'CMAKE_GENERATOR=MinGW Makefiles' | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
 476       - name: Install dependencies (Windows)
 477         if: runner.os == 'Windows'
 478         uses: msys2/setup-msys2@v2
 479         with:
 480           release: false
 481           path-type: inherit
 482           install: >-
 483             rsync
 484             openssh
 485       - name: Generate build tree (${{ env.CMAKE_BUILD_TYPE }})
 486         run: cmake -DCMAKE_BUILD_TYPE=${{ env.CMAKE_BUILD_TYPE }} -S . -B build
 487       - name: Build all with ${{ env.CXX }} ${{ env.CXXFLAGS }}
 488         run: cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2
 489       - name: Test
 490         if: env.BUILD_TESTING == 'ON'
 491         run: cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target test
 492       - name: Install
 493         if: env.BUILD_TESTING == 'ON'
 494         run: cmake --install build --config ${{ env.CMAKE_BUILD_TYPE }} --prefix /tmp
 495       - name: Failed tests log
 496         if: ${{ env.BUILD_TESTING == 'ON' && failure() }}
 497         run: cat build/Testing/Temporary/LastTest.log || true
 498       - name: Package
 499         env:
 500           PUSH_ARTIFACTS_ID: ${{ secrets.PUSH_ARTIFACTS_ID }}
 501         if: env.PUSH_ARTIFACTS_ID != '' && env.CMAKE_BUILD_TYPE == 'Release' && !(env.OS_VER == 'ubuntu-18.04' && env.CC_VND == 'gnu' && env.CC_VER == 'new  ')
 502         run: |
 503           cmake -DCMAKE_BUILD_TYPE=${{ env.CMAKE_BUILD_TYPE }} -S . -B build
 504           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target package
 505           cmake -DCPACK_COMPONENT_INSTALL=ON build
 506           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target package
 507           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target push-artifacts
 508       - name: Notify Gitter
 509         env:
 510           GITTER: ${{ secrets.GITTER }}
 511         if: (success() || failure()) && env.GITTER != ''
 512         run: bash .github/notify-gitter.sh ${{ job.status }}
 513
 514   # linux release builds
 515   release:
 516     strategy:
 517       fail-fast: false
 518       matrix:
 519         os_ver: [ubuntu-22.04, ubuntu-20.04]
 520         cc_vnd: [gnu, clang]
 521         cc_ver: [new, cur, old]
 522     runs-on: ${{ matrix.os_ver }}
 523     continue-on-error: ${{ matrix.cc_vnd == 'clang' }}
 524     env:
 525       CMAKE_BUILD_TYPE: "Release"
 526       BUILD_DOCS_MANGZ: "ON"
 527       OS_VND: Linux
 528       OS_VER: ${{ matrix.os_ver }}
 529       CC_VND: ${{ matrix.cc_vnd }}
 530       CC_VER: ${{ matrix.cc_ver }}
 531     steps:
 532       - uses: actions/checkout@v3
 533         with:
 534           fetch-depth: 0
 535       - name: Prepare environment (for new gnu on ubuntu-22.04)
 536         if: (env.OS_VER=='ubuntu-22.04') && (env.CC_VND=='gnu') && (env.CC_VER=='new')
 537         run: |
 538           echo CC="gcc-12" >> ${GITHUB_ENV}
 539           echo CXX="g++-12" >> ${GITHUB_ENV}
 540       - name: Prepare environment (for cur gnu on ubuntu-22.04)
 541         if: (env.OS_VER=='ubuntu-22.04') && (env.CC_VND=='gnu') && (env.CC_VER=='cur')
 542         run: |
 543           echo CC="gcc-11" >> ${GITHUB_ENV}
 544           echo CXX="g++-11" >> ${GITHUB_ENV}
 545       - name: Prepare environment (for old gnu on ubuntu-22.04)
 546         if: (env.OS_VER=='ubuntu-22.04') && (env.CC_VND=='gnu') && (env.CC_VER=='old')
 547         run: |
 548           echo CC="gcc-10" >> ${GITHUB_ENV}
 549           echo CXX="g++-10" >> ${GITHUB_ENV}
 550       - name: Prepare environment (for new clang on ubuntu-22.04)
 551         if: (env.OS_VER=='ubuntu-22.04') && (env.CC_VND=='clang') && (env.CC_VER=='new')
 552         run: |
 553           echo CC="clang-14" >> ${GITHUB_ENV}
 554           echo CXX="clang++-14" >> ${GITHUB_ENV}
 555           echo CXXFLAGS="-stdlib=libc++" >> ${GITHUB_ENV}
 556           echo INSTALL_CXX="libc++-14-dev libc++abi-14-dev" >> ${GITHUB_ENV}
 557       - name: Prepare environment (for cur clang on ubuntu-22.04)
 558         if: (env.OS_VER=='ubuntu-22.04') && (env.CC_VND=='clang') && (env.CC_VER=='cur')
 559         run: |
 560           echo CC="clang-13" >> ${GITHUB_ENV}
 561           echo CXX="clang++-13" >> ${GITHUB_ENV}
 562           echo CXXFLAGS="-stdlib=libc++" >> ${GITHUB_ENV}
 563           echo INSTALL_CXX="libc++-13-dev libc++abi-13-dev" >> ${GITHUB_ENV}
 564       - name: Prepare environment (for new gnu on ubuntu-20.04)
 565         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='gnu') && (env.CC_VER=='new')
 566         run: |
 567           echo CC="gcc-10" >> ${GITHUB_ENV}
 568           echo CXX="g++-10" >> ${GITHUB_ENV}
 569       - name: Prepare environment (for cur gnu on ubuntu-20.04)
 570         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='gnu') && (env.CC_VER=='cur')
 571         run: |
 572           echo CC="gcc-9" >> ${GITHUB_ENV}
 573           echo CXX="g++-9" >> ${GITHUB_ENV}
 574       - name: Prepare environment (for new clang on ubuntu-20.04)
 575         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='clang') && (env.CC_VER=='new')
 576         run: |
 577           echo CC="clang-12" >> ${GITHUB_ENV}
 578           echo CXX="clang++-12" >> ${GITHUB_ENV}
 579           echo CXXFLAGS="-stdlib=libc++" >> ${GITHUB_ENV}
 580           echo INSTALL_CXX="libc++-12-dev libc++abi-12-dev" >> ${GITHUB_ENV}
 581       - name: Prepare environment (for cur clang on ubuntu-20.04)
 582         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='clang') && (env.CC_VER=='cur')
 583         run: |
 584           echo CC="clang-11" >> ${GITHUB_ENV}
 585           echo CXX="clang++-11" >> ${GITHUB_ENV}
 586           echo CXXFLAGS="-stdlib=libc++" >> ${GITHUB_ENV}
 587           echo INSTALL_CXX="libc++-11-dev libc++abi-11-dev" >> ${GITHUB_ENV}
 588       - name: Prepare environment (for old clang on ubuntu-20.04)
 589         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='clang') && (env.CC_VER=='old')
 590         run: |
 591           echo CC="clang-10" >> ${GITHUB_ENV}
 592           echo CXX="clang++-10" >> ${GITHUB_ENV}
 593           echo CXXFLAGS="-stdlib=libc++" >> ${GITHUB_ENV}
 594           echo INSTALL_CXX="libc++-10-dev libc++abi-10-dev" >> ${GITHUB_ENV}
 595       - name: Install dependencies (Linux)
 596         if: runner.os == 'Linux'
 597         run: |
 598           sudo apt-get update -y
 599           sudo apt-get install -my \
 600             libevent-dev \
 601             libsasl2-dev \
 602             libtbb-dev \
 603             python3-sphinx \
 604             ${INSTALL_MEMCACHED} \
 605             ${INSTALL_CC} ${INSTALL_CXX}
 606           sudo systemctl stop memcached || true
 607       - name: Build memcached
 608         if: runner.os != 'Windows'
 609         run: |
 610           if test -d memcached
 611           then
 612             cd memcached
 613             ./autogen.sh
 614             cp configure{,.old} && sed -e 's/-Werror//g' <configure.old >configure
 615             ./configure CFLAGS="-O2 -pipe -fcommon" \
 616               --prefix=${MEMCACHED_PREFIX} \
 617               --enable-sasl \
 618               --enable-sasl-pwdb \
 619               --disable-coverage \
 620               --disable-dependency-tracking \
 621               --disable-docs \
 622               --disable-extstore \
 623               --disable-option-checking \
 624               ;
 625             make -j2
 626             make install
 627             cd ..
 628             echo MEMCACHED_BINARY="${MEMCACHED_PREFIX}/bin/memcached" >> ${GITHUB_ENV}
 629           fi
 630       - name: Generate build tree (${{ env.CMAKE_BUILD_TYPE }})
 631         run: cmake -DCMAKE_BUILD_TYPE=${{ env.CMAKE_BUILD_TYPE }} -S . -B build
 632       - name: Build all with ${{ env.CXX }} ${{ env.CXXFLAGS }}
 633         run: cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2
 634       - name: Test
 635         if: env.BUILD_TESTING == 'ON'
 636         run: cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target test
 637       - name: Install
 638         if: env.BUILD_TESTING == 'ON'
 639         run: cmake --install build --config ${{ env.CMAKE_BUILD_TYPE }} --prefix /tmp
 640       - name: Failed tests log
 641         if: ${{ env.BUILD_TESTING == 'ON' && failure() }}
 642         run: cat build/Testing/Temporary/LastTest.log || true
 643       - name: Package
 644         env:
 645           PUSH_ARTIFACTS_ID: ${{ secrets.PUSH_ARTIFACTS_ID }}
 646         if: env.PUSH_ARTIFACTS_ID != '' && env.CMAKE_BUILD_TYPE == 'Release' && !(env.OS_VER == 'ubuntu-18.04' && env.CC_VND == 'gnu' && env.CC_VER == 'new  ')
 647         run: |
 648           cmake -DCMAKE_BUILD_TYPE=${{ env.CMAKE_BUILD_TYPE }} -S . -B build
 649           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target package
 650           cmake -DCPACK_COMPONENT_INSTALL=ON build
 651           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target package
 652           cmake --build build --config ${{ env.CMAKE_BUILD_TYPE }} -j2 --target push-artifacts
 653       - name: Notify Gitter
 654         env:
 655           GITTER: ${{ secrets.GITTER }}
 656         if: (success() || failure()) && env.GITTER != ''
 657         run: bash .github/notify-gitter.sh ${{ job.status }}