build.gradle

description = 'Spring XD'

apply plugin: 'base'
apply plugin: 'idea'

buildscript {
	repositories {
		maven { url "http://repo.spring.io/plugins-snapshot" }
		jcenter()
	}
	dependencies {
		classpath("org.springframework.boot:spring-boot-gradle-plugin:1.1.4.RELEASE")
		classpath("org.springframework.build.gradle:propdeps-plugin:0.0.7")
		classpath 'com.moowork.gradle:gradle-grunt-plugin:0.4'
		classpath 'me.champeau.gradle:gradle-javadoc-hotfix-plugin:0.1'
		classpath 'nl.javadude.gradle.plugins:license-gradle-plugin:0.10.0'
	}
}

ext {
	linkHomepage = 'https://github.com/spring-projects/spring-xd'
	linkCi       = 'https://build.spring.io/browse/XD'
	linkIssue    = 'https://jira.spring.io/browse/XD'
	linkScmUrl           = 'https://github.com/spring-projects/spring-xd'
	linkScmConnection    = 'https://github.com/spring-projects/spring-xd.git'
	linkScmDevConnection = 'git@github.com:spring-projects/spring-xd.git'

	javadocLinks = [
		"http://docs.spring.io/spring-xd/docs/1.0.x/api/"
	] as String[]

	nonJavaProjects = [
		project(':redis'),
		project(':spring-xd-ui')
	]
	moduleProjects  = subprojects.findAll { project -> project.path.startsWith(':modules')}
	javaProjects    = subprojects - (moduleProjects + nonJavaProjects)
	coverageProjects = [
		'spring-xd-dirt',
		'spring-xd-analytics',
		'spring-xd-analytics-ml',
		'spring-xd-tuple',
		'spring-xd-module',
		'spring-xd-rest-client',
		'spring-xd-rest-domain',
		'spring-xd-shell',
		'spring-xd-hadoop',
		'spring-xd-extension-http',
		'spring-xd-extension-jdbc',
		'spring-xd-extension-reactor',
		'spring-xd-extension-gemfire'
	].collect { p -> project(p) }
}

// custom class to store the SingleNode server process
class SingleNodeServerProcess {
	Process process
}

allprojects {
	group = 'org.springframework.xd'

	repositories {
		mavenCentral()
		//maven { url 'http://repo.spring.io/libs-snapshot' }
		maven { url 'http://repo.spring.io/milestone' }
		//maven { url 'http://repo.spring.io/snapshot' }
		maven { url 'http://repo.spring.io/libs-milestone' }
		maven { url 'http://repo.spring.io/plugins-release' }
		maven { url 'http://repo.spring.io/plugins-snapshot' }
		maven { url 'https://repo.eclipse.org/content/repositories/paho-releases' }
	}

}

ext {
	// Not in IO
	activemqVersion = '5.6.0'
	apacheFtpServerVersion = '1.0.6'
	args4jVersion = '2.0.16'
	curatorVersion = '2.6.0'
	equalsverifierVersion = '1.1.3'
	ftpServerVersion = '1.0.6'
	greenmailVersion = '1.3.1b'
	hamcrestDateVersion = '0.9.3'
	httpClientVersion = '4.2.5'
	jcloudsVersion = '1.7.0'
	oracleToolsVersion = '1.2.2'
	platformVersion = '1.0.1.RELEASE'
	postgresqlVersion = '9.2-1002-jdbc4'
	splunkVersion = '1.3.0'
	springBatchAdminMgrVersion = '1.3.0.RELEASE'
	springIntegrationSplunkVersion = '1.1.0.RELEASE'
	springShellVersion = '1.1.0.RELEASE'
	zookeeperVersion = '3.4.6'

	// Also in IO
	nettyVersion = '3.7.0.Final' // N.B. Reactor depends on Netty 4
	oldGuavaVersion = '15.0'  // This is only used by spring-xd-integration-test, IO uses version 17.0
	guavaVersion = '16.0.1'

	springDataHadoopBase = '2.0.2.RELEASE'

	singleNodeServerProcess = new SingleNodeServerProcess()
}


apply from: 'gradle/build-common.gradle'


configure(javaProjects) { subproject ->

	apply plugin: 'groovy'
	apply from:   "${rootProject.projectDir}/publish-maven.gradle"
	apply plugin: 'eclipse'
	apply plugin: 'idea'
	apply plugin: 'javadocHotfix'
	apply plugin: 'spring-boot'
	apply plugin: 'propdeps'
	apply plugin: 'propdeps-maven'
	apply plugin: 'propdeps-idea'
	apply plugin: 'propdeps-eclipse'
	apply plugin: 'license'

	license {
		header rootProject.file('src/etc/header.txt')
		skipExistingHeaders true
		ext.year = Calendar.getInstance().get(Calendar.YEAR)
		mapping {
			java='SLASHSTAR_STYLE'
		}
		includes(['**/*.java'])
		excludes(['**/package-info.java'])
	}

	bootRepackage {
		enabled = false
	}

	compileJava {
		sourceCompatibility=1.6
		targetCompatibility=1.6
		options.fork = true
		options.forkOptions.with {
			memoryMaximumSize = "512m"
		}
	}

	compileTestJava {
		sourceCompatibility=1.7
		targetCompatibility=1.7
		options.fork = true
		options.forkOptions.with {
			memoryMaximumSize = "512m"
		}
	}

	eclipse {
		project { natures += 'org.springframework.ide.eclipse.core.springnature' }
	}

	// Include project specific settings
	task eclipseSettings(type: Copy) {
		from rootProject.files(
				"src/eclipse/org.eclipse.jdt.ui.prefs",
				"src/eclipse/de.loskutov.anyedit.AnyEditTools.prefs")
		into project.file('.settings/')
	}

	task eclipseJdtPrepare(type: Copy) {
		from rootProject.file("src/eclipse/org.eclipse.jdt.core.prefs")
		into project.file(".settings/")
	}

	task cleanEclipseJdtUi(type: Delete) {
		delete project.file(".settings/org.eclipse.jdt.ui.prefs")
		delete project.file(".settings/org.eclipse.jdt.core.prefs")
	}

	tasks["eclipseJdt"].dependsOn(eclipseJdtPrepare)
	tasks["cleanEclipse"].dependsOn(cleanEclipseJdtUi)
	tasks["eclipse"].dependsOn(eclipseSettings)

	sourceSets {
		test {
			groovy {
				srcDirs = ['src/test/java']
				resources {
					srcDirs = [
						'src/test/resources',
						'src/test/java'
					]
				}
			}
			resources {
				srcDirs = [
					'src/test/resources',
					'src/test/java'
				]
			}
		}
	}

	configurations.all { resolutionStrategy.cacheChangingModulesFor 60, 'minutes' }
	// dependencies that are common across all java projects
	dependencies {
		versionManagement "io.spring.platform:platform-versions:$platformVersion@properties"
		testCompile "org.springframework.boot:spring-boot-starter-test"
		testCompile "org.codehaus.groovy:groovy-all"
	}

	forceDependencyVersions(subproject)

	// enable all compiler warnings; individual projects may customize further
	[compileJava, compileTestJava]*.options*.compilerArgs = ["-Xlint:all"]

	test {
		// suppress all console output during testing unless running `gradle -i`
		logging.captureStandardOutput(LogLevel.INFO)
		minHeapSize = "128m"
		maxHeapSize = "512m"
		jvmArgs "-XX:MaxPermSize=512m"
		jvmArgs "-Djava.net.preferIPv4Stack=true"
		jvmArgs "-XX:+HeapDumpOnOutOfMemoryError"
		// 	useful for debugging the GradleWorkerMain
		//		jvmArgs "-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=8000"
		//		jvmArgs "-Dlog4j.debug=true"
		//		classpath = files('/some/dir/with/props') + project.sourceSets.test.runtimeClasspath
		maxParallelForks = project.hasProperty('maxParallelForks') ? project.maxParallelForks as int : 1
		forkEvery = 10
		ignoreFailures = project.hasProperty('ignoreTestFailures') ? getProperty('ignoreTestFailures') : false
		if (project.hasProperty('testLoggingStarted')) {
			testLogging {
				events 'started'
			}
		}
	}

	javadoc {
		description = "Generates project-level javadoc for use in -javadoc jar"

		options.memberLevel = org.gradle.external.javadoc.JavadocMemberLevel.PROTECTED
		options.author = true
		options.header = project.name
		options.links(javadocLinks)

		// suppress warnings due to cross-module @see and @link references;
		// note that global 'api' task does display all warnings.
		logging.captureStandardError LogLevel.INFO
		logging.captureStandardOutput LogLevel.INFO // suppress "## warnings" message
	}

	if (JavaVersion.current().isJava8Compatible()) {
		allprojects {
			tasks.withType(Javadoc) {
				options.addStringOption('Xdoclint:none', '-quiet')
			}
		}
	}

	task sourcesJar(type: Jar) {
		classifier = 'sources'
		from sourceSets.main.allJava
	}

	jar {
		manifest.attributes["Created-By"] =
				"${System.getProperty("java.version")} (${System.getProperty("java.specification.vendor")})"
		manifest.attributes["Implementation-Title"] = subproject.name
		manifest.attributes["Implementation-Version"] = subproject.version
		exclude 'log4j.properties'
	}

	task javadocJar(type: Jar) {
		classifier = 'javadoc'
		from javadoc
	}

	artifacts {
		archives sourcesJar
		archives javadocJar
	}
}

apply from: 'gradle/build-modules.gradle'

project('spring-xd-analytics') {
	description = 'Spring XD Anayltics'
	dependencies {
		compile project(":spring-xd-tuple")
		compile "org.springframework:spring-core"
		compile "org.springframework.data:spring-data-redis"
		compile "org.springframework.data:spring-data-commons"
		compile "redis.clients:jedis"
		compile "org.springframework.integration:spring-integration-core"
		compile "joda-time:joda-time"
		compile project(':spring-xd-module-spi')
		testCompile project(":spring-xd-test")
		testCompile "nl.jqno.equalsverifier:equalsverifier:$equalsverifierVersion"
		testCompile "com.fasterxml.jackson.core:jackson-databind"
		runtime "log4j:log4j",
				"org.slf4j:jcl-over-slf4j",
				"org.slf4j:slf4j-log4j12","org.apache.commons:commons-pool2"
	}
}

project('spring-xd-analytics-ml') {
	description = 'Spring XD Analytics ML'
	dependencies {
		compile "org.springframework:spring-core"
		testCompile project(":spring-xd-tuple")
	}
}

project('spring-xd-dirt') {
	description = 'Spring XD DIRT'
	dependencies {

		// See XD-903 for breakdown
		// ************* Common to both Server and Container
		compile "org.springframework:spring-aop"
		compile project(":spring-xd-analytics")
		compile "org.springframework.cloud:spring-cloud-spring-service-connector"
		compile "org.springframework.cloud:spring-cloud-cloudfoundry-connector"
		compile "org.springframework.boot:spring-boot-autoconfigure"
		compile "org.springframework.boot:spring-boot-actuator"
		compile "org.springframework.data:spring-data-redis"
		compile "org.springframework.integration:spring-integration-amqp"
		compile "org.springframework.integration:spring-integration-event"
        //TODO: Apparently only needed for script, transform, router modules
		runtime "org.springframework.integration:spring-integration-groovy"
		//compile "org.springframework.integration:spring-integration-http"
		// TODO: Investigate why spring-integration-http's optional dependency xerces becomes transitive dependency
		configurations.compile.exclude(group: "xerces")
		// Remove transitive dependency on commons-logging-api
		configurations.compile.exclude(group: 'commons-logging', module: 'commons-logging-api')
		compile "org.springframework.integration:spring-integration-jmx"
		compile "org.springframework.integration:spring-integration-redis"
		compile "org.jolokia:jolokia-core"
		compile "com.fasterxml.jackson.core:jackson-databind"
		compile "log4j:log4j"
		compile "com.esotericsoftware.kryo:kryo"
		compile "redis.clients:jedis"
		compile ("org.apache.zookeeper:zookeeper:$zookeeperVersion") {
			exclude group: 'jline'
		}
		compile ("org.apache.curator:curator-recipes:$curatorVersion") {
			exclude group: 'org.apache.zookeeper'
			exclude group: 'org.jboss.netty'
		}
		compile "commons-lang:commons-lang:2.4"
		compile "args4j:args4j:$args4jVersion"

		compile "org.springframework.batch:spring-batch-core"
        //Required for a classloading issue. See https://github.com/spring-projects/spring-xd/pull/1116
		runtime ("org.springframework.data:spring-data-mongodb") { exclude group: 'org.slf4j' }
		compile "org.apache.tomcat:tomcat-jdbc"
		compile ("org.springframework.batch:spring-batch-admin-manager:$springBatchAdminMgrVersion") {
			exclude group: 'org.freemarker'
			exclude group: 'hsqldb'
			exclude module: 'spring-batch-integration'
		}
		compile ("org.springframework.batch:spring-batch-integration") {
			exclude group: 'org.springframework.integration'
			exclude group: 'org.springframework'
		}
		compile "org.hibernate:hibernate-validator"

		runtime "org.slf4j:jul-to-slf4j"
		runtime "org.slf4j:jcl-over-slf4j"
		runtime "org.slf4j:slf4j-log4j12"
		runtime "org.yaml:snakeyaml"
		runtime "org.postgresql:postgresql:$postgresqlVersion"
		runtime "mysql:mysql-connector-java"

		compile project(':spring-xd-batch')

		// ************* Dirt-Server only
		compile project(':spring-xd-rest-domain')
		compile "org.springframework:spring-webmvc"
		runtime "org.springframework.data:spring-data-commons"
		compile "org.apache.tomcat.embed:tomcat-embed-core"

		// ************* Dirt-Container only (per se)
		compile project(":spring-xd-module")
		compile "com.jayway.jsonpath:json-path"

		// ************* Container: Modules (should move on their own: XD-915)
		compile project(":spring-xd-hadoop")

		// ************* Container: Imposed by some Module (can't move)
		compile "com.sun.mail:javax.mail"

		// The following is needed eg by twitter module b/c jackson classes
		// are loaded by RestTemplate and RestTemplate is in Dirt
		runtime "org.codehaus.jackson:jackson-mapper-asl"

		// ************* Test
		testCompile project(":spring-xd-test")
		testCompile "org.springframework.integration:spring-integration-test"
		testCompile "com.jayway.jsonpath:json-path"

		// The following two because of AmqBrokerAndTest
		testCompile ("org.apache.activemq:activemq-broker") {
			exclude group: 'org.mortbay.jetty'
			exclude group: 'org.fusesource.fuse-extra'
		}
		testCompile "org.springframework:spring-jms"
	}



	// skip the startScripts task to avoid default start script generation
	startScripts.setEnabled(false)
	mainClassName = "org.springframework.xd.dirt.server.SingleNodeApplication"

	task('execJar', type:Jar, dependsOn: 'jar') {
		baseName = 'spring-xd-dirt'
		version =  project.version
		classifier = 'exec'
		from sourceSets.main.output
	}

	springBoot {
		layout = 'ZIP'
	}

	bootRepackage  {
		withJarTask = tasks['execJar']
		classifier = 'exec'
		enabled = true
	}

	test {
		systemProperties["xd.home"] = "${rootProject.projectDir}"
		forkEvery = 40
	}

	task configFiles {
		def config = file("$rootDir/config")
		outputs.dir config
	}

	task xdUiFiles {
		def uiFiles = file("$rootDir/spring-xd-ui/dist")
		outputs.dir uiFiles
	}

	task scriptFiles {
		def scripts = file("$rootDir/scripts/xd")
		outputs.dir scripts
	}

	tasks["installApp"].dependsOn(":spring-xd-ui:setupUI")

	applicationDistribution.from(configFiles) { into "config" }

	applicationDistribution.from(scriptFiles) { into "bin" }

	applicationDistribution.from(moduleFiles) { into "modules" }

	applicationDistribution.from(xdUiFiles) { into "spring-xd-ui/dist" }

	// Following execution is used by jsTests task to start SingleNodeApplication as background process
	task backgroundAdminServer << { task ->
		println "Starting SingleNode server as a background process"
		ProcessBuilder processBuilder = new ProcessBuilder("java", "-cp", sourceSets.main.runtimeClasspath.getAsPath(), "org.springframework.xd.dirt.server.SingleNodeApplication");
		processBuilder.directory(file("$rootDir/spring-xd-dirt"))
		def Process proc = processBuilder.start()
		proc.consumeProcessOutputStream(System.out)
		println("Waiting for the server to startup...")
		// Give 15s for the server startup
		Thread.sleep(15000)
		// Save the process object to destroy after test completion
		project.singleNodeServerProcess.process = proc
	}

	task cleanDataDir(type: Delete) { delete "$rootDir/data" }

	tasks["backgroundAdminServer"].dependsOn("classes")
	tasks["clean"].dependsOn("cleanDataDir")

}

project('spring-xd-exec') {
	dependencies { compile project(':spring-xd-dirt') }
	apply plugin: "spring-boot"
	springBoot {
		mainClass = 'org.springframework.xd.dirt.server.SingleNodeApplication'
		layout = 'ZIP'
	}
	jar {
		exclude 'build'
		exclude 'target'
		// FIXME: unhack this
		exclude '**/gemfire-*.jar'
		exclude '**/aspectweaver-*.jar'
		into('.') { from '../spring-xd-dirt/src/main/resources/log4j.properties' }
		into('modules') { from '../modules' }
		into('config') { from '../config' }
		into('spring-xd-ui/dist') { from '../spring-xd-ui/dist' }
	}
	moduleProjects.each { moduleProject ->
		project.jar.dependsOn moduleProject.copyLibs
	}
}



project('spring-xd-hadoop') {
	description = 'Spring XD Hadoop'
	dependencies {
		compile "org.springframework:spring-aop"
		compile "org.springframework:spring-context"
		compile "org.springframework:spring-context-support"
		compile "org.springframework:spring-jdbc"
		compile "org.springframework:spring-tx"
		compile "org.springframework.integration:spring-integration-core"
		compile "org.springframework.batch:spring-batch-core"
		compile ("org.springframework.data:spring-data-hadoop:${springDataHadoopBase}") {
			exclude group: 'org.springframework.batch'
			exclude group: 'javax.servlet'
			exclude group: 'javax.servlet.jsp'
			exclude group: 'tomcat'
			exclude group: 'org.mortbay.jetty'
			exclude group: 'com.sun.jersey'
			exclude group: 'org.codehaus.jackson'
			exclude group: 'net.java.dev.jets3t'
			exclude group: 'com.jcraft'
			exclude group: 'junit'
			exclude group: 'hsqldb'
			exclude group: 'jline'
			exclude group: 'com.sun.jersey.jersey-test-framework'
		}
		// Exclude transitive dependency
		configurations.compile.exclude(group: "commons-beanutils", module: "commons-beanutils-core")

		compile ("org.springframework.data:spring-data-hadoop-store") { exclude group: 'org.apache.hadoop' }
		testRuntime "org.xerial.snappy:snappy-java"
	}
}

apply from: 'gradle/build-hadoop-distros.gradle'

project('spring-xd-yarn:spring-xd-yarn-client') {
	description = 'Spring XD YARN Client App'

	dependencies {
		compile "org.springframework:spring-aop"
		compile "org.springframework:spring-context"
		compile "org.springframework:spring-context-support"
		compile "org.springframework:spring-jdbc"
		compile "org.springframework:spring-tx"
		compile "org.springframework.batch:spring-batch-core"
		compile ("org.springframework.data:spring-yarn-boot") {
				exclude group: 'javax.servlet'
				exclude group: 'javax.servlet.jsp'
				exclude group: 'tomcat'
				exclude group: 'org.mortbay.jetty'
				exclude group: 'com.sun.jersey'
				exclude group: 'org.codehaus.jackson'
				exclude group: 'net.java.dev.jets3t'
				exclude group: 'com.jcraft'
				exclude group: 'junit'
				exclude group: 'hsqldb'
				exclude group: 'org.slf4j'
				exclude group: 'log4j'
		}
		compile "org.springframework.boot:spring-boot-autoconfigure"
		runtime "log4j:log4j",
				"org.slf4j:jcl-over-slf4j",
				"org.slf4j:slf4j-log4j12"
	}

	jar {
		setExcludes([])
	}

	bootRepackage  {
		enabled = true
	}

}

project('spring-xd-yarn:spring-xd-yarn-appmaster') {
	description = 'Spring XD YARN AppMaster'

	dependencies {
		compile "org.springframework:spring-aop"
		compile "org.springframework:spring-context"
		compile "org.springframework:spring-context-support"
		compile "org.springframework:spring-jdbc"
		compile "org.springframework:spring-tx"
		compile "org.springframework.batch:spring-batch-core"
		compile ("org.springframework.data:spring-yarn-boot") {
				exclude group: 'javax.servlet'
				exclude group: 'javax.servlet.jsp'
				exclude group: 'tomcat'
				exclude group: 'org.mortbay.jetty'
				exclude group: 'com.sun.jersey'
				exclude group: 'org.codehaus.jackson'
				exclude group: 'net.java.dev.jets3t'
				exclude group: 'com.jcraft'
				exclude group: 'junit'
				exclude group: 'hsqldb'
				exclude group: 'org.slf4j'
				exclude group: 'log4j'
				runtime "org.slf4j:jcl-over-slf4j",
								"org.slf4j:slf4j-log4j12"
		}
		compile "org.springframework.boot:spring-boot-autoconfigure"
	}

	jar {
		setExcludes([])
	}

	bootRepackage  {
		enabled = true
	}
}

// 'Binary' distributions projects

project ('spring-xd-gemfire-server') {
	description = 'Gemfire Server to support XD Development and Demos'
	dependencies {
		compile "commons-beanutils:commons-beanutils"
		compile "org.springframework.data:spring-data-gemfire"
		compile project(':spring-xd-tuple')
		runtime "log4j:log4j",
				"org.slf4j:jcl-over-slf4j",
				"org.slf4j:slf4j-log4j12"
	}
	apply plugin:'application'
	// skip the startScripts task to avoid default start script generation
	startScripts.setEnabled(false)

	task(launch, dependsOn: 'classes', type: JavaExec) {
		main = 'org.springframework.xd.gemfire.CacheServer'
		classpath = sourceSets.test.runtimeClasspath
		if (rootProject.hasProperty('config')) {
			args = [
				"${rootProject.getProperty('config')}"
			]
		}
	}

	mainClassName = 'org.springframework.xd.gemfire.CacheServer'

	task configFiles {
		def configs = file("$rootDir/spring-xd-gemfire-server/config")
		outputs.dir configs
	}

	applicationDistribution.from(configFiles) { into "config" }

	task scriptFiles {
		def scripts = file("$rootDir/scripts/gemfire")
		outputs.dir scripts
	}

	applicationDistribution.from(scriptFiles) { into "bin" }
}

project('redis') {
	description = 'Redis distribution'
	task syncScriptFiles(type: Sync) {
		from "$rootDir/scripts/redis"
		into project.file("${project.buildDir}/bin")
	}

	task sourceDist {
		def distFile = file("$rootDir/redis/dist")
		outputs.dir distFile
	}

	task syncDistFile(type: Sync) {
		from "$rootDir/redis/dist"
		into project.file("${project.buildDir}/dist")
	}

	task bundleRedis(dependsOn: [
		'syncScriptFiles',
		'syncDistFile'
	]) { description = "Bundle redis source dist with install script" }

	task clean(type: Delete) {
		description = "Wipes Redis build directory"
		delete 'build'
	}
}

// Subprojects of Spring XD proper

project('spring-xd-module') {
	description = 'Spring XD Module'
	dependencies {
		compile "org.springframework.integration:spring-integration-core"
		compile "org.springframework.boot:spring-boot-autoconfigure"
		compile project(':spring-xd-module-spi')
	}
}

project('spring-xd-module-spi') {
	description = 'Spring XD Module Options API'
	dependencies {
		compile "org.hibernate:hibernate-validator"
		compile "org.apache.tomcat.embed:tomcat-embed-el"
		compile "org.springframework:spring-web"
	}
}

project('spring-xd-tuple') {
	description = 'Spring XD Tuple'
	dependencies {
		compile "com.fasterxml.jackson.core:jackson-databind"
		compile "org.springframework:spring-context"
		compile "org.springframework.integration:spring-integration-core"
		compile "org.springframework.batch:spring-batch-infrastructure"
		compile "org.springframework:spring-jdbc"
	}
}

project('spring-xd-rest-client') {
	description = 'Spring XD REST Client'
	dependencies {
		compile "org.springframework:spring-web"
		compile project(':spring-xd-rest-domain')
		compile "com.fasterxml.jackson.core:jackson-databind"
		compile "org.codehaus.jackson:jackson-core-asl"
		compile "joda-time:joda-time"
	}
}

project('spring-xd-rest-domain') {
	description = 'Spring XD REST Domain'
	dependencies {
		compile "org.springframework:spring-webmvc"
		compile ("org.springframework.hateoas:spring-hateoas") { exclude module: "spring-asm" }
		compile "org.springframework.plugin:spring-plugin-core"
		compile ("org.springframework.batch:spring-batch-admin-manager:$springBatchAdminMgrVersion") {
			exclude module: 'spring-batch-integration'
			exclude group: 'org.springframework.integration'
			exclude group: 'org.slf4j'
			exclude group: 'org.freemarker'
		}
		compile "org.springframework.batch:spring-batch-core"
		compile "com.fasterxml.jackson.core:jackson-databind"
		compile "org.codehaus.jackson:jackson-core-asl"
	}
}

project('spring-xd-ui') {
	description = 'Spring XD UI'
	apply plugin: 'grunt'

	node {
		version = '0.10.25'
		download = true
	}

	task cleanDist(type: Delete) {
		description = "Remove the 'dist' directory"
		delete 'dist'
	}

	task cleanNodeModules(type: Delete) {
		description = "Remove the 'node_modules' directory"
		delete 'node_modules'
	}

	task cleanBowerFiles(type: Delete) {
		description = "Remove Bower directories"
		delete '.bower_cache'
		delete 'bower_components'
		delete 'app/lib'
	}

	//task afterEclipseImport(dependsOn: 'setupUI') {
	//	description = "Ensure that the UI Build runs after import into STS"
	//}

	tasks['grunt_build'].dependsOn(['npmInstall', 'installGrunt']);
	tasks['grunt_teste2e'].dependsOn(['grunt_build']);

	task ui_test(dependsOn: ['grunt_teste2e', ':spring-xd-dirt:backgroundAdminServer']) {

		description = "E2E-test the Admin UI using Grunt"

		doLast {
			def singleNodeServerProcess = project(':spring-xd-dirt').singleNodeServerProcess
			if (singleNodeServerProcess != null && singleNodeServerProcess.process != null) {
				singleNodeServerProcess.process.destroy()
				println("Stopped the SingleNode server.")
			}
		}
	}

	task setupUI(dependsOn: ['grunt_build']) { description = "Build the Admin UI using Grunt" }

	grunt_build.shouldRunAfter 'installGrunt'
	grunt_teste2e.shouldRunAfter 'installGrunt'
	installGrunt.shouldRunAfter 'npmInstall'

	task cleanUI(dependsOn: [
		'cleanDist',
		'cleanNodeModules',
		'cleanBowerFiles'
	]) { description = "Clean the Admin UI dist, node modules and bower files" }

}

project('spring-xd-test') {
	description = 'Spring XD Test'
	dependencies {
		compile "org.springframework.integration:spring-integration-test"
		compile "org.springframework.integration:spring-integration-amqp"
		compile "org.springframework.integration:spring-integration-redis"
		compile "org.springframework.integration:spring-integration-mqtt"
		compile ("org.springframework.data:spring-data-hadoop") {
			exclude group: 'javax.servlet'
			exclude group: 'javax.servlet.jsp'
			exclude group: 'tomcat'
			exclude group: 'org.mortbay.jetty'
			exclude group: 'com.sun.jersey'
			exclude group: 'org.codehaus.jackson'
			exclude group: 'net.java.dev.jets3t'
			exclude group: 'com.jcraft'
			exclude group: 'junit'
			exclude group: 'hsqldb'
			exclude group: 'org.springframework.batch'
			exclude group: 'jline'
		}
		compile "com.google.guava:guava:$guavaVersion"
		compile "org.springframework.data:spring-data-redis"
		compile "org.springframework:spring-context"
		compile "org.springframework:spring-context-support"
		compile "org.springframework:spring-tx"
		compile "org.springframework:spring-test"
		compile "redis.clients:jedis"
		compile "org.hsqldb:hsqldb"
		compile "org.apache.tomcat:tomcat-jdbc"
		compile "junit:junit"
		compile "commons-io:commons-io"
	}
}

project('spring-xd-shell') {
	description = 'Spring XD Shell'
	apply plugin: "application"
	mainClassName = "org.springframework.shell.Bootstrap"
	run { standardInput = System.in }

	test {
		include '**/*TestSuite*'
		forkEvery 20
	}

	dependencies {
		compile "org.springframework.shell:spring-shell:$springShellVersion"
		compile project(":spring-xd-rest-client")
		compile ("org.springframework.data:spring-data-hadoop") {
			exclude group: 'javax.servlet'
			exclude group: 'org.mortbay.jetty'
			exclude group: 'hsqldb'
		}
		compile "com.google.guava:guava:$guavaVersion"
		compile	"org.codehaus.jackson:jackson-mapper-asl"
		compile "commons-io:commons-io"
		configurations.compile.exclude(group: "xerces")

		runtime "org.slf4j:jcl-over-slf4j"
		runtime	"org.slf4j:slf4j-log4j12"
		runtime	"log4j:log4j"
		testCompile project(":spring-xd-test-fixtures")
		testCompile project(":spring-xd-dirt")
		testCompile "uk.co.modular-it:hamcrest-date:${hamcrestDateVersion}"
		testCompile "org.springframework.integration:spring-integration-ftp"
		testCompile "org.apache.ftpserver:ftpserver-core:$ftpServerVersion"
	}

	// skip the startScripts task to avoid default start script generation
	startScripts.setEnabled(false)

	task scriptFiles {
		def scripts = file("$rootDir/scripts/shell")
		outputs.dir scripts
	}
	applicationDistribution.from(scriptFiles) { into "bin" }

	task configFiles {
		def configs = file("$rootDir/spring-xd-shell/config")
		outputs.dir configs
	}

	applicationDistribution.from(configFiles) { into "config" }

}

project('spring-xd-batch') {
	description = 'Sub project for XD batch support '

	dependencies {
		runtime "org.yaml:snakeyaml"
		compile "org.hsqldb:hsqldb"
		compile "org.springframework.boot:spring-boot-autoconfigure"
		compile "org.springframework.boot:spring-boot-actuator"
		compile "org.springframework:spring-jdbc"
		compile "org.springframework.batch:spring-batch-core"
	}
	apply plugin:'application'
	// skip the startScripts task to avoid default start script generation
	startScripts.setEnabled(false)

	task scriptFiles {
		def scripts = file("$rootDir/scripts/hsqldb")
		outputs.dir scripts
	}
	applicationDistribution.from(scriptFiles) { into "bin" }
}

// Fixtures
project('spring-xd-test-fixtures') {
	description = 'Fixtures for use by both unit & acceptance tests '

	test {
	}
	dependencies {
		compile project(":spring-xd-test")
		compile "org.springframework.shell:spring-shell:$springShellVersion"
		compile "commons-collections:commons-collections"
		compile "com.icegreen:greenmail:$greenmailVersion"
		compile "com.fasterxml.jackson.core:jackson-databind"
		compile "org.springframework:spring-jms"
		compile "org.apache.activemq:activemq-client"
		compile "org.springframework:spring-web"
		compile ("org.springframework.data:spring-data-mongodb") { exclude group: 'org.slf4j' }

		runtime "log4j:log4j",
				"org.slf4j:jcl-over-slf4j",
				"org.slf4j:slf4j-log4j12"
	}
}


// Integration Tests
project('spring-xd-integration-test') {
	description = 'Spring Integration tests'

	test {
		onlyIf {
			System.getProperty('run_integration_tests', 'false')=='true'
		}
		exclude('org/springframework/xd/integration/test/FtpHdfsTest.class')
	}

	configurations.all {
		resolutionStrategy {
			eachDependency { DependencyResolveDetails details ->
				//Force version of Guava
				if (details.requested.group == 'com.google.guava') {
					details.useVersion "$oldGuavaVersion"
				}
			}
		}
	}

	dependencies {
		compile project(":spring-xd-test-fixtures")
		compile project(":spring-xd-test")
		compile project(":spring-xd-rest-client")
		compile "org.apache.jclouds.provider:aws-sts:$jcloudsVersion"
		compile "org.apache.jclouds.provider:aws-ec2:$jcloudsVersion"
		compile "org.apache.jclouds.driver:jclouds-sshj:$jcloudsVersion"
		compile "com.fasterxml.jackson.core:jackson-databind"
		compile ("org.apache.hadoop:hadoop-common:$hadoop22Version")
		compile ("org.apache.hadoop:hadoop-client:$hadoop22Version")
		compile "com.google.guava:guava:$oldGuavaVersion"
		compile ("org.springframework.data:spring-data-mongodb") { exclude group: 'org.slf4j' }
		testCompile "mysql:mysql-connector-java"
		testCompile "commons-collections:commons-collections"
		testCompile "org.springframework.shell:spring-shell:$springShellVersion"
		testCompile "org.springframework.boot:spring-boot-autoconfigure"
		testCompile "org.springframework:spring-web"
		testCompile "org.springframework:spring-jms"
		testCompile ("org.springframework.data:spring-data-hadoop") {
				exclude group: 'org.apache.hadoop'
		}
		runtime "log4j:log4j",
				"org.slf4j:jcl-over-slf4j",
				"org.slf4j:slf4j-log4j12"
		testCompile ("org.apache.ftpserver:ftpserver-core:${apacheFtpServerVersion}")
	}

}

// Distributed (multi container) tests
project('spring-xd-distributed-test') {
	description = 'Spring XD Distributed tests'

	test {
		onlyIf {
			Boolean.getBoolean('run_distributed_tests')
		}

		// all tests are included in the test suite
		include('org/springframework/xd/distributed/test/DistributedTestSuite.class')
	}

	dependencies {
		compile project(":spring-xd-test-fixtures")
		compile project(":spring-xd-test")
		compile project(":spring-xd-rest-client")
		compile project(":spring-xd-dirt")
		compile ("org.apache.curator:curator-test:$curatorVersion") {
			exclude group: 'org.apache.zookeeper'
			exclude group: 'org.jboss.netty'
		}
		compile "org.apache.httpcomponents:httpclient:$httpClientVersion"
		compile "com.oracle.tools:oracle-tools-runtime:$oracleToolsVersion"
		compile "com.oracle.tools:oracle-tools-core:$oracleToolsVersion"
		compile "com.oracle.tools:oracle-tools-testing-support:$oracleToolsVersion"
		testCompile "junit:junit"
		runtime "log4j:log4j",
				"org.slf4j:jcl-over-slf4j",
				"org.slf4j:slf4j-log4j12"
	}

}

apply plugin: 'sonar-runner'

sonarRunner {
	sonarProperties {
		property "sonar.jacoco.reportPath", "${buildDir.name}/jacoco/test.exec"
		property "sonar.links.homepage", linkHomepage
		property "sonar.links.ci", linkCi
		property "sonar.links.issue", linkIssue
		property "sonar.links.scm", linkScmUrl
		property "sonar.links.scm_dev", linkScmDevConnection
		property "sonar.java.coveragePlugin", "jacoco"
	}
}


task launch {
	group = 'Application'
	description = 'Launches the XD server for testing purposes'
	dependsOn 'spring-xd-dirt:run'
}


apply from: 'gradle/build-docs.gradle'
apply from: 'gradle/build-dist.gradle'

task wrapper(type: Wrapper) {
	description = "Generates build_xd[.bat] scripts"
	gradleVersion = "1.12"
	scriptFile= "gradle/build_xd"
}

apply plugin: 'jacoco'

jacoco {
	toolVersion = '0.7.0.201403182114'
}

configure (coverageProjects) {
	project -> apply plugin: 'jacoco'
	jacoco {
		toolVersion = '0.7.0.201403182114'
	}
}

task coverageReport(type: JacocoReport) {
	coverageProjects.collect { p -> executionData p.jacocoTestReport.executionData }
	coverageProjects.collect { p -> sourceSets (p.sourceSets.main) }
}

idea {
	project { languageLevel = '1.7' }
}

idea.project.ipr {
	withXml { provider ->
		provider.node.component.find { it.@name == 'VcsDirectoryMappings' }.mapping.@vcs = 'Git'
	}
}