Merge branch '7.1.x' into 8.0.x

Author: jdaugherty

.github/workflows/release.yml

@@ -285,6 +285,7 @@ jobs:
           grails
           -x 'grails/.git/*'
           -x 'grails/.github/*'
+          -x 'grails/.mailmap'
       - name: "🔐 Set up GPG" # use env var to not expose the key
         env:
           GPG_KEY: ${{ secrets.GRAILS_GPG_KEY }}

.mailmap

@@ -489,12 +489,12 @@ Some common gotchas with Java build reproducibility problems:
    not ship property files with dynamic timestamps.
 4. Gradle builds are not reproducible by default because Gradle does not guarantee file ordering. Grails configures all
    tasks that create archive files to ensure file ordering is reproducible. This configuration can be found in
-   `gradle/java-config.gradle`
+   the `CompilePlugin` in the `build-logic` project.
 5. Grails makes heavy use of Groovy AST transforms. These transforms often lookup methods on a class, and the methods
    returned by Java will vary by operating system. Any code using reflection to lookup methods or fields must sort the
    results to ensure reproducibility.
 6. Javadoc / Groovydoc will by default write out dates in it's documentation headers. Grails configures these settings
-   in `gradle/java-config.gradle`.
+   in the `CompilePlugin` in the `build-logic` project.
 
 After a build is made reproducible on the same machine, the next step is to ensure it's reproducible in GitHub actions.
 OS differences will exist and even exist between different Docker Runtimes. To help test reproducible builds, we found

RELEASE.md

@@ -42,13 +42,21 @@ dependencies {
 
 gradlePlugin {
     plugins {
-        publishPlugin {
+        register('compilePlugin') {
+            id = 'org.apache.grails.buildsrc.compile'
+            implementationClass = 'org.apache.grails.buildsrc.CompilePlugin'
+        }
+        register('publishPlugin') {
             id = 'org.apache.grails.buildsrc.publish'
             implementationClass = 'org.apache.grails.buildsrc.PublishPlugin'
         }
-        sbomPlugin {
+        register('sbomPlugin') {
             id = 'org.apache.grails.buildsrc.sbom'
             implementationClass = 'org.apache.grails.buildsrc.SbomPlugin'
         }
+        register('sharedPropertyPlugin') {
+            id = 'org.apache.grails.buildsrc.properties'
+            implementationClass = 'org.apache.grails.buildsrc.SharedPropertyPlugin'
+        }
     }
 }

build-logic/plugins/build.gradle

@@ -0,0 +1,135 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+
+package org.apache.grails.buildsrc
+
+import java.nio.charset.StandardCharsets
+import java.util.concurrent.atomic.AtomicBoolean
+
+import groovy.transform.CompileStatic
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.file.DuplicatesStrategy
+import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.api.tasks.bundling.AbstractArchiveTask
+import org.gradle.api.tasks.bundling.Jar
+import org.gradle.api.tasks.compile.GroovyCompile
+import org.gradle.api.tasks.compile.JavaCompile
+import org.gradle.api.tasks.javadoc.Javadoc
+import org.gradle.external.javadoc.StandardJavadocDocletOptions
+
+import static org.apache.grails.buildsrc.GradleUtils.lookupPropertyByType
+
+@CompileStatic
+class CompilePlugin implements Plugin<Project> {
+
+    @Override
+    void apply(Project project) {
+        def initialized = new AtomicBoolean(false)
+        project.plugins.withId('java') { // java (applied when groovy is applied) or java-library
+            if (initialized.compareAndSet(false, true)) {
+                configureCompile(project)
+            }
+        }
+    }
+
+    private static void configureCompile(Project project) {
+        configureJavaVersion(project)
+        configureJars(project)
+        configureCompiler(project)
+        configureReproducible(project)
+    }
+
+    private static void configureJavaVersion(Project project) {
+        project.tasks.withType(JavaCompile).configureEach {
+            it.options.release.set(lookupPropertyByType(project, 'javaVersion', Integer))
+        }
+    }
+
+    private static void configureJars(Project project) {
+        project.extensions.configure(JavaPluginExtension) {
+            it.withJavadocJar()
+            it.withSourcesJar()
+        }
+
+        // Grails determines the grails version via the META-INF/MANIFEST.MF file
+        // Note: we exclude attributes such as Built-By, Build-Jdk, Created-By to ensure the build is reproducible.
+        project.tasks.withType(Jar).configureEach { Jar jar ->
+            if (lookupPropertyByType(project, 'skipJavaComponent', Boolean)) {
+                jar.enabled = false
+                return
+            }
+
+            jar.manifest.attributes(
+                    'Implementation-Title': 'Apache Grails',
+                    'Implementation-Version': lookupPropertyByType(project, 'grailsVersion', String),
+                    'Implementation-Vendor': 'grails.apache.org'
+            )
+            // Explicitly fail since duplicates indicate a double configuration that needs fixed
+            jar.duplicatesStrategy = DuplicatesStrategy.FAIL
+        }
+    }
+
+    private static void configureCompiler(Project project) {
+        project.tasks.withType(JavaCompile).configureEach {
+            // Preserve method parameter names in Groovy/Java classes for IDE parameter hints & bean reflection metadata.
+            it.options.compilerArgs.add('-parameters')
+            // encoding needs to be the same since it's different across platforms
+            it.options.encoding = StandardCharsets.UTF_8.name()
+            it.options.fork = true
+            it.options.forkOptions.jvmArgs = ['-Xms128M', '-Xmx2G']
+        }
+
+        project.plugins.withId('groovy') {
+            project.tasks.withType(GroovyCompile).configureEach {
+                // encoding needs to be the same since it's different across platforms
+                it.groovyOptions.encoding = StandardCharsets.UTF_8.name()
+                // Preserve method parameter names in Groovy/Java classes for IDE parameter hints & bean reflection metadata.
+                it.groovyOptions.parameters = true
+                // encoding needs to be the same since it's different across platforms
+                it.options.encoding = StandardCharsets.UTF_8.name()
+                it.options.fork = true
+                it.options.forkOptions.jvmArgs = ['-Xms128M', '-Xmx2G']
+            }
+        }
+    }
+
+    private static void configureReproducible(Project project) {
+        project.tasks.withType(Javadoc).configureEach { Javadoc it ->
+            def options = it.options as StandardJavadocDocletOptions
+            options.noTimestamp = true
+            options.bottom = "Generated ${lookupPropertyByType(project, 'formattedBuildDate', String)} (UTC)"
+        }
+
+        // Any jar, zip, or archive should be reproducible
+        // No longer needed after https://github.com/gradle/gradle/issues/30871
+        project.tasks.withType(AbstractArchiveTask).configureEach {
+            it.preserveFileTimestamps = false // to prevent timestamp mismatches
+            it.reproducibleFileOrder = true // to keep the same ordering
+            // to avoid platform specific defaults, set the permissions consistently
+            it.filePermissions { permissions ->
+                permissions.unix(0644)
+            }
+            it.dirPermissions { permissions ->
+                permissions.unix(0755)
+            }
+        }
+    }
+}

build-logic/plugins/src/main/groovy/org/apache/grails/buildsrc/CompilePlugin.groovy

@@ -27,18 +27,42 @@ import org.gradle.api.file.Directory
 class GradleUtils {
 
     static Directory findRootGrailsCoreDir(Project project) {
-        def rootLayout = project.rootProject.layout
         // .github / .git related directories are purged from source releases, so use the .asf.yaml as an indicator of
         // the parent directory
-        if (rootLayout.projectDirectory.file('.asf.yaml').asFile.exists()) {
-            return rootLayout.projectDirectory
-        }
+        findAsfRootDir(project.layout.projectDirectory)
+    }
 
-        // we currently only nest 1 project level deep
-        rootLayout.projectDirectory.dir('../')
+    static Directory findAsfRootDir(Directory currentDirectory) {
+        def asfFile = currentDirectory.file('.asf.yaml').asFile
+        asfFile.exists() ? currentDirectory : findAsfRootDir(currentDirectory.dir('../'))
     }
 
     static <T> T lookupProperty(Project project, String name, T defaultValue = null) {
-        project.findProperty(name) as T ?: defaultValue
+        T v = lookupPropertyByType(project, name, defaultValue?.class) as T
+        return v == null ? defaultValue : v
+    }
+
+    static <T> T lookupPropertyByType(Project project, String name, Class<T> type) {
+        // a cast exception will occur without this
+        if (type && (type == Integer || type == int.class)) {
+            def v = findProperty(project, name)
+            return v == null ? null : Integer.valueOf(v as String) as T
+        }
+
+        findProperty(project, name) as T
+    }
+
+    static Object findProperty(Project project, String name) {
+        def property = project.findProperty(name)
+        if (property != null) {
+            return property
+        }
+
+        def ext = project.extensions.extraProperties
+        if (ext.has(name)) {
+            return ext.get(name)
+        }
+
+        null
     }
 }