build.gradle

import groovy.transform.Memoized

import java.text.SimpleDateFormat

buildscript {
    repositories {
        mavenCentral()
        maven {
            url "https://artifacts.consensys.net/public/maven/maven/"
            content { includeGroupByRegex('tech\\.pegasys\\..*')}
        }
    }
    dependencies {
        classpath 'tech.pegasys.internal.license.reporter:license-reporter:1.1.1'
    }
}

plugins {
    id 'com.diffplug.spotless' version '6.16.0'
    id 'com.github.ben-manes.versions' version '0.46.0'
    id 'com.github.jk1.dependency-license-report' version '2.1'
    id 'io.spring.dependency-management' version '1.1.0'
    id 'net.ltgt.errorprone' version '3.0.1' apply false
    id 'java'
    id 'application'
}

apply plugin: 'application'

application {
    applicationName = "shomei"
    getMainClass().set("net.consensys.shomei.Shomei")
    applicationDefaultJvmArgs = [
            "-Dvertx.disableFileCPResolving=true",
            "-Dshomei.home=SHOMEI_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",
            "-Dlog4j2.formatMsgNoLookups=true",
            // run `jcmd <PID> VM.native_memory` to check JVM native memory consumption
            "-XX:NativeMemoryTracking=summary",
            // 32Mb for Netty Direct ByteBuf
            "-Dio.netty.maxDirectMemory=33554432"
    ]
}

allprojects {
    apply plugin: 'java-library'
    apply plugin: 'java-test-fixtures'
    apply plugin: 'io.spring.dependency-management'
    apply plugin: 'net.ltgt.errorprone'
    apply from: "${rootDir}/gradle/versions.gradle"

    version = rootProject.version


    task sourcesJar(type: Jar, dependsOn: classes) {
        archiveClassifier = 'sources'
        from sourceSets.main.allSource
        jar.reproducibleFileOrder = true
        jar.preserveFileTimestamps = false
    }

    sourceCompatibility = '17'
    targetCompatibility = '17'

    repositories {
        mavenLocal()
        mavenCentral()
        maven {
            url "https://artifacts.consensys.net/public/maven/maven/"
            content { includeGroupByRegex('tech\\.pegasys($|\\..*)')}
        }
        maven {
            url "https://dl.cloudsmith.io/public/libp2p/jvm-libp2p/maven/"
            content { includeGroupByRegex('io\\.libp2p($|\\..*)') }
        }
        maven {
            url "https://hyperledger.jfrog.io/artifactory/besu-maven/"
            content { includeGroupByRegex('org\\.hyperledger\\.besu($|\\..*)') }
        }
        // besu-shomei-plugin for test fixture generation
        def besuShomeiPluginRelease = ivy {
            url 'https://github.com'
            patternLayout {
                artifact '/[organisation]/[module]/releases/download/v[revision]/[artifact]-v[revision].[ext]'
            }
            metadataSources {
                artifact()
            }
        }
        // restict this so we do not accidentally pull in other artifacts from github
        exclusiveContent {
            forRepositories(besuShomeiPluginRelease)
            filter { includeModule('ConsenSys', 'besu-shomei-plugin')}
        }

    }

    dependencies {
        errorprone("com.google.errorprone:error_prone_core")
        errorprone("tech.pegasys.tools.epchecks:errorprone-checks")
    }

    apply plugin: 'com.diffplug.spotless'
    spotless {
        java {
            // This path needs to be relative to each project
            target fileTree('.') {
                include '**/*.java'
                exclude '**/.gradle/**'
                exclude '**/resources'
                exclude '**/src/*/generated'
                exclude '**/src/*/generated_tests'
                exclude '**/build/**'
            }
            removeUnusedImports()
            googleJavaFormat('1.15.0')
            importOrder 'net.consensys', 'java', ''
            trimTrailingWhitespace()
            endWithNewline()
            licenseHeaderFile "${rootDir}/gradle/spotless.java.license"
        }
    }

    tasks.withType(JavaCompile) {
        options.compilerArgs += [
                '-Xlint:unchecked',
                '-Xlint:cast',
                '-Xlint:rawtypes',
                '-Xlint:overloads',
                '-Xlint:divzero',
                '-Xlint:finally',
                '-Xlint:static',
                '-Werror',
        ]
        options.forkOptions.jvmArgs += [
                '--add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED',
                '--add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED',
                '--add-opens=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED'
        ]

        options.errorprone {
            enabled = !'true'.equalsIgnoreCase(System.getProperty('avt.disableErrorProne'))
            disableWarningsInGeneratedCode

            // Our equals need to be symmetric, this checker doesn't respect that
            check('EqualsGetClass', 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)
            // Storing a lambda to avoid code duplication is not a bad thing
            check('UnnecessaryLambda', net.ltgt.gradle.errorprone.CheckSeverity.OFF)
            // Generates a ton of false alarms for no real value
            check('LongDoubleConversion', net.ltgt.gradle.errorprone.CheckSeverity.OFF)
            check('InlineMeSuggester', net.ltgt.gradle.errorprone.CheckSeverity.OFF)
            check('CanIgnoreReturnValueSuggester', net.ltgt.gradle.errorprone.CheckSeverity.OFF)
            check('DirectInvocationOnMock', net.ltgt.gradle.errorprone.CheckSeverity.OFF)

            // We don't apply strict javadoc requirements yet
            check('EmptyBlockTag', net.ltgt.gradle.errorprone.CheckSeverity.OFF)
            check('MissingSummary', net.ltgt.gradle.errorprone.CheckSeverity.OFF)

            // Force strict compliance with Java naming conventions
            check('JavaCase', net.ltgt.gradle.errorprone.CheckSeverity.WARN)

            // Check for uses of == that should probably be .equals
            check('ReferenceComparison', net.ltgt.gradle.errorprone.CheckSeverity.WARN)

            // These checks are imported from errorprone-checks dependency but not required in Teku
            check('MethodInputParametersMustBeFinal', net.ltgt.gradle.errorprone.CheckSeverity.OFF)
            check('BannedMethod', net.ltgt.gradle.errorprone.CheckSeverity.OFF)
            check('ExperimentalCliOptionMustBeCorrectlyDisplayed', net.ltgt.gradle.errorprone.CheckSeverity.OFF)

            // These are experimental checks that we want enabled
            check('MissingBraces', net.ltgt.gradle.errorprone.CheckSeverity.WARN)
            check('InsecureCryptoUsage', net.ltgt.gradle.errorprone.CheckSeverity.WARN)
            check('WildcardImport', net.ltgt.gradle.errorprone.CheckSeverity.WARN)
            check('DeduplicateConstants', net.ltgt.gradle.errorprone.CheckSeverity.WARN)
            check('RedundantOverride', net.ltgt.gradle.errorprone.CheckSeverity.WARN)
            check('RedundantThrows', net.ltgt.gradle.errorprone.CheckSeverity.WARN)
            check('UnnecessarilyFullyQualified', net.ltgt.gradle.errorprone.CheckSeverity.WARN)
            check('InitializeInline', net.ltgt.gradle.errorprone.CheckSeverity.WARN)
            check('ClassName', net.ltgt.gradle.errorprone.CheckSeverity.WARN)
            check('InterfaceWithOnlyStatics', net.ltgt.gradle.errorprone.CheckSeverity.WARN)
            check('PackageLocation', net.ltgt.gradle.errorprone.CheckSeverity.WARN)
        }
        options.encoding = 'UTF-8'
    }
}

jar { enabled = false }

dependencies {
    implementation project(':shomei')
    errorprone 'com.google.errorprone:error_prone_core'
}

@Memoized
def calculateVersion() {
    String version = rootProject.version
    if (version.endsWith("-SNAPSHOT")) {
        version = version.replace("-SNAPSHOT", "-dev-" + getCheckedOutGitCommitHash())
    }
    return version
}

def getCheckedOutGitCommitHash(length = 8) {
    try {
        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(length).trim() + "/"
        }
        def takeFromHash = length
        /*
         * '.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
    } catch (Exception e) {
        logger.warn('Could not calculate git commit, using "xxxxxxxx" (run with --info for stacktrace)')
        logger.info('Error retrieving git commit', e)
        return "xxxxxxxx"
    }
}

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

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

def dockerBuildVersion = project.hasProperty('release.releaseVersion') ? project.property('release.releaseVersion') : "${rootProject.version}"
def dockerOrgName = project.hasProperty('dockerOrgName') ? project.getProperty("dockerOrgName") : "consensys"
def dockerArtifactName = project.hasProperty("dockerArtifactName") ? project.getProperty("dockerArtifactName") : "linea-shomei"
def dockerImageName = "${dockerOrgName}/${dockerArtifactName}"
def dockerVariants = project.hasProperty("dockerVariants") ? project.getProperty("dockerVariants").split(",") : [
        "openjdk-17",
        "openjdk-17-debug",
        "openj9-jdk-17",
        "graalvm",
        "openjdk-latest"
]
def archVariants = ["amd64", "arm64"]

// rename the top level dir from shomei-<version> to shomei and this makes it really
// simple for use in docker
task dockerDistUntar {
    dependsOn distTar
    dependsOn distZip
    def dockerBuildDir = "build/docker-shomei/"
    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)
        }
        project.delete(files("${dockerBuildDir}/shomei"))
        file("${dockerBuildDir}/${distTarFileName}").renameTo("${dockerBuildDir}/shomei")
    }
}


task dockerDist {
    dependsOn dockerDistUntar
    inputs.dir("build/docker-shomei/")
    def dockerBuildDir = "build/docker-shomei/"

    doLast {
        for (def jvmVariant in dockerVariants) {
            copy {
                from file("${projectDir}/docker/${jvmVariant}/Dockerfile")
                into(dockerBuildDir)
            }
            exec {
                def image = "${dockerImageName}:${dockerBuildVersion}-${jvmVariant}"
                def dockerPlatform = ""
                if (project.hasProperty('docker-platform')){
                    dockerPlatform = "--platform ${project.getProperty('docker-platform')}"
                    println "Building for platform ${project.getProperty('docker-platform')}"
                }
                executable "sh"
                workingDir dockerBuildDir
                args "-c", "docker build ${dockerPlatform} --build-arg BUILD_DATE=${buildTime()} --build-arg VERSION=${dockerBuildVersion} --build-arg VCS_REF=${getCheckedOutGitCommitHash()} -t ${image} ."
            }
        }

        // tag the "default" (which is the variant in the zero position)
        exec {
            executable "sh"
            args "-c", "docker tag '${dockerImageName}:${dockerBuildVersion}-${dockerVariants[0]}' '${dockerImageName}:${dockerBuildVersion}'"
        }
        // create a static tag for the benchmark target
        exec {
            executable "sh"
            args "-c", "docker tag '${dockerImageName}:${dockerBuildVersion}-${dockerVariants[0]}' '${dockerImageName}:benchmark'"
        }
    }
}

task dockerTest {
    dependsOn dockerDist
    def dockerReportsDir = "docker/reports/"

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

    doLast {
        def architecture = System.getenv('architecture')
        for (def variant in dockerVariants) {
            exec {
                def image = project.hasProperty('release.releaseVersion') ? "${dockerImageName}:" + project.property('release.releaseVersion') : "${dockerImageName}:${project.version}"
                workingDir "${projectDir}/docker/${variant}"
                executable "sh"
                args "-c", "architecture=${architecture} bash ../test.sh ${image}-${variant}"
            }
        }
    }
}

task dockerUpload {
    dependsOn dockerDist
    def architecture = System.getenv('architecture')
    def image = "${dockerImageName}:${dockerBuildVersion}"
    def tags = []

    if (!isInterimBuild(dockerBuildVersion)) {
        // if this is a release build, upload the version and latest tags
        logger.quiet("uploading release build")
        tags.add("${dockerImageName}:" + dockerBuildVersion)
        tags.add("${dockerImageName}:latest")
    } else {
        // otherwise, upload as develop
        logger.quiet("uploading develop build")
        tags.add("${dockerImageName}:develop")
    }

    doLast {
        exec {
            def archImage = "${image}-${architecture}"

            logger.quiet("architecture: $architecture")
            logger.quiet("image: $image")
            logger.quiet("tags: $tags")
            logger.quiet("archImage: $archImage")

            def cmd = "true"
            tags.each { tag -> cmd += " && docker tag '${image}' '${tag.trim()}-${architecture}' && docker push '${tag.trim()}-${architecture}'" }
            executable "sh"
            args "-c", cmd
        }
    }
}

task dockerManifest {
    def tags = []

    if (!isInterimBuild(dockerBuildVersion)) {
        // if this is a release, create manifests for the version and latest tags
        tags.add("${dockerImageName}:" + dockerBuildVersion)
        tags.add("${dockerImageName}:latest")
    } else {
        // otherwise, create manifest for develop
        tags.add("${dockerImageName}:develop")
    }

    doLast {
        for (baseTag in tags) {

            exec {
                def targets = ""
                archVariants.forEach { arch -> targets += "'${baseTag}-${arch}' " }
                def cmd = "docker manifest create '${baseTag}' ${targets} && docker manifest push '${baseTag}'"
                executable "sh"
                args "-c", cmd
            }
        }
    }
}

// aliases for the prior docker task names:
task distDocker(dependsOn: dockerDist)
task testDocker(dependsOn: dockerTest)
task uploadDocker(dependsOn: dockerUpload)
task manifestDocker(dependsOn: dockerManifest)


def isInterimBuild(dockerBuildVersion) {
    // any build version that is not major.minor.patch is treated as an interim build:
    return !(dockerBuildVersion ==~ /[0-9]+\.[0-9]+\.[0-9]+/)
}

def buildTime() {
    def df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm'Z'")
    df.setTimeZone(TimeZone.getTimeZone("UTC"))
    return df.format(new Date())
}