Files
grpc-library/build.gradle
T
DongHyeonka a892a45073
pr / ci (pull_request) Successful in 3m34s
fix(release): 서명 진단이 비밀번호 모양을 알리고 Gradle 서명기로도 서명해 본다
signing-check(run 13)에서 base64를 푼 키는 맞았다. armor·CRC24·tag 5가
정상이고, 가져온 키 지문이 릴리스 키 92646CEA…F791F8AB였다. 남은 실패는
「SIGNING_PASSWORD로 서명이 안 된다」 하나인데, 비밀번호가 틀렸는지,
붙여 넣을 때 줄바꿈·공백이 섞였는지, gpg 쪽 문제인지 가를 수 없었다.
gpg는 비밀번호의 첫 줄만 읽고 Gradle은 값 전체를 쓰므로, gpg 판정이
Gradle 판정과 다를 수도 있었다.

- check-signing-key.sh: 비밀번호의 모양(글자 수, 줄바꿈·CR 수, 앞뒤 공백,
  비ASCII 수)과 서명 실패 때의 gpg 상태 키워드만 출력한다. 값은 출력하지
  않는다.
- verifySigningKey: 스크립트 뒤에 Gradle의 in-memory 서명기
  (signing.signatory)로 몇 바이트를 서명해 본다. Sign 태스크와 같은 판정이다.
  실패 문구는 BouncyCastle 예외 문장뿐이다. 둘 중 하나라도 실패하면
  태스크가 실패한다.

검증(로컬 gpg, 버리는 키): 맞는 비밀번호 ok, 틀린 비밀번호 「gpg status:
BEGIN_SIGNING FAILURE KEY_CONSIDERED」. 끝에 줄바꿈이 붙은 비밀번호는 gpg로
ok이고 모양 줄이 「line breaks 1」을 알린다(Gradle 판정은 desktop과 runner).
2026-11-08 15:21:16 +09:00

314 lines
14 KiB
Groovy

import dev.caskeleton.buildlogic.java.JavaConventionsPlugin
import dev.caskeleton.buildlogic.publishing.SigningKeys
plugins {
id 'ca.architecture'
// Every strict lane belongs to a stage a workflow executes (.gitea/workflows). Without it a lane
// that fails closed can still run nowhere (template review 2026-11-03 RR-06-03).
id 'ca.strict-lane-stages'
// The release SBOM is published as an artifact of its own, `grpc-library`, next to the modules.
id 'maven-publish'
id 'signing'
}
// The modules: every leaf the registry includes (settings.gradle). The family projects `:grpc` and
// `:grpc-advanced` are folders, not modules.
def leaves = subprojects.findAll { it.childProjects.isEmpty() }
def leafPaths = leaves.collect { it.path }
// The root's coordinate is the release's: the SBOM artifact carries the version the modules carry.
group = providers.gradleProperty('libraryGroup').get()
def revision = JavaConventionsPlugin.sourceRevision(providers)
version = JavaConventionsPlugin.releaseVersion(providers) +
(revision == JavaConventionsPlugin.UNKNOWN_REVISION ? '-SNAPSHOT' : '')
// Captured here: inside a task's configuration `group` and `version` are the task's own properties.
def libraryCoordinates = [project.group.toString(), project.version.toString()]
tasks.register('resolveAndLockAll') {
group = 'build setup'
description = 'Regenerates dependency locks for every module (requires --write-locks).'
dependsOn leafPaths.collect { "${it}:resolveAndLockAll" }
}
tasks.register('verifyDependencyLocks') {
group = 'verification'
description = 'Fails when a module resolves something its strict lockfile does not list.'
dependsOn leafPaths.collect { "${it}:verifyDependencyLocks" }
}
tasks.register('checkAll') {
group = 'verification'
description = 'Runs every module check.'
dependsOn leafPaths.collect { "${it}:check" }
}
tasks.register('qualityCheck') {
group = 'verification'
description = 'Runs production-bytecode static analysis for every module.'
dependsOn leafPaths.collect { "${it}:qualityCheck" }
}
// SpotBugs + FindSecBugs over the test source sets (config/spotbugs/exclude-test.xml). Short here
// (nine modules), so it joins `ci`.
tasks.register('testQualityCheck') {
group = 'verification'
description = 'Runs test-code static analysis for every module.'
dependsOn leafPaths.collect { "${it}:testQualityCheck" }
}
// build-logic is a copy of the template's convention plugins (build-logic/UPSTREAM.md); its own
// TestKit and unit tests keep the copy honest when it is changed here.
tasks.register('buildLogicTest') {
group = 'verification'
description = 'Runs the included build-logic build\'s tests.'
dependsOn gradle.includedBuild('build-logic').task(':test')
}
// The pull-request stage (pr.yml). Buf lint and breaking-change policy run here rather than in each
// module's `check`: Buf is a downloaded binary and the breaking check reads Git history, which a
// local `./gradlew :grpc:grpc-contract:check` should not need.
tasks.register('ci') {
group = 'verification'
description = 'The pull-request stage: module checks, architecture, static analysis, locks, Buf and build-logic tests.'
dependsOn tasks.named('checkAll')
dependsOn tasks.named('qualityCheck')
dependsOn tasks.named('testQualityCheck')
dependsOn tasks.named('verifyDependencyLocks')
// architectureCheck, not only the direction gate: it also runs verifyNoIgnoredSourcePackages.
dependsOn tasks.named('architectureCheck')
dependsOn ':grpc:grpc-contract:bufLint', ':grpc:grpc-contract:bufBreaking'
dependsOn tasks.named('buildLogicTest')
}
// Every module's integration lanes: grpc-operation-ledger-jpa's Testcontainers PostgreSQL lane, which
// certifies the atomic `INSERT ... ON CONFLICT DO NOTHING` claim durable idempotency rests on. Needs a
// container runtime.
tasks.register('integrationCheck') {
group = 'verification'
description = 'Runs every module integration test lane. Needs a container runtime.'
dependsOn leafPaths.collect { "${it}:integrationTestLaneCheck" }
}
// grpcPerformanceTest asserts the shape of a measurement (ordered percentiles, a gate that reads
// them) with a generous budget, not a number, so it can run on a shared runner.
tasks.register('performanceCheck') {
group = 'verification'
description = 'Runs every module performance test lane.'
dependsOn leafPaths.collect { "${it}:performanceTestLaneCheck" }
}
// The main-branch stage (main.yml): the pull-request stage again on the merged commit, plus the lanes
// that start containers or measure.
tasks.register('mainCheck') {
group = 'verification'
description = 'The main-branch stage: ci, integrationCheck and performanceCheck.'
dependsOn tasks.named('ci')
dependsOn tasks.named('integrationCheck')
dependsOn tasks.named('performanceCheck')
}
// ---------------------------------------------------------------- release (release.yml)
def sbomFile = layout.buildDirectory.file("release/grpc-library-${version}-cyclonedx.json")
tasks.register('verifyReleaseVersion') {
group = 'verification'
description = 'Fails unless this build names a release version and the commit it was built from.'
def releaseVersion = libraryCoordinates[1]
doLast {
if (releaseVersion.endsWith('-SNAPSHOT')) {
throw new GradleException("No commit id (-PgitRevision, GIT_SHA or GITHUB_SHA): ${releaseVersion} is not a release.")
}
if (releaseVersion == '0.0.1') {
throw new GradleException('No release version: run with RELEASE_TAG=vX.Y.Z (release.yml) or -PreleaseVersion.')
}
}
}
tasks.register('releaseSbom', Exec) {
group = 'release'
description = 'Writes the CycloneDX SBOM of the published modules from their lockfiles (Trivy).'
outputs.file(sbomFile)
outputs.upToDateWhen { false }
commandLine 'bash', file('scripts/release/sbom.sh'), sbomFile.get().asFile
}
tasks.register('dependencyVulnerabilityScan', Exec) {
group = 'verification'
description = 'Fails on a HIGH or CRITICAL dependency vulnerability or any CISA KEV match (Trivy).'
mustRunAfter tasks.named('releaseSbom')
def reports = layout.buildDirectory.dir('release/vulnerability')
commandLine 'bash', file('scripts/release/vulnerability-scan.sh'), reports.get().asFile
}
// The tag-only stage: the hermetic certification lanes of every module (their tests already run in
// `test`; a lane adds that its tag still selects something), the integration lanes, the version
// check, the SBOM and the dependency gate. grpcPerformanceTest is not release evidence on a shared
// runner and stays in mainCheck.
tasks.register('releaseCheck') {
group = 'verification'
description = 'The release stage before publishing: certification and integration lanes, version, SBOM, dependency gate.'
dependsOn tasks.named('verifyReleaseVersion')
dependsOn leafPaths.collect { "${it}:testLaneCheck" }
dependsOn tasks.named('integrationCheck')
dependsOn tasks.named('releaseSbom')
dependsOn tasks.named('dependencyVulnerabilityScan')
}
publishing {
publications {
sbom(MavenPublication) {
artifactId = 'grpc-library'
artifact(sbomFile) {
classifier = 'cyclonedx'
extension = 'json'
builtBy tasks.named('releaseSbom')
}
pom {
name = 'grpc-library'
description = 'CycloneDX SBOM of the grpc-library modules of this version.'
url = providers.gradleProperty('repositoryUrl')
packaging = 'pom'
}
}
}
repositories {
maven {
name = 'gitea'
url = providers.gradleProperty('packagesUrl')
credentials(HttpHeaderCredentials) {
name = 'Authorization'
value = "token ${providers.environmentVariable('PACKAGE_TOKEN').getOrElse('')}"
}
authentication {
header(HttpHeaderAuthentication)
}
}
maven {
name = 'staging'
url = layout.buildDirectory.dir('staging-repository')
}
}
}
// The armoured key, or the base64 of the armoured file (the usual way to keep it in a CI secret).
def signingKey = SigningKeys.armoured(providers.environmentVariable('SIGNING_KEY').getOrElse(''))
// Before anything is signed: the secret's shape, that gpg imports it as the release key and that
// SIGNING_PASSWORD signs with it, printing no part of either. Gradle's signing reports every one of
// these as "Could not read PGP secret key" (v1.0.0 release run 9); this says which. A key other
// than the release key passes with -PsigningKeyFingerprint=<its fingerprint> (a rehearsal key).
// gpg reads only a passphrase's first line and Gradle the whole value, so the task then signs a few
// bytes with Gradle's own signatory: the verdict is the one the Sign tasks would reach.
tasks.register('verifySigningKey', Exec) {
group = 'verification'
description = 'Checks SIGNING_KEY and SIGNING_PASSWORD without printing them (scripts/release/check-signing-key.sh).'
outputs.upToDateWhen { false }
ignoreExitValue = true
commandLine 'bash', file('scripts/release/check-signing-key.sh'),
providers.gradleProperty('signingKeyFingerprint').getOrElse('')
def signed = !signingKey.isBlank()
doLast {
boolean scriptPassed = executionResult.get().exitValue == 0
boolean gradlePassed = !signed
String verdict = 'skipped: no SIGNING_KEY'
if (signed) {
try {
signing.signatory.sign(new ByteArrayInputStream('signing check'.bytes), OutputStream.nullOutputStream())
gradlePassed = true
verdict = 'ok'
} catch (Exception failure) {
// Exception text only: BouncyCastle names what failed (checksum mismatch, a tag), never the key.
def cause = failure.cause ? " (${failure.cause.class.simpleName}: ${failure.cause.message})" : ''
verdict = "failed: ${failure.message}${cause}"
}
}
logger.lifecycle("signing as Gradle's Sign tasks do (in-memory key): ${verdict}")
if (!scriptPassed || !gradlePassed) {
throw new GradleException('verifySigningKey: the signing secrets would not sign; the PROBLEM lines above say why.')
}
}
}
tasks.withType(Sign).configureEach {
mustRunAfter tasks.named('verifySigningKey')
}
if (!signingKey.isBlank()) {
signing {
useInMemoryPgpKeys(signingKey, providers.environmentVariable('SIGNING_PASSWORD').getOrElse(''))
sign publishing.publications.sbom
}
}
tasks.withType(PublishToMavenRepository).configureEach {
mustRunAfter tasks.named('releaseCheck')
if (name.endsWith('ToGiteaRepository')) {
def signed = !signingKey.isBlank()
def token = providers.environmentVariable('PACKAGE_TOKEN').getOrElse('')
doFirst {
if (!signed) {
throw new GradleException('SIGNING_KEY is not set; refusing to publish unsigned files to Gitea.')
}
if (token.isBlank()) {
throw new GradleException('PACKAGE_TOKEN is not set; Gitea\'s job token cannot publish packages.')
}
}
}
}
// Everything release.yml does up to the upload, into build/staging-repository: what `release` would
// publish, checked file by file. Needs no secret; with SIGNING_KEY set it also checks every .asc.
tasks.register('releaseRehearsal') {
group = 'release'
description = 'releaseCheck, then publishes every module and the SBOM to build/staging-repository and checks the files.'
dependsOn tasks.named('releaseCheck')
if (!signingKey.isBlank()) {
dependsOn tasks.named('verifySigningKey')
}
dependsOn tasks.named('publishAllPublicationsToStagingRepository')
dependsOn leafPaths.collect { "${it}:publishAllPublicationsToStagingRepository" }
def staging = layout.buildDirectory.dir('staging-repository')
def artifacts = leaves.collect { it.name }
def coordinates = libraryCoordinates
def signed = !signingKey.isBlank()
def checker = file('scripts/release/check-staging.py')
doLast {
def command = ['python3', checker.path, staging.get().asFile.path, coordinates[0], coordinates[1],
signed ? 'signed' : 'unsigned'] + artifacts
def process = command.execute()
process.waitForProcessOutput(System.out, System.err)
if (process.exitValue() != 0) {
throw new GradleException('releaseRehearsal: the staged release is incomplete (see above).')
}
}
}
// The release: releaseCheck, then every module and the SBOM to Gitea Packages, then an anonymous read
// of each module's metadata. release.yml runs this one task on a vX.Y.Z tag.
tasks.register('release') {
group = 'release'
description = 'releaseCheck, publish to Gitea Packages, then verify the version is readable anonymously.'
dependsOn tasks.named('releaseCheck')
dependsOn tasks.named('verifySigningKey')
dependsOn tasks.named('publishAllPublicationsToGiteaRepository')
dependsOn leafPaths.collect { "${it}:publishAllPublicationsToGiteaRepository" }
def url = providers.gradleProperty('packagesUrl')
def artifacts = leaves.collect { it.name } + ['grpc-library']
def coordinates = libraryCoordinates
def verifier = file('scripts/release/verify-published.sh')
doLast {
def command = ['bash', verifier.path, url.get(), coordinates[0], coordinates[1]] + artifacts
def process = command.execute()
process.waitForProcessOutput(System.out, System.err)
if (process.exitValue() != 0) {
throw new GradleException('release: a published module is not readable anonymously (see above).')
}
}
}
// The stages a strict lane may belong to, executed by .gitea/workflows as `./gradlew <stage>` from the
// repository root. releaseCheck may run on a tag push only.
strictLaneStages {
stage ':ci', ':mainCheck', ':releaseCheck'
workflowDirectory = layout.projectDirectory.dir('.gitea/workflows')
}