build.gradle

plugins {
    id 'org.jetbrains.kotlin.jvm' apply false
    id 'com.github.johnrengelman.shadow' version '7.1.2' apply false
    id "com.github.ben-manes.versions" version "0.39.0"
    id 'base'
    id 'idea'
    id 'com.r3.conclave.dokka' version '1.5.31-1.4-SNAPSHOT'
    id 'com.github.jk1.dependency-license-report' version '1.16'
}

apply from: 'versions.gradle'
apply from: 'common.gradle'

repositories {
    maven {
        url "https://plugins.gradle.org/m2/"
    }

    // Dokka artifacts
    exclusiveContent {
        forRepository {
            maven {
                url = "https://software.r3.com/artifactory/conclave-maven"
            }
        }

        filter {
            includeModuleByRegex("com\\.r3\\.conclave\\.dokka", ".*")
        }
    }
}

dependencies {
    // We use a custom build of Dokka so we have to use the snapshot version.
    dokkaHtmlPlugin("com.r3.conclave.dokka:kotlin-as-java-plugin:1.5.31-1.4-SNAPSHOT")
}

String getConclaveRevision() {
    String conclave_revision

    try {
        // Get the id of the last commit from the current branch
        conclave_revision = "git rev-parse HEAD".execute().text.trim()
    } catch (Exception ignored) {
        project.logger.warn("Unable to get conclave revision. Git is unavailable in build environment")
        conclave_revision = "unknown"
    }

    return conclave_revision
}

enum VersionType {
    GA_RELEASE,
    RELEASE_CANDIDATE,
    SNAPSHOT,
    BETA
}

ext {
    conclave_revision = getConclaveRevision()
    project.logger.info("Conclave revision: $conclave_revision")

    if (version.endsWith("-SNAPSHOT")) {
        versionType = VersionType.SNAPSHOT
    } else if (version.matches(/.+\-RC[0-9]+$/)) {
        versionType = VersionType.RELEASE_CANDIDATE
    } else if (version.matches(/.+\-beta[0-9]+$/)) {
        versionType = VersionType.BETA
    } else {
        versionType = VersionType.GA_RELEASE
    }
}

// Allow the user to move the default build location. This is helpful for improving the
// atrocious performance of Mac Docker, which otherwise will try to build everything on
// the super-slow osxfuse filesystem. This way it can be relocated to a (faster) Linux
// native FS, or in extremis even a ramdisk.
def topDir = project.rootDir
def buildDirLocationOverride = findProperty('buildDirOverride')
if (buildDirLocationOverride != null) {
    println("Storing build output in $buildDirLocationOverride")
    allprojects {
        buildDir = "$buildDirLocationOverride/${topDir.relativePath(project.buildDir)}"
    }
}

def addAttributeToManifest(Manifest manifest, String name, String value) {
    project.logger.info("Setting $name=$value")
    manifest.attributes[name] = value
}

allprojects {
    tasks.withType(Jar).configureEach { task ->
        project.logger.info("Setting extra attributes that will be added to the manifest file for jars created from project ${task.project.name}")
        addAttributeToManifest(manifest, 'Conclave-Release-Version', conclave_version)
        addAttributeToManifest(manifest, 'Conclave-Revision', conclave_revision)
    }
}

subprojects {
    // All modules pull in the Java plugin
    apply plugin: 'java'

    repositories {
        mavenCentral()
        jcenter()
        maven {
            url = "https://software.r3.com/artifactory/conclave-maven"
        }
    }

    // The default Java version is 8. Specific modules may override this.
    // This will also configure Kotlin: https://kotlinlang.org/docs/gradle.html#gradle-java-toolchains-support
    java {
        toolchain {
            languageVersion = JavaLanguageVersion.of(8)
        }
    }

    // To create deterministic builds we want to ensure all archive tasks
    // use a reproducible file order and use consistent file timestamps
    tasks.withType(AbstractArchiveTask) {
        preserveFileTimestamps = false
        reproducibleFileOrder = true
    }

    configurations {
        compile {
            // We want to use SLF4J's version of these bindings: jcl-over-slf4j
            // Remove any transitive dependency on Apache's version.
            exclude group: 'commons-logging', module: 'commons-logging'
        }

        if (project.name.startsWith("conclave-")) {
            // Shaded dependencies should not be added to the runtime classpath so they are declared as compileOnly.
            // However compileOnly does not extend to the test configuration so we add that.
            testImplementation.extendsFrom(compileOnly)
        }
    }
}

class PublishedProject {
    String projectPath
    String description
    boolean shade = false
}

List<PublishedProject> publishedProjects = [
        new PublishedProject(
                projectPath: ':conclave-common',
                description: 'Conclave API common to enclave, host and client',
                shade: true
        ),
        new PublishedProject(
                projectPath: ':conclave-enclave',
                description: 'Conclave enclave API',
                shade: true
        ),
        new PublishedProject(
                projectPath: ':conclave-host',
                description: 'Conclave host API',
                shade: true
        ),
        new PublishedProject(
                projectPath: ':conclave-web-host',
                description: 'Conclave host web server',
                shade: true
        ),
        new PublishedProject(
                projectPath: ':conclave-client',
                description: 'Conclave client API',
                shade: true
        ),
        new PublishedProject(
                projectPath: ':conclave-web-client',
                description: 'Conclave web client API',
                shade: true
        ),
        new PublishedProject(
                projectPath: ':conclave-mail',
                description: 'Conclave mail API',
                shade: true
        ),
        new PublishedProject(
                projectPath: ':plugin-enclave-gradle',
                description: 'Conclave Gradle plugin for creating enclaves',
        ),
        new PublishedProject(
                projectPath: ':conclave-init',
                description: 'Conclave tool for bootstrapping projects',
        )
]

// region Docsite building
//
// This part of the build handles the creation of the EXTERNAL docsite.
// Dokka is the tool that reads KDoc comments from Kotlin and produces an API website.

import org.jetbrains.dokka.gradle.DokkaTask
tasks.withType(DokkaTask).configureEach {
    moduleName.set("Conclave Core")
    dokkaSourceSets {
        register("conclave") {
            displayName.set("Conclave Core")
            jdkVersion.set(8)
            reportUndocumented.set(false)
            skipDeprecated.set(true)
            includeNonPublic.set(false)
            pluginsMapConfiguration.put("org.jetbrains.dokka.base.DokkaBase", """{
                    "customAssets": [
                        "${file("$projectDir/docs/assets/docs_logo.svg")}",
                        "${file("$projectDir/docs/assets/arrow_down.svg")}"
                    ],
                    "footerMessage": "<a href=\\\"https://github.com/R3Conclave/conclave-core-sdk/wiki\\\">&#60;&#60; Back to Conclave documentation</a>"
                }"""
            )

            for (publishedProject in publishedProjects) {
                def project = project(publishedProject.projectPath)
                sourceRoots.from(file("${project.projectDir}/src/main/kotlin"))
            }

            // Filter out our internal and kotlin-specific classes
            perPackageOption {
                matchingRegex.set(".*\\.internal.*")
                suppress.set(true)
            }
            perPackageOption {
                matchingRegex.set(".*\\.kotlin.*")
                suppress.set(true)
            }
        }
    }
}

// Output HTML into the API directory for the docsite and Javadoc into a different
// directory for packaging in the documentation jar for IDEs.
tasks['dokkaHtml'].outputDirectory.set(file("$projectDir/docs/docs/api"))
tasks['dokkaJavadoc'].outputDirectory.set(file("$projectDir/docs/docs/javadoc"))

// Allow the option to exclude dokka from the SDK build.
// Important: This should only be used when building with a Java version that does not work
// with Dokka (currently anything greater than 8) to allow the SDK build to continue. It will
// result in an SDK build with the API documentation missing so should never be used for
// production builds.
def excludeDocs = findProperty('excludeDocs')
if (excludeDocs == null) {
    // Dokka does not always translate kotlin code into pure java documentation. We can use this
    // task to perform some pre-processing between generating the HTML and making the documentation site.
    task preprocessdocs(type: Exec, dependsOn: ['dokkaHtml']) {
        description = "Performs processing on the documentation generated using the apidocs task prior to running mkdocs."
        commandLine("./preprocess-docsite.sh")
        workingDir("docs")
        inputs.files(["./preprocess-docsite.sh", fileTree("docs/docs/api")])
        outputs.dir("docs/docs/api")
    }
    task packageJavadoc(type: Jar, dependsOn: ['dokkaJavadoc']) {
        from dokkaJavadoc
        archiveClassifier.set('javadoc')
        metaInf {
            from(project.rootDir) {
                include 'LICENSE'
                include 'NOTICE.md'
            }
        }
    }

    task mkdocs(type: Exec, dependsOn: ['preprocessdocs']) {
        description = "Runs the mkdocs tool to produce the static HTML website we expose to end users."
        commandLine("./make-docsite.sh")
        workingDir("docs")
        inputs.files(fileTree("docs/docs"))
        outputs.dir("docs/build")
    }
} else {
    // Dummy tasks to exclude mkdocs
    task mkdocs()
    task packageJavadoc(type: Jar) {
        archiveClassifier.set('javadoc')
    }
}

task cleanDocs {
    delete 'docs/build'
    delete 'docs/docs/api'
    delete 'docs/virtualenv'
}

tasks['clean'].dependsOn(cleanDocs)

// This task has to be called "buildDocs" because it's invoked by the
// https://github.com/corda/corda-docs-builder tool from CI.
task buildDocs(dependsOn: ['mkdocs'])
dokkaHtml.shouldRunAfter mkdocs
// endregion

for (publishedProject in publishedProjects) {
    def project1 = project(publishedProject.projectPath)

    project1.pluginManager.apply('java')
    project1.pluginManager.apply('maven-publish')
    project1.pluginManager.apply('signing')

    // We shade certain libraries into the Conclave API jars to avoid any potential versioning issues in Conclave apps
    // which might use different versions of these libraries.
    if (publishedProject.shade) {
        project1.pluginManager.apply('com.github.johnrengelman.shadow')

        project1.shadowJar {
            // After upgrading Gradle from 6.10 to 7.20, the task shadowJar caused problems with the tests
            // when the the command ./gradlew test publishAllPublicationsToBuildRepository is run. This happen because
            // the artifact generated by the tasks shadowJar and jar have the same name and Gradle gets confused.
            // The follow for loop enforces that the shadowJar task always runs after the jar and test tasks.
            for (publishedProject2 in publishedProjects) {
                Project project2 = project(publishedProject2.projectPath)
                mustRunAfter project2.jar, project2.test
            }

            if (project1.name == "conclave-mail" || project1.name == "conclave-common") {
                // Only conclave-mail and conclave-common need to have (some) of their dependencies shaded. These
                // dependencies are compileOnly.
                configurations = [project.configurations.compileClasspath]
                exclude '**/pom.xml'
                exclude '**/pom.properties'
                exclude '**/module-info.class'
                mergeServiceFiles()
                if (project1.name == "conclave-mail") {
                    exclude 'kotlin/Metadata.class'
                    // Only conclave-mail, as the root in the dependency tree, will contain the shaded kotlin. Everything
                    // else depends on conclave-mail (transitively) and so will inherit the shaded version.
                    dependencies {
                        it.include(dependency("org.jetbrains.kotlin:"))
                    }
                } else {
                    // Only conclave-common needs to contain the shaded Jackson library. Anything else that needs Jackson,
                    // e.g. conclave-host, can inherit this shaded version.
                    dependencies {
                        it.include(dependency("com.fasterxml.jackson.*:"))
                    }
                }
            } else {
                // The remaining modules are not shading anything so we turn it off.
                configurations = []
            }
            exclude 'META-INF/*.kotlin_module'
            exclude '**/*.kotlin_metadata'
            exclude '**/*.kotlin_builtins'
            // Everyone needs to have their import lines modified to the new shaded ones.
            relocate('com.fasterxml.jackson', 'com.r3.conclave.shaded.jackson')
            // Get rid of the Kotlin related stuff. We don't allow the metadata annotation to leak through because
            // it causes the IntelliJ plugin to crash, but this does unfortunately mean internal members (which are
            // public at the bytecode level) will appear. We fix this by making them synthentic which hides them from
            // the compiler.
            relocate('kotlin', 'com.r3.conclave.shaded.kotlin')
            // Replace the output of the "jar" task with this one.
            archiveClassifier = ''
        }
    }

    project1.java {
        withSourcesJar()
    }

    project1.signing {
        // Signing is required for the publication of releases to Maven Central.
        // As per Gradle Signing Plugin rules, "required = false" means that the artifacts 
        //   will only be signed if signatory credentials are configured (i.e. only in TeamCity).
        //   The build will skip signing if the key is not available, which is what we want for local builds
        required = false
        def key = System.getenv("CONCLAVE_PUBLICATION_SIGNING_PRIVATE_KEY")
        def password = System.getenv("CONCLAVE_PUBLICATION_SIGNING_PRIVATE_KEY_PASSWORD")
        useInMemoryPgpKeys(key, password)
        sign(project1.publishing.publications)
    }

    project1.publishing {
        publications {
            if (project1.name != "plugin-enclave-gradle") {
                maven(MavenPublication) {
                    from project1.components.java
                    addPomDetails(pom, project1.name, publishedProject.description)
                    artifact packageJavadoc
                }
            } else {
                //  Together with "maven-publish" plugin, "java-gradle-plugin" will prepare
                //    "pluginMaven" and "enclavePluginPluginMarkerMaven" that we override to generate
                //    a customized POM.
                //  Note that the plugin "java-gradle-plugin" is also applied
                //    in the build.gradle of "plugin-enclave-gradle".
                project1.pluginManager.apply('java-gradle-plugin')

                pluginMaven(MavenPublication) {
                    addPomDetails(pom, project.name, publishedProject.description)
                    // TODO This actually duplicates the same doc jar file for all the published modules!
                    //  https://r3-cev.atlassian.net/browse/CON-1065
                    artifact packageJavadoc
                }
                //  This is needed to override the POM of the marker, which is evaluated in the
                //    afterEvaluate of MavenPluginPublishPlugin.
                project1.afterEvaluate {
                    project1.publishing.publications {

                        enclavePluginPluginMarkerMaven(MavenPublication) {
                            addPomDetails(pom, "com.r3.conclave.enclave.gradle.plugin", "Gradle Enclave Plugin marker")
                        }
                    }
                }
            }
        }

        repositories {
            //  This repository is used for publishing to Maven Central from TeamCity.
            if (versionType == VersionType.GA_RELEASE || versionType == VersionType.BETA) {
                maven {
                    name = "OSSRH"
                    url = "https://s01.oss.sonatype.org/service/local/staging/deploy/maven2"
                    credentials {
                        username = System.getenv("CONCLAVE_OSSRH_USERNAME")
                        password = System.getenv("CONCLAVE_OSSRH_PASSWORD")
                    }
                }
            }
            maven {
                name = "artifactory"
                url = getArtifactoryForPublication()
                credentials {
                    username = System.getenv("CONCLAVE_ARTIFACTORY_USERNAME")
                    password = System.getenv("CONCLAVE_ARTIFACTORY_PASSWORD")
                }
            }
            maven {    // This section implicitly creates the publishAllPublicationsToBuildRepository target.
                name = "build"
                url = "$buildDir/repo"
            }
        }
    }
}

String getArtifactoryForPublication() {
    String mavenRepo
    if (versionType == VersionType.SNAPSHOT) {
        mavenRepo = "conclave-maven-dev"
    } else if (versionType == VersionType.RELEASE_CANDIDATE) {
        mavenRepo = "conclave-maven-unstable"
    } else {
        mavenRepo = "conclave-maven-stable"
    }
    return "https://software.r3.com/artifactory/" + mavenRepo
}

def addPomDetails(MavenPom pom, String name, String description) {
    pom.name = name
    pom.description = description
    pom.url = "https://github.com/R3Conclave/conclave-core-sdk"

    pom.licenses {
        license {
            name = 'The Apache License, Version 2.0'
            url = 'https://www.apache.org/licenses/LICENSE-2.0.txt'
            distribution = 'repo'
        }
    }
    pom.developers {
        developer {
            name = 'Conclave Team'
            email = "conclave@r3.com"
            organization = 'R3 LLC'
            organizationUrl = "https://www.r3.com"
        }
    }
    pom.scm {
        connection = "scm:git:git://github.com/R3Conclave/conclave-core-sdk.git"
        developerConnection = "scm:git:ssh://github.com:R3Conclave/conclave-core-sdk.git"
        url = "https://github.com/R3Conclave/conclave-core-sdk/tree/master"
    }
}

// To speed up IntelliJ indexing
idea {
    module {
        excludeDirs = [
                file("$projectDir/cpp/.idea"),
                file("$projectDir/scripts/build")
        ]
    }
}

// Run gradlew dependencyLicenseReport and open build/reports/dependency-license/index.html
import com.github.jk1.license.render.*
import com.github.jk1.license.filter.*
licenseReport {
    renderers = [new InventoryHtmlReportRenderer()]
    filters = [new LicenseBundleNormalizer()]
}