dshackle/build.gradle

import java.time.Instant
import java.time.ZoneId
import java.time.format.DateTimeFormatter
import java.time.temporal.ChronoUnit

buildscript {
    repositories {
        mavenLocal()
        mavenCentral()
    }
    dependencies {
        classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:1.3.70'
        classpath 'com.google.protobuf:protobuf-gradle-plugin:0.8.12'
    }
}

plugins {
    id 'java'
    id 'groovy'
    id 'idea'
    id 'application'

    id 'org.jetbrains.kotlin.jvm' version '1.3.70'
    id "com.google.cloud.tools.jib" version "1.3.0"
    id 'org.springframework.boot' version '2.1.4.RELEASE'
    id 'io.spring.dependency-management' version '1.0.6.RELEASE'
    id 'com.palantir.git-version' version '0.12.2'
    id "com.google.protobuf" version "0.8.12"
}


group = 'io.emeraldpay.dshackle'
version = '0.7-SNAPSHOT'

targetCompatibility = '11'
sourceCompatibility = '11'

repositories {
    mavenLocal()
    mavenCentral()
    maven { url "https://repo.spring.io/snapshot" }
    maven { url "https://repo.spring.io/milestone" }
    maven { url "https://dl.bintray.com/infinitape/etherjar" }
    maven { url "https://dl.bintray.com/emerald/emerald-grpc" }
}

configurations {
    compile.exclude group: "commons-logging"
    compile.exclude group: "ch.qos.logback"
    compile.exclude group: "org.slf4j", module: "slf4j-jdk14"
    compile.exclude group: "org.slf4j", module: "log4j-over-slf4j"
}

dependencies {
    implementation "io.emeraldpay:emerald-grpc:0.6.0-0.2"

    implementation "io.grpc:grpc-protobuf:${grpcVersion}"
    implementation "io.grpc:grpc-stub:${grpcVersion}"
    implementation "io.grpc:grpc-netty:${grpcVersion}"
    implementation "io.netty:netty-tcnative-boringssl-static:2.0.29.Final"
    implementation "io.netty:netty-all:4.1.48.Final"

    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
    implementation "org.jetbrains.kotlin:kotlin-reflect"

    implementation "org.springframework:spring-core:$springVersion"
    implementation "org.springframework:spring-context:$springVersion"
    implementation "org.springframework.security:spring-security-core:$springVersion"
    implementation "org.springframework.security:spring-security-web:$springVersion"
    implementation "org.springframework.security:spring-security-config:$springVersion"
    implementation "io.projectreactor:reactor-core:$reactorVersion"
    implementation "io.projectreactor.netty:reactor-netty:0.9.5.RELEASE"
    implementation 'io.projectreactor.addons:reactor-extra:3.2.3.RELEASE'
    implementation 'io.projectreactor.kotlin:reactor-kotlin-extensions:1.0.2.RELEASE'
    implementation 'com.salesforce.servicelibs:reactor-grpc:0.10.0'
    implementation 'io.lettuce:lettuce-core:5.2.2.RELEASE'

    implementation 'org.yaml:snakeyaml:1.24'

    implementation "io.infinitape:etherjar-domain:$etherjarVersion"
    implementation "io.infinitape:etherjar-hex:$etherjarVersion"
    implementation "io.infinitape:etherjar-rpc-http:$etherjarVersion"
    implementation "io.infinitape:etherjar-rpc-ws:$etherjarVersion"
    implementation "io.infinitape:etherjar-tx:$etherjarVersion"
    implementation 'org.bitcoinj:bitcoinj-core:0.15.8'

    implementation 'org.apache.httpcomponents:httpmime:4.5.8'
    implementation 'org.apache.httpcomponents:httpclient:4.5.8'
    implementation 'com.fasterxml.jackson.core:jackson-core:2.9.8'
    implementation 'com.fasterxml.jackson.core:jackson-databind:2.9.8'
    implementation 'commons-io:commons-io:2.6'
    implementation 'org.apache.commons:commons-lang3:3.9'
    implementation 'org.apache.commons:commons-collections4:4.3'
    implementation 'javax.annotation:javax.annotation-api:1.3.2'
    implementation 'org.bouncycastle:bcprov-jdk15on:1.61'

    implementation("org.springframework.boot:spring-boot-starter:$springBootVersion") {
        exclude module: 'spring-boot-starter-logging'
    }

    implementation "org.slf4j:slf4j-api:$slf4jVersion"
    implementation "org.apache.logging.log4j:log4j-slf4j-impl:2.11.1"
    implementation "org.slf4j:jul-to-slf4j:$slf4jVersion"
    implementation "org.slf4j:jcl-over-slf4j:$slf4jVersion"

    testImplementation 'cglib:cglib-nodep:3.3.0'
    testImplementation "org.spockframework:spock-core:$spockVersion"
    testImplementation "io.grpc:grpc-testing:${grpcVersion}"
    testImplementation "io.projectreactor:reactor-test:$reactorVersion"
    testImplementation 'org.objenesis:objenesis:3.1'
    testImplementation 'org.mock-server:mockserver-netty:5.10'
}

compileKotlin {
    kotlinOptions {
        jvmTarget = "11"
    }
}
compileTestKotlin {
    kotlinOptions {
        jvmTarget = "11"
    }
}

test {
    jvmArgs '-ea'
    testLogging.showStandardStreams = false
    testLogging.exceptionFormat = 'full'
}

application {
    mainClassName = 'io.emeraldpay.dshackle.StarterKt'
}

jib {
    from {
    }
    to {
        // execute with -Platest=true
        // $ gradle jib -Platest=true
        image = [
                project.hasProperty('docker') ? project.property('docker') : 'emeraldpay',
                '/dshackle:',
                (project.hasProperty('latest') && project.property('latest') == 'true') ? 'latest' : 'snapshot'
        ].join('')
        tags = [project.version].with (true) {
            if (!project.hasProperty('latest') || project.property('latest') != 'true') {
                add "t"+ DateTimeFormatter.ofPattern("yyyyMMddHHmm").withZone(ZoneId.of('UTC')).format(Instant.now())
            }
            add project.version.toString().replaceAll('(\\d+\\.\\d+).+', '$1')
        }
        auth {
            username = 'splix'
            password = System.getenv('DOCKER_KEY')
        }
    }
    container {
        jvmFlags = [
                '-Xms1024m',
        ]
        mainClass = 'io.emeraldpay.dshackle.StarterKt'
        args = []
        ports = ['8090', '8545']
    }
}

jar {
    enabled=true
}

afterEvaluate {
    distZip.dependsOn(jar)
    compileKotlin.dependsOn(generateVersion)
}

protobuf {
    protoc { artifact = "com.google.protobuf:protoc:${protocVersion}" }
    plugins {
    }
    generateProtoTasks {
    }
}

task generateVersion()  {
    group = 'Build'
    description = 'Generate project version'

    doLast {
        def version = versionDetails()
        def resourcesDir = sourceSets.main.output.resourcesDir
        resourcesDir.mkdirs()
        new File(resourcesDir, "version.properties").text = [
                "# AUTOMATICALLY GENERATED",
                "version.app=$project.version",
                "version.commit=${version.gitHash}",
                "version.tag=${version.lastTag}",
                "version.date=${DateTimeFormatter.ISO_LOCAL_DATE_TIME.withZone(ZoneId.of('UTC')).format(Instant.now().truncatedTo(ChronoUnit.SECONDS))} UTC"
        ].join("\n")

    }
}

// Show the list of failed tests and output only for them, helpful for CI
ext.failedTests = []
tasks.withType(Test) {
    def stdout = new LinkedList<String>()
    beforeTest { TestDescriptor td ->
        stdout.clear()
    }
    onOutput { TestDescriptor td, TestOutputEvent toe ->
        stdout.addAll(toe.getMessage().split('(?m)$'))
        while (stdout.size() > 100) {
            stdout.remove()
        }
    }
    afterTest { TestDescriptor descriptor, TestResult result ->
        if(result.resultType == org.gradle.api.tasks.testing.TestResult.ResultType.FAILURE){
            failedTests << "${descriptor.className} > ${descriptor.name}"
            if (!stdout.isEmpty()) {
                println("-------- ${descriptor.className} > ${descriptor.name} OUTPUT ".padRight(120, "-"))
                stdout.each { print(it) }
                println("================".padRight(120, "="))
            }
        }
    }
}
gradle.buildFinished {
    if(!failedTests.empty){
        println "Failed tests for ${project.name}:"
        failedTests.each { failedTest ->
            println failedTest
        }
        println ""
    }
}