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