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