spring-security/samples/cas/sample-xml/cassample.gradle

// 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:3.1.12"

    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.spockframework:spock-core:$spockVersion",
                   "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"
}

[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-casserver:casServer')
}

task casServer(dependsOn: ':spring-security-samples-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-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-casserver:casServer')
}