src-kafka/build.gradle

// Licensed to the Apache Software Foundation (ASF) under one or more
// contributor license agreements.  See the NOTICE file distributed with
// this work for additional information regarding copyright ownership.
// The ASF licenses this file to You 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.

import org.ajoberstar.grgit.Grgit

import java.nio.charset.StandardCharsets

buildscript {
  repositories {
    mavenCentral()
    jcenter()
    maven {
      url "https://plugins.gradle.org/m2/"
    }
  }
  apply from: file('gradle/buildscript.gradle'), to: buildscript
  apply from: "$rootDir/gradle/dependencies.gradle"

  dependencies {
    // For Apache Rat plugin to ignore non-Git files
    classpath "org.ajoberstar.grgit:grgit-core:$versions.grgit"
    classpath "com.github.ben-manes:gradle-versions-plugin:$versions.gradleVersionsPlugin"
    classpath "org.scoverage:gradle-scoverage:$versions.scoveragePlugin"
    classpath "com.github.jengelman.gradle.plugins:shadow:$versions.shadowPlugin"
    classpath "org.owasp:dependency-check-gradle:$versions.owaspDepCheckPlugin"
    classpath "com.diffplug.spotless:spotless-plugin-gradle:$versions.spotlessPlugin"
    classpath "gradle.plugin.com.github.spotbugs.snom:spotbugs-gradle-plugin:$versions.spotbugsPlugin"
    classpath "org.gradle:test-retry-gradle-plugin:$versions.testRetryPlugin"
  }
}

apply plugin: "com.diffplug.spotless"
spotless {
  scala {
    target 'streams/**/*.scala'
    scalafmt("$versions.scalafmt").configFile('checkstyle/.scalafmt.conf')
  }
}


allprojects {

  repositories {
    mavenCentral()
  }

  apply plugin: 'idea'
  apply plugin: 'org.owasp.dependencycheck'
  apply plugin: 'com.github.ben-manes.versions'

  dependencyUpdates {
    revision="release"
    resolutionStrategy {
      componentSelection { rules ->
        rules.all { ComponentSelection selection ->
          boolean rejected = ['snap', 'alpha', 'beta', 'rc', 'cr', 'm'].any { qualifier ->
            selection.candidate.version ==~ /(?i).*[.-]${qualifier}[.\d-]*/
          }
          if (rejected) {
            selection.reject('Release candidate')
          }
        }
      }
    }
    configurations.all {
      // zinc is the Scala incremental compiler, it has a configuration for its own dependencies
      // that are unrelated to the project dependencies, we should not change them
      if (name != "zinc") {
        resolutionStrategy {
          force(
            // be explicit about the javassist dependency version instead of relying on the transitive version
            libs.javassist,
            // ensure we have a single version in the classpath despite transitive dependencies
            libs.scalaLibrary,
            libs.scalaReflect,
            libs.jacksonAnnotations,
            // be explicit about the Netty dependency version instead of relying on the version set by
            // ZooKeeper (potentially older and containing CVEs)
            libs.nettyHandler,
            libs.nettyTransportNativeEpoll
          )
        }
      }
    }
  }

  tasks.withType(Javadoc) {
    // disable the crazy super-strict doclint tool in Java 8
    // noinspection SpellCheckingInspection
    options.addStringOption('Xdoclint:none', '-quiet')
  }

}

ext {
  gradleVersion = versions.gradle
  minJavaVersion = "8"
  buildVersionFileName = "kafka-version.properties"

  defaultMaxHeapSize = "2g"
  defaultJvmArgs = ["-Xss4m", "-XX:+UseParallelGC"]

  userMaxForks = project.hasProperty('maxParallelForks') ? maxParallelForks.toInteger() : null
  userIgnoreFailures = project.hasProperty('ignoreFailures') ? ignoreFailures : false

  userMaxTestRetries = project.hasProperty('maxTestRetries') ? maxTestRetries.toInteger() : 0
  userMaxTestRetryFailures = project.hasProperty('maxTestRetryFailures') ? maxTestRetryFailures.toInteger() : 0

  skipSigning = project.hasProperty('skipSigning') && skipSigning.toBoolean()
  shouldSign = !skipSigning && !version.endsWith("SNAPSHOT") && project.gradle.startParameter.taskNames.any { it.contains("upload") }

  mavenUrl = project.hasProperty('mavenUrl') ? project.mavenUrl : ''
  mavenUsername = project.hasProperty('mavenUsername') ? project.mavenUsername : ''
  mavenPassword = project.hasProperty('mavenPassword') ? project.mavenPassword : ''

  userShowStandardStreams = project.hasProperty("showStandardStreams") ? showStandardStreams : null

  userTestLoggingEvents = project.hasProperty("testLoggingEvents") ? Arrays.asList(testLoggingEvents.split(",")) : null

  userEnableTestCoverage = project.hasProperty("enableTestCoverage") ? enableTestCoverage : false

  // See README.md for details on this option and the reasoning for the default
  userScalaOptimizerMode = project.hasProperty("scalaOptimizerMode") ? scalaOptimizerMode : "inline-kafka"
  def scalaOptimizerValues = ["none", "method", "inline-kafka", "inline-scala"]
  if (!scalaOptimizerValues.contains(userScalaOptimizerMode))
    throw new GradleException("Unexpected value for scalaOptimizerMode property. Expected one of $scalaOptimizerValues), but received: $userScalaOptimizerMode")

  generatedDocsDir = new File("${project.rootDir}/docs/generated")

  commitId = project.hasProperty('commitId') ? commitId : null
}

apply from: file('wrapper.gradle')

if (file('.git').exists()) {
  apply from: file('gradle/rat.gradle')
  rat {
    // Exclude everything under the directory that git should be ignoring via .gitignore or that isn't checked in. These
    // restrict us only to files that are checked in or are staged.
    def repo = Grgit.open(currentDir: project.getRootDir())
    excludes = new ArrayList<String>(repo.clean(ignore: false, directories: true, dryRun: true))
    // And some of the files that we have checked in should also be excluded from this check
    excludes.addAll([
        '**/.git/**',
        '**/build/**',
        'CONTRIBUTING.md',
        'PULL_REQUEST_TEMPLATE.md',
        'gradlew',
        'gradlew.bat',
        'gradle/wrapper/gradle-wrapper.properties',
        'TROGDOR.md',
        '**/README.md',
        '**/id_rsa',
        '**/id_rsa.pub',
        'checkstyle/suppressions.xml',
        'streams/quickstart/java/src/test/resources/projects/basic/goal.txt',
        'streams/streams-scala/logs/*',
        '**/generated/**'
    ])
  }
}


subprojects {

  // enable running :dependencies task recursively on all subprojects
  // eg: ./gradlew allDeps
  task allDeps(type: DependencyReportTask) {}
  // enable running :dependencyInsight task recursively on all subprojects
  // eg: ./gradlew allDepInsight --configuration runtime --dependency com.fasterxml.jackson.core:jackson-databind
  task allDepInsight(type: DependencyInsightReportTask) doLast {}

  apply plugin: 'java'
  // apply the eclipse plugin only to subprojects that hold code. 'connect' is just a folder.
  if (!project.name.equals('connect')) {
    apply plugin: 'eclipse'
    fineTuneEclipseClasspathFile(eclipse, project)
  }
  apply plugin: 'maven'
  apply plugin: 'signing'
  apply plugin: 'checkstyle'
  apply plugin: "com.github.spotbugs"
  apply plugin: 'org.gradle.test-retry'

  sourceCompatibility = minJavaVersion
  targetCompatibility = minJavaVersion

  java {
    consistentResolution {
      // resolve the compileClasspath and then "inject" the result of resolution as strict constraints into the runtimeClasspath
      useCompileClasspathVersions()
    }
  }

  tasks.withType(JavaCompile) {
    options.encoding = 'UTF-8'
    options.compilerArgs << "-Xlint:all"
    // temporary exclusions until all the warnings are fixed
    options.compilerArgs << "-Xlint:-rawtypes"
    options.compilerArgs << "-Xlint:-serial"
    options.compilerArgs << "-Xlint:-try"
    options.compilerArgs << "-Werror"
    // --release is the recommended way to select the target release, but it's only supported in Java 9 so we also
    // set --source and --target via `sourceCompatibility` and `targetCompatibility`. If/when Gradle supports `--release`
    // natively (https://github.com/gradle/gradle/issues/2510), we should switch to that.
    if (JavaVersion.current().isJava9Compatible())
      options.compilerArgs << "--release" << minJavaVersion
  }

  uploadArchives {
    repositories {
      signing {
          required { shouldSign }
          sign configurations.archives

          // To test locally, replace mavenUrl in ~/.gradle/gradle.properties to file://localhost/tmp/myRepo/
          mavenDeployer {
              beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }
              repository(url: "${mavenUrl}") {
                  authentication(userName: "${mavenUsername}", password: "${mavenPassword}")
              }
              afterEvaluate {
                  pom.artifactId = "${archivesBaseName}"
                  pom.project {
                      name 'Apache Kafka'
                      packaging 'jar'
                      url 'https://kafka.apache.org'
                      licenses {
                          license {
                              name 'The Apache Software License, Version 2.0'
                              url 'https://www.apache.org/licenses/LICENSE-2.0.txt'
                              distribution 'repo'
                          }
                      }
                  }
              }
          }
      }
    }
  }

  // Remove the relevant project name once it's converted to JUnit 5
  def shouldUseJUnit5 = !(["runtime", "streams-scala", "streams"].contains(it.project.name))

  def testLoggingEvents = ["passed", "skipped", "failed"]
  def testShowStandardStreams = false
  def testExceptionFormat = 'full'
  // Gradle built-in logging only supports sending test output to stdout, which generates a lot
  // of noise, especially for passing tests. We really only want output for failed tests. This
  // hooks into the output and logs it (so we don't have to buffer it all in memory) and only
  // saves the output for failing tests. Directory and filenames are such that you can, e.g.,
  // create a Jenkins rule to collect failed test output.
  def logTestStdout = {
    def testId = { TestDescriptor descriptor ->
      "${descriptor.className}.${descriptor.name}".toString()
    }

    def logFiles = new HashMap<String, File>()
    def logStreams = new HashMap<String, FileOutputStream>()
    beforeTest { TestDescriptor td ->
      def tid = testId(td)
      // truncate the file name if it's too long
      def logFile = new File(
              "${projectDir}/build/reports/testOutput/${tid.substring(0, Math.min(tid.size(),240))}.test.stdout"
      )
      logFile.parentFile.mkdirs()
      logFiles.put(tid, logFile)
      logStreams.put(tid, new FileOutputStream(logFile))
    }
    onOutput { TestDescriptor td, TestOutputEvent toe ->
      def tid = testId(td)
      // Some output can happen outside the context of a specific test (e.g. at the class level)
      // and beforeTest/afterTest seems to not be invoked for these cases (and similarly, there's
      // a TestDescriptor hierarchy that includes the thread executing the test, Gradle tasks,
      // etc). We see some of these in practice and it seems like something buggy in the Gradle
      // test runner since we see it *before* any tests and it is frequently not related to any
      // code in the test (best guess is that it is tail output from last test). We won't have
      // an output file for these, so simply ignore them. If they become critical for debugging,
      // they can be seen with showStandardStreams.
      if (td.name == td.className || td.className == null) {
        // silently ignore output unrelated to specific test methods
        return
      } else if (logStreams.get(tid) == null) {
        println "WARNING: unexpectedly got output for a test [${tid}]" +
                " that we didn't previously see in the beforeTest hook." +
                " Message for debugging: [" + toe.message + "]."
        return
      }
      try {
        logStreams.get(tid).write(toe.message.getBytes(StandardCharsets.UTF_8))
      } catch (Exception e) {
        println "ERROR: Failed to write output for test ${tid}"
        e.printStackTrace()
      }
    }
    afterTest { TestDescriptor td, TestResult tr ->
      def tid = testId(td)
      try {
        logStreams.get(tid).close()
        if (tr.resultType != TestResult.ResultType.FAILURE) {
          logFiles.get(tid).delete()
        } else {
          def file = logFiles.get(tid)
          println "${tid} failed, log available in ${file}"
        }
      } catch (Exception e) {
        println "ERROR: Failed to close stdout file for ${tid}"
        e.printStackTrace()
      } finally {
        logFiles.remove(tid)
        logStreams.remove(tid)
      }
    }
  }

  test {
    maxParallelForks = userMaxForks ?: Runtime.runtime.availableProcessors()
    ignoreFailures = userIgnoreFailures

    maxHeapSize = defaultMaxHeapSize
    jvmArgs = defaultJvmArgs

    testLogging {
      events = userTestLoggingEvents ?: testLoggingEvents
      showStandardStreams = userShowStandardStreams ?: testShowStandardStreams
      exceptionFormat = testExceptionFormat
    }
    logTestStdout.rehydrate(delegate, owner, this)()

    // The suites are for running sets of tests in IDEs.
    // Gradle will run each test class, so we exclude the suites to avoid redundantly running the tests twice.
    exclude '**/*Suite.class'

    if (shouldUseJUnit5)
      useJUnitPlatform()

    retry {
      maxRetries = userMaxTestRetries
      maxFailures = userMaxTestRetryFailures
    }
  }

  task integrationTest(type: Test, dependsOn: compileJava) {
    maxParallelForks = userMaxForks ?: Runtime.runtime.availableProcessors()
    ignoreFailures = userIgnoreFailures

    maxHeapSize = defaultMaxHeapSize
    jvmArgs = defaultJvmArgs


    testLogging {
      events = userTestLoggingEvents ?: testLoggingEvents
      showStandardStreams = userShowStandardStreams ?: testShowStandardStreams
      exceptionFormat = testExceptionFormat
    }
    logTestStdout.rehydrate(delegate, owner, this)()

    // The suites are for running sets of tests in IDEs.
    // Gradle will run each test class, so we exclude the suites to avoid redundantly running the tests twice.
    exclude '**/*Suite.class'

    if (shouldUseJUnit5) {
      useJUnitPlatform {
        includeTags "integration"
      }
    } else {
      useJUnit {
        includeCategories 'org.apache.kafka.test.IntegrationTest'
      }
    }

    retry {
      maxRetries = userMaxTestRetries
      maxFailures = userMaxTestRetryFailures
    }
  }

  task unitTest(type: Test, dependsOn: compileJava) {
    maxParallelForks = userMaxForks ?: Runtime.runtime.availableProcessors()
    ignoreFailures = userIgnoreFailures

    maxHeapSize = defaultMaxHeapSize
    jvmArgs = defaultJvmArgs

    testLogging {
      events = userTestLoggingEvents ?: testLoggingEvents
      showStandardStreams = userShowStandardStreams ?: testShowStandardStreams
      exceptionFormat = testExceptionFormat
    }
    logTestStdout.rehydrate(delegate, owner, this)()
    
    // The suites are for running sets of tests in IDEs.
    // Gradle will run each test class, so we exclude the suites to avoid redundantly running the tests twice.
    exclude '**/*Suite.class'

    if (shouldUseJUnit5) {
      useJUnitPlatform {
        excludeTags "integration"
      }
    } else {
      useJUnit {
        excludeCategories 'org.apache.kafka.test.IntegrationTest'
      }
    }

    retry {
      maxRetries = userMaxTestRetries
      maxFailures = userMaxTestRetryFailures
    }
  }

  jar {
    from "$rootDir/LICENSE"
    from "$rootDir/NOTICE"
  }

  task srcJar(type: Jar) {
    classifier = 'sources'
    from "$rootDir/LICENSE"
    from "$rootDir/NOTICE"
    from sourceSets.main.allSource
  }

  task javadocJar(type: Jar, dependsOn: javadoc) {
    classifier 'javadoc'
    from "$rootDir/LICENSE"
    from "$rootDir/NOTICE"
    from javadoc.destinationDir
  }

  task docsJar(dependsOn: javadocJar)

  javadoc {
    options.charSet = 'UTF-8'
    options.docEncoding = 'UTF-8'
    options.encoding = 'UTF-8'
  }

  task systemTestLibs(dependsOn: jar)

  artifacts {
    archives srcJar
    archives javadocJar
  }

  if(!sourceSets.test.allSource.isEmpty()) {
    task testJar(type: Jar) {
      classifier = 'test'
      from "$rootDir/LICENSE"
      from "$rootDir/NOTICE"
      from sourceSets.test.output
    }

    task testSrcJar(type: Jar, dependsOn: testJar) {
      classifier = 'test-sources'
      from "$rootDir/LICENSE"
      from "$rootDir/NOTICE"
      from sourceSets.test.allSource
    }

    artifacts {
      archives testJar
      archives testSrcJar
    }
  }

  plugins.withType(ScalaPlugin) {

    scala {
      zincVersion = versions.zinc
    }

    task scaladocJar(type:Jar, dependsOn: scaladoc) {
      classifier = 'scaladoc'
      from "$rootDir/LICENSE"
      from "$rootDir/NOTICE"
      from scaladoc.destinationDir
    }

    //documentation task should also trigger building scala doc jar
    docsJar.dependsOn scaladocJar

  }

  tasks.withType(ScalaCompile) {
    scalaCompileOptions.additionalParameters = [
      "-deprecation",
      "-unchecked",
      "-encoding", "utf8",
      "-Xlog-reflective-calls",
      "-feature",
      "-language:postfixOps",
      "-language:implicitConversions",
      "-language:existentials",
      "-Xlint:constant",
      "-Xlint:delayedinit-select",
      "-Xlint:doc-detached",
      "-Xlint:missing-interpolator",
      "-Xlint:nullary-unit",
      "-Xlint:option-implicit",
      "-Xlint:package-object-classes",
      "-Xlint:poly-implicit-overload",
      "-Xlint:private-shadow",
      "-Xlint:stars-align",
      "-Xlint:type-parameter-shadow",
      "-Xlint:unused"
    ]

    // See README.md for details on this option and the meaning of each value
    if (userScalaOptimizerMode.equals("method"))
      scalaCompileOptions.additionalParameters += ["-opt:l:method"]
    else if (userScalaOptimizerMode.startsWith("inline-")) {
      List<String> inlineFrom = ["-opt-inline-from:org.apache.kafka.**"]
      if (project.name.equals('core'))
        inlineFrom.add("-opt-inline-from:kafka.**")
      if (userScalaOptimizerMode.equals("inline-scala"))
        inlineFrom.add("-opt-inline-from:scala.**")

      scalaCompileOptions.additionalParameters += ["-opt:l:inline"]
      scalaCompileOptions.additionalParameters += inlineFrom
    }

    if (versions.baseScala != '2.12') {
      scalaCompileOptions.additionalParameters += ["-opt-warnings", "-Xlint:strict-unsealed-patmat"]
      // Scala 2.13.2 introduces compiler warnings suppression, which is a pre-requisite for -Xfatal-warnings
      scalaCompileOptions.additionalParameters += ["-Xfatal-warnings"]
    }

    // these options are valid for Scala versions < 2.13 only
    // Scala 2.13 removes them, see https://github.com/scala/scala/pull/6502 and https://github.com/scala/scala/pull/5969
    if (versions.baseScala == '2.12') {
      scalaCompileOptions.additionalParameters += [
        "-Xlint:by-name-right-associative",
        "-Xlint:nullary-override",
        "-Xlint:unsound-match"
      ]
    }

    // Scalac's `-release` requires Java 9 or higher
    if (JavaVersion.current().isJava9Compatible())
      scalaCompileOptions.additionalParameters += ["-release", minJavaVersion]

    configure(scalaCompileOptions.forkOptions) {
      memoryMaximumSize = defaultMaxHeapSize
      jvmArgs = defaultJvmArgs
    }
  }

  checkstyle {
    configFile = new File(rootDir, "checkstyle/checkstyle.xml")
    configProperties = checkstyleConfigProperties("import-control.xml")
    toolVersion = versions.checkstyle
  }

  configure(checkstyleMain) {
    group = 'Verification'
    description = 'Run checkstyle on all main Java sources'
  }

  configure(checkstyleTest) {
    group = 'Verification'
    description = 'Run checkstyle on all test Java sources'
  }

  test.dependsOn('checkstyleMain', 'checkstyleTest')

  spotbugs {
    toolVersion = versions.spotbugs
    excludeFilter = file("$rootDir/gradle/spotbugs-exclude.xml")
    ignoreFailures = false
  }
  test.dependsOn('spotbugsMain')

  tasks.withType(com.github.spotbugs.snom.SpotBugsTask) {
    reports {
      // Continue supporting `xmlFindBugsReport` for compatibility
      xml.enabled(project.hasProperty('xmlSpotBugsReport') || project.hasProperty('xmlFindBugsReport'))
      html.enabled(!project.hasProperty('xmlSpotBugsReport') && !project.hasProperty('xmlFindBugsReport'))
    }
    maxHeapSize = defaultMaxHeapSize
    jvmArgs = defaultJvmArgs
  }

  // Ignore core since its a scala project
  if (it.path != ':core') {
    if (userEnableTestCoverage) {
      apply plugin: "jacoco"

      jacoco {
        toolVersion = versions.jacoco
      }

      // NOTE: Jacoco Gradle plugin does not support "offline instrumentation" this means that classes mocked by PowerMock
      // may report 0 coverage, since the source was modified after initial instrumentation.
      // See https://github.com/jacoco/jacoco/issues/51
      jacocoTestReport {
        dependsOn tasks.test
        sourceSets sourceSets.main
        reports {
          html.enabled = true
          xml.enabled = true
          csv.enabled = false
        }
      }

    }
  }

  if (userEnableTestCoverage) {
    def coverageGen = it.path == ':core' ? 'reportScoverage' : 'jacocoTestReport'
    task reportCoverage(dependsOn: [coverageGen])
  }

  task determineCommitId {
    def takeFromHash = 16
    if (commitId) {
      commitId = commitId.take(takeFromHash)
    } else if (file("$rootDir/.git/HEAD").exists()) {
      def headRef = file("$rootDir/.git/HEAD").text
      if (headRef.contains('ref: ')) {
        headRef = headRef.replaceAll('ref: ', '').trim()
        if (file("$rootDir/.git/$headRef").exists()) {
          commitId = file("$rootDir/.git/$headRef").text.trim().take(takeFromHash)
        }
      } else {
        commitId = headRef.trim().take(takeFromHash)
      }
    } else {
      commitId = "unknown"
    }
  }

}

gradle.taskGraph.whenReady { taskGraph ->
  taskGraph.getAllTasks().findAll { it.name.contains('spotbugsScoverage') || it.name.contains('spotbugsTest') }.each { task ->
    task.enabled = false
  }
}

def fineTuneEclipseClasspathFile(eclipse, project) {
  eclipse.classpath.file {
    beforeMerged { cp ->
      cp.entries.clear()
      // for the core project add the directories defined under test/scala as separate source directories
      if (project.name.equals('core')) {
        cp.entries.add(new org.gradle.plugins.ide.eclipse.model.SourceFolder("src/test/scala/integration", null))
        cp.entries.add(new org.gradle.plugins.ide.eclipse.model.SourceFolder("src/test/scala/other", null))
        cp.entries.add(new org.gradle.plugins.ide.eclipse.model.SourceFolder("src/test/scala/unit", null))
      }
    }
    whenMerged { cp ->
      // for the core project exclude the separate sub-directories defined under test/scala. These are added as source dirs above
      if (project.name.equals('core')) {
        cp.entries.findAll { it.kind == "src" && it.path.equals("src/test/scala") }*.excludes = ["integration/", "other/", "unit/"]
      }
      /*
       * Set all eclipse build output to go to 'build_eclipse' directory. This is to ensure that gradle and eclipse use different
       * build output directories, and also avoid using the eclpise default of 'bin' which clashes with some of our script directories.
       * https://discuss.gradle.org/t/eclipse-generated-files-should-be-put-in-the-same-place-as-the-gradle-generated-files/6986/2
       */
      cp.entries.findAll { it.kind == "output" }*.path = "build_eclipse"
      /*
       * Some projects have explicitly added test output dependencies. These are required for the gradle build but not required
       * in Eclipse since the dependent projects are added as dependencies. So clean up these from the generated classpath.
       */
      cp.entries.removeAll { it.kind == "lib" && it.path.matches(".*/build/(classes|resources)/test") }
    }
  }
}

def checkstyleConfigProperties(configFileName) {
  [importControlFile: "$rootDir/checkstyle/$configFileName",
   suppressionsFile: "$rootDir/checkstyle/suppressions.xml",
   headerFile: "$rootDir/checkstyle/java.header"]
}

// Aggregates all jacoco results into the root project directory
if (userEnableTestCoverage) {
  task jacocoRootReport(type: org.gradle.testing.jacoco.tasks.JacocoReport) {
    def javaProjects = subprojects.findAll { it.path != ':core' }

    description = 'Generates an aggregate report from all subprojects'
    dependsOn(javaProjects.test)

    additionalSourceDirs.from = javaProjects.sourceSets.main.allSource.srcDirs
    sourceDirectories.from = javaProjects.sourceSets.main.allSource.srcDirs
    classDirectories.from = javaProjects.sourceSets.main.output
    executionData.from = javaProjects.jacocoTestReport.executionData

    reports {
      html.enabled = true
      xml.enabled = true
    }

    // workaround to ignore projects that don't have any tests at all
    onlyIf = { true }
    doFirst {
      executionData = files(executionData.findAll { it.exists() })
    }
  }
}

if (userEnableTestCoverage) {
  task reportCoverage(dependsOn: ['jacocoRootReport', 'core:reportCoverage'])
}

def connectPkgs = [
    'connect:api',
    'connect:basic-auth-extension',
    'connect:file',
    'connect:json',
    'connect:runtime',
    'connect:transforms',
    'connect:mirror',
    'connect:mirror-client'
]

tasks.create(name: "jarConnect", dependsOn: connectPkgs.collect { it + ":jar" }) {}

tasks.create(name: "testConnect", dependsOn: connectPkgs.collect { it + ":test" }) {}

project(':core') {
  println "Building project 'core' with Scala version ${versions.scala}"

  apply plugin: 'scala'
  
  // scaladoc generation is configured at the sub-module level with an artifacts
  // block (cf. see streams-scala). If scaladoc generation is invoked explicitly
  // for the `core` module, this ensures the generated jar doesn't include scaladoc
  // files since the `core` module doesn't include public APIs.
  scaladoc {
    enabled = false
  }
  if (userEnableTestCoverage)
    apply plugin: "org.scoverage"
  archivesBaseName = "kafka_${versions.baseScala}"

  dependencies {
    compile project(':clients')
    compile project(':metadata')
    compile project(':raft')
    compile libs.argparse4j
    compile libs.jacksonDatabind
    compile libs.jacksonModuleScala
    compile libs.jacksonDataformatCsv
    compile libs.jacksonJDK8Datatypes
    compile libs.joptSimple
    compile libs.metrics
    compile libs.scalaCollectionCompat
    compile libs.scalaJava8Compat
    compile libs.scalaLibrary
    // only needed transitively, but set it explicitly to ensure it has the same version as scala-library
    compile libs.scalaReflect
    compile libs.scalaLogging
    compile libs.slf4jApi
    compile(libs.zookeeper) {
      exclude module: 'slf4j-log4j12'
      exclude module: 'log4j'
    }
    // ZooKeeperMain depends on commons-cli but declares the dependency as `provided`
    compile libs.commonsCli

    compileOnly libs.log4j

    testCompile project(':clients').sourceSets.test.output
    testCompile libs.bcpkix
    testCompile libs.mockitoCore
    testCompile libs.easymock
    testCompile(libs.apacheda) {
      exclude group: 'xml-apis', module: 'xml-apis'
      // `mina-core` is a transitive dependency for `apacheds` and `apacheda`.
      // It is safer to use from `apacheds` since that is the implementation.
      exclude module: 'mina-core'
    }
    testCompile libs.apachedsCoreApi
    testCompile libs.apachedsInterceptorKerberos
    testCompile libs.apachedsProtocolShared
    testCompile libs.apachedsProtocolKerberos
    testCompile libs.apachedsProtocolLdap
    testCompile libs.apachedsLdifPartition
    testCompile libs.apachedsMavibotPartition
    testCompile libs.apachedsJdbmPartition
    testCompile libs.junitJupiter
    testCompile libs.slf4jlog4j
    testCompile(libs.jfreechart) {
      exclude group: 'junit', module: 'junit'
    }
  }

  if (userEnableTestCoverage) {
    scoverage {
      scoverageVersion = versions.scoverage
      reportDir = file("${rootProject.buildDir}/scoverage")
      highlighting = false
      minimumRate = 0.0
    }
  }

  configurations {
    // manually excludes some unnecessary dependencies
    compile.exclude module: 'javax'
    compile.exclude module: 'jline'
    compile.exclude module: 'jms'
    compile.exclude module: 'jmxri'
    compile.exclude module: 'jmxtools'
    compile.exclude module: 'mail'
    // To prevent a UniqueResourceException due the same resource existing in both
    // org.apache.directory.api/api-all and org.apache.directory.api/api-ldap-schema-data
    testCompile.exclude module: 'api-ldap-schema-data'
  }

  tasks.create(name: "copyDependantLibs", type: Copy) {
    from (configurations.testRuntime) {
      include('slf4j-log4j12*')
      include('log4j*jar')
    }
    from (configurations.runtime) {
      exclude('kafka-clients*')
    }
    into "$buildDir/dependant-libs-${versions.scala}"
    duplicatesStrategy 'exclude'
  }

  task processMessages(type:JavaExec) {
    main = "org.apache.kafka.message.MessageGenerator"
    classpath = project(':generator').sourceSets.main.runtimeClasspath
    args = [ "-p", "kafka.internals.generated",
             "-o", "src/generated/java/kafka/internals/generated",
             "-i", "src/main/resources/common/message",
             "-m", "MessageDataGenerator"
    ]
    inputs.dir("src/main/resources/common/message")
    outputs.dir("src/generated/java/kafka/internals/generated")
  }

  compileJava.dependsOn 'processMessages'

  task genProtocolErrorDocs(type: JavaExec) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'org.apache.kafka.common.protocol.Errors'
    if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
    standardOutput = new File(generatedDocsDir, "protocol_errors.html").newOutputStream()
  }

  task genProtocolTypesDocs(type: JavaExec) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'org.apache.kafka.common.protocol.types.Type'
    if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
    standardOutput = new File(generatedDocsDir, "protocol_types.html").newOutputStream()
  }

  task genProtocolApiKeyDocs(type: JavaExec) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'org.apache.kafka.common.protocol.ApiKeys'
    if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
    standardOutput = new File(generatedDocsDir, "protocol_api_keys.html").newOutputStream()
  }

  task genProtocolMessageDocs(type: JavaExec) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'org.apache.kafka.common.protocol.Protocol'
    if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
    standardOutput = new File(generatedDocsDir, "protocol_messages.html").newOutputStream()
  }

  task genAdminClientConfigDocs(type: JavaExec) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'org.apache.kafka.clients.admin.AdminClientConfig'
    if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
    standardOutput = new File(generatedDocsDir, "admin_client_config.html").newOutputStream()
  }

  task genProducerConfigDocs(type: JavaExec) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'org.apache.kafka.clients.producer.ProducerConfig'
    if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
    standardOutput = new File(generatedDocsDir, "producer_config.html").newOutputStream()
  }

  task genConsumerConfigDocs(type: JavaExec) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'org.apache.kafka.clients.consumer.ConsumerConfig'
    if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
    standardOutput = new File(generatedDocsDir, "consumer_config.html").newOutputStream()
  }

  task genKafkaConfigDocs(type: JavaExec) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'kafka.server.KafkaConfig'
    if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
    standardOutput = new File(generatedDocsDir, "kafka_config.html").newOutputStream()
  }

  task genTopicConfigDocs(type: JavaExec) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'kafka.log.LogConfig'
    if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
    standardOutput = new File(generatedDocsDir, "topic_config.html").newOutputStream()
  }

  task genConsumerMetricsDocs(type: JavaExec) {
    classpath = sourceSets.test.runtimeClasspath
    main = 'org.apache.kafka.clients.consumer.internals.ConsumerMetrics'
    if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
    standardOutput = new File(generatedDocsDir, "consumer_metrics.html").newOutputStream()
  }

  task genProducerMetricsDocs(type: JavaExec) {
    classpath = sourceSets.test.runtimeClasspath
    main = 'org.apache.kafka.clients.producer.internals.ProducerMetrics'
    if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
    standardOutput = new File(generatedDocsDir, "producer_metrics.html").newOutputStream()
  }

  task siteDocsTar(dependsOn: ['genProtocolErrorDocs', 'genProtocolTypesDocs', 'genProtocolApiKeyDocs', 'genProtocolMessageDocs',
                               'genAdminClientConfigDocs', 'genProducerConfigDocs', 'genConsumerConfigDocs',
                               'genKafkaConfigDocs', 'genTopicConfigDocs',
                               ':connect:runtime:genConnectConfigDocs', ':connect:runtime:genConnectTransformationDocs',
                               ':connect:runtime:genConnectPredicateDocs',
                               ':connect:runtime:genSinkConnectorConfigDocs', ':connect:runtime:genSourceConnectorConfigDocs',
                               ':streams:genStreamsConfigDocs', 'genConsumerMetricsDocs', 'genProducerMetricsDocs',
                               ':connect:runtime:genConnectMetricsDocs'], type: Tar) {
    classifier = 'site-docs'
    compression = Compression.GZIP
    from project.file("$rootDir/docs")
    into 'site-docs'
    duplicatesStrategy 'exclude'
  }

  tasks.create(name: "releaseTarGz", dependsOn: configurations.archives.artifacts, type: Tar) {
    into "kafka_${versions.baseScala}-${version}"
    compression = Compression.GZIP
    from(project.file("$rootDir/bin")) { into "bin/" }
    from(project.file("$rootDir/config")) { into "config/" }
    from "$rootDir/LICENSE"
    from "$rootDir/NOTICE"
    from(configurations.runtime) { into("libs/") }
    from(configurations.archives.artifacts.files) { into("libs/") }
    from(project.siteDocsTar) { into("site-docs/") }
    from(project(':tools').jar) { into("libs/") }
    from(project(':tools').configurations.runtime) { into("libs/") }
    from(project(':connect:api').jar) { into("libs/") }
    from(project(':connect:api').configurations.runtime) { into("libs/") }
    from(project(':connect:runtime').jar) { into("libs/") }
    from(project(':connect:runtime').configurations.runtime) { into("libs/") }
    from(project(':connect:transforms').jar) { into("libs/") }
    from(project(':connect:transforms').configurations.runtime) { into("libs/") }
    from(project(':connect:json').jar) { into("libs/") }
    from(project(':connect:json').configurations.runtime) { into("libs/") }
    from(project(':connect:file').jar) { into("libs/") }
    from(project(':connect:file').configurations.runtime) { into("libs/") }
    from(project(':connect:basic-auth-extension').jar) { into("libs/") }
    from(project(':connect:basic-auth-extension').configurations.runtime) { into("libs/") }
    from(project(':connect:mirror').jar) { into("libs/") }
    from(project(':connect:mirror').configurations.runtime) { into("libs/") }
    from(project(':connect:mirror-client').jar) { into("libs/") }
    from(project(':connect:mirror-client').configurations.runtime) { into("libs/") }
    from(project(':streams').jar) { into("libs/") }
    from(project(':streams').configurations.runtime) { into("libs/") }
    from(project(':streams:streams-scala').jar) { into("libs/") }
    from(project(':streams:streams-scala').configurations.runtime) { into("libs/") }
    from(project(':streams:test-utils').jar) { into("libs/") }
    from(project(':streams:test-utils').configurations.runtime) { into("libs/") }
    from(project(':streams:examples').jar) { into("libs/") }
    from(project(':streams:examples').configurations.runtime) { into("libs/") }
    duplicatesStrategy 'exclude'
  }

  jar {
    dependsOn('copyDependantLibs')
  }

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

  tasks.create(name: "copyDependantTestLibs", type: Copy) {
    from (configurations.testRuntime) {
      include('*.jar')
    }
    into "$buildDir/dependant-testlibs"
    //By default gradle does not handle test dependencies between the sub-projects
    //This line is to include clients project test jar to dependant-testlibs
    from (project(':clients').testJar ) { "$buildDir/dependant-testlibs" }
    duplicatesStrategy 'exclude'
  }

  systemTestLibs.dependsOn('jar', 'testJar', 'copyDependantTestLibs')

  checkstyle {
    configProperties = checkstyleConfigProperties("import-control-core.xml")
  }

  sourceSets {
    main {
      java {
        srcDirs = ["src/generated/java", "src/main/java"]
      }
    }
    test {
      java {
        srcDirs = []
      }
      scala {
        srcDirs = ["src/test/java", "src/test/scala"]
      }
    }
  }
}

project(':metadata') {
  archivesBaseName = "kafka-metadata"

  dependencies {
    compile project(':clients')
    compile libs.jacksonDatabind
    compile libs.jacksonJDK8Datatypes
    compile libs.metrics
    compileOnly libs.log4j
    testCompile libs.junitJupiter
    testCompile libs.hamcrest
    testCompile libs.slf4jlog4j
    testCompile project(':clients').sourceSets.test.output
  }

  task processMessages(type:JavaExec) {
    main = "org.apache.kafka.message.MessageGenerator"
    classpath = project(':generator').sourceSets.main.runtimeClasspath
    args = [ "-p", "org.apache.kafka.common.metadata",
             "-o", "src/generated/java/org/apache/kafka/common/metadata",
             "-i", "src/main/resources/common/metadata",
             "-m", "MessageDataGenerator", "JsonConverterGenerator",
             "-t", "MetadataRecordTypeGenerator", "MetadataJsonConvertersGenerator"
           ]
    inputs.dir("src/main/resources/common/metadata")
    outputs.dir("src/generated/java/org/apache/kafka/common/metadata")
  }

  compileJava.dependsOn 'processMessages'

  sourceSets {
    main {
      java {
        srcDirs = ["src/generated/java", "src/main/java"]
      }
    }
    test {
      java {
        srcDirs = ["src/generated/java", "src/test/java"]
      }
    }
  }

  javadoc {
    enabled = false
  }
}

project(':examples') {
  archivesBaseName = "kafka-examples"

  dependencies {
    compile project(':core')
  }

  javadoc {
    enabled = false
  }

  checkstyle {
    configProperties = checkstyleConfigProperties("import-control-core.xml")
  }
}

project(':generator') {
  dependencies {
    compile libs.argparse4j
    compile libs.jacksonDatabind
    compile libs.jacksonJDK8Datatypes
    compile libs.jacksonJaxrsJsonProvider
    testCompile libs.junitJupiter
  }

  javadoc {
    enabled = false
  }
}

project(':clients') {
  archivesBaseName = "kafka-clients"

  configurations {
    jacksonDatabindConfig
  }

  // add jacksonDatabindConfig as provided scope config with high priority (1000)
  conf2ScopeMappings.addMapping(1000, configurations.jacksonDatabindConfig, "provided")

  dependencies {
    compile libs.zstd
    compile libs.lz4
    compile libs.snappy
    compile libs.slf4jApi

    compileOnly libs.jacksonDatabind // for SASL/OAUTHBEARER bearer token parsing
    compileOnly libs.jacksonJDK8Datatypes

    jacksonDatabindConfig libs.jacksonDatabind // to publish as provided scope dependency.

    testCompile libs.bcpkix
    testCompile libs.junitJupiter
    testCompile libs.mockitoCore

    testRuntime libs.slf4jlog4j
    testRuntime libs.jacksonDatabind
    testRuntime libs.jacksonJDK8Datatypes
    testCompile libs.jacksonJaxrsJsonProvider
  }

  task createVersionFile(dependsOn: determineCommitId) {
    ext.receiptFile = file("$buildDir/kafka/$buildVersionFileName")
    outputs.file receiptFile
    outputs.upToDateWhen { false }
    doLast {
      def data = [
        commitId: commitId,
        version: version,
      ]

      receiptFile.parentFile.mkdirs()
      def content = data.entrySet().collect { "$it.key=$it.value" }.sort().join("\n")
      receiptFile.setText(content, "ISO-8859-1")
    }
  }

  jar {
    dependsOn createVersionFile
    from("$buildDir") {
        include "kafka/$buildVersionFileName"
    }
  }

  clean.doFirst {
    delete "$buildDir/kafka/"
  }

  task processMessages(type:JavaExec) {
    main = "org.apache.kafka.message.MessageGenerator"
    classpath = project(':generator').sourceSets.main.runtimeClasspath
    args = [ "-p", "org.apache.kafka.common.message",
             "-o", "src/generated/java/org/apache/kafka/common/message",
             "-i", "src/main/resources/common/message",
             "-t", "ApiMessageTypeGenerator",
             "-m", "MessageDataGenerator", "JsonConverterGenerator"
           ]
    inputs.dir("src/main/resources/common/message")
    outputs.dir("src/generated/java/org/apache/kafka/common/message")
  }

  task processTestMessages(type:JavaExec) {
    main = "org.apache.kafka.message.MessageGenerator"
    classpath = project(':generator').sourceSets.main.runtimeClasspath
    args = [ "-p", "org.apache.kafka.common.message",
             "-o", "src/generated-test/java/org/apache/kafka/common/message",
             "-i", "src/test/resources/common/message",
             "-m", "MessageDataGenerator", "JsonConverterGenerator"
           ]
    inputs.dir("src/test/resources/common/message")
    outputs.dir("src/generated-test/java/org/apache/kafka/common/message")
  }

  sourceSets {
    main {
      java {
        srcDirs = ["src/generated/java", "src/main/java"]
      }
    }
    test {
      java {
        srcDirs = ["src/generated/java", "src/generated-test/java", "src/test/java"]
      }
    }
  }

  compileJava.dependsOn 'processMessages'

  compileTestJava.dependsOn 'processTestMessages'

  javadoc {
    include "**/org/apache/kafka/clients/admin/*"
    include "**/org/apache/kafka/clients/consumer/*"
    include "**/org/apache/kafka/clients/producer/*"
    include "**/org/apache/kafka/common/*"
    include "**/org/apache/kafka/common/acl/*"
    include "**/org/apache/kafka/common/annotation/*"
    include "**/org/apache/kafka/common/errors/*"
    include "**/org/apache/kafka/common/header/*"
    include "**/org/apache/kafka/common/metrics/*"
    include "**/org/apache/kafka/common/metrics/stats/*"
    include "**/org/apache/kafka/common/quota/*"
    include "**/org/apache/kafka/common/resource/*"
    include "**/org/apache/kafka/common/serialization/*"
    include "**/org/apache/kafka/common/config/*"
    include "**/org/apache/kafka/common/config/provider/*"
    include "**/org/apache/kafka/common/security/auth/*"
    include "**/org/apache/kafka/common/security/plain/*"
    include "**/org/apache/kafka/common/security/scram/*"
    include "**/org/apache/kafka/common/security/token/delegation/*"
    include "**/org/apache/kafka/common/security/oauthbearer/*"
    include "**/org/apache/kafka/server/authorizer/*"
    include "**/org/apache/kafka/server/policy/*"
    include "**/org/apache/kafka/server/quota/*"
    include "**/org/apache/kafka/server/log/remote/storage/*"
  }
}

project(':raft') {
  archivesBaseName = "kafka-raft"

  dependencies {
    compile project(':clients')
    compile project(':metadata')
    compile libs.slf4jApi
    compile libs.jacksonDatabind

    testCompile project(':clients')
    testCompile project(':clients').sourceSets.test.output
    testCompile libs.junitJupiter
    testCompile libs.mockitoCore

    testRuntime libs.slf4jlog4j
  }

  task createVersionFile(dependsOn: determineCommitId) {
    ext.receiptFile = file("$buildDir/kafka/$buildVersionFileName")
    outputs.file receiptFile
    outputs.upToDateWhen { false }
    doLast {
      def data = [
        commitId: commitId,
        version: version,
      ]

      receiptFile.parentFile.mkdirs()
      def content = data.entrySet().collect { "$it.key=$it.value" }.sort().join("\n")
      receiptFile.setText(content, "ISO-8859-1")
    }
  }

  task processMessages(type:JavaExec) {
    main = "org.apache.kafka.message.MessageGenerator"
    classpath = project(':generator').sourceSets.main.runtimeClasspath
    args = [ "-p", "org.apache.kafka.raft.generated",
             "-o", "src/generated/java/org/apache/kafka/raft/generated",
             "-i", "src/main/resources/common/message",
             "-m", "MessageDataGenerator", "JsonConverterGenerator"]
    inputs.dir("src/main/resources/common/message")
    outputs.dir("src/generated/java/org/apache/kafka/raft/generated")
  }

  sourceSets {
    main {
      java {
        srcDirs = ["src/generated/java", "src/main/java"]
      }
    }
    test {
      java {
        srcDirs = ["src/generated/java", "src/test/java"]
      }
    }
  }
  
  compileJava.dependsOn 'processMessages'

  jar {
    dependsOn createVersionFile
    from("$buildDir") {
        include "kafka/$buildVersionFileName"
    }
  }

  clean.doFirst {
    delete "$buildDir/kafka/"
  }

  javadoc {
    enabled = false
  }
}

project(':tools') {
  archivesBaseName = "kafka-tools"

  dependencies {
    compile project(':clients')
    compile project(':log4j-appender')
    compile libs.argparse4j
    compile libs.jacksonDatabind
    compile libs.jacksonJDK8Datatypes
    compile libs.slf4jApi

    compile libs.jacksonJaxrsJsonProvider
    compile libs.jerseyContainerServlet
    compile libs.jerseyHk2
    compile libs.jaxbApi // Jersey dependency that was available in the JDK before Java 9
    compile libs.activation // Jersey dependency that was available in the JDK before Java 9
    compile libs.jettyServer
    compile libs.jettyServlet
    compile libs.jettyServlets

    testCompile project(':clients')
    testCompile libs.junitJupiter
    testCompile project(':clients').sourceSets.test.output
    testCompile libs.mockitoInline // supports mocking static methods, final classes, etc.

    testRuntime libs.slf4jlog4j
  }

  javadoc {
    enabled = false
  }

  tasks.create(name: "copyDependantLibs", type: Copy) {
    from (configurations.testRuntime) {
      include('slf4j-log4j12*')
      include('log4j*jar')
    }
    from (configurations.runtime) {
      exclude('kafka-clients*')
    }
    into "$buildDir/dependant-libs-${versions.scala}"
    duplicatesStrategy 'exclude'
  }

  jar {
    dependsOn 'copyDependantLibs'
  }
}

project(':shell') {
  archivesBaseName = "kafka-shell"

  dependencies {
    compile libs.argparse4j
    compile libs.jacksonDatabind
    compile libs.jacksonJDK8Datatypes
    compile libs.jline
    compile libs.slf4jApi
    compile project(':clients')
    compile project(':core')
    compile project(':log4j-appender')
    compile project(':metadata')
    compile project(':raft')

    compile libs.jacksonJaxrsJsonProvider

    testCompile project(':clients')
    testCompile libs.junitJupiter

    testRuntime libs.slf4jlog4j
  }

  javadoc {
    enabled = false
  }

  tasks.create(name: "copyDependantLibs", type: Copy) {
    from (configurations.testRuntime) {
      include('jline-*jar')
    }
    from (configurations.runtime) {
      include('jline-*jar')
    }
    into "$buildDir/dependant-libs-${versions.scala}"
    duplicatesStrategy 'exclude'
  }

  jar {
    dependsOn 'copyDependantLibs'
  }
}

project(':streams') {
  archivesBaseName = "kafka-streams"
  ext.buildStreamsVersionFileName = "kafka-streams-version.properties"

  dependencies {
    compile project(':clients')

    // this dependency should be removed after we unify data API
    compile(project(':connect:json')) {
      // this transitive dependency is not used in Streams, and it breaks SBT builds
      exclude module: 'javax.ws.rs-api'
    }

    compile libs.slf4jApi
    compile libs.rocksDBJni

    // testCompileOnly prevents streams from exporting a dependency on test-utils, which would cause a dependency cycle
    testCompileOnly project(':streams:test-utils')
    testCompile project(':clients').sourceSets.test.output
    testCompile project(':core')
    testCompile project(':core').sourceSets.test.output
    testCompile libs.log4j
    testCompile libs.junitJupiterApi
    testCompile libs.junitVintageEngine
    testCompile libs.easymock
    testCompile libs.powermockJunit4
    testCompile libs.powermockEasymock
    testCompile libs.bcpkix
    testCompile libs.hamcrest

    testRuntimeOnly project(':streams:test-utils')
    testRuntime libs.slf4jlog4j
  }

  task processMessages(type:JavaExec) {
    main = "org.apache.kafka.message.MessageGenerator"
    classpath = project(':generator').sourceSets.main.runtimeClasspath
    args = [ "-p", "org.apache.kafka.streams.internals.generated",
             "-o", "src/generated/java/org/apache/kafka/streams/internals/generated",
             "-i", "src/main/resources/common/message",
             "-m", "MessageDataGenerator"
           ]
    inputs.dir("src/main/resources/common/message")
    outputs.dir("src/generated/java/org/apache/kafka/streams/internals/generated")
  }

  sourceSets {
    main {
      java {
        srcDirs = ["src/generated/java", "src/main/java"]
      }
    }
    test {
      java {
        srcDirs = ["src/generated/java", "src/test/java"]
      }
    }
  }

  compileJava.dependsOn 'processMessages'

  javadoc {
    include "**/org/apache/kafka/streams/**"
    exclude "**/internals/**"
  }

  tasks.create(name: "copyDependantLibs", type: Copy) {
    from (configurations.testRuntime) {
      include('slf4j-log4j12*')
      include('log4j*jar')
      include('*hamcrest*')
    }
    from (configurations.runtime) {
      exclude('kafka-clients*')
    }
    into "$buildDir/dependant-libs-${versions.scala}"
    duplicatesStrategy 'exclude'
  }

  task createStreamsVersionFile(dependsOn: determineCommitId) {
    ext.receiptFile = file("$buildDir/kafka/$buildStreamsVersionFileName")
    outputs.file receiptFile
    outputs.upToDateWhen { false }
    doLast {
      def data = [
              commitId: commitId,
              version: version,
      ]

      receiptFile.parentFile.mkdirs()
      def content = data.entrySet().collect { "$it.key=$it.value" }.sort().join("\n")
      receiptFile.setText(content, "ISO-8859-1")
    }
  }

  jar {
    dependsOn 'createStreamsVersionFile'
    from("$buildDir") {
      include "kafka/$buildStreamsVersionFileName"
    }
    dependsOn 'copyDependantLibs'
  }

  systemTestLibs {
    dependsOn testJar
  }

  task genStreamsConfigDocs(type: JavaExec) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'org.apache.kafka.streams.StreamsConfig'
    if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
    standardOutput = new File(generatedDocsDir, "streams_config.html").newOutputStream()
  }

  task testAll(
    dependsOn: [
            ':streams:test',
            ':streams:test-utils:test',
            ':streams:streams-scala:test',
            ':streams:upgrade-system-tests-0100:test',
            ':streams:upgrade-system-tests-0101:test',
            ':streams:upgrade-system-tests-0102:test',
            ':streams:upgrade-system-tests-0110:test',
            ':streams:upgrade-system-tests-10:test',
            ':streams:upgrade-system-tests-11:test',
            ':streams:upgrade-system-tests-20:test',
            ':streams:upgrade-system-tests-21:test',
            ':streams:upgrade-system-tests-22:test',
            ':streams:upgrade-system-tests-23:test',
            ':streams:upgrade-system-tests-24:test',
            ':streams:upgrade-system-tests-25:test',
            ':streams:upgrade-system-tests-26:test',
            ':streams:upgrade-system-tests-27:test',
            ':streams:examples:test'
    ]
  )
}

project(':streams:streams-scala') {
  println "Building project 'streams-scala' with Scala version ${versions.scala}"
  apply plugin: 'scala'
  archivesBaseName = "kafka-streams-scala_${versions.baseScala}"
  dependencies {
    compile project(':streams')

    compile libs.scalaLibrary
    compile libs.scalaCollectionCompat

    testCompile project(':core')
    testCompile project(':core').sourceSets.test.output
    testCompile project(':streams').sourceSets.test.output
    testCompile project(':clients').sourceSets.test.output
    testCompile project(':streams:test-utils')

    testCompile libs.junitJupiterApi
    testCompile libs.junitVintageEngine
    testCompile libs.scalatest
    testCompile libs.easymock
    testCompile libs.hamcrest

    testRuntime libs.slf4jlog4j
  }

  javadoc {
    include "**/org/apache/kafka/streams/scala/**"
  }

  tasks.create(name: "copyDependantLibs", type: Copy) {
    from (configurations.runtime) {
      exclude('kafka-streams*')
    }
    into "$buildDir/dependant-libs-${versions.scala}"
    duplicatesStrategy 'exclude'
  }

  jar {
    dependsOn 'copyDependantLibs'
  }

  artifacts {
    archives scaladocJar
  }

  test.dependsOn(':spotlessScalaCheck')
}

project(':streams:test-utils') {
  archivesBaseName = "kafka-streams-test-utils"

  dependencies {
    compile project(':streams')
    compile project(':clients')

    testCompile project(':clients').sourceSets.test.output
    testCompile libs.junitJupiter
    testCompile libs.easymock
    testCompile libs.hamcrest

    testRuntime libs.slf4jlog4j
  }

  javadoc {
    include "**/org/apache/kafka/streams/test/**"
    exclude "**/internals/**"
  }

  tasks.create(name: "copyDependantLibs", type: Copy) {
    from (configurations.runtime) {
      exclude('kafka-streams*')
    }
    into "$buildDir/dependant-libs-${versions.scala}"
    duplicatesStrategy 'exclude'
  }

  jar {
    dependsOn 'copyDependantLibs'
  }

}

project(':streams:examples') {
  archivesBaseName = "kafka-streams-examples"

  dependencies {
    compile project(':streams')
    compile project(':connect:json')  // this dependency should be removed after we unify data API
    compile libs.slf4jlog4j

    testCompile project(':streams:test-utils')
    testCompile project(':clients').sourceSets.test.output // for org.apache.kafka.test.IntegrationTest
    testCompile libs.junitJupiter
    testCompile libs.hamcrest
  }

  javadoc {
    enabled = false
  }

  tasks.create(name: "copyDependantLibs", type: Copy) {
    from (configurations.runtime) {
      exclude('kafka-streams*')
    }
    into "$buildDir/dependant-libs-${versions.scala}"
    duplicatesStrategy 'exclude'
  }

  jar {
    dependsOn 'copyDependantLibs'
  }
}

project(':streams:upgrade-system-tests-0100') {
  archivesBaseName = "kafka-streams-upgrade-system-tests-0100"

  dependencies {
    testCompile libs.kafkaStreams_0100
    testRuntime libs.junitJupiter
  }

  systemTestLibs {
    dependsOn testJar
  }
}

project(':streams:upgrade-system-tests-0101') {
  archivesBaseName = "kafka-streams-upgrade-system-tests-0101"

  dependencies {
    testCompile libs.kafkaStreams_0101
    testRuntime libs.junitJupiter
  }

  systemTestLibs {
    dependsOn testJar
  }
}

project(':streams:upgrade-system-tests-0102') {
  archivesBaseName = "kafka-streams-upgrade-system-tests-0102"

  dependencies {
    testCompile libs.kafkaStreams_0102
    testRuntime libs.junitJupiter
  }

  systemTestLibs {
    dependsOn testJar
  }
}

project(':streams:upgrade-system-tests-0110') {
  archivesBaseName = "kafka-streams-upgrade-system-tests-0110"

  dependencies {
    testCompile libs.kafkaStreams_0110
    testRuntime libs.junitJupiter
  }

  systemTestLibs {
    dependsOn testJar
  }
}

project(':streams:upgrade-system-tests-10') {
  archivesBaseName = "kafka-streams-upgrade-system-tests-10"

  dependencies {
    testCompile libs.kafkaStreams_10
    testRuntime libs.junitJupiter
  }

  systemTestLibs {
    dependsOn testJar
  }
}

project(':streams:upgrade-system-tests-11') {
  archivesBaseName = "kafka-streams-upgrade-system-tests-11"

  dependencies {
    testCompile libs.kafkaStreams_11
    testRuntime libs.junitJupiter
  }

  systemTestLibs {
    dependsOn testJar
  }
}

project(':streams:upgrade-system-tests-20') {
  archivesBaseName = "kafka-streams-upgrade-system-tests-20"

  dependencies {
    testCompile libs.kafkaStreams_20
    testRuntime libs.junitJupiter
  }

  systemTestLibs {
    dependsOn testJar
  }
}

project(':streams:upgrade-system-tests-21') {
  archivesBaseName = "kafka-streams-upgrade-system-tests-21"

  dependencies {
    testCompile libs.kafkaStreams_21
    testRuntime libs.junitJupiter
  }

  systemTestLibs {
    dependsOn testJar
  }
}

project(':streams:upgrade-system-tests-22') {
  archivesBaseName = "kafka-streams-upgrade-system-tests-22"

  dependencies {
    testCompile libs.kafkaStreams_22
    testRuntime libs.junitJupiter
  }

  systemTestLibs {
    dependsOn testJar
  }
}

project(':streams:upgrade-system-tests-23') {
  archivesBaseName = "kafka-streams-upgrade-system-tests-23"

  dependencies {
    testCompile libs.kafkaStreams_23
    testRuntime libs.junitJupiter
  }

  systemTestLibs {
    dependsOn testJar
  }
}

project(':streams:upgrade-system-tests-24') {
  archivesBaseName = "kafka-streams-upgrade-system-tests-24"

  dependencies {
    testCompile libs.kafkaStreams_24
    testRuntime libs.junitJupiter
  }

  systemTestLibs {
    dependsOn testJar
  }
}

project(':streams:upgrade-system-tests-25') {
  archivesBaseName = "kafka-streams-upgrade-system-tests-25"

  dependencies {
    testCompile libs.kafkaStreams_25
    testRuntime libs.junitJupiter
  }

  systemTestLibs {
    dependsOn testJar
  }
}

project(':streams:upgrade-system-tests-26') {
  archivesBaseName = "kafka-streams-upgrade-system-tests-26"

  dependencies {
    testCompile libs.kafkaStreams_26
    testRuntime libs.junitJupiter
  }

  systemTestLibs {
    dependsOn testJar
  }
}

project(':streams:upgrade-system-tests-27') {
  archivesBaseName = "kafka-streams-upgrade-system-tests-27"

  dependencies {
    testCompile libs.kafkaStreams_27
    testRuntime libs.junitJupiter
  }

  systemTestLibs {
    dependsOn testJar
  }
}

project(':jmh-benchmarks') {

  apply plugin: 'com.github.johnrengelman.shadow'

  shadowJar {
    baseName = 'kafka-jmh-benchmarks-all'
    classifier = null
    version = null
  }

  dependencies {
    compile(project(':core')) {
      // jmh requires jopt 4.x while `core` depends on 5.0, they are not binary compatible
      exclude group: 'net.sf.jopt-simple', module: 'jopt-simple'
    }
    compile project(':clients')
    compile project(':metadata')
    compile project(':streams')
    compile project(':core')
    compile project(':clients').sourceSets.test.output
    compile project(':core').sourceSets.test.output
    compile libs.jmhCore
    annotationProcessor libs.jmhGeneratorAnnProcess
    compile libs.jmhCoreBenchmarks
    compile libs.mockitoCore
    compile libs.slf4jlog4j
  }

  tasks.withType(JavaCompile) {
    // Suppress warning caused by code generated by jmh: `warning: [cast] redundant cast to long`
    options.compilerArgs << "-Xlint:-cast"
  }

  jar {
    manifest {
      attributes "Main-Class": "org.openjdk.jmh.Main"
    }
  }

  checkstyle {
    configProperties = checkstyleConfigProperties("import-control-jmh-benchmarks.xml")
  }

  task jmh(type: JavaExec, dependsOn: [':jmh-benchmarks:clean', ':jmh-benchmarks:shadowJar']) {

    main="-jar"

    doFirst {
      if (System.getProperty("jmhArgs")) {
          args System.getProperty("jmhArgs").split(' ')
      }
      args = [shadowJar.archivePath, *args]
    }
  }

  javadoc {
     enabled = false
  }
}

project(':log4j-appender') {
  archivesBaseName = "kafka-log4j-appender"

  dependencies {
    compile project(':clients')
    compile libs.slf4jlog4j

    testCompile project(':clients').sourceSets.test.output
    testCompile libs.junitJupiter
    testCompile libs.hamcrest
    testCompile libs.easymock
  }

  javadoc {
    enabled = false
  }

}

project(':connect:api') {
  archivesBaseName = "connect-api"

  dependencies {
    compile project(':clients')
    compile libs.slf4jApi
    compile libs.jaxrsApi

    testCompile libs.junitJupiter
    testRuntime libs.slf4jlog4j
    testCompile project(':clients').sourceSets.test.output
  }

  javadoc {
    include "**/org/apache/kafka/connect/**" // needed for the `aggregatedJavadoc` task
    // The URL structure was changed to include the locale after Java 8
    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/8/docs/api/"
  }

  tasks.create(name: "copyDependantLibs", type: Copy) {
    from (configurations.testRuntime) {
      include('slf4j-log4j12*')
      include('log4j*jar')
    }
    from (configurations.runtime) {
      exclude('kafka-clients*')
      exclude('connect-*')
    }
    into "$buildDir/dependant-libs"
    duplicatesStrategy 'exclude'
  }

  jar {
    dependsOn copyDependantLibs
  }
}

project(':connect:transforms') {
  archivesBaseName = "connect-transforms"

  dependencies {
    compile project(':connect:api')
    compile libs.slf4jApi

    testCompile libs.easymock
    testCompile libs.junitJupiter

    testRuntime libs.slf4jlog4j
    testCompile project(':clients').sourceSets.test.output
  }

  javadoc {
    enabled = false
  }

  tasks.create(name: "copyDependantLibs", type: Copy) {
    from (configurations.testRuntime) {
      include('slf4j-log4j12*')
      include('log4j*jar')
    }
    from (configurations.runtime) {
      exclude('kafka-clients*')
      exclude('connect-*')
    }
    into "$buildDir/dependant-libs"
    duplicatesStrategy 'exclude'
  }

  jar {
    dependsOn copyDependantLibs
  }
}

project(':connect:json') {
  archivesBaseName = "connect-json"

  dependencies {
    compile project(':connect:api')
    compile libs.jacksonDatabind
    compile libs.jacksonJDK8Datatypes
    compile libs.slf4jApi

    testCompile libs.easymock
    testCompile libs.junitJupiter

    testRuntime libs.slf4jlog4j
    testCompile project(':clients').sourceSets.test.output
  }

  javadoc {
    enabled = false
  }

  tasks.create(name: "copyDependantLibs", type: Copy) {
    from (configurations.testRuntime) {
      include('slf4j-log4j12*')
      include('log4j*jar')
    }
    from (configurations.runtime) {
      exclude('kafka-clients*')
      exclude('connect-*')
    }
    into "$buildDir/dependant-libs"
    duplicatesStrategy 'exclude'
  }

  jar {
    dependsOn copyDependantLibs
  }
}

project(':connect:runtime') {
  archivesBaseName = "connect-runtime"

  dependencies {

    compile project(':connect:api')
    compile project(':clients')
    compile project(':tools')
    compile project(':connect:json')
    compile project(':connect:transforms')

    compile libs.slf4jApi
    compile libs.jacksonJaxrsJsonProvider
    compile libs.jerseyContainerServlet
    compile libs.jerseyHk2
    compile libs.jaxbApi // Jersey dependency that was available in the JDK before Java 9
    compile libs.activation // Jersey dependency that was available in the JDK before Java 9
    compile libs.jettyServer
    compile libs.jettyServlet
    compile libs.jettyServlets
    compile libs.jettyClient
    compile(libs.reflections)
    compile(libs.mavenArtifact)

    testCompile project(':clients').sourceSets.test.output
    testCompile libs.easymock
    testCompile libs.junitJupiterApi
    testCompile libs.junitVintageEngine
    testCompile libs.powermockJunit4
    testCompile libs.powermockEasymock
    testCompile libs.mockitoCore
    testCompile libs.httpclient

    testCompile project(':clients').sourceSets.test.output
    testCompile project(':core')
    testCompile project(':core').sourceSets.test.output

    testRuntime libs.slf4jlog4j
  }

  javadoc {
    enabled = false
  }

  tasks.create(name: "copyDependantLibs", type: Copy) {
    from (configurations.testRuntime) {
      include('slf4j-log4j12*')
      include('log4j*jar')
    }
    from (configurations.runtime) {
      exclude('kafka-clients*')
      exclude('connect-*')
    }
    into "$buildDir/dependant-libs"
    duplicatesStrategy 'exclude'
  }

  jar {
    dependsOn copyDependantLibs
  }

  task genConnectConfigDocs(type: JavaExec) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'org.apache.kafka.connect.runtime.distributed.DistributedConfig'
    if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
    standardOutput = new File(generatedDocsDir, "connect_config.html").newOutputStream()
  }

  task genSinkConnectorConfigDocs(type: JavaExec) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'org.apache.kafka.connect.runtime.SinkConnectorConfig'
    if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
    standardOutput = new File(generatedDocsDir, "sink_connector_config.html").newOutputStream()
  }

  task genSourceConnectorConfigDocs(type: JavaExec) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'org.apache.kafka.connect.runtime.SourceConnectorConfig'
    if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
    standardOutput = new File(generatedDocsDir, "source_connector_config.html").newOutputStream()
  }

  task genConnectTransformationDocs(type: JavaExec) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'org.apache.kafka.connect.tools.TransformationDoc'
    if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
    standardOutput = new File(generatedDocsDir, "connect_transforms.html").newOutputStream()
  }

  task genConnectPredicateDocs(type: JavaExec) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'org.apache.kafka.connect.tools.PredicateDoc'
    if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
    standardOutput = new File(generatedDocsDir, "connect_predicates.html").newOutputStream()
  }

  task genConnectMetricsDocs(type: JavaExec) {
    classpath = sourceSets.test.runtimeClasspath
    main = 'org.apache.kafka.connect.runtime.ConnectMetrics'
    if( !generatedDocsDir.exists() ) { generatedDocsDir.mkdirs() }
    standardOutput = new File(generatedDocsDir, "connect_metrics.html").newOutputStream()
  }

}

project(':connect:file') {
  archivesBaseName = "connect-file"

  dependencies {
    compile project(':connect:api')
    compile libs.slf4jApi

    testCompile libs.easymock
    testCompile libs.junitJupiter

    testRuntime libs.slf4jlog4j
    testCompile project(':clients').sourceSets.test.output
  }

  javadoc {
    enabled = false
  }

  tasks.create(name: "copyDependantLibs", type: Copy) {
    from (configurations.testRuntime) {
      include('slf4j-log4j12*')
      include('log4j*jar')
    }
    from (configurations.runtime) {
      exclude('kafka-clients*')
      exclude('connect-*')
    }
    into "$buildDir/dependant-libs"
    duplicatesStrategy 'exclude'
  }

  jar {
    dependsOn copyDependantLibs
  }
}

project(':connect:basic-auth-extension') {
  archivesBaseName = "connect-basic-auth-extension"

  dependencies {
    compile project(':connect:api')
    compile libs.slf4jApi

    testCompile libs.bcpkix
    testCompile libs.easymock
    testCompile libs.junitJupiter
    testCompile project(':clients').sourceSets.test.output

    testRuntime libs.slf4jlog4j
    testRuntime libs.jerseyContainerServlet
  }

  javadoc {
    enabled = false
  }

  tasks.create(name: "copyDependantLibs", type: Copy) {
    from (configurations.testRuntime) {
      include('slf4j-log4j12*')
      include('log4j*jar')
    }
    from (configurations.runtime) {
      exclude('kafka-clients*')
      exclude('connect-*')
    }
    into "$buildDir/dependant-libs"
    duplicatesStrategy 'exclude'
  }

  jar {
    dependsOn copyDependantLibs
  }
}

project(':connect:mirror') {
  archivesBaseName = "connect-mirror"

  dependencies {
    compile project(':connect:api')
    compile project(':connect:runtime')
    compile project(':connect:mirror-client')
    compile project(':clients')
    compile libs.argparse4j
    compile libs.slf4jApi

    testCompile libs.junitJupiter
    testCompile libs.mockitoCore
    testCompile project(':clients').sourceSets.test.output
    testCompile project(':connect:runtime').sourceSets.test.output
    testCompile project(':core')
    testCompile project(':core').sourceSets.test.output

    testRuntime project(':connect:runtime')
    testRuntime libs.slf4jlog4j
    testRuntime libs.bcpkix
  }

  javadoc {
    enabled = false
  }

  tasks.create(name: "copyDependantLibs", type: Copy) {
    from (configurations.testRuntime) {
      include('slf4j-log4j12*')
      include('log4j*jar')
    }
    from (configurations.runtime) {
      exclude('kafka-clients*')
      exclude('connect-*')
    }
    into "$buildDir/dependant-libs"
    duplicatesStrategy 'exclude'
  }

  jar {
    dependsOn copyDependantLibs
  }
}

project(':connect:mirror-client') {
  archivesBaseName = "connect-mirror-client"

  dependencies {
    compile project(':clients')
    compile libs.slf4jApi

    testCompile libs.junitJupiter
    testCompile project(':clients').sourceSets.test.output

    testRuntime libs.slf4jlog4j
  }

  javadoc {
    enabled = true
  }

  tasks.create(name: "copyDependantLibs", type: Copy) {
    from (configurations.testRuntime) {
      include('slf4j-log4j12*')
      include('log4j*jar')
    }
    from (configurations.runtime) {
      exclude('kafka-clients*')
      exclude('connect-*')
    }
    into "$buildDir/dependant-libs"
    duplicatesStrategy 'exclude'
  }

  jar {
    dependsOn copyDependantLibs
  }
}

task aggregatedJavadoc(type: Javadoc) {
  def projectsWithJavadoc = subprojects.findAll { it.javadoc.enabled }
  source = projectsWithJavadoc.collect { it.sourceSets.main.allJava }
  classpath = files(projectsWithJavadoc.collect { it.sourceSets.main.compileClasspath })
  includes = projectsWithJavadoc.collectMany { it.javadoc.getIncludes() }
  excludes = projectsWithJavadoc.collectMany { it.javadoc.getExcludes() }
  // The URL structure was changed to include the locale after Java 8
  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/8/docs/api/"
}