Files
clean-architecture-backend-…/src/build.gradle
T
DongHyeonka ab5982e955 refactor(repo)!: 샘플 모듈과 그 참조를 지운다
문제: src/sample-portfolio(311파일)와 src/Dockerfile.sample이 빌드 8곳,
registry, PR job, spotbugs 제외, 매뉴얼·leaf 문서 수십 곳에 얽혀 있다.
매뉴얼과 생성 명령이 예시를 맡게 된 뒤로 샘플은 유지 비용만 남았고,
문서 일부는 이미 없는 태스크(sampleOffTest)와 ArchUnit 규칙을 가리킨다.

고른 방법: 소유자 결정(2026-11-07)대로 샘플을 폴더째 지우고 역할은
옮기지 않는다. 샘플을 가리키던 것도 같은 변경에서 지운다.
- 빌드: registry 행, 루트 build.gradle의 샘플 태스크·의존·단계
  (sampleWebContractCheck, :sample-portfolio:*, strict lane 단계),
  app-bootstrap architectureTestRuntimeOnly, spotbugs 제외 3곳
- CI: ci-quality-gates.yml의 sample-portfolio job과 release-gate 칸
- 테스트: SampleRuntimeDefaultsContractTest, Dockerfile.sample 비교 테스트,
  ArchUnit 규칙의 죽은 sample 패키지 제외. build-logic 테스트와
  application-core 테스트의 가짜 이름은 example-app으로 바꾼다
- 문서: 매뉴얼 예시를 실제 코드(durable operation, identifier,
  ErrorCodeRegistryMappingTest)로 바꾸고, 템플릿에 예가 없는 기법
  (유일 제약 → 같은 409)은 규칙과 확인 방법만 적는다. 결정 색인의
  샘플 전용 행은 "샘플과 함께 사라짐"으로 표시한다
버린 대안: 설계서 권장안(OpenAPI 스냅숏·웹 계약을 옮긴 뒤 삭제)은
소유자가 고르지 않았다.

위험·한계:
- 샘플 안에만 있던 검사(OpenAPI 스냅숏, Date 헤더, 가상 스레드 MDC
  전파, 요청당 SQL 수 단언)가 함께 사라진다. 소유자가 남기라 하면
  총괄이 따로 맡긴다.
- APP_CACHE_REDIS_ENABLED는 샘플이 읽지 않는 키라(설계서 가정과 다름)
  지우지 않고 src/README.md 문장만 고쳤다. 제거 기한 2026-11-30은 그대로.
- docs/capability-status.md 「제거된 코드」 표와 docs/work/evidence.md의
  샘플 경로는 이력이라 두었다.

검증(desktop, 트리 0525e14e, ~/t1-layout-logs/):
- ./gradlew :ci --warning-mode=fail rc=0 (502 executed, 83 from cache)
- :verifyStrictLaneStages --dry-run rc=0
- :app-bootstrap:documentContractTest rc=0
- -p build-logic check rc=0
- :verifyDependencyLocks rc=0
- python3 scripts/check-work-docs.py, 상대 링크 검사 rc=0

Refs: design-docs repo-structure/README.md 3.1, repo-structure/01-backend-layout.md 6.2
BREAKING CHANGE: src/sample-portfolio, src/Dockerfile.sample, 샘플 태스크와 job이 없어진다. 샘플을 고쳐 쓰던 파생 서비스는 병합 때 수정 대 삭제 충돌이 난다. docs/upgrade/2026-11-maturity-review.md B-49.
2026-11-07 12:21:03 +09:00

219 lines
12 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 three leaves (`./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 a workflow executes (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, migrate-and-start, smoke).
// ---------------------------------------------------------------------------------------------
// 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 the pull-request gate: leaf checks + architectureCheck + qualityCheck
// mainCheck the main-branch stage: environment contract, full-boot qualification,
// public-path baseline, transport and messaging qualification lanes, 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. integration-main.yml runs this aggregate on main and nightly.
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.
// Main stage, not `ci`: test code does not ship, and the full run is about as long as `ci` itself.
// It ran in no stage until 2026-11-04, and 53 of these tasks had been failing unseen.
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 leaf
// checks they touch plus architectureCheck. A nested build of five leaves, so 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.parentFile
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 stages a strict lane may belong to. `verifyStrictLaneStages --dry-run` (pull-request gate)
// fails when a strict lane that is not `explicitOnly` is in the plan of none of these, or when a
// stage is executed by no workflow — the gap that left fourteen lanes running nowhere while each
// one failed closed (review 2026-11-01 08-01). A new lane joins a stage through its category
// aggregate; no workflow line names it.
strictLaneStages {
stage ':ci', ':mainCheck', ':integrationCheck', ':performanceCheck', ':releaseCheck'
workflowDirectory = layout.projectDirectory.dir('../.github/workflows')
}
// The deny-by-default public path baseline: app-bootstrap's approval-test lane under its old name.
// `-PapprovePublicPathChange` rewrites the baseline after review.
tasks.register('verifyPublicPathSnapshot') {
group = 'verification'
description = 'Fails when the shipped public path default drifts from docs/security/public-paths-snapshot.txt.'
dependsOn ':app-bootstrap:publicPathSnapshotTest'
}
// 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')
}