// CAS sample build file

apply plugin: 'war'
apply plugin: 'jetty'
apply plugin: 'groovy'

def excludeModules = ['spring-security-acl', 'jsr250-api', 'spring-jdbc', 'spring-tx']
def jettyVersion = '8.1.9.v20130131'
def keystore = "$rootDir/samples/certificates/server.jks"
def password = 'password'

configurations {
	casServer
	excludeModules.each {name ->
		runtime.exclude module: name
	}

	runtime.exclude group: 'org.aspectj'
}

sourceSets {
	test.resources.exclude 'GebConfig.groovy'
	integrationTest.groovy.srcDir file('src/integration-test/groovy')
}

eclipse.classpath.plusConfigurations += [configurations.integrationTestRuntime]

dependencies {
	providedCompile "javax.servlet:javax.servlet-api:$servletApiVersion"

	compile project(':spring-security-core'),
			project(':spring-security-cas'),
			"org.jasig.cas.client:cas-client-core:$casClientVersion"

	runtime project(':spring-security-web'),
			project(':spring-security-config'),
			"org.springframework:spring-context-support:$springVersion",
			"org.slf4j:jcl-over-slf4j:$slf4jVersion",
			"ch.qos.logback:logback-classic:$logbackVersion",
			"net.sf.ehcache:ehcache:$ehcacheVersion"

	integrationTestCompile project(':spring-security-cas'),
				   "org.seleniumhq.selenium:selenium-htmlunit-driver:$seleniumVersion",
				   "org.gebish:geb-spock:$gebVersion",
				   'commons-httpclient:commons-httpclient:3.1',
				   "org.eclipse.jetty:jetty-server:$jettyVersion",
				   "org.eclipse.jetty:jetty-servlet:$jettyVersion",
				   "org.codehaus.groovy:groovy:$groovyVersion",
				   "org.slf4j:jcl-over-slf4j:$slf4jVersion",
				   spockDependencies
}

[jettyRun, jettyRunWar]*.configure {
	contextPath = "/cas-sample"
	def httpConnector = jettyRunWar.class.classLoader.loadClass('org.mortbay.jetty.nio.SelectChannelConnector').newInstance()
	httpConnector.port = 8080
	httpConnector.confidentialPort = 8443
	def httpsConnector = jettyRunWar.class.classLoader.loadClass('org.mortbay.jetty.security.SslSocketConnector').newInstance()
	httpsConnector.port = 8443
	httpsConnector.keystore = httpsConnector.truststore = keystore
	httpsConnector.keyPassword = httpsConnector.trustPassword = password

	connectors = [httpConnector, httpsConnector]
	doFirst() {
		System.setProperty('cas.server.host', casServer().httpsHost)
		System.setProperty('cas.service.host', jettyRunWar.httpsHost)
	}
}

task cas (dependsOn: [jettyRunWar]) {
	jettyRunWar.dependsOn(':spring-security-samples-xml-casserver:casServer')
}

task casServer(dependsOn: ':spring-security-samples-xml-casserver:casServer') {
}

integrationTest.dependsOn cas
integrationTest.doFirst {
	def casServiceHost = jettyRunWar.httpsHost
	systemProperties['cas.server.host'] = casServer().httpsHost
	systemProperties['cas.service.host'] = casServiceHost
	systemProperties['geb.build.baseUrl'] = 'https://'+casServiceHost+'/cas-sample/'
	systemProperties['geb.build.reportsDir'] = 'build/geb-reports'
	systemProperties['jar.path'] = jar.archivePath
	systemProperties['javax.net.ssl.trustStore'] = keystore
	systemProperties['javax.net.ssl.trustStorePassword'] = password
}

gradle.taskGraph.whenReady {graph ->
	def casServer = casServer()
	[casServer,jettyRunWar]*.metaClass*.getHttpsConnector {->
		def sslSocketConnClass = jettyRunWar.class.classLoader.loadClass('org.mortbay.jetty.security.SslSocketConnector')
		delegate.connectors.find { it in sslSocketConnClass }
	}
	[casServer,jettyRunWar]*.metaClass*.getHttpsHost {->
		"localhost:"+delegate.httpsConnector.port
	}
	jettyRunWar.metaClass.getHttpConnector {->
		def channelConnClass = jettyRunWar.class.classLoader.loadClass('org.mortbay.jetty.nio.SelectChannelConnector')
		delegate.connectors.find { it in channelConnClass }
	}
	if (graph.hasTask(cas)) {
		casServer.daemon = true
	}
	if(graph.hasTask(integrationTest)) {
		tasks.getByPath(':spring-security-samples-xml-casserver:casServerOverlay').logLevel = 'ERROR'
		jettyRunWar {
			additionalRuntimeJars += file("src/integration-test/resources")
			daemon = true
		}

		[jettyRunWar.httpConnector,jettyRunWar.httpsConnector,casServer.httpsConnector]*.metaClass*.reservePort { taskToCloseSocket ->
			def serverSocket = new ServerSocket(0)
			delegate.metaClass.serverSocket = serverSocket
			delegate.port = serverSocket.localPort
			taskToCloseSocket.doFirst {
				serverSocket.close()
			}
		}

		[jettyRunWar.httpConnector,jettyRunWar.httpsConnector]*.reservePort(jettyRunWar)
		jettyRunWar.httpConnector.confidentialPort = jettyRunWar.httpsConnector.port
		casServer.httpsConnector.reservePort(casServer)
	}
}

def casServer() {
	tasks.getByPath(':spring-security-samples-xml-casserver:casServer')
}