build.gradle

import net.ltgt.gradle.errorprone.CheckSeverity

import java.text.SimpleDateFormat

plugins {
  id 'com.diffplug.gradle.spotless' version '3.26.0'
  id 'com.jfrog.bintray' version '1.8.4'
  id 'com.github.ben-manes.versions' version '0.27.0'
  id 'com.github.hierynomus.license' version '0.15.0'
  id 'io.spring.dependency-management' version '1.0.8.RELEASE'
  id 'net.ltgt.errorprone' version '1.1.1' apply false
  id 'net.researchgate.release' version '2.8.1'
  id 'me.champeau.gradle.jmh' version '0.5.0' apply false
  id 'de.undercouch.download' version '4.0.1'
}

defaultTasks 'build','checkLicenses'

def buildAliases = [
  'dev': [
    'compileJava',
    'compileTestJava',
    'compileJmhJava',
    'compileIntegrationTestJava',
    'compileCompatibilityTestJava',
    'compileReferenceTestJava',
    'spotlessApply',
    'build',
    'checkLicenses',
    // TODO - Fix javadoc task
    /*'javadoc'*/],
  'mash': [
    'clean',
    'spotlessApply',
    'build',
    'test']
  ]

def expandedTaskList = []

gradle.startParameter.taskNames.each {
  expandedTaskList << (buildAliases[it] ? buildAliases[it] : it)
}
gradle.startParameter.taskNames = expandedTaskList.flatten() as Iterable<String>

def userHome = System.getProperty("user.home")
allprojects {
  apply plugin: 'java-library'
  apply plugin: 'io.spring.dependency-management'
  apply plugin: 'jacoco'
  apply plugin: 'net.ltgt.errorprone'
  apply from: "${rootDir}/gradle/versions.gradle"
  apply from: "${rootDir}/gradle/check-licenses.gradle"

  version = rootProject.version

  jacoco { toolVersion = '0.8.5' }

  sourceCompatibility = '11'
  targetCompatibility = '11'

  repositories {
    jcenter()
    mavenCentral()
    maven { url "https://hyperledger-org.bintray.com/besu-repo/" }
  }

  dependencies {
    errorprone("com.google.errorprone:error_prone_core")
  }

  apply plugin: 'com.diffplug.gradle.spotless'
  spotless {
    java {
      // This path needs to be relative to each project
      target fileTree('.') {
        include '**/*.java'
        exclude '**/.gradle/**'
        exclude 'web3j'
        //Excluding tech.pegasys.artemis.datastructures due to preferred formatting overwritten by plugin in getConstantsAsString.
        exclude '**/src/main/java/tech/pegasys/artemis/Constants.java'
        exclude '**/proto'
      }


      importOrder 'tech.pegasys', 'net.consensys', 'java', ''
      trimTrailingWhitespace()
      endWithNewline()
      licenseHeaderFile "${rootDir}/gradle/spotless.java.license"
      googleJavaFormat('1.7')
    }
  }

  tasks.withType(JavaCompile) {
    options.compilerArgs += [
      '-Xlint:unchecked',
      '-Xlint:cast',
      '-Xlint:rawtypes',
      '-Xlint:overloads',
      '-Xlint:divzero',
      '-Xlint:finally',
      '-Xlint:static',
      '-Werror',
    ]

    options.errorprone {
      disableWarningsInGeneratedCode
      // Our equals need to be symmetric, this checker doesn't respect that.
      check('EqualsGetClass', CheckSeverity.OFF)
      // We like to use futures with no return values.
      check('FutureReturnValueIgnored', CheckSeverity.OFF)
      // We use the JSR-305 annotations instead of the Google annotations.
      check('ImmutableEnumChecker', CheckSeverity.OFF)

      check('FieldCanBeFinal', CheckSeverity.OFF)
      check('InsecureCryptoUsage', CheckSeverity.WARN)
      check('WildcardImport', CheckSeverity.WARN)

      // This check is broken in Java 12.  See https://github.com/google/error-prone/issues/1257
      if (JavaVersion.current() == JavaVersion.VERSION_12) {
        check('Finally', CheckSeverity.OFF)
      }
      // This check is broken after Java 12.  See https://github.com/google/error-prone/issues/1352
      if (JavaVersion.current() > JavaVersion.VERSION_12) {
        check('TypeParameterUnusedInFormals', CheckSeverity.OFF)
      }
    }
    options.encoding = 'UTF-8'
  }
  /*
   * Pass some system properties provided on the gradle command line to test executions for
   * convenience.
   *
   * The properties passed are:
   * - 'test.ethereum.include': allows to run a single Ethereum reference tests. For instance,
   *   running a single general state test can be done with:
   *    ./gradlew :ethereum:tech.pegasys.artemis.ethereum.vm:test -Dtest.single=GeneralStateTest -Dtest.ethereum.include=callcodecallcallcode_101-Frontier
   *   The meaning being that will be run only the tests for which the value passed as "include"
   *   (which can be a java pattern) matches parts of the test name. Knowing that tests names for
   *   reference tests are of the form:
   *     <name>(-<milestone>([<variant>])?)?
   *   where <name> is the test name as defined in the json file (usually the name of the json file
   *   as well), <milestone> is the Ethereum milestone tested (not all test use it) and <variant>
   *   is only use in some general state tests where for the same json file and same milestone,
   *   multiple variant of that test are run. The variant is a simple number.
   * - 'test.ethereum.state.eip': for general state tests, allows to only run tests for the
   *   milestone specified by this value. So for instance,
   *    ./gradlew :ethereum:tech.pegasys.artemis.ethereum.vm:test -Dtest.single=GeneralStateTest -Dtest.ethereum.state.eip=Frontier
   *   only run general state tests for Frontier. Note that this behavior could be achieved as well
   *   with the 'include' option above since it is a pattern, but this is a slightly more convenient
   *   option.
   * - 'root.log.level' and 'evm.log.level': allow to control the log level used during the tests.
   */
  test {
    jvmArgs = [
      '-Xmx4g',
      '-XX:-UseGCOverheadLimit'
    ]
    Set toImport = [
      'test.ethereum.include',
      'test.ethereum.state.eip',
      'root.log.level',
      'evm.log.level'
    ]
    testLogging.showStandardStreams = true
    for (String name : toImport) {
      if (System.getProperty(name) != null) {
        systemProperty name, System.getProperty(name)
      }
    }
  }

  // Normalise Xdoclint behaviour across JDKs (OpenJDK 8 is more lenient than Oracle JDK by default).
  javadoc {
    options.addStringOption('Xdoclint:all', '-quiet')
    if (JavaVersion.current() == JavaVersion.VERSION_1_8) {
      options.addStringOption('Xwerror', '-quiet')
    } else {
      options.addStringOption('Xwerror', '-html5')
    }
    options.encoding = 'UTF-8'
  }
}

def refTestVersion = 'v0.9.0'
def refTestBaseUrl = 'https://github.com/ethereum/eth2.0-spec-tests/releases/download'
def refTestDownloadDir = "${buildDir}/refTests/${refTestVersion}"
def refTestExpandDir = "${project.rootDir}/eth-reference-tests/src/referenceTest/resources/eth2.0-spec-tests/"

task downloadRefTests(type: Download) {
  src([
      "${refTestBaseUrl}/${refTestVersion}/general.tar.gz",
      "${refTestBaseUrl}/${refTestVersion}/minimal.tar.gz",
      "${refTestBaseUrl}/${refTestVersion}/mainnet.tar.gz"
  ])
  dest "${refTestDownloadDir}"
  overwrite false
}

task cleanRefTestsGeneral(type: Delete) {
  delete "${refTestExpandDir}/tests/general"
}

task expandRefTestsGeneral(type: Copy, dependsOn: [cleanRefTestsGeneral, downloadRefTests]) {
  from tarTree("${refTestDownloadDir}/general.tar.gz")
  into refTestExpandDir
}

task cleanRefTestsMainnet(type: Delete) {
  delete "${refTestExpandDir}/tests/mainnet"
}

task expandRefTestsMainnet(type: Copy, dependsOn: [cleanRefTestsMainnet, downloadRefTests]) {
  from tarTree("${refTestDownloadDir}/mainnet.tar.gz")
  into refTestExpandDir
}

task cleanRefTestsMinimal(type: Delete) {
  delete "${refTestExpandDir}/tests/minimal"
}

task expandRefTestsMinimal(type: Copy, dependsOn: [cleanRefTestsMinimal, downloadRefTests]) {
  from tarTree("${refTestDownloadDir}/minimal.tar.gz")
  into refTestExpandDir
}

task expandRefTests(dependsOn: [expandRefTestsGeneral, expandRefTestsMainnet, expandRefTestsMinimal])
task cleanRefTests(dependsOn: [cleanRefTestsGeneral, cleanRefTestsMainnet, cleanRefTestsMinimal])

task deploy() {}

subprojects {
  tasks.withType(Test) {
    // If GRADLE_MAX_TEST_FORKS is not set, use half the available processors
   maxParallelForks = (System.getenv('GRADLE_MAX_TEST_FORKS') ?: (Runtime.runtime.availableProcessors().intdiv(2) ?: 1)).toInteger()
    useJUnitPlatform()
    reports {
      junitXml.enabled = true
    }
  }

  tasks.withType(JavaCompile) {
    options.fork = true
    options.incremental = true
  }
  apply plugin: 'maven-publish'

  sourceSets {
    // Add generated protobuf Java files to main/java sourceSet to appease Buildship.
    main {
      java {
        srcDir file('gen/main/java')
        srcDir file('gen/main/grpc')
      }
    }
    // test-support can be consumed as a library by other projects in their tests
    testSupport {
      java {
        compileClasspath += main.output
        runtimeClasspath += main.output
        srcDir file('src/test-support/java')
      }
      resources.srcDir file('src/test-support/resources')
    }
    integrationTest {
      java {
        compileClasspath += main.output
        runtimeClasspath += main.output
        srcDir file('src/integration-test/java')
      }
      resources.srcDir file('src/integration-test/resources')
    }
    compatibilityTest {
      java {
        compileClasspath += main.output
        runtimeClasspath += main.output
        srcDir file('src/compatibility-test/java')
      }
      resources.srcDir file('src/compatibility-test/resources')
    }
    referenceTest {
      java {
        srcDir file('src/referenceTest/java')
      }
      resources.srcDir file('src/referenceTest/resources')
    }
  }

  configurations {
    testSupportImplementation.extendsFrom implementation
    integrationTestImplementation.extendsFrom implementation
    compatibilityTestImplementation.extendsFrom implementation
    referenceTestImplementation.extendsFrom implementation
    testSupportArtifacts.extendsFrom testSupportImplementation
  }

  task testSupportJar (type: Jar) {
    baseName = "${project.name}-support-test"
    from sourceSets.testSupport.output
  }

  artifacts { testSupportArtifacts testSupportJar }

  def jarName = project.name
  def parent = project.parent
  while (parent != null) {
    if (parent != rootProject || jarName != 'artemis') {
      jarName = parent.name + '-' + jarName
    }
    parent = parent.parent
  }

  jar {
    baseName jarName
    manifest {
      attributes(
          'Specification-Title': jarName,
          'Specification-Version': project.version,
          'Implementation-Title': jarName,
          'Implementation-Version': calculateVersion()
      )
    }
  }

  dependencies {
    implementation 'org.apache.logging.log4j:log4j-core'
    runtime 'org.apache.logging.log4j:log4j-slf4j-impl'
    
    testImplementation sourceSets.testSupport.output
    integrationTestImplementation sourceSets.testSupport.output

    testImplementation 'org.assertj:assertj-core'
    testImplementation 'org.apache.tuweni:tuweni-junit'
    testImplementation 'org.junit.jupiter:junit-jupiter-api'
    testImplementation 'org.junit.jupiter:junit-jupiter-params'

    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
    testRuntimeOnly project(path: ':logging', configuration: 'testSupportArtifacts')

    integrationTestImplementation 'org.assertj:assertj-core'
    integrationTestImplementation 'org.apache.tuweni:tuweni-junit'
    integrationTestImplementation 'org.junit.jupiter:junit-jupiter-api'
    integrationTestImplementation 'org.junit.jupiter:junit-jupiter-params'

    integrationTestRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
    integrationTestRuntimeOnly project(path: ':logging', configuration: 'testSupportArtifacts')

    compatibilityTestImplementation 'org.assertj:assertj-core'
    compatibilityTestImplementation 'org.junit.jupiter:junit-jupiter-api'
    compatibilityTestImplementation 'org.junit.jupiter:junit-jupiter-params'
    compatibilityTestRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
    compatibilityTestRuntimeOnly project(path: ':logging', configuration: 'testSupportArtifacts')
    compatibilityTestRuntimeOnly 'org.apache.logging.log4j:log4j-core'
    compatibilityTestRuntimeOnly 'org.apache.logging.log4j:log4j-slf4j-impl'
  }

  task integrationTest(type: Test, dependsOn:["compileIntegrationTestJava"]){
    group = "verification"
    description = "Runs the Artemis integration tests"

    testClassesDirs = sourceSets.integrationTest.output.classesDirs
    classpath = sourceSets.integrationTest.runtimeClasspath
  }

  task compatibilityTest(type: Test, dependsOn:["compileCompatibilityTestJava"]){
    group = "verification"
    description = "Runs the Artemis compatibility tests"

    testClassesDirs = sourceSets.compatibilityTest.output.classesDirs
    classpath = sourceSets.compatibilityTest.runtimeClasspath
  }

  task referenceTest(type: Test, dependsOn:["compileReferenceTestJava"]){
    group = "verification"
    description = "Runs the reference tests"

    testClassesDirs = sourceSets.referenceTest.output.classesDirs
    classpath = sourceSets.referenceTest.runtimeClasspath
  }
}

jar { enabled = false }

apply plugin: 'application'
mainClassName = "tech.pegasys.artemis.Artemis"
applicationDefaultJvmArgs = [
  "-Djava.library.path=ARTEMIS_HOME/native",
  "-Dvertx.disableFileCPResolving=true",
  "-Dartemis.home=ARTEMIS_HOME",
  // We shutdown log4j ourselves, as otherwise his shutdown hook runs before our own and whatever
  // happens during shutdown is not logged.
  "-Dlog4j.shutdownHookEnabled=false"
]

run {
  if(project.hasProperty('generateFlow')){
    def flowJVMArgs = [
      "-javaagent:${userHome}/.flow/resources/javaagent.jar",
      "-Dflow.agent.include=tech.pegasys.artemis,tech.pegasys.artemis.services.beaconchain,tech.pegasys.artemis.statetransition,tech.pegasys.artemis.statetransition.util",
      "-Dflow.agent.exclude=tech.pegasys.artemis.datastructures.state,tech.pegasys.artemis.datastructures.blocks,tech.pegasys.artemis.datastructures.operations,tech.pegasys.artemis.datastructures.util.bitwise,tech.pegasys.artemis.util.hashtree,tech.pegasys.artemis.util.alogger,tech.pegasys.artemis.storage,tech.pegasys.artemis.util.bls,tech.pegasys.artemis.util.mikuli,tech.pegasys.artemis.networking.p2p,tech.pegasys.artemis.validator.coordinator",
      "-Dflow.agent.autostart",
      "-Dflow.agent.execution-name=artemis"
      ]
   applicationDefaultJvmArgs.addAll(flowJVMArgs)
  }
  args project.hasProperty("artemis.run.args") ? project.property("artemis.run.args").toString().split("\\s+") : []
  doFirst {
    applicationDefaultJvmArgs = applicationDefaultJvmArgs.collect{it.replace('ARTEMIS_HOME', "$buildDir/artemis")}
  }
}

startScripts {
  doLast {
    unixScript.text = unixScript.text.replace('ARTEMIS_HOME', '\$APP_HOME').replace('APP_NAME=', 'export LD_LIBRARY_PATH="\$APP_HOME/native:\$LD_LIBRARY_PATH"\nAPP_NAME=')
    windowsScript.text = windowsScript.text.replace('ARTEMIS_HOME', '%~dp0..')
  }
}

dependencies {
  compile project(':artemis')
  errorprone 'com.google.errorprone:error_prone_core'
}

distributions {
  main {
    contents {
      from("./LICENSE") { into "." }
      from("libs") { into "native" }
    }
  }
}

installDist { }

distTar {
  dependsOn checkLicenses
  doFirst {
    delete fileTree(dir: 'build/distributions', include: '*.tar.gz')
  }
  compression = Compression.GZIP
  extension = 'tar.gz'
}

distZip {
  dependsOn checkLicenses
  doFirst {
    delete fileTree(dir: 'build/distributions', include: '*.zip')
  }
}

// rename the top level dir from artemis-<version> to artemis and this makes it really
// simple for use in docker
tasks.register("dockerDistUntar") {
  dependsOn distTar
  def dockerBuildDir = "build/docker-artemis/"
  def distTarFile = distTar.outputs.files.singleFile
  def distTarFileName = distTar.outputs.files.singleFile.name.replace(".tar.gz", "")

  doFirst {
    new File(dockerBuildDir).mkdir()
    copy {
      from tarTree(distTarFile)
      into(dockerBuildDir)
    }
    file("${dockerBuildDir}/${distTarFileName}").renameTo("${dockerBuildDir}/artemis")
  }
}

task distDocker(type: Exec) {
  dependsOn dockerDistUntar

  def dockerBuildVersion = project.hasProperty('release.releaseVersion') ? project.property('release.releaseVersion') : "${rootProject.version}"
  def image = project.hasProperty('release.releaseVersion') ? "pegasyseng/artemis:" + project.property('release.releaseVersion') : "pegasyseng/artemis:${project.version}"
  def dockerBuildDir = "build/docker-artemis/"
  workingDir "${dockerBuildDir}"

  doFirst {
    copy {
      from file("${projectDir}/docker/Dockerfile")
      into(workingDir)
    }
  }

  executable "sh"
  args "-c", "docker build --build-arg BUILD_DATE=${buildTime()} --build-arg VERSION=${dockerBuildVersion} --build-arg VCS_REF=${getCheckedOutGitCommitHash()} -t ${image} ."
}

task distDockerWhiteblock(type: Exec) {
  dependsOn installDist

  def dockerBuildVersion = project.hasProperty('release.releaseVersion') ? project.property('release.releaseVersion') : "${rootProject.version}"
  def image = "pegasyseng/artemis:whiteblock"
  def dockerBuildDir = "build/docker-artemis-whiteblock/"
  workingDir "${dockerBuildDir}"

  doFirst {
    new File(dockerBuildDir).mkdir()
    copy {
      from fileTree("${projectDir}/docker/whiteblock/")
      into(workingDir)
    }
    copy {
      from fileTree("${projectDir}/build/install/")
      into(workingDir)
    }
    copy {
      from fileTree("${projectDir}/scripts/")
      into("${workingDir}/scripts")
    }
    copy {
      from fileTree("${projectDir}/config/")
      into("${workingDir}/config")
    }
  }

  executable "sh"
  args "-c", "docker build --build-arg BUILD_DATE=${buildTime()} --build-arg VERSION=${dockerBuildVersion} --build-arg VCS_REF=${getCheckedOutGitCommitHash()} -t ${image} ."
}

// http://label-schema.org/rc1/
// using the RFC3339 format "2016-04-12T23:20:50.52Z"
def buildTime() {
  def df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm'Z'")
  df.setTimeZone(TimeZone.getTimeZone("UTC"))
  return df.format(new Date())
}

// Takes the version, and if -SNAPSHOT is part of it replaces SNAPSHOT
// with the git commit version.
def calculateVersion() {
  String version = rootProject.version
  if (version.endsWith("-SNAPSHOT")) {
    version = version.replace("-SNAPSHOT", "-dev-" + getCheckedOutGitCommitHash())
  }
  return version
}

def getCheckedOutGitCommitHash() {
  def gitFolder = "$projectDir/.git/"
  if (!file(gitFolder).isDirectory()) {
    // We are in a submodule.  The file's contents are `gitdir: <gitFolder>\n`.
    // Read the file, cut off the front, and trim the whitespace.
    gitFolder = file(gitFolder).text.substring(8).trim() + "/"
  }
  def takeFromHash = 8
  /*
   * '.git/HEAD' contains either
   *      in case of detached head: the currently checked out commit hash
   *      otherwise: a reference to a file containing the current commit hash
   */
  def head = new File(gitFolder + "HEAD").text.split(":") // .git/HEAD
  def isCommit = head.length == 1 // e5a7c79edabbf7dd39888442df081b1c9d8e88fd

  if (isCommit) return head[0].trim().take(takeFromHash) // e5a7c79edabb

  def refHead = new File(gitFolder + head[1].trim()) // .git/refs/heads/master
  refHead.text.trim().take takeFromHash
}

task jacocoRootReport(type: JacocoReport) {
  additionalSourceDirs.from = files(subprojects.sourceSets.main.allSource.srcDirs)
  sourceDirectories.from = files(subprojects.sourceSets.main.allSource.srcDirs)
  classDirectories.from = files(subprojects.sourceSets.main.output)
  executionData.from = files(subprojects.jacocoTestReport.executionData)  //how to exclude some package/classes com.test.**
  reports {
    xml.enabled true
    csv.enabled true
    html.destination file("build/reports/jacocoHtml")
  }
  onlyIf = { true }
  doFirst {
    executionData = files(executionData.findAll { it.exists() })
  }
}

configurations { annotationProcessor }

// Prevent errorprone-checks being dependent upon errorprone-checks!
// However, ensure all subprojects comply with the custom rules.
configure(subprojects.findAll {it.name != 'errorprone-checks'}) {
  dependencies { annotationProcessor project(":errorprone-checks") }

  tasks.withType(JavaCompile) {
    options.annotationProcessorPath = configurations.annotationProcessor
  }
}

apply plugin: 'com.jfrog.bintray'

def bintrayUser = project.hasProperty('bintrayUser') ? project.property('bintrayUser') : System.getenv('BINTRAY_USER')
def bintrayKey = project.hasProperty('bintrayApiKey') ? project.property('bintrayApiKey') : System.getenv('BINTRAY_KEY')

def bintrayPackage = bintray.pkg {
  repo = 'pegasys-repo'
  name = 'artemis'
  userOrg = 'consensys'
  desc = 'Java Implementation of the Ethereum 2.0 Beacon Chain'
  licenses = ['Apache-2.0']
  websiteUrl = 'https://github.com/PegaSysEng/artemis'
  issueTrackerUrl = 'https://github.com/PegaSysEng/artemis/issues'
  vcsUrl = 'https://github.com/PegaSysEng/artemis.git'

  version {
    name = project.version
    released = new Date()
  }
}

bintray {
  user = bintrayUser
  key = bintrayKey

  filesSpec {
    from distTar.destinationDir.path
    from distZip.destinationDir.path
    into '.'
  }

  publish = true
  override = version.endsWith('SNAPSHOT')

  pkg = bintrayPackage
}

bintrayUpload.mustRunAfter(distTar)
bintrayUpload.mustRunAfter(distZip)

task dockerUpload(type: Exec) {
  dependsOn([distDocker, distDockerWhiteblock])
  def imageRepos = 'pegasyseng'
  def imageName = "${imageRepos}/artemis"
  def image = "${imageName}:${rootProject.version}"
  def cmd = "docker push '${image}'"
  def additionalTags = []
  if (project.hasProperty('branch') && project.property('branch') == 'master') {
    additionalTags.add('develop')
  }

  if (! version ==~ /.*-SNAPSHOT/) {
    additionalTags.add('latest')
    additionalTags.add(version.split(/\./)[0..1].join('.'))
  }

  additionalTags.each { tag ->
    cmd += " && docker tag '${image}' '${imageName}:${tag.trim()}' && docker push '${imageName}:${tag.trim()}'"
  }
  executable "sh"
  args "-c", cmd
}