build.gradle

// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0

import groovy.xml.*

plugins {
    id 'maven-publish'
    id 'signing'
}

group = 'software.amazon.cryptools'
version = '1.7.0'

def openssl_version = '1.1.1n'
def opensslSrcPath = "${buildDir}/openssl/openssl-${openssl_version}"

configurations {
    openssl
    jacocoAgent
    testDep.extendsFrom(jacocoAgent)
    stagingJar
    testRunner
}

repositories {
    mavenCentral {
        content { excludeGroup("openssl-src") }
    }
    // Fake Ivy Repository for current OpenSSL sources
    ivy {
        url 'https://www.openssl.org/source/'
            patternLayout {
            artifact '/[module]-[revision].[ext]'
        }
            metadataSources { artifact() }
            content { includeGroup("openssl-src") }
    }
    // Fake Ivy Repository for old OpenSSL sources
    ivy {
        url 'https://www.openssl.org/source/old/1.1.1/'
            patternLayout {
            artifact '/[module]-[revision].[ext]'
        }
        metadataSources { artifact() }
        content { includeGroup("openssl-src") }
    }
}

dependencies {
    // Separate so we can extract the jar for the agent specifically
    jacocoAgent group: 'org.jacoco', name: 'org.jacoco.agent', version: '0.8.7', classifier: 'runtime'

    // Separate so we can extract the jar for the runner specifically
    testRunner group: 'org.junit.platform', name: 'junit-platform-console-standalone', version: '1.6.2'

    testDep 'org.junit.jupiter:junit-jupiter:5.6.2'
    testDep 'org.junit.vintage:junit-vintage-engine:5.6.2'
    testDep 'org.bouncycastle:bcprov-debug-jdk15on:1.69'
    testDep 'org.bouncycastle:bcpkix-jdk15on:1.69'
    testDep 'commons-codec:commons-codec:1.12'
    testDep 'org.hamcrest:hamcrest:2.1'
    testDep 'org.jacoco:org.jacoco.core:0.8.3'
    testDep 'org.jacoco:org.jacoco.report:0.8.3'

    openssl "openssl-src:openssl:${openssl_version}@tar.gz"
}

defaultTasks 'release'

task getOpensslSrc(type: Copy) {
    def tarPath = project.configurations.openssl.find {it.name.startsWith("openssl-") }
    def tarFile = file(tarPath)

    doFirst {
        exec {
            workingDir tarFile.parent
            commandLine 'sha256sum', '--check', "${projectDir}/openssl.sha256"
        }

        mkdir "${buildDir}/openssl/bin"
    }

    def outputDir = file("${buildDir}/openssl/")
    from tarTree(tarFile)
    into outputDir
}

task buildOpenSsl {
    outputs.dir("${buildDir}/openssl/bin/")
    dependsOn getOpensslSrc

    doLast {
        exec {
            workingDir opensslSrcPath
            executable './config'
            args '-fPIC', '-ffunction-sections', '-fdata-sections', "--prefix=${buildDir}/openssl/bin"
            args 'no-autoload-config', 'no-capieng', 'no-cms', 'no-comp', 'no-ct', 'no-dgram', 'no-devcryptoeng'
            args 'no-gost', 'no-hw-padlock', 'no-nextprotoneg', 'no-ocsp', 'no-psk', 'no-rfc3779', 'no-shared'
            args 'no-sock', 'no-srp', 'no-srtp', 'threads', 'no-ts',  "no-bf", "no-cast", "no-md2", "no-rc2"
            args "no-rc4", "no-rc5", "no-srp", 'no-comp', 'no-hw', 'no-mdc2'
        }
        exec {
            workingDir opensslSrcPath
            commandLine 'make', 'depend'
        }
        exec {
            workingDir opensslSrcPath
            commandLine 'make', '-j', Runtime.runtime.availableProcessors()
        }
        exec {
            workingDir opensslSrcPath
            commandLine 'make', 'install_sw'
        }
    }
}

task executeCmake(type: Exec) {
    outputs.dir("${buildDir}/cmake")
    inputs.dir("${buildDir}/openssl/bin/")
    inputs.dir("${projectDir}/src")
    inputs.dir("${projectDir}/tst")
    inputs.dir("${projectDir}/csrc")
    inputs.dir("${projectDir}/CMake")
    inputs.dir("${projectDir}/etc")
    inputs.dir("${projectDir}/extra-jar-files")
    inputs.dir("${projectDir}/test-data")
    inputs.dir("${projectDir}/template-src")

    dependsOn buildOpenSsl

    workingDir "${buildDir}/cmake"
    def prebuiltJar = null
    if (project.hasProperty('stagingUrl')) {
        mkdir "${buildDir}/tmp"
        exec {
            workingDir "${buildDir}/tmp"
            commandLine 'wget', "${stagingUrl}/software/amazon/cryptools/${project.name}/${stagingVersion}/${project.name}-${stagingVersion}-linux-x86_64.jar"
        }
        prebuiltJar = "${buildDir}/tmp/${project.name}-${stagingVersion}-linux-x86_64.jar"
    } else if (System.properties['prebuiltJar'] != null) {
        prebuiltJar = "${projectDir}/" + System.properties['prebuiltJar']
    }

    executable 'cmake'
    args 'cmake', "-DTEST_CLASSPATH=${configurations.testDep.asPath}", "-DJACOCO_AGENT_JAR=${configurations.jacocoAgent.singleFile}"
    args "-DOPENSSL_ROOT_DIR=${buildDir}/openssl/bin", '-DCMAKE_BUILD_TYPE=Release', '-DPROVIDER_VERSION_STRING=' + version
    args "-DTEST_RUNNER_JAR=${configurations.testRunner.singleFile}"

    if (prebuiltJar != null) {
       args '-DSIGNED_JAR=' + prebuiltJar
    }

    if (System.properties['TEST_JAVA_HOME'] != null) {
        args '-DTEST_JAVA_HOME=' + System.properties['TEST_JAVA_HOME']
    }
    if (System.properties['TEST_JAVA_MAJOR_VERSION'] != null) {
        args '-DTEST_JAVA_MAJOR_VERSION=' + System.properties['TEST_JAVA_MAJOR_VERSION']
    }

    if (System.properties['SINGLE_TEST'] != null) {
        args '-DSINGLE_TEST=' + System.properties['SINGLE_TEST']

    }
    args projectDir
}

task build_objects(type: Exec) {
    dependsOn executeCmake
    outputs.file("${buildDir}/cmake/AmazonCorrettoCryptoProvider.jar")

    workingDir "${buildDir}/cmake"

    commandLine 'make', '-j', Runtime.runtime.availableProcessors(), 'accp-jar'
}

task build(overwrite:true) {
    dependsOn build_objects
    outputs.file("${buildDir}/lib/AmazonCorrettoCryptoProvider.jar")
    doLast {
        mkdir "${buildDir}/lib"
        if (project.hasProperty('jcecertAlias')) {
            ant.signjar(
                alias: jcecertAlias,
                jar: "${buildDir}/cmake/AmazonCorrettoCryptoProvider.jar",
                destDir: "${buildDir}/lib",
                storepass: jcecertPassword,
                keystore: "${project.gradle.gradleUserHomeDir}/${jcecertJks}",
                tsaurl: "http://timestamp.digicert.com"
            )
        } else {
            copy {
                from("${buildDir}/cmake") {
                    include 'AmazonCorrettoCryptoProvider.jar'
                }
                into "${buildDir}/lib"
            }
        }
    }
}

task emptyJar(type: Jar) {
    archiveFileName = 'empty.jar'
    archiveClassifier = null
    destinationDirectory = file("${buildDir}/lib")
}

task javadoc(type: Jar) {
    dependsOn executeCmake
    doFirst {
        mkdir "${buildDir}/lib"
        exec {
            workingDir "${buildDir}/cmake"
            commandLine 'make', 'javadoc'
        }
    }
    archiveFileName = 'AmazonCorrettoCryptoProvider-javadoc.jar'
    archiveClassifier = 'javadoc'
    destinationDirectory = file("${buildDir}/lib")
    from "${buildDir}/cmake/javadoc/AmazonCorrettoCryptoProvider/"
}

task src_jar {
    dependsOn executeCmake
    outputs.file("${buildDir}/lib/AmazonCorrettoCryptoProvider-sources.jar")
    doLast {
        mkdir "${buildDir}/lib"
        exec {
            workingDir "${buildDir}/cmake"
            commandLine 'make', 'accp-jar-source'
        }
        copy {
            from("${buildDir}/cmake") {
                include 'AmazonCorrettoCryptoProvider-sources.jar'
            }
            into "${buildDir}/lib"
        }
    }
}

task test_extra_checks(type: Exec) {
    dependsOn executeCmake
    workingDir "${buildDir}/cmake"
    commandLine 'make', 'check-junit-extra-checks'
}

task test(type: Exec) {
    dependsOn executeCmake
    workingDir "${buildDir}/cmake"
    commandLine 'make', 'check'
}

task single_test(type: Exec) {
    dependsOn executeCmake
    workingDir "${buildDir}/cmake"
    commandLine 'make', 'check-junit-single'
}

task test_integration(type: Exec) {
    dependsOn executeCmake
    workingDir "${buildDir}/cmake"
    commandLine 'make', 'check-integration'
}

task test_integration_extra_checks(type: Exec) {
    dependsOn executeCmake
    workingDir "${buildDir}/cmake"
    commandLine 'make', 'check-integration-extra-checks'
}

task dieharder(type: Exec) {
    dependsOn executeCmake
    workingDir "${buildDir}/cmake"
    commandLine 'make', 'check-dieharder'
}

task dieharder_threads(type: Exec) {
    dependsOn executeCmake
    workingDir "${buildDir}/cmake"
    commandLine 'make', 'check-dieharder-threads'
}

task dieharder_all {
    dependsOn dieharder, dieharder_threads
}

task coverage_clean(type: Delete) {
    delete fileTree("${buildDir}/cmake-coverage") {
        include '**/*.gcda'
    }
    delete "${buildDir}/reports/cpp"
}

task coverage_cmake(type: Exec) {
    dependsOn coverage_clean, buildOpenSsl
    doFirst {
        if (System.properties['prebuiltJar'] != null) {
            ant.fail("Cannot run coverage with a prebuilt jar")
        }
        mkdir "${buildDir}/cmake-coverage"
    }
    workingDir "${buildDir}/cmake-coverage"
    executable 'cmake'
    args "-DTEST_CLASSPATH=${configurations.testDep.asPath}"
    args "-DJACOCO_AGENT_JAR=${configurations.jacocoAgent.singleFile}"
    args "-DOPENSSL_ROOT_DIR=${buildDir}/openssl/bin"
    args '-DCMAKE_BUILD_TYPE=Coverage', '-DCOVERAGE=ON', '-DENABLE_NATIVE_TEST_HOOKS=ON'
    args '-DPROVIDER_VERSION_STRING=' + version, projectDir
    args "-DTEST_RUNNER_JAR=${configurations.testRunner.singleFile}"

    if (System.properties['SINGLE_TEST'] != null) {
        args '-DSINGLE_TEST=' + System.properties['SINGLE_TEST']

    }

}

task coverage_exec(type: Exec) {
    dependsOn coverage_cmake, coverage_clean
    doFirst {
        if (System.properties['prebuiltJar'] != null) {
            ant.fail("Cannot run coverage with a prebuilt jar")
        }
    }
    workingDir "${buildDir}/cmake-coverage"
    commandLine 'make', 'coverage'
}

task coverage_java_report(type: Copy) {
    doFirst {
        mkdir "${buildDir}/reports/java"
    }
    dependsOn coverage_exec

    from "${buildDir}/cmake-coverage/coverage/results/html/"
    into "${buildDir}/reports/java"
}

task coverage_cpp_report {
    dependsOn coverage_exec
    doFirst {
        mkdir "${buildDir}/reports/cpp"
    }
    doLast {
        exec {
            workingDir "${buildDir}/cmake-coverage"
            commandLine 'lcov', '--capture', '--directory', "${buildDir}/cmake-coverage/CMakeFiles/amazonCorrettoCryptoProvider.dir/csrc", '--output-file', "${buildDir}/cmake-coverage/coverage.info", '--rc', 'lcov_branch_coverage=1'
        }
        // Convert absolute to relative paths
        exec {
            workingDir "${buildDir}/cmake-coverage"
            commandLine 'perl', '-i', '-pe', "s[^SF:${projectDir}/*][SF:]", "${buildDir}/cmake-coverage/coverage.info"
        }
        // lcov captures coverage data for inline functions in system headers; strip this out to avoid
        // polluting our metrics with unused STL code.
        exec {
            workingDir "${buildDir}/cmake-coverage"
            commandLine 'lcov', '-e', "${buildDir}/cmake-coverage/coverage.info", 'csrc/*', '--rc', 'lcov_branch_coverage=1'
            standardOutput = new FileOutputStream("${buildDir}/reports/cpp/coverage.info")
        }
        exec {
             workingDir projectDir
             commandLine 'genhtml', '-o', "${buildDir}/reports/cpp", '--rc', 'genhtml_branch_coverage=1', "${buildDir}/reports/cpp/coverage.info"
        }
    }
}

task coverage {
    dependsOn coverage_java_report, coverage_cpp_report
}

task release {
    dependsOn build, test, coverage, javadoc, src_jar
}

task overkill {
    dependsOn test, test_extra_checks, test_integration, test_integration_extra_checks, dieharder_all
}


if (project.hasProperty('mavenUser') && project.hasProperty('jcecertAlias')) {
    publishing {
        publications {
            mavenJava(MavenPublication) {
                artifactId = project.name
                artifact source: file("${buildDir}/lib/AmazonCorrettoCryptoProvider.jar"),classifier:"linux-x86_64",extension:"jar"
                artifact emptyJar
                artifact javadoc
                artifact source: file("${buildDir}/lib/AmazonCorrettoCryptoProvider-sources.jar"),classifier:"sources",extension:"jar"

                pom {
                    name = "Amazon Corretto Crypto Provider"
                    description = 'The Amazon Corretto Crypto Provider (ACCP) is a collection of high-performance cryptographic implementations exposed via the standard JCA/JCE interfaces.'
                    url = 'https://github.com/corretto/amazon-corretto-crypto-provider'
                    licenses {
                        license {
                            name = 'The Apache License, Version 2.0'
                            url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                        }
                    }
                    scm {
                        url = 'https://github.com/corretto/amazon-corretto-crypto-provider.git'
                        connection = 'scm:git:git@github.com:corretto/amazon-corretto-crypto-provider.git'
                        developerConnection = 'scm:git:git@github.com:corretto/amazon-corretto-crypto-provider.git'
                    }
                    developers {
                        developer {
                            id = 'amazonwebservices'
                            organization = 'Amazon Web Services'
                            organizationUrl = 'https://aws.amazon.com'
                        }
                    }
                }
            }
        }
        repositories {
            maven {
                url = 'https://aws.oss.sonatype.org/service/local/staging/deploy/maven2/'
                credentials {
                    username mavenUser
                    password mavenPassword
                }
            }
        }
    }

    signing {
        sign publishing.publications.mavenJava
    }
} else {
    task publish(overwrite: true) {
        doFirst {
            ant.fail('Insufficient configuration for publishing')
        }
    }

    task sign {
        doFirst {
            ant.fail('Insufficient configuration for signing')
        }
    }

}

task clean(overwrite: true, type: Delete) {
   delete "${buildDir}/cmake"
   delete "${buildDir}/cmake-coverage"
   delete "${buildDir}/lib"
   delete "${buildDir}/reports"
   delete "${buildDir}/publications"
}

task deep_clean(type: Delete) {
   delete buildDir
}

task generateEclipseClasspath {
    doLast {
        file(".classpath").withWriter { writer ->
            // Create MarkupBuilder with 4 space indent
            def xml = new MarkupBuilder(new IndentPrinter(writer, "    ", true))

            xml.doubleQuotes = true
            xml.mkp.xmlDeclaration(version: '1.0', encoding: 'utf-8')
            xml.classpath {
                classpathentry('kind': 'con', 'path': 'org.eclipse.jdt.launching.JRE_CONTAINER') {
                    attributes {
                        attribute('name': 'module', 'value': 'true')
                    }
                }
                classpathentry('kind': 'src', 'output': 'build/eclipse/src', 'path': 'src')
                classpathentry('kind': 'src', 'output': 'build/eclipse/template-src', 'path': 'template-src')
                classpathentry('kind': 'src', 'output': 'build/eclipse/tst', 'path': 'tst') {
                    attributes {
                        attribute('name': 'test', 'value': 'true')
                    }
                }
                classpathentry('kind': 'src', 'output': 'build/eclipse/src', 'path': 'build/cmake/generated-java') {
                    attributes {
                        attribute('name': 'optional', 'value': 'true')
                    }
                }
                classpathentry('kind': 'src', 'output': 'build/eclipse/src', 'path': 'build/coverage-cmake/generated-java') {
                    attributes {
                        attribute('name': 'optional', 'value': 'true')
                    }
                }

                configurations.testDep.files.each{f ->
                    classpathentry('kind': 'lib', 'path': f) {
                        attribute('name': 'test', 'value': 'true')
                    }
                }
            } // xml.classpath
        } // file.withWriter
    } // doLast
} // generateEclipseClasspath