Make distribution tasks configuration-cache-friendly

Author: 8Keep

build.gradle

@@ -13,6 +13,8 @@ buildscript {
 }
 
 import org.gradle.api.file.RelativePath
+import java.nio.file.Files
+import java.nio.file.StandardCopyOption
 
 // Set the license for IDEs that understand this
 ext.license = file("$rootDir/source-file-header-template.txt")
@@ -25,7 +27,7 @@ allprojects {
         mavenCentral()
         google()
     }
-    tasks.withType(Jar) {
+    tasks.withType(Jar).configureEach {
         duplicatesStrategy = 'include'
     }
 }
@@ -47,7 +49,7 @@ subprojects {
             toolVersion = libs.versions.spotbugs.get()
         }
 
-        tasks.withType(com.github.spotbugs.snom.SpotBugsTask ) {
+        tasks.withType(com.github.spotbugs.snom.SpotBugsTask).configureEach {
             reports {
                 html.required = !project.hasProperty("xml-reports")
                 xml.required = project.hasProperty("xml-reports")
@@ -63,39 +65,57 @@ tasks.register('run') {
 
 defaultTasks 'run'
 
+def fileSystemOperations = services.get(FileSystemOperations)
+def libDistDir = layout.buildDirectory.dir('libDist')
+def libDistArchives = subprojects.collectMany { subproject ->
+    if (subproject.hasProperty('mainClassName')) {
+        return []
+    }
+    subproject.tasks.withType(Jar).matching { task ->
+        task.name == 'jar' ||
+                task.name == 'sourcesJar' ||
+                (buildJavaDoc == "true" && task.name == 'javadocJar')
+    }.collect { archiveTask ->
+        [
+                projectName: subproject.name,
+                archiveFile: archiveTask.archiveFile,
+                archiveClassifier: archiveTask.archiveClassifier,
+                archiveExtension: archiveTask.archiveExtension,
+        ]
+    }
+}
+
 def libDist = tasks.register('libDist') {
-    dependsOn(subprojects.collect { it.tasks.named('build') })
+    dependsOn(libDistArchives.collect { it.archiveFile })
     description = 'Builds and copies the engine binaries, sources and javadoc to build/libDist'
+    inputs.files(libDistArchives.collect { it.archiveFile })
+    outputs.dir(libDistDir)
 
     doLast {
-        File libFolder = mkdir("$buildDir/libDist/lib")
-        File sourceFolder = mkdir("$buildDir/libDist/sources")
-        File javadocFolder = mkdir("$buildDir/libDist/javadoc")
-        subprojects.each {project ->
-            if(!project.hasProperty('mainClassName')){
-                project.tasks.withType(Jar).each {archiveTask ->
-                    String classifier = archiveTask.archiveClassifier.get()
-                    String ext = archiveTask.archiveExtension.get()
-                    File archiveFile = archiveTask.archiveFile.get().asFile
-                    if (classifier == "sources") {
-                        copy {
-                            from archiveFile
-                                into sourceFolder
-                                rename {project.name + '-' + classifier + '.' + ext}
-                        }
-                    } else if (classifier == "javadoc") {
-                        copy {
-                            from archiveFile
-                                into javadocFolder
-                                rename {project.name + '-' + classifier + '.' + ext}
-                        }
-                    } else{
-                        copy {
-                            from archiveFile
-                                into libFolder
-                                rename {project.name + '.' + ext}
-                        }
-                    }
+        File libFolder = libDistDir.get().dir('lib').asFile
+        File sourceFolder = libDistDir.get().dir('sources').asFile
+        File javadocFolder = libDistDir.get().dir('javadoc').asFile
+        libDistArchives.each { archive ->
+            String classifier = archive.archiveClassifier.get()
+            String ext = archive.archiveExtension.get()
+            File archiveFile = archive.archiveFile.get().asFile
+            if (classifier == "sources") {
+                fileSystemOperations.copy {
+                    from archiveFile
+                        into sourceFolder
+                        rename {archive.projectName + '-' + classifier + '.' + ext}
+                }
+            } else if (classifier == "javadoc") {
+                fileSystemOperations.copy {
+                    from archiveFile
+                        into javadocFolder
+                        rename {archive.projectName + '-' + classifier + '.' + ext}
+                }
+            } else{
+                fileSystemOperations.copy {
+                    from archiveFile
+                        into libFolder
+                        rename {archive.projectName + '.' + ext}
                 }
             }
         }
@@ -145,7 +165,13 @@ def mergedJavadocSubprojects = [
         ":jme3-plugins",
         ":jme3-terrain",
 ]
+def mergedJavadocClasspath = providers.provider {
+    mergedJavadocSubprojects.collectMany { projectPath ->
+        project(projectPath).sourceSets.main.compileClasspath.files as List<File>
+    }
+}
 tasks.register('mergedJavadoc', Javadoc) {
+    dependsOn mergedJavadocSubprojects.collect { project(it).tasks.named('classes') }
     description = 'Creates Javadoc from all the projects.'
     title = 'jMonkeyEngine3'
     destinationDir = file("dist/javadoc")
@@ -157,7 +183,7 @@ tasks.register('mergedJavadoc', Javadoc) {
 
     options.overview = file("javadoc-overview.html")
     source = mergedJavadocSubprojects.collect { project(it).sourceSets.main.allJava }
-    classpath = files(mergedJavadocSubprojects.collect { project(it).sourceSets.main.compileClasspath })
+    classpath = files(mergedJavadocClasspath)
 }
 
 def cleanMergedJavadoc = tasks.register('cleanMergedJavadoc', Delete) {
@@ -197,45 +223,40 @@ gradle.rootProject.ext.set("usePrebuildNatives", buildNativeProjects!="true");
 
 if (skipPrebuildLibraries != "true" && buildNativeProjects != "true") {
     File nativesSnapshotPropF = file('natives-snapshot.properties')
+    String prebuildNativesUrlTemplate = PREBUILD_NATIVES_URL
 
     if (nativesSnapshotPropF.exists()) {
-        def readNativesConfig = {
-            Properties nativesSnapshotProp = new Properties()
-            nativesSnapshotPropF.withInputStream { nativesSnapshotProp.load(it) }
-
-            String nativesSnapshot = nativesSnapshotProp.getProperty("natives.snapshot")
-            if (!nativesSnapshot) {
-                throw new GradleException("Missing 'natives.snapshot' in ${nativesSnapshotPropF}")
-            }
+        Properties nativesSnapshotProp = new Properties()
+        nativesSnapshotPropF.withInputStream { nativesSnapshotProp.load(it) }
 
-            [
-                snapshot: nativesSnapshot,
-                url: PREBUILD_NATIVES_URL.replace('${natives.snapshot}', nativesSnapshot),
-                zipFile: layout.buildDirectory.file("${nativesSnapshot}-natives.zip"),
-                nativeDir: layout.buildDirectory.dir("native"),
-            ]
+        String nativesSnapshot = nativesSnapshotProp.getProperty("natives.snapshot")
+        if (!nativesSnapshot) {
+            throw new GradleException("Missing 'natives.snapshot' in ${nativesSnapshotPropF}")
         }
 
-        def nativesZipFile = providers.provider { readNativesConfig().zipFile.get().asFile }
+        String nativesUrl = prebuildNativesUrlTemplate.replace('${natives.snapshot}', nativesSnapshot)
+        File nativesZipFile = layout.buildDirectory.file("${nativesSnapshot}-natives.zip").get().asFile
         def nativesPath = layout.buildDirectory.dir("native")
 
         def getNativesZipFile = tasks.register('getNativesZipFile') {
+            inputs.property('nativesUrl', nativesUrl)
             outputs.file(nativesZipFile)
             doFirst {
-                def nativesConfig = readNativesConfig()
-                File target = nativesConfig.zipFile.get().asFile
-                println("Use natives snapshot: ${nativesConfig.url}")
-                println("Download natives from ${nativesConfig.url} to ${target}")
-                target.getParentFile().mkdirs()
-                ant.get(src: nativesConfig.url, dest: target)
+                println("Use natives snapshot: ${nativesUrl}")
+                println("Download natives from ${nativesUrl} to ${nativesZipFile}")
+                nativesZipFile.getParentFile().mkdirs()
+                File tempFile = new File(nativesZipFile.parentFile, "${nativesZipFile.name}.part")
+                tempFile.delete()
+                ant.get(src: nativesUrl, dest: tempFile)
+                Files.move(tempFile.toPath(), nativesZipFile.toPath(), StandardCopyOption.REPLACE_EXISTING)
             }
         }
 
         def extractPrebuiltNatives = tasks.register('extractPrebuiltNatives', Sync) {
             dependsOn(getNativesZipFile)
             into(nativesPath)
             from({
-                zipTree(readNativesConfig().zipFile.get().asFile)
+                zipTree(nativesZipFile)
             }) {
                 eachFile { details ->
                     def segments = details.relativePath.segments

gradle.properties

@@ -15,6 +15,11 @@ includeBranchInVersion = false
 # specify if JavaDoc should be built
 buildJavaDoc = false
 
+# Gradle performance defaults
+org.gradle.parallel=true
+org.gradle.caching=true
+org.gradle.configuration-cache=true
+
 # specify if SDK and Native libraries get built
 buildNativeProjects = false
 buildAndroidExamples = false

jme3-android-native/build.gradle

@@ -33,3 +33,14 @@ ext {
 apply from: file('openalsoft.gradle')
 apply from: file('decode.gradle')
 apply from: file('bufferallocator.gradle')
+
+def androidCompileJava = project(':jme3-android').tasks.named('compileJava')
+tasks.named('copyJmeHeadersOpenAL') {
+    dependsOn androidCompileJava
+}
+tasks.named('copyJmeHeadersDecode') {
+    dependsOn androidCompileJava
+}
+tasks.named('copyJmeHeadersBufferAllocator') {
+    dependsOn androidCompileJava
+}

jme3-examples/build.gradle

@@ -3,8 +3,23 @@ ext.mainClassName = examplesMainClassName
 
 def androidProject = project(':jme3-android')
 def androidNativeProject = project(':jme3-android-native')
+def androidProjectName = androidProject.name
+def androidNativeProjectName = androidNativeProject.name
+def fileSystemOperations = services.get(FileSystemOperations)
+def compileClasspath = configurations.compileClasspath
+def compileClasspathArtifacts = providers.provider {
+    compileClasspath.resolvedConfiguration.resolvedArtifacts.collect { artifact ->
+        [
+                file: artifact.file,
+                fileName: artifact.classifier != null ?
+                        "${artifact.name}-${artifact.classifier}.${artifact.extension}" :
+                        "${artifact.name}.${artifact.extension}",
+        ]
+    }
+}
 
-task run(dependsOn: 'build', type:JavaExec) {
+tasks.register('run', JavaExec) {
+    dependsOn sourceSets.main.runtimeClasspath
     mainClass = examplesMainClassName
     classpath = sourceSets.main.runtimeClasspath
 
@@ -49,45 +64,48 @@ jar.doFirst{
 //                'Implementation-Vendor'  : vendor,
                 'Main-Class'             : examplesMainClassName,
                 // Add dependencies to manifest, remove version
-                'Class-Path'             : configurations.compileClasspath.resolvedConfiguration.resolvedArtifacts.collect {
-                                                        'lib/' +
-                                                        it.name +
-                                                        (it.classifier != null ? '-' + it.classifier : '') +
-                                                        '.' + it.extension }.join(' ')
+                'Class-Path'             : compileClasspathArtifacts.get().collect { 'lib/' + it.fileName }.join(' ')
         )
     }
 }
 
-task dist (dependsOn: ['build', ':jme3-android:jar', ':jme3-android-native:jar']) {
+tasks.register('dist') {
+    dependsOn 'build', ':jme3-android:jar', ':jme3-android-native:jar'
+    def examplesJar = tasks.named('jar', Jar).flatMap { it.archiveFile }
+    def androidJar = androidProject.tasks.named('jar', Jar).flatMap { it.archiveFile }
+    def androidNativeJar = androidNativeProject.tasks.named('jar', Jar).flatMap { it.archiveFile }
+    def distDir = rootProject.layout.projectDirectory.dir('dist')
+
+    inputs.files(compileClasspathArtifacts.map { artifacts -> artifacts.collect { it.file } })
+    inputs.files(examplesJar, androidJar, androidNativeJar)
+    outputs.dir(distDir)
+
     doLast {
         // Copy all dependencies to ../dist/lib, remove versions from jar files
-        configurations.compileClasspath.resolvedConfiguration.resolvedArtifacts.each { artifact ->
-            copy {
+        compileClasspathArtifacts.get().each { artifact ->
+            fileSystemOperations.copy {
+                duplicatesStrategy = DuplicatesStrategy.INCLUDE
                 from artifact.file
-                into '../dist/lib'
-                if(artifact.classifier != null){
-                    rename { "${artifact.name}-${artifact.classifier}.${artifact.extension}" }
-                } else{
-                    rename { "${artifact.name}.${artifact.extension}" }
-                }
+                into distDir.dir('lib')
+                rename { artifact.fileName }
             }
         }
-        copy {
-            from tasks.named('jar').flatMap { it.archiveFile }
-            into '../dist'
+        fileSystemOperations.copy {
+            from examplesJar
+            into distDir
             rename { "jMonkeyEngine3.jar" }
         }
 
         // Copy android packages, remove version
-        copy {
-            from androidProject.tasks.named('jar').flatMap { it.archiveFile }
-            into '../dist/opt/android'
-            rename { androidProject.name + ".jar" }
+        fileSystemOperations.copy {
+            from androidJar
+            into distDir.dir('opt/android')
+            rename { androidProjectName + ".jar" }
         }
-        copy {
-            from androidNativeProject.tasks.named('jar').flatMap { it.archiveFile }
-            into '../dist/opt/android'
-            rename { androidNativeProject.name + ".jar" }
+        fileSystemOperations.copy {
+            from androidNativeJar
+            into distDir.dir('opt/android')
+            rename { androidNativeProjectName + ".jar" }
         }
     }
 }

jme3-ios-native/build.gradle

@@ -4,14 +4,17 @@ def deleteXcframework = tasks.register('deleteXcframework', Delete) {
     delete 'template/META-INF/robovm/ios/libs/jme3-ios-native.xcframework'
 }
 
+def iosDeviceDerivedDataPath = layout.buildDirectory.dir('derivedData/ios')
+def iosSimulatorDerivedDataPath = layout.buildDirectory.dir('derivedData/ios-simulator')
+
 def buildNativeLibIos = tasks.register('buildNativeLibIos', Exec) {
     executable "xcodebuild"
-    args 'archive', '-project', 'jme3-ios-native.xcodeproj', '-scheme', 'jme3-ios-native', '-configuration', 'release', '-destination', 'generic/platform=iOS', '-archivePath', 'build/archives/jme3-ios-native_iOS', 'SKIP_INSTALL=NO', 'BUILD_LIBRARY_FOR_DISTRIBUTION=YES'
+    args 'archive', '-project', 'jme3-ios-native.xcodeproj', '-scheme', 'jme3-ios-native', '-configuration', 'release', '-destination', 'generic/platform=iOS', '-derivedDataPath', iosDeviceDerivedDataPath.get().asFile.absolutePath, '-archivePath', 'build/archives/jme3-ios-native_iOS', 'SKIP_INSTALL=NO', 'BUILD_LIBRARY_FOR_DISTRIBUTION=YES'
 }
 
 def buildNativeLibSimulator = tasks.register('buildNativeLibSimulator', Exec) {
     executable "xcodebuild"
-    args 'archive', '-project', 'jme3-ios-native.xcodeproj', '-scheme', 'jme3-ios-native', '-configuration', 'release', '-destination', 'generic/platform=iOS Simulator', '-archivePath', 'build/archives/jme3-ios-native_iOS-Simulator', 'SKIP_INSTALL=NO', 'BUILD_LIBRARY_FOR_DISTRIBUTION=YES'
+    args 'archive', '-project', 'jme3-ios-native.xcodeproj', '-scheme', 'jme3-ios-native', '-configuration', 'release', '-destination', 'generic/platform=iOS Simulator', '-derivedDataPath', iosSimulatorDerivedDataPath.get().asFile.absolutePath, '-archivePath', 'build/archives/jme3-ios-native_iOS-Simulator', 'SKIP_INSTALL=NO', 'BUILD_LIBRARY_FOR_DISTRIBUTION=YES'
 }
 
 def buildNativeLib = tasks.register('buildNativeLib', Exec) {