build.gradle

import com.github.spotbugs.snom.SpotBugsTask
import io.github.gradlenexus.publishplugin.InitializeNexusStagingRepository

plugins {
    id 'java-library'
    id 'distribution'
    id 'jacoco'
    id 'maven-publish'
    id 'pmd'
    id 'signing'
    id 'com.github.spotbugs' version '5.0.12'
    id 'io.github.gradle-nexus.publish-plugin' version '1.1.0'
    id 'org.gradle.test-retry' version '1.3.1'
    id 'org.unbroken-dome.test-sets' version '4.0.0'
}

ext {
    kafkaVersion = '3.5.1'
    solaceJavaAPIVersion = '10.21.0'
    isSnapshot = project.version.endsWith('-SNAPSHOT')
}

repositories {
    mavenLocal()
    mavenCentral()
}

sourceSets {
    main {
        java {
            srcDir "${buildDir}/generated/java" // add generated sources as additional source directory
        }
    }
}

testSets {
    integrationTest
}

dependencies {
    integrationTestImplementation 'org.junit.jupiter:junit-jupiter:5.9.0'
    integrationTestImplementation 'org.junit-pioneer:junit-pioneer:1.5.0'
    integrationTestImplementation 'org.mockito:mockito-junit-jupiter:4.7.0'
    integrationTestImplementation 'org.testcontainers:testcontainers:1.17.3'
    integrationTestImplementation 'org.testcontainers:junit-jupiter:1.17.3'
    integrationTestImplementation 'org.testcontainers:kafka:1.17.3'
    integrationTestImplementation 'org.testcontainers:toxiproxy:1.16.0'
    integrationTestImplementation 'com.solace.test.integration:pubsubplus-junit-jupiter:1.1.0'
    integrationTestImplementation 'org.slf4j:slf4j-api:1.7.36'
    integrationTestImplementation 'org.apache.logging.log4j:log4j-slf4j-impl:2.18.0'
    integrationTestImplementation 'org.apache.commons:commons-configuration2:2.8.0'
    integrationTestImplementation 'commons-beanutils:commons-beanutils:1.9.4'
    integrationTestImplementation 'com.google.code.gson:gson:2.9.1'
    integrationTestImplementation 'commons-io:commons-io:2.11.0'
    integrationTestImplementation 'com.squareup.okhttp3:okhttp:4.10.0'
    integrationTestImplementation "org.apache.kafka:kafka-clients:$kafkaVersion"
    testImplementation 'org.apache.commons:commons-lang3:3.12.0'
    testImplementation 'org.junit.jupiter:junit-jupiter:5.9.0'
    testImplementation 'org.mockito:mockito-junit-jupiter:4.7.0'
    testImplementation 'org.hamcrest:hamcrest-all:1.3'
    testImplementation 'org.apache.logging.log4j:log4j-slf4j-impl:2.18.0'
    implementation "org.apache.kafka:connect-api:$kafkaVersion"
    implementation "com.solacesystems:sol-jcsmp:$solaceJavaAPIVersion"
    implementation "org.slf4j:slf4j-api:1.7.36"
}

pmd {
    consoleOutput = true
    toolVersion = '6.49.0'
    rulesMinimumPriority = 2
    sourceSets = [sourceSets.main]
}

spotbugs {
    effort 'max'
    reportLevel 'high' // Decrease to medium once medium errors are fixed
}

// Generate manifest.json file to be compliant with Confluent Hub client
tasks.register('generateConfluentConnectManifest', Copy) {
    def templateContext = [
            "project": project.properties
    ]
    from 'src/template/manifest'
    into "${buildDir}/generated/manifest"
    expand templateContext
}

spotbugsIntegrationTest {
    enabled = false
}

task('jacocoFullReport', type: JacocoReport) {
    description 'Generates code coverage report for all tests.'
    executionData tasks.withType(Test)
    sourceSets sourceSets.main
    reports {
        xml.required = true
    }
}

task('prepDistForIntegrationTesting') {
    dependsOn assembleDist
    doLast {
        copy {
            from zipTree(file(distsDirectory).listFiles().findAll {
                it.name.endsWith("-${project.version}.zip")
            }[0])
            into sourceSets.integrationTest.resources.srcDirs[0]
        }
        copy {
            from zipTree(file(distsDirectory).listFiles().findAll {
                it.name.endsWith("-${project.version}.zip")
            }[0])
            into sourceSets.integrationTest.output.resourcesDir
        }
    }
}

project.integrationTest {
    useJUnitPlatform()
    outputs.upToDateWhen { false }
    dependsOn prepDistForIntegrationTesting
    shouldRunAfter test
    retry {
        maxRetries = 3
    }
    afterSuite { desc, result ->
        if (!desc.parent)
            println("${result.resultType} " +
                    "(${result.testCount} tests, " +
                    "${result.successfulTestCount} successes, " +
                    "${result.failedTestCount} failures, " +
                    "${result.skippedTestCount} skipped)")
    }
}

project.test {
    useJUnitPlatform()
}

tasks.withType(SpotBugsTask) {
    reports {
        sarif {
            enabled = true
        }
    }
}

// Workaround to generate Sarif report
// Based off https://github.com/gradle/gradle/blob/v6.9.1/subprojects/code-quality/src/main/groovy/org/gradle/api/plugins/quality/internal/PmdInvoker.groovy
task('pmdMainSarif') {
    PmdExtension extension = project.extensions.getByType(PmdExtension)
    dependsOn classes
    outputs.dir extension.getReportsDir()
    doLast {
        ant.taskdef(name: 'pmd',
                classname: 'net.sourceforge.pmd.ant.PMDTask',
                classpath: project.configurations.pmd.asPath)
        ant.pmd(failOnRuleViolation: false,
                failuresPropertyName: "pmdFailureCount",
                minimumPriority: extension.rulesMinimumPriority.get()) {
            sourceSets.main.allJava.srcDirs.each {
                fileset(dir: it)
            }

            extension.ruleSets.each {
                ruleset(it)
            }

            extension.ruleSetFiles.each {
                ruleset(it)
            }

            if (extension.ruleSetConfig != null) {
                ruleset(extension.ruleSetConfig.asFile())
            }

            Provider<RegularFile> reportsDir = project.getLayout()
                    .file(project.getProviders().provider({ a -> extension.getReportsDir() }) as Provider<File>)
            formatter(type: 'sarif', toFile: new File(reportsDir.get().getAsFile(), 'main.sarif'))
            formatter(type: 'html', toFile: new File(reportsDir.get().getAsFile(), 'main.html'))

            if (extension.consoleOutput) {
                formatter(type: 'textcolor', toConsole: true)
            }
        }

        def failureCount = ant.project.properties["pmdFailureCount"]
        if (failureCount) {
            def message = "$failureCount PMD rule violations were found."
            if (extension.ignoreFailures || ((failureCount as Integer) <= extension.maxFailures.get())) {
                logger.warn(message)
            } else {
                throw new GradleException(message)
            }
        }
    }
}

task sourcesJar(type: Jar, dependsOn: classes) {
    classifier = 'sources'
    from sourceSets.main.allSource
}

task('generateJava', type: Copy) {
    def templateContext = [version: project.version]
    inputs.properties templateContext // Register context as input so that task doesn't skip when props are updated
    from 'src/template/java'
    into "${buildDir}/generated/java"
    expand templateContext
}

project.compileJava {
    dependsOn generateJava
    sourceCompatibility '11'
    targetCompatibility '11'
}

project.compileTestJava {
    sourceCompatibility '11'
    targetCompatibility '11'
}

project.compileIntegrationTestJava {
    sourceCompatibility '11'
    targetCompatibility '11'
}

java {
    withJavadocJar()
    withSourcesJar()
}

distributions {
    main {
        contents {
            from('etc/solace_sink.properties') { into 'etc' }
            from('etc/solace_sink_properties.json') { into 'etc' }
            from('doc/distribution-readme.md') { into 'doc' }
            from('LICENSE') { into 'doc' }
            from('THIRD-PARTY-LICENSES') { into 'doc' }
            from(generateConfluentConnectManifest) {into ''}
            into('lib') {
                from jar
                from(project.configurations.runtimeClasspath)
            }
            // from jar
        }
    }
}

publishing {
    publications {
        maven(MavenPublication) {
            from components.java
            pom {
                name = "Solace PubSub+ Connector for Kafka: Sink"
                description = "The PubSub+ Kafka Sink Connector consumes Kafka topic records and streams them to the PubSub+ Event Mesh as topic and/or queue data events."
                url = "https://github.com/SolaceProducts/pubsubplus-connector-kafka-sink"
                packaging = "jar"
                licenses {
                    license {
                        name = "Apache License, Version 2.0"
                        url = "https://github.com/SolaceProducts/pubsubplus-connector-kafka-sink/blob/master/LICENSE"
                        distribution = "repo"
                    }
                }
                organization {
                    name = "Solace"
                    url = "https://www.solace.com"
                }
                developers {
                    developer {
                        name = "Support for Solace"
                        email = "support@solace.com"
                        organization = "Solace"
                        organizationUrl = "https://solace.community"
                    }
                }
                scm {
                    connection = "scm:git:git://github.com/SolaceProducts/pubsubplus-connector-kafka-sink.git"
                    developerConnection = "scm:git:git@github.com:SolaceProducts/pubsubplus-connector-kafka-sink.git"
                    url = "https://github.com/SolaceProducts/pubsubplus-connector-kafka-sink.git"
                }
            }
        }
    }
    repositories {
        maven {
            def releasesUrl = uri('http://apps-jenkins:9090/nexus/content/repositories/releases')
            def snapshotRepositoryUrl = uri('http://apps-jenkins:9090/nexus/content/repositories/snapshots')
            url = isSnapshot ? snapshotRepositoryUrl : releasesUrl
            allowInsecureProtocol = true
            name = 'internal'
            credentials {
                username = project.properties[name + "Username"]
                password = project.properties[name + "Password"]
            }
        }
    }
}

nexusPublishing {
    repositories {
        sonatype {
            nexusUrl = uri('https://oss.sonatype.org/service/local/')
            snapshotRepositoryUrl = uri('https://oss.sonatype.org/content/repositories/snapshots')
            // gets credentials from project.properties["sonatypeUsername"] project.properties["sonatypePassword"]
        }
    }
}

signing {
    required {
        !isSnapshot
    }
    useGpgCmd()
    sign publishing.publications.maven
}

tasks.withType(Sign) {
    onlyIf {
        gradle.taskGraph.allTasks.any { task ->
            task.name.startsWith("publish") && task.name.contains('Sonatype')
        }
    }
    shouldRunAfter test, integrationTest
}

tasks.withType(InitializeNexusStagingRepository).configureEach {
    dependsOn test, integrationTest
    shouldRunAfter tasks.withType(Sign)
}

tasks.withType(PublishToMavenRepository).configureEach {
    dependsOn test, integrationTest
}