Add a configurable job timeout to `swift_test_matrix.yml`.
### Motivation:
Matrix jobs have no timeout, so a stalled nightly toolchain build runs
until the 6-hour limit. From Sep 27 to Oct 10, apple/swift-nio-quic had
139 such jobs (about 50,000 runner minutes), all on Linux nightly-main
legs.
### Modifications:
Add a `timeout_minutes` input (default 120) and use it as the
`execute-matrix` job timeout.
### Result:
Stalled jobs are cancelled after 2 hours instead of 6. The longest
successful matrix job I found was 81 minutes (grpc-swift-2 Examples), so
current callers fit, and they can raise the limit if needed.
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Reenable 6.1 CI workflows by default.
### Motivation:
6.1 workflows were disabled by default in
https://github.com/apple/swift-nio/commit/d09ffc8ad6437bc278897279e33150d8e39ee3d5.
However, we haven't been able to drop 6.1 in all repos using these
workflows yet, so this PR temporarily reenables the 6.1 workflows until
we can land that work everywhere else.
### Modifications:
Reenable 6.1 CI workflows by default.
### Result:
6.1 workflows are enabled by default.
### Motivation
* Swift 6.4 has been released, so we should add it to our CI coverage.
### Modifications
* Update `apple/swift-nio/scripts/generate_matrix.sh`
* Update `apple/swift-nio/scripts/check-matrix-job.sh`
* Update reusable adopters of `swift_test_matrix.yml`
* Update end-user adopter workflows of `swift_test_matrix.yml`
* Add Swift 6.4 inputs to `macos_tests.yml` and `macos_benchmarks.yml`
* Add a 6.4 release job to `wasm_swift_sdk.yml`
* Enable the Windows 6.4 unit test job in `main.yml` and
`pull_request.yml`
* Copy benchmark thresholds from 6.3
### Result
* NIO runs Swift 6.4 CI, and downstream repositories can opt-in.
---
- Successful run (minus broken nightlies):
https://github.com/apple/swift-nio/actions/runs/36403423635?pr=3750
Fix the following warnings:
> setter for property 'xxx' is private and cannot be referenced from an
'@inlinable' function; this will be an error in a future Swift language
mode
### Motivation:
All of the test targets now compile on Windows (#3663, #3665), but
`swift test` doesn't yet pass: a number of tests exercise functionality
that isn't supported or isn't yet functional on Windows, some crash or
hang, and a few are flaky on the WSAPoll-based selector. Before the
Windows unit tests can run in CI, those tests need to be skipped (with
reasons) so a full `swift test` exits cleanly.
### Modifications:
Skip the tests that don't pass on Windows, using `XCTSkip` / Swift
Testing's `.disabled` / a gated `setUp` where a fixture itself traps,
each with a reason. Broadly:
- **Unsupported transports/APIs:** Unix domain sockets, datagram/UDP
channels, pipe channels, raw sockets, vsock, pre-connected sockets, and
`FileRegion` sends.
- **Whole suites** for subsystems that aren't functional on Windows yet,
including the **NIOFileSystem family** (`NIOFSTests`,
`NIOFSIntegrationTests`, `NIOFSFoundationCompatTests`) whose Windows
syscall shims are still stubbed, plus `EchoServerClientTest`,
`ChannelTests`, `DatagramChannelTests`, `StreamChannelTest`,
`FileRegionTest`, `PipeChannelTest`, `RawSocketBootstrapTests`,
`ThreadTest`, and `SocketOptionProviderTest`.
- **Real crashes surfaced by a full run:** `System.enumerateDevices()`
(mis-sized `GetAdaptersAddresses` buffer), the WSAPoll selector trapping
on an invalid fd and on schedule-after-shutdown, and a connection-reset
promise leak.
- **Flaky, timing-sensitive tests:** the event-loop tick-count metrics
tests (the WSAPoll selector wakes far more often than epoll/kqueue).
Then enable the Windows 6.3 + nightly jobs in the reusable unit-tests
workflow (which runs `swift test`) in both the PR and push workflows,
and drop the separate build-only Windows job (which only ran `swift
build --build-tests`).
Windows uses the default `swift test` arguments rather than the Linux
`-Xswiftc -warnings-as-errors` override, because a `#warning` in the
(skipped) stream-channel tests would otherwise fail the build.
All skips are Windows-only; there is no behaviour change on other
platforms.
### Result:
`swift test` passes on Windows, and the Windows unit tests run in CI.
---------
Co-authored-by: George Barnett <gbarnett@apple.com>
## Motivation
Follow-up to #3663 (which got the "low-hanging" test targets compiling
on Windows). This finishes the job by getting the **last two** test
targets — `NIOPosixTests` and `NIOFoundationCompatTests` — compiling on
Windows, so **all 16 test targets now build**, and switches Windows CI
to `swift build --build-tests`.
These are **compile-only** changes: the goal is compilation, not runtime
pass. Verified by building on a Windows ARM64 VM with `swift build
--build-tests`.
## What's here
1. **Compile `NIOFoundationCompatTests`** — the target imports the `NIO`
umbrella (in `WaitSpinningRunLoopTests`, for
`MultiThreadedEventLoopGroup`) but only declared
`NIOCore`/`NIOFoundationCompat` as dependencies. `NIO` re-exports
`NIOPosix`, which imports the `CNIOPosix` **C module**; Linux/macOS
resolve that transitively, but on Windows the C-module map isn't in the
target's search path unless declared, giving the opaque `<unknown>:0:
error: missing required module 'CNIOPosix'`. Fix: declare the `NIO`
dependency it actually uses.
2. **Compile `NIOPosixTests`** — the deeply-POSIX target.
Gate-out-plus-minimal-shim:
- `import WinSDK` where only `sockaddr`/`timeval`/`in_addr` field or
type access was missing (`MemberImportVisibility`) — this alone cleared
the two largest files (`SocketAddressTest`, `HappyEyeballsTest`).
- Real fixes where cheap: `pipe` → `_pipe` (via `ucrt`), an
`STDOUT_FILENO` shim, `Thread.sleep` instead of `sleep`, and letting
`IOResult` type inference pick `ssize_t`.
- `#if !os(Windows)` gating (per-method where possible, to preserve
Windows-compilable coverage) for genuinely-unavailable APIs:
`fcntl`/`O_NONBLOCK`/`O_ASYNC`/`F_GETFL`/`F_SETFL`, `Posix.fcntl`,
`Posix.socketpair`, the integer socket-option API
(`ChannelOptions.socket`, `SOL_SOCKET`, `SO_REUSEADDR`, `so_timestamp`),
`poll`/`pollfd`, `cmsg`/`msghdr` construction,
`NonBlockingFileIO.lstat`/`symlink`/`listDirectory`/`createDirectory`,
vsock CID/connect tests, `/dev/null` syscall-wrapper perf tests, and
socket-handle (`NIOBSDSocket.Handle` `UInt64` vs `CInt`) mismatches.
- Whole-file gating only where a file is pervasively unsupported: the
SAL mock harness and its dependents (`SyscallAbstractionLayer[Context]`,
`SALChannelTests`, `SALEventLoopTests`) — it's built on `CInt` fds and
can't compile against Windows's `UInt64` socket handles without a larger
rework; `ControlMessageTests` (POSIX `msghdr`/control-message
throughout); and `MulticastTest` (deprecated
`enumerateInterfaces`/`NIONetworkInterface`).
3. **Build the test targets in CI** — change the Windows matrix command
from `swift build` to `swift build --build-tests` in `main.yml` and
`pull_request.yml`.
## Notes for reviewers
- No behavior change off Windows: every edit is behind `#if os(Windows)`
/ `#if !os(Windows)`; the few shared-line changes (`Thread.sleep`,
`IOResult` inference, an IUO force-unwrap of `msg_name`) are identical
on POSIX.
- The tests are **compiled, not run** on Windows yet. Running them needs
real Winsock work (socket handle types, etc.) and is the natural next
step.
---------
Co-authored-by: George Barnett <gbarnett@apple.com>
## Motivation
This continues the incremental Windows port of SwiftNIO. `NIOPosix`
already builds on Windows (on Winsock2 with a POSIX-shim mapping); this
PR gets the **L4 NIOFileSystem family** to **compile** on Windows:
- `_NIOFileSystem`
- `NIOFS`
- `NIOFileSystem`
- `_NIOFileSystemFoundationCompat`
- `NIOFSFoundationCompat`
With these compiling, **all non-test targets now build on Windows**, so
the Windows CI job is simplified to a bare `swift build` (which builds
the whole non-test graph) rather than an explicit per-target list.
## Scope — compile-only
**This PR gets the targets compiling; it does not yet make them
functional.** The POSIX file-system syscalls that don't exist (or aren't
exposed by swift-system) on Windows are provided as `fatalError("…
unavailable on Windows")` **stubs** with the correct signatures, so the
library type-checks and links. Real Win32 implementations, and bringing
the test targets online in CI to validate them, are deliberately left to
follow-up PRs.
The intent is to land the smallest reviewable slice first and **get
feedback on the overall shape and organization** before building on it.
## What this does
All changes are behind `#if os(Windows)` / `#if defined(_WIN32)`, with
**zero behavior change on Darwin/Linux/BSD**:
- **`Sources/*/Internal/System Calls/SystemPackage+Windows.swift`**
(new, one per tree): a module-scope compatibility shim supplying the
pieces the rest of the target expects on Windows —
- the swift-system-gap extensions swift-system doesn't provide on
Windows
(`FileDescriptor.OpenOptions.{noFollow,closeOnExec,nonBlocking,directory}`,
`Errno.noData`);
- `CInterop.Stat`/`DirEnt`/`FTS`/`FTSEnt` Windows stand-ins and the
`S_IF*`/`DT_*`/`FTS_*`/`UTIME_*` constants the call sites reference;
- `fatalError` stubs for the bare-libc syscalls (`openat`,
`stat`/`lstat`/`fstat`, `readdir`/`fdopendir`/`closedir`, `fts_*`,
`futimens`, `rename`, `symlink`, xattr-adjacent helpers, `getcwd`,
pthread TLS keys, …), matching the exact signatures the existing
`system_*` / `libc_*` wrappers call, so those wrappers and their
non-Windows call sites need no changes.
- Small `#elseif os(Windows)` branches in the existing platform switches
(`FileInfo`, `FileType`, `Errno`, `Mocking`, `Syscall(s)`,
`SystemFileHandle`, `FileSystem`) — including `fatalError` stubs for
`_copyRegularFile` / `_copySymbolicLink` /
file-materialization-via-rename.
- A tiny `CNIOWindows` addition: `errno` accessors (`CNIOWindows_errno`
/ `CNIOWindows_set_errno`, typed `errno_t` via
`_get_errno`/`_set_errno`) so the Swift errno indirection can bridge the
CRT `errno` macro.
- `CNIOWindows` added to the `NIOFS` / `_NIOFileSystem` target
dependencies in `Package.swift`.
`NIOFS` and `_NIOFileSystem` are lockstep near-duplicates, so every
Windows change is applied identically to both.
## Verification
Verified by source review and by confirming a clean `swift build` on
`aarch64-unknown-windows-msvc`. Since the syscalls are stubbed, there is
no runtime behavior to test yet.
## What I'm looking for
Feedback on the **high-level organization and shape** of the NIOFS
Windows shim before the real implementations follow:
1. Is the layering right — a single module-scope
`SystemPackage+Windows.swift` gap-shim, with the upstream `system_*` /
`libc_*` call sites left untouched?
2. When the implementations land, is emulating the POSIX seams (a
`fts(3)`-shaped tree walk, POSIX directory streams) the right approach,
or should Windows fork at a higher layer (e.g. a Windows-specific
enumerator in `DirectoryEntries`) rather than reimplementing
`fts`/`readdir`?
3. Anything about the swift-system-gap extensions or the `CInterop.*`
Windows stand-ins that should be shaped differently.
## Next steps
Follow-up PRs will replace the stubs with real Win32 implementations,
then bring the NIOFileSystem **test targets** building and running in CI
— where these shims get real validation and we start gaining deeper
confidence in Windows support across the stack.
---------
Co-authored-by: George Barnett <gbarnett@apple.com>
### Motivation:
The old NIOCrashTester doesn't work on Windows and would be hard to
port. Also, Swift Testing has wonderful 'exit test' ability, let's use
that!
### Modifications:
- Rewrite all NIOCrashTester tests in Swift Testing
### Result:
- Less code to maintain
- (hopefully) works on Windows
- fixes#3657
Add the two remaining non-test, non-NIOFS targets to the Windows CI
build list.
NIOPerformanceTester builds and runs on Windows. The only obstacle was
the `setbuf(stdout, nil)` call: `stdout` is a macro on the Windows CRT
that Swift cannot reference directly. Add a
`CNIOWindows_setStdoutUnbuffered()` wrapper so the C compiler expands
the macro (keeping us correct if its definition ever changes), and call
it on Windows.
NIOCrashTester cannot function on Windows: its OutputGrepper captures a
child process's output through a pipe channel (`NIOPipeBootstrap`),
which deliberately `fatalError`s on Windows, and relies on
`Foundation.Pipe` fd conversion plus Unix-signal crash detection. Extend
the existing `!canImport(Darwin) || os(macOS)` guard with `&&
!os(Windows)` across the target so it compiles to a no-op on Windows,
just as it already does on the non-macOS Darwin platforms.
This PR gets TCP (Servers) on Windows mostly working. I'll annotate my
PR for clarity.
**The one bug:**
If you open a TCP client connection to a Windows TCP server, it doesn't
read/write yet until a second connection comes in. This happens because
`reregister0` is called after `WSAPoll` is called - but WSAPoll isn't
woken up to know this so it doesn't know the new socket requests
read/writes/...
Also the EventLoop cannot be woken up during `el.execute { .. }` because
`SleepEx` isn't running. WSAPoll doesn't respond to this signal it
seems.
This makes the TCP server functionality not yet usable, but I thought
with this draft we could figure out what I'm missing.
Alternative considered: We can make `WSAPoll` limited to wake up every 1
ms for example, that way we can still get to these events at _some_
point.
---------
Co-authored-by: Cory Benfield <lukasa@apple.com>
Co-authored-by: Fabian Fett <fabianfett@apple.com>
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Co-authored-by: Oliver Drobnik <oliver@cocoanetics.com>
Co-authored-by: Jake Petroules <jake.petroules@apple.com>
Co-authored-by: George Barnett <gbarnett@apple.com>
Co-authored-by: Gabriele Mondada <gab@ijk.ch>
Add a Windows PR/main CI job that builds the targets which compile
cleanly today: _NIOBase64, _NIOConcurrency, _NIODataStructures,
NIOConcurrencyHelpers, NIOCore, NIOEmbedded, NIOFoundationCompat,
NIOFoundationEssentialsCompat, NIOHTTP1, NIOTLS, NIOWebSocket. The
remaining targets (NIOPosix, NIO, NIOTestUtils, downstream tests,
examples) still fail on Windows and are not yet covered.
The existing unit-tests workflow path runs swift test, which does not
accept --target, so flipping windows_6_3_enabled there would attempt to
test the whole package and fail. Instead this is an inline job that runs
swift build with explicit --target flags. As more targets come up on
Windows we'll extend the list, then eventually retire this job in favor
of windows_6_3_enabled when swift test of the whole package is green.
Co-authored-by: George Barnett <gbarnett@apple.com>
Enable Xcode betas by default now that they are available on runners
again
### Motivation:
Xcode betas are available on runners again
### Modifications:
Enable Xcode betas by default now that they are available on runners
again
### Result
Downstream packages will run Xcode beta builds
An example of this running
https://github.com/apple/swift-nio/actions/runs/27679540593/job/81863193279?pr=3627
### Motivation:
The CI pipelines offer the latest released Swift versions (which have
included Swift 6.3 for some time now) and
a nightly-main and nightly-next. Right now nightly-next pipelines are
all still 6.3, which is a problem and folks are
likely operating under the misguided assumption that they have 6.4
coverage in their pipelines.
### Modifications:
- Update the nightly-next pipelines to use 6.4 nightly images
### Result:
Nightly next pipelines moved to 6.4
### Motivation
* External callers of `macos_benchmarks.yml` (e.g. swift-log) currently
invoke the reusable workflow once per benchmark package, paying
self-hosted macOS runner-recycling cost for each invocation.
### Modifications
* Add a new `benchmark_package_paths` input to
`.github/workflows/macos_benchmarks.yml` and mark the singular
`benchmark_package_path` as deprecated. The run step forwards both
inputs straight to the script via `BENCHMARK_PACKAGE_PATH` and
`BENCHMARK_PACKAGE_PATHS` environment variables; the workflow itself
does no path parsing.
* Teach `scripts/check_benchmark_thresholds.sh` to accept
`BENCHMARK_PACKAGE_PATHS` as either a JSON array of strings
(auto-detected by a leading `[`, requires `jq`) or a newline-separated
list, falling back to the legacy `BENCHMARK_PACKAGE_PATH` when unset or
when the JSON form is an empty array.
* The script now loops over the resolved package list, wraps each
iteration in a GitHub Actions `::group::`, and emits an `::error::`
summary listing failed packages at the end, exiting non-zero if any
failed.
### Result
* A single workflow invocation runs all listed packages serially on each
Swift/Xcode runner, paying runner-recycling cost once per Swift version
instead of once per (version x package).
* Existing single-package callers keep working unchanged.
* Adopters of the script in other contexts (e.g. the Linux
`benchmarks.yml`) can pick up multi-package support by passing
`BENCHMARK_PACKAGE_PATHS` without reimplementing parsing or
failure-collection logic.
An example of this working https://github.com/apple/swift-log/pull/466
### Motivation
* The versioned `linux_nightly_6_1_enabled` input was deprecated a while
back in favour of `linux_nightly_next_enabled`, but the workflows still
combined the two with `||`/`&&` to keep the old name working.
* Now that callers have migrated, the shim is unnecessary complexity.
### Modifications
* In `unit_tests.yml`, `cxx_interop.yml`, and `benchmarks.yml`, replace
`inputs.linux_nightly_6_1_enabled || inputs.linux_nightly_next_enabled`
(and the `&&` variants) with just `inputs.linux_nightly_next_enabled`.
### Result
* `MATRIX_LINUX_NIGHTLY_NEXT_ENABLED` is driven solely by
`linux_nightly_next_enabled`.
### Motivation
* Xcode 15.4, 16.0, 16.1, 16.2, and 26 beta were already deprecated
and defaulted to `false` with no callers enabling them — redundant code.
* Xcode 16.3, 16.4, 26.0, and 26.1 will soon be uninstalled from the
runners. Their inputs are kept so downstream callers don't break, but
they should no longer produce any matrix entries.
### Modifications
* Remove input declarations, shell variables, matrix construction
blocks, and environment variable mappings for 15.4/16.0/16.1/16.2/26
beta entirely.
* Remove the matrix logic for 16.3/16.4/26.0/26.1 but retain the input
declarations as no-ops, with descriptions communicating they have no
effect.
### Result
* Less dead code in the shared workflow.
* Callers still passing `xcode_16_3` through `xcode_26_1` inputs get no
error but also no job — a graceful no-op while they migrate to
`swift_*` inputs.
### Motivation
* The `swift_*` inputs request Xcodes by Swift version with symlinks on
the runners owning the mapping. This more directly expresses the
library support window.
* All callers should migrate to `swift_6_1/6_2/6_3_enabled` instead of
specifying Xcode versions directly.
### Modifications
* Default `xcode_16_3/16_4/26_0/26_1/26_2_enabled` to `false` and mark
their descriptions as deprecated.
* Default `swift_6_1/6_2/6_3_enabled` to `true`.
### Result
* Repos still passing `xcode_*_enabled: true` explicitly continue to
work until they migrate.
Add multi-version matrix support to Wasm Swift SDK workflow
### Motivation:
The WASM CI only ran against nightly-main, making it impossible to
distinguish toolchain regressions from code issues. Other repos in the
ecosystem using `swiftlang/github-workflows` already test against
`nightly-main`, `nightly-6.3`, and `6.3` by default.
### Modifications:
- Add `nightly_main_enabled`, `nightly_6_3_enabled`, and
`release_6_3_enabled` boolean inputs to `wasm_swift_sdk.yml` (all
defaulting to `true`, matching the coverage of
`swiftlang/github-workflows/swift_package_test.yml`) and update the
matrix generation to emit the appropriate entry per enabled version.
- Update `install_swift_sdk.sh` to support non-main branch snapshots by
deriving the API and download paths from `INSTALL_SWIFT_BRANCH` rather
than hardcoding `main`/`development`.
- Fail early with a clear message if the branch snapshot API returns no
results, rather than hitting an unbound variable error.
### Result:
WASM builds are now tested against multiple Swift versions, providing a
stable baseline to identify nightly-only regressions. Callers using the
workflow without arguments get the new default coverage automatically;
those who want to narrow the matrix can set specific version inputs to
`false`.
---------
Co-authored-by: Rick Newton-Rogers <rnro@apple.com>
Co-authored-by: Cory Benfield <lukasa@apple.com>
### Motivation:
A recent PR (#3574) added support for customising the container
environment used for the matrix job for users of the reusable workflow.
It supported a custom Dockerfile and controlling `--cap-add` options to
the `docker run` command. Users who require this fine-grained control
with `--cap-add` also will benefit from being able to control the
`--security-opt` of the `docker run` command.
### Modifications:
- Add support for `--security-opt` docker flags in custom CI jobs
### Result:
Users of the reusable matrix CI workflow can control the
`--security-opt` for the container.
### Motivation
* Some consumers need to run CI inside custom Docker images with
additional Linux capabilities. The shared matrix workflows had no way to
express this — consumers had to maintain entirely bespoke CI workflows
instead.
### Modifications
* Added `MATRIX_LINUX_DOCKERFILE` and
`MATRIX_LINUX_DOCKER_CAPABILITIES_JSON` environment variables to
`generate_matrix.sh`. These propagate as `dockerfile` (string) and
`docker_capabilities` (JSON array) fields in the matrix JSON. Defaults
are empty/`[]` so existing callers are unaffected.
* Extended `add_matrix_entry()` with two optional trailing parameters
for the new fields.
* In `swift_test_matrix.yml`:
- Made the "Pull Docker image" step conditional — skipped when a
`dockerfile` is provided.
- Added a "Build Docker image from Dockerfile" step that builds the
image with `--build-arg SWIFT_IMAGE=<matrix image>` so consumers can
parameterise the Swift base image.
- Added `--cap-add` flags to `docker run` when `docker_capabilities` is
non-empty.
### Result
* Consumers can set `MATRIX_LINUX_DOCKERFILE` to a repo-relative path
and `MATRIX_LINUX_DOCKER_CAPABILITIES_JSON` to a JSON array of
capabilities. The matrix will build their Dockerfile per Swift version
and run containers with the requested capabilities.
* Existing consumers that don't set these variables see no change.
Motivation:
Swift 6.0 is no longer supported, we should bump the tools version and
remove it from our CI.
Modifications:
* Bump the Swift tools version to Swift 6.1
* Remove Swift 6.0 jobs where appropriate in main.yml, pull_request.yml
* Set language mode 5 in Benchmarks package manifest
Result:
Code reflects our support window.
---------
Co-authored-by: George Barnett <gbarnett@apple.com>
Fix Windows Docker daemon not starting before polling
### Motivation:
When a Windows runner is restored from a saved VM image, the Docker
service sometimes fails to start during the "second boot" due to a
failure creating the required virtual switches.
Manually restarting the Docker service resolves the issue every time.
### Modifications:
Before polling `docker info`, check whether the Docker service is
running and start it if it is not.
### Result:
The Docker daemon becomes available reliably on Windows runners.
### Motivation
* Swift 6.3 has been released, we should add it to our CI coverage.
### Modifications
* Update `apple/swift-nio/scripts/generate_matrix.sh`
* Update `apple/swift-nio/scripts/check-matrix-job.sh`
* Update reusable adopters of `swift_test_matrix.yml`
* Update end-user adopter workflows of `swift_test_matrix.yml`
* Remove stale `NIGHTLY_6_1` fallback shims from `generate_matrix.sh`
* Migrate `linux_nightly_6_1_arguments_override` to
`linux_nightly_next_arguments_override` in `main.yml` and
`pull_request.yml`
* Copy benchmark thresholds from 6.2
### Result
* NIO tests against Swift 6.3 in CI and downstream repositories can
opt-in.
* A successful run using the new Swift 6.3 jobs:
https://github.com/apple/swift-nio/actions/runs/23841350537/job/69497505715?pr=3565
Increase job timeout for macOS tests from 30 to 60 minutes.
### Motivation:
We see test jobs getting cancelled, for example:
https://github.com/apple/swift-nio/actions/runs/23240305356
### Modifications:
Increase test time.
### Result:
Test jobs will complete.
Add Swift-version-based inputs to macOS CI workflows
### Motivation
- The macOS CI runners now provide symbolic links mapping Swift versions
to Xcode apps ( `Xcode_swift_6.1.app`, `Xcode_swift_6.2.app`,
`Xcode_swift_6.3.app`), decoupling CI from specific Xcode versions.
- Several Xcode versions (`16.3`, `26.0`, `26.1`, `26.2`) are being
deprecated and removed from runners.
- The `-require-explicit-sendable` build argument overrides on Xcode
16.2/16.3 are no longer needed.
### Modifications
- Added `swift_6_1_enabled`, `swift_6_2_enabled`, `swift_6_3_enabled`
inputs (with corresponding `build_arguments_override`,
`test_arguments_override`, setup_command) to `macos_tests.yml`, all
defaulting to false.
- Added macos_ `swift_6_1_enabled`, macos_ `swift_6_2_enabled`, macos_
`swift_6_3_enabled` inputs to `macos_benchmarks.yml`.
- Added matrix entries using the `Xcode_swift_6.X.app` symlink paths.
- All existing `xcode_*` inputs remain unchanged for backwards
compatibility with downstream consumers.
- Enabled the new Swift-version inputs in main.yml and pull_request.yml,
removing the old `xcode_16_2/16_3` build argument overrides.
### Result
- SwiftNIO CI now runs macOS jobs for Swift `6.1`, `6.2`, and `6.3`
using the stable `Xcode_swift_6.X.app` symlinks.
- Downstream consumers are unaffected.
An example of this working here
https://github.com/apple/swift-nio/actions/runs/22960228328/job/66648462048?pr=3546
### Motivation
* xcodebuild output is suppressed with `-quiet` in the macOS tests
workflow, making it hard to diagnose CI failures on the main branch.
### Modifications
* Add a `debug_output_enabled` boolean input to `macos_tests.yml`
(defaults to `false`), which controls a `QUIET_ARG` env var used by all
xcodebuild invocations.
* When `debug_output_enabled` is `true`, `-quiet` is elided and full
xcodebuild output is emitted.
* Enable `debug_output_enabled` in `main.yml` so nightly and main-branch
push builds produce verbose output.
### Result
* PR builds remain concise (default behaviour unchanged).
* Main-branch builds now include full xcodebuild output for easier
failure triage.
Shut down simulators between test runs
### Motivation:
I suspect the CI machines are underpowered and we see simulator load
failures during testing because we are running out of resources.
### Modifications:
Add a command to shutdown the simulators before running each simulator
test.
### Result:
Hopefully, tests will pass more reliably.
### Motivation
* Swift 5.10 is no longer actively supported and CI does not require it
### Modifications
* Default Swift 5.10 CI jobs to disabled
### Result
* Swift 5.10 CI jobs will not run unless opted-in
Add parallel execution mode for integration tests
### Motivation:
Integration tests regularly take 21m in CI; they're the long pole.
### Modifications:
* Allocation count tests are now run in parallel if
`NIO_ALLOC_COUNTER_TESTS_PARALLEL` is `true`, tests in a given file
are still in serial.
* Test output is catted to different files and recovered and printed in
the order in which the tests were started.
### Result:
Integration test execution (and therefore a PR's CI checks) goes from
21m to 10m
Motivation
* `@main` references to `swiftlang/github-workflows` are deprecated.
Modifications
* Replace `@main` with `@0.0.7` in all workflow files.
Result
* Workflow files reference a pinned version of
`swiftlang/github-workflows`.
Sequoia runners are no longer available and we need to switch to Tahoe.
### Motivation:
Sequoia runners are no longer available and jobs requesting them hang.
### Modifications:
Request Tahoe runners.
### Result:
Jobs no longer hang, macOS tests and benchmarks are running on Tahoe.
Xcode-latest currently points to the 26.1 release so it gives us a false
sense of version coverage, and should be ignored.
### Motivation:
We do not need to build twice with the same environment.
### Modifications:
Set default value for Xcode latest beta enabled to `false`
### Result:
One fewer job generated for the macOS build matrix.
Co-authored-by: Rick Newton-Rogers <rnro@apple.com>
Instead of evaluating inputs directly in the run step, save them to an
environment variable and evaluate that.
### Motivation:
Evaluating workflow inputs directly can lead to injection attacks, such
as those described at https://docs.zizmor.sh/audits/#template-injection
### Modifications:
Evaluate workflow inputs as environment variables so that they do not
inadvertently execute arbitrary shell injections.
### Result:
The workflows should be more secure against malicious inputs.
Limit Darwin Job execution to apple org.
### Motivation:
When the repo is forked, the forks do not have access to the self-hosted
CI, so it should not block actions in the forked environment.
### Modifications:
Conditionalize Darwin job execution.
### Result:
macOS CI will not queue on forks.
Extract macOS benchmarks into a separate reusable workflow to completely
remove them if they are not meant to be used.
### Motivation:
macOS Benchmarks is an opt-in workflow. If no macOS versions selected to
run benchmarks on, there is now a skipped matrix jobs, creating
unnecessary visual and cognitive noise during workflow results analysis:
<img width="391" height="369" alt="Screenshot 2025-12-10 at 14 22 50"
src="https://github.com/user-attachments/assets/959ff2a1-3872-4bff-97ac-1dca6d2d4ea5"
/>
### Modifications:
macOS benchmarks workflow is extracted into a separate reusable
workflow.
### Result:
- If a repo is not running macOS benchmarks, there is no extra skipped
jobs.
- When willing to run macOS benchmarks, `macos_benchmarks.yml` workflow
should be used.
- This is a breaking change in the reusable workflows interface, so all
the repos (just the `swift-log`?) need to adopt the new reusable
workflow.
Test runs:
- old workflow run with [unused macOS benchmarks skipped and
visible](https://github.com/apple/swift-nio/actions/runs/20102000384/job/57675171794)
- new workflow run with [no macOS benchmarks
visible](https://github.com/apple/swift-nio/actions/runs/20102837431)
because they are not used
- new workflow run with actually [executed and visible macOS
benchmarks](https://github.com/apple/swift-nio/actions/runs/20103726421)
After the recent addition of macOS-based benchmarks, the `main` workflow
has been failing with:
```
Error when evaluating 'strategy' for job 'benchmarks-macos'. apple/swift-nio/.github/workflows/benchmarks.yml@main (Line: 239, Col: 15): Matrix vector 'config' does not contain any values
```
This happens because `swift-nio` does not set any `_enabled` flag for
any version of Xcode to run the benchmarks.
An example of a failed run:
https://github.com/apple/swift-nio/actions/runs/19479529118
### Motivation:
Scheduled jobs should not fail.
### Modifications:
Added a condition for running macOS benchmarks matrix generation job.
### Result:
Jobs should not fail without any Xcode versions picked for running
benchmarks.
An example of a run with macos-matrix job skipped:
https://github.com/apple/swift-nio/actions/runs/19482328681/job/55758816398
An example of a run with a opt-in macOS Benchmarks:
https://github.com/apple/swift-nio/actions/runs/19484086327/job/55762298924
Run benchmarks on macOS in addition to Linux.
### Motivation:
1. macOS and Linux benchmark yield different results and we would like
to rack both of them.
2. default Linux GitHub workers do not provide access to PMU, which is
necessary for instructions metric benchmarking
### Modifications:
- `benchmarks.yml` workflow support running benchmarks on self-hosted
macOS runners
### Result:
Benchmarks are running on both linux and macOS runners. An example of an
opt-in PR running just one Xcode version:
https://github.com/apple/swift-nio/actions/runs/19468002318/job/55707591945.
An example of an opt-in PR and thresholds expectations check failed:
https://github.com/apple/swift-nio/actions/runs/19468236909/job/55708359111
I've been running `swift-nio` benchmarks on macOS runners and it is much
less stable than Linux for allocations and context switches. I suggest
we make this an opt-in feature and take in only for instructions count
benchmarks, for example upcoming to the `swift-log`. This also makes it
less stressful for macOS runners pool.
### Motivation:
The Watch Series 10 and iPhone 16 Pro simulators haven't been working
for some time
### Modifications:
Swap the iOS and macOS test targets
### Result:
Testing against simulators should work
Here is an example of the change in action. The new targets can be
discovered but one of the Xcodes then hits an unrelated issue
https://github.com/apple/swift-nio/actions/runs/19130486127/job/54672071880?pr=3437