build.gradle

/*
 * Copyright 2019 Aiven Oy and http-connector-for-apache-kafka project contributors
 *
 * 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
 *
 * http://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.
 */

plugins {
    // https://docs.gradle.org/current/userguide/java_library_plugin.html
    id 'java-library'

    // https://docs.gradle.org/current/userguide/distribution_plugin.html
    id 'distribution'

    // https://docs.gradle.org/current/userguide/checkstyle_plugin.html
    id 'checkstyle'

    // https://docs.gradle.org/current/userguide/idea_plugin.html
    id 'idea'

    // https://plugins.gradle.org/plugin/nebula.lint
    id "nebula.lint" version "18.1.0"

    // https://plugins.gradle.org/plugin/com.github.spotbugs
    id "com.github.spotbugs" version "5.1.3"

    // https://plugins.gradle.org/plugin/com.diffplug.gradle.spotless
    id "com.diffplug.spotless" version "6.22.0"
}

repositories {
    mavenCentral()
    maven {
        url "https://packages.confluent.io/maven"
    }
}

sourceCompatibility = JavaVersion.VERSION_11
targetCompatibility = JavaVersion.VERSION_11

wrapper {
    distributionType = 'ALL'
    doLast {
        def sha256Sum = new String(new URL("${distributionUrl}.sha256").bytes)
        propertiesFile << "distributionSha256Sum=${sha256Sum}\n"
        println "Added checksum to wrapper properties"
    }
}

ext {
    moduleName = "io.aiven.kafka.connect.http"

    avroVersion = "1.9.2" // Version 1.9.2 brings Jackson 2.10.2 package for Avro
    confluentPlatformVersion = "6.0.2" // For compatibility tests use version 6.0.2 to match Kafka 2.6.
                                       // NOTE: Confluent Platform v6.0.3 has a dependency mismatch issue.
    hamcrestVersion = "2.2"
    jacksonVersion = "2.15.2" // This Jackson is used in the tests.
    jupiterVersion = "5.10.0"
    kafkaVersion = '2.6.3'
    jettyVersion = "9.4.51.v20230217"
    junit4Version = "4.13.2"
    jsr305Version = "3.0.2"
    log4jVersion = "2.20.0"
    mockitoVersion = '5.5.0'
    servletVersion = "4.0.1"
    slf4japiVersion = "1.7.36"
    spotbugsAnnotationsVersion = "4.7.3"
    testcontainersVersion = '1.19.0'
    assertjVersion = "3.24.2"
    awaitilityVersion = "4.2.0"
}

distributions {
    main {
        contents {
            from jar
            from configurations.runtimeClasspath
        }
    }
}

sourceSets {
    integrationTest {
        java.srcDir file('src/integration-test/java')
        resources.srcDir file('src/integration-test/resources')
        compileClasspath += sourceSets.main.output + configurations.testRuntimeClasspath
        runtimeClasspath += output + compileClasspath
    }
}

idea {
    module {
        testSources.from(sourceSets.integrationTest.java.srcDirs)
        testSources.from(sourceSets.integrationTest.resources.srcDirs)
    }
}

configurations {
    integrationTestImplementation.extendsFrom testImplementation
    integrationTestRuntimeOnly.extendsFrom testRuntimeOnly
}

dependencies {
    compileOnly "org.apache.kafka:connect-api:$kafkaVersion"
    compileOnly "org.apache.kafka:connect-json:$kafkaVersion"
    compileOnly "org.apache.kafka:kafka-clients:$kafkaVersion"

    // For Spotbugs suppressions
    compileOnly "com.github.spotbugs:spotbugs-annotations:$spotbugsAnnotationsVersion"
    compileOnly "com.google.code.findbugs:jsr305:$jsr305Version"

    implementation "com.fasterxml.jackson.core:jackson-core:$jacksonVersion"
    implementation "com.fasterxml.jackson.core:jackson-databind:$jacksonVersion"
    implementation "org.slf4j:slf4j-api:$slf4japiVersion"

    testRuntimeOnly "org.apache.kafka:connect-json:$kafkaVersion"
    testRuntimeOnly "org.apache.logging.log4j:log4j-slf4j-impl:$log4jVersion"
    testRuntimeOnly "org.junit.jupiter:junit-jupiter:$jupiterVersion"

    testImplementation "org.apache.kafka:connect-api:$kafkaVersion"
    testImplementation "org.junit.jupiter:junit-jupiter-api:$jupiterVersion"
    testImplementation "org.junit.jupiter:junit-jupiter-params:$jupiterVersion"
    testImplementation "org.mockito:mockito-core:$mockitoVersion"
    testImplementation "org.mockito:mockito-junit-jupiter:$mockitoVersion"
    testImplementation "org.assertj:assertj-core:$assertjVersion"

    integrationTestRuntimeOnly "io.confluent:kafka-avro-serializer:$confluentPlatformVersion"
    integrationTestRuntimeOnly "io.confluent:kafka-connect-avro-converter:$confluentPlatformVersion"
    integrationTestRuntimeOnly "io.confluent:kafka-json-serializer:$confluentPlatformVersion"
    integrationTestRuntimeOnly "org.junit.jupiter:junit-jupiter:$jupiterVersion"
    integrationTestRuntimeOnly "org.apache.logging.log4j:log4j-slf4j-impl:$log4jVersion"

    integrationTestImplementation "org.apache.kafka:connect-runtime:$kafkaVersion"
    integrationTestImplementation "com.fasterxml.jackson.core:jackson-annotations:$jacksonVersion"
    integrationTestImplementation "javax.servlet:javax.servlet-api:$servletVersion"
    integrationTestImplementation "org.apache.avro:avro:$avroVersion"
    integrationTestImplementation "org.apache.kafka:connect-runtime:$kafkaVersion"
    integrationTestImplementation "org.eclipse.jetty:jetty-http:$jettyVersion"
    integrationTestImplementation "org.eclipse.jetty:jetty-server:$jettyVersion"
    integrationTestImplementation "org.eclipse.jetty:jetty-util:$jettyVersion"
    integrationTestImplementation "junit:junit:$junit4Version" // This is for testcontainers
    integrationTestImplementation "org.testcontainers:junit-jupiter:$testcontainersVersion"
    integrationTestImplementation "org.testcontainers:kafka:$testcontainersVersion" // this is not Kafka version
    integrationTestImplementation "org.testcontainers:testcontainers:$testcontainersVersion"
    integrationTestImplementation "org.awaitility:awaitility:$awaitilityVersion"

    // Make test utils from 'test' available in 'integration-test'
    integrationTestImplementation sourceSets.test.output
}

checkstyle {
    toolVersion '10.12.0'
}

compileJava {
    // Enable modules.
    inputs.property('moduleName', moduleName)
    doFirst {
        options.compilerArgs = [
                '--module-path', classpath.asPath
        ]
        classpath = files()
    }
}

test {
    useJUnitPlatform {
        includeEngines 'junit-jupiter'
    }
}

tasks.register('integrationTest', Test) {
    description = 'Runs the integration tests.'
    group = 'verification'
    testClassesDirs = sourceSets.integrationTest.output.classesDirs
    classpath = sourceSets.integrationTest.runtimeClasspath

    // defines testing order
    shouldRunAfter test
    // requires archive for connect runner
    dependsOn distTar

    useJUnitPlatform()

    // Run always.
    outputs.upToDateWhen { false }

    // Pass the distribution file path to the tests.
    systemProperty("integration-test.distribution.file.path", distTar.archiveFile.get().asFile.path)
}

tasks.javadoc {
    // disable missing javadoc lint and show only warning and error messages
    options.addStringOption('Xdoclint:all,-missing', '-quiet')
}

processResources {
    filesMatching('http-connector-for-apache-kafka-version.properties') {
        expand(version: version)
    }
}

jar {
    manifest {
        attributes(
                'Version': "${getArchiveVersion().get()}"
        )
    }
}

tasks.register('connectorConfigDoc') {
    description = "Generates the connector's configuration documentation."
    group = "documentation"
    dependsOn "classes"

    doLast {
        javaexec {
            main = "io.aiven.kafka.connect.http.config.HttpSinkConfig"
            classpath = sourceSets.main.runtimeClasspath + sourceSets.main.compileClasspath
            standardOutput = new FileOutputStream("$projectDir/docs/sink-connector-config-options.rst")
        }
    }
}

spotless {
    format "xml", {
        target "**/*.xml"
        targetExclude ".*/**", "gradle/wrapper/**"
        eclipseWtp("xml").configFile("${project.rootDir}/config/spotless-eclipse-wtp-xml.prefs")
        endWithNewline()
    }

    format "misc", {
        target "**/*.gradle", "**/*.md", "**/*.properties"
        targetExclude ".*/**", "gradle/wrapper/**"
        endWithNewline()
        indentWithSpaces()
        trimTrailingWhitespace()
    }
}

spotbugs {
    toolVersion = "4.7.3"
    excludeFilter = file("${project.rootDir}/config/spotbugs-exclude.xml")
}
spotbugsMain {
    reports {
        html {
            enabled = true
            stylesheet = 'fancy-hist.xsl'
        }
    }
}
spotbugsTest {
    reports {
        html {
            enabled = true
            stylesheet = 'fancy-hist.xsl'
        }
    }
}
spotbugsIntegrationTest {
    reports {
        html {
            enabled = true
            stylesheet = 'fancy-hist.xsl'
        }
    }
}

gradleLint.alwaysRun = false
gradleLint {
    rules  = ['all-dependency']
}