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   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     env:
 228       CFLAGS: -O0 --coverage
 229       CXXFLAGS: -O0 --coverage
 230     continue-on-error: true
 231     steps:
 232       - uses: actions/checkout@v2
 233       - name: Install dependencies (Linux)
 234         if: runner.os == 'Linux'
 235         run: |
 236           sudo apt-get install \
 237             libevent-dev \
 238             libsasl2-dev \
 239             ${INSTALL_MEMCACHED} \
 240             ${INSTALL_CC} ${INSTALL_CXX}
 241           sudo systemctl stop memcached || true
 242       - name: Install dependencies (Mac)
 243         if: runner.os == 'macOS'
 244         run: |
 245           brew install bison flex ${INSTALL_MEMCACHED}
 246           brew services stop memcached || true
 247           echo MEMCACHED_BINARY="/usr/local/bin/memcached" >> ${GITHUB_ENV}
 248       - name: Build memcached
 249         run: |
 250           if test -d memcached
 251           then
 252             cd memcached
 253             ./autogen.sh
 254             ./configure CFLAGS="-O2 -pipe" \
 255               --prefix=${MEMCACHED_PREFIX} \
 256               --enable-sasl \
 257               --enable-sasl-pwdb \
 258               --disable-coverage \
 259               --disable-dependency-tracking \
 260               --disable-docs \
 261               --disable-extstore \
 262               --disable-option-checking \
 263               ;
 264             make -j2
 265             make install
 266             cd ..
 267             echo MEMCACHED_BINARY="${MEMCACHED_PREFIX}/bin/memcached" >> ${GITHUB_ENV}
 268           fi
 269       - name: Generate build tree (${{ env.CMAKE_BUILD_TYPE }})
 270         run: cmake -S . -B build
 271       - name: Build all with ${{ env.CXX }} ${{ env.CXXFLAGS }}
 272         run: make -C build -j2 all
 273       - name: Test
 274         run: make -C build -j2 test
 275       - name: Install
 276         run: make -C build -j2 install DESTDIR=.
 277       - name: Failed tests log
 278         if: ${{ failure() }}
 279         run: cat build/Testing/Temporary/LastTest.log || true
 280       - uses: codecov/codecov-action@v1.0.13
 281
 282   # release builds
 283   release:
 284     strategy:
 285       fail-fast: false
 286       matrix:
 287         os_ver: [ubuntu-20.04, ubuntu-18.04]
 288         cc_vnd: [gnu, clang]
 289         cc_ver: [new, cur, old]
 290     runs-on: ${{ matrix.os_ver }}
 291     continue-on-error: ${{ matrix.cc_vnd == 'clang' }}
 292     env:
 293       CMAKE_BUILD_TYPE: Release
 294       OS_VND: Linux
 295       OS_VER: ${{ matrix.os_ver }}
 296       CC_VND: ${{ matrix.cc_vnd }}
 297       CC_VER: ${{ matrix.cc_ver }}
 298     steps:
 299       - uses: actions/checkout@v2
 300       - name: Prepare environment (for new gnu on ubuntu-20.04)
 301         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='gnu') && (env.CC_VER=='new')
 302         run: |
 303           echo CC="gcc-10" >> ${GITHUB_ENV}
 304           echo CXX="g++-10" >> ${GITHUB_ENV}
 305           echo INSTALL_CC="gcc-10" >> ${GITHUB_ENV}
 306           echo INSTALL_CXX="g++-10" >> ${GITHUB_ENV}
 307       - name: Prepare environment (for cur gnu on ubuntu-20.04)
 308         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='gnu') && (env.CC_VER=='cur')
 309         run: |
 310           echo CC="gcc-9" >> ${GITHUB_ENV}
 311           echo CXX="g++-9" >> ${GITHUB_ENV}
 312       - name: Prepare environment (for old gnu on ubuntu-20.04)
 313         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='gnu') && (env.CC_VER=='old')
 314         run: |
 315           echo CC="gcc-8" >> ${GITHUB_ENV}
 316           echo CXX="g++-8" >> ${GITHUB_ENV}
 317       - name: Prepare environment (for new clang on ubuntu-20.04)
 318         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='clang') && (env.CC_VER=='new')
 319         run: |
 320           echo CC="clang-10" >> ${GITHUB_ENV}
 321           echo CXX="clang++-10" >> ${GITHUB_ENV}
 322       - name: Prepare environment (for cur clang on ubuntu-20.04)
 323         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='clang') && (env.CC_VER=='cur')
 324         run: |
 325           echo CC="clang-9" >> ${GITHUB_ENV}
 326           echo CXX="clang++-9" >> ${GITHUB_ENV}
 327       - name: Prepare environment (for old clang on ubuntu-20.04)
 328         if: (env.OS_VER=='ubuntu-20.04') && (env.CC_VND=='clang') && (env.CC_VER=='old')
 329         run: |
 330           echo CC="clang-8" >> ${GITHUB_ENV}
 331           echo CXX="clang++-8" >> ${GITHUB_ENV}
 332       - name: Prepare environment (for new gnu on ubuntu-18.04)
 333         if: (env.OS_VER=='ubuntu-18.04') && (env.CC_VND=='gnu') && (env.CC_VER=='new')
 334         run: |
 335           echo CC="gcc-9" >> ${GITHUB_ENV}
 336           echo CXX="g++-9" >> ${GITHUB_ENV}
 337       - name: Prepare environment (for cur gnu on ubuntu-18.04)
 338         if: (env.OS_VER=='ubuntu-18.04') && (env.CC_VND=='gnu') && (env.CC_VER=='cur')
 339         run: |
 340           echo CC="gcc-8" >> ${GITHUB_ENV}
 341           echo CXX="g++-8" >> ${GITHUB_ENV}
 342       - name: Prepare environment (for old gnu on ubuntu-18.04)
 343         if: (env.OS_VER=='ubuntu-18.04') && (env.CC_VND=='gnu') && (env.CC_VER=='old')
 344         run: |
 345           echo CC="gcc-7" >> ${GITHUB_ENV}
 346           echo CXX="g++-7" >> ${GITHUB_ENV}
 347       - name: Prepare environment (for new clang on ubuntu-18.04)
 348         if: (env.OS_VER=='ubuntu-18.04') && (env.CC_VND=='clang') && (env.CC_VER=='new')
 349         run: |
 350           echo CC="clang-9" >> ${GITHUB_ENV}
 351           echo CXX="clang++-9" >> ${GITHUB_ENV}
 352       - name: Prepare environment (for cur clang on ubuntu-18.04)
 353         if: (env.OS_VER=='ubuntu-18.04') && (env.CC_VND=='clang') && (env.CC_VER=='cur')
 354         run: |
 355           echo CC="clang-8" >> ${GITHUB_ENV}
 356           echo CXX="clang++-8" >> ${GITHUB_ENV}
 357       - name: Prepare environment (for old clang on ubuntu-18.04)
 358         if: (env.OS_VER=='ubuntu-18.04') && (env.CC_VND=='clang') && (env.CC_VER=='old')
 359         run: |
 360           echo CC="clang-6.0" >> ${GITHUB_ENV}
 361           echo CXX="clang++-6.0" >> ${GITHUB_ENV}
 362           echo CXXFLAGS="-stdlib=libc++" >> ${GITHUB_ENV}
 363       - name: Install dependencies (Linux)
 364         if: runner.os == 'Linux'
 365         run: |
 366           sudo apt-get install \
 367             libevent-dev \
 368             libsasl2-dev \
 369             ${INSTALL_MEMCACHED} \
 370             ${INSTALL_CC} ${INSTALL_CXX}
 371           sudo systemctl stop memcached || true
 372       - name: Install dependencies (Mac)
 373         if: runner.os == 'macOS'
 374         run: |
 375           brew install bison flex ${INSTALL_MEMCACHED}
 376           brew services stop memcached || true
 377           echo MEMCACHED_BINARY="/usr/local/bin/memcached" >> ${GITHUB_ENV}
 378       - name: Build memcached
 379         run: |
 380           if test -d memcached
 381           then
 382             cd memcached
 383             ./autogen.sh
 384             ./configure CFLAGS="-O2 -pipe" \
 385               --prefix=${MEMCACHED_PREFIX} \
 386               --enable-sasl \
 387               --enable-sasl-pwdb \
 388               --disable-coverage \
 389               --disable-dependency-tracking \
 390               --disable-docs \
 391               --disable-extstore \
 392               --disable-option-checking \
 393               ;
 394             make -j2
 395             make install
 396             cd ..
 397             echo MEMCACHED_BINARY="${MEMCACHED_PREFIX}/bin/memcached" >> ${GITHUB_ENV}
 398           fi
 399       - name: Generate build tree (${{ env.CMAKE_BUILD_TYPE }})
 400         run: cmake -S . -B build
 401       - name: Build all with ${{ env.CXX }} ${{ env.CXXFLAGS }}
 402         run: make -C build -j2 all
 403       - name: Test
 404         run: make -C build -j2 test
 405       - name: Install
 406         run: make -C build -j2 install DESTDIR=.
 407       - name: Failed tests log
 408         if: ${{ failure() }}
 409         run: cat build/Testing/Temporary/LastTest.log || true