mirror of
https://github.com/corda/corda.git
synced 2024-12-19 21:17:58 +00:00
406f7ff292
This requires Kotlin 1.2 versions of core and serialization (core-1.2 and serialization-1.2 respectively), which are just "shell" modules and which compile the existing source code with Kotlin 1.2. The 1.2 plugin does not work with the current version of Gradle and so the 1.2 compiler has to be called directly. Now with two versions of Kotlin in the code base, each module needs to have its version manually specified to ensure a clean separation. Otherwise, the default Kotlin version can override 1.2 when needed. Some of the code was tidied-up or improved to enable it to be cross-compiled. For post-1.2 APIs being used, they have been copied into core-1.2 with the same method signatures. OpenTelemetryComponent was moved to node-api, along with the dependency, to avoid also having a 1.2 version for the opentelemetry module.
696 lines
30 KiB
Groovy
696 lines
30 KiB
Groovy
import com.r3.testing.DistributeTestsBy
|
|
import com.r3.testing.PodLogLevel
|
|
import net.corda.plugins.apiscanner.GenerateApi
|
|
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
|
|
|
|
import static org.gradle.api.JavaVersion.VERSION_17
|
|
import static org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
|
|
import static org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_8
|
|
|
|
buildscript {
|
|
// For sharing constants between builds
|
|
Properties constants = new Properties()
|
|
file("$projectDir/constants.properties").withInputStream { constants.load(it) }
|
|
|
|
// Our version: bump this on release.
|
|
ext.baseVersion = constants.getProperty("cordaVersion")
|
|
ext.versionSuffix = constants.getProperty("versionSuffix")
|
|
|
|
ext.corda_build_edition = System.getenv("CORDA_BUILD_EDITION")?.trim() ?: "Corda Open Source"
|
|
ext.corda_platform_version = constants.getProperty("platformVersion")
|
|
ext.corda_shell_version = constants.getProperty("cordaShellVersion")
|
|
ext.gradle_plugins_version = constants.getProperty("gradlePluginsVersion")
|
|
|
|
// Dependency versions. Can run 'gradle dependencyUpdates' to find new versions of things.
|
|
//
|
|
// TODO: Sort this alphabetically.
|
|
ext.warnings_as_errors = project.hasProperty("compilation.warningsAsErrors") ? project.property("compilation.warningsAsErrors").toBoolean() : false
|
|
|
|
ext.quasar_group = 'co.paralleluniverse'
|
|
// Set version of Quasar according to version of Java used:
|
|
ext.quasar_version = constants.getProperty("quasarVersion")
|
|
ext.quasar_classifier = constants.getProperty("quasarClassifier")
|
|
ext.quasar_exclusions = [
|
|
'co.paralleluniverse**',
|
|
'groovy**',
|
|
'com.esotericsoftware.**',
|
|
'jdk**',
|
|
'junit**',
|
|
'kotlin**',
|
|
'net.rubygrapefruit.**',
|
|
'org.gradle.**',
|
|
'org.apache.**',
|
|
'org.jacoco.**',
|
|
'org.junit**',
|
|
'org.slf4j**',
|
|
'worker.org.gradle.**',
|
|
'org.mockito.kotlin**',
|
|
'org.assertj**',
|
|
'org.hamcrest**',
|
|
'org.mockito**',
|
|
'org.opentest4j**'
|
|
]
|
|
|
|
ext.capsule_version = constants.getProperty("capsuleVersion")
|
|
ext.open_telemetry_version = constants.getProperty("openTelemetryVersion")
|
|
ext.open_telemetry_sem_conv_version = constants.getProperty("openTelemetrySemConvVersion")
|
|
ext.asm_version = constants.getProperty("asmVersion")
|
|
ext.artemis_version = constants.getProperty("artemisVersion")
|
|
ext.jackson_version = constants.getProperty("jacksonVersion")
|
|
ext.jackson_kotlin_version = constants.getProperty("jacksonKotlinVersion")
|
|
ext.jetty_version = constants.getProperty("jettyVersion")
|
|
ext.jersey_version = constants.getProperty("jerseyVersion")
|
|
ext.servlet_version = constants.getProperty("servletVersion")
|
|
ext.assertj_version = constants.getProperty("assertjVersion")
|
|
ext.slf4j_version = constants.getProperty("slf4JVersion")
|
|
ext.log4j_version = constants.getProperty("log4JVersion")
|
|
ext.bouncycastle_version = constants.getProperty("bouncycastleVersion")
|
|
ext.guava_version = constants.getProperty("guavaVersion")
|
|
ext.caffeine_version = constants.getProperty("caffeineVersion")
|
|
ext.disruptor_version = constants.getProperty("disruptorVersion")
|
|
ext.metrics_version = constants.getProperty("metricsVersion")
|
|
ext.metrics_new_relic_version = constants.getProperty("metricsNewRelicVersion")
|
|
ext.okhttp_version = constants.getProperty("okhttpVersion")
|
|
ext.netty_version = constants.getProperty("nettyVersion")
|
|
ext.tcnative_version = constants.getProperty("tcnativeVersion")
|
|
ext.typesafe_config_version = constants.getProperty("typesafeConfigVersion")
|
|
ext.fileupload_version = constants.getProperty("fileuploadVersion")
|
|
ext.kryo_version = constants.getProperty("kryoVersion")
|
|
ext.kryo_serializer_version = constants.getProperty("kryoSerializerVersion")
|
|
ext.junit_version = constants.getProperty("junitVersion")
|
|
ext.junit_vintage_version = constants.getProperty("junitVintageVersion")
|
|
ext.junit_jupiter_version = constants.getProperty("junitJupiterVersion")
|
|
ext.junit_platform_version = constants.getProperty("junitPlatformVersion")
|
|
ext.mockito_version = constants.getProperty("mockitoVersion")
|
|
ext.mockito_kotlin_version = constants.getProperty("mockitoKotlinVersion")
|
|
ext.hamkrest_version = constants.getProperty("hamkrestVersion")
|
|
ext.jopt_simple_version = constants.getProperty("joptSimpleVersion")
|
|
ext.jansi_version = constants.getProperty("jansiVersion")
|
|
ext.hibernate_version = constants.getProperty("hibernateVersion")
|
|
ext.h2_version = constants.getProperty("h2Version")
|
|
ext.rxjava_version = constants.getProperty("rxjavaVersion")
|
|
ext.dokka_version = constants.getProperty("dokkaVersion")
|
|
ext.eddsa_version = constants.getProperty("eddsaVersion")
|
|
ext.dependency_checker_version = constants.getProperty("dependencyCheckerVersion")
|
|
ext.commons_collections_version = constants.getProperty("commonsCollectionsVersion")
|
|
ext.beanutils_version = constants.getProperty("beanutilsVersion")
|
|
ext.jsr305_version = constants.getProperty("jsr305Version")
|
|
ext.shiro_version = constants.getProperty("shiroVersion")
|
|
ext.artifactory_plugin_version = constants.getProperty('artifactoryPluginVersion')
|
|
ext.hikari_version = constants.getProperty("hikariVersion")
|
|
ext.liquibase_version = constants.getProperty("liquibaseVersion")
|
|
ext.artifactory_contextUrl = 'https://software.r3.com/artifactory'
|
|
ext.publicArtifactURL = 'https://download.corda.net/maven'
|
|
ext.docker_compose_rule_version = constants.getProperty("dockerComposeRuleVersion")
|
|
ext.selenium_version = constants.getProperty("seleniumVersion")
|
|
ext.ghostdriver_version = constants.getProperty("ghostdriverVersion")
|
|
ext.proguard_version = constants.getProperty('proguardVersion')
|
|
ext.jsch_version = constants.getProperty("jschVersion")
|
|
ext.protonj_version = constants.getProperty("protonjVersion")
|
|
ext.snappy_version = constants.getProperty("snappyVersion")
|
|
ext.class_graph_version = constants.getProperty('classgraphVersion')
|
|
ext.jcabi_manifests_version = constants.getProperty("jcabiManifestsVersion")
|
|
ext.picocli_version = constants.getProperty("picocliVersion")
|
|
ext.commons_io_version = constants.getProperty("commonsIoVersion")
|
|
ext.controlsfx_version = constants.getProperty("controlsfxVersion")
|
|
ext.detekt_version = constants.getProperty('detektVersion')
|
|
ext.docker_java_version = constants.getProperty("dockerJavaVersion")
|
|
ext.commons_configuration2_version = constants.getProperty("commonsConfiguration2Version")
|
|
ext.commons_text_version = constants.getProperty("commonsTextVersion")
|
|
ext.snake_yaml_version = constants.getProperty("snakeYamlVersion")
|
|
ext.fontawesomefx_commons_version = constants.getProperty("fontawesomefxCommonsVersion")
|
|
ext.fontawesomefx_fontawesome_version = constants.getProperty("fontawesomefxFontawesomeVersion")
|
|
ext.javaassist_version = constants.getProperty("javaassistVersion")
|
|
ext.test_add_opens = [
|
|
'--add-opens', 'java.base/java.time=ALL-UNNAMED',
|
|
'--add-opens', 'java.base/java.io=ALL-UNNAMED',
|
|
'--add-opens', 'java.base/java.util=ALL-UNNAMED',
|
|
'--add-opens', 'java.base/java.net=ALL-UNNAMED',
|
|
'--add-opens', 'java.base/java.nio=ALL-UNNAMED',
|
|
'--add-opens', 'java.base/java.lang.invoke=ALL-UNNAMED',
|
|
'--add-opens', 'java.base/java.security.cert=ALL-UNNAMED',
|
|
'--add-opens', 'java.base/java.security=ALL-UNNAMED',
|
|
'--add-opens', 'java.base/javax.net.ssl=ALL-UNNAMED',
|
|
'--add-opens', 'java.base/java.lang=ALL-UNNAMED',
|
|
'--add-opens', 'java.base/java.util.concurrent=ALL-UNNAMED',
|
|
'--add-opens', 'java.sql/java.sql=ALL-UNNAMED'
|
|
]
|
|
ext.test_add_exports = [
|
|
'--add-exports', 'java.base/sun.nio.ch=ALL-UNNAMED'
|
|
]
|
|
|
|
ext.corda_revision = {
|
|
try {
|
|
"git rev-parse HEAD".execute().text.trim()
|
|
} catch (Exception ignored) {
|
|
logger.warn("git is unavailable in build environment")
|
|
"unknown"
|
|
}
|
|
}()
|
|
ext.corda_docs_link = "https://docs.corda.net/docs/corda-os/$baseVersion"
|
|
repositories {
|
|
mavenLocal()
|
|
// Use system environment to activate caching with Artifactory,
|
|
// because it is actually easier to pass that during parallel build.
|
|
// NOTE: it has to be a name of a virtual repository with all
|
|
// required remote or local repositories!
|
|
if (System.getenv("CORDA_USE_CACHE")) {
|
|
maven {
|
|
name "R3 Maven remote repositories"
|
|
url "${artifactory_contextUrl}/${System.getenv("CORDA_USE_CACHE")}"
|
|
authentication {
|
|
basic(BasicAuthentication)
|
|
}
|
|
credentials {
|
|
username = System.getenv('CORDA_ARTIFACTORY_USERNAME')
|
|
password = System.getenv('CORDA_ARTIFACTORY_PASSWORD')
|
|
}
|
|
}
|
|
} else {
|
|
maven {
|
|
url "${publicArtifactURL}/corda-dependencies-dev"
|
|
content {
|
|
includeGroupByRegex 'net\\.corda(\\..*)?'
|
|
includeGroupByRegex 'com\\.r3(\\..*)?'
|
|
includeGroup 'co.paralleluniverse'
|
|
}
|
|
}
|
|
maven {
|
|
url "${publicArtifactURL}/corda-releases"
|
|
content {
|
|
includeGroupByRegex 'net\\.corda(\\..*)?'
|
|
includeGroupByRegex 'com\\.r3(\\..*)?'
|
|
}
|
|
}
|
|
mavenCentral()
|
|
jcenter()
|
|
}
|
|
}
|
|
dependencies {
|
|
classpath "net.corda.plugins:quasar-utils:$gradle_plugins_version"
|
|
classpath "net.corda.plugins:cordformation:$gradle_plugins_version"
|
|
classpath "net.corda.plugins:cordapp:$gradle_plugins_version"
|
|
classpath "net.corda.plugins:api-scanner:$gradle_plugins_version"
|
|
classpath "net.corda.plugins:jar-filter:$gradle_plugins_version"
|
|
classpath "com.guardsquare:proguard-gradle:$proguard_version"
|
|
classpath 'com.github.ben-manes:gradle-versions-plugin:0.15.0'
|
|
classpath "org.jetbrains.dokka:dokka-base:$dokka_version"
|
|
classpath "net.i2p.crypto:eddsa:$eddsa_version" // Needed for ServiceIdentityGenerator in the build environment.
|
|
classpath "org.owasp:dependency-check-gradle:$dependency_checker_version"
|
|
classpath "org.jfrog.buildinfo:build-info-extractor-gradle:$artifactory_plugin_version"
|
|
// Capsule gradle plugin forked and maintained locally to support Gradle 5.x
|
|
// See https://github.com/corda/gradle-capsule-plugin
|
|
classpath "us.kirchmeier:gradle-capsule-plugin:1.0.5_r3"
|
|
classpath group: "com.r3.testing", name: "gradle-distributed-testing-plugin", version: '1.3.0'
|
|
classpath "org.sonarsource.scanner.gradle:sonarqube-gradle-plugin:2.8"
|
|
}
|
|
|
|
configurations.classpath {
|
|
// FORCE Gradle to use latest SNAPSHOT plugins.
|
|
resolutionStrategy.cacheChangingModulesFor 0, 'seconds'
|
|
}
|
|
}
|
|
|
|
plugins {
|
|
id 'org.jetbrains.kotlin.jvm' apply false
|
|
id 'org.jetbrains.kotlin.plugin.allopen' apply false
|
|
id 'org.jetbrains.kotlin.plugin.jpa' apply false
|
|
id 'com.github.johnrengelman.shadow' version '7.1.2' apply false
|
|
id "org.ajoberstar.grgit" version "4.0.0"
|
|
id 'corda.root-publish'
|
|
id "org.jetbrains.dokka" version "1.8.20"
|
|
}
|
|
|
|
apply plugin: 'project-report'
|
|
apply plugin: 'com.github.ben-manes.versions'
|
|
apply plugin: 'com.r3.testing.distributed-testing'
|
|
|
|
// If the command line project option -PversionFromGit is added to the gradle invocation, we'll resolve
|
|
// the latest git commit hash and timestamp and create a version postfix from that
|
|
if (project.hasProperty("versionFromGit")){
|
|
ext.versionSuffix = "${grgit.head().dateTime.format("yyyyMMdd_HHmmss")}-${grgit.head().abbreviatedId}"
|
|
}
|
|
|
|
// Need the `toString()` call on these, because they need to be converted from GStringImpl to Java Strings.
|
|
if (ext.versionSuffix != ""){
|
|
ext.corda_release_version = "${ext.baseVersion}-${ext.versionSuffix}".toString()
|
|
} else {
|
|
ext.corda_release_version = "${ext.baseVersion}".toString()
|
|
}
|
|
|
|
logger.lifecycle("JDK: {}", System.getProperty("java.home"))
|
|
logger.lifecycle("Quasar version: {}", quasar_version)
|
|
logger.lifecycle("Quasar classifier: {}", quasar_classifier.toString())
|
|
logger.lifecycle("Building Corda version: {}", corda_release_version)
|
|
logger.lifecycle("User home: {}", System.getProperty('user.home'))
|
|
|
|
allprojects {
|
|
apply plugin: 'java'
|
|
apply plugin: 'kotlin-allopen'
|
|
apply plugin: 'jacoco'
|
|
apply plugin: 'org.owasp.dependencycheck'
|
|
apply plugin: 'org.sonarqube'
|
|
|
|
allOpen {
|
|
annotations(
|
|
"javax.persistence.Entity",
|
|
"javax.persistence.Embeddable",
|
|
"javax.persistence.MappedSuperclass"
|
|
)
|
|
}
|
|
|
|
dependencyCheck {
|
|
suppressionFile = '.ci/dependency-checker/suppressedLibraries.xml'
|
|
cveValidForHours = 1
|
|
format = 'ALL'
|
|
failOnError = project.property('owasp.failOnError')
|
|
// by default CVSS is '11' which passes everything. Set between 0-10 to catch vulnerable deps
|
|
failBuildOnCVSS = project.property('owasp.failBuildOnCVSS').toFloat()
|
|
|
|
analyzers {
|
|
assemblyEnabled = false
|
|
nuspecEnabled = false
|
|
nugetconfEnabled = false
|
|
}
|
|
}
|
|
|
|
sourceCompatibility = VERSION_17
|
|
targetCompatibility = VERSION_17
|
|
|
|
jacoco {
|
|
// JDK11 official support (https://github.com/jacoco/jacoco/releases/tag/v0.8.3)
|
|
toolVersion = "0.8.7"
|
|
}
|
|
|
|
test {
|
|
jvmArgs test_add_opens
|
|
jvmArgs test_add_exports
|
|
}
|
|
|
|
java {
|
|
withSourcesJar()
|
|
withJavadocJar()
|
|
}
|
|
|
|
tasks.withType(JavaCompile).configureEach {
|
|
options.compilerArgs << "-Xlint:unchecked" << "-Xlint:deprecation" << "-Xlint:-options" << "-parameters"
|
|
options.compilerArgs << '-XDenableSunApiLintControl'
|
|
if (warnings_as_errors) {
|
|
// We cannot fail the build on compiler warnings because we have java warnings that you cannot disable:
|
|
// Signal is internal proprietary API and may be removed in a future release
|
|
// otherwise we should have the following line here:
|
|
// options.compilerArgs << "-Werror"
|
|
}
|
|
options.encoding = 'UTF-8'
|
|
}
|
|
|
|
tasks.withType(KotlinCompile).configureEach {
|
|
compilerOptions {
|
|
languageVersion = KOTLIN_1_8
|
|
apiVersion = KOTLIN_1_8
|
|
jvmTarget = JVM_17
|
|
javaParameters = true // Useful for reflection.
|
|
freeCompilerArgs = ['-Xjvm-default=all-compatibility']
|
|
allWarningsAsErrors = warnings_as_errors
|
|
}
|
|
}
|
|
|
|
tasks.register('compileAll') { task ->
|
|
task.dependsOn tasks.withType(AbstractCompile)
|
|
}
|
|
|
|
tasks.withType(Jar).configureEach { task ->
|
|
// Includes War and Ear
|
|
manifest {
|
|
attributes('Corda-Release-Version': corda_release_version)
|
|
attributes('Corda-Platform-Version': corda_platform_version)
|
|
attributes('Corda-Revision': corda_revision)
|
|
attributes('Corda-Vendor': corda_build_edition)
|
|
attributes('Automatic-Module-Name': "net.corda.${task.project.name.replaceAll('-', '.')}")
|
|
attributes('Corda-Docs-Link': corda_docs_link)
|
|
}
|
|
}
|
|
|
|
tasks.withType(Test).configureEach {
|
|
forkEvery = 20
|
|
ignoreFailures = project.hasProperty('tests.ignoreFailures') ? project.property('tests.ignoreFailures').toBoolean() : false
|
|
failFast = project.hasProperty('tests.failFast') ? project.property('tests.failFast').toBoolean() : false
|
|
|
|
// Prevent the project from creating temporary files outside of the build directory.
|
|
systemProperty 'java.io.tmpdir', buildDir.absolutePath
|
|
|
|
maxHeapSize = "1g"
|
|
|
|
if (project.path.startsWith(':experimental') && System.getProperty("experimental.test.enable") == null) {
|
|
enabled = false
|
|
}
|
|
|
|
// Required to use Gradle build cache (until Gradle 5.0 is released with default value of "append" set to false)
|
|
// See https://github.com/gradle/gradle/issues/5269 and https://github.com/gradle/gradle/pull/6419
|
|
extensions.configure(TypeOf.typeOf(JacocoTaskExtension)) { ex ->
|
|
// ex.append = false
|
|
}
|
|
|
|
maxParallelForks = (System.env.CORDA_TESTING_FORKS == null) ? 1 : "$System.env.CORDA_TESTING_FORKS".toInteger()
|
|
|
|
systemProperty 'java.security.egd', 'file:/dev/./urandom'
|
|
}
|
|
|
|
tasks.withType(Test).configureEach {
|
|
if (name.contains("integrationTest")) {
|
|
maxParallelForks = (System.env.CORDA_INT_TESTING_FORKS == null) ? 1 : "$System.env.CORDA_INT_TESTING_FORKS".toInteger()
|
|
}
|
|
}
|
|
|
|
group 'net.corda'
|
|
version "$corda_release_version"
|
|
|
|
repositories {
|
|
mavenLocal()
|
|
// Prevents cache giving use the wrong artemis
|
|
mavenCentral {
|
|
content {
|
|
includeGroup 'org.apache.activemq'
|
|
}
|
|
}
|
|
// Use system environment to activate caching with Artifactory,
|
|
// because it is actually easier to pass that during parallel build.
|
|
// NOTE: it has to be a name of a virtual repository with all
|
|
// required remote or local repositories!
|
|
if (System.getenv("CORDA_USE_CACHE")) {
|
|
maven {
|
|
name "R3 Maven remote repositories"
|
|
url "${artifactory_contextUrl}/${System.getenv("CORDA_USE_CACHE")}"
|
|
authentication {
|
|
basic(BasicAuthentication)
|
|
}
|
|
credentials {
|
|
username = System.getenv('CORDA_ARTIFACTORY_USERNAME')
|
|
password = System.getenv('CORDA_ARTIFACTORY_PASSWORD')
|
|
}
|
|
}
|
|
} else {
|
|
maven {
|
|
url "${publicArtifactURL}/corda-dependencies"
|
|
content {
|
|
includeGroupByRegex 'net\\.corda(\\..*)?'
|
|
includeGroupByRegex 'com\\.r3(\\..*)?'
|
|
includeGroup 'co.paralleluniverse'
|
|
includeGroup 'org.crashub'
|
|
includeGroup 'com.github.bft-smart'
|
|
includeGroup 'com.github.detro'
|
|
}
|
|
metadataSources {
|
|
mavenPom()
|
|
artifact()
|
|
}
|
|
}
|
|
maven {
|
|
url "${publicArtifactURL}/corda-dependencies-dev"
|
|
content {
|
|
includeGroup 'co.paralleluniverse'
|
|
}
|
|
}
|
|
maven {
|
|
url "${publicArtifactURL}/corda-dev"
|
|
content {
|
|
includeGroupByRegex 'net\\.corda(\\..*)?'
|
|
includeGroupByRegex 'com\\.r3(\\..*)?'
|
|
}
|
|
}
|
|
maven {
|
|
url 'https://repo.gradle.org/gradle/libs-releases'
|
|
content {
|
|
includeGroup 'org.gradle'
|
|
includeGroup 'com.github.detro'
|
|
}
|
|
}
|
|
maven {
|
|
url "${publicArtifactURL}/corda-releases"
|
|
content {
|
|
includeModule('net.corda', 'corda-shell')
|
|
}
|
|
}
|
|
mavenCentral()
|
|
jcenter()
|
|
}
|
|
}
|
|
|
|
configurations {
|
|
configureEach {
|
|
resolutionStrategy {
|
|
if (pluginManager.hasPlugin("org.jetbrains.kotlin.jvm")) {
|
|
// Force dependencies to use the same version of Kotlin as Corda.
|
|
force "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
|
|
}
|
|
|
|
// Force dependencies to use the same version of Guava as Corda.
|
|
force "com.google.guava:guava:$guava_version"
|
|
|
|
// Demand that everything uses our given versions of:
|
|
// * Netty
|
|
// * Apache commons-configuration2
|
|
eachDependency { details ->
|
|
if (details.requested.group == 'io.netty' && details.requested.name.startsWith('netty-')) {
|
|
if (details.requested.name.startsWith('netty-tcnative')) {
|
|
details.useVersion tcnative_version
|
|
} else {
|
|
details.useVersion netty_version
|
|
}
|
|
}
|
|
|
|
if (details.requested.group == 'org.apache.commons') {
|
|
if (details.requested.name == "commons-configuration2") {
|
|
details.useVersion commons_configuration2_version
|
|
} else if (details.requested.name == "commons-text") {
|
|
details.useVersion commons_text_version
|
|
}
|
|
}
|
|
if (details.requested.group == 'org.yaml' && details.requested.name == 'snakeyaml') {
|
|
details.useVersion snake_yaml_version
|
|
}
|
|
}
|
|
|
|
dependencySubstitution {
|
|
// We want to use SLF4J's version of these bindings: jcl-over-slf4j
|
|
// Remove any transitive dependency on Apache's version.
|
|
substitute module('commons-logging:commons-logging') with module("org.slf4j:jcl-over-slf4j:$slf4j_version")
|
|
|
|
// Remove any transitive dependency on Logback (e.g. Liquibase 3.6 introduces this dependency)
|
|
substitute module('ch.qos.logback:logback-classic') with module("org.apache.logging.log4j:log4j-slf4j-impl:$log4j_version")
|
|
|
|
// Netty-All is an uber-jar which contains every Netty module.
|
|
// Exclude it to force us to use the individual Netty modules instead.
|
|
substitute module('io.netty:netty-all') with module("io.netty:netty-common:$netty_version")
|
|
|
|
// Force dependencies to use the same version of Guava as Corda.
|
|
substitute module('com.google.guava:guava') with module("com.google.guava:guava:$guava_version")
|
|
|
|
// Effectively delete this unused and unwanted transitive dependency of Artemis.
|
|
substitute module('org.jgroups:jgroups') with module("org.apache.activemq:artemis-commons:$artemis_version")
|
|
}
|
|
|
|
// FORCE Gradle to use latest SNAPSHOT dependencies.
|
|
cacheChangingModulesFor 0, 'seconds'
|
|
}
|
|
}
|
|
|
|
if (pluginManager.hasPlugin("org.jetbrains.kotlin.jvm")) {
|
|
// Select all of the compileClasspath and runtimeClasspath etc configurations,
|
|
// but NOT the "classpath" configuration, as that is used by the Gradle plugins.
|
|
matching { it.name.endsWith("Classpath") }.configureEach { cfg ->
|
|
cfg.resolutionStrategy {
|
|
dependencySubstitution {
|
|
// Force dependencies to use the same version of Kotlin as Corda.
|
|
substitute module('org.jetbrains.kotlin:kotlin-stdlib-common') with module("org.jetbrains.kotlin:kotlin-stdlib-common:$kotlin_version")
|
|
substitute module('org.jetbrains.kotlin:kotlin-stdlib') with module("org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version")
|
|
substitute module('org.jetbrains.kotlin:kotlin-reflect') with module("org.jetbrains.kotlin:kotlin-reflect:$kotlin_version")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
sonarqube {
|
|
properties {
|
|
property "sonar.projectName", "Corda"
|
|
property "sonar.projectKey", "corda"
|
|
property 'sonar.tests', '**/src/test/**,**/src/smoke-test/**,**/src/integration-test/**,**/src/integration-test-slow/**'
|
|
property 'sonar.coverage.jacoco.xmlReportPaths', "${rootDir.path}/build/reports/jacoco/jacocoRootReport/jacocoRootReport.xml"
|
|
property 'detekt.sonar.kotlin.baseline.path', "${rootDir.path}/detekt-baseline.xml"
|
|
property 'detekt.sonar.kotlin.config.path', "${rootDir.path}/detekt-config.yml"
|
|
}
|
|
}
|
|
|
|
configurations {
|
|
detekt
|
|
}
|
|
|
|
// Required for building out the fat JAR.
|
|
dependencies {
|
|
implementation project(':node')
|
|
implementation "com.google.guava:guava:$guava_version"
|
|
|
|
// Set to corda implementation to ensure it exists now deploy nodes no longer relies on build
|
|
implementation project(path: ":node:capsule", configuration: 'runtimeArtifacts')
|
|
implementation project(path: ":testing:testserver:testcapsule:", configuration: 'runtimeArtifacts')
|
|
|
|
// For the buildCordappDependenciesJar task
|
|
runtimeOnly project(':client:jfx')
|
|
runtimeOnly project(':client:mock')
|
|
runtimeOnly project(':client:rpc')
|
|
runtimeOnly project(':core')
|
|
runtimeOnly project(':confidential-identities')
|
|
runtimeOnly project(':finance:workflows')
|
|
runtimeOnly project(':finance:contracts')
|
|
runtimeOnly project(':testing:testserver')
|
|
testImplementation project(':test-utils')
|
|
detekt 'io.gitlab.arturbosch.detekt:detekt-cli:1.0.1'
|
|
}
|
|
|
|
jar {
|
|
// Prevent the root project from building an unwanted dummy CorDapp.
|
|
enabled = false
|
|
}
|
|
|
|
tasks.register('jacocoRootReport', JacocoReport) {
|
|
dependsOn = subprojects.test
|
|
// additionalSourceDirs = files(subprojects.sourceSets.main.allSource.srcDirs)
|
|
// sourceDirectories = files(subprojects.sourceSets.main.allSource.srcDirs)
|
|
// classDirectories = files(subprojects.sourceSets.main.output)
|
|
// executionData = files(subprojects.jacocoTestReport.executionData)
|
|
reports {
|
|
html.required = true
|
|
xml.required = true
|
|
csv.required = false
|
|
}
|
|
onlyIf = {
|
|
true
|
|
}
|
|
doFirst {
|
|
executionData = files(executionData.findAll {
|
|
it.exists()
|
|
})
|
|
}
|
|
}
|
|
|
|
tasks.register('detekt', JavaExec) {
|
|
def input = "$projectDir"
|
|
def config = "$projectDir/detekt-config.yml"
|
|
def baseline = "$projectDir/detekt-baseline.xml"
|
|
def detektPluginsJar = project(':detekt-plugins').tasks.jar
|
|
def plugins = detektPluginsJar.outputs.files.singleFile
|
|
def params = ['-i', input, '-c', config, '-b', baseline, '--plugins', plugins]
|
|
inputs.files(detektPluginsJar, config, baseline)
|
|
mainClass = "io.gitlab.arturbosch.detekt.cli.Main"
|
|
classpath = configurations.detekt
|
|
args(params)
|
|
}
|
|
|
|
tasks.register('detektBaseline', JavaExec) {
|
|
mainClass = "io.gitlab.arturbosch.detekt.cli.Main"
|
|
classpath = configurations.detekt
|
|
def input = "$projectDir"
|
|
def config = "$projectDir/detekt-config.yml, $projectDir/detekt-baseline-config.yml"
|
|
def baseline = "$projectDir/detekt-baseline.xml"
|
|
def params = ['-i', input, '-c', config, '-b', baseline, '--create-baseline']
|
|
args(params)
|
|
}
|
|
|
|
tasks.withType(Test).configureEach {
|
|
reports.html.outputLocation.set(file("${reporting.baseDir}/${name}"))
|
|
}
|
|
|
|
tasks.register('testReport', TestReport) {
|
|
destinationDir = file("$buildDir/reports/allTests")
|
|
// Include the results from the `test` task in all subprojects
|
|
reportOn subprojects*.test
|
|
}
|
|
|
|
// Note: corda.jar is used at runtime so no runtime ZIP is necessary.
|
|
// Resulting ZIP can be found in "build/distributions"
|
|
tasks.register('buildCordappDependenciesZip', Zip) {
|
|
baseName 'corda-deps'
|
|
from configurations.runtimeOnly
|
|
from configurations.implementation
|
|
from configurations.testImplementation
|
|
from buildscript.configurations.classpath
|
|
from 'node/capsule/NOTICE' // CDDL notice
|
|
duplicatesStrategy = DuplicatesStrategy.EXCLUDE
|
|
}
|
|
|
|
tasks.register('generateApi', GenerateApi) {
|
|
baseName = "api-corda"
|
|
}
|
|
|
|
// This exists to reduce CI build time when the envvar is set (can save up to 40 minutes)
|
|
if (file('corda-docs-only-build').exists() || (System.getenv('CORDA_DOCS_ONLY_BUILD') != null)) {
|
|
if (file('corda-docs-only-build').exists()) {
|
|
logger.info("Tests are disabled due to presence of file 'corda-docs-only-build' in the project root")
|
|
} else {
|
|
logger.info("Tests are disabled due to the presence of envvar CORDA_DOCS_ONLY_BUILD")
|
|
}
|
|
|
|
allprojects {
|
|
test {
|
|
exclude '*/**'
|
|
}
|
|
|
|
it.afterEvaluate {
|
|
if (it.tasks.findByName("integrationTest") != null) {
|
|
integrationTest {
|
|
exclude '*/**'
|
|
}
|
|
}
|
|
}
|
|
|
|
it.afterEvaluate {
|
|
if (it.tasks.findByName("smokeTest") != null) {
|
|
smokeTest {
|
|
exclude '*/**'
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
wrapper {
|
|
gradleVersion = '5.6.4'
|
|
distributionType = Wrapper.DistributionType.ALL
|
|
}
|
|
|
|
distributedTesting {
|
|
profilesURL = 'https://raw.githubusercontent.com/corda/infrastructure-profiles/master'
|
|
|
|
parallelTestGroups {
|
|
allParallelIntegrationTest {
|
|
testGroups 'integrationTest'
|
|
profile 'generalPurpose.yml'
|
|
podLogLevel PodLogLevel.INFO
|
|
distribution DistributeTestsBy.METHOD
|
|
}
|
|
allParallelUnitTest {
|
|
podLogLevel PodLogLevel.INFO
|
|
testGroups 'test'
|
|
profile 'generalPurpose.yml'
|
|
distribution DistributeTestsBy.CLASS
|
|
}
|
|
allParallelUnitAndIntegrationTest {
|
|
testGroups 'test', 'integrationTest'
|
|
profile 'generalPurpose.yml'
|
|
distribution DistributeTestsBy.METHOD
|
|
}
|
|
allParallelSmokeTest {
|
|
testGroups 'smokeTest'
|
|
profile 'regression.yml'
|
|
distribution DistributeTestsBy.METHOD
|
|
}
|
|
allParallelSlowIntegrationTest {
|
|
testGroups 'slowIntegrationTest'
|
|
profile 'regression.yml'
|
|
distribution DistributeTestsBy.METHOD
|
|
}
|
|
}
|
|
}
|