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   push:
   5     paths-ignore:
   6       - "docs/**"
   7     branches-ignore:
   8       - gh-pages
   9       - catch
  10       - v1.x
  11   pull_request:
  12     branches:
  13       - master
  14       - v1.x
  15 env:
  16   # defaults
  17   INSTALL_MEMCACHED:  memcached
  18   CMAKE_BUILD_TYPE:   Debug
  19   BUILD_TESTING:      "ON"
  20   ENABLE_SASL:        "OFF"
  21   ENABLE_HASH_HSIEH:  "ON"
  22   ENABLE_DTRACE:      "OFF"
  23   VERBOSE:            "ON"
  24   OS_VND:   Linux #
  25   OS_VER:   ubuntu-20.04 #
  26   CC_VND:   gnu #
  27   CC_VER:   cur #
  28
  29 jobs:
  30
  31   # new memcached
  32   dbg-new:
  33     name: dbg-new (ubuntu-20.04, gnu, cur)
  34     runs-on: ubuntu-20.04 #
  35     env:
  36       INSTALL_MEMCACHED:
  37       MEMCACHED_PREFIX: /tmp
  38       ENABLE_SASL:      "ON"
  39     steps:
  40       - uses: actions/checkout@v2
  41       - uses: actions/checkout@v2
  42         with:
  43           repository: memcached/memcached
  44           path: memcached
  45           ref: 1.6.7
  46       - name: Prepare environment (for cur gnu on ubuntu-20.04)
  47         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='gnu') && (env.CC_VER=='cur')
  48         run: |
  49           echo CC="gcc-9" >> ${GITHUB_ENV}
  50           echo CXX="g++-9" >> ${GITHUB_ENV}
  51       - name: Install dependencies (Linux)
  52         if: runner.os == 'Linux'
  53         run: |
  54           sudo apt-get install \
  55             libevent-dev \
  56             libsasl2-dev \
  57             ${INSTALL_MEMCACHED} \
  58             ${INSTALL_CC} ${INSTALL_CXX}
  59           sudo systemctl stop memcached || true
  60       - name: Install dependencies (Mac)
  61         if: runner.os == 'macOS'
  62         run: |
  63           brew install bison flex ${INSTALL_MEMCACHED}
  64           brew services stop memcached || true
  65           echo MEMCACHED_BINARY="/usr/local/bin/memcached" >> ${GITHUB_ENV}
  66       - name: Build memcached
  67         run: |
  68           if test -d memcached
  69           then
  70             cd memcached
  71             ./autogen.sh
  72             ./configure CFLAGS="-O2 -pipe" \
  73               --prefix=${MEMCACHED_PREFIX} \
  74               --enable-sasl \
  75               --enable-sasl-pwdb \
  76               --disable-coverage \
  77               --disable-dependency-tracking \
  78               --disable-docs \
  79               --disable-extstore \
  80               --disable-option-checking \
  81               ;
  82             make -j2
  83             make install
  84             cd ..
  85             echo MEMCACHED_BINARY="${MEMCACHED_PREFIX}/bin/memcached" >> ${GITHUB_ENV}
  86           fi
  87       - name: Generate build tree (${{ env.CMAKE_BUILD_TYPE }})
  88         run: cmake -S . -B build
  89       - name: Build all with ${{ env.CXX }} ${{ env.CXXFLAGS }}
  90         run: make -C build -j2 all
  91       - name: Test
  92         run: make -C build -j2 test
  93       - name: Install
  94         run: make -C build -j2 install DESTDIR=.
  95       - name: Failed tests log
  96         if: ${{ failure() }}
  97         run: cat build/Testing/Temporary/LastTest.log || true
  98
  99   # sanitizer build
 100   dbg-san:
 101     name: dbg-san (ubuntu-20.04, gnu, cur)
 102     runs-on: ubuntu-20.04 #
 103     env:
 104       ENABLE_SANITIZERS: "address;undefined"
 105     steps:
 106       - uses: actions/checkout@v2
 107       - name: Prepare environment (for cur gnu on ubuntu-20.04)
 108         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='gnu') && (env.CC_VER=='cur')
 109         run: |
 110           echo CC="gcc-9" >> ${GITHUB_ENV}
 111           echo CXX="g++-9" >> ${GITHUB_ENV}
 112       - name: Install dependencies (Linux)
 113         if: runner.os == 'Linux'
 114         run: |
 115           sudo apt-get install \
 116             libevent-dev \
 117             libsasl2-dev \
 118             ${INSTALL_MEMCACHED} \
 119             ${INSTALL_CC} ${INSTALL_CXX}
 120           sudo systemctl stop memcached || true
 121       - name: Install dependencies (Mac)
 122         if: runner.os == 'macOS'
 123         run: |
 124           brew install bison flex ${INSTALL_MEMCACHED}
 125           brew services stop memcached || true
 126           echo MEMCACHED_BINARY="/usr/local/bin/memcached" >> ${GITHUB_ENV}
 127       - name: Build memcached
 128         run: |
 129           if test -d memcached
 130           then
 131             cd memcached
 132             ./autogen.sh
 133             ./configure CFLAGS="-O2 -pipe" \
 134               --prefix=${MEMCACHED_PREFIX} \
 135               --enable-sasl \
 136               --enable-sasl-pwdb \
 137               --disable-coverage \
 138               --disable-dependency-tracking \
 139               --disable-docs \
 140               --disable-extstore \
 141               --disable-option-checking \
 142               ;
 143             make -j2
 144             make install
 145             cd ..
 146             echo MEMCACHED_BINARY="${MEMCACHED_PREFIX}/bin/memcached" >> ${GITHUB_ENV}
 147           fi
 148       - name: Generate build tree (${{ env.CMAKE_BUILD_TYPE }})
 149         run: cmake -S . -B build
 150       - name: Build all with ${{ env.CXX }} ${{ env.CXXFLAGS }}
 151         run: make -C build -j2 all
 152       - name: Test
 153         run: make -C build -j2 test
 154       - name: Install
 155         run: make -C build -j2 install DESTDIR=.
 156       - name: Failed tests log
 157         if: ${{ failure() }}
 158         run: cat build/Testing/Temporary/LastTest.log || true
 159
 160   # coverage build
 161   dbg-cov:
 162     name: dbg-cov (ubuntu-20.04, gnu, cur)
 163     runs-on: ubuntu-20.04 #
 164     env:
 165       CFLAGS: -O0 --coverage
 166       CXXFLAGS: -O0 --coverage
 167     steps:
 168       - uses: actions/checkout@v2
 169       - name: Prepare environment (for cur gnu on ubuntu-20.04)
 170         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='gnu') && (env.CC_VER=='cur')
 171         run: |
 172           echo CC="gcc-9" >> ${GITHUB_ENV}
 173           echo CXX="g++-9" >> ${GITHUB_ENV}
 174       - name: Install dependencies (Linux)
 175         if: runner.os == 'Linux'
 176         run: |
 177           sudo apt-get install \
 178             libevent-dev \
 179             libsasl2-dev \
 180             ${INSTALL_MEMCACHED} \
 181             ${INSTALL_CC} ${INSTALL_CXX}
 182           sudo systemctl stop memcached || true
 183       - name: Install dependencies (Mac)
 184         if: runner.os == 'macOS'
 185         run: |
 186           brew install bison flex ${INSTALL_MEMCACHED}
 187           brew services stop memcached || true
 188           echo MEMCACHED_BINARY="/usr/local/bin/memcached" >> ${GITHUB_ENV}
 189       - name: Build memcached
 190         run: |
 191           if test -d memcached
 192           then
 193             cd memcached
 194             ./autogen.sh
 195             ./configure CFLAGS="-O2 -pipe" \
 196               --prefix=${MEMCACHED_PREFIX} \
 197               --enable-sasl \
 198               --enable-sasl-pwdb \
 199               --disable-coverage \
 200               --disable-dependency-tracking \
 201               --disable-docs \
 202               --disable-extstore \
 203               --disable-option-checking \
 204               ;
 205             make -j2
 206             make install
 207             cd ..
 208             echo MEMCACHED_BINARY="${MEMCACHED_PREFIX}/bin/memcached" >> ${GITHUB_ENV}
 209           fi
 210       - name: Generate build tree (${{ env.CMAKE_BUILD_TYPE }})
 211         run: cmake -S . -B build
 212       - name: Build all with ${{ env.CXX }} ${{ env.CXXFLAGS }}
 213         run: make -C build -j2 all
 214       - name: Test
 215         run: make -C build -j2 test
 216       - name: Install
 217         run: make -C build -j2 install DESTDIR=.
 218       - name: Failed tests log
 219         if: ${{ failure() }}
 220         run: cat build/Testing/Temporary/LastTest.log || true
 221       - uses: codecov/codecov-action@v1.0.13
 222
 223   # mac build
 224   dbg-mac:
 225     name: dbg-mac (macos-10.15, clang, apple)
 226     runs-on: macos-10.15 #
 227     continue-on-error: true
 228     steps:
 229       - uses: actions/checkout@v2
 230       - name: Install dependencies (Linux)
 231         if: runner.os == 'Linux'
 232         run: |
 233           sudo apt-get install \
 234             libevent-dev \
 235             libsasl2-dev \
 236             ${INSTALL_MEMCACHED} \
 237             ${INSTALL_CC} ${INSTALL_CXX}
 238           sudo systemctl stop memcached || true
 239       - name: Install dependencies (Mac)
 240         if: runner.os == 'macOS'
 241         run: |
 242           brew install bison flex ${INSTALL_MEMCACHED}
 243           brew services stop memcached || true
 244           echo MEMCACHED_BINARY="/usr/local/bin/memcached" >> ${GITHUB_ENV}
 245       - name: Build memcached
 246         run: |
 247           if test -d memcached
 248           then
 249             cd memcached
 250             ./autogen.sh
 251             ./configure CFLAGS="-O2 -pipe" \
 252               --prefix=${MEMCACHED_PREFIX} \
 253               --enable-sasl \
 254               --enable-sasl-pwdb \
 255               --disable-coverage \
 256               --disable-dependency-tracking \
 257               --disable-docs \
 258               --disable-extstore \
 259               --disable-option-checking \
 260               ;
 261             make -j2
 262             make install
 263             cd ..
 264             echo MEMCACHED_BINARY="${MEMCACHED_PREFIX}/bin/memcached" >> ${GITHUB_ENV}
 265           fi
 266       - name: Generate build tree (${{ env.CMAKE_BUILD_TYPE }})
 267         run: cmake -S . -B build
 268       - name: Build all with ${{ env.CXX }} ${{ env.CXXFLAGS }}
 269         run: make -C build -j2 all
 270       - name: Test
 271         run: make -C build -j2 test
 272       - name: Install
 273         run: make -C build -j2 install DESTDIR=.
 274       - name: Failed tests log
 275         if: ${{ failure() }}
 276         run: cat build/Testing/Temporary/LastTest.log || true
 277
 278   # release builds
 279   release:
 280     strategy:
 281       fail-fast: false
 282       matrix:
 283         os_ver: [ubuntu-20.04, ubuntu-18.04]
 284         cc_vnd: [gnu, clang]
 285         cc_ver: [new, cur, old]
 286     runs-on: ${{ matrix.os_ver }}
 287     continue-on-error: ${{ matrix.cc_vnd == 'clang' }}
 288     env:
 289       CMAKE_BUILD_TYPE: Release
 290       OS_VND: Linux
 291       OS_VER: ${{ matrix.os_ver }}
 292       CC_VND: ${{ matrix.cc_vnd }}
 293       CC_VER: ${{ matrix.cc_ver }}
 294     steps:
 295       - uses: actions/checkout@v2
 296       - name: Prepare environment (for new gnu on ubuntu-20.04)
 297         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='gnu') && (env.CC_VER=='new')
 298         run: |
 299           echo CC="gcc-10" >> ${GITHUB_ENV}
 300           echo CXX="g++-10" >> ${GITHUB_ENV}
 301           echo INSTALL_CC="gcc-10" >> ${GITHUB_ENV}
 302           echo INSTALL_CXX="g++-10" >> ${GITHUB_ENV}
 303       - name: Prepare environment (for cur gnu on ubuntu-20.04)
 304         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='gnu') && (env.CC_VER=='cur')
 305         run: |
 306           echo CC="gcc-9" >> ${GITHUB_ENV}
 307           echo CXX="g++-9" >> ${GITHUB_ENV}
 308       - name: Prepare environment (for old gnu on ubuntu-20.04)
 309         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='gnu') && (env.CC_VER=='old')
 310         run: |
 311           echo CC="gcc-8" >> ${GITHUB_ENV}
 312           echo CXX="g++-8" >> ${GITHUB_ENV}
 313       - name: Prepare environment (for new clang on ubuntu-20.04)
 314         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='clang') && (env.CC_VER=='new')
 315         run: |
 316           echo CC="clang-10" >> ${GITHUB_ENV}
 317           echo CXX="clang++-10" >> ${GITHUB_ENV}
 318       - name: Prepare environment (for cur clang on ubuntu-20.04)
 319         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='clang') && (env.CC_VER=='cur')
 320         run: |
 321           echo CC="clang-9" >> ${GITHUB_ENV}
 322           echo CXX="clang++-9" >> ${GITHUB_ENV}
 323       - name: Prepare environment (for old clang on ubuntu-20.04)
 324         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='clang') && (env.CC_VER=='old')
 325         run: |
 326           echo CC="clang-8" >> ${GITHUB_ENV}
 327           echo CXX="clang++-8" >> ${GITHUB_ENV}
 328       - name: Prepare environment (for new gnu on ubuntu-18.04)
 329         if: (env.OS_VER=='ubuntu-18.04') && (env.CC_VND=='gnu') && (env.CC_VER=='new')
 330         run: |
 331           echo CC="gcc-9" >> ${GITHUB_ENV}
 332           echo CXX="g++-9" >> ${GITHUB_ENV}
 333       - name: Prepare environment (for cur gnu on ubuntu-18.04)
 334         if: (env.OS_VER=='ubuntu-18.04') && (env.CC_VND=='gnu') && (env.CC_VER=='cur')
 335         run: |
 336           echo CC="gcc-8" >> ${GITHUB_ENV}
 337           echo CXX="g++-8" >> ${GITHUB_ENV}
 338       - name: Prepare environment (for old gnu on ubuntu-18.04)
 339         if: (env.OS_VER=='ubuntu-18.04') && (env.CC_VND=='gnu') && (env.CC_VER=='old')
 340         run: |
 341           echo CC="gcc-7" >> ${GITHUB_ENV}
 342           echo CXX="g++-7" >> ${GITHUB_ENV}
 343       - name: Prepare environment (for new clang on ubuntu-18.04)
 344         if: (env.OS_VER=='ubuntu-18.04') && (env.CC_VND=='clang') && (env.CC_VER=='new')
 345         run: |
 346           echo CC="clang-9" >> ${GITHUB_ENV}
 347           echo CXX="clang++-9" >> ${GITHUB_ENV}
 348       - name: Prepare environment (for cur clang on ubuntu-18.04)
 349         if: (env.OS_VER=='ubuntu-18.04') && (env.CC_VND=='clang') && (env.CC_VER=='cur')
 350         run: |
 351           echo CC="clang-8" >> ${GITHUB_ENV}
 352           echo CXX="clang++-8" >> ${GITHUB_ENV}
 353       - name: Prepare environment (for old clang on ubuntu-18.04)
 354         if: (env.OS_VER=='ubuntu-18.04') && (env.CC_VND=='clang') && (env.CC_VER=='old')
 355         run: |
 356           echo CC="clang-6.0" >> ${GITHUB_ENV}
 357           echo CXX="clang++-6.0" >> ${GITHUB_ENV}
 358           echo CXXFLAGS="-stdlib=libc++" >> ${GITHUB_ENV}
 359       - name: Install dependencies (Linux)
 360         if: runner.os == 'Linux'
 361         run: |
 362           sudo apt-get install \
 363             libevent-dev \
 364             libsasl2-dev \
 365             ${INSTALL_MEMCACHED} \
 366             ${INSTALL_CC} ${INSTALL_CXX}
 367           sudo systemctl stop memcached || true
 368       - name: Install dependencies (Mac)
 369         if: runner.os == 'macOS'
 370         run: |
 371           brew install bison flex ${INSTALL_MEMCACHED}
 372           brew services stop memcached || true
 373           echo MEMCACHED_BINARY="/usr/local/bin/memcached" >> ${GITHUB_ENV}
 374       - name: Build memcached
 375         run: |
 376           if test -d memcached
 377           then
 378             cd memcached
 379             ./autogen.sh
 380             ./configure CFLAGS="-O2 -pipe" \
 381               --prefix=${MEMCACHED_PREFIX} \
 382               --enable-sasl \
 383               --enable-sasl-pwdb \
 384               --disable-coverage \
 385               --disable-dependency-tracking \
 386               --disable-docs \
 387               --disable-extstore \
 388               --disable-option-checking \
 389               ;
 390             make -j2
 391             make install
 392             cd ..
 393             echo MEMCACHED_BINARY="${MEMCACHED_PREFIX}/bin/memcached" >> ${GITHUB_ENV}
 394           fi
 395       - name: Generate build tree (${{ env.CMAKE_BUILD_TYPE }})
 396         run: cmake -S . -B build
 397       - name: Build all with ${{ env.CXX }} ${{ env.CXXFLAGS }}
 398         run: make -C build -j2 all
 399       - name: Test
 400         run: make -C build -j2 test
 401       - name: Install
 402         run: make -C build -j2 install DESTDIR=.
 403       - name: Failed tests log
 404         if: ${{ failure() }}
 405         run: cat build/Testing/Temporary/LastTest.log || true