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