corda/serialization-deterministic/build.gradle

description 'Corda serialization (deterministic)'

apply from: '../deterministic.gradle'
apply plugin: 'com.jfrog.artifactory'
apply plugin: 'net.corda.plugins.publish-utils'
apply plugin: 'java-library'
apply plugin: 'idea'

evaluationDependsOn(":serialization")

def javaHome = System.getProperty('java.home')
def jarBaseName = "corda-${project.name}".toString()

configurations {
    deterministicLibraries.extendsFrom implementation
    deterministicArtifacts.extendsFrom deterministicLibraries
}

dependencies {
    compileOnly project(':serialization')

    // Configure these by hand. It should be a minimal subset of dependencies,
    // and without any obviously non-deterministic ones such as Hibernate.

    // This dependency will become "compile" scoped in our published POM.
    // See publish.dependenciesFrom.defaultScope.
    deterministicLibraries project(path: ':core-deterministic', configuration: 'deterministicArtifacts')

    // These "implementation" dependencies will become "runtime" scoped in our published POM.
    implementation "org.apache.qpid:proton-j:$protonj_version"
    implementation "org.iq80.snappy:snappy:$snappy_version"
    implementation "com.google.guava:guava:$guava_version"
}

jar {
    archiveBaseName = 'DOES-NOT-EXIST'
    // Don't build a jar here because it would be the wrong one.
    // The jar we really want will be built by the metafix task.
    enabled = false
}

def serializationJarTask = tasks.getByPath(':serialization:jar')
def originalJar = serializationJarTask.outputs.files.singleFile

task patchSerialization(type: Zip, dependsOn: serializationJarTask) {
    destinationDirectory = file("$buildDir/source-libs")
    metadataCharset 'UTF-8'
    archiveClassifier = 'transient'
    archiveExtension = 'jar'

    from(compileKotlin)
    from(zipTree(originalJar)) {
        exclude 'net/corda/serialization/internal/AttachmentsClassLoaderBuilder*'
        exclude 'net/corda/serialization/internal/ByteBufferStreams*'
        exclude 'net/corda/serialization/internal/DefaultWhitelist*'
        exclude 'net/corda/serialization/internal/amqp/AMQPSerializerFactories*'
        exclude 'net/corda/serialization/internal/amqp/AMQPStreams*'
        exclude 'net/corda/serialization/internal/amqp/AMQPSerializationThreadContext*'
        exclude 'net/corda/serialization/internal/model/DefaultCacheProvider*'
    }

    reproducibleFileOrder = true
    includeEmptyDirs = false
}

import proguard.gradle.ProGuardTask
task predeterminise(type: ProGuardTask, dependsOn: project(':core-deterministic').assemble) {
    injars patchSerialization
    outjars file("$buildDir/proguard/pre-deterministic-${project.version}.jar")

    libraryjars file("$javaHome/lib/rt.jar")
    libraryjars file("$javaHome/lib/jce.jar")
    libraryjars file("$javaHome/lib/ext/sunec.jar")
    configurations.compileClasspath.forEach {
        if (originalJar != it) {
            libraryjars it, filter: '!META-INF/versions/**'
        }
    }

    keepattributes '*'
    keepdirectories
    dontpreverify
    dontobfuscate
    dontoptimize
    dontnote
    printseeds
    verbose

    keep '@net.corda.core.KeepForDJVM class * { *; }', includedescriptorclasses:true
    keepclassmembers 'class net.corda.serialization.** { public synthetic <methods>; }'
}

import net.corda.gradle.jarfilter.JarFilterTask
task jarFilter(type: JarFilterTask) {
    jars predeterminise
    annotations {
        forDelete = [
            "net.corda.core.DeleteForDJVM"
        ]
        forStub = [
            "net.corda.core.StubOutForDJVM"
        ]
        forRemove = [
            "co.paralleluniverse.fibers.Suspendable"
        ]
        forSanitise = [
            "net.corda.core.DeleteForDJVM"
        ]
    }
}

task determinise(type: ProGuardTask) {
    injars jarFilter
    outjars file("$buildDir/proguard/$jarBaseName-${project.version}.jar")

    libraryjars file("$javaHome/lib/rt.jar")
    libraryjars file("$javaHome/lib/jce.jar")
    configurations.deterministicLibraries.forEach {
        libraryjars it, filter: '!META-INF/versions/**'
    }

    // Analyse the JAR for dead code, and remove (some of) it.
    optimizations 'code/removal/simple,code/removal/advanced'
    printconfiguration

    keepattributes '*'
    keepdirectories
    dontobfuscate
    dontnote
    printseeds
    verbose

    keep '@net.corda.core.KeepForDJVM class * { *; }', includedescriptorclasses:true
    keepclassmembers 'class net.corda.serialization.** { public synthetic <methods>; }'
}

import net.corda.gradle.jarfilter.MetaFixerTask
task metafix(type: MetaFixerTask) {
    outputDir file("$buildDir/libs")
    jars determinise
    suffix ""

    // Strip timestamps from the JAR to make it reproducible.
    preserveTimestamps = false
}

task checkDeterminism(type: ProGuardTask, dependsOn: jdkTask) {
    injars metafix

    libraryjars deterministic_rt_jar

    configurations.deterministicLibraries.forEach {
        libraryjars it, filter: '!META-INF/versions/**'
    }

    keepattributes '*'
    dontpreverify
    dontobfuscate
    dontoptimize
    verbose

    keep 'class *'
}

defaultTasks "determinise"
determinise.finalizedBy metafix
metafix.finalizedBy checkDeterminism
assemble.dependsOn checkDeterminism

def deterministicJar = metafix.outputs.files.singleFile
artifacts {
    deterministicArtifacts file: deterministicJar, name: jarBaseName, type: 'jar', extension: 'jar', builtBy: metafix
    publish file: deterministicJar, name: jarBaseName, type: 'jar', extension: 'jar', builtBy: metafix
}

publish {
    dependenciesFrom(configurations.deterministicArtifacts) {
        defaultScope = 'compile'
    }
    publishSources = false
    publishJavadoc = false
    name jarBaseName
}

// Must be after publish {} so that the previous install task exists for overwriting.
task install(overwrite: true, dependsOn: 'publishToMavenLocal')

idea {
    module {
        if (project.hasProperty("deterministic_idea_sdk")) {
            jdkName project.property("deterministic_idea_sdk") as String
        }
    }
}