build.gradle

/*
 * Copyright 2013-2020 Real Logic Limited.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
buildscript {
    repositories {
        mavenCentral()
    }
}

plugins {
    id 'java-library'
    id 'idea'
    id 'com.github.johnrengelman.shadow' version '6.1.0' apply false
    id "com.github.ben-manes.versions" version "0.34.0"
}

defaultTasks 'clean', 'build'

def checkstyleVersion = '8.36.2'
def hamcrestVersion = '2.2'
def mockitoVersion = '3.6.0'
def junitVersion = '5.7.0'
def jmhVersion = '1.26'
def agronaVersion = '1.8.0'
def agronaVersionRange = '[1.8,1.9[' // allow any patch release of 1.8.x

def sbeGroup = 'uk.co.real-logic'
def sbeVersion = file('version.txt').text.trim()

ext {
    isReleaseVersion = !sbeVersion.endsWith('-SNAPSHOT')
    releasesRepoUrl = 'https://oss.sonatype.org/service/local/staging/deploy/maven2/'
    snapshotsRepoUrl = 'https://oss.sonatype.org/content/repositories/snapshots/'

    if (!project.hasProperty('ossrhUsername')) {
        ossrhUsername = ''
    }

    if (!project.hasProperty('ossrhPassword')) {
        ossrhPassword = ''
    }
}

def projectPom = {
    name = 'sbe'
    packaging = 'pom'
    description = 'FIX/SBE - OSI layer 6 presentation for encoding and decoding application messages' +
        ' in binary format for low-latency applications'
    url = 'https://github.com/real-logic/simple-binary-encoding'

    scm {
        connection = 'scm:git:github.com/real-logic/simple-binary-encoding.git'
        developerConnection = 'scm:git:github.com/real-logic/simple-binary-encoding.git'
        url = 'github.com/real-logic/simple-binary-encoding.git'
    }

    licenses {
        license {
            name = 'The Apache License, Version 2.0'
            url = 'https://www.apache.org/licenses/LICENSE-2.0.txt'
        }
    }

    developers {
        developer {
            id = 'tmontgomery'
            name = 'Todd L. Montgomery'
            email = 'tmont@nard.net'
            url = 'https://github.com/tmontgomery'
        }
        developer {
            id = 'mjpt777'
            name = 'Martin Thompson'
            email = 'mjpt777@gmail.com'
            url = 'https://github.com/mjpt777'
        }
        developer {
            id = 'odeheurles'
            name = 'Olivier Deheurles'
            email = 'olivier@weareadaptive.com'
            url = 'https://github.com/odeheurles'
        }
        developer {
            id = 'RichardWarburton'
            name = 'Richard Warburton'
            email = 'richard.warburton@gmail.com'
            url = 'https://github.com/RichardWarburton'
        }
        developer {
            id = 'BillSegall'
            name = 'Bill Segall'
            email = 'bill.segall@gmail.com'
            url = 'https://github.com/BillSegall'
        }
        developer {
            id = 'mikeb01'
            name = 'Mike Barker'
            email = 'mikeb01@gmail.com'
            url = 'https://github.com/mikeb01'
        }
        developer {
            id = 'vyazelenko'
            name = 'Dmitry Vyazelenko'
            email = 'vyazelenko@yahoo.com'
            url = 'https://github.com/vyazelenko'
        }
    }
}

allprojects {
    repositories {
        mavenLocal()
        mavenCentral()
    }

    configurations.all {
        resolutionStrategy {
            failOnVersionConflict()
        }
    }
}

jar.enabled = false

subprojects {
    apply plugin: 'java-library'
    apply plugin: 'checkstyle'
    apply plugin: 'eclipse'

    group = sbeGroup
    version = sbeVersion

    checkstyle.toolVersion = "${checkstyleVersion}"

    tasks.withType(Sign) {
        onlyIf {
            isReleaseVersion && gradle.taskGraph.hasTask(tasks.publish)
        }
    }

    tasks.withType(Jar) {
        enabled = true
        includeEmptyDirs = false
    }

    tasks.withType(JavaCompile) {
        if (JavaVersion.current().isJava9Compatible()) {
            options.compilerArgs.addAll(['--add-exports', 'java.base/java.lang.reflect=ALL-UNNAMED'])
            options.compilerArgs.addAll(['--add-exports', 'jdk.unsupported/sun.misc=ALL-UNNAMED'])
        }
        options.encoding = 'UTF-8'
        options.deprecation = true
    }

    javadoc {
        failOnError false
        title = '<h1>Simple Binary Encoding (SBE)</h1>'
        options.bottom = '<i>Copyright &#169; 2013-2020 Real Logic Limited. All Rights Reserved.</i>'
        options.encoding = 'UTF-8'
        options.docEncoding = 'UTF-8'
        options.charSet = 'UTF-8'
        options.links("https://www.javadoc.io/doc/org.agrona/agrona/${agronaVersion}/")
        if (JavaVersion.current().isJava11Compatible()) {
            options.links("https://docs.oracle.com/en/java/javase/${JavaVersion.current().majorVersion}/docs/api/")
        } else {
            options.links("https://docs.oracle.com/javase/${JavaVersion.current().majorVersion}/docs/api/")
        }
        if (JavaVersion.current().isJava10Compatible()) {
            options.addBooleanOption 'html5', true
        }
    }

    test {
        if (JavaVersion.current().isJava9Compatible()) {
            jvmArgs('--add-opens', 'java.base/java.lang.reflect=ALL-UNNAMED')
            jvmArgs('--add-exports', 'jdk.unsupported/sun.misc=ALL-UNNAMED')
        }

        useJUnitPlatform()

        testLogging {
            showStandardStreams = true
            exceptionFormat = 'full'
        }
    }
}

def validationXsdPath = project(':sbe-tool').projectDir.toString() + '/src/main/resources/fpl/sbe.xsd'

project(':sbe-tool') {
    apply plugin: 'maven-publish'
    apply plugin: 'signing'

    dependencies {
        api("org.agrona:agrona") {
            version {
                strictly(agronaVersionRange)
                prefer(agronaVersion)
            }
        }
        testImplementation files('build/classes/java/generated')
        testImplementation "org.hamcrest:hamcrest:${hamcrestVersion}"
        testImplementation ("org.mockito:mockito-junit-jupiter:${mockitoVersion}") {
            exclude group: 'org.junit.jupiter'
        }
        testImplementation "org.junit.jupiter:junit-jupiter-api:${junitVersion}"
        testImplementation "org.junit.jupiter:junit-jupiter-params:${junitVersion}"
        testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${junitVersion}"
    }

    def generatedDir = 'build/generated-src'
    sourceSets {
        generated {
            java.srcDir generatedDir
            compileClasspath += sourceSets.main.runtimeClasspath
        }
        test {
            java.srcDir generatedDir
            compileClasspath += sourceSets.main.runtimeClasspath
        }
    }

    compileGeneratedJava {
        dependsOn 'generateTestCodecs'
        classpath += sourceSets.main.runtimeClasspath
    }

    compileTestJava.dependsOn compileGeneratedJava

    task generateTestCodecs(dependsOn: 'compileJava', type: JavaExec) {
        main = 'uk.co.real_logic.sbe.SbeTool'
        classpath = sourceSets.main.runtimeClasspath
        systemProperties(
            'sbe.output.dir': generatedDir,
            'sbe.target.language': 'Java',
            'sbe.validation.stop.on.error': 'true',
            'sbe.validation.xsd': validationXsdPath)
        args = ['src/test/resources/json-printer-test-schema.xml',
                'src/test/resources/composite-elements-schema.xml']
    }

    jar {
        manifest.attributes(
            'Specification-Title': 'Simple Binary Encoding',
            'Specification-Version': '1.0',
            'Implementation-Title': 'SBE',
            'Implementation-Version': sbeVersion,
            'Implementation-Vendor': 'Real Logic Limited',
            'Automatic-Module-Name': 'uk.co.real_logic.sbe.tool'
        )
    }

    task sourcesJar(type: Jar) {
        archiveClassifier.set('sources')
        from sourceSets.main.allSource
        from ('src/main/cpp/otf') {
            into 'cpp'
        }
    }

    java {
        withSourcesJar()
        withJavadocJar()
    }

    publishing {
        publications {
            sbe(MavenPublication) {
                from components.java
                pom(projectPom)
            }
        }

        repositories {
            maven {
                url = !isReleaseVersion ? snapshotsRepoUrl : releasesRepoUrl
                credentials {
                    username = ossrhUsername
                    password = ossrhPassword
                }
            }
        }
    }

    signing {
        sign publishing.publications.sbe
    }
}

project(':sbe-all') {
    apply plugin: 'maven-publish'
    apply plugin: 'signing'
    apply plugin: 'com.github.johnrengelman.shadow'

    dependencies {
        implementation project(':sbe-tool')
    }

    shadowJar {
        archiveClassifier.set('')
        manifest.attributes(
            'Main-Class': 'uk.co.real_logic.sbe.SbeTool',
            'Specification-Title': 'Simple Binary Encoding',
            'Specification-Version': '1.0',
            'Implementation-Title': 'SBE',
            'Implementation-Version': sbeVersion,
            'Implementation-Vendor': 'Real Logic Limited',
            'Automatic-Module-Name': 'uk.co.real_logic.sbe.all'
        )
    }

    jar.finalizedBy shadowJar

    task sourcesJar(type: Jar) {
        archiveClassifier.set('sources')
        from project(':sbe-tool').sourceSets.main.allSource
        from (project(':sbe-tool').file('src/main/cpp/otf')) {
            into 'cpp'
        }
    }

    javadoc {
        source += project(':sbe-tool').sourceSets.main.allJava
    }

    task javadocJar(type: Jar, dependsOn: javadoc) {
        archiveClassifier.set('javadoc')
        from javadoc.destinationDir
    }

    publishing {
        publications {
            sbeAll(MavenPublication) {
                artifact shadowJar
                artifact sourcesJar
                artifact javadocJar
                pom(projectPom)
            }
        }
        repositories {
            maven {
                url = !isReleaseVersion ? snapshotsRepoUrl : releasesRepoUrl
                credentials {
                    username = ossrhUsername
                    password = ossrhPassword
                }
            }
        }
    }

    signing {
        sign publishing.publications.sbeAll
    }
}

project(':sbe-samples') {
    apply plugin: 'maven-publish'
    apply plugin: 'signing'

    dependencies {
        api project(':sbe-tool')
        implementation files('build/classes/java/generated')
    }

    def generatedDir = 'build/generated-src'
    sourceSets {
        generated {
            java.srcDir generatedDir
            compileClasspath += project(':sbe-all').sourceSets.main.runtimeClasspath
        }
    }

    compileJava.dependsOn 'compileGeneratedJava'
    compileGeneratedJava.dependsOn 'generateCodecs'

    task generateCodecs(type: JavaExec) {
        main = 'uk.co.real_logic.sbe.SbeTool'
        classpath = project(':sbe-all').sourceSets.main.runtimeClasspath
        systemProperties(
            'sbe.output.dir': generatedDir,
            'sbe.target.language': 'Java',
            'sbe.java.generate.interfaces': 'true',
            'sbe.validation.stop.on.error': 'true',
            'sbe.xinclude.aware': 'true',
            'sbe.validation.xsd': validationXsdPath)
        args = ['src/main/resources/example-schema.xml', 'src/main/resources/example-extension-schema.xml']
    }

    task runExampleUsingGeneratedStub(dependsOn: 'compileJava', type: JavaExec) {
        classpath = sourceSets.main.runtimeClasspath
        main = 'uk.co.real_logic.sbe.examples.ExampleUsingGeneratedStub'
        systemProperties System.getProperties()
    }

    task runExampleUsingGeneratedStubExtension(dependsOn: 'compileJava', type: JavaExec) {
        classpath = sourceSets.main.runtimeClasspath
        main = 'uk.co.real_logic.sbe.examples.ExampleUsingGeneratedStubExtension'
        systemProperties System.getProperties()
    }

    task runOtfExample(dependsOn: 'compileJava', type: JavaExec) {
        classpath = sourceSets.main.runtimeClasspath
        main = 'uk.co.real_logic.sbe.examples.OtfExample'
        workingDir = 'src/main/resources'
    }

    task runJavaExamples {
        dependsOn 'runExampleUsingGeneratedStub', 'runExampleUsingGeneratedStubExtension', 'runOtfExample'
    }

    jar {
        from sourceSets.generated.output

        manifest.attributes(
            'Main-Class': 'uk.co.real_logic.sbe.SbeTool',
            'Specification-Title': 'Simple Binary Encoding',
            'Specification-Version': '1.0',
            'Implementation-Title': 'SBE',
            'Implementation-Version': sbeVersion,
            'Implementation-Vendor': 'Real Logic Limited',
            'Automatic-Module-Name': 'uk.co.real_logic.sbe.samples'
        )
    }

    task sourcesJar(type: Jar) {
        archiveClassifier.set('sources')
        from sourceSets.main.allSource
        from sourceSets.generated.allSource
    }

    javadoc {
        source += sourceSets.generated.allJava
        source += project(':sbe-tool').sourceSets.main.allJava
    }

    java {
        withSourcesJar()
        withJavadocJar()
    }

    publishing {
        publications {
            sbeSamples(MavenPublication) {
                from components.java
                pom(projectPom)
            }
        }

        repositories {
            maven {
                url = !isReleaseVersion ? snapshotsRepoUrl : releasesRepoUrl
                credentials {
                    username = ossrhUsername
                    password = ossrhPassword
                }
            }
        }
    }

    signing {
        sign publishing.publications.sbeSamples
    }
}

project(':sbe-benchmarks') {
    apply plugin: 'com.github.johnrengelman.shadow'

    dependencies {
        implementation "org.openjdk.jmh:jmh-core:${jmhVersion}"
        annotationProcessor "org.openjdk.jmh:jmh-generator-annprocess:${jmhVersion}"
        implementation project(':sbe-tool')
        implementation files('build/classes/java/generated')
    }

    sourceSets {
        generated {
            java.srcDir 'build/generated-src'
            compileClasspath += project(':sbe-all').sourceSets.main.runtimeClasspath
        }
    }

    compileGeneratedJava.dependsOn 'generateCodecs'
    compileJava.dependsOn 'compileGeneratedJava'

    task generateCodecs(type: JavaExec) {
        main = 'uk.co.real_logic.sbe.SbeTool'
        classpath = project(':sbe-all').sourceSets.main.runtimeClasspath
        systemProperties(
            'sbe.output.dir': 'build/generated-src',
            'sbe.target.language': 'Java',
            'sbe.validation.stop.on.error': 'true',
            'sbe.validation.xsd': validationXsdPath,
            'sbe.java.encoding.buffer.type': 'org.agrona.concurrent.UnsafeBuffer',
            'sbe.java.decoding.buffer.type': 'org.agrona.concurrent.UnsafeBuffer')
        args = ['src/main/resources/car.xml', 'src/main/resources/fix-message-samples.xml']
    }

    shadowJar {
        archiveFileName = 'sbe-benchmarks.jar'
        archiveClassifier.set('benchmarks')
        manifest.attributes('Main-Class': 'org.openjdk.jmh.Main')
    }

    jar.finalizedBy shadowJar

    javadoc.enabled = false
}

/*
 * Golang codec targets used for testing, benchmarking etc. We have
 * multiple targets as:
 *  *) some of the test files generate warnings from the xsd so we don't
 *     validate those.
 *  *) Some of the test files need an additional output directory setting
 *     as they generate into the same directory and golang won't allow that.
 *  *) Some examples need to fiddle with WorkingDir to deal with XInclude
 */
task generateGolangCodecTestComposite(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-tool').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'gocode/src',
        'sbe.target.language': 'golang')
    args = ['sbe-tool/src/test/resources/composite-elements-schema-rc4.xml']
}

task generateGolangCodecTestBasic(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-tool').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'gocode/src/basic',
        'sbe.target.language': 'golang')
    args = ['sbe-tool/src/test/resources/basic-types-schema.xml']
}

task generateGolangCodecTestGroup(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-tool').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'gocode/src/group',
        'sbe.target.language': 'golang')
    args = ['sbe-tool/src/test/resources/basic-group-schema.xml']
}

task generateGolangCodecTestVarData(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-tool').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'gocode/src/vardata',
        'sbe.target.language': 'golang')
    args = ['sbe-tool/src/test/resources/basic-variable-length-schema.xml']
}

task generateGolangCodecsWithXIncludes(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-tool').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'gocode/src',
        'sbe.target.language': 'golang',
        'sbe.xinclude.aware': 'true',
        'sbe.validation.xsd': validationXsdPath)
    args = ['sbe-samples/src/main/resources/example-schema.xml',
            'sbe-samples/src/main/resources/example-extension-schema.xml']
}

task generateGolangCodecsWithXSD(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-tool').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'gocode/src',
        'sbe.target.language': 'golang',
        'sbe.xinclude.aware': 'true',
        'sbe.validation.xsd': validationXsdPath)
    args = ['sbe-tool/src/test/resources/group-with-data-schema.xml',
            'sbe-tool/src/test/resources/FixBinary.xml',
            'sbe-tool/src/test/resources/issue435.xml',
            'sbe-tool/src/test/resources/issue472.xml',
            'sbe-tool/src/test/resources/issue483.xml',
            'sbe-tool/src/test/resources/issue488.xml',
            'sbe-tool/src/test/resources/issue560.xml',
            'sbe-tool/src/test/resources/issue661.xml',
            'sbe-tool/src/test/resources/since-deprecated-test-schema.xml',
            'sbe-tool/src/test/resources/example-bigendian-test-schema.xml',
            'gocode/resources/example-composite.xml',
            'gocode/resources/group-with-data-extension-schema.xml',
            'gocode/resources/simple.xml']
}

task generateGolangCodecs {
    description = 'Generate golang test codecs'
    dependsOn 'generateGolangCodecTestVarData',
        'generateGolangCodecTestGroup',
        'generateGolangCodecTestBasic',
        'generateGolangCodecTestComposite',
        'generateGolangCodecsWithXIncludes',
        'generateGolangCodecsWithXSD'
}

/*
 * CSharp codec targets used for testing, benchmarking etc. We have
 * multiple targets as XInclude forces us to change working dir
 */
task generateCSharpCodecsWithXIncludes(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-tool').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'csharp/sbe-generated',
        'sbe.target.language': 'uk.co.real_logic.sbe.generation.csharp.CSharp',
        'sbe.xinclude.aware': 'true',
        'sbe.validation.xsd': validationXsdPath)
    args = ['sbe-samples/src/main/resources/example-schema.xml',
            'sbe-samples/src/main/resources/example-extension-schema.xml']
}

task generateCSharpCodecsTests(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-tool').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'csharp/sbe-generated',
        'sbe.target.language': 'uk.co.real_logic.sbe.generation.csharp.CSharp',
        'sbe.xinclude.aware': 'true',
        'sbe.validation.xsd': validationXsdPath)
    args = ['sbe-tool/src/test/resources/FixBinary.xml',
            'sbe-tool/src/test/resources/issue435.xml',
            'sbe-tool/src/test/resources/issue483.xml',
            'sbe-tool/src/test/resources/issue560.xml',
            'sbe-tool/src/test/resources/since-deprecated-test-schema.xml',
            'sbe-tool/src/test/resources/example-bigendian-test-schema.xml',
            'sbe-benchmarks/src/main/resources/fix-message-samples.xml']
}

task generateCSharpCodecs {
    description = 'Generate csharp codecs'
    dependsOn 'generateCSharpCodecsTests',
        'generateCSharpCodecsWithXIncludes'
}

task generateJavaIrCodecs(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-all').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'sbe-tool/src/main/java',
        'sbe.target.language': 'Java',
        'sbe.validation.xsd': validationXsdPath)
    args = ['sbe-tool/src/main/resources/sbe-ir.xml']
}

task generateCppIrCodecs(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-tool').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'sbe-tool/src/main/cpp',
        'sbe.target.language': 'cpp',
        'sbe.validation.xsd': validationXsdPath)
    args = ['sbe-tool/src/main/resources/sbe-ir.xml']
}

task generateGolangIrCodecs(type: JavaExec) {
    main = 'uk.co.real_logic.sbe.SbeTool'
    classpath = project(':sbe-tool').sourceSets.main.runtimeClasspath
    systemProperties(
        'sbe.output.dir': 'sbe-tool/src/main/golang',
        'sbe.target.language': 'golang',
        'sbe.validation.xsd': validationXsdPath)
    args = ['sbe-tool/src/main/resources/sbe-ir.xml']
}

task generateIrCodecs {
    description = 'Generate Java, C++, and golang IR Codecs'
    dependsOn 'generateJavaIrCodecs', 'generateCppIrCodecs', 'generateGolangIrCodecs'
}

task runJavaBenchmarks(type: Exec) {
    commandLine 'java',
        '-jar', 'sbe-benchmarks/build/libs/sbe-benchmarks.jar',
        '-jvmArgs', '-Dagrona.disable.bounds.checks=true -XX:+UseParallelOldGC',
        '-w', '1s', '-r', '1s','-wi', '3', '-i', '5', '-tu', 'ns', '-f', '5'
}

task testReport(type: TestReport) {
    destinationDir = file("$buildDir/reports/allTests")
    // Include the results from the `test` task in all sub-projects
    reportOn subprojects*.test
}

wrapper {
    gradleVersion = '6.6.1'
    distributionType = 'ALL'
}