You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
957 lines
28 KiB
957 lines
28 KiB
// 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 |
|
|
|
buildscript { |
|
repositories { |
|
mavenCentral() |
|
jcenter() |
|
} |
|
apply from: file('gradle/buildscript.gradle'), to: buildscript |
|
|
|
dependencies { |
|
// For Apache Rat plugin to ignore non-Git files |
|
classpath "org.ajoberstar:grgit:1.5.0" |
|
classpath 'com.github.ben-manes:gradle-versions-plugin:0.12.0' |
|
classpath 'org.scoverage:gradle-scoverage:2.1.0' |
|
} |
|
} |
|
|
|
allprojects { |
|
apply plugin: 'idea' |
|
apply plugin: 'eclipse' |
|
apply plugin: "jacoco" |
|
|
|
repositories { |
|
mavenCentral() |
|
} |
|
|
|
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') |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
if (JavaVersion.current().isJava8Compatible()) { |
|
tasks.withType(Javadoc) { |
|
// disable the crazy super-strict doclint tool in Java 8 |
|
// noinspection SpellCheckingInspection |
|
options.addStringOption('Xdoclint:none', '-quiet') |
|
} |
|
} |
|
|
|
} |
|
|
|
ext { |
|
gradleVersion = "3.0" |
|
buildVersionFileName = "kafka-version.properties" |
|
|
|
userMaxForks = project.hasProperty('maxParallelForks') ? maxParallelForks.toInteger() : null |
|
|
|
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 |
|
|
|
generatedDocsDir = new File("${project.rootDir}/docs/generated") |
|
} |
|
|
|
apply from: "$rootDir/gradle/dependencies.gradle" |
|
apply from: file('wrapper.gradle') |
|
|
|
if (new 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(project.file('.')) |
|
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', |
|
'gradlew', |
|
'gradlew.bat', |
|
'**/README.md' |
|
]) |
|
} |
|
} |
|
|
|
subprojects { |
|
apply plugin: 'java' |
|
apply plugin: 'maven' |
|
apply plugin: 'signing' |
|
apply plugin: 'checkstyle' |
|
|
|
sourceCompatibility = 1.7 |
|
|
|
compileJava { |
|
options.encoding = 'UTF-8' |
|
// Add unchecked once we drop support for Java 7 as @SuppressWarnings("unchecked") is too buggy in Java 7 |
|
options.compilerArgs << "-Xlint:deprecation" |
|
} |
|
|
|
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 'http://kafka.apache.org' |
|
licenses { |
|
license { |
|
name 'The Apache Software License, Version 2.0' |
|
url 'http://www.apache.org/licenses/LICENSE-2.0.txt' |
|
distribution 'repo' |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
test { |
|
maxParallelForks = userMaxForks ?: Runtime.runtime.availableProcessors() |
|
testLogging { |
|
events = userTestLoggingEvents ?: ["passed", "skipped", "failed"] |
|
showStandardStreams = userShowStandardStreams ?: false |
|
exceptionFormat = 'full' |
|
} |
|
} |
|
|
|
jar { |
|
from '../LICENSE' |
|
from '../NOTICE' |
|
} |
|
|
|
task srcJar(type: Jar) { |
|
classifier = 'sources' |
|
from '../LICENSE' |
|
from '../NOTICE' |
|
from sourceSets.main.allSource |
|
} |
|
|
|
task javadocJar(type: Jar, dependsOn: javadoc) { |
|
classifier 'javadoc' |
|
from '../LICENSE' |
|
from '../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 '../LICENSE' |
|
from '../NOTICE' |
|
from sourceSets.test.output |
|
} |
|
|
|
task testSrcJar(type: Jar, dependsOn: testJar) { |
|
classifier = 'test-sources' |
|
from '../LICENSE' |
|
from '../NOTICE' |
|
from sourceSets.test.allSource |
|
} |
|
|
|
artifacts { |
|
archives testJar |
|
archives testSrcJar |
|
} |
|
} |
|
|
|
plugins.withType(ScalaPlugin) { |
|
task scaladocJar(type:Jar) { |
|
classifier = 'scaladoc' |
|
from '../LICENSE' |
|
from '../NOTICE' |
|
from scaladoc.destinationDir |
|
} |
|
|
|
//documentation task should also trigger building scala doc jar |
|
docsJar.dependsOn scaladocJar |
|
|
|
artifacts { |
|
archives scaladocJar |
|
} |
|
} |
|
|
|
tasks.withType(ScalaCompile) { |
|
scalaCompileOptions.additionalParameters = [ |
|
"-deprecation", |
|
"-unchecked", |
|
"-encoding", "utf8", |
|
"-target:jvm-${sourceCompatibility}".toString(), |
|
"-Xlog-reflective-calls", |
|
"-feature", |
|
"-language:postfixOps", |
|
"-language:implicitConversions", |
|
"-language:existentials" |
|
] |
|
|
|
configure(scalaCompileOptions.forkOptions) { |
|
memoryMaximumSize = '1g' |
|
jvmArgs = ['-XX:MaxPermSize=512m', '-Xss2m'] |
|
} |
|
} |
|
|
|
checkstyle { |
|
configFile = new File(rootDir, "checkstyle/checkstyle.xml") |
|
configProperties = [importControlFile: "$rootDir/checkstyle/import-control.xml"] |
|
} |
|
test.dependsOn('checkstyleMain', 'checkstyleTest') |
|
|
|
// Ignore core since its a scala project |
|
if (it.path != ':core') { |
|
// NOTE: Gradles Jacoco 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 |
|
} |
|
} |
|
} |
|
} |
|
|
|
// Aggregates all jacoco results into the root project directory |
|
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 = files(javaProjects.sourceSets.main.allSource.srcDirs) |
|
sourceDirectories = files(javaProjects.sourceSets.main.allSource.srcDirs) |
|
classDirectories = files(javaProjects.sourceSets.main.output) |
|
executionData = files(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() }) |
|
} |
|
} |
|
|
|
task reportCoverage(dependsOn: ['jacocoRootReport', 'core:reportScoverage']) |
|
|
|
for ( sv in ['2_10', '2_11'] ) { |
|
String svInDot = sv.replaceAll( "_", ".") |
|
|
|
tasks.create(name: "jar_core_${sv}", type: GradleBuild) { |
|
startParameter = project.getGradle().getStartParameter().newInstance() |
|
startParameter.projectProperties += [scalaVersion: "${svInDot}"] |
|
tasks = ['core:jar'] |
|
} |
|
|
|
tasks.create(name: "test_core_${sv}", type: GradleBuild) { |
|
startParameter = project.getGradle().getStartParameter().newInstance() |
|
startParameter.projectProperties += [scalaVersion: "${svInDot}"] |
|
tasks = ['core:test'] |
|
} |
|
|
|
tasks.create(name: "srcJar_${sv}", type: GradleBuild) { |
|
startParameter = project.getGradle().getStartParameter().newInstance() |
|
startParameter.projectProperties += [scalaVersion: "${svInDot}"] |
|
tasks = ['core:srcJar'] |
|
} |
|
|
|
tasks.create(name: "docsJar_${sv}", type: GradleBuild) { |
|
startParameter = project.getGradle().getStartParameter().newInstance() |
|
startParameter.projectProperties += [scalaVersion: "${svInDot}"] |
|
tasks = ['core:docsJar'] |
|
} |
|
|
|
tasks.create(name: "install_${sv}", type: GradleBuild) { |
|
startParameter = project.getGradle().getStartParameter().newInstance() |
|
startParameter.projectProperties += [scalaVersion: "${svInDot}"] |
|
tasks = ['install'] |
|
} |
|
|
|
tasks.create(name: "releaseTarGz_${sv}", type: GradleBuild) { |
|
startParameter = project.getGradle().getStartParameter().newInstance() |
|
startParameter.projectProperties += [scalaVersion: "${svInDot}"] |
|
tasks = ['releaseTarGz'] |
|
} |
|
|
|
tasks.create(name: "uploadCoreArchives_${sv}", type: GradleBuild) { |
|
startParameter = project.getGradle().getStartParameter().newInstance() |
|
startParameter.projectProperties += [scalaVersion: "${svInDot}"] |
|
tasks = ['core:uploadArchives'] |
|
} |
|
} |
|
|
|
def connectPkgs = ['connect:api', 'connect:runtime', 'connect:json', 'connect:file'] |
|
def pkgs = ['clients', 'examples', 'log4j-appender', 'tools', 'streams', 'streams:examples'] + connectPkgs |
|
|
|
tasks.create(name: "jarConnect", dependsOn: connectPkgs.collect { it + ":jar" }) {} |
|
tasks.create(name: "jarAll", dependsOn: ['jar_core_2_10', 'jar_core_2_11'] + pkgs.collect { it + ":jar" }) { } |
|
|
|
tasks.create(name: "srcJarAll", dependsOn: ['srcJar_2_10', 'srcJar_2_11'] + pkgs.collect { it + ":srcJar" }) { } |
|
|
|
tasks.create(name: "docsJarAll", dependsOn: ['docsJar_2_10', 'docsJar_2_11'] + pkgs.collect { it + ":docsJar" }) { } |
|
|
|
tasks.create(name: "testConnect", dependsOn: connectPkgs.collect { it + ":test" }) {} |
|
tasks.create(name: "testAll", dependsOn: ['test_core_2_10', 'test_core_2_11'] + pkgs.collect { it + ":test" }) { } |
|
|
|
tasks.create(name: "installAll", dependsOn: ['install_2_10', 'install_2_11'] + pkgs.collect { it + ":install" }) { } |
|
|
|
tasks.create(name: "releaseTarGzAll", dependsOn: ['releaseTarGz_2_10', 'releaseTarGz_2_11']) { } |
|
|
|
tasks.create(name: "uploadArchivesAll", dependsOn: ['uploadCoreArchives_2_10', 'uploadCoreArchives_2_11'] + pkgs.collect { it + ":uploadArchives" }) { } |
|
|
|
project(':core') { |
|
println "Building project 'core' with Scala version ${versions.scala}" |
|
|
|
apply plugin: 'scala' |
|
apply plugin: "org.scoverage" |
|
archivesBaseName = "kafka_${versions.baseScala}" |
|
|
|
dependencies { |
|
compile project(':clients') |
|
compile libs.joptSimple |
|
compile libs.metrics |
|
compile libs.scala |
|
compile libs.slf4jlog4j |
|
compile libs.zkclient |
|
compile libs.zookeeper |
|
// These modules were broken out of core scala in 2.10. We can remove special handling when 2.10 support is dropped. |
|
if (versions.baseScala != '2.10') { |
|
compile libs.scalaParserCombinators |
|
} |
|
|
|
testCompile project(':clients').sourceSets.test.output |
|
testCompile libs.bcpkix |
|
testCompile libs.easymock |
|
testCompile(libs.apacheda) { |
|
exclude group: 'xml-apis', module: 'xml-apis' |
|
} |
|
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.junit |
|
testCompile libs.scalaTest |
|
|
|
scoverage libs.scoveragePlugin |
|
scoverage libs.scoverageRuntime |
|
} |
|
|
|
jacocoTestReport.enabled = false |
|
scoverage { |
|
reportDir = file("${rootProject.buildDir}/scoverage") |
|
highlighting = false |
|
} |
|
checkScoverage { |
|
minimumRate = 0.0 |
|
} |
|
checkScoverage.shouldRunAfter('test') |
|
|
|
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' |
|
compile.exclude module: 'netty' |
|
// 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*') |
|
} |
|
from (configurations.runtime) { |
|
exclude('kafka-clients*') |
|
} |
|
into "$buildDir/dependant-libs-${versions.scala}" |
|
duplicatesStrategy 'exclude' |
|
} |
|
|
|
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 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 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 siteDocsTar(dependsOn: ['genProtocolErrorDocs', 'genProtocolApiKeyDocs', 'genProtocolMessageDocs', |
|
'genProducerConfigDocs', 'genConsumerConfigDocs', 'genKafkaConfigDocs', |
|
'genTopicConfigDocs', ':connect:runtime:genConnectConfigDocs', |
|
':streams:genStreamsConfigDocs'], type: Tar) { |
|
classifier = 'site-docs' |
|
compression = Compression.GZIP |
|
from project.file("../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("../bin")) { into "bin/" } |
|
from(project.file("../config")) { into "config/" } |
|
from '../LICENSE' |
|
from '../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: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(':streams').jar) { into("libs/") } |
|
from(project(':streams').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" |
|
duplicatesStrategy 'exclude' |
|
} |
|
|
|
systemTestLibs.dependsOn('jar', 'testJar', 'copyDependantTestLibs') |
|
|
|
checkstyle { |
|
configProperties = [importControlFile: "$rootDir/checkstyle/import-control-core.xml"] |
|
} |
|
} |
|
|
|
project(':examples') { |
|
archivesBaseName = "kafka-examples" |
|
|
|
dependencies { |
|
compile project(':core') |
|
} |
|
|
|
javadoc { |
|
enabled = false |
|
} |
|
|
|
checkstyle { |
|
configProperties = [importControlFile: "$rootDir/checkstyle/import-control-core.xml"] |
|
} |
|
} |
|
|
|
project(':clients') { |
|
archivesBaseName = "kafka-clients" |
|
|
|
dependencies { |
|
compile libs.lz4 |
|
compile libs.snappy |
|
compile libs.slf4jApi |
|
|
|
testCompile libs.bcpkix |
|
testCompile libs.junit |
|
testCompile libs.easymock |
|
testCompile libs.powermock |
|
testCompile libs.powermockEasymock |
|
|
|
testRuntime libs.slf4jlog4j |
|
} |
|
|
|
task determineCommitId { |
|
ext.commitId = "unknown" |
|
def takeFromHash = 16 |
|
if (file("../.git/HEAD").exists()) { |
|
def headRef = file("../.git/HEAD").text |
|
if (headRef.contains('ref: ')) { |
|
headRef = headRef.replaceAll('ref: ', '').trim() |
|
if (file("../.git/$headRef").exists()) { |
|
commitId = file("../.git/$headRef").text.trim().take(takeFromHash) |
|
} |
|
} else { |
|
commitId = headRef.trim().take(takeFromHash) |
|
} |
|
} |
|
commitId |
|
} |
|
|
|
task createVersionFile(dependsOn: determineCommitId) { |
|
ext.receiptFile = file("$buildDir/kafka/$buildVersionFileName") |
|
outputs.file receiptFile |
|
outputs.upToDateWhen { false } |
|
doLast { |
|
def data = [ |
|
commitId: determineCommitId.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/" |
|
} |
|
|
|
javadoc { |
|
include "**/org/apache/kafka/clients/consumer/*" |
|
include "**/org/apache/kafka/clients/producer/*" |
|
include "**/org/apache/kafka/common/*" |
|
include "**/org/apache/kafka/common/errors/*" |
|
include "**/org/apache/kafka/common/serialization/*" |
|
include "**/org/apache/kafka/common/config/*" |
|
} |
|
} |
|
|
|
project(':tools') { |
|
archivesBaseName = "kafka-tools" |
|
|
|
dependencies { |
|
compile project(':clients') |
|
compile project(':log4j-appender') |
|
compile libs.argparse4j |
|
compile libs.jacksonDatabind |
|
compile libs.slf4jlog4j |
|
|
|
testCompile project(':clients') |
|
testCompile libs.junit |
|
} |
|
|
|
javadoc { |
|
enabled = false |
|
} |
|
|
|
tasks.create(name: "copyDependantLibs", type: Copy) { |
|
from (configurations.testRuntime) { |
|
include('slf4j-log4j12*') |
|
} |
|
from (configurations.runtime) { |
|
exclude('kafka-clients*') |
|
} |
|
into "$buildDir/dependant-libs-${versions.scala}" |
|
duplicatesStrategy 'exclude' |
|
} |
|
|
|
jar { |
|
dependsOn 'copyDependantLibs' |
|
} |
|
} |
|
|
|
project(':streams') { |
|
archivesBaseName = "kafka-streams" |
|
|
|
dependencies { |
|
compile project(':clients') |
|
compile project(':connect:json') // this dependency should be removed after we unify data API |
|
compile libs.slf4jApi |
|
compile libs.rocksDBJni |
|
// this dependency should be removed after KIP-4 |
|
compile (libs.zkclient) { |
|
// users should be able to choose the logging implementation (and slf4j bridge) |
|
exclude module: 'slf4j-log4j12' |
|
exclude module: 'log4j' |
|
exclude module: 'jline' |
|
exclude module: 'netty' |
|
} |
|
|
|
// zkclient has a hard log4j dependency, we set it here as well to avoid copying an older |
|
// version to the binary package; the following two dependencies should be removed after KIP-4 |
|
// (along with the zkclient dependency) |
|
compile libs.log4j |
|
compile libs.jacksonDatabind |
|
|
|
testCompile project(':clients').sourceSets.test.output |
|
testCompile project(':core') |
|
testCompile project(':core').sourceSets.test.output |
|
testCompile libs.junit |
|
|
|
testRuntime libs.slf4jlog4j |
|
} |
|
|
|
javadoc { |
|
include "**/org/apache/kafka/streams/**" |
|
exclude "**/internals/**" |
|
} |
|
|
|
tasks.create(name: "copyDependantLibs", type: Copy) { |
|
from (configurations.testRuntime) { |
|
include('slf4j-log4j12*') |
|
} |
|
from (configurations.runtime) { |
|
exclude('kafka-clients*') |
|
} |
|
into "$buildDir/dependant-libs-${versions.scala}" |
|
duplicatesStrategy 'exclude' |
|
} |
|
|
|
jar { |
|
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() |
|
} |
|
} |
|
|
|
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 // this dependency should be removed after KIP-4 |
|
} |
|
|
|
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(':log4j-appender') { |
|
archivesBaseName = "kafka-log4j-appender" |
|
|
|
dependencies { |
|
compile project(':clients') |
|
compile libs.slf4jlog4j |
|
|
|
testCompile project(':clients').sourceSets.test.output |
|
testCompile libs.junit |
|
} |
|
|
|
javadoc { |
|
enabled = false |
|
} |
|
|
|
} |
|
|
|
project(':connect:api') { |
|
archivesBaseName = "connect-api" |
|
|
|
dependencies { |
|
compile project(':clients') |
|
compile libs.slf4jApi |
|
|
|
testCompile libs.junit |
|
|
|
testRuntime libs.slf4jlog4j |
|
} |
|
|
|
javadoc { |
|
include "**/org/apache/kafka/connect/**" // needed for the `javadocAll` task |
|
options.links "http://docs.oracle.com/javase/7/docs/api/" |
|
} |
|
|
|
tasks.create(name: "copyDependantLibs", type: Copy) { |
|
from (configurations.testRuntime) { |
|
include('slf4j-log4j12*') |
|
} |
|
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.slf4jApi |
|
|
|
testCompile libs.easymock |
|
testCompile libs.junit |
|
testCompile libs.powermock |
|
testCompile libs.powermockEasymock |
|
|
|
testRuntime libs.slf4jlog4j |
|
} |
|
|
|
javadoc { |
|
enabled = false |
|
} |
|
|
|
tasks.create(name: "copyDependantLibs", type: Copy) { |
|
from (configurations.testRuntime) { |
|
include('slf4j-log4j12*') |
|
} |
|
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 libs.slf4jApi |
|
|
|
compile libs.jacksonJaxrsJsonProvider |
|
compile libs.jerseyContainerServlet |
|
compile libs.jettyServer |
|
compile libs.jettyServlet |
|
compile libs.jettyServlets |
|
compile(libs.reflections) { |
|
// Exclude because of LGPL license |
|
exclude group: 'com.google.code.findbugs', module: 'annotations' |
|
} |
|
|
|
testCompile project(':clients').sourceSets.test.output |
|
testCompile libs.easymock |
|
testCompile libs.junit |
|
testCompile libs.powermock |
|
testCompile libs.powermockEasymock |
|
testCompile project(":connect:json") |
|
|
|
testRuntime libs.slf4jlog4j |
|
} |
|
|
|
javadoc { |
|
enabled = false |
|
} |
|
|
|
tasks.create(name: "copyDependantLibs", type: Copy) { |
|
from (configurations.testRuntime) { |
|
include('slf4j-log4j12*') |
|
} |
|
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() |
|
} |
|
} |
|
|
|
project(':connect:file') { |
|
archivesBaseName = "connect-file" |
|
|
|
dependencies { |
|
compile project(':connect:api') |
|
compile libs.slf4jApi |
|
|
|
testCompile libs.easymock |
|
testCompile libs.junit |
|
testCompile libs.powermock |
|
testCompile libs.powermockEasymock |
|
|
|
testRuntime libs.slf4jlog4j |
|
} |
|
|
|
javadoc { |
|
enabled = false |
|
} |
|
|
|
tasks.create(name: "copyDependantLibs", type: Copy) { |
|
from (configurations.testRuntime) { |
|
include('slf4j-log4j12*') |
|
} |
|
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() } |
|
options.links "http://docs.oracle.com/javase/7/docs/api/" |
|
}
|
|
|