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