# Main-branch stage: is the merged state healthy. It does not block a merge — the merge has already # happened — but it fails loudly, after the change it reports on (owner decision 2026-09-16). # # On every push to main: the main stage, the container lanes, the build-logic tests, configuration # cache, links and the dependency scan. Nightly (and on a manual run) also the jobs that need a matrix # or an environment the stage tasks do not have, and last the performance lanes, which need a # machine nothing else is using: the runner takes one job at a time, and the performance job is the # last one in this file (owner decision 2026-11-07; the job says why not `needs`). # # Which lanes a stage means is decided by its Gradle task (build.gradle). The stage jobs (`main` # for the main and integration stages, `performance`) run them as one line; # `verifyStrictLaneStages` fails a pull request that changes that line, its condition, or adds a # way for it to pass quietly. name: main on: push: branches: [main] schedule: # 04:00 KST. grpc-library runs at 03:00 and messaging-library at 03:30 on the same runner. - cron: "0 19 * * *" workflow_dispatch: inputs: run_protected_aws: description: Also run the protected AWS object-storage lane (needs the sandbox secrets) type: boolean default: false permissions: contents: read # One group per trigger and branch. A newer push cancels the older push run on the same branch, and a # newer nightly the older nightly, queued or running: the newer run tests everything the older one # would have, and the runner is shared. A push leaves a nightly alone (the nightly has jobs a push # does not), and a manual run cancels only an older manual run on the same branch. Gitea cancels the # queued and blocked runs of a group even without cancel-in-progress; with it, the running ones too. concurrency: group: main-${{ github.event_name }}-${{ github.ref }} cancel-in-progress: true env: # Reuse would hand one lane a container another lane had already faulted. TESTCONTAINERS_REUSE_ENABLE: "false" jobs: # Both main-branch stages in one Gradle run, the integration stage first (build.gradle # `strictLaneStages` says why). # mainCheck: environment contract, full-boot qualification, public-path baseline, transport and # messaging qualification, document-contract lanes, test-code analysis, the feature generator # round trip. integrationCheck: every integration-category strict lane, against real PostgreSQL, # MongoDB, Kafka, MinIO, nginx and Toxiproxy; a lane joins by declaring `integration()`, no line # here names it, and lanes that need an input this job does not have are explicitOnly and named # in the output. `--continue`: one failed lane must not hide the others. main: runs-on: ubuntu-latest timeout-minutes: 240 steps: - uses: https://github.com/actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2 - uses: ./.gitea/actions/setup-java-gradle - run: ./gradlew :integrationCheck :mainCheck --continue # The included build's own tests (TestKit for the convention plugins). The main task graph does # not reach them; `ci` already runs every plugin they test (owner decision 2026-11-07: main stage). build-logic: runs-on: ubuntu-latest timeout-minutes: 30 steps: - uses: https://github.com/actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2 - uses: ./.gitea/actions/setup-java-gradle - run: ./gradlew -p build-logic test configuration-cache: runs-on: ubuntu-latest timeout-minutes: 30 steps: - uses: https://github.com/actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2 - uses: ./.gitea/actions/setup-java-gradle - run: bash scripts/ci/verify-configuration-cache.sh # Every committed Markdown link, external URLs included. A documentation check, so the main stage # (owner decision 2026-09-16); scripts/check-docs.py checks the relative links on every pull request. links: runs-on: ubuntu-latest timeout-minutes: 15 steps: - uses: https://github.com/actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2 # v2.9.0 runs lychee v0.24.2. v2.0.2 ran v0.16.1, which has no --root-dir at all; a relative # --root-dir works from lychee v0.22.0. The job token is this Gitea's and means nothing to the # GitHub hosts lychee would send it to, so none is passed, and Gitea has no job summary page. - name: Check committed documentation links uses: https://github.com/lycheeverse/lychee-action@e7477775783ea5526144ba13e8db5eec57747ce8 # lycheeverse/lychee-action@v2.9.0 with: token: "" jobSummary: false args: >- --no-progress --root-dir . README.md docs/build.md 'src/**/README.md' 'src/**/AGENTS.md' 'docs/**/*.md' '.github/**/*.md' fail: true # The dependency tree against today's vulnerability database: new advisories appear without a # commit, so main and nightly scan again what the pull request scanned. vulnerabilities: runs-on: ubuntu-latest timeout-minutes: 20 steps: - uses: https://github.com/actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2 - uses: ./.gitea/actions/trivy-db-cache - run: bash scripts/ci/trivy-scan.sh filesystem # Experimental by design: the result is reported, never used to block anything. http3-experimental: runs-on: ubuntu-latest timeout-minutes: 30 continue-on-error: true steps: - uses: https://github.com/actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2 - uses: ./.gitea/actions/setup-java-gradle - run: ./gradlew :adapter:outbound:httpclient:test -Phttp3.tests.enabled=true # --------------------------------------------------------------------------------------------- # Nightly and manual runs only. # The platform contract on every Stable PostgreSQL major, one major per job: the integration stage # runs the lane once, on the default major. JpaReleaseRenderingTest holds this list to the release # registry's Stable majors (src/adapter/outbound/persistence-jpa/release/release-registry.json). jpa-postgresql: if: ${{ github.event_name != 'push' }} runs-on: ubuntu-latest timeout-minutes: 60 strategy: fail-fast: false matrix: postgresql: ["16", "17", "18"] steps: - uses: https://github.com/actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2 - uses: ./.gitea/actions/setup-java-gradle - run: ./gradlew :adapter:outbound:persistence-jpa:jpaPlatformContractTest -Pjpa.matrix.versions=${{ matrix.postgresql }} # One HTTP transport per step, so a transport that stops satisfying the shared contract fails on its # own step; `always()` runs the second after the first fails. One job rather than a matrix: each # row is under a minute, most of it job start. `ci` runs the lane once over both. httpclient-transport: if: ${{ github.event_name != 'push' }} runs-on: ubuntu-latest timeout-minutes: 30 steps: - uses: https://github.com/actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2 - uses: ./.gitea/actions/setup-java-gradle - name: apache if: ${{ always() }} run: ./gradlew :adapter:outbound:httpclient:httpClientStableContractTest -Phttpclient.contract.transports=apache - name: jdk if: ${{ always() }} run: ./gradlew :adapter:outbound:httpclient:httpClientStableContractTest -Phttpclient.contract.transports=jdk # Sentinel promotion, Cluster redirects and TLS against real servers, every supported version. # docs/redis/support-matrix.md says which lane produced which evidence; each step's log carries the # commit, the server version and the image digest. # # One job, a step per topology and version. As eleven matrix jobs each row paid the job start # again (container, checkout, JDK, Gradle start and configuration: 26 of the 135 runner minutes # of manual run 100 went to these rows, about a third of it start). `always()` runs every row # after one fails, and the job's red names the failed step. The script stops its topology on # exit, so the rows do not share a server. redis-topology: if: ${{ github.event_name != 'push' }} runs-on: ubuntu-latest timeout-minutes: 90 steps: - uses: https://github.com/actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2 - uses: ./.gitea/actions/setup-java-gradle - name: standalone on Redis 7.2 if: ${{ always() }} run: bash scripts/ci/redis-topology.sh standalone 7.2 - name: standalone on Redis 7.4 if: ${{ always() }} run: bash scripts/ci/redis-topology.sh standalone 7.4 - name: standalone on Redis 8.2 if: ${{ always() }} run: bash scripts/ci/redis-topology.sh standalone 8.2 - name: sentinel on Redis 7.2 if: ${{ always() }} run: bash scripts/ci/redis-topology.sh sentinel 7.2 - name: sentinel on Redis 7.4 if: ${{ always() }} run: bash scripts/ci/redis-topology.sh sentinel 7.4 - name: sentinel on Redis 8.2 if: ${{ always() }} run: bash scripts/ci/redis-topology.sh sentinel 8.2 - name: cluster on Redis 7.2 if: ${{ always() }} run: bash scripts/ci/redis-topology.sh cluster 7.2 - name: cluster on Redis 7.4 if: ${{ always() }} run: bash scripts/ci/redis-topology.sh cluster 7.4 - name: cluster on Redis 8.2 if: ${{ always() }} run: bash scripts/ci/redis-topology.sh cluster 8.2 - name: tls on Redis 7.4 if: ${{ always() }} run: bash scripts/ci/redis-topology.sh tls 7.4 - name: tls on Redis 8.2 if: ${{ always() }} run: bash scripts/ci/redis-topology.sh tls 8.2 # The one fileserver environment a pull request cannot provide: a real NFSv4 server. fileserver-nfs-ambiguity: if: ${{ github.event_name != 'push' }} runs-on: ubuntu-latest timeout-minutes: 45 env: FILESERVER_NFS_TESTS: "true" steps: - uses: https://github.com/actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2 # The NFS server is the host kernel's nfsd, which a container cannot load: the runner's daemon # has no /lib/modules. Without the module the server exits at once and the compose step only # says "dependency failed to start" (runs 52 and 63). The runner host loads it once, at boot: # echo nfsd | sudo tee /etc/modules-load.d/nfsd.conf && sudo modprobe nfsd - name: The runner host has the nfsd kernel module run: | grep -qw nfsd /proc/filesystems || { echo "fileserver-nfs: the runner host kernel has no nfsd module; load it on the host:" >&2 echo " echo nfsd | sudo tee /etc/modules-load.d/nfsd.conf && sudo modprobe nfsd" >&2 exit 1 } - uses: ./.gitea/actions/setup-java-gradle - run: docker compose -f src/adapter/outbound/fileserver/compose/nfs/compose.yml up -d --wait - run: ./gradlew :adapter:outbound:fileserver:test --tests '*NfsAmbiguityIntegrationTest' - if: ${{ always() }} run: docker compose -f src/adapter/outbound/fileserver/compose/nfs/compose.yml down -v # The notification fault, race and restart suites run again on their own: one green run says least # about exactly these. notification-chaos: if: ${{ github.event_name != 'push' }} runs-on: ubuntu-latest timeout-minutes: 60 steps: - uses: https://github.com/actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2 - uses: ./.gitea/actions/setup-java-gradle # One invocation for the four suites. A second `test --rerun` deletes the first one's result # files, and the check below then finds no results for the suites that ran first. - name: Ambiguity and fault harness, concurrency and rotation races run: >- ./gradlew :adapter:outbound:notification:test --rerun --tests '*ChaosSecurity*' --tests '*CrossProviderContractSuite*' --tests '*ConcurrencyTest' --tests '*ProviderRuntimeStateTest' # A filter that matches nothing passes. Each filter above names classes that exist today; if # one is renamed the job fails rather than quietly stops covering it. - name: Every named suite actually ran run: | for suite in ChaosSecurity CrossProviderContractSuite ConcurrencyTest ProviderRuntimeStateTest; do find . -path '*/build/test-results/*' -name "*${suite}*.xml" | grep -q . || { echo "no test results for ${suite}: the filter matched nothing" >&2 exit 1 } done - name: Restart recovery and lease fencing (real PostgreSQL) run: ./gradlew :adapter:outbound:persistence-jpa:jpaPlatformContractTest :adapter:outbound:persistence-jpa:jpaPlatformFailureTest # Advisory probes for the next JPA, Hibernate and PostgreSQL majors. The targets are not resolvable # yet, so each records NOT_EXECUTABLE with its reason instead of implying compatibility evidence. # JpaReleaseRenderingTest requires every Experimental PostgreSQL major to be the `target` here. jpa-next: if: ${{ github.event_name != 'push' }} runs-on: ubuntu-latest timeout-minutes: 60 continue-on-error: true strategy: fail-fast: false matrix: include: - id: jakarta-persistence-4 target: Jakarta Persistence 4 test: "*Jpa4CompatibilityTest" reason: the JPA 4 API is not on any configuration this build resolves, so nothing has been compiled against it - id: hibernate-8 target: Hibernate 8 test: "*Hibernate8CompatibilityTest" reason: Hibernate 8 is not resolvable from this build, so nothing has been compiled or run against it - id: postgresql-19 target: PostgreSQL 19 test: "*PostgreSql19CompatibilityTest" reason: no PostgreSQL 19 image is published yet, so no container of that major has ever been started by this lane steps: - uses: https://github.com/actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2 - uses: ./.gitea/actions/setup-java-gradle - run: ./gradlew :adapter:outbound:persistence-jpa:test --tests '${{ matrix.test }}' --rerun - if: ${{ always() }} run: | echo "${{ matrix.target }} compatibility is NOT_EXECUTABLE (${{ github.sha }}): ${{ matrix.reason }}" # The protected AWS lane, only on a manual run that asks for it: it needs the sandbox secrets. object-storage-aws: if: ${{ github.event_name == 'workflow_dispatch' && inputs.run_protected_aws }} runs-on: ubuntu-latest timeout-minutes: 30 env: OBJECT_STORAGE_AWS_QUALIFICATION_ENABLED: "true" OBJECT_STORAGE_AWS_BUCKET: ${{ secrets.OBJECT_STORAGE_AWS_BUCKET }} OBJECT_STORAGE_AWS_REGION: ${{ secrets.OBJECT_STORAGE_AWS_REGION }} OBJECT_STORAGE_AWS_EXPECTED_OWNER: ${{ secrets.OBJECT_STORAGE_AWS_EXPECTED_OWNER }} steps: - uses: https://github.com/actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2 - uses: ./.gitea/actions/setup-java-gradle - run: ./gradlew :adapter:outbound:objectstorage:objectStorageAwsQualificationTest # Every blocking Compose runtime lane, on the qualification image (Dockerfile # COMPOSITION=qualification: every capability module present). compose-smoke: if: ${{ github.event_name != 'push' }} runs-on: ubuntu-latest timeout-minutes: 180 steps: - uses: https://github.com/actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2 - run: bash scripts/run-compose-runtime-smoke.sh --matrix src/bootstrap/app/compose-lanes/compose-profile-contracts.json # Not a gate: the pull-request stage once more, on main, so that a pull request finds main's # results in the build cache and runs only what its change touches. setup-gradle keys its cache by # job name and a job first restores the newest entry of its own name, so this job is named after # pr.yml's one job. Main saves, a pull request only reads (.gitea/actions/setup-java-gradle). # Nightly and manual runs only: a push does not wait for it, and a pull request after a day's # merges reruns the modules those changed. done: if: ${{ github.event_name != 'push' }} runs-on: ubuntu-latest timeout-minutes: 75 steps: - uses: https://github.com/actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2 - uses: ./.gitea/actions/setup-java-gradle - run: ./gradlew :prCheck # Load, slow-client, shutdown, pool and resource bounds. Last, after every other heavy job of the # run, so the bounds are measured on a runner that is not building something else. # # Last by position, not by `needs`. This Gitea (1.27) decides a job's `if` on the server once the # jobs it needs finish, and it left this job Blocked in every run it reached: 2.5 days on a manual # run (63), and on every push, where the nightly jobs it waited for are skipped (79). A throwaway # workflow started by hand reproduced it with nothing else in it (2026-11-11, three variants): # every job with both `needs` and `if` stayed Blocked, whatever the `if` said and whether or not # the jobs it needed had passed. A job without `needs` is runnable when the run starts, and the one # runner (capacity 1) takes the job that became runnable first, so a run's jobs go in the order they # were created, which is their order in this file. A second runner would let this job overlap the # others; it would still run. performance: if: ${{ github.event_name != 'push' }} runs-on: ubuntu-latest timeout-minutes: 120 steps: - uses: https://github.com/actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2 - uses: ./.gitea/actions/setup-java-gradle - run: ./gradlew :performanceCheck --continue