mirror/curl
2
0
Fork 0
mirror of https://github.com/curl/curl.git synced 2024-12-27 06:59:43 +08:00
Code Issues Packages Projects Releases Wiki Activity
0b520e1250
curl/.github/workflows/windows.yml

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

472 lines
20 KiB
YAML
Raw Normal View History

GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
# Copyright (C) Viktor Szakats
#
# SPDX-License-Identifier: curl
name: windows
on:
push:
branches:
- master
- '*/ci'
paths-ignore:
- '**/*.md'
- '.azure-pipelines.yml'
- '.circleci/**'
- '.cirrus.yml'
- 'appveyor.*'
- 'packages/**'
- 'plan9/**'
- 'projects/**'
- 'winbuild/**'
pull_request:
branches:
- master
paths-ignore:
- '**/*.md'
- '.azure-pipelines.yml'
- '.circleci/**'
- '.cirrus.yml'
- 'appveyor.*'
- 'packages/**'
- 'plan9/**'
- 'projects/**'
- 'winbuild/**'
concurrency:
group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.sha }}
cancel-in-progress: true
permissions: {}
jobs:
cygwin:
GHA: add three old (gcc 6, 7, 9) mingw-w64 jobs Re-implement old mingw-w64 jobs in GHA. This allows to use the latest Windows runners, replacing Windows Server 2012 R2 (gcc 6) and Windows Server 2016 (gcc 7, 9) with Windows Server 2022. GHA runners are also significantly faster, and allow running tests in parallel (`-j14`). It also offloads 3 more long-running jobs from AppVeyor CI. These jobs download (then cache) the mingw-w64 packages from their original location, which allows flexibility in choosing which versions and flavours (win32/POSIX, SEH/DWARF, 64/32-bit) we want to test in CI. The new jobs use these distros: - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/ (for gcc 7, same as on AppVeyor) - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/ (for gcc 6, same as on AppVeyor) - https://winlibs.com/ (for gcc 9) I matched existing AppVeyor job configs, with these differences: - gcc 6.4.0 instead of 6.3.0. (same distro as on AppVeyor, but the latest bugfix release) - gcc 9.5.0 instead of 9.1.0 and a different (but compatible) binary distro. (in AppVeyor this relies on an old MSYS2 pre-installed on the runner) - using win32 builds instead of posix for gcc 6.4.0 and 7.3.0. - websockets enabled. - always build examples. - always build tests (this wasn't done for 6.4.0 with AppVeyor CI). I did not replicate existing test exclusions, and oddly enough the few failures (so far) were different from MSYS2 jobs and also from their AppVeyor CI counterparts. Also: - delete redundant (default) `-u` option from `cygpath` calls. - allow matrix options to override default ones in CMake. - detect and use Windows-supplied curl for `TFLAGS` `-ac` option. (it's available in modern runners.) - delete the 3 AppVeyor CI jobs now replicated in GHA. - appveyor: prefer `SYSTEMROOT` over `WINDIR`. - tidy-up quotes. Job performance: ``` AppVeyor GHA w/examples w/tests -------- ---------- CMake, mingw-w64, gcc 6, Debug, x86, Schannel, Static, no-unity 1m25s 8m50s CMake, mingw-w64, gcc 7, Debug, x64, Schannel, Static, Unicode 31m45s 9m39s CMake, mingw-w64, gcc 9, Debug, x64, Schannel, Static 28m25s 13m38s ``` Based on these runs: https://ci.appveyor.com/project/curlorg/curl/builds/49880799 https://github.com/curl/curl/actions/runs/9218292508 Notice that building examples and tests is time consuming. We can tweak any build parameter as necessary to make them more useful and/or without clogging the job queue or introducing flakiness. Closes #13759
2024-05-23 20:54:49 +08:00
name: 'cygwin (${{ matrix.build }}, ${{ matrix.platform }}, ${{ matrix.config }})'
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
runs-on: windows-latest
timeout-minutes: 45
env:
SHELLOPTS: 'igncr'
strategy:
matrix:
include:
CI: tidy up skipping tests build/run in Windows jobs Simplify controlling whether to build and/run tests in a CI job. Apply the TFLAGS='skipall' (do not build nor run tests) or 'skiprun' (build, but do not run) method already used with old-mingw-w64 and msvc jobs to existing Windows jobs in GHA and AppVeyor. Also: - add Cygwin/cmake test build and run steps while here. - replace `DISABLED_TESTS` with `TFLAGS` in AppVeyor. Closes #13796
2024-05-28 00:48:32 +08:00
- { build: 'automake', platform: 'x86_64', tflags: '' , config: '--enable-debug --disable-threaded-resolver' }
- { build: 'cmake' , platform: 'x86_64', tflags: 'skipall', config: '-DCURL_USE_OPENSSL=ON' }
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
fail-fast: false
steps:
- run: git config --global core.autocrlf input
GHA: bump actions/checkout from 4.1.4 to 4.1.6 Bumps [actions/checkout](https://github.com/actions/checkout) from 4.1.4 to 4.1.6. - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/0ad4b8fadaa221de15dcec353f45205ec38ea70b...a5ac7e51b41094c92402da3b24376905380afc29) --- updated-dependencies: - dependency-name: actions/checkout dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> Closes #13720
2024-05-20 22:25:03 +08:00
- uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4
GHA: pin dependencies Closes #13691
2024-05-18 06:31:56 +08:00
- uses: cygwin/cygwin-install-action@006ad0b0946ca6d0a3ea2d4437677fa767392401 # v4
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
with:
platform: ${{ matrix.platform }}
# https://cygwin.com/cgi-bin2/package-grep.cgi
packages: autoconf libtool ${{ matrix.build }} gcc-core gcc-g++ binutils make libssl-devel zlib-devel libbrotli-devel libnghttp2-devel libpsl-devel libssh2-devel
site: https://mirrors.kernel.org/sourceware/cygwin/
- name: 'autotools configure'
if: ${{ matrix.build == 'automake' }}
timeout-minutes: 5
shell: C:\cygwin\bin\bash.exe '{0}'
run: |
export PATH="/usr/bin:$(cygpath ${SYSTEMROOT})/system32"
autoreconf -fi
mkdir bld && cd bld && ../configure --enable-warnings --enable-werror \
--prefix="${HOME}"/install \
--enable-websockets \
--with-openssl \
--with-libssh2 \
CI: disable dependency tracking in most autotools builds For better build performance. Dependency tracking causes a build overhead while compiling to help a subsequent build, but in CI there is never one and the extra work is discarded. Closes #13794
2024-05-27 21:19:35 +08:00
--disable-dependency-tracking \
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
${{ matrix.config }} || { tail -n 1200 config.log; false; }
- name: 'autotools build'
if: ${{ matrix.build == 'automake' }}
timeout-minutes: 10
shell: C:\cygwin\bin\bash.exe '{0}'
run: |
make -C bld -j3 V=1 install
find . -name '*.exe' -o -name '*.dll'
bld/src/curl.exe --disable --version
- name: 'autotools build examples'
if: ${{ matrix.build == 'automake' }}
timeout-minutes: 5
shell: C:\cygwin\bin\bash.exe '{0}'
run: |
make -C bld -j3 V=1 examples
- name: 'autotools build tests'
CI: tidy up skipping tests build/run in Windows jobs Simplify controlling whether to build and/run tests in a CI job. Apply the TFLAGS='skipall' (do not build nor run tests) or 'skiprun' (build, but do not run) method already used with old-mingw-w64 and msvc jobs to existing Windows jobs in GHA and AppVeyor. Also: - add Cygwin/cmake test build and run steps while here. - replace `DISABLED_TESTS` with `TFLAGS` in AppVeyor. Closes #13796
2024-05-28 00:48:32 +08:00
if: ${{ matrix.build == 'automake' && matrix.tflags != 'skipall' }}
GHA: increase timeout for Cygwin autotools build tests step Apparently 10 minutes are not (always) enough: https://github.com/curl/curl/actions/runs/9197003907/job/25296439556#step:8:1936 Closes #13753
2024-05-23 03:37:35 +08:00
timeout-minutes: 15
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
shell: C:\cygwin\bin\bash.exe '{0}'
run: |
make -C bld -j3 -C tests V=1
- name: 'autotools run tests'
CI: tidy up skipping tests build/run in Windows jobs Simplify controlling whether to build and/run tests in a CI job. Apply the TFLAGS='skipall' (do not build nor run tests) or 'skiprun' (build, but do not run) method already used with old-mingw-w64 and msvc jobs to existing Windows jobs in GHA and AppVeyor. Also: - add Cygwin/cmake test build and run steps while here. - replace `DISABLED_TESTS` with `TFLAGS` in AppVeyor. Closes #13796
2024-05-28 00:48:32 +08:00
if: ${{ matrix.build == 'automake' && matrix.tflags != 'skipall' && matrix.tflags != 'skiprun' }}
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
timeout-minutes: 40
shell: C:\cygwin\bin\bash.exe '{0}'
run: |
export TFLAGS='-j8 ${{ matrix.tflags }}'
GHA: add three old (gcc 6, 7, 9) mingw-w64 jobs Re-implement old mingw-w64 jobs in GHA. This allows to use the latest Windows runners, replacing Windows Server 2012 R2 (gcc 6) and Windows Server 2016 (gcc 7, 9) with Windows Server 2022. GHA runners are also significantly faster, and allow running tests in parallel (`-j14`). It also offloads 3 more long-running jobs from AppVeyor CI. These jobs download (then cache) the mingw-w64 packages from their original location, which allows flexibility in choosing which versions and flavours (win32/POSIX, SEH/DWARF, 64/32-bit) we want to test in CI. The new jobs use these distros: - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/ (for gcc 7, same as on AppVeyor) - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/ (for gcc 6, same as on AppVeyor) - https://winlibs.com/ (for gcc 9) I matched existing AppVeyor job configs, with these differences: - gcc 6.4.0 instead of 6.3.0. (same distro as on AppVeyor, but the latest bugfix release) - gcc 9.5.0 instead of 9.1.0 and a different (but compatible) binary distro. (in AppVeyor this relies on an old MSYS2 pre-installed on the runner) - using win32 builds instead of posix for gcc 6.4.0 and 7.3.0. - websockets enabled. - always build examples. - always build tests (this wasn't done for 6.4.0 with AppVeyor CI). I did not replicate existing test exclusions, and oddly enough the few failures (so far) were different from MSYS2 jobs and also from their AppVeyor CI counterparts. Also: - delete redundant (default) `-u` option from `cygpath` calls. - allow matrix options to override default ones in CMake. - detect and use Windows-supplied curl for `TFLAGS` `-ac` option. (it's available in modern runners.) - delete the 3 AppVeyor CI jobs now replicated in GHA. - appveyor: prefer `SYSTEMROOT` over `WINDIR`. - tidy-up quotes. Job performance: ``` AppVeyor GHA w/examples w/tests -------- ---------- CMake, mingw-w64, gcc 6, Debug, x86, Schannel, Static, no-unity 1m25s 8m50s CMake, mingw-w64, gcc 7, Debug, x64, Schannel, Static, Unicode 31m45s 9m39s CMake, mingw-w64, gcc 9, Debug, x64, Schannel, Static 28m25s 13m38s ``` Based on these runs: https://ci.appveyor.com/project/curlorg/curl/builds/49880799 https://github.com/curl/curl/actions/runs/9218292508 Notice that building examples and tests is time consuming. We can tweak any build parameter as necessary to make them more useful and/or without clogging the job queue or introducing flakiness. Closes #13759
2024-05-23 20:54:49 +08:00
if [ -x "$(cygpath "${SYSTEMROOT}/System32/curl.exe")" ]; then
TFLAGS+=" -ac $(cygpath "${SYSTEMROOT}/System32/curl.exe")"
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
fi
make -C bld -j3 V=1 test-ci
- name: 'cmake configure'
if: ${{ matrix.build == 'cmake' }}
timeout-minutes: 5
shell: C:\cygwin\bin\bash.exe '{0}'
run: |
export PATH="/usr/bin:$(cygpath ${SYSTEMROOT})/system32"
GHA: add three old (gcc 6, 7, 9) mingw-w64 jobs Re-implement old mingw-w64 jobs in GHA. This allows to use the latest Windows runners, replacing Windows Server 2012 R2 (gcc 6) and Windows Server 2016 (gcc 7, 9) with Windows Server 2022. GHA runners are also significantly faster, and allow running tests in parallel (`-j14`). It also offloads 3 more long-running jobs from AppVeyor CI. These jobs download (then cache) the mingw-w64 packages from their original location, which allows flexibility in choosing which versions and flavours (win32/POSIX, SEH/DWARF, 64/32-bit) we want to test in CI. The new jobs use these distros: - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/ (for gcc 7, same as on AppVeyor) - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/ (for gcc 6, same as on AppVeyor) - https://winlibs.com/ (for gcc 9) I matched existing AppVeyor job configs, with these differences: - gcc 6.4.0 instead of 6.3.0. (same distro as on AppVeyor, but the latest bugfix release) - gcc 9.5.0 instead of 9.1.0 and a different (but compatible) binary distro. (in AppVeyor this relies on an old MSYS2 pre-installed on the runner) - using win32 builds instead of posix for gcc 6.4.0 and 7.3.0. - websockets enabled. - always build examples. - always build tests (this wasn't done for 6.4.0 with AppVeyor CI). I did not replicate existing test exclusions, and oddly enough the few failures (so far) were different from MSYS2 jobs and also from their AppVeyor CI counterparts. Also: - delete redundant (default) `-u` option from `cygpath` calls. - allow matrix options to override default ones in CMake. - detect and use Windows-supplied curl for `TFLAGS` `-ac` option. (it's available in modern runners.) - delete the 3 AppVeyor CI jobs now replicated in GHA. - appveyor: prefer `SYSTEMROOT` over `WINDIR`. - tidy-up quotes. Job performance: ``` AppVeyor GHA w/examples w/tests -------- ---------- CMake, mingw-w64, gcc 6, Debug, x86, Schannel, Static, no-unity 1m25s 8m50s CMake, mingw-w64, gcc 7, Debug, x64, Schannel, Static, Unicode 31m45s 9m39s CMake, mingw-w64, gcc 9, Debug, x64, Schannel, Static 28m25s 13m38s ``` Based on these runs: https://ci.appveyor.com/project/curlorg/curl/builds/49880799 https://github.com/curl/curl/actions/runs/9218292508 Notice that building examples and tests is time consuming. We can tweak any build parameter as necessary to make them more useful and/or without clogging the job queue or introducing flakiness. Closes #13759
2024-05-23 20:54:49 +08:00
cmake -B bld ${options} \
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
"-DCMAKE_C_FLAGS=${cflags}" \
-DCMAKE_UNITY_BUILD=ON \
-DCURL_WERROR=ON \
-DBUILD_EXAMPLES=ON \
-DENABLE_WEBSOCKETS=ON \
GHA: add three old (gcc 6, 7, 9) mingw-w64 jobs Re-implement old mingw-w64 jobs in GHA. This allows to use the latest Windows runners, replacing Windows Server 2012 R2 (gcc 6) and Windows Server 2016 (gcc 7, 9) with Windows Server 2022. GHA runners are also significantly faster, and allow running tests in parallel (`-j14`). It also offloads 3 more long-running jobs from AppVeyor CI. These jobs download (then cache) the mingw-w64 packages from their original location, which allows flexibility in choosing which versions and flavours (win32/POSIX, SEH/DWARF, 64/32-bit) we want to test in CI. The new jobs use these distros: - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/ (for gcc 7, same as on AppVeyor) - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/ (for gcc 6, same as on AppVeyor) - https://winlibs.com/ (for gcc 9) I matched existing AppVeyor job configs, with these differences: - gcc 6.4.0 instead of 6.3.0. (same distro as on AppVeyor, but the latest bugfix release) - gcc 9.5.0 instead of 9.1.0 and a different (but compatible) binary distro. (in AppVeyor this relies on an old MSYS2 pre-installed on the runner) - using win32 builds instead of posix for gcc 6.4.0 and 7.3.0. - websockets enabled. - always build examples. - always build tests (this wasn't done for 6.4.0 with AppVeyor CI). I did not replicate existing test exclusions, and oddly enough the few failures (so far) were different from MSYS2 jobs and also from their AppVeyor CI counterparts. Also: - delete redundant (default) `-u` option from `cygpath` calls. - allow matrix options to override default ones in CMake. - detect and use Windows-supplied curl for `TFLAGS` `-ac` option. (it's available in modern runners.) - delete the 3 AppVeyor CI jobs now replicated in GHA. - appveyor: prefer `SYSTEMROOT` over `WINDIR`. - tidy-up quotes. Job performance: ``` AppVeyor GHA w/examples w/tests -------- ---------- CMake, mingw-w64, gcc 6, Debug, x86, Schannel, Static, no-unity 1m25s 8m50s CMake, mingw-w64, gcc 7, Debug, x64, Schannel, Static, Unicode 31m45s 9m39s CMake, mingw-w64, gcc 9, Debug, x64, Schannel, Static 28m25s 13m38s ``` Based on these runs: https://ci.appveyor.com/project/curlorg/curl/builds/49880799 https://github.com/curl/curl/actions/runs/9218292508 Notice that building examples and tests is time consuming. We can tweak any build parameter as necessary to make them more useful and/or without clogging the job queue or introducing flakiness. Closes #13759
2024-05-23 20:54:49 +08:00
-DCURL_BROTLI=ON -DUSE_NGHTTP2=ON \
${{ matrix.config }}
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
- name: 'cmake build'
if: ${{ matrix.build == 'cmake' }}
timeout-minutes: 10
shell: C:\cygwin\bin\bash.exe '{0}'
run: |
cmake --build bld --config '${{ matrix.type }}' --parallel 3
[[ '${{ matrix.config }}' != *'BUILD_SHARED_LIBS=OFF'* ]] && cp -f -p bld/lib/*.dll bld/src/
find . -name '*.exe' -o -name '*.dll'
bld/src/curl.exe --disable --version
CI: tidy up skipping tests build/run in Windows jobs Simplify controlling whether to build and/run tests in a CI job. Apply the TFLAGS='skipall' (do not build nor run tests) or 'skiprun' (build, but do not run) method already used with old-mingw-w64 and msvc jobs to existing Windows jobs in GHA and AppVeyor. Also: - add Cygwin/cmake test build and run steps while here. - replace `DISABLED_TESTS` with `TFLAGS` in AppVeyor. Closes #13796
2024-05-28 00:48:32 +08:00
- name: 'cmake build tests'
if: ${{ matrix.build == 'cmake' && matrix.tflags != 'skipall' }}
timeout-minutes: 15
shell: C:\cygwin\bin\bash.exe '{0}'
run: |
cmake --build bld --config '${{ matrix.type }}' --parallel 3 --target testdeps
- name: 'cmake run tests'
if: ${{ matrix.build == 'cmake' && matrix.tflags != 'skipall' && matrix.tflags != 'skiprun' }}
timeout-minutes: 40
shell: C:\cygwin\bin\bash.exe '{0}'
run: |
export TFLAGS='-j8 ${{ matrix.tflags }}'
if [ -x "$(cygpath "${SYSTEMROOT}/System32/curl.exe")" ]; then
TFLAGS+=" -ac $(cygpath "${SYSTEMROOT}/System32/curl.exe")"
fi
ls bld/lib/*.dll >/dev/null 2>&1 && cp -f -p bld/lib/*.dll bld/tests/libtest/
cmake --build bld --config '${{ matrix.type }}' --target test-ci
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
msys2:
GHA: add three old (gcc 6, 7, 9) mingw-w64 jobs Re-implement old mingw-w64 jobs in GHA. This allows to use the latest Windows runners, replacing Windows Server 2012 R2 (gcc 6) and Windows Server 2016 (gcc 7, 9) with Windows Server 2022. GHA runners are also significantly faster, and allow running tests in parallel (`-j14`). It also offloads 3 more long-running jobs from AppVeyor CI. These jobs download (then cache) the mingw-w64 packages from their original location, which allows flexibility in choosing which versions and flavours (win32/POSIX, SEH/DWARF, 64/32-bit) we want to test in CI. The new jobs use these distros: - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/ (for gcc 7, same as on AppVeyor) - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/ (for gcc 6, same as on AppVeyor) - https://winlibs.com/ (for gcc 9) I matched existing AppVeyor job configs, with these differences: - gcc 6.4.0 instead of 6.3.0. (same distro as on AppVeyor, but the latest bugfix release) - gcc 9.5.0 instead of 9.1.0 and a different (but compatible) binary distro. (in AppVeyor this relies on an old MSYS2 pre-installed on the runner) - using win32 builds instead of posix for gcc 6.4.0 and 7.3.0. - websockets enabled. - always build examples. - always build tests (this wasn't done for 6.4.0 with AppVeyor CI). I did not replicate existing test exclusions, and oddly enough the few failures (so far) were different from MSYS2 jobs and also from their AppVeyor CI counterparts. Also: - delete redundant (default) `-u` option from `cygpath` calls. - allow matrix options to override default ones in CMake. - detect and use Windows-supplied curl for `TFLAGS` `-ac` option. (it's available in modern runners.) - delete the 3 AppVeyor CI jobs now replicated in GHA. - appveyor: prefer `SYSTEMROOT` over `WINDIR`. - tidy-up quotes. Job performance: ``` AppVeyor GHA w/examples w/tests -------- ---------- CMake, mingw-w64, gcc 6, Debug, x86, Schannel, Static, no-unity 1m25s 8m50s CMake, mingw-w64, gcc 7, Debug, x64, Schannel, Static, Unicode 31m45s 9m39s CMake, mingw-w64, gcc 9, Debug, x64, Schannel, Static 28m25s 13m38s ``` Based on these runs: https://ci.appveyor.com/project/curlorg/curl/builds/49880799 https://github.com/curl/curl/actions/runs/9218292508 Notice that building examples and tests is time consuming. We can tweak any build parameter as necessary to make them more useful and/or without clogging the job queue or introducing flakiness. Closes #13759
2024-05-23 20:54:49 +08:00
name: 'msys2 (${{ matrix.build }}, ${{ matrix.sys }}, ${{ matrix.env }}, ${{ matrix.config }})'
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
runs-on: windows-latest
timeout-minutes: 45
strategy:
matrix:
include:
GHA: disable TFTP test on native Windows Some TFTP tests seem to enter into a loop and maybe hang? E.g. 1007, 1009, 1238 Try fixing it by skipping all TFTP tests. Ref: https://github.com/curl/curl/actions/runs/9141987545/job/25137038249?pr=13698 Also drop mingw-w64 test exclusions copy-pasted from MSYS jobs. Possibly related: cffbcc3110c1eda2e333f9cfe2e269154618793a #5364 Close #13699
2024-05-19 04:38:58 +08:00
- { build: 'autotools', sys: 'msys' , env: 'x86_64' , tflags: '!19 !1233', config: '--enable-debug --disable-threaded-resolver --disable-proxy' }
- { build: 'autotools', sys: 'msys' , env: 'x86_64' , tflags: '!19 !504 !704 !705 !1233', config: '--enable-debug --disable-threaded-resolver' }
- { build: 'autotools', sys: 'msys' , env: 'x86_64' , tflags: '!19 !504 !704 !705 !1233', config: '' }
build: untangle `CURLDEBUG` and `DEBUGBUILD` macros `CURLDEBUG` is meant to enable memory tracking, but in a bunch of cases, it was protecting debug features that were supposed to be guarded with `DEBUGBUILD`. Replace these uses with `DEBUGBUILD`. This leaves `CURLDEBUG` uses solely for its intended purpose: to enable the memory tracking debug feature. Also: - autotools: rely on `DEBUGBUILD` to enable `checksrc`. Instead of `CURLDEBUG`, which worked in most cases because debug builds enable `CURLDEBUG` by default, but it's not accurate. - include `lib/easyif.h` instead of keeping a copy of a declaration. - add CI test jobs for the build issues discovered. Ref: https://github.com/curl/curl/pull/13694#issuecomment-2120311894 Closes #13718
2024-05-20 20:21:05 +08:00
- { build: 'autotools', sys: 'mingw64', env: 'x86_64' , tflags: 'skiprun' , config: '--enable-debug --disable-threaded-resolver --disable-curldebug --enable-static=no' }
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
# FIXME: WebSockets test results ignored due to frequent failures on native Windows:
GHA: disable TFTP tests in Windows jobs Shot in the dark trying to find out which tests are hanging / going to an infinite loop. The ones failing after 45 minutes (mingw-w64) or 30 minutes (MSVC). Ref: https://github.com/curl/curl/pull/13599#issuecomment-2119372376
2024-05-28 19:07:34 +08:00
- { build: 'cmake' , sys: 'mingw64', env: 'x86_64' , tflags: '~2301 ~2302' , config: '-DENABLE_DEBUG=ON -DBUILD_SHARED_LIBS=OFF -DCURL_USE_SCHANNEL=ON -DENABLE_UNICODE=ON', type: 'Debug' }
cmake: fix `-Wredundant-decls` in unity/mingw-w64/gcc/curldebug/DLL builds It affected cmake-unity shared-curltool curldebug mingw-w64 gcc builds when building the `testdeps` target. Apply the solution already used in `lib/base64.c` and `lib/dynbuf.c` to fix it. Also update an existing GHA CI job to test the issue fixed. ``` In file included from curl/lib/version_win32.c:35, from curl/_bld/src/CMakeFiles/curl.dir/Unity/unity_0_c.c:145: curl/lib/memdebug.h:52:14: error: redundant redeclaration of 'curl_dbg_logfile' [-Werror=redundant-decls] 52 | extern FILE *curl_dbg_logfile; | ^~~~~~~~~~~~~~~~ In file included from curl/src/slist_wc.c:32, from curl/_bld/src/CMakeFiles/curl.dir/Unity/unity_0_c.c:4: curl/lib/memdebug.h:52:14: note: previous declaration of 'curl_dbg_logfile' with type 'FILE *' {aka 'struct _iobuf *'} 52 | extern FILE *curl_dbg_logfile; | ^~~~~~~~~~~~~~~~ curl/lib/memdebug.h:55:44: error: redundant redeclaration of 'curl_dbg_malloc' [-Werror=redundant-decls] 55 | CURL_EXTERN ALLOC_FUNC ALLOC_SIZE(1) void *curl_dbg_malloc(size_t size, | ^~~~~~~~~~~~~~~ curl/lib/memdebug.h:55:44: note: previous declaration of 'curl_dbg_malloc' with type 'void *(size_t, int, const char *)' {aka 'void *(long long unsigned int, int, const char *)'} 55 | CURL_EXTERN ALLOC_FUNC ALLOC_SIZE(1) void *curl_dbg_malloc(size_t size, | ^~~~~~~~~~~~~~~ [...] curl/lib/memdebug.h:110:17: error: redundant redeclaration of 'curl_dbg_fclose' [-Werror=redundant-decls] 110 | CURL_EXTERN int curl_dbg_fclose(FILE *file, int line, const char *source); | ^~~~~~~~~~~~~~~ curl/lib/memdebug.h:110:17: note: previous declaration of 'curl_dbg_fclose' with type 'int(FILE *, int, const char *)' {aka 'int(struct _iobuf *, int, const char *)'} 110 | CURL_EXTERN int curl_dbg_fclose(FILE *file, int line, const char *source); | ^~~~~~~~~~~~~~~ ``` Ref: https://ci.appveyor.com/project/curlorg/curl/builds/49840554/job/a4aoet17e9qnqx1a#L362 After: https://ci.appveyor.com/project/curlorg/curl/builds/49843735/job/hbo2uah2vj0ns523 Ref: #13689 (CI testing this PR with `DEBUGBUILD`/`CURLDEBUG`/shared-static combinations) Depends-on: #13694 Depends-on: #13800 Closes #13705
2024-05-19 22:55:45 +08:00
- { build: 'cmake' , sys: 'mingw64', env: 'x86_64' , tflags: 'skiprun' , config: '-DENABLE_DEBUG=OFF -DBUILD_SHARED_LIBS=ON -DCURL_USE_SCHANNEL=ON -DENABLE_UNICODE=ON -DENABLE_CURLDEBUG=ON', type: 'Release' }
CI: tidy up skipping tests build/run in Windows jobs Simplify controlling whether to build and/run tests in a CI job. Apply the TFLAGS='skipall' (do not build nor run tests) or 'skiprun' (build, but do not run) method already used with old-mingw-w64 and msvc jobs to existing Windows jobs in GHA and AppVeyor. Also: - add Cygwin/cmake test build and run steps while here. - replace `DISABLED_TESTS` with `TFLAGS` in AppVeyor. Closes #13796
2024-05-28 00:48:32 +08:00
- { build: 'cmake' , sys: 'clang64', env: 'clang-x86_64', tflags: 'skiprun' , config: '-DENABLE_DEBUG=ON -DBUILD_SHARED_LIBS=OFF -DCURL_USE_OPENSSL=ON -DENABLE_UNICODE=OFF', type: 'Release' }
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
fail-fast: false
steps:
- run: git config --global core.autocrlf input
GHA: bump actions/checkout from 4.1.4 to 4.1.6 Bumps [actions/checkout](https://github.com/actions/checkout) from 4.1.4 to 4.1.6. - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/0ad4b8fadaa221de15dcec353f45205ec38ea70b...a5ac7e51b41094c92402da3b24376905380afc29) --- updated-dependencies: - dependency-name: actions/checkout dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> Closes #13720
2024-05-20 22:25:03 +08:00
- uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4
GHA: pin dependencies Closes #13691
2024-05-18 06:31:56 +08:00
- uses: msys2/setup-msys2@d0e80f58dffbc64f6a3a1f43527d469b4fc7b6c8 # v2
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
if: ${{ matrix.sys == 'msys' }}
with:
msystem: ${{ matrix.sys }}
# https://packages.msys2.org/search
install: gcc ${{ matrix.build }} make openssl-devel zlib-devel brotli-devel libnghttp2-devel libpsl-devel libssh2-devel
GHA: pin dependencies Closes #13691
2024-05-18 06:31:56 +08:00
- uses: msys2/setup-msys2@d0e80f58dffbc64f6a3a1f43527d469b4fc7b6c8 # v2
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
if: ${{ matrix.sys != 'msys' }}
with:
msystem: ${{ matrix.sys }}
install: >-
mingw-w64-${{ matrix.env }}-cc
mingw-w64-${{ matrix.env }}-${{ matrix.build }} make
mingw-w64-${{ matrix.env }}-openssl
GHA: add autotools mingw-64, build-only job Cherry-picked from #13718 Closes #13793
2024-05-27 21:07:23 +08:00
mingw-w64-${{ matrix.env }}-libssh2
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
- name: 'autotools configure'
if: ${{ matrix.build == 'autotools' }}
timeout-minutes: 5
shell: msys2 {0}
run: |
autoreconf -fi
mkdir bld && cd bld && ../configure --enable-warnings --enable-werror \
--prefix="${HOME}"/install \
--enable-websockets \
--with-openssl \
--with-libssh2 \
CI: disable dependency tracking in most autotools builds For better build performance. Dependency tracking causes a build overhead while compiling to help a subsequent build, but in CI there is never one and the extra work is discarded. Closes #13794
2024-05-27 21:19:35 +08:00
--disable-dependency-tracking \
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
${{ matrix.config }} || { tail -n 1200 config.log; false; }
- name: 'autotools build'
if: ${{ matrix.build == 'autotools' }}
timeout-minutes: 10
shell: msys2 {0}
run: |
make -C bld -j3 V=1 install
find . -name '*.exe' -o -name '*.dll'
bld/src/curl.exe --disable --version
- name: 'autotools build examples'
if: ${{ matrix.build == 'autotools' }}
timeout-minutes: 5
shell: msys2 {0}
run: |
make -C bld -j3 V=1 examples
- name: 'autotools build tests'
CI: tidy up skipping tests build/run in Windows jobs Simplify controlling whether to build and/run tests in a CI job. Apply the TFLAGS='skipall' (do not build nor run tests) or 'skiprun' (build, but do not run) method already used with old-mingw-w64 and msvc jobs to existing Windows jobs in GHA and AppVeyor. Also: - add Cygwin/cmake test build and run steps while here. - replace `DISABLED_TESTS` with `TFLAGS` in AppVeyor. Closes #13796
2024-05-28 00:48:32 +08:00
if: ${{ matrix.build == 'autotools' && matrix.tflags != 'skipall' }}
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
timeout-minutes: 10
shell: msys2 {0}
run: |
make -C bld -j3 -C tests V=1
- name: 'autotools run tests'
CI: tidy up skipping tests build/run in Windows jobs Simplify controlling whether to build and/run tests in a CI job. Apply the TFLAGS='skipall' (do not build nor run tests) or 'skiprun' (build, but do not run) method already used with old-mingw-w64 and msvc jobs to existing Windows jobs in GHA and AppVeyor. Also: - add Cygwin/cmake test build and run steps while here. - replace `DISABLED_TESTS` with `TFLAGS` in AppVeyor. Closes #13796
2024-05-28 00:48:32 +08:00
if: ${{ matrix.build == 'autotools' && matrix.tflags != 'skipall' && matrix.tflags != 'skiprun' }}
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
timeout-minutes: 30
shell: msys2 {0}
run: |
GHA: disable TFTP tests in Windows jobs Shot in the dark trying to find out which tests are hanging / going to an infinite loop. The ones failing after 45 minutes (mingw-w64) or 30 minutes (MSVC). Ref: https://github.com/curl/curl/pull/13599#issuecomment-2119372376
2024-05-28 19:07:34 +08:00
export TFLAGS='-j14 !TFTP ${{ matrix.tflags }}'
GHA: add three old (gcc 6, 7, 9) mingw-w64 jobs Re-implement old mingw-w64 jobs in GHA. This allows to use the latest Windows runners, replacing Windows Server 2012 R2 (gcc 6) and Windows Server 2016 (gcc 7, 9) with Windows Server 2022. GHA runners are also significantly faster, and allow running tests in parallel (`-j14`). It also offloads 3 more long-running jobs from AppVeyor CI. These jobs download (then cache) the mingw-w64 packages from their original location, which allows flexibility in choosing which versions and flavours (win32/POSIX, SEH/DWARF, 64/32-bit) we want to test in CI. The new jobs use these distros: - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/ (for gcc 7, same as on AppVeyor) - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/ (for gcc 6, same as on AppVeyor) - https://winlibs.com/ (for gcc 9) I matched existing AppVeyor job configs, with these differences: - gcc 6.4.0 instead of 6.3.0. (same distro as on AppVeyor, but the latest bugfix release) - gcc 9.5.0 instead of 9.1.0 and a different (but compatible) binary distro. (in AppVeyor this relies on an old MSYS2 pre-installed on the runner) - using win32 builds instead of posix for gcc 6.4.0 and 7.3.0. - websockets enabled. - always build examples. - always build tests (this wasn't done for 6.4.0 with AppVeyor CI). I did not replicate existing test exclusions, and oddly enough the few failures (so far) were different from MSYS2 jobs and also from their AppVeyor CI counterparts. Also: - delete redundant (default) `-u` option from `cygpath` calls. - allow matrix options to override default ones in CMake. - detect and use Windows-supplied curl for `TFLAGS` `-ac` option. (it's available in modern runners.) - delete the 3 AppVeyor CI jobs now replicated in GHA. - appveyor: prefer `SYSTEMROOT` over `WINDIR`. - tidy-up quotes. Job performance: ``` AppVeyor GHA w/examples w/tests -------- ---------- CMake, mingw-w64, gcc 6, Debug, x86, Schannel, Static, no-unity 1m25s 8m50s CMake, mingw-w64, gcc 7, Debug, x64, Schannel, Static, Unicode 31m45s 9m39s CMake, mingw-w64, gcc 9, Debug, x64, Schannel, Static 28m25s 13m38s ``` Based on these runs: https://ci.appveyor.com/project/curlorg/curl/builds/49880799 https://github.com/curl/curl/actions/runs/9218292508 Notice that building examples and tests is time consuming. We can tweak any build parameter as necessary to make them more useful and/or without clogging the job queue or introducing flakiness. Closes #13759
2024-05-23 20:54:49 +08:00
if [ -x "$(cygpath "${SYSTEMROOT}/System32/curl.exe")" ]; then
TFLAGS+=" -ac $(cygpath "${SYSTEMROOT}/System32/curl.exe")"
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
fi
make -C bld -j3 V=1 test-ci
- name: 'cmake configure'
if: ${{ matrix.build == 'cmake' }}
timeout-minutes: 5
shell: msys2 {0}
run: |
if [[ '${{ matrix.env }}' = 'clang'* ]]; then
options='-DCMAKE_C_COMPILER=clang'
else
options='-DCMAKE_C_COMPILER=gcc'
fi
GHA: add three old (gcc 6, 7, 9) mingw-w64 jobs Re-implement old mingw-w64 jobs in GHA. This allows to use the latest Windows runners, replacing Windows Server 2012 R2 (gcc 6) and Windows Server 2016 (gcc 7, 9) with Windows Server 2022. GHA runners are also significantly faster, and allow running tests in parallel (`-j14`). It also offloads 3 more long-running jobs from AppVeyor CI. These jobs download (then cache) the mingw-w64 packages from their original location, which allows flexibility in choosing which versions and flavours (win32/POSIX, SEH/DWARF, 64/32-bit) we want to test in CI. The new jobs use these distros: - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/ (for gcc 7, same as on AppVeyor) - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/ (for gcc 6, same as on AppVeyor) - https://winlibs.com/ (for gcc 9) I matched existing AppVeyor job configs, with these differences: - gcc 6.4.0 instead of 6.3.0. (same distro as on AppVeyor, but the latest bugfix release) - gcc 9.5.0 instead of 9.1.0 and a different (but compatible) binary distro. (in AppVeyor this relies on an old MSYS2 pre-installed on the runner) - using win32 builds instead of posix for gcc 6.4.0 and 7.3.0. - websockets enabled. - always build examples. - always build tests (this wasn't done for 6.4.0 with AppVeyor CI). I did not replicate existing test exclusions, and oddly enough the few failures (so far) were different from MSYS2 jobs and also from their AppVeyor CI counterparts. Also: - delete redundant (default) `-u` option from `cygpath` calls. - allow matrix options to override default ones in CMake. - detect and use Windows-supplied curl for `TFLAGS` `-ac` option. (it's available in modern runners.) - delete the 3 AppVeyor CI jobs now replicated in GHA. - appveyor: prefer `SYSTEMROOT` over `WINDIR`. - tidy-up quotes. Job performance: ``` AppVeyor GHA w/examples w/tests -------- ---------- CMake, mingw-w64, gcc 6, Debug, x86, Schannel, Static, no-unity 1m25s 8m50s CMake, mingw-w64, gcc 7, Debug, x64, Schannel, Static, Unicode 31m45s 9m39s CMake, mingw-w64, gcc 9, Debug, x64, Schannel, Static 28m25s 13m38s ``` Based on these runs: https://ci.appveyor.com/project/curlorg/curl/builds/49880799 https://github.com/curl/curl/actions/runs/9218292508 Notice that building examples and tests is time consuming. We can tweak any build parameter as necessary to make them more useful and/or without clogging the job queue or introducing flakiness. Closes #13759
2024-05-23 20:54:49 +08:00
cflags='-Wno-deprecated-declarations' # for examples
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
if [ '${{ matrix.test }}' = 'uwp' ]; then
options+=' -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION=10.0'
pacman --noconfirm --ask 20 --noprogressbar --sync --needed 'mingw-w64-${{ matrix.env }}-winstorecompat-git'
specs="$(realpath gcc-specs-uwp)"
gcc -dumpspecs | sed -e 's/-lmingwex/-lwindowsapp -lmingwex -lwindowsapp -lwindowsappcompat/' -e 's/-lmsvcrt/-lmsvcr120_app/' > "${specs}"
cflags+=" -specs=${specs} -DWINSTORECOMPAT -DWINAPI_FAMILY=WINAPI_FAMILY_APP"
# CMake (as of v3.26.4) gets confused and applies the MSVC rc.exe command-line
# template to windres. Reset it to the windres template manually:
rcopts='<CMAKE_RC_COMPILER> -O coff <DEFINES> <INCLUDES> <FLAGS> <SOURCE> <OBJECT>'
else
rcopts=''
fi
[ '${{ matrix.type }}' = 'Debug' ] && options+=' -DCMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG='
[ '${{ matrix.type }}' = 'Release' ] && options+=' -DCMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE='
GHA: add three old (gcc 6, 7, 9) mingw-w64 jobs Re-implement old mingw-w64 jobs in GHA. This allows to use the latest Windows runners, replacing Windows Server 2012 R2 (gcc 6) and Windows Server 2016 (gcc 7, 9) with Windows Server 2022. GHA runners are also significantly faster, and allow running tests in parallel (`-j14`). It also offloads 3 more long-running jobs from AppVeyor CI. These jobs download (then cache) the mingw-w64 packages from their original location, which allows flexibility in choosing which versions and flavours (win32/POSIX, SEH/DWARF, 64/32-bit) we want to test in CI. The new jobs use these distros: - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/ (for gcc 7, same as on AppVeyor) - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/ (for gcc 6, same as on AppVeyor) - https://winlibs.com/ (for gcc 9) I matched existing AppVeyor job configs, with these differences: - gcc 6.4.0 instead of 6.3.0. (same distro as on AppVeyor, but the latest bugfix release) - gcc 9.5.0 instead of 9.1.0 and a different (but compatible) binary distro. (in AppVeyor this relies on an old MSYS2 pre-installed on the runner) - using win32 builds instead of posix for gcc 6.4.0 and 7.3.0. - websockets enabled. - always build examples. - always build tests (this wasn't done for 6.4.0 with AppVeyor CI). I did not replicate existing test exclusions, and oddly enough the few failures (so far) were different from MSYS2 jobs and also from their AppVeyor CI counterparts. Also: - delete redundant (default) `-u` option from `cygpath` calls. - allow matrix options to override default ones in CMake. - detect and use Windows-supplied curl for `TFLAGS` `-ac` option. (it's available in modern runners.) - delete the 3 AppVeyor CI jobs now replicated in GHA. - appveyor: prefer `SYSTEMROOT` over `WINDIR`. - tidy-up quotes. Job performance: ``` AppVeyor GHA w/examples w/tests -------- ---------- CMake, mingw-w64, gcc 6, Debug, x86, Schannel, Static, no-unity 1m25s 8m50s CMake, mingw-w64, gcc 7, Debug, x64, Schannel, Static, Unicode 31m45s 9m39s CMake, mingw-w64, gcc 9, Debug, x64, Schannel, Static 28m25s 13m38s ``` Based on these runs: https://ci.appveyor.com/project/curlorg/curl/builds/49880799 https://github.com/curl/curl/actions/runs/9218292508 Notice that building examples and tests is time consuming. We can tweak any build parameter as necessary to make them more useful and/or without clogging the job queue or introducing flakiness. Closes #13759
2024-05-23 20:54:49 +08:00
cmake -B bld ${options} \
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
"-DCMAKE_C_FLAGS=${cflags}" \
"-DCMAKE_RC_COMPILE_OBJECT=${rcopts}" \
GHA: add three old (gcc 6, 7, 9) mingw-w64 jobs Re-implement old mingw-w64 jobs in GHA. This allows to use the latest Windows runners, replacing Windows Server 2012 R2 (gcc 6) and Windows Server 2016 (gcc 7, 9) with Windows Server 2022. GHA runners are also significantly faster, and allow running tests in parallel (`-j14`). It also offloads 3 more long-running jobs from AppVeyor CI. These jobs download (then cache) the mingw-w64 packages from their original location, which allows flexibility in choosing which versions and flavours (win32/POSIX, SEH/DWARF, 64/32-bit) we want to test in CI. The new jobs use these distros: - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/ (for gcc 7, same as on AppVeyor) - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/ (for gcc 6, same as on AppVeyor) - https://winlibs.com/ (for gcc 9) I matched existing AppVeyor job configs, with these differences: - gcc 6.4.0 instead of 6.3.0. (same distro as on AppVeyor, but the latest bugfix release) - gcc 9.5.0 instead of 9.1.0 and a different (but compatible) binary distro. (in AppVeyor this relies on an old MSYS2 pre-installed on the runner) - using win32 builds instead of posix for gcc 6.4.0 and 7.3.0. - websockets enabled. - always build examples. - always build tests (this wasn't done for 6.4.0 with AppVeyor CI). I did not replicate existing test exclusions, and oddly enough the few failures (so far) were different from MSYS2 jobs and also from their AppVeyor CI counterparts. Also: - delete redundant (default) `-u` option from `cygpath` calls. - allow matrix options to override default ones in CMake. - detect and use Windows-supplied curl for `TFLAGS` `-ac` option. (it's available in modern runners.) - delete the 3 AppVeyor CI jobs now replicated in GHA. - appveyor: prefer `SYSTEMROOT` over `WINDIR`. - tidy-up quotes. Job performance: ``` AppVeyor GHA w/examples w/tests -------- ---------- CMake, mingw-w64, gcc 6, Debug, x86, Schannel, Static, no-unity 1m25s 8m50s CMake, mingw-w64, gcc 7, Debug, x64, Schannel, Static, Unicode 31m45s 9m39s CMake, mingw-w64, gcc 9, Debug, x64, Schannel, Static 28m25s 13m38s ``` Based on these runs: https://ci.appveyor.com/project/curlorg/curl/builds/49880799 https://github.com/curl/curl/actions/runs/9218292508 Notice that building examples and tests is time consuming. We can tweak any build parameter as necessary to make them more useful and/or without clogging the job queue or introducing flakiness. Closes #13759
2024-05-23 20:54:49 +08:00
'-DCMAKE_BUILD_TYPE=${{ matrix.type }}' \
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
-DCMAKE_UNITY_BUILD=ON \
-DCURL_WERROR=ON \
-DBUILD_EXAMPLES=ON \
-DENABLE_WEBSOCKETS=ON \
GHA: add three old (gcc 6, 7, 9) mingw-w64 jobs Re-implement old mingw-w64 jobs in GHA. This allows to use the latest Windows runners, replacing Windows Server 2012 R2 (gcc 6) and Windows Server 2016 (gcc 7, 9) with Windows Server 2022. GHA runners are also significantly faster, and allow running tests in parallel (`-j14`). It also offloads 3 more long-running jobs from AppVeyor CI. These jobs download (then cache) the mingw-w64 packages from their original location, which allows flexibility in choosing which versions and flavours (win32/POSIX, SEH/DWARF, 64/32-bit) we want to test in CI. The new jobs use these distros: - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/ (for gcc 7, same as on AppVeyor) - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/ (for gcc 6, same as on AppVeyor) - https://winlibs.com/ (for gcc 9) I matched existing AppVeyor job configs, with these differences: - gcc 6.4.0 instead of 6.3.0. (same distro as on AppVeyor, but the latest bugfix release) - gcc 9.5.0 instead of 9.1.0 and a different (but compatible) binary distro. (in AppVeyor this relies on an old MSYS2 pre-installed on the runner) - using win32 builds instead of posix for gcc 6.4.0 and 7.3.0. - websockets enabled. - always build examples. - always build tests (this wasn't done for 6.4.0 with AppVeyor CI). I did not replicate existing test exclusions, and oddly enough the few failures (so far) were different from MSYS2 jobs and also from their AppVeyor CI counterparts. Also: - delete redundant (default) `-u` option from `cygpath` calls. - allow matrix options to override default ones in CMake. - detect and use Windows-supplied curl for `TFLAGS` `-ac` option. (it's available in modern runners.) - delete the 3 AppVeyor CI jobs now replicated in GHA. - appveyor: prefer `SYSTEMROOT` over `WINDIR`. - tidy-up quotes. Job performance: ``` AppVeyor GHA w/examples w/tests -------- ---------- CMake, mingw-w64, gcc 6, Debug, x86, Schannel, Static, no-unity 1m25s 8m50s CMake, mingw-w64, gcc 7, Debug, x64, Schannel, Static, Unicode 31m45s 9m39s CMake, mingw-w64, gcc 9, Debug, x64, Schannel, Static 28m25s 13m38s ``` Based on these runs: https://ci.appveyor.com/project/curlorg/curl/builds/49880799 https://github.com/curl/curl/actions/runs/9218292508 Notice that building examples and tests is time consuming. We can tweak any build parameter as necessary to make them more useful and/or without clogging the job queue or introducing flakiness. Closes #13759
2024-05-23 20:54:49 +08:00
-DCURL_BROTLI=ON -DUSE_NGHTTP2=ON \
${{ matrix.config }}
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
- name: 'cmake build'
if: ${{ matrix.build == 'cmake' }}
timeout-minutes: 10
shell: msys2 {0}
run: |
cmake --build bld --config '${{ matrix.type }}' --parallel 3
[[ '${{ matrix.config }}' != *'BUILD_SHARED_LIBS=OFF'* ]] && cp -f -p bld/lib/*.dll bld/src/
find . -name '*.exe' -o -name '*.dll'
bld/src/curl.exe --disable --version
- name: 'cmake build tests'
CI: tidy up skipping tests build/run in Windows jobs Simplify controlling whether to build and/run tests in a CI job. Apply the TFLAGS='skipall' (do not build nor run tests) or 'skiprun' (build, but do not run) method already used with old-mingw-w64 and msvc jobs to existing Windows jobs in GHA and AppVeyor. Also: - add Cygwin/cmake test build and run steps while here. - replace `DISABLED_TESTS` with `TFLAGS` in AppVeyor. Closes #13796
2024-05-28 00:48:32 +08:00
if: ${{ matrix.build == 'cmake' && matrix.tflags != 'skipall' }}
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
timeout-minutes: 10
shell: msys2 {0}
run: |
cmake --build bld --config '${{ matrix.type }}' --parallel 3 --target testdeps
- name: 'cmake run tests'
CI: tidy up skipping tests build/run in Windows jobs Simplify controlling whether to build and/run tests in a CI job. Apply the TFLAGS='skipall' (do not build nor run tests) or 'skiprun' (build, but do not run) method already used with old-mingw-w64 and msvc jobs to existing Windows jobs in GHA and AppVeyor. Also: - add Cygwin/cmake test build and run steps while here. - replace `DISABLED_TESTS` with `TFLAGS` in AppVeyor. Closes #13796
2024-05-28 00:48:32 +08:00
if: ${{ matrix.build == 'cmake' && matrix.tflags != 'skipall' && matrix.tflags != 'skiprun' }}
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
timeout-minutes: 40
shell: msys2 {0}
run: |
GHA: disable TFTP tests in Windows jobs Shot in the dark trying to find out which tests are hanging / going to an infinite loop. The ones failing after 45 minutes (mingw-w64) or 30 minutes (MSVC). Ref: https://github.com/curl/curl/pull/13599#issuecomment-2119372376
2024-05-28 19:07:34 +08:00
export TFLAGS='-j14 !TFTP ${{ matrix.tflags }}'
GHA: add three old (gcc 6, 7, 9) mingw-w64 jobs Re-implement old mingw-w64 jobs in GHA. This allows to use the latest Windows runners, replacing Windows Server 2012 R2 (gcc 6) and Windows Server 2016 (gcc 7, 9) with Windows Server 2022. GHA runners are also significantly faster, and allow running tests in parallel (`-j14`). It also offloads 3 more long-running jobs from AppVeyor CI. These jobs download (then cache) the mingw-w64 packages from their original location, which allows flexibility in choosing which versions and flavours (win32/POSIX, SEH/DWARF, 64/32-bit) we want to test in CI. The new jobs use these distros: - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/ (for gcc 7, same as on AppVeyor) - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/ (for gcc 6, same as on AppVeyor) - https://winlibs.com/ (for gcc 9) I matched existing AppVeyor job configs, with these differences: - gcc 6.4.0 instead of 6.3.0. (same distro as on AppVeyor, but the latest bugfix release) - gcc 9.5.0 instead of 9.1.0 and a different (but compatible) binary distro. (in AppVeyor this relies on an old MSYS2 pre-installed on the runner) - using win32 builds instead of posix for gcc 6.4.0 and 7.3.0. - websockets enabled. - always build examples. - always build tests (this wasn't done for 6.4.0 with AppVeyor CI). I did not replicate existing test exclusions, and oddly enough the few failures (so far) were different from MSYS2 jobs and also from their AppVeyor CI counterparts. Also: - delete redundant (default) `-u` option from `cygpath` calls. - allow matrix options to override default ones in CMake. - detect and use Windows-supplied curl for `TFLAGS` `-ac` option. (it's available in modern runners.) - delete the 3 AppVeyor CI jobs now replicated in GHA. - appveyor: prefer `SYSTEMROOT` over `WINDIR`. - tidy-up quotes. Job performance: ``` AppVeyor GHA w/examples w/tests -------- ---------- CMake, mingw-w64, gcc 6, Debug, x86, Schannel, Static, no-unity 1m25s 8m50s CMake, mingw-w64, gcc 7, Debug, x64, Schannel, Static, Unicode 31m45s 9m39s CMake, mingw-w64, gcc 9, Debug, x64, Schannel, Static 28m25s 13m38s ``` Based on these runs: https://ci.appveyor.com/project/curlorg/curl/builds/49880799 https://github.com/curl/curl/actions/runs/9218292508 Notice that building examples and tests is time consuming. We can tweak any build parameter as necessary to make them more useful and/or without clogging the job queue or introducing flakiness. Closes #13759
2024-05-23 20:54:49 +08:00
if [ -x "$(cygpath "${SYSTEMROOT}/System32/curl.exe")" ]; then
TFLAGS+=" -ac $(cygpath "${SYSTEMROOT}/System32/curl.exe")"
fi
ls bld/lib/*.dll >/dev/null 2>&1 && cp -f -p bld/lib/*.dll bld/tests/libtest/
cmake --build bld --config '${{ matrix.type }}' --target test-ci
old-mingw-w64:
name: 'old-mingw-w64 (${{ matrix.build }}, ${{ matrix.env }}, ${{ matrix.config }})'
runs-on: windows-latest
timeout-minutes: 45
strategy:
matrix:
include:
- build: 'cmake'
env: '9.5.0-x86_64'
url: 'https://github.com/brechtsanders/winlibs_mingw/releases/download/9.5.0-10.0.0-msvcrt-r1/winlibs-x86_64-posix-seh-gcc-9.5.0-mingw-w64msvcrt-10.0.0-r1.7z'
config: '-DENABLE_DEBUG=ON -DBUILD_SHARED_LIBS=OFF -DCURL_USE_SCHANNEL=ON -DENABLE_UNICODE=OFF'
cmake: `ENABLE_DEBUG=ON` to always set `-DDEBUGBUILD` Before this patch `ENABLE_DEBUG=ON` always enabled the TrackMemory (aka `ENABLE_CURLDEBUG=ON`) feature, but required the `Debug` CMake configration to actually enable curl debug features (aka `-DDEBUGBUILD`). Curl debug features do not require compiling with C debug options. This also made enabling debug features unintuitive and complicated to use. Due to other issues (subject to PR #13694) it also caused an error in default (and `Release`/`MinSizeRel`/`RelWithDebInfo`) configs, when building the `testdeps` target: ``` ld: CMakeFiles/unit1395.dir/unit1395.c.o: in function `test': unit1395.c:(.text+0x1a0): undefined reference to `dedotdotify' ``` Ref: https://github.com/curl/curl/actions/runs/9037287098/job/24835990826#step:3:2483 Fix it by always defining `DEBUGBUILD` when setting `ENABLE_DEBUG=ON`. Decoupling this option from the selected CMake configuration. Note that after this patch `ENABLE_DEBUG=ON` unconditionally enables curl debug features. These features are insecure and unsuited for production. Make sure to omit this option when building for production in default, `Release` (and other not-`Debug`) modes. Also delete a workaround no longer necessary in GHA CI jobs. Ref: 1a62b6e68c08c7e471ff22dd92932aba7e026817 (2015-03-03) Ref: #13583 Closes #13592
2024-05-11 08:44:10 +08:00
type: 'Release'
GHA: enable tests 1139, 1177, 1477 on Windows These exclusions came from the AppVeyor CI config, but they do pass now and they are static tests with no flakiness risk. Follow-up to 0914d8aadddac0d1459673d5b7f77e8f3378b22b #13759 Closes #13817
2024-05-29 01:19:43 +08:00
tflags: '~2301 ~2302 ~3027'
GHA: add three old (gcc 6, 7, 9) mingw-w64 jobs Re-implement old mingw-w64 jobs in GHA. This allows to use the latest Windows runners, replacing Windows Server 2012 R2 (gcc 6) and Windows Server 2016 (gcc 7, 9) with Windows Server 2022. GHA runners are also significantly faster, and allow running tests in parallel (`-j14`). It also offloads 3 more long-running jobs from AppVeyor CI. These jobs download (then cache) the mingw-w64 packages from their original location, which allows flexibility in choosing which versions and flavours (win32/POSIX, SEH/DWARF, 64/32-bit) we want to test in CI. The new jobs use these distros: - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/ (for gcc 7, same as on AppVeyor) - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/ (for gcc 6, same as on AppVeyor) - https://winlibs.com/ (for gcc 9) I matched existing AppVeyor job configs, with these differences: - gcc 6.4.0 instead of 6.3.0. (same distro as on AppVeyor, but the latest bugfix release) - gcc 9.5.0 instead of 9.1.0 and a different (but compatible) binary distro. (in AppVeyor this relies on an old MSYS2 pre-installed on the runner) - using win32 builds instead of posix for gcc 6.4.0 and 7.3.0. - websockets enabled. - always build examples. - always build tests (this wasn't done for 6.4.0 with AppVeyor CI). I did not replicate existing test exclusions, and oddly enough the few failures (so far) were different from MSYS2 jobs and also from their AppVeyor CI counterparts. Also: - delete redundant (default) `-u` option from `cygpath` calls. - allow matrix options to override default ones in CMake. - detect and use Windows-supplied curl for `TFLAGS` `-ac` option. (it's available in modern runners.) - delete the 3 AppVeyor CI jobs now replicated in GHA. - appveyor: prefer `SYSTEMROOT` over `WINDIR`. - tidy-up quotes. Job performance: ``` AppVeyor GHA w/examples w/tests -------- ---------- CMake, mingw-w64, gcc 6, Debug, x86, Schannel, Static, no-unity 1m25s 8m50s CMake, mingw-w64, gcc 7, Debug, x64, Schannel, Static, Unicode 31m45s 9m39s CMake, mingw-w64, gcc 9, Debug, x64, Schannel, Static 28m25s 13m38s ``` Based on these runs: https://ci.appveyor.com/project/curlorg/curl/builds/49880799 https://github.com/curl/curl/actions/runs/9218292508 Notice that building examples and tests is time consuming. We can tweak any build parameter as necessary to make them more useful and/or without clogging the job queue or introducing flakiness. Closes #13759
2024-05-23 20:54:49 +08:00
- build: 'cmake'
env: '7.3.0-x86_64'
url: 'https://downloads.sourceforge.net/mingw-w64/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/7.3.0/threads-win32/seh/x86_64-7.3.0-release-win32-seh-rt_v5-rev0.7z'
config: '-DENABLE_DEBUG=ON -DBUILD_SHARED_LIBS=OFF -DCURL_USE_SCHANNEL=ON -DENABLE_UNICODE=ON'
type: 'Debug'
GHA: enable tests 1139, 1177, 1477 on Windows These exclusions came from the AppVeyor CI config, but they do pass now and they are static tests with no flakiness risk. Follow-up to 0914d8aadddac0d1459673d5b7f77e8f3378b22b #13759 Closes #13817
2024-05-29 01:19:43 +08:00
tflags: '~2301 ~2302 ~3027'
GHA: add three old (gcc 6, 7, 9) mingw-w64 jobs Re-implement old mingw-w64 jobs in GHA. This allows to use the latest Windows runners, replacing Windows Server 2012 R2 (gcc 6) and Windows Server 2016 (gcc 7, 9) with Windows Server 2022. GHA runners are also significantly faster, and allow running tests in parallel (`-j14`). It also offloads 3 more long-running jobs from AppVeyor CI. These jobs download (then cache) the mingw-w64 packages from their original location, which allows flexibility in choosing which versions and flavours (win32/POSIX, SEH/DWARF, 64/32-bit) we want to test in CI. The new jobs use these distros: - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/ (for gcc 7, same as on AppVeyor) - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/ (for gcc 6, same as on AppVeyor) - https://winlibs.com/ (for gcc 9) I matched existing AppVeyor job configs, with these differences: - gcc 6.4.0 instead of 6.3.0. (same distro as on AppVeyor, but the latest bugfix release) - gcc 9.5.0 instead of 9.1.0 and a different (but compatible) binary distro. (in AppVeyor this relies on an old MSYS2 pre-installed on the runner) - using win32 builds instead of posix for gcc 6.4.0 and 7.3.0. - websockets enabled. - always build examples. - always build tests (this wasn't done for 6.4.0 with AppVeyor CI). I did not replicate existing test exclusions, and oddly enough the few failures (so far) were different from MSYS2 jobs and also from their AppVeyor CI counterparts. Also: - delete redundant (default) `-u` option from `cygpath` calls. - allow matrix options to override default ones in CMake. - detect and use Windows-supplied curl for `TFLAGS` `-ac` option. (it's available in modern runners.) - delete the 3 AppVeyor CI jobs now replicated in GHA. - appveyor: prefer `SYSTEMROOT` over `WINDIR`. - tidy-up quotes. Job performance: ``` AppVeyor GHA w/examples w/tests -------- ---------- CMake, mingw-w64, gcc 6, Debug, x86, Schannel, Static, no-unity 1m25s 8m50s CMake, mingw-w64, gcc 7, Debug, x64, Schannel, Static, Unicode 31m45s 9m39s CMake, mingw-w64, gcc 9, Debug, x64, Schannel, Static 28m25s 13m38s ``` Based on these runs: https://ci.appveyor.com/project/curlorg/curl/builds/49880799 https://github.com/curl/curl/actions/runs/9218292508 Notice that building examples and tests is time consuming. We can tweak any build parameter as necessary to make them more useful and/or without clogging the job queue or introducing flakiness. Closes #13759
2024-05-23 20:54:49 +08:00
- build: 'cmake'
env: '6.4.0-i686'
url: 'https://downloads.sourceforge.net/mingw-w64/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/6.4.0/threads-win32/dwarf/i686-6.4.0-release-win32-dwarf-rt_v5-rev0.7z'
config: '-DENABLE_DEBUG=ON -DBUILD_SHARED_LIBS=OFF -DCURL_USE_SCHANNEL=ON -DENABLE_UNICODE=OFF -DCMAKE_UNITY_BUILD=OFF'
type: 'Debug'
tflags: 'skiprun'
fail-fast: false
steps:
- name: 'cache compiler (gcc ${{ matrix.env }})'
uses: actions/cache@0c45773b623bea8c8e75f6c82b208c3cf94ea4f9 # v4
id: cache-compiler
with:
path: C:\my-cache\mingw-w64-${{ matrix.env }}
key: ${{ runner.os }}-mingw-w64-${{ matrix.env }}
- name: 'install compiler (gcc ${{ matrix.env }})'
if: ${{ steps.cache-compiler.outputs.cache-hit != 'true' }}
timeout-minutes: 5
shell: C:\msys64\usr\bin\bash.exe {0}
run: |
mkdir -p /c/my-cache/
cd /c/my-cache/ || exit 1
curl --fail --silent --show-error --retry 3 --retry-connrefused --output pack.bin --location --proto-redir =https '${{ matrix.url }}'
mkdir -p mingw-w64-${{ matrix.env }}
cd mingw-w64-${{ matrix.env }} || exit 1
pwd
7z x -y ../pack.bin >/dev/null
- run: git config --global core.autocrlf input
- uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4
- name: 'update PATH (gcc ${{ matrix.env }})'
shell: C:\msys64\usr\bin\bash.exe {0}
run: |
echo "PATH=/c/my-cache/mingw-w64-${{ matrix.env }}/mingw64/bin:/c/msys64/usr/bin:$PATH" >> $GITHUB_ENV
- name: 'cmake configure'
if: ${{ matrix.build == 'cmake' }}
timeout-minutes: 5
shell: C:\msys64\usr\bin\bash.exe {0}
run: |
cflags='-Wno-deprecated-declarations' # for examples
[ '${{ matrix.type }}' = 'Debug' ] && options+=' -DCMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG='
[ '${{ matrix.type }}' = 'Release' ] && options+=' -DCMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE='
cmake -B bld ${options} \
'-GMSYS Makefiles' \
-DCMAKE_C_COMPILER=gcc \
"-DCMAKE_C_FLAGS=${cflags}" \
'-DCMAKE_BUILD_TYPE=${{ matrix.type }}' \
-DCMAKE_UNITY_BUILD=ON \
-DCURL_WERROR=ON \
-DBUILD_EXAMPLES=ON \
-DENABLE_WEBSOCKETS=ON \
${{ matrix.config }}
- name: 'cmake build'
if: ${{ matrix.build == 'cmake' }}
timeout-minutes: 10
shell: C:\msys64\usr\bin\bash.exe {0}
run: |
cmake --build bld --config '${{ matrix.type }}' --parallel 3
[[ '${{ matrix.config }}' != *'BUILD_SHARED_LIBS=OFF'* ]] && cp -f -p bld/lib/*.dll bld/src/
bld/src/curl.exe --disable --version
- name: 'cmake build tests'
if: ${{ matrix.build == 'cmake' && matrix.tflags != 'skipall' }}
timeout-minutes: 10
shell: C:\msys64\usr\bin\bash.exe {0}
run: |
cmake --build bld --config '${{ matrix.type }}' --parallel 3 --target testdeps
- name: 'cmake run tests'
if: ${{ matrix.build == 'cmake' && matrix.tflags != 'skipall' && matrix.tflags != 'skiprun' }}
timeout-minutes: 40
shell: C:\msys64\usr\bin\bash.exe {0}
run: |
GHA: disable TFTP tests in Windows jobs Shot in the dark trying to find out which tests are hanging / going to an infinite loop. The ones failing after 45 minutes (mingw-w64) or 30 minutes (MSVC). Ref: https://github.com/curl/curl/pull/13599#issuecomment-2119372376
2024-05-28 19:07:34 +08:00
export TFLAGS='-j14 !TFTP ${{ matrix.tflags }}'
GHA: add three old (gcc 6, 7, 9) mingw-w64 jobs Re-implement old mingw-w64 jobs in GHA. This allows to use the latest Windows runners, replacing Windows Server 2012 R2 (gcc 6) and Windows Server 2016 (gcc 7, 9) with Windows Server 2022. GHA runners are also significantly faster, and allow running tests in parallel (`-j14`). It also offloads 3 more long-running jobs from AppVeyor CI. These jobs download (then cache) the mingw-w64 packages from their original location, which allows flexibility in choosing which versions and flavours (win32/POSIX, SEH/DWARF, 64/32-bit) we want to test in CI. The new jobs use these distros: - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/ (for gcc 7, same as on AppVeyor) - https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/ (for gcc 6, same as on AppVeyor) - https://winlibs.com/ (for gcc 9) I matched existing AppVeyor job configs, with these differences: - gcc 6.4.0 instead of 6.3.0. (same distro as on AppVeyor, but the latest bugfix release) - gcc 9.5.0 instead of 9.1.0 and a different (but compatible) binary distro. (in AppVeyor this relies on an old MSYS2 pre-installed on the runner) - using win32 builds instead of posix for gcc 6.4.0 and 7.3.0. - websockets enabled. - always build examples. - always build tests (this wasn't done for 6.4.0 with AppVeyor CI). I did not replicate existing test exclusions, and oddly enough the few failures (so far) were different from MSYS2 jobs and also from their AppVeyor CI counterparts. Also: - delete redundant (default) `-u` option from `cygpath` calls. - allow matrix options to override default ones in CMake. - detect and use Windows-supplied curl for `TFLAGS` `-ac` option. (it's available in modern runners.) - delete the 3 AppVeyor CI jobs now replicated in GHA. - appveyor: prefer `SYSTEMROOT` over `WINDIR`. - tidy-up quotes. Job performance: ``` AppVeyor GHA w/examples w/tests -------- ---------- CMake, mingw-w64, gcc 6, Debug, x86, Schannel, Static, no-unity 1m25s 8m50s CMake, mingw-w64, gcc 7, Debug, x64, Schannel, Static, Unicode 31m45s 9m39s CMake, mingw-w64, gcc 9, Debug, x64, Schannel, Static 28m25s 13m38s ``` Based on these runs: https://ci.appveyor.com/project/curlorg/curl/builds/49880799 https://github.com/curl/curl/actions/runs/9218292508 Notice that building examples and tests is time consuming. We can tweak any build parameter as necessary to make them more useful and/or without clogging the job queue or introducing flakiness. Closes #13759
2024-05-23 20:54:49 +08:00
if [ -x "$(cygpath "${SYSTEMROOT}/System32/curl.exe")" ]; then
TFLAGS+=" -ac $(cygpath "${SYSTEMROOT}/System32/curl.exe")"
GHA: add MSYS, mingw-w64, Cygwin jobs - re-implement autotools MSYS and Cygwin AppVeyor jobs in GHA. Now build with SSL and PSL to improve test coverage. - re-implement MSYS2 mingw-w64 gcc 13 AppVeyor job in GHA. `CMake, mingw-w64, gcc 13, Debug, x64, Schannel, Static, Unicode` - add new cmake Cygwin job (build-only). - enable `-j14` parallelism when running tests. - delete the 5 migrated jobs from AppVeyor CI. - add 2 build-only mingw-w64 builds, gcc Release and clang OpenSSL. - also enable brotli, libssh2, nghttp2 for more test coverage. These jobs offer better performance, more flexibility and parallelization compared to the AppVeyor ones they replace. It also offloads AppVeyor, allowing to iterate faster. They also appear more reliable than e.g. Azure Windows jobs, where runners are prone to fail [1]. Closes #13599 [1]: `Exit code 143 returned from process: file name 'C:\Windows\system32\docker.EXE', arguments 'exec -i 6b13a669c6dfe7fb9f59414369872fd64d61c7182f880c3d39c135cb4c115c8f C:\__a\externals\node\bin\node.exe C:\__w\_temp\containerHandlerInvoker.js'.`
2024-05-11 21:29:23 +08:00
fi
ls bld/lib/*.dll >/dev/null 2>&1 && cp -f -p bld/lib/*.dll bld/tests/libtest/
cmake --build bld --config '${{ matrix.type }}' --target test-ci
GHA: add three MSVC jobs Continuing the theme, add 3 MSVC jobs with tests, matching configurations used on AppVeyor. MSVC versions are identical: 19.39.33523.0 + Windows SDK 10.0.22621.0. Also enable websockets, and build examples. Tests are run in parallel (`-j14`), with improved performance. Job performance: ``` AppVeyor GHA w/examples -------- ---------- CMake, VS2022, Debug, x64, Schannel, Static, Unicode 38m 4s 11m57s CMake, VS2022, Debug, x64, no SSL, Static 35m15s 12m 6s CMake, VS2022, Debug, x64, no SSL, Static, HTTP only 25m25s 10m36s ``` Based on these runs: https://ci.appveyor.com/project/curlorg/curl/builds/49884748 https://github.com/curl/curl/actions/runs/9229448468 This is the first time examples are built in CI with MSVC: Fix all warnings and errors that came up via d4b85890555388bec212b75f47a5c1a48705b156 #13771. Closes #13766
2024-05-24 23:53:27 +08:00
msvc:
name: 'msvc (${{ matrix.arch }}, ${{ matrix.plat }}, ${{ matrix.config }})'
runs-on: windows-latest
timeout-minutes: 30
strategy:
matrix:
include:
- { arch: 'x64', plat: 'windows', tflags: '~1516 ~2301 ~2302 ~2303 ~2307', config: '-DENABLE_DEBUG=ON -DCURL_USE_SCHANNEL=ON -DBUILD_SHARED_LIBS=OFF -DENABLE_UNICODE=ON ', type: 'Debug' }
- { arch: 'x64', plat: 'windows', tflags: '~1516 ~2301 ~2302 ~2303 ~2307', config: '-DENABLE_DEBUG=ON -DCURL_USE_SCHANNEL=OFF -DBUILD_SHARED_LIBS=OFF -DENABLE_UNICODE=OFF', type: 'Debug' }
- { arch: 'x64', plat: 'windows', tflags: '~1516 ~2301 ~2302 ~2303 ~2307', config: '-DENABLE_DEBUG=ON -DCURL_USE_SCHANNEL=OFF -DHTTP_ONLY=ON -DENABLE_UNICODE=OFF', type: 'Debug' }
fail-fast: false
steps:
- uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4
- name: 'cmake configure'
timeout-minutes: 5
shell: bash
run: |
archgen=${{ matrix.arch }}; [ "${archgen}" = 'x86' ] && archgen='Win32'
if [ '${{ matrix.plat }}' = 'uwp' ]; then
system='WindowsStore'
options='-DCMAKE_SYSTEM_VERSION=10.0'
else
system='Windows'
fi
[ '${{ matrix.type }}' = 'Debug' ] && options+=' -DCMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG='
[ '${{ matrix.type }}' = 'Release' ] && options+=' -DCMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE='
cmake -B bld ${options} \
"-DCMAKE_SYSTEM_NAME=${system}" \
-DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake \
"-DCMAKE_GENERATOR_PLATFORM=${archgen}" \
'-DVCPKG_TARGET_TRIPLET=${{ matrix.arch }}-${{ matrix.plat }}' \
-DCMAKE_VS_GLOBALS=TrackFileAccess=false \
'-DCMAKE_UNITY_BUILD=${{ matrix.unity }}' \
"-DCMAKE_C_FLAGS=${cflags}" \
'-DCMAKE_BUILD_TYPE=${{ matrix.type }}' \
-DCMAKE_UNITY_BUILD=ON \
-DCURL_WERROR=ON \
-DBUILD_EXAMPLES=ON \
-DENABLE_WEBSOCKETS=ON \
${{ matrix.config }}
- name: 'cmake build'
timeout-minutes: 5
shell: bash
run: |
cmake --build bld --config '${{ matrix.type }}' --parallel 3
[[ '${{ matrix.config }}' != *'BUILD_SHARED_LIBS=OFF'* ]] && cp -f -p bld/lib/*.dll bld/src/
bld/src/curl.exe --disable --version
- name: 'cmake build tests'
if: ${{ matrix.tflags != 'skipall' }}
timeout-minutes: 10
shell: bash
run: |
cmake --build bld --config '${{ matrix.type }}' --parallel 3 --target testdeps
- name: 'cmake run tests'
if: ${{ matrix.tflags != 'skipall' && matrix.tflags != 'skiprun' }}
timeout-minutes: 30
shell: bash
run: |
GHA: disable TFTP tests in Windows jobs Shot in the dark trying to find out which tests are hanging / going to an infinite loop. The ones failing after 45 minutes (mingw-w64) or 30 minutes (MSVC). Ref: https://github.com/curl/curl/pull/13599#issuecomment-2119372376
2024-05-28 19:07:34 +08:00
export TFLAGS='-j14 !TFTP ${{ matrix.tflags }}'
GHA: add three MSVC jobs Continuing the theme, add 3 MSVC jobs with tests, matching configurations used on AppVeyor. MSVC versions are identical: 19.39.33523.0 + Windows SDK 10.0.22621.0. Also enable websockets, and build examples. Tests are run in parallel (`-j14`), with improved performance. Job performance: ``` AppVeyor GHA w/examples -------- ---------- CMake, VS2022, Debug, x64, Schannel, Static, Unicode 38m 4s 11m57s CMake, VS2022, Debug, x64, no SSL, Static 35m15s 12m 6s CMake, VS2022, Debug, x64, no SSL, Static, HTTP only 25m25s 10m36s ``` Based on these runs: https://ci.appveyor.com/project/curlorg/curl/builds/49884748 https://github.com/curl/curl/actions/runs/9229448468 This is the first time examples are built in CI with MSVC: Fix all warnings and errors that came up via d4b85890555388bec212b75f47a5c1a48705b156 #13771. Closes #13766
2024-05-24 23:53:27 +08:00
ls bld/lib/*.dll >/dev/null 2>&1 && cp -f -p bld/lib/*.dll bld/tests/libtest/
cmake --build bld --config '${{ matrix.type }}' --target test-ci
Reference in New Issue Copy Permalink