build.gradle

/*
 * Copyright 2019 ConsenSys AG.
 *
 * Licensed 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 net.ltgt.gradle.errorprone.CheckSeverity

import java.time.OffsetDateTime
import java.time.ZoneOffset
import java.time.format.DateTimeFormatter

buildscript {
  repositories { jcenter() }

  dependencies {
    classpath 'org.apache.openjpa:openjpa:3.1.0'
    classpath 'com.radcortez.gradle:openjpa-gradle-plugin:3.0.0'
  }
}

plugins {
  id "com.diffplug.gradle.spotless" version "3.10.0"
  id 'com.github.ben-manes.versions' version '0.28.0'
  id "com.github.hierynomus.license" version "0.14.0"
  id 'net.ltgt.errorprone' version '0.8'
  id 'io.spring.dependency-management' version '1.0.6.RELEASE'
  id 'org.ajoberstar.grgit' version '4.1.0'
}
rootProject.version = calculatePublishVersion()
def specificVersion = calculateVersion()

apply plugin: 'java-library'
apply plugin: "scala"
apply plugin: "jacoco"
apply plugin: 'net.ltgt.errorprone'
apply plugin: 'application'
apply plugin: 'maven-publish'
apply plugin: 'io.spring.dependency-management'
apply from: "gradle/check-licenses.gradle"
apply from: "gradle/versions.gradle"
apply plugin: 'openjpa'

//////
// Default tasks and build aliases

defaultTasks 'checkLicenses', 'assemble', 'javadoc', 'test', 'acceptanceTest'

def buildAliases = ['dev': [
    'spotlessApply',
    'checkLicenses',
    'assemble',
    'javadoc',
    'test',
    'acceptanceTest'
  ]]

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')

def expandedTaskList = []
gradle.startParameter.taskNames.each {
  expandedTaskList << (buildAliases[it] ? buildAliases[it] : it)
}
gradle.startParameter.taskNames = expandedTaskList.flatten()


// 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
}
// 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)
  print "describe gives this version ${version}"
  if (version == null) {
    return "UNKNOWN+g${grgit.head().abbreviatedId}"
  }
  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}\n" } }

/////
// Source formatting

spotless {
  java {
    licenseHeaderFile 'gradle/spotless.license.java'
    removeUnusedImports()
    eclipse().configFile(rootProject.file('gradle/eclipse-java-consensys-style.xml'))
    importOrder 'net.consensys', 'java', ''
    endWithNewline()
  }
  groovyGradle {
    target '**/*.gradle'
    greclipse().configFile(rootProject.file('gradle/greclipse-gradle-consensys-style.properties'))
    endWithNewline()
  }
  format 'scala', {
    target '**/*.scala'
    licenseHeaderFile 'gradle/spotless.license.java', 'package'
    paddedCell()
  }
  format 'build-gradle', {
    target '/build.gradle'
    licenseHeaderFile 'gradle/spotless.license.java', 'import'
    paddedCell()
  }
}

license { exclude "**/*" }


//////
// Compiler arguments

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

  options.errorprone {
    check('FutureReturnValueIgnored', CheckSeverity.OFF)
    check('FutureReturnValueIgnored', CheckSeverity.OFF)
    check('EqualsGetClass', CheckSeverity.OFF)
    check('InsecureCryptoUsage', CheckSeverity.WARN)
    check('FieldCanBeFinal', CheckSeverity.WARN)
    check('WildcardImport', CheckSeverity.WARN)
    check('TestExceptionChecker', CheckSeverity.WARN)
    // This check is broken in Java 12.  See https://github.com/google/error-prone/issues/1257
    if ((JavaVersion.current().majorVersion as Integer) > 11) {
      check('Finally', CheckSeverity.OFF)
    }
  }
}


//////
// Additional source sets (acceptance and performance tests)

test { useJUnitPlatform() }

sourceSets {
  acceptance {
    java.srcDir file('src/acceptance-test/java')
    resources.srcDir file('src/acceptance-test/resources')
    compileClasspath += main.runtimeClasspath + test.runtimeClasspath
    runtimeClasspath += main.runtimeClasspath + test.runtimeClasspath
  }
  performance {
    scala.srcDir file('src/performance-test/scala')
    resources.srcDir file('src/performance-test/resources')
    compileClasspath += main.runtimeClasspath
    runtimeClasspath += main.runtimeClasspath
  }
}

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

task javadocJar(type: Jar, dependsOn: javadoc) {
  classifier = 'javadoc'
  from javadoc.destinationDir
}

task acceptanceTest(type: Test, dependsOn: installDist) {
  description = 'Runs the acceptance tests'
  group = 'verification'
  useJUnitPlatform()
  setTestClassesDirs(sourceSets.acceptance.output.getClassesDirs())
  classpath = sourceSets.acceptance.runtimeClasspath
}

static def gatlingURL() {
  def appUrl = System.getProperty('gatlingURL')
  appUrl ?: 'http://localhost:8295'
}

task startOrion {
  dependsOn installDist
  doLast {
    copy {
      from "$projectDir/src/performance-test/resources"
      into "$buildDir/install/orion"
      include '*'
    }
    ext.process1 = new ProcessBuilder()
      .directory(new File("$buildDir/install/orion"))
      .command('bin/orion', 'config-8081.txt')
      .start()
    ext.process2 = new ProcessBuilder()
      .directory(new File("$buildDir/install/orion"))
      .command('bin/orion', 'config-8083.txt')
      .start()
    ext.process3 = new ProcessBuilder()
      .directory(new File("$buildDir/install/orion"))
      .command('bin/orion', 'config-8085.txt')
      .start()
  }
}

task stopOrion {
  doLast {
    if (tasks.startOrion.process1 != null) {
      tasks.startOrion.process1.destroy()
    }
    if (tasks.startOrion.process2 != null) {
      tasks.startOrion.process2.destroy()
    }
    if (tasks.startOrion.process3 != null) {
      tasks.startOrion.process3.destroy()
    }
  }
}

task performanceTest(type: JavaExec) {
  description = 'Runs the performance tests'
  group = 'verification'

  dependsOn startOrion
  finalizedBy stopOrion

  main = 'io.gatling.app.Gatling'
  classpath = sourceSets.performance.runtimeClasspath
  args = [
    '--simulation',
    'net.consensys.orion.load.LoadSimulation',
    '--results-folder',
    file('build/reports/performance').absolutePath,
    '--mute'
  ]
  environment = ['appUrl': gatlingURL()]
  systemProperties = ['gatling.core.directory.binaries': sourceSets.test.output.classesDirs]
}

openjpa {
  // only use the jpa entity classes defined the in the persistence.xml
  excludes = ['**/*.class']
}

//////
// Dependencies
repositories {
  jcenter()
  maven { url "https://repo1.maven.org/maven2/" }
  maven { url "https://artifacts.consensys.net/public/maven/maven/" }
}

dependencies {
  implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core'
  implementation 'org.antlr:antlr4-runtime'

  compile 'org.apache.tuweni:bytes'
  compile 'org.apache.tuweni:concurrent'
  compile 'org.apache.tuweni:concurrent-coroutines'
  compile 'org.apache.tuweni:config'
  compile 'org.apache.tuweni:crypto'
  compile 'org.apache.tuweni:io'
  compile 'org.apache.tuweni:kv'
  compile 'org.apache.tuweni:net'
  compile 'org.apache.tuweni:rlp'
  compile 'org.apache.tuweni:toml'

  // vertx
  compile 'io.vertx:vertx-core'
  compile 'io.vertx:vertx-web'

  // crypto
  compile 'org.bouncycastle:bcprov-jdk15on'
  compile 'org.bouncycastle:bcpkix-jdk15on'
  compile 'com.github.jnr:jnr-ffi'

  // http client
  testCompile 'com.squareup.okhttp3:okhttp'

  // storage
  compile 'org.fusesource.leveldbjni:leveldbjni-all'
  compile('org.mapdb:mapdb') {
    exclude group: 'net.jpountz.lz4', module: 'lz4'
  }
  compile 'org.lz4:lz4-java'
  compile 'com.jolbox:bonecp'
  compile 'org.apache.openjpa:openjpa'
  compile 'org.postgresql:postgresql'

  // serialization
  compile 'com.moandjiezana.toml:toml4j'
  compile 'com.fasterxml.jackson.core:jackson-databind'
  compile 'com.fasterxml.jackson.dataformat:jackson-dataformat-cbor'
  compile 'com.fasterxml.jackson.datatype:jackson-datatype-jdk8'

  // logging
  compile 'org.apache.logging.log4j:log4j-api'
  compile 'org.apache.logging.log4j:log4j-core'
  compile 'org.apache.logging.log4j:log4j-slf4j-impl'

  // XML
  compile 'javax.xml.bind:jaxb-api'

  //Oracle JDBC
  compile('com.oracle.ojdbc:ojdbc10')

  // testing
  testCompile 'org.apache.tuweni:junit'
  testCompile 'com.h2database:h2'
  testCompile 'org.junit.jupiter:junit-jupiter-api'
  testCompile 'org.junit.jupiter:junit-jupiter-params'
  testRuntime 'org.junit.jupiter:junit-jupiter-engine'
  testCompile 'org.mockito:mockito-all'
  testCompile 'org.awaitility:awaitility'
  // mock http server (unit test purposes)
  testCompile 'com.squareup.okhttp3:mockwebserver'
  testCompile 'org.assertj:assertj-core'
  testCompile 'io.vertx:vertx-unit'
  testCompile 'io.vertx:vertx-junit5'

  // performance testing
  performanceCompile 'org.scala-lang:scala-library'
  performanceCompile 'org.scalatest:scalatest_2.12'
  performanceCompile 'io.gatling:gatling-core'
  performanceCompile 'io.gatling:gatling-http'
  performanceCompile 'io.gatling:gatling-app'
  performanceCompile 'io.gatling.highcharts:gatling-charts-highcharts'

  errorprone 'com.google.errorprone:error_prone_core'
  if (JavaVersion.current().isJava8()) {
    errorproneJavac("com.google.errorprone:javac")
  }
}


//////
// Packaging

mainClassName = 'net.consensys.orion.cmd.Orion'
group = 'net.consensys'

jar {
  doFirst {
    delete fileTree(dir:'build/libs', include: '*.jar')
    new File("$buildDir/version").text = """$version"""
  }
  manifest {
    attributes('Implementation-Title': project.name,
    'Implementation-Version': project.version,
    'Main-Class': mainClassName
    )
  }
}

distributions {
  main {
    contents {
      from("./LICENSE") { into "." }
      from("build/reports/license/license-dependency.html") { into "." }
      from("./database") { into "database" }
    }
  }
}

installDist { dependsOn checkLicenses }

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

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

// rename the top level dir from orion-<version> to orion and this makes it really
// simple for use in docker
tasks.register("dockerDistUntar") {
  dependsOn distTar
  dependsOn distZip
  def dockerBuildDir = "build/docker-orion/"
  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}/orion")
  }
}

task distDocker(type: Exec) {
  dependsOn dockerDistUntar
  def dockerBuildVersion = project.hasProperty('release.releaseVersion') ? project.property('release.releaseVersion') : "${rootProject.version}"
  def imageName = "consensys/quorum-orion"
  def image = project.hasProperty('release.releaseVersion') ? "${imageName}:" + project.property('release.releaseVersion') : "${imageName}:${project.version}"
  def dockerBuildDir = "build/docker-orion/"
  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 testDocker(type: Exec) {
  dependsOn distDocker
  def dockerReportsDir = "docker/reports/"
  def imageName = "consensys/quorum-orion"
  def image = project.hasProperty('release.releaseVersion') ? "${imageName}:" + project.property('release.releaseVersion') : "${imageName}:${project.version}"
  workingDir "docker"

  doFirst {
    new File(dockerReportsDir).mkdir()
  }

  executable "sh"
  args "-c", "bash test.sh ${image}"
}

task testDockerHA(type: Exec) {
  dependsOn distDocker
  def dockerReportsDir = "docker/reports/"
  def imageName = "consensys/quorum-orion"
  def image = project.hasProperty('release.releaseVersion') ? "${imageName}:" + project.property('release.releaseVersion') : "${imageName}:${project.version}"
  workingDir "docker"

  doFirst {
    new File(dockerReportsDir).mkdir()
  }

  executable "sh"
  args "-c", "bash test_ha.sh ${image}"
}

task dockerUpload(type: Exec) {
  dependsOn distDocker
  def dockerBuildVersion = project.hasProperty('release.releaseVersion') ? project.property('release.releaseVersion') : "${rootProject.version}"
  def imageName = "consensys/quorum-orion"
  def image = "${imageName}:${dockerBuildVersion}"
  def cmd = "docker push '${image}'"

  def psImageName = "pegasyseng/orion"
  def psImage = "${psImageName}:${dockerBuildVersion}"
  cmd += " && docker tag '${image}' '${psImage}' && docker push '${psImage}'"

  def additionalTags = []

  if (project.hasProperty('branch') && project.property('branch') == 'master') {
    additionalTags.add('develop')
  }

  if (!(dockerBuildVersion ==~ /.*-SNAPSHOT/)) {
    additionalTags.add('latest')
    additionalTags.add(dockerBuildVersion)
  }

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

// http://label-schema.org/rc1/
// using the RFC3339 format "2016-04-12T23:20:50.52Z"
def buildTime() {
  return OffsetDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SS'Z'"))
}

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
}

//////
// Runtime

applicationDefaultJvmArgs = [
  "-Dvertx.disableFileCPResolving=true",
  "-Dvertx.logger-delegate-factory-class-name=io.vertx.core.logging.Log4j2LogDelegateFactory"
]

run {
  description = 'Run Orion. Use -Pargs="" to pass arguments'
  standardInput = System.in

  if (project.hasProperty("args")) {
    args project.getProperty('args').split()
  }
}


//////
// Publishing & release

publishing {
  repositories {
    maven {
      name = "cloudsmith"
      url = "https://api-g.cloudsmith.io/maven/consensys/maven/"
      credentials {
        username = cloudsmithUser
        password = cloudsmithKey
      }
    }
  }
  publications {
    mavenArtifact(MavenPublication) {
      from components.java
      artifact sourcesJar
      artifact javadocJar
      pom.withXml {
        asNode().children().last() + {
          resolveStrategy = Closure.DELEGATE_FIRST
          name 'Orion'
          description 'A java implementation of an Enterprise Ethereum Private Transaction Manager.'
          url 'https://github.com/consensys/orion'
          scm { url 'https://github.com/consensys/orion' }
          licenses {
            license {
              name 'The Apache Software License, Version 2.0'
              url 'http://www.apache.org/license/LICENSE-2.0.txt'
              distribution 'repo'
            }
          }
        }
      }
    }
  }
}

task cloudsmithUpload {
  dependsOn([distTar, distZip])
  doLast {
    exec {
      executable project.file("scripts/cloudsmith-upload.sh")
      args rootProject.version, distTar.archiveFile.get(), distZip.archiveFile.get()
    }
  }
}