build.gradle

//discovery v5

plugins {
  id 'java-library'
  id 'com.diffplug.spotless' version '6.0.4'
  id 'com.github.ben-manes.versions' version '0.39.0'
  id 'com.github.hierynomus.license' version '0.16.1'
  id 'io.spring.dependency-management' version '1.0.11.RELEASE'
  id 'net.ltgt.errorprone' version '2.0.2'
  id 'org.ajoberstar.grgit' version '4.1.1'
}

rootProject.version = calculatePublishVersion()
def specificVersion = calculateVersion()
def isDevelopBuild = rootProject.version.contains('develop')

apply from: "${rootDir}/gradle/versions.gradle"
apply from: "${rootDir}/gradle/check-licenses.gradle"
defaultTasks 'build', 'checkLicenses'

sourceCompatibility = '11'
targetCompatibility = '11'

repositories {
  jcenter()
  mavenCentral()
}

dependencies {
  implementation 'org.apache.tuweni:bytes'
  implementation 'org.apache.tuweni:units'
  implementation 'org.apache.tuweni:crypto'
  implementation 'org.bouncycastle:bcprov-jdk15on'

  implementation 'com.google.guava:guava'
  implementation 'io.projectreactor:reactor-core'
  implementation 'io.netty:netty-all'
  implementation 'io.vertx:vertx-core'
  implementation 'org.apache.logging.log4j:log4j-api'
  implementation 'org.apache.logging.log4j:log4j-core'
  implementation 'org.web3j:core'

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

  testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
  testRuntimeOnly 'org.apache.logging.log4j:log4j-slf4j-impl'

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

spotless {
  java {
    target fileTree('.') {
      include '**/*.java'
      exclude '**.gradle/**'
      exclude '**/src/*/generated'
      exclude '**/src/*/generated_tests'
      exclude '**/build/**'
    }

    importOrder 'tech.pegasys', 'net.consensys', 'java', ''
    trimTrailingWhitespace()
    endWithNewline()
    googleJavaFormat('1.13.0')
  }
}

license {
  header rootProject.file("gradle/java.license")
  skipExistingHeaders true
  mapping('java', 'SLASHSTAR_STYLE')
  exclude 'Dockerfile'
  exclude '*.go'
  ext.year = Calendar.getInstance().get(Calendar.YEAR)
}

tasks.withType(JavaCompile) {
  options.fork = true
  options.incremental = true
  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', net.ltgt.gradle.errorprone.CheckSeverity.OFF)
    // We like to use futures with no return values.
    check('FutureReturnValueIgnored', net.ltgt.gradle.errorprone.CheckSeverity.OFF)
    // We use the JSR-305 annotations instead of the Google annotations.
    check('ImmutableEnumChecker', net.ltgt.gradle.errorprone.CheckSeverity.OFF)

    check('FieldCanBeFinal', net.ltgt.gradle.errorprone.CheckSeverity.OFF)
    check('InsecureCryptoUsage', net.ltgt.gradle.errorprone.CheckSeverity.WARN)
    check('WildcardImport', net.ltgt.gradle.errorprone.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', net.ltgt.gradle.errorprone.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', net.ltgt.gradle.errorprone.CheckSeverity.OFF)
    }
  }
  options.encoding = 'UTF-8'

  jar {
    baseName project.name

    manifest {
      attributes(
          'Specification-Title': project.name,
          'Specification-Version': project.version,
          'Implementation-Title': project.name,
          'Implementation-Version': specificVersion
      )
    }
  }
}

test {
  jvmArgs = [
      '-Xmx4g',
      '-XX:-UseGCOverheadLimit',
  ]
  useJUnitPlatform()
  reports {
    junitXml.enabled = true
  }
}

javadoc {
  options.addStringOption('Xdoclint:all', '-quiet')
  options.addStringOption('Xwerror', '-html5')
  options.encoding = 'UTF-8'
}

task sourcesJar(type: Jar, dependsOn: classes) {
  classifier = 'sources'
  from sourceSets.main.allSource
}

task runTestDiscovery(type:JavaExec) {
    main = 'org.ethereum.beacon.discovery.app.DiscoveryTestServer'
    classpath = sourceSets.main.runtimeClasspath + sourceSets.test.runtimeClasspath
    systemProperty "log4j.configurationFile", "log4j2-test-discovery.xml"
}

def cloudsmithUser = project.hasProperty('cloudsmithUser') ? project.property('cloudsmithUser') : System.getenv('CLOUDSMITH_USER')
def cloudsmithKey = project.hasProperty('cloudsmithApiKey') ? project.property('cloudsmithApiKey') : System.getenv('CLOUDSMITH_API_KEY')

apply plugin: 'maven-publish'
publishing {
  repositories {
    maven {
      name = "cloudsmith"
      url = "https://api-g.cloudsmith.io/maven/consensys/maven/"
      credentials {
        username = cloudsmithUser
        password = cloudsmithKey
      }
    }
  }
  publications {
    mavenJava(MavenPublication) {
      groupId "tech.pegasys.discovery"
      version project.version
      from components.java
      artifact sourcesJar

      versionMapping {
        usage('java-api') { fromResolutionOf('runtimeClasspath') }
        usage('java-runtime') { fromResolutionResult() }
      }
      pom {
        name = "${project.name}"
        url = 'http://github.com/ConsenSys/discovery'
        licenses {
          license {
            name = 'The Apache License, Version 2.0'
            url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
          }
        }
        scm {
          connection = 'scm:git:git://github.com/ConsenSys/discovery.git'
          developerConnection = 'scm:git:ssh://github.com/ConsenSys/discovery.git'
          url = 'https://github.com/ConsenSys/discovery'
        }
      }
    }
  }
}


// Calculate the version that this build would be published under (if it is published)
// If this exact commit is tagged, use the tag
// If this is on a release-* branch, use the most recent tag appended with +develop (e.g. 0.1.1-RC1+develop)
// Otherwise, use develop
def calculatePublishVersion() {
  if (!grgit) {
    return 'UNKNOWN'
  }
  def specificVersion = calculateVersion()
  def isReleaseBranch = grgit.branch.current().name.startsWith('release-')
  if (specificVersion.contains('+')) {
    return isReleaseBranch ? "${specificVersion.substring(0, specificVersion.indexOf('+'))}+develop" : "develop"
  }
  return specificVersion
}

// Calculate the version that teku --version will report (among other places)
// If this exact commit is tagged, use the tag
// Otherwise use git describe --tags and replace the - after the tag with a +
def calculateVersion() {
  if (!grgit) {
    return 'UNKNOWN'
  }
  String version = grgit.describe(tags: true)
  def versionPattern = ~/^(?<lastVersion>.*)-(?<devVersion>[0-9]+-g[a-z0-9]+)$/
  def matcher = version =~ versionPattern
  if (matcher.find()) {
    return "${matcher.group("lastVersion")}+${matcher.group("devVersion")}"
  }
  return version
}

task printVersion() {
  doFirst {
    print "Specific version: ${specificVersion}  Publish version: ${project.version}"
  }
}