mirror of
https://github.com/corda/corda.git
synced 2024-12-20 21:43:14 +00:00
6dd33fb8f7
Major changes due to JDK 17: 1. JDK17 JCE Provider now has built-in support for eddsas, corda uses the bouncycastle (i2p) implementation. This PR removes the conflicting algorithms from the built-in JCE provider. 2. JavaScript scripting has been removed from the JDK, the corda log4j config was using scripting to conditionally output additional diagnostic info if the MDC was populated. This PR has removed the scripting. 3. The artifactory plug-ins used are now deprecated, this PR has removed them and uses the same code as Corda 5 for publishing to artifactory. 4. Javadoc generation has been modified to use the latest dokka plug-ins. 5. Gradle 7.6 has implemented an incredibly annoying change where transitive dependencies are not put on the compile classpath, so that they have to be explicitly added as dependencies to projects. 6. Mockito has been updated, which sadly meant that quite a few source files have to changes to use the new (org.mockito.kotlin) package name. This makes this PR appear much larger than it is. 7. A number of tests have been marked as ignored to get a green, broadly they fall into 3 classes. The first is related to crypto keypair tests, it appears some logic in the JDK prefers to use the SunJCE implementation and we prefer to use bouncycastle. I believe this issue can be fixed with better test setup. The second group is related to our use of a method called "uncheckedCast(..)", the purpose of this method was to get rid of the annoying unchecked cast compiler warning that would otherwise exist. It looks like the Kotlin 1.9 compiler type inference differs and at runtime sometimes the type it infers is "Void" which causes an exception at runtime. The simplest solution is to use an explicit cast instead of unchecked cast, Corda 5 have removed unchecked cast from their codebase. The third class are a number of ActiveMQ tests which appear to have a memory leak somewhere.
703 lines
30 KiB
Groovy
703 lines
30 KiB
Groovy
import com.r3.testing.DistributeTestsBy
|
|
import com.r3.testing.PodLogLevel
|
|
|
|
import static org.gradle.api.JavaVersion.VERSION_11
|
|
import static org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_8
|
|
import static org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_11
|
|
|
|
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.jdkClassifier = constants.getProperty("jdkClassifier")
|
|
ext.cordaScanApiClassifier = jdkClassifier
|
|
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 '2.0.4' 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()
|
|
}
|
|
|
|
// We need the following three lines even though they're inside an allprojects {} block below because otherwise
|
|
// IntelliJ gets confused when importing the project and ends up erasing and recreating the .idea directory, along
|
|
// with the run configurations. It also doesn't realise that the project is a Java 8 project and misconfigures
|
|
// the resulting import. This fixes it.
|
|
apply plugin: 'java'
|
|
|
|
logger.lifecycle("Java version: {}", JavaVersion.current())
|
|
sourceCompatibility = VERSION_11
|
|
targetCompatibility = VERSION_11
|
|
logger.lifecycle("Java source compatibility: {}", sourceCompatibility)
|
|
logger.lifecycle("Java target compatibility: {}", targetCompatibility)
|
|
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: 'org.jetbrains.kotlin.jvm'
|
|
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_11
|
|
targetCompatibility = VERSION_11
|
|
|
|
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
|
|
}
|
|
|
|
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(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
|
|
compilerOptions {
|
|
languageVersion = KOTLIN_1_8
|
|
apiVersion = KOTLIN_1_8
|
|
jvmTarget = JVM_11
|
|
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()
|
|
}
|
|
}
|
|
|
|
if (jdkClassifier) {
|
|
jar {
|
|
// JDK11 built and published artifacts to include classifier
|
|
archiveClassifier = jdkClassifier
|
|
}
|
|
}
|
|
|
|
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 {
|
|
all {
|
|
resolutionStrategy {
|
|
// 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")
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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")
|
|
}
|
|
|
|
// FORCE Gradle to use latest SNAPSHOT dependencies.
|
|
cacheChangingModulesFor 0, 'seconds'
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
task jacocoRootReport(type: org.gradle.testing.jacoco.tasks.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.enabled = true
|
|
xml.enabled = true
|
|
csv.enabled = 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)
|
|
main = "io.gitlab.arturbosch.detekt.cli.Main"
|
|
classpath = configurations.detekt
|
|
args(params)
|
|
}
|
|
|
|
tasks.register('detektBaseline', JavaExec) {
|
|
main = "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.destination = file("${reporting.baseDir}/${name}")
|
|
}
|
|
|
|
task testReport(type: 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"
|
|
task buildCordappDependenciesZip(type: 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', net.corda.plugins.apiscanner.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
|
|
}
|
|
}
|
|
}
|