pr / done (pull_request) Successful in 3m28s
문제: :app-bootstrap:publicPathSnapshotTest(루트 verifyPublicPathSnapshot)는
빌드에 approvePublicPathChange가 있으면 publicpath.snapshot.write=true를
시험에 주었고, 시험은 기준선을 먼저 쓴 뒤 그 파일과 비교해 늘 통과했다.
project.hasProperty는 -P뿐 아니라 gradle.properties(저장소·GRADLE_USER_HOME),
ORG_GRADLE_PROJECT_ 환경 변수, GRADLE_OPTS의 -Dorg.gradle.project.에서도
참이라, 한 줄로 보안 기준선 게이트가 말없이 꺼졌다.
고른 방법: API surface 태스크와 같은 모양으로 나눈다. 비교 lane은 쓰기
스위치를 false로 고정하고, 실행 전(doFirst)에 셋 중 하나면 「read-only」로
실패한다. (1) 빌드에 승인 속성이 있다. (2) 시험 JVM이 받을
publicpath.snapshot.write가 false가 아니다. (3) 상속한 JAVA_TOOL_OPTIONS·
JDK_JAVA_OPTIONS·_JAVA_OPTIONS에 그 스위치가 있다. 고정값은 앞의 두
변수를 이긴다(JVM이 Gradle의 -D보다 먼저 읽는다). _JAVA_OPTIONS는 뒤에
읽혀 고정값을 이기므로(기준 main에서도 같은 빈틈) (3)이 막는다. main
단계 lane이라 up-to-date·캐시가 없어 mainCheck·releaseCheck마다 검사가
돈다. 쓰기는 새 Test 태스크 :app-bootstrap:publicPathSnapshotUpdate(루트
별칭 updatePublicPathSnapshot)가 같은 tag 시험을 쓰기 스위치를 켜고
돌린다. 승인 속성이 없으면 쓰기 전에 실패하고, 어떤 단계에도 들지
않으며, 매번 다시 돈다.
버린 대안: 쓴 뒤 「기준선을 다시 썼다, 커밋하라」로 실패시키기 — 한 lane
안에서 통과·실패의 뜻이 갈려 lane 결과 판정과 섞인다. update를
explicitOnly strict lane으로 두기 — TEST lane은 캐시되어 쓰기를 건너뛸 수
있고 집계 태스크마다 안내가 찍힌다.
위험·한계: 승인 명령이 verifyPublicPathSnapshot -P…에서
updatePublicPathSnapshot -P…로 바뀐다. 승인 속성을 상시로 둔 파생 서비스는
mainCheck·releaseCheck가 실패한다(docs/upgrade/2026-11-round9-public-surface.md
5행). 기준선 머리 주석의 명령 한 줄만 바뀌고 경로 내용은 그대로다.
갱신 명령을 적은 곳(docs/build.md, be-security 스킬, 제거 표
docs/capability-status.md·build-logic/README.md)도 함께 고친다.
검증: desktop 공유 잠금 아래 detached worktree, --no-build-cache.
변이 = gradle.properties의 approvePublicPathChange=true + SecurityConfig의
requestMatchers("/v1/admin/**").permitAll() 한 줄.
- RED(기준 96c0b4c7): 변이에서 verifyPublicPathSnapshot rc=0, 기준선에
permitAll 줄이 덧붙었다. permitAll + _JAVA_OPTIONS로 쓰기 스위치를 준
것도 rc=0(JAVA_TOOL_OPTIONS·JDK_JAVA_OPTIONS는 rc=1).
- GREEN(이 커밋 트리 3958ac3e):
- 변이 없음 verifyPublicPathSnapshot rc=0.
- 변이, -P, ORG_GRADLE_PROJECT_ 각각 rc=1 「is read-only」.
- permitAll + 세 JVM 옵션 변수 각각 rc=1 「is read-only」.
- 빌드 스크립트가 쓰기 스위치를 true로 덮으면 rc=1 「is read-only」.
- permitAll만 rc=1 「surface changed」.
- 승인 없는 updatePublicPathSnapshot rc=1, 기준선 그대로.
- updatePublicPathSnapshot -PapprovePublicPathChange rc=0, 새 줄이
들어가고 이어서 verifyPublicPathSnapshot rc=0.
- scripts/ci/verify-configuration-cache.sh rc=0.
- scripts/verify.sh(트리 3958ac3e, 「HEAD 트리와 같음」): desktop leaf
:app-bootstrap --no-cache rc=0(tests=330 failures=0), desktop pr
--no-cache rc=0(tests=7329 failures=0), 노트북 docs rc=0.
BREAKING CHANGE: 공개 경로 스냅숏 갱신은 ./gradlew updatePublicPathSnapshot
-PapprovePublicPathChange다. verifyPublicPathSnapshot·mainCheck·releaseCheck는
approvePublicPathChange가 어디서든 켜져 있으면 실패한다.
Refs: REV-BE-0011
304 lines
17 KiB
Groovy
304 lines
17 KiB
Groovy
plugins {
|
|
// Spring Boot stays on the root build script classpath because a leaf applies it by id
|
|
// (`app-bootstrap`) and a leaf resolves plugin classes from the root.
|
|
//
|
|
// Spotless, SpotBugs, Error Prone and Spring's dependency-management are NOT here any more. They
|
|
// were declared `apply false` for a `configure(subprojects)` block that applied them to every
|
|
// leaf; build-logic's `ca.quality-conventions` and `ca.java-conventions` apply them now, and a
|
|
// plugin reachable from two classpaths is two versions waiting to differ. Their versions are the
|
|
// same catalog entries either way — build-logic/settings.gradle reads gradle/libs.versions.toml.
|
|
alias(libs.plugins.spring.boot) apply false
|
|
// JMH benchmarks in the leaves that apply this plugin (`./gradlew :<leaf>:jmh`); never part of a gate.
|
|
alias(libs.plugins.jmh) apply false
|
|
|
|
// Convention plugin from the included build, applied to the ROOT because the rules it owns are
|
|
// about the repository: the architecture gates. The release version/revision is each leaf's
|
|
// `ca.java-conventions` (ca.release-provenance was removed, BUILD-O3-5). The public-path
|
|
// baseline is app-bootstrap's approval test, the local start-up is scripts/bootstrap-local.sh,
|
|
// and archive hygiene is gone with the revision it cleaned out of every leaf's jar name (review
|
|
// 2026-09-24 BUILD-O3-5).
|
|
id 'ca.architecture'
|
|
// Every strict lane belongs to a stage, and each stage's workflow job runs it (review
|
|
// 2026-11-01 08-01).
|
|
id 'ca.strict-lane-stages'
|
|
}
|
|
|
|
group = 'dev.caskeleton'
|
|
|
|
// A release archive has to name the commit that produced it. The revision rule is the one every
|
|
// leaf's version uses (JavaConventionsPlugin.sourceRevision, tested in build-logic), read here so
|
|
// the tag-only gate and the jars cannot disagree about what counts as a commit id.
|
|
tasks.register('verifyReleaseProvenance') {
|
|
group = 'verification'
|
|
description = 'Fails when the build cannot name the source revision it was produced from.'
|
|
String revision = dev.caskeleton.buildlogic.java.JavaConventionsPlugin.sourceRevision(providers)
|
|
boolean traceable = revision != dev.caskeleton.buildlogic.java.JavaConventionsPlugin.UNKNOWN_REVISION
|
|
outputs.upToDateWhen { false }
|
|
doLast { task ->
|
|
if (!traceable) {
|
|
throw new GradleException('verifyReleaseProvenance: no source revision. A release archive has to name the '
|
|
+ 'commit that produced it; supply -PgitRevision=<sha>, GIT_SHA or GITHUB_SHA.')
|
|
}
|
|
task.logger.lifecycle("verifyReleaseProvenance: OK — revision ${revision}")
|
|
}
|
|
}
|
|
|
|
// One explicit command regenerates every module's Gradle-default lockfile.
|
|
tasks.register('resolveAndLockAll') {
|
|
group = 'build setup'
|
|
description = 'Regenerates dependency locks for all subprojects (requires --write-locks).'
|
|
dependsOn subprojects.findAll { it.childProjects.isEmpty() }.collect { "${it.path}:resolveAndLockAll" }
|
|
}
|
|
|
|
tasks.register('verifyDependencyLocks') {
|
|
group = 'verification'
|
|
description = 'Verifies strict dependency lock state for production CI subprojects.'
|
|
dependsOn subprojects.findAll { it.childProjects.isEmpty() }.collect { "${it.path}:verifyDependencyLocks" }
|
|
}
|
|
|
|
// feature-developer-experience-contract D3 — the ordered local bootstrap lifecycle is
|
|
// scripts/bootstrap-local.sh (compile, Docker preflight, dependency wait, start, smoke). Startup
|
|
// Flyway runs only when the persistence-jpa runtimeOnly line is on; the default composition is web.
|
|
|
|
// ---------------------------------------------------------------------------------------------
|
|
// Lifecycle.
|
|
//
|
|
// :<leaf>:check that leaf — compile, its tests, Spotless, Checkstyle, Error Prone
|
|
// check every leaf's check (Gradle matches the name across projects)
|
|
// architectureCheck dependency direction + purity + app-bootstrap whole-repository ArchUnit
|
|
// qualityCheck SpotBugs + FindSecBugs across every leaf (ca.quality-conventions)
|
|
// ci leaf checks + architectureCheck + qualityCheck
|
|
// prCheck the pull-request stage: ci + testQualityCheck + every leaf's
|
|
// auxiliaryStyleCheck + dependency locks + the Compose render, the
|
|
// repository layout and the document checks (scripts outside Gradle)
|
|
// mainCheck the main-branch stage: environment contract, full-boot qualification,
|
|
// public-path baseline, transport and messaging qualification lanes, the
|
|
// GraphQL transport-boundary lane (graphqlStableTest), each leaf's
|
|
// document-contract lanes, and the feature generator round trip
|
|
// (verifyFeatureScaffold)
|
|
// integrationCheck the declared strict integration lanes (several need a container runtime)
|
|
// performanceCheck the declared strict performance lanes (load, shutdown, pool and resource
|
|
// bounds; real servers and containers)
|
|
// releaseCheck the tag-only checks: release provenance + public path snapshot (not `ci`
|
|
// again — a tag is cut from a main commit the PR and main stages ran on)
|
|
//
|
|
// A leaf's check is that leaf's; a repository question gets a repository task named after it.
|
|
// Task PATHS, not TaskProviders: a leaf's tasks are created by convention plugins after the root is
|
|
// evaluated, and a path is resolved when the task graph is built.
|
|
// ---------------------------------------------------------------------------------------------
|
|
List<String> leafPaths = subprojects.findAll { it.childProjects.isEmpty() }.collect { it.path }.toSorted()
|
|
|
|
tasks.register('qualityCheck') {
|
|
group = 'verification'
|
|
description = 'Runs SpotBugs and FindSecBugs across every production CI leaf.'
|
|
dependsOn leafPaths.collect { "${it}:qualityCheck" }
|
|
}
|
|
|
|
tasks.register('configContractCheck') {
|
|
group = 'verification'
|
|
description = 'Runs the environment contract owned by the composition root.'
|
|
dependsOn ':app-bootstrap:verifyEnvKeys'
|
|
}
|
|
|
|
// A lane that needs an input this build was not given (the Redis topology coordinates, the protected
|
|
// AWS sandbox authority) is explicit-only: the aggregate leaves it out and names it when it runs
|
|
// (review NEW-16).
|
|
tasks.register('integrationCheck') {
|
|
group = 'verification'
|
|
description = "Runs every production CI leaf's integration-category test lanes. Several need a container runtime."
|
|
dependsOn leafPaths.collect { "${it}:integrationTestLaneCheck" }
|
|
}
|
|
|
|
// Performance lanes are not the pull request's or the main stage's: their bounds need a machine that
|
|
// is not compiling something else. main.yml runs this aggregate nightly, after its other jobs.
|
|
tasks.register('performanceCheck') {
|
|
group = 'verification'
|
|
description = "Runs every production CI leaf's performance-category test lanes. Several need a container runtime."
|
|
dependsOn leafPaths.collect { "${it}:performanceTestLaneCheck" }
|
|
}
|
|
|
|
tasks.named('architectureCheck') {
|
|
dependsOn leafPaths.collect { "${it}:architectureTestLaneCheck" }
|
|
}
|
|
|
|
// app-bootstrap is left out: its `check` already runs its full-boot lane in the pull-request gate,
|
|
// and the main stage ran the same lane a second time on every main push (review 2026-11-01 08-02).
|
|
// The lane stays merge-blocking, because a composition that does not boot must not merge.
|
|
tasks.register('systemTestCheck') {
|
|
group = 'verification'
|
|
description = "Runs every production CI leaf's full application/system test lanes that `ci` does not already run."
|
|
dependsOn leafPaths.findAll { it != ':app-bootstrap' }.collect { "${it}:systemTestLaneCheck" }
|
|
}
|
|
|
|
tasks.register('qualificationCheck') {
|
|
group = 'verification'
|
|
description = 'Runs repository/build-behavior qualification that is intentionally outside local leaf checks.'
|
|
dependsOn tasks.named('systemTestCheck')
|
|
dependsOn leafPaths.collect { "${it}:auxiliaryStyleCheck" }
|
|
dependsOn tasks.named('testQualityCheck')
|
|
}
|
|
|
|
// SpotBugs + FindSecBugs over every leaf's test source sets, against config/spotbugs/exclude-test.xml.
|
|
// It ran in no stage until 2026-11-04, and 53 of these tasks had been failing unseen. From then it ran
|
|
// in the main stage only, so a finding in test code surfaced after the merge (main run 269: a dead
|
|
// local store in graphql's systemTest). Since 2026-11-20 prCheck runs it and every leaf's
|
|
// auxiliaryStyleCheck too: a pull request restores the build cache main's `done` job fills, so the
|
|
// analysis of a leaf whose inputs did not change comes from it (desktop 2026-11-13, the unchanged tree
|
|
// in a second checkout: +29 s with a warm cache, +310 s without). qualificationCheck keeps both as
|
|
// well; taking a gate out of a stage is the owner's call.
|
|
tasks.register('testQualityCheck') {
|
|
group = 'verification'
|
|
description = 'Runs SpotBugs and FindSecBugs over every leaf\'s test source sets.'
|
|
dependsOn leafPaths.collect { "${it}:testQualityCheck" }
|
|
}
|
|
|
|
// The feature generator's round trip (review 2026-11-01 개선 순서 4): scripts/new-feature.sh writes
|
|
// two features into a throwaway copy of the working tree and that copy's own Gradle runs the checks
|
|
// of the five leaves they touch plus architectureCheck, which runs every leaf's architecture lane. A
|
|
// nested build that long belongs to the main stage, not the pull request. The script is the whole
|
|
// check; this task only gives it a stage.
|
|
tasks.register('verifyFeatureScaffold', Exec) {
|
|
group = 'verification'
|
|
description = 'Generates features with scripts/new-feature.sh in a scratch copy and runs the gates they must pass.'
|
|
workingDir = rootProject.projectDir
|
|
commandLine 'bash', 'scripts/verify-feature-scaffold.sh'
|
|
}
|
|
|
|
// Each lane below names its tests and rejects skips; these two only aggregate them.
|
|
tasks.register('conditionalTransportQualification') {
|
|
group = 'verification'
|
|
description = 'Runs the no-skip GraphQL, gRPC and WebSocket transport lanes and the opt-in classpath contract.'
|
|
dependsOn ':adapter:inbound:graphql:graphqlTransportQualificationTest',
|
|
':adapter:inbound:grpc:grpcTransportQualificationTest',
|
|
':adapter:inbound:websocket:websocketTransportQualificationTest',
|
|
':app-bootstrap:conditionalTransportBuildContractTest'
|
|
}
|
|
|
|
tasks.register('verifyMessagingContracts') {
|
|
group = 'verification'
|
|
description = 'Qualifies the application integration-event contract and the shared envelope schema.'
|
|
dependsOn ':application-core:messagingApplicationContractQualificationTest',
|
|
':shared-contract:messagingSharedSchemaQualificationTest'
|
|
}
|
|
|
|
tasks.register('ci') {
|
|
group = 'verification'
|
|
description = 'The pull-request gate: every production CI leaf check plus the architecture and quality gates.'
|
|
dependsOn leafPaths.collect { "${it}:check" }
|
|
dependsOn tasks.named('architectureCheck')
|
|
dependsOn tasks.named('qualityCheck')
|
|
}
|
|
|
|
tasks.register('mainCheck') {
|
|
group = 'verification'
|
|
description = 'The main-branch stage: the gates that are not worth a pull request\'s wait.'
|
|
dependsOn leafPaths.collect { "${it}:mainCheck" }
|
|
dependsOn tasks.named('configContractCheck')
|
|
dependsOn tasks.named('qualificationCheck')
|
|
dependsOn tasks.named('verifyPublicPathSnapshot')
|
|
dependsOn tasks.named('conditionalTransportQualification')
|
|
dependsOn tasks.named('verifyMessagingContracts')
|
|
dependsOn ':adapter:inbound:graphql:graphqlStableTest'
|
|
dependsOn tasks.named('verifyFeatureScaffold')
|
|
}
|
|
|
|
// The checks outside Gradle that the pull-request stage runs. Each is a script with its own tests
|
|
// (scripts/tests); these tasks only give them a stage, so pr.yml and scripts/verify.sh run the same
|
|
// one line. Repository root as working directory: that is where the scripts expect to start.
|
|
def repositoryRoot = rootProject.projectDir
|
|
tasks.register('verifyComposeProfiles', Exec) {
|
|
group = 'verification'
|
|
description = 'Renders every Compose lane and checks it renders exactly what it declares.'
|
|
workingDir = repositoryRoot
|
|
commandLine 'bash', 'scripts/verify-compose-profile-contracts.sh'
|
|
}
|
|
tasks.register('verifyRepositoryLayout', Exec) {
|
|
group = 'verification'
|
|
description = 'Refuses a top-level entry of the repository or src/ outside the allow list.'
|
|
workingDir = repositoryRoot
|
|
commandLine 'python3', 'scripts/check-repo-layout.py'
|
|
}
|
|
tasks.register('verifyWorkDocs', Exec) {
|
|
group = 'verification'
|
|
description = 'Checks the work manual: size limits, no history IDs, playbook skeleton, relative links.'
|
|
workingDir = repositoryRoot
|
|
commandLine 'python3', 'scripts/check-work-docs.py'
|
|
}
|
|
tasks.register('testDocumentChecks', Exec) {
|
|
group = 'verification'
|
|
description = 'Runs the tests of the scripts outside Gradle (document checker, hooks, ledger).'
|
|
workingDir = repositoryRoot
|
|
commandLine 'python3', '-m', 'unittest', 'discover', '-s', 'scripts/tests'
|
|
}
|
|
tasks.register('documentCheck', Exec) {
|
|
group = 'verification'
|
|
description = 'Checks living documents: language, head blocks, references, numbers, links, style.'
|
|
workingDir = repositoryRoot
|
|
commandLine 'python3', 'scripts/check-docs.py'
|
|
dependsOn tasks.named('testDocumentChecks')
|
|
}
|
|
|
|
tasks.register('prCheck') {
|
|
group = 'verification'
|
|
description = 'The pull-request stage: ci, test-code analysis and style, dependency locks, the Compose render, the layout, the work manual and the documents.'
|
|
dependsOn tasks.named('ci')
|
|
dependsOn tasks.named('testQualityCheck')
|
|
dependsOn leafPaths.collect { "${it}:auxiliaryStyleCheck" }
|
|
dependsOn tasks.named('verifyDependencyLocks')
|
|
dependsOn tasks.named('verifyComposeProfiles')
|
|
dependsOn tasks.named('verifyRepositoryLayout')
|
|
dependsOn tasks.named('verifyWorkDocs')
|
|
dependsOn tasks.named('documentCheck')
|
|
}
|
|
|
|
// The stages a strict lane may belong to, and the one workflow job that runs each.
|
|
// `verifyStrictLaneStages --dry-run` (pull-request stage) fails when a strict lane that is not
|
|
// `explicitOnly` is in the plan of none of them — the gap that left fourteen lanes running nowhere
|
|
// while each one failed closed (review 2026-11-01 08-01) — or when a stage job is not the line
|
|
// `./gradlew <stage> <options>` under the declared event and condition. A new lane joins a stage
|
|
// through its category aggregate; no workflow line names it. The performance lane runs only
|
|
// nightly, after the other heavy jobs, on a runner nothing else is using (owner decision 2026-11-07).
|
|
strictLaneStages {
|
|
workflowDirectory = layout.projectDirectory.dir('.gitea/workflows')
|
|
stage ':prCheck', workflow: 'pr.yml', event: 'pull_request', job: 'done'
|
|
// One job and one Gradle run for both main-branch stages: it compiles once, and the
|
|
// main stage's analysis and the feature generator's nested build run while the integration
|
|
// lanes take turns on the one real-server slot. Two jobs spent about 34 runner minutes on a push
|
|
// (run 79), two of them compiling the same modules twice.
|
|
// integrationCheck comes first on the line because Gradle starts ready work in the order of
|
|
// the requested tasks: the integration lanes' compiles go first and the slot is busy from the
|
|
// first minute. Second on the line, the lanes waited about ten minutes behind the main stage's
|
|
// analysis and then ran one at a time on an idle machine (desktop 1,760 s, first on the line
|
|
// 1,484 s, same commit range).
|
|
stage ':mainCheck', workflow: 'main.yml', event: 'push', filter: 'branches: [main]', job: 'main',
|
|
options: '--continue', line: ':integrationCheck :mainCheck'
|
|
stage ':integrationCheck', workflow: 'main.yml', event: 'push', filter: 'branches: [main]', job: 'main',
|
|
options: '--continue', line: ':integrationCheck :mainCheck'
|
|
stage ':performanceCheck', workflow: 'main.yml', event: 'schedule', job: 'performance', options: '--continue',
|
|
condition: '${{ github.event_name != \'push\' }}'
|
|
stage ':releaseCheck', workflow: 'release.yml', event: 'push', filter: 'tags: ["v*"]', job: 'release'
|
|
}
|
|
|
|
// The deny-by-default public path baseline: app-bootstrap's approval-test lane under its old name.
|
|
// It only compares, and fails when the build sets approvePublicPathChange. After review,
|
|
// `updatePublicPathSnapshot -PapprovePublicPathChange` rewrites the baseline.
|
|
tasks.register('verifyPublicPathSnapshot') {
|
|
group = 'verification'
|
|
description = 'Fails when the public path surface (default, profile overrides, filter-chain permitAll and securityMatcher statements) drifts from docs/security/public-paths-snapshot.txt.'
|
|
dependsOn ':app-bootstrap:publicPathSnapshotTest'
|
|
}
|
|
tasks.register('updatePublicPathSnapshot') {
|
|
group = 'verification'
|
|
description = 'Rewrites docs/security/public-paths-snapshot.txt from the current public path surface after review. Requires -PapprovePublicPathChange.'
|
|
dependsOn ':app-bootstrap:publicPathSnapshotUpdate'
|
|
}
|
|
|
|
// The checks that only matter for a release artifact. Not `ci` again: a release tag is cut from a
|
|
// main commit that the pull-request gate and the main stage already ran on (review BUILD-중복-6).
|
|
tasks.register('releaseCheck') {
|
|
group = 'verification'
|
|
description = 'The tag-only checks: release provenance and the public path baseline.'
|
|
dependsOn tasks.named('verifyReleaseProvenance')
|
|
dependsOn tasks.named('verifyPublicPathSnapshot')
|
|
}
|