Files
clean-architecture-backend-…/.gitea/workflows/main.yml
T
DongHyeonka 5feb06982d
pr / done (pull_request) Canceled after 0s
ci(release): needs가 있는 job이 runner 대기열 뒤로 가는 비용을 적는다
수동 release run 157에서 `app-image-release`는 gate가 끝나고 3시간 뒤에,
`app-image-signing`은 이미지 job이 끝나고 2시간 뒤에 시작했다. runner
label(`ubuntu-latest`)은 다른 job과 같고 environment도 없다. 원인은
`needs`다. Gitea는 runner에 실행할 수 있게 된 지 가장 오래된 job을 준다.
그 runner가 받는 모든 repo가 대상이다. `needs`가 없는 job은 run을 만들 때부터
실행할 수 있다. `needs`가 있는 job은 앞 job이 끝나야 실행할 수 있다. 그래서
그 시각 전에 만들어진 모든 job 뒤에 선다.

같은 시간대 두 repo의 job 시각이 이 순서와 맞는다.
- 이미지 job(17:50 실행 가능): 17:47에 만들어진 프론트 run까지 먼저 돌았다.
  17:51에 만들어진 run보다는 앞이었다.
- 서명 job(21:01 실행 가능): 19:28에 만들어진 run까지 먼저 돌았다. 22:30에
  만들어진 run보다는 앞이었다.

release.yml에 그 비용과 측정값을 적고, 태그는 대기 중인 run이 없을 때
자르라고 적는다. main.yml `performance` 주석의 「만든 순서」도 「실행할 수
있게 된 순서」로 고친다. `needs`가 없는 job에서는 둘이 같다.

고르지 않은 안:
- `needs`를 빼고 파일 순서에 맡긴다. gate가 실패해도 이미지가 publish될 수
  있다.
- 서명을 이미지 job에 합친다. 서명 키가 빌드하는 job에 들어간다.
- runner를 늘린다. 이번 프로그램의 범위 밖이다.
대기는 runner가 바쁠 때만 생기고, release 비용(job 시간 합)에는 들어가지
않는다.

동작 변경 없음: 주석만 바꿨다.

검증: scripts/verify.sh docs(노트북) rc=0. release.yml을 읽는 시험
(DeveloperExperienceContractTest, JpaReleaseRenderingTest)은 주석 문구를
보지 않고, 넣은 주석에는 JPA gate 태스크 이름이 없다.
2026-11-13 08:32:49 +09:00

359 lines
18 KiB
YAML

# 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