refactor: 리펙토링 진행중 의존성 gradle은 얇게 유지, 각 모듈에서 처리하고 있는 부분에 대해서 리펙토링

This commit is contained in:
donghyeon-ka
2026-09-24 11:15:10 +09:00
parent 9da00eb782
commit 208077fddf
438 changed files with 5815 additions and 1528 deletions
-1
View File
@@ -4,7 +4,6 @@
/.trivyignore.yaml @DongHyeonka
/.github/ @DongHyeonka
/renovate.json @DongHyeonka
/flaky-quarantine.yaml @DongHyeonka
# Public security and compatibility baselines require an explicit maintainer review.
/docs/security/ @DongHyeonka
+30
View File
@@ -129,10 +129,40 @@ jobs:
run: ./gradlew -p optional-platforms ci --stacktrace
configuration-cache:
# Two questions, and they are not the same question.
#
# The first is whether every task in the repository-wide gates can be *stored*. That is a
# property of the task graph, so `--dry-run` answers it for the whole of `ci`,
# `integrationCheck` and `releaseCheck` in seconds, and it is the question this job used to
# duck: it checked two leaves, because four tasks elsewhere held a live `Configuration` in
# their state and could not be serialised at all. They hold resolved root components now, so
# the honest scope is all three gates rather than two leaves.
#
# The second is whether a stored entry is actually *reused* and the build still executes its
# work. `--dry-run` cannot answer that, so the executing check stays — on the two core leaves,
# because doubling a full `ci` run to prove reuse would cost more than the guarantee is worth.
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2
- uses: ./.github/actions/setup-gradle-java
- name: Require every repository-wide gate to be storable
working-directory: src
shell: bash
run: |
set -euo pipefail
for gate in ci integrationCheck releaseCheck; do
echo "::group::${gate}"
./gradlew "${gate}" --dry-run \
--configuration-cache --configuration-cache-problems=fail --stacktrace
output="$({ ./gradlew "${gate}" --dry-run \
--configuration-cache --configuration-cache-problems=fail --stacktrace; } 2>&1)"
printf '%s\n' "${output}"
echo '::endgroup::'
grep -Fq 'Reusing configuration cache.' <<<"${output}" || {
echo "::error::Gradle did not reuse the configuration cache for ${gate}."
exit 1
}
done
- name: Store configuration cache for the everyday core build
working-directory: src
run: >-
+33 -2
View File
@@ -290,8 +290,39 @@ jobs:
working-directory: src
run: ./gradlew :adapter:outbound:persistence-jpa:postgresqlLegacyOutboxRowLifecycleIntegrationTest --stacktrace
# Dynamic half of the compose-profile contract. All 15 blocking lanes run on main/nightly; a
# partial lane run is reproduction only and cannot satisfy this job.
# The optional gRPC platform build declares one strict INTEGRATION lane —
# `grpc-operation-ledger-jpa:integrationTest`, which certifies the atomic
# `INSERT ... ON CONFLICT DO NOTHING` claim that durable mutation idempotency rests on against a
# real PostgreSQL. It was registered in Gradle, listed in `strictTestLanes`, and invoked by
# nothing: `-p optional-platforms ci` reaches `checkAll`, `qualityCheck` and the dependency
# verifier, none of which runs a lane whose category is INTEGRATION, and release.yml's gRPC gate
# names only the three grpc-testkit lanes.
#
# Stage 2 rather than stage 1 for the same reason as every other job in this file: the lane starts
# a Testcontainers PostgreSQL, and the pull-request budget is minutes for the whole gate.
grpc-optional-platform-integration:
runs-on: ubuntu-latest
timeout-minutes: 45
env:
TESTCONTAINERS_REUSE_ENABLE: "false"
steps:
- uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2
- uses: ./.github/actions/setup-gradle-java
- name: Certify the gRPC operation ledger against real PostgreSQL
working-directory: src
run: ./gradlew -p optional-platforms integrationCheck --stacktrace
- name: Publish the optional-platform lane reports
if: always()
uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # actions/upload-artifact@v4.6.2
with:
name: grpc-optional-platform-integration-reports
path: src/optional-platforms/**/build/reports/tests/
if-no-files-found: warn
# Dynamic half of the compose-profile contract. Every blocking lane the matrix declares runs on
# main and nightly; a partial lane run is reproduction only and cannot satisfy this job. The count
# is not written here on purpose — a number in prose drifts the moment a lane is added, and the
# matrix file is the thing this job reads.
compose-runtime-smoke:
runs-on: ubuntu-latest
timeout-minutes: 180
+4 -3
View File
@@ -84,9 +84,10 @@ services:
stop_grace_period: 40s
# ---- Health check -------------------------------------------------------
# Targets the actuator readiness probe on the management port (9001).
# CROSS-FEATURE COUPLING: /actuator/health/readiness is implemented by the
# parallel runtime-health + actuator branches. This healthcheck will report
# UNHEALTHY in this worktree until those branches are merged.
# The warning that used to stand here — that this probe would report UNHEALTHY until two
# parallel branches merged — outlived the branches. src/Dockerfile removed its copy and said
# why: "a stale warning about a healthcheck is the kind of comment that gets a real red
# container ignored."
healthcheck:
test:
- "CMD"
+1 -28
View File
@@ -5,7 +5,7 @@
# root yet.
# Update only after review with:
# ./gradlew :adapter:outbound:persistence-jpa:updateJpaApiSurface -PapproveJpaApiSurfaceChange
# types: 338
# types: 311
dev.caskeleton.adapter.outbound.persistence.api.PersistenceOperationName
dev.caskeleton.adapter.outbound.persistence.api.capability.CapabilitySupport
dev.caskeleton.adapter.outbound.persistence.api.capability.JpaCapability
@@ -58,9 +58,6 @@ dev.caskeleton.adapter.outbound.persistence.api.transaction.TransactionProfile
dev.caskeleton.adapter.outbound.persistence.audit.AuditContextPort
dev.caskeleton.adapter.outbound.persistence.audit.AuditableEntity
dev.caskeleton.adapter.outbound.persistence.audit.DomainContextAuditContextPort
dev.caskeleton.adapter.outbound.persistence.auditing.AuditMetadata
dev.caskeleton.adapter.outbound.persistence.auditing.JpaAuditingConfiguration
dev.caskeleton.adapter.outbound.persistence.auditing.JpaAuditorProvider
dev.caskeleton.adapter.outbound.persistence.cache.CacheConcurrencyStrategy
dev.caskeleton.adapter.outbound.persistence.cache.CacheRegionCatalog
dev.caskeleton.adapter.outbound.persistence.cache.HibernateCacheGuard
@@ -107,30 +104,6 @@ dev.caskeleton.adapter.outbound.persistence.experimental.tenant.TenantId
dev.caskeleton.adapter.outbound.persistence.failure.PersistenceExceptionTranslator
dev.caskeleton.adapter.outbound.persistence.failure.SqlStateErrorMapping
dev.caskeleton.adapter.outbound.persistence.failure.StandardSqlStateErrorMapping
dev.caskeleton.adapter.outbound.persistence.fileserver.FileserverJpaPersistenceConfig
dev.caskeleton.adapter.outbound.persistence.fileserver.FileserverSchemaActivation
dev.caskeleton.adapter.outbound.persistence.fileserver.JpaCleanupQueue
dev.caskeleton.adapter.outbound.persistence.fileserver.JpaContentReferenceLedger
dev.caskeleton.adapter.outbound.persistence.fileserver.JpaFileMetadataStore
dev.caskeleton.adapter.outbound.persistence.fileserver.JpaFileQuotaService
dev.caskeleton.adapter.outbound.persistence.fileserver.JpaQuotaCommitGateway
dev.caskeleton.adapter.outbound.persistence.fileserver.JpaQuotaReclaimGateway
dev.caskeleton.adapter.outbound.persistence.fileserver.JpaRecoveryQueue
dev.caskeleton.adapter.outbound.persistence.fileserver.JpaStagingUploadLocator
dev.caskeleton.adapter.outbound.persistence.fileserver.JpaUploadSessionStore
dev.caskeleton.adapter.outbound.persistence.fileserver.entity.CleanupItemEntity
dev.caskeleton.adapter.outbound.persistence.fileserver.entity.FileEntity
dev.caskeleton.adapter.outbound.persistence.fileserver.entity.QuotaReservationEntity
dev.caskeleton.adapter.outbound.persistence.fileserver.entity.RecoveryItemEntity
dev.caskeleton.adapter.outbound.persistence.fileserver.entity.UploadSessionEntity
dev.caskeleton.adapter.outbound.persistence.fileserver.entity.VerificationResultEntity
dev.caskeleton.adapter.outbound.persistence.fileserver.repository.FileTransitionRepository
dev.caskeleton.adapter.outbound.persistence.fileserver.repository.FileserverCleanupRepository
dev.caskeleton.adapter.outbound.persistence.fileserver.repository.FileserverQuotaRepository
dev.caskeleton.adapter.outbound.persistence.fileserver.repository.FileserverRecoveryRepository
dev.caskeleton.adapter.outbound.persistence.fileserver.repository.JpaFileRepository
dev.caskeleton.adapter.outbound.persistence.fileserver.repository.JpaUploadSessionRepository
dev.caskeleton.adapter.outbound.persistence.fileserver.repository.UploadLeaseRepository
dev.caskeleton.adapter.outbound.persistence.h2.H2IdempotencyClaimRepository
dev.caskeleton.adapter.outbound.persistence.h2.H2LocalTimeoutConfigurer
dev.caskeleton.adapter.outbound.persistence.h2.H2OutboxClaimRepository
+51
View File
@@ -0,0 +1,51 @@
# Capability status — IMPLEMENTED / WIRED / QUALIFIED
Three different questions get three different answers, and conflating them is what the
2026-09-18 techlead review found over and over: a capability with 12,000 lines and 482 green tests
that no running application assembled, and a provider with no wiring that was nonetheless live.
"There is code for it" is not "the shipped artifact builds it" is not "it has been proven against a
real provider."
| Column | The question | Who decides it |
| --- | --- | --- |
| **IMPLEMENTED** | Does this repository contain the capability? | `src/config/architecture/modules.json` — the leaf is registered |
| **WIRED** | Does the shipped `app-bootstrap` artifact assemble it when its switch is on? | the leaf's `META-INF/spring/...AutoConfiguration.imports`, its edge in `app-bootstrap/build.gradle`, and a composition test that boots `CaSkeletonApplication` |
| **QUALIFIED** | Has it been proven against a real provider, by something CI runs? | a strict test lane against a real provider **and** a workflow that executes it |
The third column is the one that rots quietly, because a lane can exist and be invoked by nothing.
Each row below names the lane *and* the workflow, so "qualified" can be checked rather than believed.
## Status
| Capability | Master switch | IMPLEMENTED | WIRED | QUALIFIED | Evidence |
| --- | --- | --- | --- | --- | --- |
| Relational persistence (JPA/PostgreSQL) | `APP_PERSISTENCE_JPA_ENABLED` | yes | yes | yes | six `postgresql*IntegrationTest` lanes, run by `integration-main.yml` → `jpa-provider-ownership-contracts` |
| Document persistence (MongoDB) | `APP_PERSISTENCE_MONGO_ENABLED` | yes | yes | yes | six container lanes (`mongoReplicaSetTest`, `mongoFailoverTest`, …), run by `integration-main.yml` → `mongo-container-lanes` |
| Messaging (broker-neutral core) | `APP_MESSAGING_ENABLED` | yes | yes | Kafka only | `messaging-kafka:messagingCertificationTest` behind `verifyMessagingCertificationEvidence`, run by `messaging-certification.yml`. **No broker starter ships**: a deployment composes `messaging-spring-boot-starter-kafka` or `-rabbit` itself, and selecting a broker it did not compose is refused at startup. Rabbit ships validators and no transport. |
| Redis capabilities (cache / rate-limit / lease / idempotency) | `APP_REDIS_ENABLED` | yes | yes | yes | `cache-redis:redisTopologyTest`, run by `redis-sdk-topology.yml` |
| Notification platform | `APP_NOTIFICATION_PLATFORM_ENABLED` | yes | yes | claim-scoped | `verifyNotificationEvidence` refuses a grade in `docs/notification/support-matrix.md` that no proven claim backs; run by `notification-platform.yml`. There is no real-SMTP lane, and the matrix says so rather than implying one. |
| File export publication (R2) | `APP_FILESERVER_ENABLED` | yes | yes | yes | A different capability from the platform row below, in its own namespace so the two cannot be switched on together by accident. Atomic publication and durability are proven by `adapter:outbound:fileserver`'s own lanes inside its `check`, which every PR runs. |
| File server platform | `APP_FILESERVER_PLATFORM_ENABLED` | yes | yes | yes | `app-bootstrap:integrationTest` → `FileserverCompositionIntegrationTest` (required by the strict lane, so it cannot silently disappear), run by `integration-main.yml` → `bootstrap-integration` |
| Outbound HTTP client | `APP_HTTPCLIENT_ENABLED` | yes | yes | yes | `httpclient:httpClientFailureInjectionTest` against a faulted upstream, run by `integration-main.yml` → `httpclient-fault-injection` |
| GraphQL transport | `APP_GRAPHQL_ENABLED` | yes | yes | compose-level | `local-graphql` and the three `off-*` lanes in `src/config/runtime/compose-profile-contracts.json`, run by `integration-main.yml` → `compose-runtime-smoke`. The route's absence when the switch is off is what those lanes prove. |
| Object storage | `app.object-storage.enabled` (no `MasterSwitch` entry) | yes | **no** | MinIO only | The leaf is **not** an `app-bootstrap` dependency — only `sample-portfolio` consumes it, and `app-bootstrap:integrationTest` assembles it test-only against digest-pinned MinIO. A fork that wants it adds the edge. |
| gRPC platform | — (build-level) | yes | **no** | yes | Absent from the main build entirely: `optional-platforms` is a separate Gradle build, so the switch is the `include`, not an environment variable. `-p optional-platforms ci` runs on every PR and `integrationCheck` certifies the operation ledger against real PostgreSQL. |
| WebSocket transport | — (build-level) | yes | **no** | — | Qualification-only edge in `app-bootstrap`; `ConditionalTransportBuildContractTest` asserts it has no production edge. |
## Reading the "no" rows
A **no** in WIRED is not a defect. It is the review's Build Composition principle working: the
repository holds more capabilities than any one derived service should ship, and a capability that
is absent from the artifact holds no beans, no connections and no threads whatever its configuration
says. The three **no** rows are the ones where that choice has been made and is enforced by a test.
The rows that say **yes** are the ones where the choice is still "ship it and switch it off", which
is a weaker guarantee — correct, but it depends on the switch being honest rather than on the code
being absent. Moving more rows to **no** is what `app-bootstrap`'s composition-ownership work is for.
## Keeping this honest
`CapabilityStatusDocumentTest` derives the switch list from `MasterSwitch` and fails when a switch
has no row here. That is deliberately the only automated check: a table of facts that a parser
re-derives would be a second source of truth, and the columns above are judgements about evidence,
which is exactly the thing the review says a build must not pretend to compute.
+2
View File
@@ -27,6 +27,8 @@
fields:
- field: enabled
env: APP_HTTPCLIENT_ENABLED
- field: rotation-drain-timeout
env: APP_HTTPCLIENT_ROTATION_DRAIN_TIMEOUT
- field: clients[N].name
env: APP_HTTPCLIENT_CLIENTS_N_NAME
- field: clients[N].mode
@@ -150,7 +150,6 @@ dev.caskeleton.adapter.outbound.notification.slack.webhook.SlackWebhookProvider
dev.caskeleton.application.notification.ApplyNotificationReceiptCommand
dev.caskeleton.application.notification.ApplyNotificationReceiptResult
dev.caskeleton.application.notification.ApplyNotificationReceiptUseCase
dev.caskeleton.application.notification.Channel
dev.caskeleton.application.notification.ConsentCheckMode
dev.caskeleton.application.notification.EmailRecipientReference
dev.caskeleton.application.notification.InitializeNotificationWriterFencesCommand
+14
View File
@@ -3436,6 +3436,20 @@ env_keys:
compatibility_impact: additive
required_test: httpclient-platform:off-state-zero-side-effects-and-env-manifest-parity
- name: APP_HTTPCLIENT_ROTATION_DRAIN_TIMEOUT
# How long a retired runtime generation may keep draining after a certificate rotation before
# its connection pool is closed underneath whatever is still in flight. Rotation replaces a
# generation rather than mutating material in place, because a pool holds sockets established
# under the previous identity; this value is how long the old identity is allowed to finish.
type: duration
default: 30s
classification: public-config
required: false
reload_policy: restart-only
owner_branch: httpclient-platform-activation-boundary
compatibility_impact: additive
required_test: httpclient-platform:off-state-zero-side-effects-and-env-manifest-parity
# === Fileserver HTTP platform (app.fileserver-platform.*) ===
#
# A different capability from the app.fileserver R2 publication block above. Separate
@@ -0,0 +1,739 @@
# Techlead review application — 2026-09-23 closure
## Authority and scope
Applies `docs/reviews/2026-09-18-techlead-review/` (`00-overview.md` §0-A "우선순위 교정" order) to the
working tree at `9da00eb7`. The overview's own ordering is followed: restore the red gates, then the
named blockers, then leaf findings. Where an area document's `0-B` revalidation disagrees with the
current tree, the tree was re-measured and the tree wins — several `0-B` observations were already
stale by the time this pass ran.
Commit policy is unchanged: nothing here is staged, committed or pushed.
## 1. Environment defect found before any review work could run
Every Gradle invocation failed at `:build-logic:compileJava` with
`Unable to delete directory .../build-logic/build/classes/java/main`. 22,677 paths under the
repository — including 95 source files and every leaf's `build/` tree — were owned by `root`,
written by a Gradle daemon running outside this account. No verification of any kind was possible,
so ownership was normalised to the repository account before the review pass began. Root can still
write everything it could before; nothing else changed.
## 2. The red gates the review named are green
`00-overview.md` §0-A lists five failures across three tasks. Re-run against the current tree:
./gradlew verifyCleanArchitectureDependencies \
:adapter:outbound:persistence-jpa:test \
:app-bootstrap:test \
:app-bootstrap:architectureTest --continue
# BUILD SUCCESSFUL in 2m 44s
- `JpaModuleBoundaryTest` no longer requires the empty `auditing` package; the catalog and the tree
agree.
- The Redis composition test no longer reaches a live server: the ACL probe is supplied as a
composition-only bean.
- `UNAUTHENTICATED`, `INVALID_TOKEN` and `FORBIDDEN` each appear in a runbook's `error_codes`
frontmatter.
- `PersistenceJpaLeafReadyAutoConfiguration` no longer exists; the root names no leaf-internal type.
Those four are recorded closed on evidence, not on the `0-B` text.
## 3. Findings closed in this pass
### 3.1 gRPC operation-ledger integration lane had no CI caller (11 §0-B, 13 §0-B, overview §0.2 P0)
`grpc-operation-ledger-jpa` declared a Testcontainers PostgreSQL `integrationTest` that certifies the
atomic `INSERT ... ON CONFLICT DO NOTHING` claim durable idempotency rests on, and nothing ran it:
`-p optional-platforms ci` reaches `checkAll`, `qualityCheck` and the dependency verifier, none of
which runs a lane whose category is INTEGRATION.
- `optional-platforms/build.gradle` gains an `integrationCheck` aggregate over every leaf's
`integrationTestLaneCheck`. `--dry-run` confirms it reaches
`:grpc:grpc-operation-ledger-jpa:integrationTest`.
- `integration-main.yml` gains a `grpc-optional-platform-integration` job that executes it. Stage 2,
because the lane starts a container.
- `DeveloperExperienceContractTest.everyOptionalPlatformIntegrationLaneHasAnExecutingWorkflowCaller`
pins both halves so the lane cannot become an orphan again.
RED at `HEAD`: `git show HEAD:src/optional-platforms/build.gradle | grep -c integrationCheck` = 0,
and `integration-main.yml` named `optional-platforms` 0 times. GREEN after the change.
### 3.2 A build-time source scanner moved back to its owner (13 §0.2 P1)
`build-tools/jpa/SetConfigParameterBindingVerifier` scanned Java source text for
`set_config('...')` without a `?`. The contract is right and the placement was not: it needs no
dependency resolution and no task graph, and the review's Phase 6 target is a smaller `build-tools`.
- Deleted `SetConfigParameterBindingVerifier`, `SetConfigParameterBindingResult`,
`VerifySetConfigParameterBindingTask`, their functional test, the `JpaEvidencePlugin` registration
and the `check` hook.
- Added `persistence-jpa`'s own `SetConfigParameterBindingTest`, which asserts the same invariant and
additionally asserts that the scan reaches a non-empty tree containing at least one subject — a
source scan that walks nothing otherwise passes for the wrong reason.
- `config/jpa/readiness-cards.yaml` no longer names the deleted task.
`build-tools` shrinks by 4 files. `-p build-tools test` and `:adapter:outbound:persistence-jpa:check`
are green.
### 3.3 `:adapter:outbound:persistence-jpa:check` was red at HEAD
Two defects the previous commit left behind, neither of which `:test` alone could see:
- `verifyJpaApiSurface` failed: the `auditing` capability's three public types were deleted without
recording the adopter API-surface change. Recorded through the sanctioned
`updateJpaApiSurface -PapproveJpaApiSurfaceChange` path.
- `PersistenceEntityScanCoverageTest` failed: `PersistenceJpaConfig` still listed
`...persistence.auditing` in both `@EntityScan` and `@EnableJpaRepositories`. "A scan for a package
that no longer exists is a scan of nothing" — the entries are gone.
- A Checkstyle violation (`invalidBase64` as a catch parameter) in
`AdminOperationResultPayloadCodec`.
### 3.4 `verifyNotificationApiSurface` was red at HEAD
`dev.caskeleton.application.notification.Channel` was deleted from `application-core` in the previous
commit — the type now lives at `...notification.platform.api.routing.Channel` in
`application-notification` — and the snapshot was not updated. Recorded through
`updateNotificationApiSurface -PapproveNotificationApiChange`; no source still names the old type.
### 3.5 Redis pub/sub decoded with the wrong codec on three of six surfaces (07 M13)
The blocking channel subscription fixed "one codec per channel" and left the three others on
`first.messageCodec()`, so the same two-channel subscription was correct through
`RedisPubSubOperations` and silently reinterpreted the second channel's payload under the first
channel's schema through the reactive and sharded ones — whenever the framings happened to be
compatible.
- `LettuceRedisShardedPubSubOperations`, `LettuceReactiveRedisPubSubOperations` and
`LettuceReactiveRedisShardedPubSubOperations` now build a channel→codec map and refuse a channel
they never subscribed to.
- `SubscriptionFlux.createPerChannel` carries the per-channel rule into the reactive bridge.
- The reactive pattern subscription now refuses mixed codecs, which the blocking one already did; the
shared rule lives in `PubSubCodecs` so it cannot be fixed one implementation at a time again.
### 3.6 One event-loop group per Redis account (07 M9)
`RedisTopologyClientFactory.resources()` was called once per credential role, so an application +
advanced + pub/sub deployment built three `DefaultClientResources` — `max(2, cores)` IO threads, a
computation pool and a timer each. On an eight-core pod that is twenty-four IO threads to talk to one
Redis. The accounts differ in who they authenticate as, which is a property of the connection.
One `SharedClientResources` is now built per `create()` and handed to every client; a hold count
stops the loops exactly once, after the last client releases, and a build that fails before any
client takes a hold still stops them.
### 3.7 `spring-kafka` declared and never imported (10 M9)
`messaging-kafka/build.gradle` declared `org.springframework.kafka:spring-kafka` and no source in the
repository imports `org.springframework.kafka` outside two forbidden-type catalogs. Removed, and the
four affected lockfiles regenerated.
### 3.8 The shipped composition could not enable the outbox at all
Found by running `:app-bootstrap:systemTest`, not by reading. After the broker starter split made the
core messaging starter broker-neutral, three rules combined into a contradiction:
- `CapabilityDependencyValidator`: outbox on ⇒ messaging on.
- `MessagingProviderSelection`: messaging on ⇒ a broker id, and its client library present.
- The shipped composition deliberately ships neither broker starter.
So the outbox had no reachable configuration, and selecting a broker produced Spring reporting a
missing `.class` file rather than a missing capability. Three changes:
- `MessagingProviderSelection` now checks the provider *configuration* as well as the client library,
and names the starter the deployment did not compose. The client library and the broker starter are
two different build decisions and a deployment can hold the first transitively.
- The outbox↔messaging rule is scoped to the *relay*. An outbox with the relay off writes rows and
publishes nothing, which is the configuration an operator uses to park events until a transport
exists — exactly what `OutboxRelayBrokerRequirementValidator` documents as one of the two coherent
states.
- `BootstrapCapabilityReachabilitySystemTest` stops hand-registering no-op Kafka seams to assert a
composition this artifact cannot produce, and gains
`shippedCompositionRefusesABrokerItDidNotCompose`, which asks the build-composition question of the
artifact rather than of a build file.
### 3.9 GraphQL single-flight had a real race (found by a failing test, not by the review)
`BoundedPreparsedDocumentProviderTest.concurrentMissesOnOneKeyParseOnce` was red at HEAD.
`getDocument` looked the key up, then claimed it in `inFlight` — and between those two steps the
previous leader could finish parsing, store the document and release its slot, at which point the
late thread's `putIfAbsent` succeeded and it parsed a document that was already cached. The class
documents single-flight as a guarantee; the leader now re-reads the cache after taking the claim.
### 3.10 HTTP client runtime certificate rotation had no entry point (08 L6)
`TlsRuntimeRotationCoordinator` and the generation drain it drives were fully implemented and
published by nothing, so a renewed client certificate could only be picked up by a restart while the
leaf's documentation claimed runtime generations as a responsibility.
- `ClientRuntimeFactory` is now a published bean that dispatches on the profile's API type, and the
registry builds its initial generation through it — a replacement generation built differently from
the one it replaces is not the same client with new material.
- `TlsRuntimeRotationCoordinator` is published, `@ConditionalOnMissingBean`.
- The drain budget is configuration rather than a constant:
`app.httpclient.rotation-drain-timeout`, registered in `docs/registries/env-keys.yaml`,
`src/.env.example`, `config/httpclient.yml` and `docs/httpclient/env-fields.yaml`.
### 3.11 Redis SDK Low findings (07 L3, L4, L5)
- **L3.** `ValueOperationRequests.decodeAll` clamped the key index to `keys.size() - 1`, so an MGET
reply of a different length than the request decoded every extra value with the last key's codec
and attributed it to that key. MGET replies positionally; a length mismatch means the positions no
longer line up, and it is now an error rather than a silent reinterpretation.
- **L4.** `SearchQuery.expression` reached `FT.SEARCH` unchecked. RESP argument framing is
length-prefixed, so the expression cannot become another command however it is spelled — but it
could still be unbounded or carry control characters. Both are rejected where the value is
constructed.
- **L5.** `Duration.ofNanos(Duration.ofMillis(v).toNanos() / 1_000L)` computed the right value and
read like a defect. SLOWLOG reports microseconds, so it now says so.
### 3.12 Notification Low findings (09 L6, L9)
- **L6.** `adapter:outbound:fileserver`'s guidance forbids fully-qualified inline type references and
this leaf's did not, so the same construct was a defect in one capability and ordinary style in the
next; the platform auto-configurations had accumulated twenty-two. They are now imports, and the
rule is written into `adapter/outbound/notification/CLAUDE.md` so the inconsistency cannot return.
- **L9.** The move from the composition root into the leaf dropped the assertion that every
`@Import`ed type is itself a configuration class. `@Import` accepts any class: one carrying neither
`@Configuration` nor `@AutoConfiguration` is imported as a plain bean, its `@Bean` methods are never
read, and the capability is simply absent with nothing failing. Restored.
### 3.13 Governance plugins are no longer applied to every Java leaf (13 §0-B, Phase 6)
`JavaConventionsPlugin` applied five special plugins to all 71 Java leaves. Three of them governed
nothing there: `ca.api-surface` is configured by three leaves, `ca.dependency-policy` by two and
`ca.strict-qualification` by nine, so the other leaves carried an extension apiece and a
`verifyDependencyPolicy` task that checked an empty policy. Those three are now declared by the
leaves that use them.
`ca.strict-test-lane` and `ca.test-jvm-agents` stay global, and the reason is written into the
plugin: the first supplies the per-leaf `*TestLaneCheck` aggregates that the root's repository-wide
tasks depend on **by task path**, so a leaf without them breaks the root task graph rather than
losing a check; the second attaches the Mockito startup agent to every `Test` task, and a leaf that
quietly lost it would self-attach instead.
Measured the way `13-build-dependency-ci.md` §0-B measures it — `src/main` only — `build-tools` went
from 102 files / 6,152 lines to 99 / 6,048, and `build-logic` from 82 / 5,671 to 82 / 5,678 (the
seven lines are the comment above). That is the first movement in the intended direction; the
review's point was that `build-tools` had been *growing* during the simplification phase. It is not
the reduction Phase 6 asks for, which is why §4 still lists it as open.
### 3.14 Build/dependency/CI Low findings (13 L1-L8)
- **L1.** `docker-compose.yml` still carried the healthcheck warning that `src/Dockerfile` had
already removed, and removed for a stated reason: "a stale warning about a healthcheck is the kind
of comment that gets a real red container ignored." One copy had been fixed; both are now.
- **L2.** `.github/CODEOWNERS` assigned an owner to `/flaky-quarantine.yaml`, deleted in `ef947e5b`.
- **L3.** `optional-platforms` did not apply `ca.release-provenance`, so every gRPC leaf's jar was
versioned `0.0.1-SNAPSHOT` while main-build jars carry `<version>+<sha>`: one commit, two artifact
sets, one of them untraceable. The root now applies it.
- **L4.** `src/Dockerfile`'s dependency-resolution stage did not copy `gradle.properties`, so it ran
`verifyDependencyLocks` without the repository's memory, worker and caching settings.
- **L5.** The root `verifyDependencyLocks` aggregate excludes `:sample-portfolio` — correctly, since
the sample is outside production architecture and runtime-membership policy — and nothing else
verified its lock state, which had changed by hundreds of lines. Its own `check`, which CI runs as
a PR gate, now verifies it.
- **L6.** `src/README.md` named `src/.env` as the public-path SSOT; `PublicPathSnapshotPlugin` reads
`app-bootstrap/src/main/resources/config/security.yml`. The config split moved the file and the
documentation stayed.
- **L7.** `src/README.md` listed "Spotless, Checkstyle, Error Prone" without saying that Checkstyle's
scope here is naming plus a handful of logical rules, deliberately excluding everything the
formatter owns. The division of labour is now written where the list is.
- **L8.** `application.acl`, `application-advanced.acl`, `raw-gateway.acl` and `admin-readonly.acl`
still declared `nopass` long after `all-accounts.acl` — the file a deployment actually loads — had
been given fixture passwords, and `acl/README.md` claimed "none of these files carries one" while
its neighbour carried eight. The per-role files now carry the same fixture credentials and the
README says what they are and why they are written down.
### 3.15 Object storage L10
`S3SdkApiCharacterizationTest` defined a private helper named `assertThatCode`, which is also an
AssertJ entry point, so `allSatisfy(builder -> assertThatCode(...))` read like an assertion while
building no assertion object at all. Renamed to `requireSdkMethod`, which is what it does.
### 3.16 The review's central structural gap, narrowed (overview §4)
The overview's single deepest finding is that Spring Boot needs two independent things before an
auto-configuration runs — the annotation on the class, and a line naming it in
`META-INF/spring/...AutoConfiguration.imports` — and that this repository tested the first
exhaustively and the second in three leaves out of eleven. Every assembly defect the review found
was in the other eight, and the mechanism is the same each time: a test that builds a context with
`AutoConfigurations.of(...)` supplies the registration itself, so it stays green for a capability
present in no running application.
Six of the twelve leaves that ship a registration file now had a test reading it. The other six —
`adapter:inbound:web`, `adapter:outbound:httpclient`, `adapter:outbound:messaging`,
`adapter:outbound:messaging-kafka`, `adapter:outbound:redis-runtime` and
`messaging:messaging-spring-boot-starter` — now do too. Each asserts both directions: every root the
leaf means to publish is named in the file it ships, and every name in that file resolves to a class
carrying `@AutoConfiguration`.
The file is read from the leaf's own source tree rather than from the classpath. The first draft
aggregated every `AutoConfiguration.imports` the class loader could see, which immediately failed on
springdoc's `SpringDocWebMvcConfiguration` and on a Boot health class the messaging bridge's test
runtime does not carry — it was testing other people's modules. Falsifiability was checked by adding
one non-auto-configuration line to the HTTP client's file: the test fails, and the file is byte-identical
to `HEAD` afterwards.
That closes the mechanism for every leaf that publishes a registration file. It does not close the
review's wider point — that 16 of 1,899 test files start the real composition root — which is what
the composition contracts in §3.8 and the Phase 2 work in §4 are about.
### 3.17 The sample's idempotency regression (carried in the master's residual queue)
`SampleApplicationContextTest` was red for a reason the master recorded as a separate follow-up:
`SampleIdempotencyConfig.idempotencyExecutor` requires an `IdempotencyStorePort` and the only
implementation this composition can produce, `IdempotencyStoreAdapter`, is
`@ConditionalOnProperty(ca-skeleton.capabilities.idempotency.provider=jdbc)` — a key the sample never
set. The sample ships `persistence-jpa` and runs the production migration timeline, which owns
`idempotency_record`, so the provider is declared rather than the executor made optional: a sample
that demonstrates idempotency with no store is a worse reference than one that names its provider.
### 3.18 Two auxiliary source sets did not compile at HEAD
Neither is reachable from a leaf's `check`, which is why both survived: `check` compiles `main`,
`test` and `testFixtures`, and these lanes are compiled by `qualificationCheck`'s
`auxiliaryStyleCheck`, which only `ci` reaches.
- `messaging-outbox-jdbc-postgresql`'s `OutboxPostgresIT` called `markAmbiguous(MessageId, ...)`, an
overload that no longer exists — a terminal write is now checked against the lease token, so the
method takes the lease that owns the row. The test claims through `claimBatch` and marks through
the returned lease. This lane is invoked by `integration-main.yml`, so it was a red CI job that no
local `check` could show.
- `httpclient`'s `Http2StreamSaturationTest` passed a fourth argument to
`ReactorHttpClientFactory.create`, which takes three.
The same leaf's `testFixturesRuntimeClasspath` lock state was stale in the same way — seven Jetty
coordinates the configuration no longer resolves — so `verifyDependencyLocks`, which only the root
aggregate runs, was red at HEAD too. Regenerated. The optional gRPC build's Spotless check was red
for the same structural reason: `./gradlew spotlessApply` in the main build does not reach an
included build, so `-p optional-platforms` needed its own pass.
### 3.19 The four commit-inclusion findings are now verifiable, and they hold
`inbound-web C3`, `persistence-mongo H6`, `bootstrap/sample H5` and `build/CI H9` were open only
because the earlier sessions could not stage or commit, so "the moved trees are in the snapshot CI
consumes" could not be certified. `9da00eb7` committed them, so the question is answerable now:
git ls-files src/adapter/outbound/httpclient/src/main/resources/META-INF # 1
git ls-files src/adapter/outbound/notification/src/main/resources/META-INF # 1
git ls-files src/adapter/outbound/persistence-jpa/src/main/resources/META-INF # 1
git ls-files src/adapter/inbound/web/src/systemTest # 7
git ls-files src/app-bootstrap/src/integrationTest # 5
git ls-files src/sample-portfolio/src/systemTest # 2
The three `.imports` files are the ones H5 named as the dangerous half: a missing source set fails a
`strictTestLanes requires(...)` loudly, while a missing registration file leaves the class present
and the capability unassembled with nothing failing. All three are tracked. The registration tests
added in §3.16 now also make their absence a red test rather than a silent omission.
### 3.20 Three optional capabilities lowered to `runtimeOnly` (overview §2.3)
The review asks, once leaf ownership is settled, whether a capability the composition root does not
import can drop to `runtimeOnly` — while saying `runtimeOnly` is not itself the goal. Measuring the
root's own sources answers it for three of them today:
app-bootstrap/src/main imports from persistence-mongo 0
app-bootstrap/src/main imports from httpclient 0
app-bootstrap/src/main imports from inbound:graphql 0
All three are now `runtimeOnly`. Nothing about the artifact changes — they still ship, and their
master switches still decide activation — but "the composition root has no compile-time business
with this capability" stops being a habit and becomes something the compiler keeps. It also makes
the set of capabilities a fork can drop by deleting one line visible in the build file, which is the
state the remaining nine packages have to reach.
The four tests that name those leaves' types (the import filters, the deployment-mode enum, the HTTP
client settings) declare them as `testImplementation` rather than widening the main scope back, with
the Mongo reactive exclusions repeated because `MongoShippedCompositionContractTest` asserts the
shape of the classpath it runs on.
For comparison, the capabilities that cannot move yet, and by how much:
`fileserver` 38 imports, `inbound:web` 29, `cache`/`redis` 25, `persistence` 13, `notification` 7,
`support` 3, `messaging` 3, `identifier` 2.
### 3.21 The gRPC diagnostics redactor was not idempotent
Surfaced only once the optional build's Spotless check stopped failing first — `-p optional-platforms
ci` runs without `--continue`, so one red task hid the next.
`GrpcChannelDiagnosticsSnapshot` decides whether a peer address is masked by masking it and
comparing, because a masked address carries no marker to look for. That is the only test available
to it, and it works only if masking is idempotent. It was not: `maskAddress("10.4.x.x")` finds no
four numeric octets, falls through to the hash branch, and returns `masked:<digest>` — so a snapshot
assembled from correctly masked addresses was rejected as unmasked and the diagnostics endpoint
could not publish one. `maskAddress` now returns an already-masked value unchanged, and
`GrpcDiagnosticsRedactorIdempotenceTest` pins the property next to the function that has to hold it,
including the case of a value that merely ends in the mask's suffix.
### 3.22 Smaller corrections
- `AdapterActivationReportShapeTest` set `ca-skeleton.lock.multi-instance-enabled`, a key no
production code reads (the real one is `ca-skeleton.runtime.*`). The "widest possible shape" was
therefore missing that consumer.
- `integration-main.yml` no longer states a compose lane count in prose; the matrix file is what the
job reads, and the declared lanes have grown past the number the comment carried.
## 3-B. What the first pass left open
Written as a second section rather than folded above, because the first pass reported these as open
and the record should show what changed rather than quietly reading as if they never were. It
started at six; §3-B.7 is the seventh, which the first pass had put in §4 as blocked.
### 3-B.1 Build/CI M6 — `org.gradle.parallel=true` is on
The flag had been tried and reverted: three root tasks reached into other projects and resolved
their configurations, which Gradle refuses once project execution is parallel —
"Resolution of the configuration ':application-core:runtimeClasspath' was attempted without an
exclusive lock". The fix the review names is to make the verification project-owned, and that is
what happened:
- `verifyCleanArchitectureDependencies` keeps the two repository-wide questions — is the registry
self-consistent, and does the set of governed modules match the set of declared leaves — and
depends on one `verifyModuleDependencyDirection` per module, registered in the module.
- `verifyApplicationCoreDependencyPurity` became one `verifyModuleDependencyPurity` per
`application-*` module, in that module.
- `verifyRuntimeModuleRegistry` became one `verifyCompositionRuntimeMembership` per composition
root, in that root.
`architectureCheck` and the full `ci` pass with the flag on. What the move also did — and this was
not the goal — is close most of the configuration-cache half of M6; §3-B.7 records that, because the
reason it was open turned out not to be the reason the review gives.
Turning the flag on then found something the review could not have: `adapter:inbound:web`'s
real-server lanes fail together and pass alone. Three of them start an embedded Tomcat, Jetty or
Reactor Netty and assert on timing — a permit released at the wrong moment, a capacity refusal that
has to arrive inside a five-second read timeout — and running them concurrently makes the machine,
not the code, decide. `ReactiveWebThrottleIT` failed three tests on socket timeouts and passed on
its own.
Ordering them inside `adapter:inbound:web` was tried first and was not enough: the next run failed
`ReactiveWebThrottleIT` again and added `TomcatWebSocketAbuseIT`, because the contention is across
leaves rather than within one. So the lanes share one slot build-wide —
`ExclusiveRealServerLaneService`, a Gradle build service with `maxParallelUsages = 1`, attached by
`StrictTestLanePlugin` to every strict lane whose category is not `TEST`. That is precisely the set
that starts a server or a container; the hermetic unit lanes, which are the bulk of the build and
the whole reason to run in parallel, are untouched.
The exclusive slot was necessary and not sufficient, and the next full run said so: with every
real-server lane taking turns among themselves, `webFluxContractTest` still failed twice —
`ReactiveContractRecordingIT`'s `unsupported-media-415` probe and `ReactiveWebThrottleIT`'s capacity
refusal, both `SocketTimeoutException` — while SpotBugs was analysing a dozen leaves. The contention
is not lane-against-lane at all. It is lane-against-the-whole-build, and no build service can
express that, because the thing the lane needs is the machine.
So the second half of the fix is in the fixtures rather than the build. Every socket budget in the
web testkit was a small number chosen for an idle machine — five-second connects, ten-second reads —
and none of those suites asserts latency. They assert the status, headers, problem code and body
that came back. A timeout below the worst scheduling delay of a loaded host is therefore not a
safety net; it is a second, invisible assertion about how busy the host is, and it is the one that
failed. `HttpFixtureTimeouts` now holds one connect and one read budget for all six fixtures, with
the reason written where the number is rather than in six places. Two suites keep their own numbers
and say why: the fault lanes, where the client read budget *is* the contract, and the performance
lanes, where the measurement is the point.
This is the cost the review's own K7 argument predicts — "a measurement on a shared CI runner
wobbles, and a wobbling gate gets switched off" — met by taking turns and by removing the hidden
latency assertion, rather than by switching anything off. It is also the one part of M6 the review
could not have known about, because the flag had never stayed on long enough to find it.
### 3-B.2 HTTP-client L5 — the HTTP/2 promotion is reachable
`Http2EvidenceMapper` knew how to turn a refused stream into "the peer did not process this", and
`BlockingAttemptExecutor` passed `ProtocolEvidence.none()` at every call, so the promotion existed
only in five unit tests. A `ProtocolEvidenceReader` seam now sits between the engine and the
classifier, and `ApacheHttp2EvidenceReader` walks the cause chain for HC5's
`H2StreamResetException`.
Only `REFUSED_STREAM` is reported, and the limit is the finding's other half. RFC 9113 §8.7 makes
that code a fact about non-processing; GOAWAY needs the frame's last-stream-id compared against the
attempt's stream id, and HC5 surfaces neither. Reporting GOAWAY without them would mean treating
every connection that went away as proof the request was never processed — and the requests that
*had* been processed are exactly the ones a false NOT_SENT would duplicate. The reader says nothing
there, which leaves the ordinary classification in place.
### 3-B.3 Phase 7 — the launcher and the capability status
- `./gradlew bootstrap` takes `-PbootstrapProfile=<name>` and selects the compose overlay by it,
defaulting to `local`. A profile naming no overlay is refused with the list read off the
directory. No `scripts/run` wrapper: the ordered four-stage lifecycle already lives in the plugin,
and a shell copy would either duplicate it or drift from it.
- `docs/capability-status.md` separates IMPLEMENTED, WIRED and QUALIFIED per capability and names
what decides each column — the registry, the registration file plus the composition edge, and a
real-provider lane **plus the workflow that runs it**. `CapabilityStatusDocumentTest` fails when a
`MasterSwitch` has no row, which is how the document stays complete; it deliberately does not
re-derive the cells, because those are judgements about evidence and a parser that computed them
would be the very thing the review says to stop adding. Writing it immediately found a capability
nobody had classified: `APP_FILESERVER_ENABLED`, the R2 publication block, distinct from the
fileserver platform switch.
- The compose gaps the review measured were already closed by earlier work and are recorded as such:
18 declared lanes, redis/fileserver/httpclient present, a redis service in
`docker-compose.infra.yml`, static contract on PRs and the dynamic matrix on main/nightly.
### 3-B.4 Phase 6 — more verification moved out of `build-tools`
`verifyOperationalErrorRegistry` compared `OperationalError` with `docs/registries/error-codes.yaml`
using a hand-written YAML line scanner inside an included build. It needs no dependency resolution
and no task graph, so it is `OperationalErrorRegistryContractTest` in `app-bootstrap` now — reading
the registry with a real parser, which the scanner's line-prefix matching could not do. `build-tools`
is 98 files / 5,880 lines, from 102 / 6,152 at the review's own measurement.
What remains is the JPA evidence platform (47 files, 2,830 lines) and the notification/messaging/mongo
evidence verifiers. Those are **not** moved, and deliberately: each is invoked by a release or
qualification workflow (`jpa-release.yml`, `jpa-r2-evidence.yml`, `ci-quality-gates.yml`,
`messaging-certification.yml`, `notification-platform.yml`), so deleting them removes release gates.
The review's K5 says `build-tools` may remain physically; what it asks is that verification needing
no build move out, and that is the rule being applied one verifier at a time rather than by
deleting a platform with live callers.
### 3-B.5 Phase 2 — the Redis and Fileserver capabilities now own their own assembly
The prerequisite turned out not to be a startup-SPI extraction. `12-bootstrap-sample.md` §3.4 already
names the answer and marks it Keep: `adapter/outbound/support`'s
`CapabilityStartupValidationException` lets a leaf fail closed without depending on app-bootstrap,
and `StartupFailureExceptionReporter` recognises it and emits the repository's standard
`STARTUP_VALIDATION_FAILED` log. All fourteen bootstrap-coupled call sites in the Redis package were
`StartupFailures.envValidation(...)` — a configuration error, which is exactly what that exception
is.
So eight of the ten classes moved to `adapter:outbound:cache-redis`, which already allowed the
support edge in the registry: the capability root, the cache/rate-limit/lease/idempotency wiring, the
key policy, the settings and the ACL probe. The leaf ships its own
`AutoConfiguration.imports` and its own registration test; `app-bootstrap`'s no longer names it.
Two stayed, and not for want of trying: `RedisReadinessGroupPostProcessor` appends to the
application-wide readiness group and `RedisActivationValidator` reads the bootstrap-owned secret
policy. Both are cross-capability by the review's own ownership rule — "application-wide common
infrastructure → bootstrap" — so moving them would have been the wrong direction, not progress.
`CaSkeletonApplication` needed two changes, and both were demanded by a test rather than guessed:
- the scan exclusion gained the new package — the parity test failed with the four imported children
by name;
- `@ConfigurationPropertiesScan` was narrowed from `dev.caskeleton.adapter.outbound.cache.redis` to
`...cache.redis.sdk`. The wider base package now contained `RedisCapabilitySettings`, so the
properties scan bound it while every switch was off — the exact thing the off-state contract
forbids, caught by the shipped-composition test naming the bean.
The move also exposed an older fragility that had nothing to do with Redis:
`PersistenceJpaAutoConfigurationTest` read its registration file through
`getResourceAsStream`, which answers with the first match on the classpath. It had been correct only
because no other leaf on that classpath shipped one; the moment `cache-redis` did, it read someone
else's file. It reads its own file now, the way the registration tests added in §3.16 do.
**Fileserver.** The first pass called this one blocked on a design decision — a new starter leaf,
because the assembly's imports span `adapter:outbound:fileserver`, `adapter:inbound:web` and
`application-fileserver`. That reading was wrong, and the way it was wrong is the useful part: the
28 classes were not one assembly with three owners. They were two assemblies that had been merged
into one package, and the merge was what made the ownership look undecidable.
Splitting on the actual question — *does this class need anything outside the fileserver leaf?* —
divides them cleanly:
- **13 moved** to `adapter:outbound:fileserver`, under `platform/autoconfigure`: the settings and
their binder, the startup check and validator, and the storage-gateway, storage-operations,
verification, security, download-lifecycle, maintenance and observability wiring. A new
`FileserverCapabilityAutoConfiguration` is the leaf's root — the master switch, the settings bean,
and `@Import` of the seven — and the leaf ships its own `AutoConfiguration.imports` and its own
registration test.
- **13 stayed** in `app-bootstrap`, and each for a named reason rather than inertia. Nine are the
HTTP surface — core policy, web assembly, HTTP download, nginx delegation, protocol, the admin
plane and its management context, and the startup configuration that composes the whole platform —
which is `adapter:inbound:web`'s business and belongs to the composition root by the review's own
ownership rule. Four are cross-adapter and were moved *back* after they failed to compile in the
leaf: `FileserverLocalStorageCoreConfiguration` needs
`adapter:outbound:persistence-fileserver` and spring-jdbc, `FileserverUploadServiceConfiguration`
needs `adapter:outbound:identifier`, and `FileserverCleanupConfiguration` with its worker needs
logstash's `kv(...)` encoder. A leaf that reaches a sibling adapter is the composition root's job
by definition.
- **2 were deleted.** `FileserverStorageConfiguration` and `FileserverServiceConfiguration` were
pure `@Import` aggregators, and each aggregated across that split — leaf-internal wiring in the
same list as a sibling-adapter dependency. Keeping them would have meant an aggregator that has to
live in bootstrap in order to name classes that live in the leaf, which is the coupling the move
is for. The imports they held are now on the two roots that can actually own them.
The leaf gained one registry edge, `adapter-outbound-support`, for the same reason Redis already had
it: `FileserverStartupViolations` collects every violation and throws
`CapabilityStartupValidationException`, so the leaf fails closed with the repository's standard
`STARTUP_VALIDATION_FAILED` report and without depending on `app-bootstrap`. `modules.json`, the
leaf's `build.gradle` and its `gradle.lockfile` were updated together.
`CaSkeletonApplication` needed the same two changes as Redis, and again a test named them: the scan
exclusion gained `...fileserver.platform.autoconfigure.*`, and
`dev.caskeleton.bootstrap.autoconfigure.fileserver` came out of `@ConfigurationPropertiesScan`
because the moved `FileserverPlatformSettings` is now bound by the leaf's own root.
### 3-B.6 Object Storage M7 — the claim is closed, the qualification is not
The AWS lane's two tests were called `...QualificationTest` and asserted that four environment
variables were set. Nothing in them touches S3, builds this leaf's provider or moves a byte, so a
green run meant "somebody exported the right variables" while the name said "the AWS provider is
qualified". They are `AwsS3QualificationPreconditionsTest` and
`AwsS3DirectMutationPreconditionsTest` now, with the distinction written into the class.
The qualification itself stays open and cannot be closed here: it needs credentials and an
authorised sandbox, and manufacturing evidence for it is the one thing worse than not having it.
What is closable is the claim — `AwsQualificationClaimHonestyTest` fails if any card in
`docs/registries/object-storage-readiness.yaml` names an AWS provider while the preconditions lane
is the only AWS evidence there is. Today no card does, so the registry is honest; the test is what
has to be deleted before anyone can make it dishonest.
### 3-B.7 Build/CI M6, the other half — the configuration cache
M6 names five call sites as what blocks the configuration cache —
`notCompatibleWithConfigurationCache` in `JavaConventionsPlugin`, `getTaskGraph().whenReady` and
`addTestListener` in `StrictTestLanePlugin`, and `projectsEvaluated` in `ArchiveHygienePlugin`,
`ArchitecturePlugin` and `RuntimeMembershipPlugin` — and the first pass repeated that list into
`gradle.properties` and into §4. Repeating it was the mistake: none of it had been measured, and
`./gradlew ci --dry-run --configuration-cache` takes eight seconds.
Measured, four of the five are not problems at all. `projectsEvaluated` and `whenReady` both run
during configuration, which is the phase the cache stores. The `addTestListener` registrations *are*
in the `integrationCheck` graph and still produce nothing: `StrictLaneExecutionTracker` is a plain
class holding two `AtomicLong`s and a set, which is all the cache asks of a listener. The real
blockers were four tasks — three of them written *in this pass*, in §3-B.1, when the root-owned
checks were split into project-owned ones — each holding a live `Configuration` in its task state:
:application-core:verifyModuleDependencyPurity VerifyApplicationCoreDependencyPurityTask
:<module>:verifyModuleDependencyDirection VerifyModuleDependencyDirectionTask
:app-bootstrap:verifyCompositionRuntimeMembership VerifyCompositionRuntimeMembershipTask
:adapter:outbound:{messaging,notification}:verifyDependencyPolicy VerifyDependencyPolicyTask
A `Configuration` cannot be serialised, so storing failed outright rather than degrading — and the
failure is fatal, which is why the first measurement reported one problem and hid the other eight
behind it. All four now take a `Provider<ResolvedComponentResult>` from
`getIncoming().getResolutionResult().getRootComponent()`, the supported carrier, plus the declared
dependencies as strings. The graph is resolved while the owning project is still configuring instead
of at execution time from whichever project happens to run the action, which is the same ownership
correction §3-B.1 made for the parallel flag — the two defects had one cause.
Three smaller things fell out of it. `getAllComponents()` has no equivalent on a root component, so
`ResolvedComponents.reachableFrom` walks the graph with a visited set — not an optimisation, because
a cycle there is an infinite loop rather than a diagnosis. `DependencyPolicyCheck` had to become
public: the cache rebuilds a record through its canonical constructor, and a package-private record
has a package-private one, which surfaced as `NoSuchMethodException` on the *second* run only.
And `VerifyApplicationCoreDependencyPurityTask` called `getProject()` in its action for a log line;
it carries the module path as an input now.
Result, measured rather than argued:
./gradlew ci --dry-run --configuration-cache --configuration-cache-problems=fail # stored, reused
./gradlew integrationCheck --dry-run --configuration-cache --configuration-cache-problems=fail # stored, reused
./gradlew releaseCheck --dry-run --configuration-cache --configuration-cache-problems=fail # stored, reused
./gradlew architectureCheck :adapter:outbound:{messaging,notification}:verifyDependencyPolicy \
--configuration-cache --configuration-cache-problems=fail # executes, reused
The rewrite was checked for having neutered the checks rather than fixed them: emptying
`application-core`'s `allowed_dependencies` in the registry still fails
`:application-core:verifyModuleDependencyDirection` with the forbidden edge named, under the
configuration cache.
One opt-out remains and is deliberate: `ResolveConfigurationsTask` — `verifyDependencyLocks` and
`resolveAndLockAll`. Resolving every configuration at execution time is not an implementation detail
of that task, it *is* the task, because STRICT lock validation happens during resolution; moving it
behind a provider would move lock verification into every build's configuration phase. Since the
pull-request gate runs `:ci` and `:verifyDependencyLocks` in one invocation, the flag is still off
repository-wide — enabling it is a change to how CI is split, not a property, and
`gradle.properties` now says that instead of the five call sites.
What did change is the review's other complaint about this job: `ci-quality-gates.yml`'s
`configuration-cache` job checked two leaves. It now requires all three repository-wide gates to
store *and* reuse, via `--dry-run` — which answers the storability question for the entire task
graph in seconds — and keeps the executing two-leaf check, because `--dry-run` cannot prove that a
reused entry still does the work.
## 4. What remains, and why
One item, and it is blocked on something this session cannot supply rather than on effort.
- **Object Storage AWS qualification.** Needs credentials and an authorised sandbox. The claim is
guarded (§3-B.6) — `AwsQualificationClaimHonestyTest` fails if any readiness card names an AWS
provider while the preconditions lane is the only AWS evidence — but the evidence itself cannot be
manufactured, and manufacturing it is the one outcome worse than not having it.
Two things that earlier drafts of this document listed here are *not* remaining work, and saying why
matters more than the line item:
- **Phase 2's fileserver capability** was called blocked on a new starter leaf. It was not; the
package held two assemblies rather than one, and splitting it on ownership needed no new module
(§3-B.5).
- **Configuration cache** was called blocked on five plugin call sites, copied from the review
without measuring. Four of the five were never problems; the actual blockers were four tasks this
work itself had introduced, and they are fixed (§3-B.7). What is left is one deliberate opt-out on
lock verification, which is a property of what that task does.
Everything else the first pass listed here — Phase 6's governance reduction, Phase 7, Build/CI M6,
HTTP-client L5 — is closed in §3-B.
## 5. Verification
The repository-wide gate had not been run against this tree before this pass; running it is what
found most of §3. Final state:
./gradlew ci verifyDependencyLocks verifyPublicPathSnapshot --continue # exit 0
./gradlew -p optional-platforms ci --continue # exit 0
./gradlew -p build-logic test # exit 0
./gradlew -p build-tools test # exit 0
Zero failing tasks. Run with `org.gradle.parallel=true`, which is itself part of what is being
verified: the same four commands failed eight tasks before the verification moved into the owning
projects, two more after the real-server lanes got their exclusive slot, and none once the web
testkit's socket budgets stopped asserting machine load (§3-B.1).
The configuration cache is verified separately, because it is a property of the task graph rather
than of a run:
./gradlew {ci,integrationCheck,releaseCheck} --dry-run \
--configuration-cache --configuration-cache-problems=fail # each: stored, then reused
Both invocations of each gate pass with problems set to `fail`, so this is not a count of warnings —
it is the absence of any. `verifyDependencyLocks` is outside that set by design (§3-B.7).
`ci` is leaf checks + `architectureCheck` + `qualityCheck` + `configContractCheck` +
`qualificationCheck` + `sampleWebContractCheck`, so it covers SpotBugs/FindSecBugs, the environment
contract, the auxiliary source sets that no leaf `check` compiles, and the app-bootstrap
`systemTest` and `architectureTest` lanes.
Container-backed lanes are not included: `integrationCheck` and the compose runtime matrix are
stage-2 CI jobs by design, and the review's Keep list says so. The one such lane this pass touched —
`messaging-outbox-jdbc-postgresql:integrationTest` — was verified to compile, which is what was
broken; its execution belongs to `integration-main.yml`.
One observation was first recorded here as a flake and turned out not to be one, which is the reason
it is worth keeping in the record. `adapter:inbound:web:webFluxContractTest` failed with a
`SocketTimeoutException` in one full run, passed in the next, and then failed again in a third — two
tests that time, in two different suites. Re-running would have "cleared" it twice. What it actually
was is described in §3-B.1: the web testkit's socket budgets were small enough to expire on a healthy
server under a parallel build, so every one of those suites carried an unstated assertion about
machine load. The three runs are the evidence that a lane starting real servers under contention is
exactly the kind of gate that gets turned off after being mistaken for a defect — and that calling
the first failure a flake was the beginning of doing that.
Falsifiability was checked where a new test could pass vacuously: the registration contract fails
when one non-auto-configuration line is added to a leaf's `.imports` file (and the file is
byte-identical to `HEAD` afterwards), and the gRPC operation-ledger aggregate was confirmed by
`--dry-run` to reach `:grpc:grpc-operation-ledger-jpa:integrationTest`.
Nothing is committed or pushed, and nothing is staged.
That last clause needed correcting rather than stating. The capability moves were made with
`git mv`, which stages, so 31 renames sat in the index — contrary to the repository's `human-only`
commit policy, and put there by this work rather than by anyone. The index is restored to `HEAD`.
Only the index was touched: the working tree's checksum is byte-identical before and after, and no
file was rewritten to achieve it.
Restoring it also makes the review's H5 warning sharper rather than softer, which is the reason to
say so precisely. The tree now stands at 252 modified files, **36 deleted** and **54 untracked**,
and the deletions and the additions are two halves of the same moves:
| Move | Old paths, now deleted | New paths, now untracked |
| --- | --- | --- |
| Redis capability → `cache-redis` | 8 main + 2 test | the same 10, plus a leaf `.imports` and a registration test |
| Fileserver capability → `fileserver` | 13 main + 1 test | 13 main + 2 new roots, plus a leaf `.imports` and 2 tests |
| Object storage qualification rename | 2 | 2 |
| `build-logic`/`build-tools` verification moves | 8 | 4, plus the tests that replaced them |
So `git commit -a` would record every deletion and none of the additions, and the result would
compile against nothing: `RedisCapabilityConfig` would be gone from `app-bootstrap` and absent from
`cache-redis` in the same commit. **`git add -A` is required**, and a `git status` that shows zero
untracked paths afterwards is the check that it worked.
@@ -0,0 +1,272 @@
# App Bootstrap Build Composition — implementation plan
Design authority: the 2026-09-23 "App Bootstrap Build Composition 설계 작업 문서".
Review authority: `docs/reviews/2026-09-18-techlead-review/` §00, §12, §13 and
`docs/reviews/2026-09-23-techlead-review-application-closure.md`.
This plan is the §17 deliverable. It settles the three decisions the design document deliberately
left open — what "selection" *is* mechanically, where the contract is enforced, and what a
composition module is allowed to be — and then splits the work into the task units §17 names. It
does not restate the design.
## 0. Measured baseline
Re-measured on the current tree rather than quoted (design §15 forbids reusing an old log).
The design document's named gate is green:
./gradlew verifyCleanArchitectureDependencies :adapter:outbound:persistence-jpa:test \
:app-bootstrap:test :app-bootstrap:architectureTest --continue # exit 0, 0 FAILED
`:app-bootstrap:runtimeClasspath` resolves **33 project edges**. Every optional capability is among
them, including the three the earlier pass lowered to `runtimeOnly`:
graphql httpclient persistence-mongo <- runtimeOnly, still on the classpath
fileserver notification cache-redis redis-runtime
messaging-spring-boot-starter + 16 further messaging leaves
This is the design document's §2.3 claim, confirmed: `runtimeOnly` moved these off the *compile*
classpath and left them in the artifact. Nothing about the shipped jar changed.
## 1. Decision — selection is a Gradle edge, and the repository already has one
The design document asks for a mechanism without naming one. It does not need a new one: **object
storage is already in the target state**, and `docs/capability-status.md` already documents it that
way — WIRED **no**, "The leaf is not an `app-bootstrap` dependency … A fork that wants it adds the
edge", with `integrationTestImplementation project(':adapter:outbound:objectstorage')` supplying it
to the lane that proves it assembles.
So the work is not to invent Build Composition. It is to move the other capabilities to the shape
one capability already has.
**Selection = the presence of a project dependency in `app-bootstrap/build.gradle`.** Not a Gradle
property, not a feature variant, not a capability DSL. Reasons, in the order design §9 ranks them:
- it is the existing Gradle model, and it is already how object storage works;
- a property would make the shipped artifact depend on how the build was invoked, so two builds of
the same commit could ship different jars — the opposite of what a composition contract is for;
- the thing a fork edits is one line in one file, which is what a template should ask of an adopter.
Rejected alternative, recorded because it is the obvious one: `-PcaCapabilities=fileserver,...`. It
reads well and it is worse — it moves the answer to "does this build ship Fileserver?" out of the
repository and into the invocation, and no test can pin an invocation.
## 2. Decision — the contract is enforced by the verifier that already exists
Design §7.1 requires a RED test proving an unselected capability is absent from
`runtimeClasspath`, and design §9 forbids adding a bespoke verifier for it.
Both are satisfiable at once. `ca.dependency-policy` already resolves a named configuration and
fails on forbidden or missing coordinates (`dependencyPolicy { absent … required … }`,
`VerifyDependencyPolicyTask`, wired into `check`). A project dependency resolves to a real
`ModuleVersionIdentifier` — `dev.caskeleton:<project name>` — so an absence on `runtimeClasspath` is
expressible today, with no new task, no new source set and no string scanning.
// app-bootstrap/build.gradle
dependencyPolicy {
absent 'dev.caskeleton:fileserver',
'Fileserver is an optional capability; the minimal composition does not ship it.'
}
That is the Phase 1 RED: it fails on the current tree, because the edge is there.
Two things this deliberately does **not** replace:
- the Runtime Activation tests. Design §3.1 is the whole point — `absent` answers "is it in the
artifact", the existing OFF-state guards answer "is it assembled". Neither is evidence for the
other, and the plan keeps them in different files so they cannot be confused.
- the boot artifact evidence design §7.5 asks for. `runtimeClasspath` is what `bootJar` packages, so
the two agree by construction — but "by construction" is an argument, not a measurement. One
`bootJar` content assertion is added once, in Step 7, as a check *of the argument*, not per
capability.
## 3. Decision — what a composition module may contain
A `composition:<capability>` module exists only when a capability genuinely spans adapters that must
not depend on each other. It contains cross-adapter wiring and nothing else: no business rule, no
transport surface, no settings that a single leaf could own. If a capability turns out to be
self-contained after the leaf-ownership pass, **no composition module is created for it** — the leaf
is selected directly, exactly as object storage is.
This matters because the fileserver work in the 2026-09-23 closure §3-B.5 already found that the
package which looked like one cross-adapter assembly was two assemblies merged. The same question is
asked before each composition module is created, not after.
Registry: each new module gets a `modules.json` entry with explicit `allowed_dependencies`.
`settings.gradle` includes registered projects automatically, so registration *is* inclusion. A
composition module is **not** a composition root: it composes a capability, it does not run.
## 4. Task units
Ordered. A unit is done when its own focused command is green; no unit starts before the previous
one is.
| # | Unit | Done when |
| --- | --- | --- |
| 1 | Fileserver Build Composition RED test | `:app-bootstrap:verifyDependencyPolicy` fails naming `dev.caskeleton:fileserver`, and the failure text is the contract |
| 2 | Fileserver composition extraction | the 4 cross-adapter configurations left in bootstrap by closure §3-B.5 move to `composition:fileserver`; bootstrap's fileserver edges are gone; unit 1 is green |
| 3 | Fileserver ON/OFF regression | OFF-state and ON-state tests unchanged in meaning and green, from the source set that selects the composition |
| 4 | Notification composition extraction | same shape, same three units collapsed into one because the pattern is proven |
| 5 | Persistence/JPA ownership review | per-file verdict against design §11 Q1–Q4, recorded; only files that answer Q1 or Q2 move |
| 6 | Messaging / Redis residual ownership | broker selection becomes a build edge; Redis keeps only the two application-wide files closure §3-B.5 already justified |
| 7 | Mongo / HTTP client / GraphQL actual optionalization | `runtimeOnly` → absent; one `bootJar` assertion proves the classpath argument |
| 8 | Minimal + full composition certification | minimal = `:app-bootstrap` main; full = the app-bootstrap `systemTest` source set selecting every capability. No new application module unless a source set proves insufficient |
| 9 | Registry / docs / comment alignment | `modules.json`, `capability-status.md` WIRED column, and the "shipped so an operator can enable it" comments in `app-bootstrap/build.gradle` all say the same thing |
| 10 | Focused → repository-wide gates | design §15 command, then `ci`, dependency locks, public-path snapshot, optional-platforms |
Unit 8 uses a source set rather than a new module because `app-bootstrap:integrationTest` already
does exactly this for object storage. Design §6.2 warns against forcing `sample-portfolio` to carry
every capability, and this avoids it without adding a module.
## 5. What this plan does not do
Taken from design §10, repeated here because a plan that omits them invites them:
- no mechanical removal of every `dev.caskeleton.adapter.*` import; ownership is argued per file
- no new platform layer, no new build DSL, no per-capability verifier
- no change to provider behaviour, no feature work, no unrelated test cleanup
- no staging, commit or push — repository policy is `human-only`
- no working-tree cleanup; the tree carries 36 tracked deletions and 54 untracked additions from the
previous pass, and closure §5 records how they must be committed
## 6. Regression guard
Design §14's list is the non-negotiable set. Each unit's focused command includes whichever of these
it can break:
JPA boundary gate :adapter:outbound:persistence-jpa:test
Redis composition unit isolation :adapter:outbound:cache-redis:test
app-bootstrap architecture test :app-bootstrap:architectureTest
runtime activation OFF guards :app-bootstrap:test, :app-bootstrap:systemTest
configuration cache ci/integrationCheck/releaseCheck --dry-run --configuration-cache
gRPC operation-ledger CI caller -p optional-platforms integrationCheck
Leaf ownership already moved for Redis and Fileserver (closure §3-B.5) is a floor, not a starting
point: this work extends it and must not walk it back.
## 7. Progress — units 1 and 2
### Unit 1 is done
`app-bootstrap/build.gradle` declares the contract as a `dependencyPolicy` absence on
`runtimeClasspath`. It was checked for vacuity before it was trusted: a temporary `required` on the
same coordinate passed, which is what proves `dev.caskeleton:fileserver` is the shape a project
dependency actually resolves to. Without that probe an `absent` rule with a misspelled coordinate
would have been green from the first day and meant nothing.
### Unit 2 is done except for one measured blocker
Moved, in this order, because each step unblocked the next:
1. **`RuntimeProfileSnapshot` → `adapter:outbound:support`.** It was the real coupling. A capability
configuration that has a production-only rule had to ask app-bootstrap what the profile was, so
the configuration could not leave app-bootstrap. BOOT-002 said "one composition-root owner"; it
now says one owner for the repository, which is strictly stronger and is what lets a composition
module ask the question at all.
2. **`composition:fileserver-platform` created and registered.** Named for the capability rather
than the directory: `:composition:fileserver` resolves to `dev.caskeleton:fileserver`, the same
coordinate as `adapter:outbound:fileserver`, and Gradle silently substituted the module for
itself. The messaging family already prefixes its leaves for this reason.
3. **The 13 cross-adapter configurations moved**, with the auto-configuration and management-context
registration files that name them. `StartupFailures` became
`CapabilityStartupValidationException`, the same seam the Redis and Fileserver leaf moves used.
4. **app-bootstrap's fileserver edges removed**; the lanes that verify the capability select it.
5. **BOOT-007 moved to the module it governs**, with `allowEmptyShould(false)`. Left where it was it
would have analysed an empty package and passed for having nothing to check — and BOOT-012 caught
the rule leaving the pinned set, which is that guard working rather than an obstacle.
Result: `adapter:outbound:fileserver` is off the minimal runtime classpath. Project edges on
`:app-bootstrap:runtimeClasspath` went from 33 to 32.
**The blocker, measured rather than estimated.** `application-fileserver` is still there, and not
through the composition. It arrives through three leaves every application needs, because the
capability's code is inside them:
| leaf | fileserver files |
| --- | --- |
| `adapter:inbound:web` (`web.fileserver.*`) | 62 |
| `adapter:outbound:persistence-jpa` (`persistence.fileserver.*`) | 25 |
| `adapter:outbound:identifier` | 1 |
So Fileserver was never only "assembled by the composition root". It is embedded in required leaves,
and no composition module can express selecting it out until those 88 files move to leaves of their
own. The coupling was measured and is one-directional and small — `web.fileserver` reaches
`web.{core, observability, auth}` nine times, and exactly one non-fileserver web class
(`WebModuleBoundary`) reaches back — so the split is tractable. It is unit 2b, and it is the next
thing to do.
The contract line stays RED. Softening it to make the gate green would record the opposite of what
was measured, and design §7.1 asks for this test to be RED before the structure changes, not after
it is convenient.
### Verification at this point
./gradlew verifyCleanArchitectureDependencies :adapter:outbound:persistence-jpa:test \
:app-bootstrap:test :app-bootstrap:architectureTest \
:composition:fileserver-platform:check :adapter:outbound:support:test --continue # green
./gradlew ci --continue # 1,276 tasks, exactly one failure:
# :app-bootstrap:verifyDependencyPolicy, the intended RED
One failing task out of 1,276, and it is the one this unit deliberately left failing. Nothing else
in the repository regressed.
## 8. Unit 2 is complete — the Fileserver vertical slice
The blocker recorded above was right about the cause and wrong about the size. `application-fileserver`
arrived through three required leaves, and all three turned out to be clean extractions:
| Extracted | Into | Why it was clean |
| --- | --- | --- |
| 1 file — the upload identifier factory | `adapter:outbound:fileserver` | It implements one Fileserver port and nothing else. One class is why every application that needed an identifier also resolved the Fileserver use cases. |
| 25 files + 4 migrations | `adapter:outbound:persistence-fileserver` (new leaf) | The package imported `application.fileserver`, JPA, Hibernate, Spring Data and JDBC — and not one type from any other `persistence.*` package. No seam was needed. |
| 62 files | `adapter:inbound:web-fileserver` (new leaf) | `web.fileserver` imports `web.{core, auth, observability}` nine times; exactly one non-fileserver class referenced it back, and only in a javadoc sentence. |
The web platform's module map did **not** move. `WebStableModule` still declares the twelve fileserver
modules and their edges, and `WebBuildModel.platformSourceRoots()` now returns two roots — which is
what that method's plural has meant since it was written. A second copy of the map in the second leaf
would have been a second answer to "is this edge declared", and the map is the one thing a platform
must not have two of.
Result: `:app-bootstrap:runtimeClasspath` went from **33 project edges to 31**, and the contract now
names the whole capability rather than the part that was easy to remove:
absent 'dev.caskeleton:fileserver'
absent 'dev.caskeleton:application-fileserver'
absent 'dev.caskeleton:web-fileserver'
absent 'dev.caskeleton:persistence-fileserver'
### What the repository's own guards caught
Every move was stopped first by a guard already in the tree, and every one was the same shape — a
rule still pointing at something that had moved:
- `JpaModuleBoundaryTest`: *"a rule about a package that does not exist passes by finding nothing"*
- `ArchRuleDiscoveryContractTest` (BOOT-012): a rule leaving the pinned set is a decision, not a deletion
- `verifyJpaApiSurface` / `verifyJpaAdopterApiSurface`: surface change promoted to a review decision
- `PersistenceEntityScanCoverageTest`: an opt-in package that is no longer opt-in because it is no longer here
`verifyJpaAdopterApiSurface` was **not** widened by allowlist (design §28). Its scan excludes the
directory that *owns* the implementation; there are two such leaves now, so the exclusion was
corrected, and the baseline file still governs every other module's imports.
### One regression this introduced and then removed
The new web leaf first declared `spring-boot-starter-webflux`. The web leaf's own build file says in
a comment why it declares `spring-webflux` instead: the starter puts reactor-netty — a second
embedded server — on the runtime classpath of an application that already has Tomcat. The new leaf
now matches, and the lock files record the difference.
### Verification
./gradlew ci verifyDependencyLocks --continue # exit 0, 0 FAILED
Repository-wide, everything green, including `:app-bootstrap:verifyDependencyPolicy` — the RED that
opened this unit.
### Next
Unit 4, the Notification composition. Unit 3's ON/OFF regressions are covered by the tests that moved
with the code (`FileserverRuntimeAssemblyTest`, `FileserverPlatformAutoConfigurationTest` in the
composition module, `FileserverCompositionIntegrationTest` in app-bootstrap's integration lane) and
all are green in the run above.
+9 -2
View File
@@ -5,8 +5,15 @@ the account is the last enforcement boundary and a permit issued inside the proc
so a mistake in the SDK is still refused by the server.
A Redis ACL file accepts nothing but complete `user` lines — no comments and no line continuations —
which is why the rationale lives here instead of inline. Password material is supplied at deploy
time; none of these files carries one.
which is why the rationale lives here instead of inline.
Every account here carries a **fixture** password (`fixture-*`). None of them is a deployment
credential and none is read by anything but the local lanes; a deployment replaces the whole file
with one whose passwords come from its secret store. They are written down rather than left as
`nopass` because an account that accepts any password makes every assertion about authentication
pass for the same reason a typo would have — and because these files are what a fork copies. The
four per-role files carried `nopass` long after `all-accounts.acl`, the file a deployment actually
loads, had been fixed; a fork that copied one of them got an open account and a green lane.
| File | Account | Grants |
| --- | --- | --- |
+1 -1
View File
@@ -1 +1 @@
user ca-skeleton-admin-readonly on nopass ~* resetchannels -@all +info +dbsize +time +lastsave +memory|usage +memory|stats +slowlog|get +slowlog|len +latency|latest +latency|history +client|list +client|info +command|info +command|docs +command|count +command|getkeysandflags +config|get +acl|dryrun +acl|whoami +cluster|info +cluster|slots +cluster|shards +cluster|nodes +object|encoding +object|freq +object|idletime +pubsub|channels +pubsub|numsub +pubsub|shardchannels +xinfo|stream +xinfo|groups +xinfo|consumers +function|list +function|stats +cluster|keyslot
user ca-skeleton-admin-readonly on >fixture-admin ~* resetchannels -@all +info +dbsize +time +lastsave +memory|usage +memory|stats +slowlog|get +slowlog|len +latency|latest +latency|history +client|list +client|info +command|info +command|docs +command|count +command|getkeysandflags +config|get +acl|dryrun +acl|whoami +cluster|info +cluster|slots +cluster|shards +cluster|nodes +object|encoding +object|freq +object|idletime +pubsub|channels +pubsub|numsub +pubsub|shardchannels +xinfo|stream +xinfo|groups +xinfo|consumers +function|list +function|stats +cluster|keyslot
+1 -1
View File
@@ -1 +1 @@
user ca-skeleton-application-advanced on nopass sanitize-payload ~prod:* resetchannels &prod:* -@all +@read +@write +@string +@hash +@list +@set +@sortedset +@bitmap +@hyperloglog +@geo +@stream +@pubsub +@transaction +evalsha +evalsha_ro +script|load +script|exists +fcall +fcall_ro -keys -flushdb -flushall -shutdown -debug -eval -eval_ro -smembers -sort -sort_ro -randomkey -migrate -swapdb -select
user ca-skeleton-application-advanced on >fixture-advanced sanitize-payload ~prod:* resetchannels &prod:* -@all +@read +@write +@string +@hash +@list +@set +@sortedset +@bitmap +@hyperloglog +@geo +@stream +@pubsub +@transaction +evalsha +evalsha_ro +script|load +script|exists +fcall +fcall_ro -keys -flushdb -flushall -shutdown -debug -eval -eval_ro -smembers -sort -sort_ro -randomkey -migrate -swapdb -select
+1 -1
View File
@@ -1 +1 @@
user ca-skeleton-application on nopass sanitize-payload ~prod:* resetchannels &prod:* -@all +@connection +@pubsub +@transaction +@read +@write +@string +@hash +@list +@set +@sortedset +@bitmap +@hyperloglog +@geo +@stream -keys -flushdb -flushall -shutdown -debug -sort -sort_ro -smembers -randomkey -migrate -swapdb -select
user ca-skeleton-application on >fixture-application sanitize-payload ~prod:* resetchannels &prod:* -@all +@connection +@pubsub +@transaction +@read +@write +@string +@hash +@list +@set +@sortedset +@bitmap +@hyperloglog +@geo +@stream -keys -flushdb -flushall -shutdown -debug -sort -sort_ro -smembers -randomkey -migrate -swapdb -select
+1 -1
View File
@@ -1 +1 @@
user ca-skeleton-raw-gateway on nopass sanitize-payload ~prod:* resetchannels -@all +smembers +sort +sort_ro
user ca-skeleton-raw-gateway on >fixture-raw sanitize-payload ~prod:* resetchannels -@all +smembers +sort +sort_ro
+1
View File
@@ -235,6 +235,7 @@ APP_FILESERVER_LOCAL_EXPECTED_FILE_STORE_TYPE=
APP_FILESERVER_LOCAL_MOUNT_SENTINEL_SHA256=
APP_FILESERVER_LOCAL_EXPECTED_OWNER=
APP_HTTPCLIENT_ENABLED=false
APP_HTTPCLIENT_ROTATION_DRAIN_TIMEOUT=30s
APP_FILESERVER_PLATFORM_ENABLED=false
APP_FILESERVER_PLATFORM_INSTANCE_ID=local-node
APP_FILESERVER_PLATFORM_DEFAULT_NAMESPACE=default
+4
View File
@@ -38,6 +38,10 @@ WORKDIR /build/src
# (Requires the labs Dockerfile frontend — see the `# syntax` directive at the top of this file.)
COPY gradlew ./
COPY gradle/ gradle/
# The repository's Gradle memory, worker and caching settings. Without it the dependency-resolution
# stage below resolves every module's locked configuration on Gradle's defaults rather than the
# -Xmx1g / workers.max / caching-on this build is tuned for.
COPY gradle.properties ./
COPY config/ ./config/
COPY --parents settings.gradle build.gradle **/build.gradle **/gradle.lockfile ./
# The convention plugins, whole. The glob above copies files named build.gradle and gradle.lockfile,
+12 -3
View File
@@ -15,6 +15,11 @@
테스트, Spotless, Checkstyle, Error Prone만 담당합니다. 저장소 전체 정책은 이름이 드러나는
루트 task로 실행하며, CI가 이를 집계합니다.
이 셋의 역할은 겹치지 않습니다. Spotless(google-java-format)가 포맷과 import 순서를 소유하고,
Checkstyle은 **포매터가 표현할 수 없는 것만** — 네이밍과 몇 가지 논리/설계 규칙만 — 봅니다
(`config/checkstyle/checkstyle.xml`). 줄 길이·들여쓰기·import 순서 모듈이 여기에 없는 것은 누락이
아니라 포매터와 싸우지 않기 위한 선택입니다. Error Prone은 컴파일 시점 버그 패턴을 담당합니다.
| 게이트 | 하는 일 |
| --- | --- |
| `architectureCheck` | Clean Architecture 의존 방향, runtime membership, application-core purity, Git에 실리지 않는 source package를 검사 |
@@ -142,9 +147,13 @@ Checkstyle은 파싱된 파일에 같은 질문을 하고, leaf 단위로 돕니
- **하는 일.** deny-by-default public path 표면이 승인 없이 바뀌면 빌드를 실패시킵니다.
- **배경.** 이 앱은 deny-by-default 입니다. 즉 `SECURITY_PUBLIC_PATHS` 가 먹이는 명시적 `permitAll()`
경로를 **제외한** 모든 요청은 인증을 요구합니다(`src/.env` → `SecuritySettings.publicPaths()` →
`SecurityConfig`). 이 public 표면이 바뀌는 순간이 곧 보호되던 엔드포인트가 조용히 공개로 노출되는
지점입니다. 그래서 그 표면을 snapshot 으로 떠 두고, 미승인 변경에 빌드를 실패시킵니다.
경로를 **제외한** 모든 요청은 인증을 요구합니다
(`app-bootstrap/src/main/resources/config/security.yml` → `SecuritySettings.publicPaths()` →
`SecurityConfig`). 설정 분할 이전에는 이 SSOT 가 `src/.env` 였고 문서만 그대로 남아 있었습니다.
스냅샷 플러그인이 실제로 읽는 파일은 `config/security.yml` 입니다
(`build-logic/.../publicpath/PublicPathSnapshotPlugin.java`).
이 public 표면이 바뀌는 순간이 곧 보호되던 엔드포인트가 조용히 공개로 노출되는 지점입니다.
그래서 그 표면을 snapshot 으로 떠 두고, 미승인 변경에 빌드를 실패시킵니다.
- **승인 방법.** `verifyPublicPathSnapshot` 은 항상 읽기 전용입니다. reviewer 가 변경을 승인한 뒤
`./gradlew updatePublicPathSnapshot -PapprovePublicPathChange` 로 snapshot 을 명시적으로 다시
생성합니다. 공개 경로 변경은 보안 리뷰 대상으로 보고 재생성된 snapshot 을 함께 커밋합니다.
+2
View File
@@ -4,6 +4,8 @@ plugins {
id 'java-test-fixtures'
id 'ca.auxiliary-source-set'
id 'ca.graphql-platform'
id 'ca.api-surface'
id 'ca.strict-qualification'
}
// Driving adapter: GraphQL API (skeleton machinery, transport-only).
@@ -86,8 +86,20 @@ public final class BoundedPreparsedDocumentProvider<D> {
return await(leader);
}
metrics.recordMiss();
try {
// Claiming the key is not the same instant as missing it. Between this thread's lookup and
// its claim, the previous leader can finish parsing, store the document and release its
// in-flight slot — and then this thread's putIfAbsent succeeds and it parses a document that
// is already cached. The single-flight guarantee this class documents is only true if the
// leader re-reads the cache after it has the claim.
D parsedWhileClaiming = lookup(key, clock.instant());
if (parsedWhileClaiming != null) {
metrics.recordHit();
mine.complete(parsedWhileClaiming);
return parsedWhileClaiming;
}
metrics.recordMiss();
D document = parseAndValidate.apply(key);
store(key, document, documentWeight, clock.instant());
mine.complete(document);
+1
View File
@@ -1,6 +1,7 @@
plugins {
id 'ca.spring-library'
id 'ca.spring-config'
id 'ca.strict-qualification'
}
String grpcVersion = libs.versions.grpc.get()
@@ -0,0 +1,42 @@
plugins {
id 'ca.spring-library'
id 'ca.spring-config'
}
// The Fileserver capability's HTTP surface.
//
// It was the `web.fileserver` package inside `adapter:inbound:web`, and that is the last reason
// every application resolved `application-fileserver`: the capability's controllers, DTOs, mappers,
// range and nginx helpers, tus and draft-12 upload surfaces and its HTTP authorization all compiled
// into the leaf that any application with an HTTP API depends on.
//
// The package keeps its name. It is still part of the web platform's module map — `WebStableModule`
// declares its twelve modules and their edges, and `WebBuildModel.platformSourceRoots()` scans this
// source root alongside the web leaf's, which is what that method's plural has always been for. A
// second copy of the map here would be a second answer to "is this edge declared", and the map is
// the one thing the platform must not have two of.
//
// It depends on `adapter:inbound:web` rather than the reverse: the fileserver modules import `core`,
// `auth` and `observability`, nine times in total, and nothing outside them imports fileserver.
dependencies {
implementation project(':adapter:inbound:web')
implementation project(':application-core')
implementation project(':application-fileserver')
implementation project(':shared-contract')
implementation 'org.springframework.boot:spring-boot-starter-web'
implementation 'org.springframework.boot:spring-boot-starter-security'
implementation 'org.springframework.boot:spring-boot-starter-validation'
// `spring-webflux`, not `spring-boot-starter-webflux`, for the reason the web leaf states in
// its own build file: the starter puts reactor-netty — a second embedded server — on the
// runtime classpath of an application that already has Tomcat. The reactive fileserver surface
// needs the types, not another server.
implementation 'org.springframework:spring-webflux'
implementation 'io.projectreactor:reactor-core'
testImplementation project(':adapter:inbound:web')
testImplementation testFixtures(project(':adapter:inbound:web'))
testImplementation 'org.springframework.boot:spring-boot-starter-test'
testImplementation 'org.springframework.security:spring-security-test'
testImplementation 'io.projectreactor:reactor-test'
}
@@ -0,0 +1,192 @@
# This is a Gradle generated file for dependency locking.
# Manual edits can break the build and are not advised.
# This file is expected to be part of source control.
biz.aQute.bnd:biz.aQute.bnd.annotation:7.1.0=compileClasspath,testCompileClasspath
ch.qos.logback:logback-classic:1.5.38=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
ch.qos.logback:logback-core:1.5.38=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
com.fasterxml.jackson.core:jackson-annotations:2.21=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
com.fasterxml.jackson.core:jackson-core:2.21.5=runtimeClasspath,testRuntimeClasspath
com.fasterxml.jackson.core:jackson-databind:2.21.5=runtimeClasspath,testRuntimeClasspath
com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:2.21.5=runtimeClasspath,testRuntimeClasspath
com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.21.5=runtimeClasspath,testRuntimeClasspath
com.fasterxml.jackson:jackson-bom:2.21.5=runtimeClasspath,testRuntimeClasspath
com.fasterxml:classmate:1.7.3=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
com.github.ben-manes.caffeine:caffeine:3.2.4=annotationProcessor,testAnnotationProcessor
com.github.kevinstern:software-and-algorithms:1.0=annotationProcessor,testAnnotationProcessor
com.github.spotbugs:spotbugs-annotations:4.10.2=spotbugs
com.github.spotbugs:spotbugs:4.10.2=spotbugs
com.github.stephenc.jcip:jcip-annotations:1.0-1=spotbugs
com.google.auto.service:auto-service-annotations:1.0.1=annotationProcessor,testAnnotationProcessor
com.google.auto.value:auto-value-annotations:1.9=annotationProcessor,testAnnotationProcessor
com.google.auto:auto-common:1.2.2=annotationProcessor,testAnnotationProcessor
com.google.code.findbugs:jsr305:3.0.2=checkstyle,spotbugs
com.google.code.gson:gson:2.13.2=spotbugs
com.google.errorprone:error_prone_annotation:2.49.0=annotationProcessor,testAnnotationProcessor
com.google.errorprone:error_prone_annotations:2.38.0=compileClasspath,testCompileClasspath
com.google.errorprone:error_prone_annotations:2.41.0=spotbugs
com.google.errorprone:error_prone_annotations:2.47.0=checkstyle
com.google.errorprone:error_prone_annotations:2.49.0=annotationProcessor,testAnnotationProcessor
com.google.errorprone:error_prone_check_api:2.49.0=annotationProcessor,testAnnotationProcessor
com.google.errorprone:error_prone_core:2.49.0=annotationProcessor,testAnnotationProcessor
com.google.googlejavaformat:google-java-format:1.35.0=annotationProcessor,testAnnotationProcessor
com.google.guava:failureaccess:1.0.3=annotationProcessor,checkstyle,testAnnotationProcessor
com.google.guava:guava:33.5.0-jre=annotationProcessor,testAnnotationProcessor
com.google.guava:guava:33.6.0-jre=checkstyle
com.google.guava:listenablefuture:9999.0-empty-to-avoid-conflict-with-guava=annotationProcessor,checkstyle,testAnnotationProcessor
com.google.j2objc:j2objc-annotations:3.1=annotationProcessor,checkstyle,testAnnotationProcessor
com.google.protobuf:protobuf-java:4.33.2=annotationProcessor,testAnnotationProcessor
com.h3xstream.findsecbugs:findsecbugs-plugin:1.14.0=spotbugsPlugins
com.jayway.jsonpath:json-path:2.10.0=testCompileClasspath,testRuntimeClasspath
com.nimbusds:nimbus-jose-jwt:10.4=runtimeClasspath,testRuntimeClasspath
com.puppycrawl.tools:checkstyle:13.5.0=checkstyle
com.tngtech.archunit:archunit-junit5-api:1.3.0=testRuntimeClasspath
com.tngtech.archunit:archunit-junit5-engine-api:1.3.0=testRuntimeClasspath
com.tngtech.archunit:archunit-junit5-engine:1.3.0=testRuntimeClasspath
com.tngtech.archunit:archunit-junit5:1.3.0=testRuntimeClasspath
com.tngtech.archunit:archunit:1.3.0=testRuntimeClasspath
com.vaadin.external.google:android-json:0.0.20131108.vaadin1=testCompileClasspath,testRuntimeClasspath
commons-beanutils:commons-beanutils:1.11.0=checkstyle
commons-collections:commons-collections:3.2.2=checkstyle
commons-io:commons-io:2.21.0=spotbugs
commons-logging:commons-logging:1.3.6=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
info.picocli:picocli:4.7.7=checkstyle
io.github.eisop:dataflow-errorprone:3.41.0-eisop1=annotationProcessor,testAnnotationProcessor
io.github.java-diff-utils:java-diff-utils:4.12=annotationProcessor,testAnnotationProcessor
io.micrometer:micrometer-commons:1.16.7=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
io.micrometer:micrometer-observation:1.16.7=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
io.projectreactor:reactor-core:3.8.7=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
io.projectreactor:reactor-test:3.8.7=testCompileClasspath,testRuntimeClasspath
io.swagger.core.v3:swagger-annotations-jakarta:2.2.38=runtimeClasspath,testRuntimeClasspath
io.swagger.core.v3:swagger-core-jakarta:2.2.38=runtimeClasspath,testRuntimeClasspath
io.swagger.core.v3:swagger-models-jakarta:2.2.38=runtimeClasspath,testRuntimeClasspath
jakarta.activation:jakarta.activation-api:2.1.4=runtimeClasspath,testCompileClasspath,testRuntimeClasspath
jakarta.annotation:jakarta.annotation-api:3.0.0=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
jakarta.servlet:jakarta.servlet-api:6.1.0=testRuntimeClasspath
jakarta.validation:jakarta.validation-api:3.1.1=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
jakarta.xml.bind:jakarta.xml.bind-api:4.0.5=runtimeClasspath,testCompileClasspath,testRuntimeClasspath
javax.inject:javax.inject:1=annotationProcessor,testAnnotationProcessor
jaxen:jaxen:2.0.6=spotbugs
net.bytebuddy:byte-buddy-agent:1.17.8=testCompileClasspath,testRuntimeClasspath
net.bytebuddy:byte-buddy:1.17.8=testCompileClasspath,testRuntimeClasspath
net.minidev:accessors-smart:2.6.0=testCompileClasspath,testRuntimeClasspath
net.minidev:json-smart:2.6.0=testCompileClasspath,testRuntimeClasspath
net.sf.saxon:Saxon-HE:12.9=checkstyle,spotbugs
org.antlr:antlr4-runtime:4.13.2=checkstyle
org.apache.bcel:bcel:6.12.0=spotbugs
org.apache.commons:commons-lang3:3.20.0=checkstyle,runtimeClasspath,spotbugs,testRuntimeClasspath
org.apache.commons:commons-text:1.15.0=spotbugs
org.apache.commons:commons-text:1.3=checkstyle
org.apache.httpcomponents:httpclient:4.5.13=checkstyle
org.apache.httpcomponents:httpcore:4.4.16=checkstyle
org.apache.logging.log4j:log4j-api:2.25.5=compileClasspath,runtimeClasspath,spotbugs,testCompileClasspath,testRuntimeClasspath
org.apache.logging.log4j:log4j-core:2.25.5=spotbugs
org.apache.logging.log4j:log4j-to-slf4j:2.25.5=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.apache.maven.doxia:doxia-core:1.12.0=checkstyle
org.apache.maven.doxia:doxia-logging-api:1.12.0=checkstyle
org.apache.maven.doxia:doxia-module-xdoc:1.12.0=checkstyle
org.apache.maven.doxia:doxia-sink-api:1.12.0=checkstyle
org.apache.tomcat.embed:tomcat-embed-core:11.0.24=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.apache.tomcat.embed:tomcat-embed-el:11.0.24=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.apache.tomcat.embed:tomcat-embed-websocket:11.0.24=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.apache.xbean:xbean-reflect:3.7=checkstyle
org.apiguardian:apiguardian-api:1.1.2=testCompileClasspath
org.assertj:assertj-core:3.27.7=testCompileClasspath,testRuntimeClasspath
org.awaitility:awaitility:4.3.0=testCompileClasspath,testRuntimeClasspath
org.codehaus.plexus:plexus-classworlds:2.6.0=checkstyle
org.codehaus.plexus:plexus-component-annotations:2.1.0=checkstyle
org.codehaus.plexus:plexus-container-default:2.1.0=checkstyle
org.codehaus.plexus:plexus-utils:3.3.0=checkstyle
org.dom4j:dom4j:2.2.0=spotbugs
org.hamcrest:hamcrest:3.0=testCompileClasspath,testRuntimeClasspath
org.hibernate.validator:hibernate-validator:9.0.1.Final=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.javassist:javassist:3.28.0-GA=checkstyle
org.jboss.logging:jboss-logging:3.6.3.Final=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.jspecify:jspecify:1.0.1=annotationProcessor,checkstyle,compileClasspath,runtimeClasspath,testAnnotationProcessor,testCompileClasspath,testRuntimeClasspath
org.junit.jupiter:junit-jupiter-api:6.0.3=testCompileClasspath,testRuntimeClasspath
org.junit.jupiter:junit-jupiter-engine:6.0.3=testRuntimeClasspath
org.junit.jupiter:junit-jupiter-params:6.0.3=testCompileClasspath,testRuntimeClasspath
org.junit.jupiter:junit-jupiter:6.0.3=testCompileClasspath,testRuntimeClasspath
org.junit.platform:junit-platform-commons:6.0.3=testCompileClasspath,testRuntimeClasspath
org.junit.platform:junit-platform-engine:6.0.3=testRuntimeClasspath
org.junit.platform:junit-platform-launcher:6.0.3=testRuntimeClasspath
org.junit:junit-bom:6.0.3=testCompileClasspath,testRuntimeClasspath
org.junit:junit-bom:6.1.0=spotbugs
org.mockito:mockito-core:5.20.0=mockitoAgent,testCompileClasspath,testRuntimeClasspath
org.mockito:mockito-junit-jupiter:5.20.0=testCompileClasspath,testRuntimeClasspath
org.objenesis:objenesis:3.3=testRuntimeClasspath
org.openapitools:jackson-databind-nullable:0.2.6=runtimeClasspath,testRuntimeClasspath
org.opentest4j:opentest4j:1.3.0=testCompileClasspath,testRuntimeClasspath
org.osgi:org.osgi.annotation.bundle:2.0.0=compileClasspath,testCompileClasspath
org.osgi:org.osgi.annotation.versioning:1.1.2=compileClasspath,testCompileClasspath
org.osgi:org.osgi.resource:1.0.0=compileClasspath,testCompileClasspath
org.osgi:org.osgi.service.serviceloader:1.0.0=compileClasspath,testCompileClasspath
org.ow2.asm:asm-analysis:9.10.1=spotbugs
org.ow2.asm:asm-commons:9.10.1=spotbugs
org.ow2.asm:asm-tree:9.10.1=spotbugs
org.ow2.asm:asm-util:9.10.1=spotbugs
org.ow2.asm:asm:9.10.1=spotbugs
org.ow2.asm:asm:9.7.1=testCompileClasspath,testRuntimeClasspath
org.pcollections:pcollections:4.0.1=annotationProcessor,testAnnotationProcessor
org.reactivestreams:reactive-streams:1.0.4=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.reflections:reflections:0.10.2=checkstyle
org.skyscreamer:jsonassert:1.5.3=testCompileClasspath,testRuntimeClasspath
org.slf4j:jul-to-slf4j:2.0.18=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.slf4j:slf4j-api:2.0.18=compileClasspath,runtimeClasspath,spotbugs,spotbugsSlf4j,testCompileClasspath,testRuntimeClasspath
org.slf4j:slf4j-simple:2.0.17=spotbugsSlf4j
org.slf4j:slf4j-simple:2.0.18=checkstyle
org.springdoc:springdoc-openapi-starter-common:3.0.0=runtimeClasspath,testRuntimeClasspath
org.springdoc:springdoc-openapi-starter-webmvc-api:3.0.0=runtimeClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-autoconfigure:4.0.8=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-configuration-processor:4.0.8=annotationProcessor
org.springframework.boot:spring-boot-http-converter:4.0.8=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-jackson:4.0.8=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-resttestclient:4.0.8=testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-security-oauth2-resource-server:4.0.8=runtimeClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-security:4.0.8=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-servlet:4.0.8=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-starter-jackson-test:4.0.8=testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-starter-jackson:4.0.8=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-starter-logging:4.0.8=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-starter-oauth2-resource-server:4.0.8=runtimeClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-starter-security:4.0.8=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-starter-test:4.0.8=testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-starter-tomcat-runtime:4.0.8=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-starter-tomcat:4.0.8=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-starter-validation:4.0.8=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-starter-web:4.0.8=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-starter-webmvc-test:4.0.8=testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-starter-webmvc:4.0.8=testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-starter:4.0.8=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-test-autoconfigure:4.0.8=testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-test:4.0.8=testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-tomcat:4.0.8=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-validation:4.0.8=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-web-server:4.0.8=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-webmvc-test:4.0.8=testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot-webmvc:4.0.8=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework.boot:spring-boot:4.0.8=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework.security:spring-security-config:7.0.7=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework.security:spring-security-core:7.0.7=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework.security:spring-security-crypto:7.0.7=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework.security:spring-security-oauth2-core:7.0.7=runtimeClasspath,testRuntimeClasspath
org.springframework.security:spring-security-oauth2-jose:7.0.7=runtimeClasspath,testRuntimeClasspath
org.springframework.security:spring-security-oauth2-resource-server:7.0.7=runtimeClasspath,testRuntimeClasspath
org.springframework.security:spring-security-test:7.0.7=testCompileClasspath,testRuntimeClasspath
org.springframework.security:spring-security-web:7.0.7=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework.session:spring-session-core:4.0.5=runtimeClasspath,testRuntimeClasspath
org.springframework:spring-aop:7.0.9=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework:spring-beans:7.0.9=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework:spring-context:7.0.9=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework:spring-core:7.0.9=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework:spring-expression:7.0.9=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework:spring-test:7.0.9=testCompileClasspath,testRuntimeClasspath
org.springframework:spring-web:7.0.9=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework:spring-webflux:7.0.9=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.springframework:spring-webmvc:7.0.9=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
org.xmlresolver:xmlresolver:5.3.3=checkstyle,spotbugs
org.xmlunit:xmlunit-core:2.10.4=testCompileClasspath,testRuntimeClasspath
org.yaml:snakeyaml:2.5=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
tools.jackson.core:jackson-core:3.1.5=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
tools.jackson.core:jackson-databind:3.1.5=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
tools.jackson:jackson-bom:3.1.5=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
empty=

Some files were not shown because too many files have changed in this diff Show More