| /* |
| * 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 |
| * |
| * http://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. |
| */ |
| import org.apache.geode.gradle.plugins.DependencyConstraints |
| |
| if (project.name.endsWith("geode-all-bom")) { |
| // This anti-pattern is a workaround -- java-platform must be applied before java or java-library |
| // to avoid conflicts over redefining certain configurations. |
| // Evaluation as to whether java-platform should be applied at all is left to GEODE-6611. |
| apply plugin: 'java-platform' |
| } |
| apply plugin: 'java-library' |
| |
| sourceCompatibility = 1.8 |
| targetCompatibility = 1.8 |
| compileJava.options.encoding = 'UTF-8' |
| |
| dependencies { |
| // log4j-core has an annotation processor that is passed on the compile-classpath via geode-core and others. |
| // Fix Gradle warning here until we clean up our own classpath |
| annotationProcessor 'org.apache.logging.log4j:log4j-core:' + DependencyConstraints.get('log4j.version') |
| } |
| |
| String javaVersion = System.properties['java.version'] |
| if (javaVersion.startsWith("1.8.0") && javaVersion.split("-")[0].split("_")[1].toInteger() < 121) { |
| throw new GradleException("Java version 1.8.0_121 or later required, but was " + javaVersion) |
| } |
| |
| // apply compiler options |
| gradle.taskGraph.whenReady({ graph -> |
| tasks.withType(JavaCompile).each { javac -> |
| javac.configure { |
| sourceCompatibility '1.8' |
| targetCompatibility '1.8' |
| options.encoding = 'UTF-8' |
| } |
| javac.options.incremental = true |
| javac.options.fork = true |
| javac.options.forkOptions.with({ |
| memoryMaximumSize = "768m" |
| }) |
| if (project.hasProperty('compileJVM') && !compileJVM.trim().isEmpty()) { |
| javac.options.forkOptions.executable = compileJVM + "/bin/javac" |
| } |
| } |
| }) |
| |
| // apply default manifest |
| gradle.taskGraph.whenReady({ graph -> |
| tasks.withType(Jar).each { jar -> |
| |
| def projectDependencies = [] |
| def runtimeList = [] |
| def allProjectDeps = [] |
| |
| def confList = ['api', 'implementation', 'runtimeOnly'] |
| confList.each { conf -> |
| allProjectDeps.addAll(project.configurations.getByName(conf).getDependencies()) |
| } |
| |
| // Iterate over runtime classpath dependencies and separate project dependencies from library |
| // dependencies. |
| allProjectDeps.each { dependency -> |
| if ( dependency instanceof ProjectDependency ) { |
| def platformAttribute = Attribute.of("org.gradle.category", org.gradle.api.attributes.Category.class) |
| def foundAttribute = dependency.attributes.getAttribute(platformAttribute) |
| if ( foundAttribute == null) { |
| projectDependencies.add(dependency) |
| } else if ('platform'.equals(foundAttribute)) { |
| projectDependencies.add(dependency) |
| } |
| } else { |
| project.configurations.runtimeClasspath.files(dependency).each { depJar -> |
| runtimeList.add(depJar.name) |
| } |
| } |
| } |
| |
| // Iterate over project (parent) dependencies and remove its runtime library dependencies from |
| // the current project's runtime library dependencies. |
| // Also removes all parent project's runtime project dependencies from the current project. |
| // This returns a unique set of parent project and library dependencies that are not found |
| // within it's parent's project dependencies. |
| projectDependencies.clone().each { ProjectDependency projectDependency -> |
| Project geodeProject = projectDependency.getDependencyProject() |
| def collect = geodeProject.configurations.runtimeClasspath.collect { it.name } |
| runtimeList.removeAll(collect) |
| // projectDependencies.removeAll(collect.collect {it-".jar"}) |
| } |
| |
| jar.doFirst { |
| manifest { |
| attributes.put("Manifest-Version", "1.0") |
| attributes.put("Created-By", System.getProperty("user.name")) |
| attributes.put("Title", rootProject.name) |
| attributes.put("Version", version) |
| attributes.put("Organization", productOrg) |
| attributes.put("Class-Path", runtimeList.join(' ')) |
| attributes.put("Dependent-Modules", projectDependencies.collect({ "${it.name}-${it.version}" }).join(' ')) |
| attributes.put("Module-Name", project.name) |
| } |
| } |
| jar.metaInf { |
| from("$rootDir/geode-assembly/src/main/dist/LICENSE") |
| if (jar.source.filter({ it.name.contains('NOTICE') }).empty) { |
| from("$rootDir/NOTICE") |
| } |
| } |
| } |
| }) |
| |
| configurations { |
| testOutput { |
| extendsFrom testCompile |
| description 'a dependency that exposes test artifacts' |
| } |
| } |
| |
| // This ensures that javadoc and source jars also have any prefix paths stripped and will |
| // be created as libs/foo-sources.jar instead of libs/extensions/foo-sources.jar for example. |
| tasks.all { task -> |
| if (task instanceof Jar) { |
| baseName = project.name |
| } |
| } |
| |
| task jarTest(type: Jar, dependsOn: testClasses) { |
| description 'Assembles a jar archive of test classes.' |
| from sourceSets.test.output |
| classifier 'test' |
| } |
| |
| artifacts { |
| testOutput jarTest |
| } |
| |
| javadoc { |
| destinationDir = file("$buildDir/javadoc") |
| options.addStringOption('Xdoclint:none', '-quiet') |
| options.encoding = 'UTF-8' |
| exclude "**/internal/**" |
| |
| classpath += configurations.compileOnly |
| } |
| |
| |